func TestNormalizationFuncGlobalExistence(t *testing.T) { // This test can be safely deleted when we will not support multiple flag formats root := NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, os.Stdout, os.Stderr) if root.Parent() != nil { t.Fatal("We expect the root command to be returned") } if root.GlobalNormalizationFunc() == nil { t.Fatal("We expect that root command has a global normalization function") } if reflect.ValueOf(root.GlobalNormalizationFunc()).Pointer() != reflect.ValueOf(root.Flags().GetNormalizeFunc()).Pointer() { t.Fatal("root command seems to have a wrong normalization function") } sub := root for sub.HasSubCommands() { sub = sub.Commands()[0] } // In case of failure of this test check this PR: spf13/cobra#110 if reflect.ValueOf(sub.Flags().GetNormalizeFunc()).Pointer() != reflect.ValueOf(root.Flags().GetNormalizeFunc()).Pointer() { t.Fatal("child and root commands should have the same normalization functions") } }
func main() { runtime.GOMAXPROCS(runtime.NumCPU()) cmd := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, os.Stdout, os.Stderr) if err := cmd.Execute(); err != nil { os.Exit(1) } }
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 NewAPIFactory() (*cmdutil.Factory, *testFactory, runtime.Codec) { t := &testFactory{ Validator: validation.NullSchema{}, } generators := map[string]kubectl.Generator{ "run/v1": kubectl.BasicReplicationController{}, "run-pod/v1": kubectl.BasicPod{}, "service/v1": kubectl.ServiceGeneratorV1{}, "service/v2": kubectl.ServiceGeneratorV2{}, "service/test": testServiceGenerator{}, } f := &cmdutil.Factory{ Object: func() (meta.RESTMapper, runtime.ObjectTyper) { return testapi.Default.RESTMapper(), api.Scheme }, Client: func() (*client.Client, error) { // Swap out the HTTP client out of the client with the fake's version. fakeClient := t.Client.(*fake.RESTClient) c := client.NewOrDie(t.ClientConfig) c.Client = fakeClient.Client return c, t.Err }, RESTClient: func(*meta.RESTMapping) (resource.RESTClient, error) { return t.Client, t.Err }, Describer: func(*meta.RESTMapping) (kubectl.Describer, error) { return t.Describer, t.Err }, Printer: func(mapping *meta.RESTMapping, noHeaders, withNamespace bool, wide bool, showAll bool, columnLabels []string) (kubectl.ResourcePrinter, error) { return t.Printer, t.Err }, Validator: func(validate bool, cacheDir string) (validation.Schema, error) { return t.Validator, t.Err }, DefaultNamespace: func() (string, bool, error) { return t.Namespace, false, t.Err }, ClientConfig: func() (*client.Config, error) { return t.ClientConfig, t.Err }, CanBeExposed: func(kind string) error { if kind != "ReplicationController" && kind != "Service" && kind != "Pod" { return fmt.Errorf("invalid resource provided: %v, only a replication controller, service or pod is accepted", kind) } return nil }, Generator: func(name string) (kubectl.Generator, bool) { generator, ok := generators[name] return generator, ok }, } rf := cmdutil.NewFactory(nil) f.PodSelectorForObject = rf.PodSelectorForObject return f, t, testapi.Default.Codec() }
func TestKubectlValidation(t *testing.T) { testCases := []struct { data string err bool }{ {`{"apiVersion": "v1", "kind": "thisObjectShouldNotExistInAnyGroup"}`, true}, {`{"apiVersion": "invalidVersion", "kind": "Pod"}`, true}, {`{"apiVersion": "v1", "kind": "Pod"}`, false}, // The following test the experimental api. // TOOD: Replace with something more robust. These may move. {`{"apiVersion": "extensions/v1beta1", "kind": "Ingress"}`, false}, {`{"apiVersion": "extensions/v1beta1", "kind": "Job"}`, false}, {`{"apiVersion": "vNotAVersion", "kind": "Job"}`, true}, } components := framework.NewMasterComponents(&framework.Config{}) defer components.Stop(true, true) ctx := clientcmdapi.NewContext() cfg := clientcmdapi.NewConfig() cluster := clientcmdapi.NewCluster() cluster.Server = components.ApiServer.URL cluster.InsecureSkipTLSVerify = true overrides := clientcmd.ConfigOverrides{ ClusterInfo: *cluster, Context: *ctx, CurrentContext: "test", } cmdConfig := clientcmd.NewNonInteractiveClientConfig(*cfg, "test", &overrides) factory := util.NewFactory(cmdConfig) schema, err := factory.Validator(true, "") if err != nil { t.Errorf("failed to get validator: %v", err) return } for i, test := range testCases { err := schema.ValidateBytes([]byte(test.data)) if err == nil { if test.err { t.Errorf("case %d: expected error", i) } } else { if !test.err { t.Errorf("case %d: unexpected error: %v", i, err) } } } }
func NewDeployer() *Deployer { mux := http.NewServeMux() factory := cmdutil.NewFactory(nil) factory.BindFlags(pflag.CommandLine) s := &Deployer{ BindAddress: util.IP(net.ParseIP("0.0.0.0")), BindPort: 10253, Authentication: false, Authorization: false, Mux: mux, HandlerContainer: newRESTContainer(mux), Factory: factory, WebService: NewRESTWebService(), } return s }
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) }