cb-cli: github.com/hortonworks/cb-cli/dataplane/flags Index | Files

package flags

import "github.com/hortonworks/cb-cli/dataplane/flags"

Index

Package Files

flags.go

Variables

var (
    FlDebugOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:   "debug",
            Usage:  "debug mode",
            EnvVar: "DEBUG",
        },
    }
    FlWaitOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "wait",
            Usage: "wait for the operation to finish, no argument required",
        },
    }
    FlInputJson = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "cli-input-json",
            Usage: "user provided file with json content",
        },
    }
    FlOutputOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:   "output",
            Usage:  "supported formats: json, yaml, table (default: \"json\")",
            EnvVar: "CB_OUT_FORMAT",
        },
    }
    FlProfileOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:   "profile",
            Usage:  "selects a config profile to use",
            EnvVar: "CB_PROFILE",
        },
    }
    FlForceOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "force",
            Usage: "force the operation",
        },
    }
    FlServerOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:   "server",
            Usage:  "server address",
            EnvVar: "CB_SERVER_ADDRESS",
        },
    }
    FlServerRequired = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:   "server",
            Usage:  "server address",
            EnvVar: "CB_SERVER_ADDRESS",
        },
    }
    FlName = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "name",
            Usage: "name of resource",
        },
    }
    FlNames = StringSliceFlag{
        RequiredFlag: REQUIRED,
        StringSliceFlag: cli.StringSliceFlag{
            Name:  "names",
            Usage: "names of the resources",
        },
    }
    FlNameOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "name",
            Usage: "name of resource",
        },
    }
    FlClusterToUpgrade = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "cluster",
            Usage: "cluster to upgrade",
        },
    }
    FlDescriptionOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "description",
            Usage: "description of resource",
        },
    }
    FlDlOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "datalake",
            Usage: "marks the blueprint with Data Lake Ready tag",
        },
    }
    FlRoleARN = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "role-arn",
        },
    }
    FlAccessKey = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "access-key",
        },
    }
    FlSecretKey = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "secret-key",
        },
    }
    FlProjectId = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "project-id",
        },
    }
    FlServiceAccountId = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "service-account-id",
        },
    }
    FlServiceAccountPrivateKeyFile = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "service-account-private-key-file",
        },
    }
    FlServiceAccountJsonFile = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "service-account-json-file",
        },
    }
    FlTenantUser = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "tenant-user",
        },
    }
    FlTenantPassword = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "tenant-password",
        },
    }
    FlTenantName = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "tenant-name",
        },
    }
    FlEndpoint = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "endpoint",
        },
    }
    FlKeystoneScopeOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name: "keystone-scope",
        },
    }
    FlUserDomain = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "user-domain",
        },
    }
    FlProjectDomainNameOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name: "project-domain-name",
        },
    }
    FlDomainNameOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name: "domain-name",
        },
    }
    FlProjectNameOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name: "project-name",
        },
    }
    FlFacingOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name: "facing",
        },
    }
    FlSubscriptionId = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "subscription-id",
        },
    }
    FlTenantId = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "tenant-id",
        },
    }
    FlAppId = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "app-id",
        },
    }
    FlAppPassword = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name: "app-password",
        },
    }
    FlFile = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "file",
            Usage: "location of the input JSON file",
        },
    }
    FlOutputFile = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "file",
            Usage: "location of the generated output file",
        },
    }
    FlURL = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "url",
            Usage: "URL location of the input JSON file",
        },
    }
    FlBlueprintName = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "blueprint-name",
            Usage: "name of the blueprint",
        },
    }
    FlBlueprintNameOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "blueprint-name",
            Usage: "name of the blueprint",
        },
    }
    FlBlueprintFileOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "blueprint-file",
            Usage: "location of the blueprint file",
        },
    }
    FlCloudStorageBaseLocationOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "cloud-storage-base-location",
            Usage: "specifies the base location on any kind of cloud storage",
        },
    }
    FlCloudStorageInstanceProfileOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "cloud-storage-aws-instance-profile",
            Usage: "in case of AWS storage it specifies the instanceProfile",
        },
    }
    FlCloudStorageTypeOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "cloud-storage",
            Usage: "type of the cloud storage [wasb/WASB, adls-gen1/ADLS-GEN1, s3/S3, gcs/GCS, adls-gen2/ADLS-GEN2]",
        },
    }
    FlDefaultEncryptionOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "with-default-encryption",
            Usage: "default encryption for AWS instances which can use a default key",
        },
    }
    FlCustomEncryptionOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "with-custom-encryption",
            Usage: "custom key encryption for AWS instances which can use your custom key",
        },
    }
    FlRawEncryptionOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "with-raw-encryption",
            Usage: "custom encryption for GCP instances which can use your raw key",
        },
    }
    FlRsaEncryptionOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "with-rsa-encryption",
            Usage: "custom key encryption for GCP instances which can use your rsa key",
        },
    }
    FlKmsEncryptionOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "with-kms-encryption",
            Usage: "custom key encryption for GCP instances which can use your kms key",
        },
    }
    FlWithBlueprintValidation = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "with-blueprint-validation",
            Usage: "enable blueprint validation",
        },
    }
    FlExecutionType = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "execution-type",
            Usage: "type of execution [pre-ambari-start, pre-termination, post-ambari-start, post-cluster-install]",
        },
    }
    FlCMUserOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "input-json-param-user",
            Usage: "user of the cluster and Cloudera Manager",
        },
    }
    FlCMPasswordOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "input-json-param-password",
            Usage: "password of the cluster and Cloudera Manager",
        },
    }
    FlGroupName = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "group-name",
            Usage: "name of the group to scale",
        },
    }
    FlDesiredNodeCount = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "desired-node-count",
            Usage: "desired number of nodes",
        },
    }
    FlOldPassword = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "old-password",
            Usage: "old password of ambari",
        },
    }
    FlNewPassword = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "new-password",
            Usage: "new password of ambari",
        },
    }
    FlAmbariUser = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ambari-user",
            Usage: "user of ambari",
        },
    }
    FlLdapServer = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-server",
            Usage: "address of the ldap server (e.g: ldap://10.0.0.1:384)",
        },
    }
    FlLdapSecureOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "ldaps",
            Usage: "set ldaps if the ldap is secured with SSL",
        },
    }
    FlLdapCertificate = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "ldaps-cert-file",
            Usage: "location of the certificate file to be imported in case of LDAPS",
        },
    }
    FlLdapDomain = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-domain",
            Usage: "ldap domain (e.g: ad.dp.com)",
        },
    }
    FlLdapBindDN = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-bind-dn",
            Usage: "ldap bind dn (e.g: CN=Administrator,CN=Users,DC=ad,DC=cb,DC=com)",
        },
    }
    FlLdapUserNameAttribute = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-user-name-attribute",
            Usage: "ldap user name attribute",
        },
    }
    FlLdapUserObjectClass = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-user-object-class",
            Usage: "ldap user object class",
        },
    }
    FlLdapGroupMemberAttribute = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-group-member-attribute",
            Usage: "ldap group member attribute",
        },
    }
    FlLdapGroupNameAttribute = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-group-name-attribute",
            Usage: "ldap group name attribute",
        },
    }
    FlLdapGroupObjectClass = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-group-object-class",
            Usage: "ldap group object class",
        },
    }
    FlLdapBindPassword = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-bind-password",
            Usage: "ldap bind password",
        },
    }
    FlLdapDirectoryType = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-directory-type",
            Usage: "ldap directory type (LDAP or ACTIVE_DIRECTORY)",
        },
    }
    FlLdapUserSearchBase = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-user-search-base",
            Usage: "ldap user search base (e.g: CN=Users,DC=ad,DC=cb,DC=com)",
        },
    }
    FlLdapUserDnPattern = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-user-dn-pattern",
            Usage: "ldap userDnPattern (e.g: CN={0},DC=ad,DC=cb,DC=com)",
        },
    }
    FlLdapGroupSearchBase = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-group-search-base",
            Usage: "ldap group search base (e.g: OU=scopes,DC=ad,DC=cb,DC=com)",
        },
    }
    FlLdapAdminGroup = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "ldap-admin-group",
            Usage: "ldap group of administrators",
        },
    }
    FlLdapUserToCreate = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-user-to-create",
            Usage: "name of the ldap user (e.g user will create CN=user)",
        },
    }
    FlLdapUserToCreatePassword = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-user-to-create-password",
            Usage: "password of the user",
        },
    }
    FlLdapUserToCreateEmail = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-user-to-create-email",
            Usage: "email of the ldap user (it will set the mail attribute)",
        },
    }
    FlLdapUserToCreateBase = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-user-to-create-base",
            Usage: "base DN where the user will be created (e.g: CN=Users,DC=ad,DC=cb,DC=com)",
        },
    }
    FlLdapUserToCreateGroups = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "ldap-user-to-create-groups",
            Usage: "semicolon separated list of group DNs that the user will be added to (e.g: OU=dataplane,CN=Users,DC=ad,DC=cb,DC=com;)",
        },
    }
    FlLdapGroupToCreate = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-group-to-create",
            Usage: "name of the ldap group (e.g dataplane will create CN=dataplane)",
        },
    }
    FlLdapGroupToCreateBase = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-group-to-create-base",
            Usage: "base DN where the group will be created (e.g: CN=Users,DC=ad,DC=cb,DC=com)",
        },
    }
    FlLdapGroupToDelete = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-group-to-delete",
            Usage: "name of the ldap group",
        },
    }
    FlLdapGroupToDeleteBase = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-group-to-delete-base",
            Usage: "base DN from where the group will be deleted (e.g: CN=Users,DC=ad,DC=cb,DC=com)",
        },
    }
    FlLdapUserToDelete = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-user-to-delete",
            Usage: "name of the ldap user to delete",
        },
    }
    FlLdapUserToDeleteBase = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-user-to-delete-base",
            Usage: "base DN from where the user will be deleted (e.g: CN=Users,DC=ad,DC=cb,DC=com)",
        },
    }
    FlCredential = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "credential",
            Usage: "name of the credential",
        },
    }
    FlRegion = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "region",
            Usage: "name of the region",
        },
    }
    FlClusterShape = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "cluster-shape",
            Usage: "defines the used cluster shape, can be LIGHT_DUTY, MEDIUM_DUTY_HA",
        },
    }
    FlAvailabilityZoneOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "availability-zone",
            Usage: "name of the availability zone",
        },
    }
    FlImageCatalog = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "imagecatalog",
            Usage: "name of the imagecatalog",
        },
    }
    FlImageCatalogOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "imagecatalog",
            Usage: "name of the imagecatalog",
        },
    }
    FlImageId = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "imageid",
            Usage: "id of the image",
        },
    }
    FlProxyHost = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "proxy-host",
            Usage: "hostname or ip of the proxy",
        },
    }
    FlProxyPort = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "proxy-port",
            Usage: "port of the proxy",
        },
    }
    FlProxyProtocol = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "proxy-protocol",
            Usage: "protocol of the proxy (http or https)",
            Value: "http",
        },
    }
    FlProxyUser = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "proxy-user",
            Usage: "user for the proxy if basic auth is required",
        },
    }
    FlProxyPassword = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "proxy-password",
            Usage: "password for the proxy if basic auth is required",
        },
    }
    FlRdsUserName = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "db-username",
            Usage: "username to use for the jdbc connection",
        },
    }
    FlRdsPassword = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "db-password",
            Usage: "password to use for the jdbc connection",
        },
    }
    FlRdsDriverOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "driver",
            Usage: "[DEPRECATED] has no effect",
        },
    }
    FlRdsURL = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "url",
            Usage: "JDBC connection URL in the form of jdbc:<db-type>://<address>:<port>/<db>",
        },
    }
    FlRdsDatabaseEngineOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "database-engine",
            Usage: "[DEPRECATED] has no effect",
        },
    }
    FlRdsType = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "type",
            Usage: "type of database, aka the service name that will use the db like HIVE, DRUID, SUPERSET, RANGER, etc.",
        },
    }
    FlRdsValidatedOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "not-validated",
            Usage: "[DEPRECATED] has no effect, use 'dp database test ...' command instead",
        },
    }
    FlKubernetesConfigFile = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "kubernetes-config",
            Usage: "Kubernetes config file location",
        },
    }
    FLMpackURL = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "url",
            Usage: "URL of the mpack",
        },
    }
    FLMpackPurge = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "purge",
            Usage: "purge existing resources specified in purge-list",
        },
    }
    FLMpackPurgeList = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "purge-list",
            Usage: "" /* 145 byte string literal not displayed */,
        },
    }
    FLMpackForce = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "force",
            Usage: "force install management pack",
        },
    }
    FlRdsConnectorJarURLOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "connector-jar-url",
            Usage: "URL of the jdbc jar file",
        },
    }
    FlCidrOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "cidr",
            Usage: "defines Classless Inter-Domain Routing for cluster",
        },
    }
    FlWithCustomDomainOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "with-custom-domain",
            Usage: "adds custom domain configuration to the template",
        },
    }
    FlWithTagsOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "with-tags",
            Usage: "adds user defined tags configuration to the template",
        },
    }
    FlWithImageOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "with-image",
            Usage: "adds image-catalog configuration to the template",
        },
    }
    FlWithSourceCluster = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "source-cluster",
            Usage: "source cluster to use as datalake",
        },
    }
    FlHostGroups = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "host-groups",
            Usage: "comma separated list of hostgroups where the failed nodes will be repaired",
        },
    }
    FlNodes = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "nodes",
            Usage: "comma separated list of nodes that will be repaired",
        },
    }
    FlDeleteVolumes = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "delete-volumes",
            Usage: "volumes of failed nodes will be deleted, otherwise reattaches them to newly created node instances.",
        },
    }
    FlRemoveOnly = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "remove-only",
            Usage: "the failed nodes will only be removed, otherwise the failed nodes will be removed and new nodes will be started.",
        },
    }
    FlResourceID = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "resource-id",
            Usage: "id of resource",
        },
    }
    FlAuditID = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "audit-id",
            Usage: "id of audit",
        },
    }
    FlWorkspaceOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:   "workspace",
            Usage:  "name of the workspace",
            EnvVar: "CB_WORKSPACE",
        },
    }
    FlUserID = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "user-id",
            Usage: "id of the user",
        },
    }
    FlUserName = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "name",
            Usage: "name of user",
        },
    }
    FlUserNameOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "name",
            Usage: "name of user",
        },
    }
    FlVersion = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "version",
            Usage: "component version",
        },
    }
    FlVdfUrl = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "vdf-url",
            Usage: "vdf url",
        },
    }
    FlMPackUrl = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "mpack-url",
            Usage: "mpack url",
        },
    }
    FlRepoUrl = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "repo-url",
            Usage: "repository url",
        },
    }
    FlRepoGpgUrl = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "gpg-url",
            Usage: "repository GPG url",
        },
    }
    FlEnvironmentCredential = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "credential",
            Usage: "name of the credential",
        },
    }
    FlEnvironmentCredentialOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "credential",
            Usage: "name of the credential",
        },
    }
    FlEnvironmentRegions = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "regions",
            Usage: "region names for the environment",
        },
    }
    FlLdapNamesOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "ldap-names",
            Usage: "ldap config names delimited by comma",
        },
    }
    FlProxyNamesOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "proxy-names",
            Usage: "proxy config names delimited by comma",
        },
    }
    FlKerberosNamesOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "kerberos-names",
            Usage: "kerberos config names delimited by comma",
        },
    }
    FlRdsNamesOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "rds-names",
            Usage: "rds config names delimited by comma",
        },
    }
    FlLdapNameOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "ldap-name",
            Usage: "ldap config name",
        },
    }
    FlEnvironmentName = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "env-name",
            Usage: "name of an environment",
        },
    }
    FlEnvironmentNameOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "env-name",
            Usage: "name of an environment",
        },
    }
    FlEnvironmentTemplateFile = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "file",
            Usage: "location of the environment JSON template file",
        },
    }
    FlEnvironmentEditTemplateFile = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "file",
            Usage: "location of the environment edit JSON template file",
        },
    }
    FlEnvironments = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "environments",
            Usage: "environment names to be used for attaching, detaching resources",
        },
    }
    FlEnvironmentsOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "environments",
            Usage: "names of environments in which the created resource should be attached during the creation",
        },
    }
    FlEnvironmentLocationName = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "location-name",
            Usage: "location name of the environment. must be one of the regions",
        },
    }
    FlEnvironmentLocationNameOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "location-name",
            Usage: "location name of the environment. must be one of the regions",
        },
    }
    FlEnvironmentLongitudeOptional = Float64Flag{
        RequiredFlag: OPTIONAL,
        Float64Flag: cli.Float64Flag{
            Name:  "longitude",
            Usage: "longitude of the environment's location. must be specified if the location is made-up and not supported on the cloud provider",
        },
    }
    FlEnvironmentLatitudeOptional = Float64Flag{
        RequiredFlag: OPTIONAL,
        Float64Flag: cli.Float64Flag{
            Name:  "latitude",
            Usage: "latitude of the environment's location. must be specified if the location is made-up and not supported on the cloud provider",
        },
    }
    FlNetworkId = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "network-id",
            Usage: "the ID of the existing network to attach",
        },
    }
    FlSubnetIds = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "subnet-ids",
            Usage: "a comma separated list of existing subnet IDs",
        },
    }
    FlNetworkCidr = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "network-cidr",
            Usage: "the cidr of the new network",
        },
    }
    FlSubnetCidrs = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "subnet-cidrs",
            Usage: "a comma separated list of subnet cidrs",
        },
    }
    FlResourceGroupName = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "resource-group",
            Usage: "the name of the resource group",
        },
    }
    FlRangerAdminPasswordOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "ranger-admin-password",
            Usage: "ranger admin password",
        },
    }
    FlKerberosNameOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "kerberos-name",
            Usage: "kerberos config name",
        },
    }
    FlKerberosPassword = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "password",
            Usage: "kerberos password",
        },
    }
    FlKerberosPrincipal = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "principal",
            Usage: "kerberos principal",
        },
    }
    FlKerberosDisableVerifyKdcTrust = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "disable-verify-kdc-trust",
            Usage: "disable kdc-trust verification",
        },
    }
    FlKerberosDomain = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "domain",
            Usage: "kerberos domain",
        },
    }
    FlKerberosNameServers = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "nameservers",
            Usage: "kerberos nameservers",
        },
    }
    FlKerberosTcpAllowed = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "tcp-allowed",
            Usage: "kerberos tcp-allowed flag",
        },
    }
    FlKerberosUrl = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "url",
            Usage: "kerberos url",
        },
    }
    FlKerberosAdminUrl = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "admin-url",
            Usage: "kerberos admin url",
        },
    }
    FlKerberosRealm = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "realm",
            Usage: "kerberos realm",
        },
    }
    FlKerberosLdapUrl = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ldap-url",
            Usage: "kerberos LDAP url",
        },
    }
    FlKerberosContainerDn = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "container-dn",
            Usage: "kerberos container dn",
        },
    }
    FlKerberosAdmin = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "admin",
            Usage: "kerberos admin",
        },
    }
    FlTimeoutMinutes = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "minutes",
            Usage: "timeout (minutes)",
        },
    }
    FlTimeoutHours = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "hours",
            Usage: "timeout (hours)",
        },
    }
    FlTimeoutDays = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "days",
            Usage: "timeout (hours)",
        },
    }
    FlShowUsage = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "show-usage",
            Usage: "shows the command usage",
        },
    }
    FlShowInternal = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "show-internal",
            Usage: "shows the internal commands as well",
        },
    }

    FlApiKeyIDOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "apikeyid",
            Usage: "API key ID",
        },
    }
    FlPrivateKeyOptional = StringFlag{
        RequiredFlag: OPTIONAL,
        StringFlag: cli.StringFlag{
            Name:  "privatekey",
            Usage: "API private key",
        },
    }
    FlWriteToProfileOptional = BoolFlag{
        RequiredFlag: OPTIONAL,
        BoolFlag: cli.BoolFlag{
            Name:  "write-to-profile",
            Usage: "writes the values into the profile",
        },
    }
    FlIpaUsersSlice = StringSliceFlag{
        RequiredFlag: OPTIONAL,
        StringSliceFlag: cli.StringSliceFlag{
            Name:  "user",
            Usage: "name of users to sync (provide option once for each name)",
        },
    }
    FlIpaEnvironmentsSlice = StringSliceFlag{
        RequiredFlag: OPTIONAL,
        StringSliceFlag: cli.StringSliceFlag{
            Name:  "environment",
            Usage: "name of environments to sync (provide option once for each name)",
        },
    }
    FlIpaUserPassword = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "ipa-user-password",
            Usage: "password for user in the ipa server",
        },
    }
    FlIpaSyncOperationId = StringFlag{
        RequiredFlag: REQUIRED,
        StringFlag: cli.StringFlag{
            Name:  "operation-id",
            Usage: "id for the operation",
        },
    }
)
var OPTIONAL = RequiredFlag{false}
var REQUIRED = RequiredFlag{true}

