Example #1
0
// run the import command
func runImport(cmd *Command, args ...string) {
	if len(args) == 0 {
		cmd.DisplayUsageAndExit()
	}
	// make sure that the manifest file exists
	if _, err := os.Stat(args[0]); err != nil {
		fmt.Println(utils.Fail(
			fmt.Sprintf("error: can't open %s manifest file", args[0])))
		os.Exit(2)
	}

	options := func(i *Import) {
		i.Force = forceImport
		i.Verbose = verboseImport
		i.Prompt = promptImport
		i.Manifest = args[0]
	}
	i := NewImport(options)
	out, err := i.Run()
	if err != nil {
		fmt.Println(utils.Fail(fmt.Sprintf("error: %v", err)))
		os.Exit(2)
	}
	fmt.Printf("%s\n", utils.Ok(out))
	os.Exit(0)
}
Example #2
0
func copySource(ver string) error {
	var out []byte
	fmt.Fprint(Output, "Copying source... ")
	destination := filepath.Join(CacheDirectory(), ver)
	os.RemoveAll(destination)
	curr, err := os.Getwd()
	if err != nil {
		return err
	}
	defer func() {
		exec.Command("git", "checkout", "master").Run()
		os.Chdir(curr)
	}()
	os.Chdir(TARGET)
	if ver != "go" && ver != "tip" {
		out, err := exec.Command("git", "checkout", ver).CombinedOutput()
		log.Println(string(out), err)
		if err != nil {
			fmt.Fprintln(Output, utils.Fail("✖"))
			return fmt.Errorf("%s", out)
		}
	}
	out, err = exec.Command("cp", "-R", "../git", destination).CombinedOutput()
	if err != nil {
		fmt.Fprintln(Output, utils.Fail("✖"))
		return err
	}
	fmt.Fprintln(Output, utils.Ok("✔"))
	logOutput(out)
	return nil
}
Example #3
0
// export the given environment using a VenGO.manifest file
func (e *Export) envExport() (string, error) {
	fmt.Print("Loading environment... ")
	environment, err := e.LoadEnvironment()
	if err != nil {
		fmt.Println(utils.Fail("✖"))
		return "", err
	}
	fmt.Println(utils.Ok("✔"))
	fmt.Print("Generating manifest... ")
	environManifest, err := environment.Manifest()
	if err != nil {
		fmt.Println(utils.Fail("✖"))
		return "", err
	}
	manifest, err := environManifest.Generate()
	if err != nil {
		fmt.Println(utils.Fail("✖"))
		return "", err
	}
	fmt.Println(utils.Ok("✔"))
	if e.Prettify {
		buffer := new(bytes.Buffer)
		json.Indent(buffer, manifest, "", "\t")
		manifest = buffer.Bytes()
	}
	fmt.Printf("Writing manifest into %s... ", environment.VenGO_PATH)
	err = ioutil.WriteFile(
		filepath.Join(environment.VenGO_PATH, e.Name), manifest, 0644)
	if err != nil {
		fmt.Println(utils.Fail("✖"))
	}
	fmt.Println(utils.Ok("✔"))

	return "", err
}
Example #4
0
// run the migrate command
func runMigrate(cmd *Command, args ...string) {
	if len(args) < 2 {
		cmd.DisplayUsageAndExit()
	}
	environName := args[0]
	goVersion := args[1]
	if os.Getenv("VENGO_ENV") == environName {
		fmt.Println(
			"error:", fmt.Sprintf("%s is currently in use as the active environment"))
		fmt.Printf("%s: execute 'deactivate' before call this command\n", suggest)
		os.Exit(2)
	}
	envPath := filepath.Join(os.Getenv("VENGO_HOME"), environName)
	if _, err := os.Stat(envPath); err != nil {
		fmt.Printf("%s is no a VenGO environment...\n", environName)
		fmt.Println(err)
		os.Exit(2)
	}
	fmt.Print("Checking installed Go versions...")
	if !env.LookupInstalledVersion(goVersion) {
		fmt.Println(utils.Fail("✖"))
		fmt.Println(fmt.Sprintf(
			"sorry vengo can't perform the operation because %s is %s",
			goVersion, utils.Fail("not installed")))
		fmt.Printf("%s: run 'vengo install %s'\n", suggest, goVersion)
		os.Exit(2)
	}
	fmt.Println(utils.Ok("✔"))

	library := filepath.Join(envPath, "lib")
	installed, _ := os.Readlink(library)
	if installed == goVersion {
		fmt.Printf("%s in use Go version is already %s, skipping...", environName, installed)
		os.Exit(0)
	}
	fmt.Printf("unlinking previous %s Go version from %s...", installed, environName)
	if err := os.Remove(library); err != nil {
		fmt.Println(utils.Fail("✖"))
		fmt.Println(err)
		os.Exit(2)
	}
	fmt.Println(utils.Ok("✔"))
	fmt.Printf("Linking Go version %s...", goVersion)
	path := filepath.Join(cache.CacheDirectory(), goVersion)
	err := os.Symlink(path, filepath.Join(envPath, "lib"))
	if err != nil {
		fmt.Println(utils.Fail("✖"))
		fmt.Println(err)
		os.Exit(2)
	}
	fmt.Println(utils.Ok("✔"))
	fmt.Println("Done. You may want to run 'go build -a ./... in $GOPATH")
	os.Exit(0)
}
Example #5
0
// create a string representation of a package
func (p *Package) String() string {
	check := utils.Ok("✔")
	if !p.Installed {
		check = utils.Fail("✖")
	}
	return fmt.Sprintf(`    %s(%s) %s`, p.Name, p.Url, check)
}
Example #6
0
// fun the install command
func runInstall(cmd *Command, args ...string) {
	if len(args) == 0 {
		cmd.DisplayUsageAndExit()
	}
	options := func(i *Install) {
		i.Verbose = verboseInstall
		i.Force = forceInstall
		i.NoCGO = nocgoInstall
		i.BootStrap = bootStrap
		if binaryInstall {
			i.Source = Binary
		} else {
			if sourceInstall {
				i.Source = Source
			}
		}
		i.Version = args[0]
	}
	i := NewInstall(options)
	data, err := i.Run()
	if err != nil {
		fmt.Println(utils.Fail(fmt.Sprintf("error: %v", err)))
		if !verboseInstall {
			fmt.Printf(
				"%s: run the install command with the '-v' option\n", suggest)
		}
		os.Exit(2)
	}
	fmt.Println(data)
	os.Exit(0)
}
Example #7
0
// implements the Runner interface creating the new virtual environment
func (m *Mkenv) Run() (string, error) {
	fmt.Fprint(cache.Output, "Checking installed Go versions... ")
	if err := m.checkInstalled(); err != nil {
		fmt.Fprintln(cache.Output, utils.Fail("✖"))
		return "", err
	}
	fmt.Fprintln(cache.Output, utils.Ok("✔"))

	newEnv := env.NewEnvironment(m.Name, m.Prompt)
	if newEnv.Exists() && !m.Force {
		suggest := fmt.Sprintf(
			"  %s: use --force to force reinstallation", utils.Ok("suggestion"))
		return "", fmt.Errorf("error: %s already exists\n%s", m.Name, suggest)
	}
	if err := newEnv.Generate(); err != nil {
		os.RemoveAll(filepath.Join(os.Getenv("VENGO_HOME"), m.Name))
		return "", err
	}
	if err := newEnv.Install(m.Version); err != nil {
		os.RemoveAll(filepath.Join(os.Getenv("VENGO_HOME"), m.Name))
		return "", err
	}

	return fmt.Sprintf(
		"%s", utils.Ok(fmt.Sprintf(
			"Go %s environment created using %s", m.Name, m.Version))), nil
}
Example #8
0
// run the mkenv command
func runMkenv(cmd *Command, args ...string) {
	if len(args) == 0 {
		cmd.DisplayUsageAndExit()
	}
	options := func(m *Mkenv) {
		m.Force = forceMkenv
		if goversionMkenv != "" {
			m.Version = goversionMkenv
		}
		if promptMkenv != "" {
			m.Prompt = promptMkenv
		}
		m.Name = args[0]
	}
	mkenv := NewMkenv(options)
	data, err := mkenv.Run()
	if err != nil {
		if IsNotInstalledError(err) {
			fmt.Println(fmt.Sprintf(
				"sorry vengo can't perform the operation because %s is %s",
				mkenv.Version, utils.Fail("not installed")))
			fmt.Printf("%s: run 'vengo install %s'\n", suggest, mkenv.Version)
			os.Exit(2)
		}
		fmt.Println(err)
		os.Exit(2)
	}
	fmt.Println(data)
}
Example #9
0
func checkSource(tag string) error {
	fmt.Fprintf(Output, "Checking %s... ", tag)
	out, err := exec.Command("hg", "pull", "-R", TARGET).CombinedOutput()
	if err != nil {
		fmt.Fprintln(Output, utils.Fail("✖"))
		return err
	}
	fmt.Fprintln(Output, utils.Ok("✔"))
	logOutput(out)
	return nil
}
Example #10
0
// determine if a Go version has been already compiled in the cache
func AlreadyCompiled(ver string) bool {
	manifest := filepath.Join(CacheDirectory(), ver, ".vengo-manifest")
	if _, err := os.Stat(manifest); err != nil {
		return false
	}
	fmt.Fprint(Output, "Checking manifest integrity... ")
	if err := CheckManifestIntegrity(manifest); err != nil {
		fmt.Println(utils.Fail("✖"))
		log.Println(err)
		return false
	}
	fmt.Fprintln(Output, utils.Ok("✔"))
	return true
}
Example #11
0
// run the export command
func runExport(cmd *Command, args ...string) {
	env := func(e *Export) {}
	if len(args) == 0 {
		activeEnv := os.Getenv("VENGO_ENV")
		if activeEnv == "" {
			cmd.DisplayUsageAndExit()
		}
	} else {
		env = func(e *Export) {
			e.Environment = filepath.Join(cache.VenGO_PATH, args[0])
		}
	}
	options := func(e *Export) {
		e.Force = forceExport
		e.Prettify = prettifyExport
		e.Name = nameExport
	}
	e := NewExport(options, env)
	if e.Err() != nil {
		fmt.Println(utils.Fail(fmt.Sprint(e.Err())))
		os.Exit(2)
	}
	if e.Exists() {
		if !e.Force {
			p := filepath.Join(e.Environment, e.Name)
			fmt.Println(utils.Fail(fmt.Sprintf("%s already exists", p)))
			fmt.Printf("%s: use the -f option to overwrite it\n", suggest)
			os.Exit(2)
		}
	}
	_, err := e.Run()
	if err != nil {
		fmt.Println(utils.Fail(fmt.Sprintf("error: %v", err)))
		os.Exit(2)
	}
	os.Exit(0)
}
Example #12
0
func pull() error {
	curr, err := os.Getwd()
	if err != nil {
		return err
	}
	defer os.Chdir(curr)
	os.Chdir(TARGET)
	fmt.Fprintf(Output, "Pulling Go sources from Github... ")
	out, err := exec.Command("git", "pull").CombinedOutput()
	if err != nil {
		fmt.Println(Output, utils.Fail("✖"))
		return err
	}
	fmt.Fprintln(Output, utils.Ok("✔"))
	logOutput(out)
	return nil
}
Example #13
0
// generates the output for the list command
func (l *List) display(versions map[string][]string) (string, error) {
	output := []string{}
	if l.DisplayAs == Text {
		if l.ShowBoth || l.ShowInstalled {
			output = append(output, utils.Ok("Installed"))
			for _, v := range versions["installed"] {
				_, err := os.Stat(
					filepath.Join(cache.CacheDirectory(), v, ".vengo-manifest"))
				check := utils.Ok("✔")
				if err != nil {
					check = utils.Fail("✖")
				}
				output = append(output, fmt.Sprintf("    %s %s", v, check))
			}
		}
		if l.ShowBoth || l.ShowNotInstalled {
			output = append(output, utils.Ok("Available for Installation"))
			output = append(output, versions["available"]...)
		}
		return strings.Join(output, "\n"), nil
	}

	if l.DisplayAs == Json {
		jsonData := &BriefJSON{[]string{}, []string{}}
		if l.ShowBoth || l.ShowInstalled {
			for _, v := range versions["installed"] {
				v := strings.TrimLeft(v, "    ")
				jsonData.Installed = append(jsonData.Installed, v)
			}
		}
		if l.ShowBoth || l.ShowNotInstalled {
			for _, v := range versions["available"] {
				v := strings.TrimLeft(v, "    ")
				jsonData.Available = append(jsonData.Available, v)
			}
		}
		data, err := json.Marshal(jsonData)
		return string(data), err
	}

	return "", fmt.Errorf("List.DisplayAs is not set to a valid value!")
}
Example #14
0
func cloneSource() error {
	// check if git command line is installed
	if _, err := exec.LookPath("git"); err != nil {
		log.Fatal("Git is not installed on this system.")
	}

	if GitExists() {
		return pull()
	}
	fmt.Fprint(Output, "Cloning Go sources from Github... ")

	out, err := exec.Command("git", "clone", REPO, TARGET).CombinedOutput()
	if err != nil {
		fmt.Println(Output, utils.Fail("✖"))
		return err
	}
	fmt.Fprintln(Output, utils.Ok("✔"))
	logOutput(out)
	return nil
}
Example #15
0
// install all the packages in the manifest using their respective revisions
func (em *envManifest) installPackages(v bool) error {
	curr, _ := os.Getwd()
	environmentPath := filepath.Join(os.Getenv("VENGO_ENV"), "src")
	if err := os.MkdirAll(environmentPath, 0755); err != nil {
		return err
	}
	defer os.Chdir(curr)
	os.Chdir(environmentPath)
	for _, pkg := range em.Packages {
		if pkg.CodeRevision == "0000000000000000000000000000000000000000" {
			continue // we are in a test here
		}
		fmt.Printf("Cloning %s... ", pkg.Name)
		if err := pkg.Vcs.Clone(pkg.Url, pkg.CodeRevision, pkg.Root, v); err != nil {
			fmt.Println(utils.Fail("✖"))
			return err
		}
		fmt.Println(utils.Ok("✔"))
	}
	return nil
}
Example #16
0
// download and extract the given file checking the given sha1 signature
func downloadAndExtract(ver, url, expected_sha1 string) error {
	resp, err := http.Get(url)
	if err != nil {
		return err
	}

	if resp.StatusCode != 200 {
		if resp.StatusCode == 400 {
			log.Fatalf("Version %s can't be found!\n", ver)
		}
		return fmt.Errorf("%s", resp.Status)
	}
	defer resp.Body.Close()

	fmt.Fprintf(Output, "downloading Go%s from %s ", ver, url)
	buf := new(bytes.Buffer)
	size, err := io.Copy(buf, resp.Body)
	if err != nil {
		fmt.Fprintln(Output, utils.Fail("✖"))
		return err
	}
	fmt.Fprintln(Output, utils.Ok("✔"))

	pkg_sha1 := fmt.Sprintf("%x", sha1.Sum(buf.Bytes()))
	if pkg_sha1 != expected_sha1 {
		return fmt.Errorf(
			"Error: SHA1 is different! expected %s got %s",
			expected_sha1, pkg_sha1,
		)
	}
	fmt.Fprintf(Output, "%d bytes donwloaded... decompresssing... ", size)
	prefix := filepath.Join(CacheDirectory(), ver)
	extractTar(prefix, readGzipFile(buf))
	buf.Reset()
	buf = nil
	fmt.Fprintln(Output, utils.Ok("✔"))

	return nil
}
Example #17
0
// generates the output for the lsenvs command
func (e *EnvironmentsList) display(
	available, invalid []string) (string, error) {

	output := []string{}
	if e.DisplayAs == Text {
		output = append(output, utils.Ok("Virtual Go Environments"))
		for _, v := range available {
			output = append(output, fmt.Sprintf("    %s %s", v, utils.Ok("✔")))
		}
		for _, v := range invalid {
			output = append(
				output, fmt.Sprintf("    %s %s", v, utils.Fail("✖")))
		}

		return strings.Join(output, "\n"), nil
	}

	if e.DisplayAs == Json {
		data, err := json.Marshal(&EnvironmentsJSON{available, invalid})
		return string(data), err
	}

	return "", fmt.Errorf("EnvironmentsList.DisplayAs is not a valid value!")
}
Example #18
0
Go versions.

