本文整理汇总了Golang中github.com/cloudfoundry/cli/flags.FlagContext.Int方法的典型用法代码示例。如果您正苦于以下问题:Golang FlagContext.Int方法的具体用法?Golang FlagContext.Int怎么用?Golang FlagContext.Int使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类github.com/cloudfoundry/cli/flags.FlagContext
的用法示例。
在下文中一共展示了FlagContext.Int方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: Execute
func (cmd *CreateQuota) Execute(context flags.FlagContext) {
name := context.Args()[0]
cmd.ui.Say(T("Creating quota {{.QuotaName}} as {{.Username}}...", map[string]interface{}{
"QuotaName": terminal.EntityNameColor(name),
"Username": terminal.EntityNameColor(cmd.config.Username()),
}))
quota := models.QuotaFields{
Name: name,
}
memoryLimit := context.String("m")
if memoryLimit != "" {
parsedMemory, err := formatters.ToMegabytes(memoryLimit)
if err != nil {
cmd.ui.Failed(T("Invalid memory limit: {{.MemoryLimit}}\n{{.Err}}", map[string]interface{}{"MemoryLimit": memoryLimit, "Err": err}))
}
quota.MemoryLimit = parsedMemory
}
instanceMemoryLimit := context.String("i")
if instanceMemoryLimit == "-1" || instanceMemoryLimit == "" {
quota.InstanceMemoryLimit = -1
} else {
parsedMemory, errr := formatters.ToMegabytes(instanceMemoryLimit)
if errr != nil {
cmd.ui.Failed(T("Invalid instance memory limit: {{.MemoryLimit}}\n{{.Err}}", map[string]interface{}{"MemoryLimit": instanceMemoryLimit, "Err": errr}))
}
quota.InstanceMemoryLimit = parsedMemory
}
if context.IsSet("r") {
quota.RoutesLimit = context.Int("r")
}
if context.IsSet("s") {
quota.ServicesLimit = context.Int("s")
}
if context.IsSet("allow-paid-service-plans") {
quota.NonBasicServicesAllowed = true
}
err := cmd.quotaRepo.Create(quota)
httpErr, ok := err.(errors.HttpError)
if ok && httpErr.ErrorCode() == errors.QUOTA_EXISTS {
cmd.ui.Ok()
cmd.ui.Warn(T("Quota Definition {{.QuotaName}} already exists", map[string]interface{}{"QuotaName": quota.Name}))
return
}
if err != nil {
cmd.ui.Failed(err.Error())
}
cmd.ui.Ok()
}
示例2: Requirements
func (cmd *SSH) Requirements(requirementsFactory requirements.Factory, fc flags.FlagContext) []requirements.Requirement {
if len(fc.Args()) != 1 {
cmd.ui.Failed(T("Incorrect Usage. Requires APP_NAME as argument") + "\n\n" + commandregistry.Commands.CommandUsage("ssh"))
}
if fc.IsSet("i") && fc.Int("i") < 0 {
cmd.ui.Failed(fmt.Sprintf(T("Incorrect Usage:")+" %s\n\n%s", T("Value for flag 'app-instance-index' cannot be negative"), commandregistry.Commands.CommandUsage("ssh")))
}
var err error
cmd.opts, err = options.NewSSHOptions(fc)
if err != nil {
cmd.ui.Failed(fmt.Sprintf(T("Incorrect Usage:")+" %s\n\n%s", err.Error(), commandregistry.Commands.CommandUsage("ssh")))
}
cmd.appReq = requirementsFactory.NewApplicationRequirement(cmd.opts.AppName)
reqs := []requirements.Requirement{
requirementsFactory.NewLoginRequirement(),
requirementsFactory.NewTargetedSpaceRequirement(),
cmd.appReq,
}
return reqs
}
示例3: NewSSHOptions
func NewSSHOptions(fc flags.FlagContext) (*SSHOptions, error) {
sshOptions := &SSHOptions{}
sshOptions.AppName = fc.Args()[0]
sshOptions.Index = uint(fc.Int("i"))
sshOptions.SkipHostValidation = fc.Bool("k")
sshOptions.SkipRemoteExecution = fc.Bool("N")
sshOptions.Command = fc.StringSlice("c")
if fc.IsSet("L") {
for _, arg := range fc.StringSlice("L") {
forwardSpec, err := sshOptions.parseLocalForwardingSpec(arg)
if err != nil {
return sshOptions, err
}
sshOptions.ForwardSpecs = append(sshOptions.ForwardSpecs, *forwardSpec)
}
}
if fc.IsSet("t") && fc.Bool("t") {
sshOptions.TerminalRequest = REQUEST_TTY_YES
}
if fc.IsSet("tt") && fc.Bool("tt") {
sshOptions.TerminalRequest = REQUEST_TTY_FORCE
}
if fc.Bool("T") {
sshOptions.TerminalRequest = REQUEST_TTY_NO
}
return sshOptions, nil
}
示例4: Execute
func (cmd *MapRoute) Execute(c flags.FlagContext) {
hostName := c.String("n")
path := c.String("path")
domain := cmd.domainReq.GetDomain()
app := cmd.appReq.GetApplication()
port := c.Int("port")
randomPort := c.Bool("random-port")
route, apiErr := cmd.routeCreator.CreateRoute(hostName, path, port, randomPort, domain, cmd.config.SpaceFields())
if apiErr != nil {
cmd.ui.Failed(T("Error resolving route:\n{{.Err}}", map[string]interface{}{"Err": apiErr.Error()}))
}
cmd.ui.Say(T("Adding route {{.URL}} to app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...",
map[string]interface{}{
"URL": terminal.EntityNameColor(route.URL()),
"AppName": terminal.EntityNameColor(app.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
apiErr = cmd.routeRepo.Bind(route.GUID, app.GUID)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
}
示例5: Execute
func (cmd *ConfigCommands) Execute(context flags.FlagContext) {
if !context.IsSet("trace") && !context.IsSet("async-timeout") && !context.IsSet("color") && !context.IsSet("locale") {
cmd.ui.Failed(T("Incorrect Usage\n\n") + command_registry.Commands.CommandUsage("config"))
return
}
if context.IsSet("async-timeout") {
asyncTimeout := context.Int("async-timeout")
if asyncTimeout < 0 {
cmd.ui.Failed(T("Incorrect Usage\n\n") + command_registry.Commands.CommandUsage("config"))
}
cmd.config.SetAsyncTimeout(uint(asyncTimeout))
}
if context.IsSet("trace") {
cmd.config.SetTrace(context.String("trace"))
}
if context.IsSet("color") {
value := context.String("color")
switch value {
case "true":
cmd.config.SetColorEnabled("true")
case "false":
cmd.config.SetColorEnabled("false")
default:
cmd.ui.Failed(T("Incorrect Usage\n\n") + command_registry.Commands.CommandUsage("config"))
}
}
if context.IsSet("locale") {
locale := context.String("locale")
if locale == "CLEAR" {
cmd.config.SetLocale("")
return
}
foundLocale := false
for _, value := range SUPPORTED_LOCALES {
if value == locale {
cmd.config.SetLocale(locale)
foundLocale = true
break
}
}
if !foundLocale {
cmd.ui.Say(fmt.Sprintf("Could not find locale %s. The known locales are:", locale))
cmd.ui.Say("")
for _, locale := range SUPPORTED_LOCALES {
cmd.ui.Say(locale)
}
}
}
}
示例6: Execute
func (cmd *ConfigCommands) Execute(context flags.FlagContext) {
if !context.IsSet("trace") && !context.IsSet("async-timeout") && !context.IsSet("color") && !context.IsSet("locale") {
cmd.ui.Failed(T("Incorrect Usage") + "\n\n" + command_registry.Commands.CommandUsage("config"))
return
}
if context.IsSet("async-timeout") {
asyncTimeout := context.Int("async-timeout")
if asyncTimeout < 0 {
cmd.ui.Failed(T("Incorrect Usage") + "\n\n" + command_registry.Commands.CommandUsage("config"))
}
cmd.config.SetAsyncTimeout(uint(asyncTimeout))
}
if context.IsSet("trace") {
cmd.config.SetTrace(context.String("trace"))
}
if context.IsSet("color") {
value := context.String("color")
switch value {
case "true":
cmd.config.SetColorEnabled("true")
case "false":
cmd.config.SetColorEnabled("false")
default:
cmd.ui.Failed(T("Incorrect Usage") + "\n\n" + command_registry.Commands.CommandUsage("config"))
}
}
if context.IsSet("locale") {
locale := context.String("locale")
if locale == "CLEAR" {
cmd.config.SetLocale("")
return
}
if IsSupportedLocale(locale) {
cmd.config.SetLocale(locale)
return
}
unsupportedLocaleMessage := T("Could not find locale '{{.UnsupportedLocale}}'. The known locales are:\n", map[string]interface{}{
"UnsupportedLocale": locale,
})
supportedLocales := SupportedLocales()
sort.Strings(supportedLocales)
for i := range supportedLocales {
unsupportedLocaleMessage = unsupportedLocaleMessage + "\n" + supportedLocales[i]
}
cmd.ui.Failed(unsupportedLocaleMessage)
}
}
示例7: Execute
func (cmd *ConfigCommands) Execute(context flags.FlagContext) {
if !context.IsSet("trace") && !context.IsSet("async-timeout") && !context.IsSet("color") && !context.IsSet("locale") {
cmd.ui.Failed(T("Incorrect Usage\n\n") + command_registry.Commands.CommandUsage("config"))
return
}
if context.IsSet("async-timeout") {
asyncTimeout := context.Int("async-timeout")
if asyncTimeout < 0 {
cmd.ui.Failed(T("Incorrect Usage\n\n") + command_registry.Commands.CommandUsage("config"))
}
cmd.config.SetAsyncTimeout(uint(asyncTimeout))
}
if context.IsSet("trace") {
cmd.config.SetTrace(context.String("trace"))
}
if context.IsSet("color") {
value := context.String("color")
switch value {
case "true":
cmd.config.SetColorEnabled("true")
case "false":
cmd.config.SetColorEnabled("false")
default:
cmd.ui.Failed(T("Incorrect Usage\n\n") + command_registry.Commands.CommandUsage("config"))
}
}
if context.IsSet("locale") {
locale := context.String("locale")
if locale == "CLEAR" {
cmd.config.SetLocale("")
return
}
if IsSupportedLocale(locale) {
cmd.config.SetLocale(locale)
return
}
cmd.ui.Say(fmt.Sprintf("Could not find locale '%s'. The known locales are:", locale))
cmd.ui.Say("")
supportedLocales := SupportedLocales()
sort.Strings(supportedLocales)
for i := range supportedLocales {
cmd.ui.Say(supportedLocales[i])
}
}
}
示例8: Execute
func (cmd *CreateRoute) Execute(c flags.FlagContext) {
hostName := c.String("n")
space := cmd.spaceReq.GetSpace()
domain := cmd.domainReq.GetDomain()
path := c.String("path")
port := c.Int("port")
randomPort := c.Bool("random-port")
_, err := cmd.CreateRoute(hostName, path, port, randomPort, domain, space.SpaceFields)
if err != nil {
cmd.ui.Failed(err.Error())
}
}
示例9: Execute
func (cmd *Files) Execute(c flags.FlagContext) {
app := cmd.appReq.GetApplication()
var instance int
if c.IsSet("i") {
instance = c.Int("i")
if instance < 0 {
cmd.ui.Failed(T("Invalid instance: {{.Instance}}\nInstance must be a positive integer",
map[string]interface{}{
"Instance": instance,
}))
}
if instance >= app.InstanceCount {
cmd.ui.Failed(T("Invalid instance: {{.Instance}}\nInstance must be less than {{.InstanceCount}}",
map[string]interface{}{
"Instance": instance,
"InstanceCount": app.InstanceCount,
}))
}
}
cmd.ui.Say(T("Getting files for app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...",
map[string]interface{}{
"AppName": terminal.EntityNameColor(app.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
path := "/"
if len(c.Args()) > 1 {
path = c.Args()[1]
}
list, apiErr := cmd.appFilesRepo.ListFiles(app.Guid, instance, path)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("")
if list == "" {
cmd.ui.Say("No files found")
} else {
cmd.ui.Say("%s", list)
}
}
示例10: Execute
func (cmd *DeleteRoute) Execute(c flags.FlagContext) {
host := c.String("n")
path := c.String("path")
domainName := c.Args()[0]
port := c.Int("port")
url := (&models.RoutePresenter{
Host: host,
Domain: domainName,
Path: path,
Port: port,
}).URL()
if !c.Bool("f") {
if !cmd.ui.ConfirmDelete("route", url) {
return
}
}
cmd.ui.Say(T("Deleting route {{.URL}}...", map[string]interface{}{"URL": terminal.EntityNameColor(url)}))
domain := cmd.domainReq.GetDomain()
route, err := cmd.routeRepo.Find(host, domain, path, port)
if err != nil {
if _, ok := err.(*errors.ModelNotFoundError); ok {
cmd.ui.Warn(T("Unable to delete, route '{{.URL}}' does not exist.",
map[string]interface{}{"URL": url}))
return
}
cmd.ui.Failed(err.Error())
return
}
err = cmd.routeRepo.Delete(route.GUID)
if err != nil {
cmd.ui.Failed(err.Error())
return
}
cmd.ui.Ok()
}
示例11: Execute
func (cmd *UnmapRoute) Execute(c flags.FlagContext) error {
hostName := c.String("n")
path := c.String("path")
port := c.Int("port")
domain := cmd.domainReq.GetDomain()
app := cmd.appReq.GetApplication()
route, err := cmd.routeRepo.Find(hostName, domain, path, port)
if err != nil {
return err
}
cmd.ui.Say(T("Removing route {{.URL}} from app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...",
map[string]interface{}{
"URL": terminal.EntityNameColor(route.URL()),
"AppName": terminal.EntityNameColor(app.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
var routeFound bool
for _, routeApp := range route.Apps {
if routeApp.GUID == app.GUID {
routeFound = true
err = cmd.routeRepo.Unbind(route.GUID, app.GUID)
if err != nil {
return err
}
break
}
}
cmd.ui.Ok()
if !routeFound {
cmd.ui.Warn(T("\nRoute to be unmapped is not currently mapped to the application."))
}
return nil
}
示例12: Execute
func (cmd *UpdateBuildpack) Execute(c flags.FlagContext) {
buildpack := cmd.buildpackReq.GetBuildpack()
cmd.ui.Say(T("Updating buildpack {{.BuildpackName}}...", map[string]interface{}{"BuildpackName": terminal.EntityNameColor(buildpack.Name)}))
updateBuildpack := false
if c.IsSet("i") {
position := c.Int("i")
buildpack.Position = &position
updateBuildpack = true
}
enabled := c.Bool("enable")
disabled := c.Bool("disable")
if enabled && disabled {
cmd.ui.Failed(T("Cannot specify both {{.Enabled}} and {{.Disabled}}.", map[string]interface{}{
"Enabled": "enabled",
"Disabled": "disabled",
}))
}
if enabled {
buildpack.Enabled = &enabled
updateBuildpack = true
}
if disabled {
disabled = false
buildpack.Enabled = &disabled
updateBuildpack = true
}
lock := c.Bool("lock")
unlock := c.Bool("unlock")
if lock && unlock {
cmd.ui.Failed(T("Cannot specify both lock and unlock options."))
return
}
path := c.String("p")
var dir string
var err error
if path != "" {
dir, err = filepath.Abs(path)
if err != nil {
cmd.ui.Failed(err.Error())
return
}
}
if dir != "" && (lock || unlock) {
cmd.ui.Failed(T("Cannot specify buildpack bits and lock/unlock."))
}
if lock {
buildpack.Locked = &lock
updateBuildpack = true
}
if unlock {
unlock = false
buildpack.Locked = &unlock
updateBuildpack = true
}
if updateBuildpack {
newBuildpack, apiErr := cmd.buildpackRepo.Update(buildpack)
if apiErr != nil {
cmd.ui.Failed(T("Error updating buildpack {{.Name}}\n{{.Error}}", map[string]interface{}{
"Name": terminal.EntityNameColor(buildpack.Name),
"Error": apiErr.Error(),
}))
}
buildpack = newBuildpack
}
if dir != "" {
apiErr := cmd.buildpackBitsRepo.UploadBuildpack(buildpack, dir)
if apiErr != nil {
cmd.ui.Failed(T("Error uploading buildpack {{.Name}}\n{{.Error}}", map[string]interface{}{
"Name": terminal.EntityNameColor(buildpack.Name),
"Error": apiErr.Error(),
}))
}
}
cmd.ui.Ok()
}
示例13:
Ω(fCtx.StringSlice("slice")[0]).To(Equal("value1"), "slice[0] should be 'value1'")
Ω(fCtx.StringSlice("slice")[1]).To(Equal("value2"), "slice[1] should be 'value2'")
})
It("errors when a non-boolean flag is provided without a value", func() {
err := fCtx.Parse("-name")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("No value provided for flag"))
Expect(fCtx.String("name")).To(Equal(""))
})
It("sets Int(<flag>) to return provided value when a int flag is provided", func() {
err := fCtx.Parse("--instance", "10")
Expect(err).NotTo(HaveOccurred())
Expect(fCtx.Int("instance")).To(Equal(10))
Expect(fCtx.IsSet("instance")).To(Equal(true))
Expect(fCtx.Int("non-exist-flag")).To(Equal(0))
Expect(fCtx.IsSet("non-exist-flag")).To(Equal(false))
})
It("sets Float64(<flag>) to return provided value when a float64 flag is provided", func() {
err := fCtx.Parse("-float", "10.5")
Expect(err).NotTo(HaveOccurred())
Expect(fCtx.Float64("float")).To(Equal(10.5))
Expect(fCtx.IsSet("float")).To(Equal(true))
Expect(fCtx.Float64("non-exist-flag")).To(Equal(float64(0)))
Expect(fCtx.IsSet("non-exist-flag")).To(Equal(false))
示例14: getAppParamsFromContext
func (cmd *Push) getAppParamsFromContext(c flags.FlagContext) (appParams models.AppParams) {
if len(c.Args()) > 0 {
appParams.Name = &c.Args()[0]
}
appParams.NoRoute = c.Bool("no-route")
appParams.UseRandomHostname = c.Bool("random-route")
appParams.NoHostname = c.Bool("no-hostname")
if c.String("n") != "" {
appParams.Hosts = &[]string{c.String("n")}
}
if c.String("route-path") != "" {
routePath := c.String("route-path")
appParams.RoutePath = &routePath
}
if c.String("b") != "" {
buildpack := c.String("b")
if buildpack == "null" || buildpack == "default" {
buildpack = ""
}
appParams.BuildpackUrl = &buildpack
}
if c.String("c") != "" {
command := c.String("c")
if command == "null" || command == "default" {
command = ""
}
appParams.Command = &command
}
if c.String("d") != "" {
appParams.Domains = &[]string{c.String("d")}
}
if c.IsSet("i") {
instances := c.Int("i")
if instances < 1 {
cmd.ui.Failed(T("Invalid instance count: {{.InstancesCount}}\nInstance count must be a positive integer",
map[string]interface{}{"InstancesCount": instances}))
}
appParams.InstanceCount = &instances
}
if c.String("k") != "" {
diskQuota, err := formatters.ToMegabytes(c.String("k"))
if err != nil {
cmd.ui.Failed(T("Invalid disk quota: {{.DiskQuota}}\n{{.Err}}",
map[string]interface{}{"DiskQuota": c.String("k"), "Err": err.Error()}))
}
appParams.DiskQuota = &diskQuota
}
if c.String("m") != "" {
memory, err := formatters.ToMegabytes(c.String("m"))
if err != nil {
cmd.ui.Failed(T("Invalid memory limit: {{.MemLimit}}\n{{.Err}}",
map[string]interface{}{"MemLimit": c.String("m"), "Err": err.Error()}))
}
appParams.Memory = &memory
}
if c.String("docker-image") != "" {
dockerImage := c.String("docker-image")
appParams.DockerImage = &dockerImage
}
if c.String("p") != "" {
path := c.String("p")
appParams.Path = &path
}
if c.String("s") != "" {
stackName := c.String("s")
appParams.StackName = &stackName
}
if c.String("t") != "" {
timeout, err := strconv.Atoi(c.String("t"))
if err != nil {
cmd.ui.Failed("Error: %s", fmt.Errorf(T("Invalid timeout param: {{.Timeout}}\n{{.Err}}",
map[string]interface{}{"Timeout": c.String("t"), "Err": err.Error()})))
}
appParams.HealthCheckTimeout = &timeout
}
if healthCheckType := c.String("u"); healthCheckType != "" {
if healthCheckType != "port" && healthCheckType != "none" {
cmd.ui.Failed("Error: %s", fmt.Errorf(T("Invalid health-check-type param: {{.healthCheckType}}",
map[string]interface{}{"healthCheckType": healthCheckType})))
}
appParams.HealthCheckType = &healthCheckType
}
return
//.........这里部分代码省略.........
示例15:
Expect(fc.IsSet("force")).To(BeFalse())
fc.NewBoolFlag("force", "f", "force process")
fc.Parse("--force")
Expect(fc.IsSet("force")).To(BeTrue())
Expect(fc.IsSet("f")).To(BeTrue())
Expect(fc.Bool("force")).To(BeTrue())
Expect(fc.Bool("f")).To(BeTrue())
})
})
Describe("NewIntFlag()", func() {
It("init the flag context with a new int flagset", func() {
fc.Parse("-i", "5")
Expect(fc.IsSet("i")).To(BeFalse())
Expect(fc.Int("i")).To(Equal(0))
fc.NewIntFlag("i", "i2", "setting new int flag")
fc.Parse("-i", "5")
Expect(fc.IsSet("i")).To(BeTrue())
Expect(fc.IsSet("i2")).To(BeTrue())
Expect(fc.Int("i")).To(Equal(5))
Expect(fc.Int("i2")).To(Equal(5))
})
})
Describe("NewIntFlagWithDefault()", func() {
It("init the flag context with a new int flagset with default value", func() {
fc.Parse("-i", "5")
Expect(fc.IsSet("i")).To(BeFalse())
Expect(fc.Int("i")).To(Equal(0))