initial commit

Author: egonelbre

common.go

@@ -0,0 +1,161 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+func (cmd Common) DeleteNonRepos() {
+	var err error
+	srcdir := cmd.Path("src")
+
+	var repos = map[string]bool{}
+	repos[strings.ToLower(filepath.FromSlash(cmd.Package))] = true
+
+	err = filepath.Walk(srcdir,
+		func(path string, info os.FileInfo, err error) error {
+			rpath, err := filepath.Rel(srcdir, path)
+			if err != nil || rpath == "" || rpath == "." || rpath == ".." || !info.IsDir() {
+				return err
+			}
+			if filepath.Base(rpath) == ".git" {
+				repos[strings.ToLower(filepath.Dir(rpath))] = true
+				return filepath.SkipDir
+			}
+			return nil
+		})
+	ErrFatalf(err, "collect failed: %q", err)
+
+	err = filepath.Walk(srcdir,
+		func(path string, info os.FileInfo, err error) error {
+			rpath, err := filepath.Rel(srcdir, path)
+			if err != nil || rpath == "" || rpath == "." || rpath == ".." {
+				return err
+			}
+
+			lowpath := strings.ToLower(rpath)
+
+			for repo := range repos {
+				if repo == lowpath {
+					return filepath.SkipDir
+				}
+			}
+
+			for repo := range repos {
+				if strings.HasPrefix(repo, lowpath) {
+					return nil
+				}
+			}
+
+			err = os.RemoveAll(path)
+			if err != nil {
+				return err
+			}
+			return filepath.SkipDir
+		})
+	ErrFatalf(err, "remove failed: %q", err)
+}
+
+func (cmd Common) VendorModules() {
+	fmt.Fprintf(os.Stdout, "# Vendoring modules\n")
+
+	workdir, err := os.Getwd()
+	ErrFatalf(err, "unable to get working directory: %q\n", err)
+
+	defer func() {
+		err = os.Chdir(workdir)
+		ErrFatalf(err, "unable to change directory: %q\n", err)
+	}()
+
+	err = os.Chdir(cmd.RepoDir())
+	ErrFatalf(err, "unable to change directory: %q\n", err)
+
+	err = os.RemoveAll("vendor")
+	if os.IsNotExist(err) {
+		err = nil
+	}
+	ErrFatalf(err, "unable to delete vendor: %q\n", err)
+
+	for repeat := 2; repeat > 0; repeat-- {
+		gomod := exec.Command("go", "mod", "vendor", "-v")
+		gomod.Env = append(os.Environ(), "GO111MODULE=on")
+		gomod.Stdout, gomod.Stderr = os.Stdout, os.Stderr
+		err = gomod.Run()
+		Errf(err, "go mod vendor failed, retrying: %q\n", err)
+		if err == nil {
+			break
+		}
+	}
+	ErrFatalf(err, "go mod vendor failed: %q\n", err)
+}
+
+func (cmd Common) FlattenVendor() {
+	fmt.Fprintf(os.Stdout, "# Flattening vendor\n")
+
+	vendordir := filepath.Join(cmd.RepoDir(), "vendor")
+	srcdir := cmd.Path("src")
+	err := filepath.Walk(vendordir,
+		func(path string, info os.FileInfo, err error) error {
+			rpath, err := filepath.Rel(vendordir, path)
+			if err != nil || rpath == "" || rpath == "." || rpath == ".." {
+				return err
+			}
+			if err != nil {
+				return err
+			}
+			err = os.Rename(
+				filepath.Join(vendordir, rpath),
+				filepath.Join(srcdir, rpath))
+			if err != nil {
+				return err
+			}
+			return filepath.SkipDir
+		})
+	ErrFatalf(err, "rename failed: %q", err)
+
+	err = os.Remove(vendordir)
+	ErrFatalf(err, "unable to delete vendor: %q", err)
+}
+
+func ReadModules(path string) []string {
+	data, err := ioutil.ReadFile(path)
+	if os.IsNotExist(err) {
+		return nil
+	}
+
+	if err != nil {
+		ErrFatalf(err, "unable to read modules.txt: %q", err)
+	}
+
+	unsorted := []string{}
+	for _, line := range strings.Split(string(data), "\n") {
+		line = strings.TrimSpace(line)
+		if strings.HasPrefix(line, "#") {
+			continue
+		}
+		if line == "" {
+			continue
+		}
+		unsorted = append(unsorted, line)
+	}
+
+	sort.Strings(unsorted)
+
+	modules := []string{}
+	before := "\x00"
+
+	for _, line := range unsorted {
+		if strings.HasPrefix(line, before) {
+			continue
+		}
+		before = line
+		modules = append(modules, line)
+	}
+
+	return modules
+}

go.mod

@@ -0,0 +1 @@
+module storj.io/gospace

main.go