func CheckRequiredFlagsAndArguments Uses

func CheckRequiredFlagsAndArguments(c *cli.Context) error

func OptionalFlags Uses

func OptionalFlags(flags []cli.Flag) []cli.Flag

func PrintFlagCompletion Uses

func PrintFlagCompletion(f cli.Flag)

func RequiredFlags Uses

func RequiredFlags(flags []cli.Flag) []cli.Flag

type BoolFlag Uses

type BoolFlag struct {
    cli.BoolFlag
    RequiredFlag
}

type FlagBuilder Uses

type FlagBuilder struct {
    // contains filtered or unexported fields
}

func NewFlagBuilder Uses

func NewFlagBuilder() *FlagBuilder

func (*FlagBuilder) AddAuthenticationFlags Uses

func (fb *FlagBuilder) AddAuthenticationFlags() *FlagBuilder

func (*FlagBuilder) AddAuthenticationFlagsWithoutWorkspace Uses

func (fb *FlagBuilder) AddAuthenticationFlagsWithoutWorkspace() *FlagBuilder

func (*FlagBuilder) AddCommonKerberosCreateFlags Uses

func (fb *FlagBuilder) AddCommonKerberosCreateFlags() *FlagBuilder

func (*FlagBuilder) AddFlags Uses

func (fb *FlagBuilder) AddFlags(flags ...cli.Flag) *FlagBuilder

