Golang Command.Name方法代码示例

func fwk_run_cmd_build(cmd *commander.Command, args []string) error {
	var err error
	n := "fwk-app-" + cmd.Name()

	fnames := make([]string, 0, len(args))
	for _, arg := range args {
		if arg == "" {
			continue
		}
		if arg[0] == '-' {
			continue
		}
		fnames = append(fnames, arg)
	}

	if len(fnames) <= 0 {
		return fmt.Errorf("%s: you need to give a list of files or a directory", n)
	}

	bldr, err := builder.NewBuilder(fnames...)
	if err != nil {
		return err
	}

	if o := cmd.Flag.Lookup("o").Value.Get().(string); o != "" {
		bldr.Name = o
	}

	err = bldr.Build()
	if err != nil {
		return err
	}

	return err
}

func hwaf_run_cmd_pmgr_get(cmd *commander.Command, args []string) {
	var err error
	n := "hwaf-pmgr-" + cmd.Name()
	verbose := cmd.Flag.Lookup("v").Value.Get().(bool)

	pkguri := ""
	switch len(args) {
	case 1:
		pkguri = args[0]
	default:
		err = fmt.Errorf("%s: you need to give a package URI to install", n)
		handle_err(err)
	}

	pkguri = strings.Replace(pkguri, "http://", "", 1)
	pkguri = strings.Replace(pkguri, "https://", "", 1)

	if verbose {
		fmt.Printf("%s: get [%s]...\n", n, pkguri)
	}

	//manifest_url := path.Join(pkguri, "MANIFEST")

	if verbose {
		fmt.Printf("%s: get [%s]... [ok]\n", n, pkguri)
	}
}

func alto_run_cmd_vm_add(cmd *commander.Command, args []string) {
	var err error
	n := "alto-" + cmd.Name()

	vm_name := ""
	vm_id := ""
	switch len(args) {
	case 2:
		vm_name = args[0]
		vm_id = args[1]
	default:
		err = fmt.Errorf("%s: needs 2 arguments (vm-name, vm-id)\n", n)
		handle_err(err)
	}

	quiet := cmd.Flag.Lookup("q").Value.Get().(bool)
	if !quiet {
		fmt.Printf("%s: adding VM [%s] to repository...\n", n, vm_name)
	}

	err = g_ctx.AddVm(altolib.Vm{Id: vm_id, Tag: vm_name})
	handle_err(err)

	if !quiet {
		fmt.Printf("%s: adding VM [%s] to repository... [done]\n", n, vm_name)
	}
	return
}

func alto_run_cmd_box_ls(cmd *commander.Command, args []string) {
	var err error
	n := "alto-" + cmd.Name()

	switch len(args) {
	case 0:
		// ok
	default:
		err = fmt.Errorf("%s: does not take any argument\n", n)
		handle_err(err)
	}

	quiet := cmd.Flag.Lookup("q").Value.Get().(bool)

	if !quiet {
		fmt.Printf("%s: listing boxes...\n", n)
	}

	boxes := g_ctx.Boxes()
	for _, box := range boxes {
		const indent = "    "
		fmt.Printf(
			"::: box [%s] (cpus=%d ram=%dMb)\n%s%v\n%s%v\n",
			box.Id, box.Cpus, box.Ram,
			indent, box.Vm,
			indent, box.Disk,
		)
	}

	if !quiet {
		fmt.Printf("%s: listing boxes... [done]\n", n)
	}

	return
}

