kuberntes 的 Cmdline 实现

func main() {
    if err := app.run(); err != nil {
        os.exit(1)
    }
    os.exit(0)
}

cmd := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, os.Stdout, os.Stderr)
return cmd.Execute()

func NewKubectlCommand(f cmdutil.Factory, in io.Reader, out, err io.Writer) *cobra.Command {

创建command，设置执行函数
设置command的flag (即命令行参数）
设置子命令、以及自命令的命令行参数

cmds := &cobra.Command{
    Use:   "kubectl",
    Short: i18n.T("kubectl controls the kubernetes cluster manager"),
    Long: templates.LongDesc(`
kubectl controls the kubernetes cluster manager.

Find more information at https://github.com/kubernetes/kubernetes.`),
    Run: runHelp,
    BashCompletionFunction: bash_completion_func,
}

f.BindFlags(cmds.PersistentFlags())
f.BindExternalFlags(cmds.PersistentFlags())

func NewFactory(optionalClientConfig clientcmd.ClientConfig) Factory {
    clientAccessFactory := NewClientAccessFactory(optionalClientConfig)
    objectMappingFactory := NewObjectMappingFactory(clientAccessFactory)
    builderFactory := NewBuilderFactory(clientAccessFactory, objectMappingFactory)

    return &factory{
        ClientAccessFactory:  clientAccessFactory,
        ObjectMappingFactory: objectMappingFactory,
        BuilderFactory:       builderFactory,
    }
}

// BindFlags adds any flags that are common to all kubectl sub commands.
BindFlags(flags *pflag.FlagSet)

// BindExternalFlags adds any flags defined by external projects (not part of pflags)
BindExternalFlags(flags *pflag.FlagSet)

func NewClientAccessFactory(optionalClientConfig clientcmd.ClientConfig) ClientAccessFactory {
    flags := pflag.NewFlagSet("", pflag.ContinueOnError)

    clientConfig := optionalClientConfig
    if optionalClientConfig == nil {
        clientConfig = DefaultClientConfig(flags)
    }

    return NewClientAccessFactoryFromDiscovery(flags, clientConfig, &discoveryFactory{clientConfig: clientConfig})
}

    f := &ring0Factory{
        flags:            flags,
        clientConfig:     clientConfig,
        discoveryFactory: discoveryFactory,
        clientCache:      clientCache,
    }

func (f *ring0Factory) BindFlags(flags *pflag.FlagSet) {

    flags.AddFlagSet(f.flags)
    flags.BoolVar(&f.clientCache.matchVersion, FlagMatchBinaryVersion, false, "Require server version to match client version")
    flags.SetNormalizeFunc(utilflag.WordSepNormalizeFunc)
}

func (f *ring0Factory) BindExternalFlags(flags *pflag.FlagSet) {
    flags.AddGoFlagSet(flag.CommandLine)
}

func NewClientAccessFactory(optionalClientConfig clientcmd.ClientConfig) ClientAccessFactory {
    flags := pflag.NewFlagSet("", pflag.ContinueOnError)

    clientConfig := optionalClientConfig
    if optionalClientConfig == nil {
        clientConfig = DefaultClientConfig(flags)
    }

    return NewClientAccessFactoryFromDiscovery(flags, clientConfig, &discoveryFactory{clientConfig: clientConfig})
}

flags.StringVar(&loadingRules.ExplicitPath, "kubeconfig", "", "Path to the kubeconfig file to use for CLI requests.")
...
clientcmd.BindOverrideFlags(overrides, flags, flagNames)

func BindOverrideFlags(overrides *ConfigOverrides, flags *pflag.FlagSet, flagNames ConfigOverrideFlags) {
    BindAuthInfoFlags(&overrides.AuthInfo, flags, flagNames.AuthOverrideFlags)
    BindClusterFlags(&overrides.ClusterInfo, flags, flagNames.ClusterOverrideFlags)
    BindContextFlags(&overrides.Context, flags, flagNames.ContextOverrideFlags)
    flagNames.CurrentContext.BindStringFlag(flags, &overrides.CurrentContext)
    flagNames.Timeout.BindStringFlag(flags, &overrides.Timeout)
}

// BindAuthInfoFlags is a convenience method to bind the specified flags to their associated variables
func BindAuthInfoFlags(authInfo *clientcmdapi.AuthInfo, flags *pflag.FlagSet, flagNames AuthOverrideFlags) {
    flagNames.ClientCertificate.BindStringFlag(flags, &authInfo.ClientCertificate).AddSecretAnnotation(flags)
    flagNames.ClientKey.BindStringFlag(flags, &authInfo.ClientKey).AddSecretAnnotation(flags)
    flagNames.Token.BindStringFlag(flags, &authInfo.Token).AddSecretAnnotation(flags)
    flagNames.Impersonate.BindStringFlag(flags, &authInfo.Impersonate).AddSecretAnnotation(flags)
    flagNames.Username.BindStringFlag(flags, &authInfo.Username).AddSecretAnnotation(flags)
    flagNames.Password.BindStringFlag(flags, &authInfo.Password).AddSecretAnnotation(flags)
}

flagNames := clientcmd.RecommendedConfigOverrideFlags("")
// short flagnames are disabled by default.  These are here for compatibility with existing scripts
flagNames.ClusterOverrideFlags.APIServer.ShortName = "s"

func RecommendedConfigOverrideFlags(prefix string) ConfigOverrideFlags {
    return ConfigOverrideFlags{
        AuthOverrideFlags:    RecommendedAuthOverrideFlags(prefix),
        ClusterOverrideFlags: RecommendedClusterOverrideFlags(prefix),
        ContextOverrideFlags: RecommendedContextOverrideFlags(prefix),

        CurrentContext: FlagInfo{prefix + FlagContext, "", "", "The name of the kubeconfig context to use"},
        Timeout:        FlagInfo{prefix + FlagTimeout, "", "0", "The length of time to wait before giving up on a single server request. Non-zero values should contain a corresponding time unit (e.g. 1s, 2m, 3h). A value of zero means don't timeout requests."},
    }
}

func RecommendedAuthOverrideFlags(prefix string) AuthOverrideFlags {
    return AuthOverrideFlags{
        ClientCertificate: FlagInfo{prefix + FlagCertFile, "", "", "Path to a client certificate file for TLS"},
        ClientKey:         FlagInfo{prefix + FlagKeyFile, "", "", "Path to a client key file for TLS"},
        Token:             FlagInfo{prefix + FlagBearerToken, "", "", "Bearer token for authentication to the API server"},
        Impersonate:       FlagInfo{prefix + FlagImpersonate, "", "", "Username to impersonate for the operation"},
        Username:          FlagInfo{prefix + FlagUsername, "", "", "Username for basic authentication to the API server"},
        Password:          FlagInfo{prefix + FlagPassword, "", "", "Password for basic authentication to the API server"},
    }
}

FlagClusterName  = "cluster"
FlagAuthInfoName = "user"
FlagContext      = "context"
FlagNamespace    = "namespace"
FlagAPIServer    = "server"
FlagAPIVersion   = "api-version"
FlagInsecure     = "insecure-skip-tls-verify"
FlagCertFile     = "client-certificate"
FlagKeyFile      = "client-key"
FlagCAFile       = "certificate-authority"
FlagEmbedCerts   = "embed-certs"
FlagBearerToken  = "token"
FlagImpersonate  = "as"
FlagUsername     = "username"
FlagPassword     = "password"
FlagTimeout      = "request-timeout"

overrides := &clientcmd.ConfigOverrides{ClusterDefaults: clientcmd.ClusterDefaults}
clientcmd.BindOverrideFlags(overrides, flags, flagNames)
clientConfig := clientcmd.NewInteractiveDeferredLoadingClientConfig(loadingRules, overrides, os.Stdin)
return clientConfig

type ClientConfig interface {
    // RawConfig returns the merged result of all overrides
    RawConfig() (clientcmdapi.Config, error)
    // ClientConfig returns a complete client config
    ClientConfig() (*restclient.Config, error)
    // Namespace returns the namespace resulting from the merged
    // result of all overrides and a boolean indicating if it was
    // overridden
    Namespace() (string, bool, error)
    // ConfigAccess returns the rules for loading/persisting the config.
    ConfigAccess() ConfigAccess
}

groups := templates.CommandGroups{
    {
        Message: "Basic Commands (Beginner):",
        Commands: []*cobra.Command{
            NewCmdCreate(f, out, err),
            NewCmdExposeService(f, out),
            NewCmdRun(f, in, out, err),
            set.NewCmdSet(f, out, err),
        },
    },
...
groups.Add(cmds)

func RunCreate(f cmdutil.Factory, cmd *cobra.Command, out, errOut io.Writer, options *CreateOptions) error {

type Factory interface {
	ClientAccessFactory
	ObjectMappingFactory
	BuilderFactory
}