func (*FlagBuilder) AddOutputFlag Uses

func (fb *FlagBuilder) AddOutputFlag() *FlagBuilder

func (*FlagBuilder) AddResourceDefaultFlags Uses

func (fb *FlagBuilder) AddResourceDefaultFlags() *FlagBuilder

func (*FlagBuilder) AddResourceFlagsWithOptionalName Uses

func (fb *FlagBuilder) AddResourceFlagsWithOptionalName() *FlagBuilder

func (*FlagBuilder) AddTemplateFlags Uses

func (fb *FlagBuilder) AddTemplateFlags() *FlagBuilder

func (*FlagBuilder) Build Uses

func (fb *FlagBuilder) Build() []cli.Flag

type Float64Flag Uses

type Float64Flag struct {
    cli.Float64Flag
    RequiredFlag
}

type Int64Flag Uses

type Int64Flag struct {
    cli.Int64Flag
    RequiredFlag
}

type IntFlag Uses

type IntFlag struct {
    cli.IntFlag
    RequiredFlag
}

type RequiredFlag Uses

type RequiredFlag struct {
    Required bool
}

type StringFlag Uses

type StringFlag struct {
    cli.StringFlag
    RequiredFlag
}

type StringSliceFlag Uses

type StringSliceFlag struct {
    cli.StringSliceFlag
    RequiredFlag
}

Package flags imports 4 packages (graph) and is imported by 34 packages. Updated 2019-07-23. Refresh now. Tools for package owners.