func hwaf_run_cmd_self_init(cmd *commander.Command, args []string) error {
	var err error
	n := "hwaf-self-" + cmd.Name()

	switch len(args) {
	case 0:
		// ok
	default:
		return fmt.Errorf("%s: does NOT take any argument", n)
	}

	verbose := cmd.Flag.Lookup("v").Value.Get().(bool)

	if verbose {
		fmt.Printf("%s...\n", n)
	}

	hwaf_root := os.Getenv("HWAF_ROOT")
	for _, dir := range []string{g_ctx.Root, hwaf_root} {
		if dir != "" {
			g_ctx.Warnf("you are trying to 'hwaf self init' while running a HWAF_ROOT-based installation\n")
			g_ctx.Warnf("this is like crossing the streams in Ghostbusters (ie: it's bad.)\n")
			g_ctx.Warnf("if you think you know what you are doing, unset HWAF_ROOT and re-run 'hwaf self init'\n")
			return fmt.Errorf("${HWAF_ROOT} was set (%s)", dir)
		}
	}

	// 'hwaf self init' is now dummied out...

	if verbose {
		fmt.Printf("%s... [ok]\n", n)
	}

	return err
}

func alto_run_cmd_vm_ls(cmd *commander.Command, args []string) {
	var err error
	n := "alto-" + cmd.Name()

	switch len(args) {
	case 0:
		// ok
	default:
		err = fmt.Errorf("%s: does not take any argument\n", n)
		handle_err(err)
	}

	quiet := cmd.Flag.Lookup("q").Value.Get().(bool)

	if !quiet {
		fmt.Printf("%s: listing VMs...\n", n)
	}

	vms := g_ctx.Vms()
	for _, vm := range vms {
		fmt.Printf("%v\n", vm)
	}

	if !quiet {
		fmt.Printf("%s: listing VMs... [done]\n", n)
	}

	return
}

func crossReleaseChanges(cmd *c.Command, args []string) {
	dev.MustFindCrowbar()
	if len(args) != 2 {
		log.Fatalf("%s takes exactly 2 release names!")
	}
	releases := new([2]dev.Release)
	// Translate command line parameters.
	// releases[0] will be the release with changes, and
	// releases[1] will be the base release.
	for i, name := range args {
		switch name {
		case "current":
			releases[i] = dev.CurrentRelease()
		case "parent":
			if i == 0 {
				log.Fatalf("parent can only be the second arg to %s\n", cmd.Name())
			}
			releases[1] = releases[0].Parent()
			if releases[1] == nil {
				log.Fatalf("%s does not have a parent release.\n", releases[0].Name())
			}
		default:
			releases[i] = dev.GetRelease(name)
		}
	}
	dev.CrossReleaseChanges(releases[0], releases[1])
}

func git_run_cmd_dl_rm(cmd *commander.Command, args []string) {
	n := "github-" + cmd.Name()
	if len(args) != 1 {
		err := fmt.Errorf("%s: needs a file-id to delete", n)
		handle_err(err)
	}
	file_id := args[0]

	repo_name := cmd.Flag.Lookup("repo").Value.Get().(string)
	if repo_name == "" {
		err := fmt.Errorf("%s: needs a github repository name to delete from", n)
		handle_err(err)
	}

	user := cmd.Flag.Lookup("u").Value.Get().(string)
	org := cmd.Flag.Lookup("org").Value.Get().(string)

	if user == "" {
		v, err := Cfg.String("go-octogit", "username")
		handle_err(err)
		user = v
	}

	password, err := Cfg.String("go-octogit", "password")
	handle_err(err)

	ghc, err := client.NewGithubClient(user, password, client.AUTH_USER_PASSWORD)
	handle_err(err)

	account := user
	// DELETE /repos/:owner/:repo/downloads/:id
	if org != "" {
		account = org
	}
	url := path.Join("repos", account, repo_name, "downloads", file_id)

	fmt.Printf("%s: deleting download id=%s from [%s/%s]...\n",
		n, file_id, account, repo_name)

	req, err := ghc.NewAPIRequest("DELETE", url, nil)
	handle_err(err)

	resp, err := ghc.RunRequest(req, new(http.Client))
	handle_err(err)

	sc := resp.RawHttpResponse.StatusCode
	switch sc {
	case 204:
		// all good
	case 404:
		err = fmt.Errorf("%s: no such file-id\n", n)
	default:
		err = fmt.Errorf("%s: request did not succeed. got (status=%d) %v\n", n, resp.RawHttpResponse.StatusCode, resp.RawHttpResponse)
	}
	handle_err(err)

	fmt.Printf("%s: deleting download id=%s from [%s/%s]... [done]\n",
		n, file_id, account, repo_name)
}

