コード例 #1
0
ファイル: main.go プロジェクト: KalyaniSingh21/stack
func cp(src, dst string) error {
	if strings.HasSuffix(dst, "/") && !strings.HasSuffix(src, "/") {
		n := src
		if strings.Contains(n, "/") {
			n = n[strings.LastIndex(n, "/")+1:]
		}
		dst = filepath.Join(dst, n)
	}

	snl, err := storage.ParseLocation(src)
	if err != nil {
		return err
	}

	dnl, err := storage.ParseLocation(dst)
	if err != nil {
		return err
	}

	source, err := storage.Get(snl)
	if err != nil {
		return err
	}
	defer source.Close()

	err = storage.Put(dnl, source)
	if err != nil {
		return err
	}
	return nil
}
コード例 #2
0
ファイル: main.go プロジェクト: KalyaniSingh21/stack
func rm(src string) error {
	loc, err := storage.ParseLocation(src)
	if err != nil {
		return err
	}
	return storage.Delete(loc)
}
コード例 #3
0
ファイル: watch.go プロジェクト: KalyaniSingh21/stack
func watch(src string) error {
	loc, err := storage.ParseLocation(src)
	if err != nil {
		return err
	}

	watcher, err := sync.Watch(loc)
	if err != nil {
		return err
	}
	defer watcher.Stop()

	// TODO: a better approach here would be to use a channel to retry on,
	//       then if you jacked up the config, it would pick up the change
	//       in the middle of all the retries. As it stands now it would take a
	//       minute to fix itself.
	eb := backoff.NewExponentialBackOff()
	eb.MaxElapsedTime = time.Minute

	for range watcher.C {
		log.Println("[watch] new version")
		backoff.Retry(func() error {
			err := apply(src)
			if err != nil {
				log.Printf("[watch] error installing: %v\n", err)
			}
			return err
		}, eb)
	}

	return nil
}
コード例 #4
0
ファイル: main.go プロジェクト: calebdoxsey/devenv
func installGo() error {
	cmd := exec.Command(filepath.Join(goroot, "bin", "go"), "version")
	cmd.Env = []string{"GOROOT=" + goroot}
	goVersion, _ := cmd.CombinedOutput()
	if strings.TrimSpace(string(goVersion)) == "go version go1.5.1 linux/amd64" {
		return nil
	}

	log.Println("installing go")

	loc, err := storage.ParseLocation("https://storage.googleapis.com/golang/go1.5.1.linux-amd64.tar.gz")
	if err != nil {
		return err
	}

	rc, err := storage.Get(loc)
	if err != nil {
		return err
	}
	defer rc.Close()

	err = archive.ExtractReader("/tmp", rc, "go.tar.gz")
	if err != nil {
		return err
	}

	dst := goroot
	os.RemoveAll(dst)
	os.Rename("/tmp/go", dst)

	return nil
}
コード例 #5
0
ファイル: main.go プロジェクト: calebdoxsey/devenv
func installAppEngine() error {
	appEngineVersion, _ := exec.Command(filepath.Join(home, "dist", "go_appengine", "goapp"), "version").CombinedOutput()
	if strings.TrimSpace(string(appEngineVersion)) == "go version go1.4.2 (appengine-1.9.27) linux/amd64" {
		return nil
	}

	log.Println("installing app engine")

	url, err := storage.ParseLocation("https://storage.googleapis.com/appengine-sdks/featured/go_appengine_sdk_linux_amd64-1.9.27.zip")
	if err != nil {
		return err
	}
	rc, err := storage.Get(url)
	if err != nil {
		return err
	}
	defer rc.Close()

	err = archive.ExtractReader("/tmp", rc, "appengine.zip")
	if err != nil {
		return err
	}

	dst := filepath.Join(home, "dist", "go_appengine")
	os.RemoveAll(dst)
	os.Rename("/tmp/go_appengine", dst)

	return nil
}
コード例 #6
0
ファイル: main.go プロジェクト: KalyaniSingh21/stack
func ls(dir string) error {
	loc, err := storage.ParseLocation(dir)
	if err != nil {
		return err
	}
	names, err := storage.List(loc)
	if err != nil {
		return err
	}
	for _, name := range names {
		fmt.Println(name)
	}
	return nil
}
コード例 #7
0
ファイル: main.go プロジェクト: calebdoxsey/devenv
func installFish() error {
	fishVersion, _ := exec.Command(filepath.Join(home, "bin", "fish"), "--version").CombinedOutput()
	if strings.TrimSpace(string(fishVersion)) == "fish, version 2.2.0" {
		return nil
	}

	log.Println("installing fish")

	url, err := storage.ParseLocation("http://fishshell.com/files/2.2.0/fish-2.2.0.tar.gz")
	if err != nil {
		return err
	}

	rc, err := storage.Get(url)
	if err != nil {
		return err
	}
	defer rc.Close()

	err = archive.ExtractReader("/tmp", rc, "fish.tar.gz")
	if err != nil {
		return err
	}

	dst := filepath.Join(home, "dist", "fish")
	os.RemoveAll(dst)
	os.Rename("/tmp/fish-2.2.0", dst)

	cmd := exec.Command("bash", "-c", "./configure --prefix=$HOME && make && make install")
	cmd.Dir = dst
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	err = cmd.Run()
	if err != nil {
		return err
	}

	log.Println("setting fish as default shell")
	cmd = exec.Command("bash", "-c", "sudo chsh -s "+filepath.Join(home, "bin", "fish")+" vagrant")
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	err = cmd.Run()
	if err != nil {
		return err
	}

	return nil
}
コード例 #8
0
ファイル: main.go プロジェクト: calebdoxsey/devenv
func download(src, name, dst string) error {
	url, err := storage.ParseLocation(src)
	if err != nil {
		return err
	}
	rc, err := storage.Get(url)
	if err != nil {
		return err
	}
	defer rc.Close()

	err = archive.ExtractReader(dst, rc, name)
	if err != nil {
		return err
	}

	return nil
}
コード例 #9
0
ファイル: main.go プロジェクト: calebdoxsey/devenv
func installRedis() error {
	redisVersion, _ := exec.Command(filepath.Join(home, "bin", "redis-server"), "--version").CombinedOutput()
	if strings.TrimSpace(string(redisVersion)) == "Redis server v=3.0.4 sha=00000000:0 malloc=jemalloc-3.6.0 bits=64 build=bbb5a106838ae534" {
		return nil
	}
	log.Println("installing redis")

	url, err := storage.ParseLocation("http://download.redis.io/releases/redis-3.0.4.tar.gz")
	if err != nil {
		return err
	}
	rc, err := storage.Get(url)
	if err != nil {
		return err
	}
	defer rc.Close()

	err = archive.ExtractReader("/tmp", rc, "redis.tar.gz")
	if err != nil {
		return err
	}

	dst := filepath.Join(home, "dist", "redis")
	os.RemoveAll(dst)
	os.Rename("/tmp/redis-3.0.4", dst)

	cmd := exec.Command("bash", "-c", "make && env PREFIX=$HOME make install")
	cmd.Dir = dst
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	err = cmd.Run()
	if err != nil {
		return err
	}

	return nil
}
コード例 #10
0
ファイル: apply.go プロジェクト: KalyaniSingh21/stack
func apply(src string) error {
	pl := NewPortLock(49001)
	pl.Lock()
	defer pl.Unlock()

	loc, err := storage.ParseLocation(src)
	if err != nil {
		return err
	}
	rc, err := storage.Get(loc)
	if err != nil {
		return err
	}
	defer rc.Close()

	cfg, err := ParseConfig(rc)
	if err != nil {
		return err
	}

	prevCfg := ReadConfig()

	err = applySources(prevCfg, cfg)
	if err != nil {
		return fmt.Errorf("error processing sources: %v", err)
	}

	err = applyApplications(prevCfg, cfg)
	if err != nil {
		return fmt.Errorf("error processing applications: %v", err)
	}

	SaveConfig(cfg)

	return nil
}