JSON output:
  One can pass the -j or --json option to display the output as a JSON
  structure with the following format:
    {
        "installed": [
             "1.3rc2",
             "go1.2.2",
             "go1.3.2","go1.3.3",
             "go1.4",
             "go1.4rc1",
             "go1.4rc2"
        ]
    }
`, utils.Ok("✔"), utils.Fail("✖")),
	Execute: runList,
}

var (
	allList          bool
	nonInstalledList bool
	asJsonList       bool
)

// initialize the command
func init() {
	cmdList.Flag.BoolVarP(&allList, "all", "a", false, "")
	cmdList.Flag.BoolVarP(&nonInstalledList, "non-installed", "n", false, "")
	cmdList.Flag.BoolVarP(&asJsonList, "json", "j", false, "")
	cmdList.register()
Example #19
0
	Describe("String", func() {
		It("Will return back a right formatted string", func() {
			options := func(p *env.Package) {
				p.Name = "GoTest"
				p.Url = "http://golang.org"
				p.Installed = true
				p.Vcs = "hg"
			}
			p := env.NewPackage(options)

			Expect(p).ToNot(BeNil())
			Expect(fmt.Sprint(p)).To(Equal(fmt.Sprintf("    %s(%s) %s", p.Name, p.Url, utils.Ok("✔"))))
			p.Installed = false

			Expect(fmt.Sprint(p)).To(Equal(fmt.Sprintf("    %s(%s) %s", p.Name, p.Url, utils.Fail("✖"))))
		})
	})

	Describe("Manifest", func() {
		BeforeEach(func() {
			os.Setenv("VENGO_HOME", "")
			if _, err := os.Stat(filepath.Join(cache.VenGO_PATH, "goTest")); err != nil {
				e := env.NewEnvironment("goTest", "(goTest)")

				Expect(e.Generate()).To(Succeed())
				newLib, err := ioutil.TempDir("", "VenGO-")

				Expect(err).ToNot(HaveOccurred())
				Expect(os.MkdirAll(filepath.Join(newLib, "go1.3.2"), 0755)).To(Succeed())
				Expect(
Example #20
0
				Context("Using Text output", func() {
					It("Should return a title and a list of available/invalid environments", func() {
						l := commands.NewEnvironmentsList()

						Expect(l).ToNot(BeNil())
						environments, err := l.Run()

						Expect(err).ToNot(HaveOccurred())
						envsSplit := strings.Split(environments, "\n")

						Expect(envsSplit[0]).To(Equal(utils.Ok("Virtual Go Environments")))
						Expect(envsSplit[1]).To(Equal(fmt.Sprintf("    MyEnv1                .VenGO   %s", utils.Ok("✔"))))
						Expect(envsSplit[2]).To(Equal(fmt.Sprintf("    MyEnv2                .VenGO   %s", utils.Ok("✔"))))
						Expect(envsSplit[3]).To(Equal(fmt.Sprintf("    MyEnv3                .VenGO   %s", utils.Ok("✔"))))
						Expect(envsSplit[4]).To(Equal(fmt.Sprintf("    MyInvalidEnv1 %s", utils.Fail("✖"))))
						Expect(envsSplit[5]).To(Equal(fmt.Sprintf("    MyInvalidEnv2 %s", utils.Fail("✖"))))
					})
				})

				Context("using Json output", func() {
					It("Should return a Json structure with two lists with 3 and 2 elements", func() {
						jsonOutput := func(e *commands.EnvironmentsList) {
							e.DisplayAs = commands.Json
						}
						l := commands.NewEnvironmentsList(jsonOutput)

						Expect(l).ToNot(BeNil())
						environments, err := l.Run()

						Expect(err).ToNot(HaveOccurred())
Example #21
0
// compile a given version of go in the cache
func Compile(ver string, verbose, nocgo bool, boostrap ...string) error {
	fmt.Fprint(Output, "Compiling... ")
	if verbose {
		fmt.Fprint(Output, "\n")
	}

	bs := ""
	if len(boostrap) > 0 {
		bs = boostrap[0]
	}

	currdir, _ := os.Getwd()
	prefixed := false
	err := os.Chdir(filepath.Join(CacheDirectory(), ver, "go", "src"))
	if err != nil {
		if !strings.HasPrefix(ver, "go") && ver != "tip" {
			ver = fmt.Sprintf("go%s", ver)
		}
		prefixed = true
		if err := os.Chdir(
			filepath.Join(CacheDirectory(), ver, "src")); err != nil {
			if !verbose {
				fmt.Fprintln(Output, utils.Fail("✖"))
			}
			return err
		}
	}
	defer func() { os.Chdir(currdir) }()

	cmd := "./make.bash"
	if runtime.GOOS == "windows" {
		cmd = "./make.bat"
	}
	if nocgo {
		os.Setenv("CGO_ENABLED", "0")
	}
	if bs != "" {
		os.Setenv("GOROOT_BOOTSTRAP", bs)
	}
	if err := utils.Exec(verbose, cmd); err != nil {
		return err
	}
	goBin := filepath.Join(CacheDirectory(), ver, "go", "bin", "go")
	if prefixed {
		goBin = filepath.Join(CacheDirectory(), ver, "bin", "go")
	}
	if _, err := os.Stat(goBin); err != nil {
		if !verbose {
			fmt.Fprintln(Output, utils.Fail("✖"))
		}
		fmt.Fprintln(Output, err)
		return fmt.Errorf("Go %s wasn't compiled properly! %v", ver, err)
	}
	if !verbose {
		fmt.Fprintln(Output, utils.Ok("✔"))
	}
	fmt.Fprintf(Output, "Generating manifest... ")
	if err := generateManifest(ver); err != nil {
		os.RemoveAll(filepath.Join(CacheDirectory(), ver))
		fmt.Fprintln(Output, utils.Fail("✖"))
		return err
	}
	fmt.Fprintln(Output, utils.Ok("✔"))

	return nil
}