// executeNamespaceRequest handles client operations for namespaces func executeNamespaceRequest(method string, c *client.Client) bool { var err error var ns *kubecfg.NamespaceInfo switch method { case "ns": args := flag.Args() switch len(args) { case 1: ns, err = kubecfg.LoadNamespaceInfo(*nsFile) case 2: ns = &kubecfg.NamespaceInfo{Namespace: args[1]} err = kubecfg.SaveNamespaceInfo(*nsFile, ns) default: glog.Fatalf("usage: kubecfg ns [<namespace>]") } default: return false } if err != nil { glog.Fatalf("Error: %v", err) } fmt.Printf("Using namespace %s\n", ns.Namespace) return true }
func main() { flag.Usage = func() { usage() } flag.Parse() util.InitLogs() defer util.FlushLogs() verflag.PrintAndExitIfRequested() // Initialize the client if clientConfig.Host == "" { clientConfig.Host = os.Getenv("KUBERNETES_MASTER") } // Load namespace information for requests // Check if the namespace was overriden by the -ns argument ctx := api.NewDefaultContext() if len(*ns) > 0 { ctx = api.WithNamespace(ctx, *ns) } else { nsInfo, err := kubecfg.LoadNamespaceInfo(*nsFile) if err != nil { glog.Fatalf("Error loading current namespace: %v", err) } ctx = api.WithNamespace(ctx, nsInfo.Namespace) } if clientConfig.Host == "" { // TODO: eventually apiserver should start on 443 and be secure by default // TODO: don't specify http or https in Host, and infer that from auth options. clientConfig.Host = "http://localhost:8080" } if client.IsConfigTransportTLS(*clientConfig) { auth, err := kubecfg.LoadClientAuthInfoOrPrompt(*authConfig, os.Stdin) if err != nil { glog.Fatalf("Error loading auth: %v", err) } clientConfig.Username = auth.User clientConfig.Password = auth.Password if auth.CAFile != "" { clientConfig.CAFile = auth.CAFile } if auth.CertFile != "" { clientConfig.CertFile = auth.CertFile } if auth.KeyFile != "" { clientConfig.KeyFile = auth.KeyFile } if auth.BearerToken != "" { clientConfig.BearerToken = auth.BearerToken } if auth.Insecure != nil { clientConfig.Insecure = *auth.Insecure } } kubeClient, err := client.New(clientConfig) if err != nil { glog.Fatalf("Can't configure client: %v", err) } if *serverVersion != verflag.VersionFalse { got, err := kubeClient.ServerVersion() if err != nil { fmt.Printf("Couldn't read version from server: %v\n", err) os.Exit(1) } if *serverVersion == verflag.VersionRaw { fmt.Printf("%#v\n", *got) os.Exit(0) } else { fmt.Printf("Server: Kubernetes %s\n", got) os.Exit(0) } } if *preventSkew { got, err := kubeClient.ServerVersion() if err != nil { fmt.Printf("Couldn't read version from server: %v\n", err) os.Exit(1) } if c, s := version.Get(), *got; !reflect.DeepEqual(c, s) { fmt.Printf("Server version (%#v) differs from client version (%#v)!\n", s, c) os.Exit(1) } } if *proxy { glog.Info("Starting to serve on localhost:8001") if *openBrowser { go func() { time.Sleep(2 * time.Second) open.Start("http://localhost:8001/static/") }() } server, err := kubecfg.NewProxyServer(*www, clientConfig) if err != nil { glog.Fatalf("Error creating proxy server: %v", err) } glog.Fatal(server.Serve()) } if len(flag.Args()) < 1 { usage() os.Exit(1) } method := flag.Arg(0) matchFound := executeAPIRequest(ctx, method, kubeClient) || executeControllerRequest(ctx, method, kubeClient) || executeNamespaceRequest(method, kubeClient) if matchFound == false { glog.Fatalf("Unknown command %s", method) } }