func alto_run_cmd_down(cmd *commander.Command, args []string) {
	var err error
	n := "alto-" + cmd.Name()

	switch len(args) {
	case 0:
		// ok
	default:
		err = fmt.Errorf("%s: does not take any argument\n", n)
		handle_err(err)
	}

	quiet := cmd.Flag.Lookup("q").Value.Get().(bool)
	do_kill := cmd.Flag.Lookup("kill").Value.Get().(bool)

	if !quiet {
		fmt.Printf("%s: shutting down...\n", n)
	}

	const cfg_fname = "AltoFile"
	if !path_exists(cfg_fname) {
		err = fmt.Errorf("%s: no such file [%s]. did you run 'alto init some-box-name' ?", n, cfg_fname)
		handle_err(err)
	}

	const id_fname = ".alto.id"
	if !path_exists(id_fname) {
		err = fmt.Errorf("%s: no such file [%s]. did you run 'alto up' ?", n, id_fname)
		handle_err(err)
	}

	data, err := ioutil.ReadFile(id_fname)
	handle_err(err)

	id := bytes.Trim(data, " \r\n")

	cmd_name := "stratus-shutdown-instance"
	if do_kill {
		cmd_name = "stratus-kill-instance"
	}

	ssh := exec.Command(cmd_name, string(id))
	ssh.Stdin = os.Stdin
	ssh.Stdout = os.Stdout
	ssh.Stderr = os.Stderr
	err = ssh.Run()
	handle_err(err)

	err = os.Remove(id_fname)
	handle_err(err)

	if !quiet {
		fmt.Printf("%s: shutting down... [done]\n", n)
	}
	return
}

func remoteChanges(cmd *c.Command, args []string) {
	dev.MustFindCrowbar()
	switch len(args) {
	case 0:
		dev.RemoteChanges(dev.CurrentRelease())
	case 1:
		dev.RemoteChanges(dev.GetRelease(args[0]))
	default:
		log.Fatalf("%s takes 0 or 1 release name!\n", cmd.Name())
	}
}

func hwaf_run_cmd_git_rm_submodule(cmd *commander.Command, args []string) {
	var err error
	n := "hwaf-" + cmd.Name()

	pkgdir := ""
	pkgname := ""
	switch len(args) {
	case 1:
		pkgdir = args[0]
		pkgname = args[0]
	default:
		err = fmt.Errorf("%s: needs a submodule name to remove", n)
		handle_err(err)
	}

	nocommit := cmd.Flag.Lookup("no-commit").Value.Get().(bool)

	cmtpkgdir := "src"

	if !path_exists(pkgdir) {
		cfg, err := g_ctx.LocalCfg()
		handle_err(err)
		if cfg.HasOption("hwaf-cfg", "cmtpkgs") {
			cmtpkgdir, err = cfg.String("hwaf-cfg", "cmtpkgs")
			handle_err(err)
		}
		if path_exists(filepath.Join(cmtpkgdir, pkgdir)) {
			pkgdir = filepath.Join(cmtpkgdir, pkgdir)
		}
	}

	pkgdir = os.ExpandEnv(pkgdir)
	pkgdir = filepath.Clean(pkgdir)

	if !path_exists(pkgdir) {
		err = fmt.Errorf("no such directory [%s]", pkgdir)
		handle_err(err)
	}

	if !nocommit {
		git := exec.Command("git", "add", ".gitmodules")
		err = git.Run()
		handle_err(err)

		git = exec.Command(
			"git", "commit", "-m",
			fmt.Sprintf("removed submodule [%s]", pkgname),
		)
		err = git.Run()
		handle_err(err)
	}

	handle_err(err)
}

