// NewCommandDockerBuilder provides a CLI handler for Docker build type
func NewCommandDockerBuilder(name string) *cobra.Command {
cmd := &cobra.Command{
Use: name,
Short: "Run an OpenShift Docker build",
Long: dockerBuilderLong,
Run: func(c *cobra.Command, args []string) {
cmd.RunDockerBuild()
},
}
cmd.AddCommand(version.NewVersionCommand(name))
return cmd
}
// NewCommandSTIBuilder provides a CLI handler for STI build type
func NewCommandSTIBuilder(name string) *cobra.Command {
cmd := &cobra.Command{
Use: name,
Short: "Run an OpenShift Source-to-Images build",
Long: stiBuilderLong,
Run: func(c *cobra.Command, args []string) {
cmd.RunSTIBuild()
},
}
cmd.AddCommand(version.NewVersionCommand(name))
return cmd
}
// NewCommndTemplateRouter provides CLI handler for the template router backend
func NewCommandTemplateRouter(name string) *cobra.Command {
cfg := &templateRouterConfig{
Config: clientcmd.NewConfig(),
}
cmd := &cobra.Command{
Use: fmt.Sprintf("%s%s", name, clientcmd.ConfigSyntax),
Short: "Start an OpenShift router",
Long: routerLong,
Run: func(c *cobra.Command, args []string) {
defaultCert := util.Env("DEFAULT_CERTIFICATE", "")
if len(defaultCert) > 0 {
cfg.DefaultCertificate = defaultCert
}
routerSvcNamespace := util.Env("ROUTER_SERVICE_NAMESPACE", "")
routerSvcName := util.Env("ROUTER_SERVICE_NAME", "")
cfg.RouterService = ktypes.NamespacedName{
Namespace: routerSvcNamespace,
Name: routerSvcName,
}
plugin, err := makeTemplatePlugin(cfg)
if err != nil {
glog.Fatal(err)
}
if err = start(cfg.Config, plugin); err != nil {
glog.Fatal(err)
}
},
}
cmd.AddCommand(version.NewVersionCommand(name))
flag := cmd.Flags()
cfg.Config.Bind(flag)
flag.StringVar(&cfg.TemplateFile, "template", util.Env("TEMPLATE_FILE", ""), "The path to the template file to use")
flag.StringVar(&cfg.ReloadScript, "reload", util.Env("RELOAD_SCRIPT", ""), "The path to the reload script to use")
flag.StringVar(&cfg.StatsPort, "stats-port", util.Env("STATS_PORT", ""), "If the underlying router implementation can provide statistics this is a hint to expose it on this port.")
flag.StringVar(&cfg.StatsPassword, "stats-password", util.Env("STATS_PASSWORD", ""), "If the underlying router implementation can provide statistics this is the requested password for auth.")
flag.StringVar(&cfg.StatsUsername, "stats-user", util.Env("STATS_USERNAME", ""), "If the underlying router implementation can provide statistics this is the requested username for auth.")
return cmd
}
func NewCommandAdmin(name, fullName string, out io.Writer) *cobra.Command {
// Main command
cmds := &cobra.Command{
Use: name,
Short: "Tools for managing an OpenShift cluster",
Long: fmt.Sprintf(adminLong),
Run: cmdutil.DefaultSubCommandRun(out),
}
f := clientcmd.New(cmds.PersistentFlags())
cmds.AddCommand(project.NewCmdNewProject(project.NewProjectRecommendedName, fullName+" "+project.NewProjectRecommendedName, f, out))
cmds.AddCommand(policy.NewCmdPolicy(policy.PolicyRecommendedName, fullName+" "+policy.PolicyRecommendedName, f, out))
cmds.AddCommand(exipfailover.NewCmdIPFailoverConfig(f, fullName, "ipfailover", out))
cmds.AddCommand(router.NewCmdRouter(f, fullName, "router", out))
cmds.AddCommand(registry.NewCmdRegistry(f, fullName, "registry", out))
cmds.AddCommand(buildchain.NewCmdBuildChain(f, fullName, "build-chain"))
cmds.AddCommand(node.NewCommandManageNode(f, node.ManageNodeCommandName, fullName+" "+node.ManageNodeCommandName, out))
cmds.AddCommand(cmd.NewCmdConfig(fullName, "config"))
cmds.AddCommand(prune.NewCommandPrune(prune.PruneRecommendedName, fullName+" "+prune.PruneRecommendedName, f, out))
// TODO: these probably belong in a sub command
cmds.AddCommand(admin.NewCommandCreateKubeConfig(admin.CreateKubeConfigCommandName, fullName+" "+admin.CreateKubeConfigCommandName, out))
cmds.AddCommand(admin.NewCommandCreateBootstrapPolicyFile(admin.CreateBootstrapPolicyFileCommand, fullName+" "+admin.CreateBootstrapPolicyFileCommand, out))
cmds.AddCommand(admin.NewCommandCreateBootstrapProjectTemplate(f, admin.CreateBootstrapProjectTemplateCommand, fullName+" "+admin.CreateBootstrapProjectTemplateCommand, out))
cmds.AddCommand(admin.NewCommandOverwriteBootstrapPolicy(admin.OverwriteBootstrapPolicyCommandName, fullName+" "+admin.OverwriteBootstrapPolicyCommandName, fullName+" "+admin.CreateBootstrapPolicyFileCommand, out))
cmds.AddCommand(admin.NewCommandNodeConfig(admin.NodeConfigCommandName, fullName+" "+admin.NodeConfigCommandName, out))
// TODO: these should be rolled up together
cmds.AddCommand(admin.NewCommandCreateMasterCerts(admin.CreateMasterCertsCommandName, fullName+" "+admin.CreateMasterCertsCommandName, out))
cmds.AddCommand(admin.NewCommandCreateClient(admin.CreateClientCommandName, fullName+" "+admin.CreateClientCommandName, out))
cmds.AddCommand(admin.NewCommandCreateKeyPair(admin.CreateKeyPairCommandName, fullName+" "+admin.CreateKeyPairCommandName, out))
cmds.AddCommand(admin.NewCommandCreateServerCert(admin.CreateServerCertCommandName, fullName+" "+admin.CreateServerCertCommandName, out))
cmds.AddCommand(admin.NewCommandCreateSignerCert(admin.CreateSignerCertCommandName, fullName+" "+admin.CreateSignerCertCommandName, out))
// TODO: use groups
templates.ActsAsRootCommand(cmds)
if name == fullName {
cmds.AddCommand(version.NewVersionCommand(fullName))
}
cmds.AddCommand(cmd.NewCmdOptions(out))
return cmds
}
// NewCommandAtomicEnprise creates the standard AtomicEnterprise command
func NewCommandAtomicEnterprise(name string) *cobra.Command {
out := os.Stdout
root := &cobra.Command{
Use: name,
Short: "Atomic Enterprise helps you build, deploy, and manage your cloud applications",
Long: openshiftLong,
Run: cmdutil.DefaultSubCommandRun(out),
}
startAllInOne, _ := start.NewCommandStartAllInOne(name, out)
root.AddCommand(startAllInOne)
root.AddCommand(admin.NewCommandAdmin("admin", name+" admin", out))
root.AddCommand(cli.NewCommandCLI("cli", name+" cli"))
root.AddCommand(cli.NewCmdKubectl("kube", out))
root.AddCommand(newExperimentalCommand("ex", name+" ex"))
root.AddCommand(version.NewVersionCommand(name))
// infra commands are those that are bundled with the binary but not displayed to end users
// directly
infra := &cobra.Command{
Use: "infra", // Because this command exposes no description, it will not be shown in help
}
infra.AddCommand(
irouter.NewCommandTemplateRouter("router"),
deployer.NewCommandDeployer("deploy"),
builder.NewCommandSTIBuilder("sti-build"),
builder.NewCommandDockerBuilder("docker-build"),
gitserver.NewCommandGitServer("git-server"),
)
root.AddCommand(infra)
root.AddCommand(cmd.NewCmdOptions(out))
// TODO: add groups
templates.ActsAsRootCommand(root)
return root
}
// NewCommandDeployer provides a CLI handler for deploy.
func NewCommandDeployer(name string) *cobra.Command {
cfg := &config{
Config: clientcmd.NewConfig(),
}
cmd := &cobra.Command{
Use: fmt.Sprintf("%s%s", name, clientcmd.ConfigSyntax),
Short: "Run the OpenShift deployer",
Long: deployerLong,
Run: func(c *cobra.Command, args []string) {
_, kClient, err := cfg.Config.Clients()
if err != nil {
glog.Fatal(err)
}
if len(cfg.DeploymentName) == 0 {
glog.Fatal("deployment is required")
}
if len(cfg.Namespace) == 0 {
glog.Fatal("namespace is required")
}
deployer := NewDeployer(kClient)
if err = deployer.Deploy(cfg.Namespace, cfg.DeploymentName); err != nil {
glog.Fatal(err)
}
},
}
cmd.AddCommand(version.NewVersionCommand(name))
flag := cmd.Flags()
cfg.Config.Bind(flag)
flag.StringVar(&cfg.DeploymentName, "deployment", util.Env("OPENSHIFT_DEPLOYMENT_NAME", ""), "The deployment name to start")
flag.StringVar(&cfg.Namespace, "namespace", util.Env("OPENSHIFT_DEPLOYMENT_NAMESPACE", ""), "The deployment namespace")
return cmd
}
func NewCommand(name, fullName string, out io.Writer) *cobra.Command {
cmds := &cobra.Command{
Use: name,
Short: "Kubernetes server components",
Long: fmt.Sprintf(kubernetesLong),
Run: func(c *cobra.Command, args []string) {
c.SetOutput(os.Stdout)
c.Help()
},
}
cmds.AddCommand(NewAPIServerCommand("apiserver", fullName+" apiserver", out))
cmds.AddCommand(NewControllersCommand("controller-manager", fullName+" controller-manager", out))
cmds.AddCommand(NewKubeletCommand("kubelet", fullName+" kubelet", out))
cmds.AddCommand(NewProxyCommand("proxy", fullName+" proxy", out))
cmds.AddCommand(NewSchedulerCommand("scheduler", fullName+" scheduler", out))
if "hyperkube" == fullName {
cmds.AddCommand(version.NewVersionCommand(fullName))
}
return cmds
}
func NewCommandCLI(name, fullName string) *cobra.Command {
in := os.Stdin
out := os.Stdout
// Main command
cmds := &cobra.Command{
Use: name,
Short: "Client tools for Atomic Enterprise",
Long: fmt.Sprintf(cliLong, fullName),
Run: cmdutil.DefaultSubCommandRun(out),
BashCompletionFunction: bashCompletionFunc,
}
f := clientcmd.New(cmds.PersistentFlags())
loginCmd := cmd.NewCmdLogin(fullName, f, in, out)
groups := templates.CommandGroups{
{
Message: "Basic Commands:",
Commands: []*cobra.Command{
cmd.NewCmdTypes(fullName, f, out),
loginCmd,
cmd.NewCmdRequestProject("new-project", fullName+" new-project", fullName+" login", fullName+" project", f, out),
cmd.NewCmdNewApplication(fullName, f, out),
cmd.NewCmdStatus(fullName, f, out),
cmd.NewCmdProject(fullName+" project", f, out),
},
},
{
Message: "Build and Deploy Commands:",
Commands: []*cobra.Command{
cmd.NewCmdStartBuild(fullName, f, out),
cmd.NewCmdBuildLogs(fullName, f, out),
cmd.NewCmdDeploy(fullName, f, out),
cmd.NewCmdRollback(fullName, f, out),
cmd.NewCmdNewBuild(fullName, f, out),
cmd.NewCmdCancelBuild(fullName, f, out),
cmd.NewCmdImportImage(fullName, f, out),
cmd.NewCmdScale(fullName, f, out),
cmd.NewCmdTag(fullName, f, out),
},
},
{
Message: "Application Modification Commands:",
Commands: []*cobra.Command{
cmd.NewCmdGet(fullName, f, out),
cmd.NewCmdDescribe(fullName, f, out),
cmd.NewCmdEdit(fullName, f, out),
cmd.NewCmdEnv(fullName, f, os.Stdin, out),
cmd.NewCmdVolume(fullName, f, out),
cmd.NewCmdLabel(fullName, f, out),
cmd.NewCmdExpose(fullName, f, out),
cmd.NewCmdStop(fullName, f, out),
cmd.NewCmdDelete(fullName, f, out),
},
},
{
Message: "Troubleshooting and Debugging Commands:",
Commands: []*cobra.Command{
cmd.NewCmdLogs(fullName, f, out),
cmd.NewCmdExec(fullName, f, os.Stdin, out, os.Stderr),
cmd.NewCmdPortForward(fullName, f),
cmd.NewCmdProxy(fullName, f, out),
},
},
{
Message: "Advanced Commands:",
Commands: []*cobra.Command{
cmd.NewCmdCreate(fullName, f, out),
cmd.NewCmdUpdate(fullName, f, out),
cmd.NewCmdProcess(fullName, f, out),
cmd.NewCmdExport(fullName, f, os.Stdin, out),
policy.NewCmdPolicy(policy.PolicyRecommendedName, fullName+" "+policy.PolicyRecommendedName, f, out),
secrets.NewCmdSecrets(secrets.SecretsRecommendedName, fullName+" "+secrets.SecretsRecommendedName, f, out, fullName+" edit"),
},
},
{
Message: "Settings Commands:",
Commands: []*cobra.Command{
cmd.NewCmdLogout("logout", fullName+" logout", fullName+" login", f, in, out),
cmd.NewCmdConfig(fullName, "config"),
cmd.NewCmdWhoAmI(cmd.WhoAmIRecommendedCommandName, fullName+" "+cmd.WhoAmIRecommendedCommandName, f, out),
},
},
}
groups.Add(cmds)
templates.ActsAsRootCommand(cmds, groups...).
ExposeFlags(loginCmd, "certificate-authority", "insecure-skip-tls-verify")
if name == fullName {
cmds.AddCommand(version.NewVersionCommand(fullName))
}
cmds.AddCommand(cmd.NewCmdOptions(out))
return cmds
}