Example #1
0
File: apply.go Project: ycaille/gru
// Executes the "apply" command
func execApplyCommand(c *cli.Context) error {
	if len(c.Args()) < 1 {
		return cli.NewExitError(errNoModuleName.Error(), 64)
	}

	L := lua.NewState()
	defer L.Close()
	config := &catalog.Config{
		Module:   c.Args()[0],
		DryRun:   c.Bool("dry-run"),
		Logger:   resource.DefaultLogger,
		SiteRepo: c.String("siterepo"),
		L:        L,
	}

	katalog := catalog.New(config)
	if err := katalog.Load(); err != nil {
		if err != nil {
			return cli.NewExitError(err.Error(), 1)
		}
	}

	if err := katalog.Run(); err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	return nil
}
Example #2
0
// ProjectDelete deletes services.
func ProjectDelete(p project.APIProject, c *cli.Context) error {
	options := options.Delete{
		RemoveVolume: c.Bool("v"),
	}
	if !c.Bool("force") {
		stoppedContainers, err := p.Containers(context.Background(), project.Filter{
			State: project.Stopped,
		}, c.Args()...)
		if err != nil {
			return cli.NewExitError(err.Error(), 1)
		}
		if len(stoppedContainers) == 0 {
			fmt.Println("No stopped containers")
			return nil
		}
		fmt.Printf("Going to remove %v\nAre you sure? [yN]\n", strings.Join(stoppedContainers, ", "))
		var answer string
		_, err = fmt.Scanln(&answer)
		if err != nil {
			return cli.NewExitError(err.Error(), 1)
		}
		if answer != "y" && answer != "Y" {
			return nil
		}
	}
	err := p.Delete(context.Background(), options, c.Args()...)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	return nil
}
Example #3
0
File: helpers.go Project: nlf/dlite
func statusRequest() (*VMStatus, *cli.ExitError) {
	user := getUser()
	req, err := http.NewRequest("GET", "http://127.0.0.1:1050/status", nil)
	if err != nil {
		return nil, cli.NewExitError(err.Error(), 1)
	}

	req.Header.Add("X-Username", user.Name)
	client := &http.Client{}
	res, err := client.Do(req)
	if err != nil {
		return nil, cli.NewExitError(getRequestError(err), 1)
	}

	defer res.Body.Close()
	decoder := json.NewDecoder(res.Body)
	if res.StatusCode < 200 || res.StatusCode >= 400 {
		status := VMStatusError{}
		err := decoder.Decode(&status)
		if err != nil {
			return nil, cli.NewExitError(err.Error(), 1)
		}

		return nil, cli.NewExitError(status.Message, 1)
	}

	status := VMStatus{}
	err = decoder.Decode(&status)
	if err != nil {
		return nil, cli.NewExitError(err.Error(), 1)
	}

	return &status, nil
}
Example #4
0
File: helpers.go Project: nlf/dlite
func stringRequest(action string) *cli.ExitError {
	user := getUser()
	req, err := http.NewRequest("POST", fmt.Sprintf("http://127.0.0.1:1050/%s", action), nil)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	req.Header.Add("X-Username", user.Name)
	client := &http.Client{}
	res, err := client.Do(req)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	defer res.Body.Close()
	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	code := 0
	if res.StatusCode < 200 || res.StatusCode >= 400 {
		code = 1
	}

	return cli.NewExitError(string(body), code)
}
Example #5
0
File: list.go Project: dnaeon/gru
// Executes the "list" command
func execListCommand(c *cli.Context) error {
	klient := newEtcdMinionClientFromFlags(c)

	cFlag := c.String("with-classifier")
	minions, err := parseClassifierPattern(klient, cFlag)

	// Ignore errors about missing minion directory
	if err != nil {
		if eerr, ok := err.(client.Error); !ok || eerr.Code != client.ErrorCodeKeyNotFound {
			return cli.NewExitError(err.Error(), 1)
		}
	}

	if len(minions) == 0 {
		return nil
	}

	table := uitable.New()
	table.MaxColWidth = 80
	table.AddRow("MINION", "NAME")
	for _, minion := range minions {
		name, err := klient.MinionName(minion)
		if err != nil {
			return cli.NewExitError(err.Error(), 1)
		}

		table.AddRow(minion, name)
	}

	fmt.Println(table)

	return nil
}
Example #6
0
// Executes the "lastseen" command
func execLastseenCommand(c *cli.Context) error {
	client := newEtcdMinionClientFromFlags(c)

	cFlag := c.String("with-classifier")
	minions, err := parseClassifierPattern(client, cFlag)

	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	table := uitable.New()
	table.MaxColWidth = 80
	table.AddRow("MINION", "LASTSEEN")
	for _, minion := range minions {
		lastseen, err := client.MinionLastseen(minion)
		if err != nil {
			return cli.NewExitError(err.Error(), 1)
		}

		table.AddRow(minion, time.Unix(lastseen, 0))
	}

	fmt.Println(table)

	return nil
}
Example #7
0
File: queue.go Project: dnaeon/gru
// Executes the "queue" command
func execQueueCommand(c *cli.Context) error {
	if len(c.Args()) == 0 {
		return cli.NewExitError(errNoMinion.Error(), 64)
	}

	minion := uuid.Parse(c.Args()[0])
	if minion == nil {
		return cli.NewExitError(errInvalidUUID.Error(), 64)
	}

	klient := newEtcdMinionClientFromFlags(c)

	// Ignore errors about missing queue directory
	queue, err := klient.MinionTaskQueue(minion)
	if err != nil {
		if eerr, ok := err.(client.Error); !ok || eerr.Code != client.ErrorCodeKeyNotFound {
			return cli.NewExitError(err.Error(), 1)
		}
	}

	if len(queue) == 0 {
		return nil
	}

	table := uitable.New()
	table.MaxColWidth = 40
	table.AddRow("TASK", "STATE", "RECEIVED")
	for _, t := range queue {
		table.AddRow(t.ID, t.State, time.Unix(t.TimeReceived, 0))
	}

	fmt.Println(table)

	return nil
}
Example #8
0
func TestProcess(t *testing.T) {
	passwd := "pass"
	url1, _ := soap.ParseURL("127.0.0.1")
	url2, _ := soap.ParseURL("root:@127.0.0.1")
	url3, _ := soap.ParseURL("line:[email protected]")
	url4, _ := soap.ParseURL("root:[email protected]")
	result, _ := url.Parse("https://*****:*****@127.0.0.1/sdk")
	passEmpty := ""
	result1, _ := url.Parse("https://root:@127.0.0.1/sdk")
	tests := []struct {
		URL      *url.URL
		User     string
		Password *string

		err    error
		result *url.URL
	}{
		{nil, "", nil, cli.NewExitError("--target argument must be specified", 1), nil},
		{nil, "root", nil, cli.NewExitError("--target argument must be specified", 1), nil},
		{nil, "root", &passwd, cli.NewExitError("--target argument must be specified", 1), nil},
		{url1, "root", &passwd, nil, result},
		{url4, "", nil, nil, result},
		{url3, "root", &passwd, nil, result},
		{url2, "", &passwd, nil, result},
		{url1, "root", &passEmpty, nil, result1},
	}

	for _, test := range tests {
		target := NewTarget()
		target.URL = test.URL
		target.User = test.User
		target.Password = test.Password
		if target.URL != nil {
			t.Logf("Before processing, url: %s", target.URL.String())
		}
		e := target.HasCredentials()
		if test.err != nil {
			if e == nil {
				t.Errorf("Empty error")
			}
			if e.Error() != test.err.Error() {
				t.Errorf("Unexpected error message: %s", e.Error())
			}
		} else if e != nil {
			t.Errorf("Unexpected error %s", e.Error())
		} else {
			if target.URL != test.URL {
				t.Errorf("unexpected result url: %s", target.URL.String())
			} else {
				t.Logf("result url: %s", target.URL.String())
			}
		}
	}
}
Example #9
0
File: helpers.go Project: nlf/dlite
func ensureRoot() *cli.ExitError {
	if uid := os.Geteuid(); uid != 0 {
		return cli.NewExitError("This command requires sudo", 1)
	}

	if uid := os.Getenv("SUDO_UID"); uid == "" {
		return cli.NewExitError("This command requires sudo", 1)
	}

	return nil
}
Example #10
0
File: hdp.go Project: vincer/hdp
func validate(ip string, port int, c *cli.Context) *cli.ExitError {
	if strings.TrimSpace(ip) == "" {
		return cli.NewExitError("IP address is required. `hdp -h` for usage info.", 1)
	}
	if net.ParseIP(ip) == nil {
		return cli.NewExitError("Invalid IP address", 1)
	}
	if port < 0 || port > 65535 {
		return cli.NewExitError("Invalid port", 2)
	}
	return nil
}
Example #11
0
File: helpers.go Project: nlf/dlite
func runCleanup(hostname, home string) *cli.ExitError {
	exe, err := osext.Executable()
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	output, err := exec.Command("sudo", exe, "cleanup", "--hostname", hostname, "--home", home).Output()
	code := 0
	if err != nil {
		code = 1
	}
	return cli.NewExitError(string(output), code)
}
Example #12
0
File: serve.go Project: dnaeon/gru
// Executes the "serve" command
func execServeCommand(c *cli.Context) error {
	name, err := os.Hostname()
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	concurrency := c.Int("concurrency")
	if concurrency < 0 {
		concurrency = runtime.NumCPU()
	}

	if c.String("siterepo") == "" {
		return cli.NewExitError(errNoSiteRepo.Error(), 64)
	}

	nameFlag := c.String("name")
	if nameFlag != "" {
		name = nameFlag
	}

	etcdCfg := etcdConfigFromFlags(c)
	minionCfg := &minion.EtcdMinionConfig{
		Concurrency: concurrency,
		Name:        name,
		SiteRepo:    c.String("siterepo"),
		EtcdConfig:  etcdCfg,
	}

	m, err := minion.NewEtcdMinion(minionCfg)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	// Channel on which the shutdown signal is sent
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

	// Start minion
	err = m.Serve()
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	// Block until a shutdown signal is received
	<-quit
	m.Stop()

	return nil
}
Example #13
0
// ProjectPull pulls images for services.
func ProjectPull(p project.APIProject, c *cli.Context) error {
	err := p.Pull(context.Background(), c.Args()...)
	if err != nil && !c.Bool("ignore-pull-failures") {
		return cli.NewExitError(err.Error(), 1)
	}
	return nil
}
Example #14
0
// ProjectKill forces stop service containers.
func ProjectKill(p project.APIProject, c *cli.Context) error {
	err := p.Kill(context.Background(), c.String("signal"), c.Args()...)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	return nil
}
Example #15
0
// ProjectStop stops all services.
func ProjectStop(p project.APIProject, c *cli.Context) error {
	err := p.Stop(context.Background(), c.Int("timeout"), c.Args()...)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	return nil
}
Example #16
0
// ProjectUnpause unpauses service containers.
func ProjectUnpause(p project.APIProject, c *cli.Context) error {
	err := p.Unpause(context.Background(), c.Args()...)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	return nil
}
Example #17
0
// ProjectLog gets services logs.
func ProjectLog(p project.APIProject, c *cli.Context) error {
	err := p.Log(context.Background(), c.Bool("follow"), c.Args()...)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	return nil
}
Example #18
0
// ProjectPort prints the public port for a port binding.
func ProjectPort(p project.APIProject, c *cli.Context) error {
	if len(c.Args()) != 2 {
		return cli.NewExitError("Please pass arguments in the form: SERVICE PORT", 1)
	}

	index := c.Int("index")
	protocol := c.String("protocol")
	serviceName := c.Args()[0]
	privatePort := c.Args()[1]

	port, err := p.Port(context.Background(), index, protocol, serviceName, privatePort)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	fmt.Println(port)
	return nil
}
Example #19
0
File: graph.go Project: dnaeon/gru
// Executes the "graph" command
func execGraphCommand(c *cli.Context) error {
	if len(c.Args()) < 1 {
		return cli.NewExitError(errNoModuleName.Error(), 64)
	}

	L := lua.NewState()
	defer L.Close()

	module := c.Args()[0]
	config := &catalog.Config{
		Module:   module,
		DryRun:   true,
		Logger:   log.New(os.Stdout, "", log.LstdFlags),
		SiteRepo: c.String("siterepo"),
		L:        L,
	}

	katalog := catalog.New(config)
	resource.LuaRegisterBuiltin(L)
	if err := L.DoFile(module); err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	collection, err := resource.CreateCollection(katalog.Unsorted)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	g, err := collection.DependencyGraph()
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	g.AsDot("resources", os.Stdout)
	g.Reversed().AsDot("reversed", os.Stdout)

	sorted, err := g.Sort()
	if err == graph.ErrCircularDependency {
		circular := graph.New()
		circular.AddNode(sorted...)
		circular.AsDot("circular", os.Stdout)
		return cli.NewExitError(graph.ErrCircularDependency.Error(), 1)
	}

	return nil
}
Example #20
0
File: create.go Project: vmware/vic
func (c *Create) processProxies() error {
	var err error
	if c.httpProxy != "" {
		c.HTTPProxy, err = url.Parse(c.httpProxy)
		if err != nil || c.HTTPProxy.Host == "" || c.HTTPProxy.Scheme != "http" {
			return cli.NewExitError(fmt.Sprintf("Could not parse HTTP proxy - expected format http://fqnd_or_ip:port: %s", c.httpProxy), 1)
		}
	}

	if c.httpsProxy != "" {
		c.HTTPSProxy, err = url.Parse(c.httpsProxy)
		if err != nil || c.HTTPSProxy.Host == "" || c.HTTPSProxy.Scheme != "https" {
			return cli.NewExitError(fmt.Sprintf("Could not parse HTTPS proxy - expected format https://fqnd_or_ip:port: %s", c.httpsProxy), 1)
		}
	}

	return nil
}
Example #21
0
// ProjectPs lists the containers.
func ProjectPs(p project.APIProject, c *cli.Context) error {
	qFlag := c.Bool("q")
	allInfo, err := p.Ps(context.Background(), qFlag, c.Args()...)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	os.Stdout.WriteString(allInfo.String(!qFlag))
	return nil
}
Example #22
0
// ProjectRun runs a given command within a service's container.
func ProjectRun(p project.APIProject, c *cli.Context) error {
	if len(c.Args()) == 0 {
		logrus.Fatal("No service specified")
	}

	serviceName := c.Args()[0]
	commandParts := c.Args()[1:]

	options := options.Run{
		Detached: c.Bool("d"),
	}

	exitCode, err := p.Run(context.Background(), serviceName, commandParts, options)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	return cli.NewExitError("", exitCode)
}
Example #23
0
File: info.go Project: dnaeon/gru
// Executes the "info" command
func execInfoCommand(c *cli.Context) error {
	if len(c.Args()) == 0 {
		return cli.NewExitError(errNoMinion.Error(), 64)
	}

	arg := c.Args()[0]
	minion := uuid.Parse(arg)
	if minion == nil {
		return cli.NewExitError(errInvalidUUID.Error(), 64)
	}

	klient := newEtcdMinionClientFromFlags(c)
	name, err := klient.MinionName(minion)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	lastseen, err := klient.MinionLastseen(minion)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	// Ignore errors about missing queue directory
	taskQueue, err := klient.MinionTaskQueue(minion)
	if err != nil {
		if eerr, ok := err.(client.Error); !ok || eerr.Code != client.ErrorCodeKeyNotFound {
			return cli.NewExitError(err.Error(), 1)
		}
	}

	// Ignore errors about missing log directory
	taskLog, err := klient.MinionTaskLog(minion)
	if err != nil {
		if eerr, ok := err.(client.Error); !ok || eerr.Code != client.ErrorCodeKeyNotFound {
			return cli.NewExitError(err.Error(), 1)
		}
	}

	// Ignore errors about missing classifier directory
	classifierKeys, err := klient.MinionClassifierKeys(minion)
	if err != nil {
		if eerr, ok := err.(client.Error); !ok || eerr.Code != client.ErrorCodeKeyNotFound {
			return cli.NewExitError(err.Error(), 1)
		}
	}

	table := uitable.New()
	table.MaxColWidth = 80
	table.AddRow("Minion:", minion)
	table.AddRow("Name:", name)
	table.AddRow("Lastseen:", time.Unix(lastseen, 0))
	table.AddRow("Queue:", len(taskQueue))
	table.AddRow("Log:", len(taskLog))
	table.AddRow("Classifiers:", len(classifierKeys))

	fmt.Println(table)

	return nil
}
Example #24
0
File: create.go Project: vmware/vic
func (c *Create) processBridgeNetwork() error {
	// bridge network params
	var err error

	_, c.Data.BridgeIPRange, err = net.ParseCIDR(c.BridgeIPRange)
	if err != nil {
		return cli.NewExitError(fmt.Sprintf("Error parsing bridge network ip range: %s. Range must be in CIDR format, e.g., 172.16.0.0/12", err), 1)
	}
	return nil
}
Example #25
0
// ProjectDelete deletes services.
func ProjectDelete(p project.APIProject, c *cli.Context) error {
	options := options.Delete{
		RemoveVolume: c.Bool("v"),
	}
	err := p.Delete(context.Background(), options, c.Args()...)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	return nil
}
Example #26
0
func (c *Create) processParams() error {
	defer trace.End(trace.Begin(""))

	if err := c.HasCredentials(); err != nil {
		return err
	}

	if c.cert != "" && c.key == "" {
		return cli.NewExitError("key cert should be specified at the same time", 1)
	}
	if c.cert == "" && c.key != "" {
		return cli.NewExitError("key cert should be specified at the same time", 1)
	}

	if c.ExternalNetworkName == "" {
		c.ExternalNetworkName = "VM Network"
	}

	if c.BridgeNetworkName == "" {
		c.BridgeNetworkName = c.DisplayName
	}

	if len(c.DisplayName) > MaxDisplayNameLen {
		return cli.NewExitError(fmt.Sprintf("Display name %s exceeds the permitted 31 characters limit. Please use a shorter -name parameter", c.DisplayName), 1)
	}

	if err := c.processContainerNetworks(); err != nil {
		return err
	}

	if err := c.processVolumeStores(); err != nil {
		return errors.Errorf("Error occurred while processing volume stores: %s", err)
	}

	//	if err := c.processReservations(); err != nil {
	//		return err
	//	}
	// FIXME: add parameters for these configurations
	c.osType = "linux"

	c.Insecure = true
	return nil
}
Example #27
0
// ProjectConfig validates and print the compose file.
func ProjectConfig(p project.APIProject, c *cli.Context) error {
	yaml, err := p.Config()
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	if !c.Bool("quiet") {
		fmt.Println(yaml)
	}
	return nil
}
Example #28
0
File: create.go Project: vmware/vic
func (c *Create) processInsecureRegistries() error {
	for _, registry := range c.insecureRegistries {
		url, err := url.Parse(registry)
		if err != nil {
			return cli.NewExitError(fmt.Sprintf("%s is an invalid format for registry url", registry), 1)
		}
		c.InsecureRegistries = append(c.InsecureRegistries, *url)
	}

	return nil
}
Example #29
0
func runAgent(c *cli.Context) error {
	a := agent.Agent{
		DockerAddress: c.String("docker"),
		FusisAddress:  c.String("fusis-addr"),
		LabelFilter:   c.String("label-filter"),
		Interval:      c.Duration("interval"),
	}
	if a.FusisAddress == "" {
		return cli.NewExitError("Parameter --fusis-addr is mandatory", 1)
	}
	err := a.Init()
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	handleSignals(&a)
	log.Print("Running agent...")
	a.Start()
	a.Wait()
	return nil
}
Example #30
0
func Initialize(c *cli.Context) error {

	// read seed.json and send the data to the db
	reader, err := os.Open(c.String("seed"))
	if err != nil {
		return cli.NewExitError("Error opening seed.json: "+err.Error(), 1)
	}

	seedData, err := ioutil.ReadAll(reader)
	if err != nil {
		return cli.NewExitError("Error reading seed.json: "+err.Error(), 1)
	}

	var src = json.RawMessage(seedData)

	// generate a random string for the secret
	randomBytes := make([]byte, 48)

	_, err = rand.Read(randomBytes)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}

	newAppSecret := base64.RawURLEncoding.EncodeToString(randomBytes)
	conf := struct{ AuthSecret string }{newAppSecret}

	if err := patch(c, "config", &conf, nil); err != nil {
		return cli.NewExitError("Error from server: "+err.Error(), 1)
	}

	fmt.Println("Add this secret to your environment -- it won't be available again.")
	fmt.Printf("export ORI_APP_SECRET=%s\n", newAppSecret)
	c.GlobalSet("secret", newAppSecret)

	// send to admin
	if err = post(c, "load", &src, nil); err != nil {
		return err
	}
	return nil

}