func runPostHandleNameCmd(cmd *commander.Command, args []string) error {
	if err := validateCmdArgs(cmd, args); err != nil {
		return err
	}
	req, err := client.NewRequest("POST", "vm/"+cmd.Name()+"/"+args[0], nil)
	if err != nil {
		return err
	}
	if _, err := pp(client.Do(req)); err != nil {
		return err
	}
	return nil
}

func alto_run_cmd_status(cmd *commander.Command, args []string) {
	var err error
	n := "alto-" + cmd.Name()

	switch len(args) {
	case 0:
		// ok
	default:
		err = fmt.Errorf("%s: does not take any argument\n", n)
		handle_err(err)
	}

	quiet := cmd.Flag.Lookup("q").Value.Get().(bool)
	all_boxes := cmd.Flag.Lookup("all").Value.Get().(bool)

	if !quiet {
		fmt.Printf("%s...\n", n)
	}

	cmd_name := "stratus-describe-instance"
	id := ""
	if !all_boxes {
		const id_fname = ".alto.id"
		if !path_exists(id_fname) {
			err = fmt.Errorf("%s: no such file [%s]. did you run 'alto up' ?", n, id_fname)
			handle_err(err)
		}

		data, err := ioutil.ReadFile(id_fname)
		handle_err(err)

		id = string(bytes.Trim(data, " \r\n"))
	}

	ssh_args := []string{}
	if id != "" {
		ssh_args = append(ssh_args, id)
	}
	ssh := exec.Command(cmd_name, ssh_args...)
	ssh.Stdin = os.Stdin
	ssh.Stdout = os.Stdout
	ssh.Stderr = os.Stderr
	err = ssh.Run()
	handle_err(err)

	if !quiet {
		fmt.Printf("%s:... [done]\n", n)
	}
	return
}

func runGetListHandlesubidCmd(cmd *commander.Command, args []string) error {
	if err := validateCmdArgs(cmd, args); err != nil {
		return err
	}

	req, err := client.NewRequest("GET", "v1/"+cmd.Name()+"/list", nil)
	if err != nil {
		return err
	}
	if _, err := pp(client.Do(req)); err != nil {
		return err
	}
	return nil
}

func run_setup_auth(cmd *commander.Command, args []string) error {
	n := cmd.Name()
	// fmt.Printf("%s:  args: %v\n", n, args)
	// fmt.Printf("%s: flags: %v\n", n, cmd.Flag.NArg())

	dirname := os.ExpandEnv(ami.ConfigDir)
	if !path_exists(dirname) {
		err := os.MkdirAll(dirname, 0700)
		if err != nil {
			return err
		}
	}
	dirname = os.ExpandEnv(ami.CertDir)
	if !path_exists(dirname) {
		err := os.MkdirAll(dirname, 0700)
		if err != nil {
			return err
		}
	}

	cert_fname := cmd.Flag.Lookup("usercert").Value.Get().(string)
	if !path_exists(cert_fname) {
		fmt.Printf("%s: no such user certificate file [%s]\n", n, cert_fname)
	}
	key_fname := cmd.Flag.Lookup("userkey").Value.Get().(string)
	if !path_exists(key_fname) {
		fmt.Printf("%s: no such user key file [%s]\n", n, key_fname)
	}

	user_cert, user_key, err := ami.LoadCert(cert_fname, key_fname)
	if err != nil {
		return err
	}

	cert_fname = filepath.Join(dirname, "usercert.pem")
	err = ioutil.WriteFile(cert_fname, user_cert, 0600)
	if err != nil {
		return err
	}

	key_fname = filepath.Join(dirname, "userkey.pem")
	err = ioutil.WriteFile(key_fname, user_key, 0600)
	if err != nil {
		return err
	}

	return nil
}