go-selfupdate binary uses os env to detect arch/platform so you can crosscompile

main.go

@@ -1,132 +1,132 @@
 package main
 
 import (
-    "fmt"
+	"bytes"
-    "os"
+	"compress/gzip"
-    "encoding/json"
+	"crypto/sha256"
-    "io/ioutil"
+	"encoding/json"
-    "io"
+	"fmt"
-    "path/filepath"
+	"github.com/kr/binarydist"
-    "compress/gzip"
+	"io"
-    "bytes"
+	"io/ioutil"
-    "crypto/sha256"
+	"os"
-    "github.com/kr/binarydist"
+	"path/filepath"
-    "runtime"
+	//"runtime"
-    //"encoding/base64"
+	//"encoding/base64"
 )
 
-const (
+var plat string
-    plat = runtime.GOOS + "-" + runtime.GOARCH
-)
 
 type current struct {
-    Version string
+	Version string
-    Sha256 []byte
+	Sha256  []byte
 }
 
 func generateSha256(path string) []byte {
-    h := sha256.New()
+	h := sha256.New()
-    b, err := ioutil.ReadFile(path)
+	b, err := ioutil.ReadFile(path)
-    if err != nil {
+	if err != nil {
-        fmt.Println(err)
+		fmt.Println(err)
-    }
+	}
-    h.Write(b)
+	h.Write(b)
-    sum := h.Sum(nil)
+	sum := h.Sum(nil)
-    return sum
+	return sum
-    //return base64.URLEncoding.EncodeToString(sum)
+	//return base64.URLEncoding.EncodeToString(sum)
 }
 
 type gzReader struct {
-        z, r io.ReadCloser
+	z, r io.ReadCloser
 }
 
 func (g *gzReader) Read(p []byte) (int, error) {
-        return g.z.Read(p)
+	return g.z.Read(p)
 }
 
 func (g *gzReader) Close() error {
-        g.z.Close()
+	g.z.Close()
-        return g.r.Close()
+	return g.r.Close()
 }
 
 func newGzReader(r io.ReadCloser) io.ReadCloser {
-        var err error
+	var err error
-        g := new(gzReader)
+	g := new(gzReader)
-        g.r = r
+	g.r = r
-        g.z, err = gzip.NewReader(r)
+	g.z, err = gzip.NewReader(r)
-        if err != nil {
+	if err != nil {
-            panic(err)
+		panic(err)
-        }
+	}
-        return g
+	return g
 }
 
 func main() {
-    appPath := os.Args[1]
+	plat = os.Getenv("GOOS") + "-" + os.Getenv("GOARCH")
-    version := os.Args[2]
-    genDir := "public"
-    os.MkdirAll(genDir, 0755)
 
-    c := current{Version: version, Sha256: generateSha256(appPath)}
+	appPath := os.Args[1]
+	version := os.Args[2]
+	genDir := "public"
+	os.MkdirAll(genDir, 0755)
 
-    b, err := json.MarshalIndent(c, "", "    ")
+	c := current{Version: version, Sha256: generateSha256(appPath)}
-    if err != nil {
-        fmt.Println("error:", err)
-    }
-    err = ioutil.WriteFile(filepath.Join(genDir, plat + ".json"), b, 0755)
-    if err != nil {
-        panic(err)
-    }
 
-    os.MkdirAll(filepath.Join(genDir, version), 0755)
+	b, err := json.MarshalIndent(c, "", "    ")
+	if err != nil {
+		fmt.Println("error:", err)
+	}
+	err = ioutil.WriteFile(filepath.Join(genDir, plat+".json"), b, 0755)
+	if err != nil {
+		panic(err)
+	}
 
-    var buf bytes.Buffer
+	os.MkdirAll(filepath.Join(genDir, version), 0755)
-    w := gzip.NewWriter(&buf)
-    f, err := ioutil.ReadFile(appPath)
-    if err != nil {
-        panic(err)
-    }
-    w.Write(f)
-    w.Close() // You must close this first to flush the bytes to the buffer.
-    err = ioutil.WriteFile(filepath.Join(genDir, version, plat + ".gz"), buf.Bytes(), 0755)
 
-    files, err := ioutil.ReadDir(genDir)
+	var buf bytes.Buffer
-    if err != nil {
+	w := gzip.NewWriter(&buf)
-        fmt.Println(err)
+	f, err := ioutil.ReadFile(appPath)
-    }
+	if err != nil {
+		panic(err)
+	}
+	w.Write(f)
+	w.Close() // You must close this first to flush the bytes to the buffer.
+	err = ioutil.WriteFile(filepath.Join(genDir, version, plat+".gz"), buf.Bytes(), 0755)
 
-    for _, file := range files {
+	files, err := ioutil.ReadDir(genDir)
-        if file.IsDir() == false {
+	if err != nil {
-            continue
+		fmt.Println(err)
-        }
+	}
-        if file.Name() == version {
-            continue
-        }
 
-        os.Mkdir(filepath.Join(genDir, file.Name(), version), 0755)
+	for _, file := range files {
+		if file.IsDir() == false {
+			continue
+		}
+		if file.Name() == version {
+			continue
+		}
 
-        fName := filepath.Join(genDir, file.Name(), plat + ".gz")
+		os.Mkdir(filepath.Join(genDir, file.Name(), version), 0755)
-        old, err := os.Open(fName)
-        if err != nil {
-            fmt.Fprintf(os.Stderr, "Can't open %s: error: %s\n", fName, err)
-            os.Exit(1)
-        }
 
-        fName = filepath.Join(genDir, version, plat + ".gz")
+		fName := filepath.Join(genDir, file.Name(), plat+".gz")
-        newF, err := os.Open(fName)
+		old, err := os.Open(fName)
-        if err != nil {
+		if err != nil {
-            fmt.Fprintf(os.Stderr, "Can't open %s: error: %s\n", fName, err)
+			fmt.Fprintf(os.Stderr, "Can't open %s: error: %s\n", fName, err)
-            os.Exit(1)
+			os.Exit(1)
-        }
+		}
 
-        ar := newGzReader(old)
+		fName = filepath.Join(genDir, version, plat+".gz")
-        defer ar.Close()
+		newF, err := os.Open(fName)
-        br := newGzReader(newF)
+		if err != nil {
-        defer br.Close()
+			fmt.Fprintf(os.Stderr, "Can't open %s: error: %s\n", fName, err)
-        patch := new(bytes.Buffer)
+			os.Exit(1)
-        if err := binarydist.Diff(ar, br, patch); err != nil {
+		}
-            panic(err)
+
-        }
+		ar := newGzReader(old)
-        ioutil.WriteFile(filepath.Join(genDir, file.Name(), version, plat), patch.Bytes(), 0755)
+		defer ar.Close()
-    }
+		br := newGzReader(newF)
+		defer br.Close()
+		patch := new(bytes.Buffer)
+		if err := binarydist.Diff(ar, br, patch); err != nil {
+			panic(err)
+		}
+		ioutil.WriteFile(filepath.Join(genDir, file.Name(), version, plat), patch.Bytes(), 0755)
+	}
 
 }