func main() {
// use os.Args instead of "flags" because "flags" will mess up the man pages!
path := "docs/man/man1"
if len(os.Args) == 2 {
path = os.Args[1]
} else if len(os.Args) > 2 {
fmt.Fprintf(os.Stderr, "usage: %s [output directory]\n", os.Args[0])
os.Exit(1)
}
outDir, err := genutils.OutDir(path)
if err != nil {
fmt.Fprintf(os.Stderr, "failed to get output directory: %v\n", err)
os.Exit(1)
}
// Set environment variables used by kubectl so the output is consistent,
// regardless of where we run.
os.Setenv("HOME", "/home/username")
//TODO os.Stdin should really be something like ioutil.Discard, but a Reader
kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
genMarkdown(kubectl, "", outDir)
for _, c := range kubectl.Commands() {
genMarkdown(c, "kubectl", outDir)
}
}
func TestKubectlCompatibility(t *testing.T) {
f := clientcmd.New(pflag.NewFlagSet("name", pflag.ContinueOnError))
oc := NewCommandCLI("oc", "oc", &bytes.Buffer{}, ioutil.Discard, ioutil.Discard)
kubectl := kcmd.NewKubectlCommand(f.Factory, nil, ioutil.Discard, ioutil.Discard)
kubectlLoop:
for _, kubecmd := range kubectl.Commands() {
for _, occmd := range oc.Commands() {
if kubecmd.Name() == occmd.Name() {
if MissingCommands.Has(kubecmd.Name()) {
t.Errorf("%s was supposed to be missing", kubecmd.Name())
continue
}
if WhitelistedCommands.Has(kubecmd.Name()) {
t.Errorf("%s was supposed to be whitelisted", kubecmd.Name())
continue
}
continue kubectlLoop
}
}
if MissingCommands.Has(kubecmd.Name()) || WhitelistedCommands.Has(kubecmd.Name()) {
continue
}
t.Errorf("missing %q in oc", kubecmd.Name())
}
}
/*
WARNING: this logic is duplicated, with minor changes, in cmd/hyperkube/kubectl.go
Any salient changes here will need to be manually reflected in that file.
*/
func Run() error {
logs.InitLogs()
defer logs.FlushLogs()
cmd := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, os.Stdout, os.Stderr)
return cmd.Execute()
}
func AddFlags(fs *pflag.FlagSet, kubectlSubCmd string) {
cmd := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, os.Stdout, os.Stderr)
fs.AddFlagSet(cmd.LocalFlags())
if kubectlSubCmd == "" {
return
}
for _, child := range cmd.Commands() {
if child.Name() == kubectlSubCmd {
fs.AddFlagSet(child.LocalFlags())
return
}
}
}
func NewKubectlServer() *Server {
cmd := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, os.Stdout, os.Stderr)
localFlags := cmd.LocalFlags()
localFlags.SetInterspersed(false)
return &Server{
name: "kubectl",
SimpleUsage: "Kubernetes command line client",
Long: "Kubernetes command line client",
Run: func(s *Server, args []string) error {
cmd.SetArgs(args)
return cmd.Execute()
},
flags: localFlags,
}
}
func main() {
errors := []error{}
kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
result := cmdsanity.CheckCmdTree(kubectl, cmdsanity.AllCmdChecks, []string{})
errors = append(errors, result...)
if len(errors) > 0 {
for i, err := range errors {
fmt.Fprintf(os.Stderr, "%d. %s\n\n", i+1, err)
}
os.Exit(1)
}
fmt.Fprintln(os.Stdout, "Congrats, CLI looks good!")
}
func main() {
flag.Parse()
if len(*outputFile) < 1 {
fmt.Printf("Must specify --output.\n")
os.Exit(1)
}
// Initialize a kubectl command that we can use to get the help documentation
kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
// Create the structural representation
spec := NewKubectlSpec(kubectl)
// Write the spec to a file as yaml
WriteFile(spec)
}
func NewKubectlServer() *Server {
// need to use term.StdStreams to get the right IO refs on Windows
stdin, stdout, stderr := term.StdStreams()
cmd := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), stdin, stdout, stderr)
localFlags := cmd.LocalFlags()
localFlags.SetInterspersed(false)
return &Server{
name: "kubectl",
SimpleUsage: "Kubernetes command line client",
Long: "Kubernetes command line client",
Run: func(s *Server, args []string) error {
cmd.SetArgs(args)
return cmd.Execute()
},
flags: localFlags,
}
}
// NewCmdKubectl provides exactly the functionality from Kubernetes,
// but with support for OpenShift resources
func NewCmdKubectl(name string, out io.Writer) *cobra.Command {
flags := pflag.NewFlagSet("", pflag.ContinueOnError)
f := clientcmd.New(flags)
cmds := kubecmd.NewKubectlCommand(f.Factory, os.Stdin, out, os.Stderr)
cmds.Aliases = []string{"kubectl"}
cmds.Use = name
cmds.Short = "Kubernetes cluster management via kubectl"
flags.VisitAll(func(flag *pflag.Flag) {
if f := cmds.PersistentFlags().Lookup(flag.Name); f == nil {
cmds.PersistentFlags().AddFlag(flag)
} else {
glog.V(5).Infof("already registered flag %s", flag.Name)
}
})
cmds.PersistentFlags().Var(flags.Lookup("config").Value, "kubeconfig", "Specify a kubeconfig file to define the configuration")
templates.ActsAsRootCommand(cmds)
cmds.AddCommand(cmd.NewCmdOptions(out))
return cmds
}
func main() {
// use os.Args instead of "flags" because "flags" will mess up the man pages!
path := "contrib/completions/bash/"
if len(os.Args) == 2 {
path = os.Args[1]
} else if len(os.Args) > 2 {
fmt.Fprintf(os.Stderr, "usage: %s [output directory]\n", os.Args[0])
os.Exit(1)
}
outDir, err := genutils.OutDir(path)
if err != nil {
fmt.Fprintf(os.Stderr, "failed to get output directory: %v\n", err)
os.Exit(1)
}
outFile := outDir + "kubectl"
//TODO os.Stdin should really be something like ioutil.Discard, but a Reader
kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
kubectl.GenBashCompletionFile(outFile)
}
// NewCmdKubectl provides exactly the functionality from Kubernetes,
// but with support for OpenShift resources
func NewCmdKubectl(name string, out io.Writer) *cobra.Command {
flags := pflag.NewFlagSet("", pflag.ContinueOnError)
f := clientcmd.New(flags)
cmds := kubecmd.NewKubectlCommand(f.Factory, os.Stdin, out, os.Stderr)
cmds.Aliases = []string{"kubectl"}
cmds.Use = name
cmds.Short = "Kubernetes cluster management via kubectl"
cmds.Long = cmds.Long + `
This command exposes the exact semantics of the Kubernetes command line client with additional
support for application lifecycles.`
flags.VisitAll(func(flag *pflag.Flag) {
if f := cmds.PersistentFlags().Lookup(flag.Name); f == nil {
cmds.PersistentFlags().AddFlag(flag)
} else {
glog.V(5).Infof("already registered flag %s", flag.Name)
}
})
templates.ActsAsRootCommand(cmds)
cmds.AddCommand(cmd.NewCmdOptions(out))
return cmds
}
// this only checks one level deep for nested commands, but it does ensure that we've gotten several
// --validate flags. Based on that we can reasonably assume we got them in the kube commands since they
// all share the same registration.
func TestValidateDisabled(t *testing.T) {
f := clientcmd.New(pflag.NewFlagSet("name", pflag.ContinueOnError))
oc := NewCommandCLI("oc", "oc", &bytes.Buffer{}, ioutil.Discard, ioutil.Discard)
kubectl := kcmd.NewKubectlCommand(f.Factory, nil, ioutil.Discard, ioutil.Discard)
for _, kubecmd := range kubectl.Commands() {
for _, occmd := range oc.Commands() {
if kubecmd.Name() == occmd.Name() {
ocValidateFlag := occmd.Flags().Lookup("validate")
if ocValidateFlag == nil {
continue
}
if ocValidateFlag.Value.String() != "false" {
t.Errorf("%s --validate is not defaulting to false", occmd.Name())
}
}
}
}
}
/*
WARNING: this logic is duplicated, with minor changes, in cmd/hyperkube/kubectl.go
Any salient changes here will need to be manually reflected in that file.
*/
func Run() error {
cmd := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, os.Stdout, os.Stderr)
return cmd.Execute()
}
func main() {
// embed kubectl
if filepath.Base(os.Args[0]) == "kubectl" {
cmd := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, os.Stdout, os.Stderr)
if err := cmd.Execute(); err != nil {
os.Exit(1)
}
return
}
usr, err := user.Current()
if err != nil {
log.Fatal(err)
}
mfs := pflag.NewFlagSet("main", pflag.ExitOnError)
nodes := mfs.StringSlice("nodes", []string{}, "list of nodes to make part of cluster")
sshKeyfile := mfs.String("ssh-keyfile", usr.HomeDir+"/.vagrant.d/insecure_private_key", "private ssh key to use for tunnels")
sshUser := mfs.String("ssh-user", "core", "ssh user to use for tunnels")
clusterIPRange := mfs.String("service-cluster-ip-range", "10.1.30.0/24", "A CIDR notation IP range from which to assign service cluster IPs. This must not overlap with any IP ranges assigned to nodes for pods.")
mfs.Parse(os.Args)
config := &ssh.ClientConfig{
User: *sshUser,
Auth: []ssh.AuthMethod{
PublicKeyFile(*sshKeyfile),
},
}
for _, remoteHost := range *nodes {
// Dial your ssh server.
go func(host string) {
// Serve HTTP with your SSH server acting as a reverse proxy.
go func() {
b := &backoff.Backoff{
//These are the defaults
Min: 100 * time.Millisecond,
Max: 10 * time.Second,
Factor: 2,
Jitter: false,
}
for {
conn, err := ssh.Dial("tcp", host, config)
if err != nil {
log.Println("unable to connect, retrying:", err)
time.Sleep(b.Duration())
continue
}
defer conn.Close()
// Request the remote side to open port 8080 on all interfaces.
l, err := conn.Listen("tcp", remoteListen)
if err != nil {
log.Println("unable to register tcp forward, retrying:", err)
time.Sleep(b.Duration())
continue
}
defer l.Close()
fwd, _ := forward.New()
http.Serve(l, http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
req.URL = testutils.ParseURI("http://localhost:8080")
fwd.ServeHTTP(resp, req)
}))
log.Println("proxy connection broken, reconnecting....")
time.Sleep(b.Duration())
}
}()
go func() {
// this will block, and the kubelet will stop once the connection is broken
// loop for reconnection
b := &backoff.Backoff{
//These are the defaults
Min: 100 * time.Millisecond,
Max: 10 * time.Second,
Factor: 2,
Jitter: false,
}
for {
ip, _, err := net.SplitHostPort(host)
if err != nil {
log.Fatalf("unable split host port: %v", err)
return
}
cmd := fmt.Sprintf("sudo /usr/bin/kubelet --hostname-override=%s --api-servers=http://localhost:8080", ip)
_, err = executeCmd(cmd, host, config)
if err != nil {
log.Println("unable to execute kubelet, retrying:", err)
}
// if we got here something went wrong
dur := b.Duration()
log.Println("kubelet connection broken, reconnecting in", dur)
time.Sleep(dur)
}
}()
<-make(chan interface{})
}(remoteHost)
}
go func() {
// etcd reads os.Args so we have to use mess with them
os.Args = []string{"etcd"}
etcdmain.Main()
}()
go func() {
s := kubeapiserver.NewAPIServer()
fs := pflag.NewFlagSet("apiserver", pflag.ContinueOnError)
s.AddFlags(fs)
fs.Parse([]string{
"--service-cluster-ip-range=" + *clusterIPRange,
"--etcd-servers=http://127.0.0.1:2379",
"--ssh-keyfile=" + *sshKeyfile,
"--ssh-user="******"controller", pflag.ContinueOnError)
s.AddFlags(fs)
fs.Parse([]string{})
s.Run([]string{})
}()
go func() {
s := scheduler.NewSchedulerServer()
fs := pflag.NewFlagSet("scheduler", pflag.ContinueOnError)
s.AddFlags(fs)
fs.Parse([]string{})
s.Run([]string{})
}()
<-make(chan interface{})
}
/*
WARNING: this logic is duplicated, with minor changes, in cmd/hyperkube/kubectl.go
Any salient changes here will need to be manually reflected in that file.
*/
func Run() error {
// need to use term.StdStreams to get the right IO refs on Windows
stdin, stdout, stderr := term.StdStreams()
cmd := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), stdin, stdout, stderr)
return cmd.Execute()
}
func main() {
// use os.Args instead of "flags" because "flags" will mess up the man pages!
path := "docs/man/man1"
module := ""
if len(os.Args) == 3 {
path = os.Args[1]
module = os.Args[2]
} else {
fmt.Fprintf(os.Stderr, "usage: %s [output directory] [module] \n", os.Args[0])
os.Exit(1)
}
outDir, err := genutils.OutDir(path)
if err != nil {
fmt.Fprintf(os.Stderr, "failed to get output directory: %v\n", err)
os.Exit(1)
}
// Set environment variables used by command so the output is consistent,
// regardless of where we run.
os.Setenv("HOME", "/home/username")
switch module {
case "kube-apiserver":
// generate manpage for kube-apiserver
apiserver := apiservapp.NewAPIServerCommand()
genMarkdown(apiserver, "", outDir)
for _, c := range apiserver.Commands() {
genMarkdown(c, "kube-apiserver", outDir)
}
case "kube-controller-manager":
// generate manpage for kube-controller-manager
controllermanager := cmapp.NewControllerManagerCommand()
genMarkdown(controllermanager, "", outDir)
for _, c := range controllermanager.Commands() {
genMarkdown(c, "kube-controller-manager", outDir)
}
case "kube-proxy":
// generate manpage for kube-proxy
proxy := proxyapp.NewProxyCommand()
genMarkdown(proxy, "", outDir)
for _, c := range proxy.Commands() {
genMarkdown(c, "kube-proxy", outDir)
}
case "kube-scheduler":
// generate manpage for kube-scheduler
scheduler := schapp.NewSchedulerCommand()
genMarkdown(scheduler, "", outDir)
for _, c := range scheduler.Commands() {
genMarkdown(c, "kube-scheduler", outDir)
}
case "kubelet":
// generate manpage for kubelet
kubelet := kubeletapp.NewKubeletCommand()
genMarkdown(kubelet, "", outDir)
for _, c := range kubelet.Commands() {
genMarkdown(c, "kubelet", outDir)
}
case "kubectl":
// generate manpage for kubectl
// TODO os.Stdin should really be something like ioutil.Discard, but a Reader
kubectl := kubectlcmd.NewKubectlCommand(kubectlcmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
genMarkdown(kubectl, "", outDir)
for _, c := range kubectl.Commands() {
genMarkdown(c, "kubectl", outDir)
}
default:
fmt.Fprintf(os.Stderr, "Module %s is not supported", module)
os.Exit(1)
}
}