@@ -0,0 +1,97 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type Command interface {
+	Name() string
+	Parse(args []string) error
+	Exec()
+}
+
+type Common struct {
+	Root    string
+	RootAbs string
+
+	Package string
+	Repo    string
+}
+
+func (cmd Common) RepoDir() string {
+	return cmd.Path("src", filepath.FromSlash(cmd.Package))
+}
+
+func (cmd Common) Path(args ...string) string {
+	return filepath.Join(append([]string{cmd.RootAbs}, args...)...)
+}
+
+func main() {
+	common := Common{}
+	cmdname := ""
+	args := []string{}
+	{
+		set := flag.NewFlagSet("", flag.ContinueOnError)
+
+		set.StringVar(&common.Root, "root", os.Getenv("GOSPACE_ROOT"), "root directory (default GOSPACE_ROOT)")
+		set.StringVar(&common.Package, "pkg", os.Getenv("GOSPACE_PKG"), "package name (default GOSPACE_PKG)")
+		set.StringVar(&common.Repo, "repo", os.Getenv("GOSPACE_REPO"), "package name (default GOSPACE_REPO)")
+
+		if err := set.Parse(os.Args[1:]); err != nil {
+			fmt.Fprintln(os.Stderr, "invalid args")
+			os.Exit(1)
+		}
+
+		fail := false
+		if common.Root == "" {
+			fmt.Fprintln(os.Stderr, "root directory is missing, please specify `-root` or GOSPACE_ROOT environment variable")
+			fail = true
+		}
+		if common.Package == "" {
+			fmt.Fprintln(os.Stderr, "package name is missing, please specify `-pkg` or GOSPACE_PKG environment variable")
+			fail = true
+		}
+		if common.Repo == "" {
+			fmt.Fprintln(os.Stderr, "repo name is missing, please specify `-repo` or GOSPACE_REPO environment variable")
+			fail = true
+		}
+
+		if fail {
+			os.Exit(1)
+		}
+
+		cmdname = set.Arg(0)
+		if set.NArg() > 1 {
+			args = set.Args()[1:]
+		}
+
+		common.RootAbs, _ = filepath.Abs(common.Root)
+	}
+
+	cmds := []Command{
+		&Setup{Common: common},
+		&Update{Common: common},
+	}
+
+	for _, cmd := range cmds {
+		if strings.EqualFold(cmdname, cmd.Name()) {
+			if err := cmd.Parse(args); err != nil {
+				fmt.Fprintln(os.Stderr, "invalid args", err)
+				os.Exit(1)
+			}
+			cmd.Exec()
+			return
+		}
+	}
+
+	fmt.Fprintln(os.Stderr, "unknown command:", cmdname)
+	fmt.Fprintln(os.Stderr, "supported:")
+	for _, cmd := range cmds {
+		fmt.Fprintln(os.Stderr, "\t"+cmd.Name())
+	}
+	os.Exit(1)
+}

setup.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+)
+
+type Setup struct {
+	Common
+	Overwrite bool
+}
+
+func (cmd *Setup) Name() string { return "setup" }
+
+func (cmd *Setup) Parse(args []string) error {
+	set := flag.NewFlagSet(cmd.Name(), flag.ExitOnError)
+	set.BoolVar(&cmd.Overwrite, "overwrite", false, "overwrite existing and reclone everything")
+	return set.Parse(args)
+}
+
+func (cmd *Setup) Exec() {
+	if !cmd.Overwrite && !Exists(cmd.Path("src")) {
+		fmt.Fprintf(os.Stderr, "src directory %q already setup", cmd.Path("src"))
+		os.Exit(1)
+	}
+
+	// _ = os.RemoveAll(cmd.Path("pkg"))
+	_ = os.RemoveAll(cmd.Path("bin"))
+	_ = os.RemoveAll(cmd.Path("src"))
+
+	repodir := cmd.RepoDir()
+
+	fmt.Fprintf(os.Stdout, "# Cloning repository\n")
+	git := exec.Command("git", "clone", cmd.Repo, repodir)
+	git.Stdout, git.Stderr = os.Stdout, os.Stderr
+	ErrFatal(git.Run(), "git clone failed")
+
+	cmd.VendorModules()
+	cmd.FlattenVendor()
+}

update.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"flag"
+)
+
+type Update struct {
+	Common
+}
+
+func (cmd *Update) Name() string { return "update" }
+
+func (cmd *Update) Parse(args []string) error {
+	set := flag.NewFlagSet("update", flag.ExitOnError)
+	return set.Parse(args)
+}
+
+func (cmd *Update) Exec() {
+	srcdir := cmd.Path("src")
+	if !Exists(srcdir) {
+		Fatalf("src directory %q missing, run setup", srcdir)
+	}
+
+	cmd.DeleteNonRepos()
+	cmd.VendorModules()
+	cmd.FlattenVendor()
+}

util.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func Exists(dir string) bool {
+	_, err := os.Stat(dir)
+	return err == nil || !os.IsNotExist(err)
+}
+
+func Fatal(args ...interface{}) {
+	fmt.Fprintln(os.Stderr, args...)
+	panic("aborted")
+}
+
+func Fatalf(format string, args ...interface{}) {
+	fmt.Fprintf(os.Stderr, format, args...)
+	panic("aborted")
+}
+
+func ErrFatal(err error, args ...interface{}) {
+	if err == nil {
+		return
+	}
+	fmt.Fprintln(os.Stderr, args...)
+	panic("aborted")
+}
+
+func ErrFatalf(err error, format string, args ...interface{}) {
+	if err == nil {
+		return
+	}
+	fmt.Fprintf(os.Stderr, format, args...)
+	panic("aborted")
+}
+
+func Errf(err error, format string, args ...interface{}) {
+	if err == nil {
+		return
+	}
+	fmt.Fprintf(os.Stderr, format, args...)
+}