func (cmd *Config) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } if c.Args().Present() { configValue, err := entity_config.ConfigValue(cmd.network, scope.Application, scope.Entity, c.Args().First()) if nil != err { error_handler.ErrorExit(err) } displayValue, err := stringRepresentation(configValue) if nil != err { error_handler.ErrorExit(err) } fmt.Println(displayValue) } else { config, err := entity_config.ConfigCurrentState(cmd.network, scope.Application, scope.Entity) if nil != err { error_handler.ErrorExit(err) } table := terminal.NewTable([]string{"Key", "Value"}) for key, value := range config { table.Add(key, fmt.Sprintf("%v", value)) } table.Print() } }
func (cmd *Restart) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } parms := c.StringSlice("param") invoke(cmd.network, scope.Application, scope.Entity, restartEffector, parms) }
func (cmd *Deploy) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } var create models.TaskSummary var err error var blueprint []byte if c.Args().First() == "" { error_handler.ErrorExit("A filename or URL or '-' must be provided as the first argument", error_handler.CLIUsageErrorExitCode) } if c.Args().First() == "-" { blueprint, err = ioutil.ReadAll(os.Stdin) if err != nil { error_handler.ErrorExit(err) } create, err = application.CreateFromBytes(cmd.network, blueprint) } else { create, err = application.Create(cmd.network, c.Args().First()) } if nil != err { if httpErr, ok := err.(net.HttpError); ok { error_handler.ErrorExit(strings.Join([]string{httpErr.Status, httpErr.Body}, "\n"), httpErr.Code) } else { error_handler.ErrorExit(err) } } table := terminal.NewTable([]string{"Id:", create.EntityId}) table.Add("Name:", create.EntityDisplayName) table.Add("Status:", create.CurrentStatus) table.Print() }
func (cmd *Login) Run(scope scope.Scope, c *cli.Context) { if !c.Args().Present() { error_handler.ErrorExit("A URL must be provided as the first argument", error_handler.CLIUsageErrorExitCode) } // If an argument was not supplied, it is set to empty string cmd.network.BrooklynUrl = c.Args().Get(0) cmd.network.BrooklynUser = c.Args().Get(1) cmd.network.BrooklynPass = c.Args().Get(2) cmd.network.SkipSslChecks = c.GlobalBool("skipSslChecks") if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } // Strip off trailing '/' from URL if present. if cmd.network.BrooklynUrl[len(cmd.network.BrooklynUrl)-1] == '/' { if len(cmd.network.BrooklynUrl) == 1 { error_handler.ErrorExit("URL must not be a single \"/\" character", error_handler.CLIUsageErrorExitCode) } cmd.network.BrooklynUrl = cmd.network.BrooklynUrl[0 : len(cmd.network.BrooklynUrl)-1] } // Prompt for password if not supplied (password is not echoed to screen if cmd.network.BrooklynUser != "" && cmd.network.BrooklynPass == "" { fmt.Print("Enter Password: "******"\n") cmd.network.BrooklynPass = string(bytePassword) } if cmd.config.Map == nil { cmd.config.Map = make(map[string]interface{}) } // now persist these credentials to the yaml file auth, ok := cmd.config.Map["auth"].(map[string]interface{}) if !ok { auth = make(map[string]interface{}) cmd.config.Map["auth"] = auth } auth[cmd.network.BrooklynUrl] = map[string]string{ "username": cmd.network.BrooklynUser, "password": cmd.network.BrooklynPass, } cmd.config.Map["target"] = cmd.network.BrooklynUrl cmd.config.Map["skipSslChecks"] = cmd.network.SkipSslChecks cmd.config.Write() loginVersion, err := version.Version(cmd.network) if nil != err { error_handler.ErrorExit(err) } fmt.Printf("Connected to Brooklyn version %s at %s\n", loginVersion.Version, cmd.network.BrooklynUrl) }
func (cmd *Spec) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } spec, err := entities.Spec(cmd.network, scope.Application, scope.Entity) if nil != err { error_handler.ErrorExit(err) } fmt.Println(spec) }
func (cmd *Policy) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } if c.Args().Present() { cmd.show(scope.Application, scope.Entity, c.Args().First()) } else { cmd.list(scope.Application, scope.Entity) } }
func (cmd *Tree) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } trees, err := application.Tree(cmd.network) if nil != err { error_handler.ErrorExit(err) } cmd.printTrees(trees, "") }
func (cmd *ActivityStreamStdout) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } activityStream, err := activities.ActivityStream(cmd.network, scope.Activity, "stdout") if nil != err { error_handler.ErrorExit(err) } fmt.Println(activityStream) }
func (cmd *Version) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } version, err := version.Version(cmd.network) if nil != err { error_handler.ErrorExit(err) } fmt.Println(version.Version) }
func (cmd *SetConfig) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } response, err := entity_config.SetConfig(cmd.network, scope.Application, scope.Entity, scope.Config, c.Args().First()) if nil != err { error_handler.ErrorExit(err) } fmt.Println(response) }
func (cmd *Delete) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } del, err := application.Delete(cmd.network, scope.Application) if nil != err { error_handler.ErrorExit(err) } fmt.Println(del) }
func (cmd *AddCatalog) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } create, err := catalog.AddCatalog(cmd.network, c.Args().First()) if nil != err { error_handler.ErrorExit(err) } fmt.Println(create) }
func (cmd *Rename) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } rename, err := entities.Rename(cmd.network, scope.Application, scope.Entity, c.Args().First()) if nil != err { error_handler.ErrorExit(err) } fmt.Println(rename) }
func (cmd *Access) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } access, err := access_control.Access(cmd.network) if nil != err { error_handler.ErrorExit(err) } fmt.Println("Location Provisioning Allowed:", access.LocationProvisioningAllowed) }
func (cmd *StopPolicy) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } spec, err := entity_policies.StopPolicy(cmd.network, scope.Application, scope.Entity, c.Args().First()) if nil != err { error_handler.ErrorExit(err) } fmt.Println(spec) }
func (cmd *AddChildren) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } activity, err := entities.AddChildren(cmd.network, scope.Application, scope.Entity, c.Args().First()) if nil != err { error_handler.ErrorExit(err) } table := terminal.NewTable([]string{"Id", "Task", "Submitted", "Status"}) table.Add(activity.Id, activity.DisplayName, time.Unix(activity.SubmitTimeUtc/1000, 0).Format(time.UnixDate), activity.CurrentStatus) table.Print() }
func (cmd *Catalog) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } catalog, err := catalog.Catalog(cmd.network) if nil != err { error_handler.ErrorExit(err) } table := terminal.NewTable([]string{"Id", "Name", "Description"}) for _, app := range catalog { table.Add(app.Id, app.Name, app.Description) } table.Print() }
func (cmd *Locations) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } locationList, err := locations.LocationList(cmd.network) if nil != err { error_handler.ErrorExit(err) } table := terminal.NewTable([]string{"Id", "Name", "Spec"}) for _, location := range locationList { table.Add(location.Id, location.Name, location.Spec) } table.Print() }
func (cmd *Entity) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } if c.NumFlags() > 0 && c.FlagNames()[0] == "children" { cmd.listentity(scope.Application, c.StringSlice("children")[0]) } else { if c.Args().Present() { cmd.show(scope.Application, c.Args().First()) } else { if scope.Entity == scope.Application { cmd.listapp(scope.Application) } else { cmd.listentity(scope.Application, scope.Entity) } } } }
func (cmd *Effector) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } effectors, err := entity_effectors.EffectorList(cmd.network, scope.Application, scope.Entity) if nil != err { error_handler.ErrorExit(err) } table := terminal.NewTable([]string{"Name", "Description", "Parameters"}) for _, effector := range effectors { var parameters []string for _, parameter := range effector.Parameters { parameters = append(parameters, parameter.Name) } if !c.Args().Present() || c.Args().First() == effector.Name { table.Add(effector.Name, effector.Description, strings.Join(parameters, ",")) } } table.Print() }
func (cmd *List) Run(scope scope.Scope, c *cli.Context) { if err := net.VerifyLoginURL(cmd.network); err != nil { error_handler.ErrorExit(err) } fmt.Printf("Unrecognised item for list, please use one of (%s)\n", listCommandsUsage) }