func TestVersion(t *testing.T) { handler := New(map[string]RESTStorage{}, codec, "/prefix/version") server := httptest.NewServer(handler) client := http.Client{} request, err := http.NewRequest("GET", server.URL+"/version", nil) if err != nil { t.Errorf("unexpected error: %v", err) } response, err := client.Do(request) if err != nil { t.Errorf("unexpected error: %v", err) } var info version.Info err = json.NewDecoder(response.Body).Decode(&info) if err != nil { t.Errorf("unexpected error: %v", err) } if !reflect.DeepEqual(version.Get(), info) { t.Errorf("Expected %#v, Got %#v", version.Get(), info) } }
// PrintAndExitIfRequested will check if the -version flag was passed // and, if so, print the version and exit. func PrintAndExitIfRequested() { if *versionFlag == VersionRaw { fmt.Printf("%#v\n", version.Get()) os.Exit(0) } else if *versionFlag == VersionTrue { fmt.Printf("Kubernetes %s\n", version.Get()) os.Exit(0) } }
// DefaultKubernetesUserAgent returns the default user agent that clients can use. func DefaultKubernetesUserAgent() string { commit := version.Get().GitCommit if len(commit) > 7 { commit = commit[:7] } if len(commit) == 0 { commit = "unknown" } version := version.Get().GitVersion seg := strings.SplitN(version, "-", 2) version = seg[0] return fmt.Sprintf("%s/%s (%s/%s) kubernetes/%s", path.Base(os.Args[0]), version, gruntime.GOOS, gruntime.GOARCH, commit) }
func main() { openshiftCmd := &cobra.Command{ Use: "openshift", Short: "OpenShift helps you build, deploy, and manage your applications", Long: longDescription, Run: func(c *cobra.Command, args []string) { c.Help() }, } openshiftCmd.AddCommand(master.NewCommandStartAllInOne("start")) openshiftCmd.AddCommand(client.NewCommandKubecfg("kube")) openshiftCmd.AddCommand(tour.NewCommandTour("tour")) // version information versionCmd := &cobra.Command{ Use: "version", Short: "Display version", Run: func(c *cobra.Command, args []string) { fmt.Printf("openshift %v\n", version.Get()) fmt.Printf("kubernetes %v\n", kubeversion.Get()) }, } openshiftCmd.AddCommand(versionCmd) if err := openshiftCmd.Execute(); err != nil { fmt.Fprintf(os.Stderr, "Error: %s", err) os.Exit(1) } }
func (c *Fake) ServerVersion() (*version.Info, error) { c.Lock.Lock() defer c.Lock.Unlock() c.Actions = append(c.Actions, FakeAction{Action: "get-version", Value: nil}) versionInfo := version.Get() return &versionInfo, nil }
func (c *Fake) ServerVersion() (*version.Info, error) { action := ActionImpl{} action.Verb = "get" action.Resource = "version" c.Invokes(action, nil) versionInfo := version.Get() return &versionInfo, nil }
// NewVersionCommand creates a command for displaying the version of this binary func NewVersionCommand(basename string) *cobra.Command { return &cobra.Command{ Use: "version", Short: "Display version", Run: func(c *cobra.Command, args []string) { fmt.Printf("%s %v\n", basename, Get()) fmt.Printf("kubernetes %v\n", kubeversion.Get()) }, } }
func MatchesServerVersion(c *Config) error { client, err := New(c) if err != nil { return err } clientVersion := version.Get() serverVersion, err := client.ServerVersion() if err != nil { return fmt.Errorf("couldn't read version from server: %v\n", err) } if s := *serverVersion; !reflect.DeepEqual(clientVersion, s) { return fmt.Errorf("server version (%#v) differs from client version (%#v)!\n", s, clientVersion) } return nil }
func GetKubeClient(config *client.Config, matchVersion bool) (*client.Client, error) { // TODO: get the namespace context when kubectl ns is completed c, err := client.New(config) if err != nil { return nil, err } if matchVersion { clientVersion := version.Get() serverVersion, err := c.ServerVersion() if err != nil { return nil, fmt.Errorf("couldn't read version from server: %v\n", err) } if s := *serverVersion; !reflect.DeepEqual(clientVersion, s) { return nil, fmt.Errorf("server version (%#v) differs from client version (%#v)!\n", s, clientVersion) } } return c, nil }
func (c *KubeConfig) Run() { util.InitLogs() defer util.FlushLogs() var masterServer string if len(c.HttpServer) > 0 { masterServer = c.HttpServer } else if len(os.Getenv("KUBERNETES_MASTER")) > 0 { masterServer = os.Getenv("KUBERNETES_MASTER") } else { masterServer = "http://localhost:8080" } kubeClient, err := kubeclient.New(masterServer, nil) if err != nil { glog.Fatalf("Unable to parse %s as a URL: %v", masterServer, err) } client, err := osclient.New(masterServer, nil) if err != nil { glog.Fatalf("Unable to parse %s as a URL: %v", masterServer, err) } // TODO: this won't work if TLS is enabled with client cert auth, but no // passwords are required. Refactor when we address client auth abstraction. if kubeClient.Secure() { auth, err := kubecfg.LoadAuthInfo(c.AuthConfig, os.Stdin) if err != nil { glog.Fatalf("Error loading auth: %v", err) } kubeClient, err = kubeclient.New(masterServer, auth) if err != nil { glog.Fatalf("Unable to parse %s as a URL: %v", masterServer, err) } client, err = osclient.New(masterServer, auth) if err != nil { glog.Fatalf("Unable to parse %s as a URL: %v", masterServer, err) } } // check the kubernetes server version if c.ServerVersion { got, err := kubeClient.ServerVersion() if err != nil { fmt.Printf("Couldn't read version from server: %v\n", err) os.Exit(1) } fmt.Printf("Server Version: %#v\n", got) os.Exit(0) } if c.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 c.Proxy { glog.Info("Starting to serve on localhost:8001") server := kubecfg.NewProxyServer(c.WWW, kubeClient) glog.Fatal(server.Serve()) } method := c.Arg(0) clients := map[string]RESTClient{ "minions": kubeClient.RESTClient, "pods": kubeClient.RESTClient, "services": kubeClient.RESTClient, "replicationControllers": kubeClient.RESTClient, "builds": client.RESTClient, "buildConfigs": client.RESTClient, "images": client.RESTClient, "imageRepositories": client.RESTClient, "imageRepositoryMappings": client.RESTClient, } matchFound := c.executeAPIRequest(method, clients) || c.executeControllerRequest(method, kubeClient) if matchFound == false { glog.Fatalf("Unknown command %s", method) } }
// PrintAndExitIfRequested will check if the -version flag was passed // and, if so, print the version and exit. func PrintAndExitIfRequested() { if *versionFlag { fmt.Printf("Kubernetes %s\n", version.Get()) os.Exit(0) } }
func main() { flag.Usage = func() { usage() } flag.Parse() util.InitLogs() defer util.FlushLogs() verflag.PrintAndExitIfRequested() secure := true var masterServer string if len(*httpServer) > 0 { masterServer = *httpServer } else if len(os.Getenv("KUBERNETES_MASTER")) > 0 { masterServer = os.Getenv("KUBERNETES_MASTER") } else { masterServer = "http://localhost:8080" } parsedURL, err := url.Parse(masterServer) if err != nil { glog.Fatalf("Unable to parse %v as a URL\n", err) } if parsedURL.Scheme != "" && parsedURL.Scheme != "https" { secure = false } var auth *kube_client.AuthInfo if secure { auth, err = kubecfg.LoadAuthInfo(*authConfig, os.Stdin) if err != nil { glog.Fatalf("Error loading auth: %v", err) } } client := kube_client.New(masterServer, auth) if *serverVersion { got, err := client.ServerVersion() if err != nil { fmt.Printf("Couldn't read version from server: %v\n", err) os.Exit(1) } fmt.Printf("Server Version: %#v\n", got) os.Exit(0) } if *preventSkew { got, err := client.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") server := kubecfg.NewProxyServer(*www, masterServer, auth) glog.Fatal(server.Serve()) } if len(flag.Args()) < 1 { usage() os.Exit(1) } method := flag.Arg(0) matchFound := executeAPIRequest(method, client) || executeControllerRequest(method, client) if matchFound == false { glog.Fatalf("Unknown command %s", method) } }
// handleVersionReq writes the server's version information. func handleVersion(w http.ResponseWriter, req *http.Request) { writeRawJSON(http.StatusOK, version.Get(), w) }
func TestClient(t *testing.T) { m := master.New(&master.Config{ EtcdServers: newEtcdClient().GetCluster(), }) storage, codec := m.API_v1beta1() s := httptest.NewServer(apiserver.Handle(storage, codec, "/api/v1beta1/")) client := client.NewOrDie(s.URL, nil) info, err := client.ServerVersion() if err != nil { t.Fatalf("unexpected error: %v", err) } if e, a := version.Get(), *info; !reflect.DeepEqual(e, a) { t.Errorf("expected %#v, got %#v", e, a) } pods, err := client.ListPods(labels.Everything()) if err != nil { t.Fatalf("unexpected error: %v", err) } if len(pods.Items) != 0 { t.Errorf("expected no pods, got %#v", pods) } // get a validation error pod := &api.Pod{ DesiredState: api.PodState{ Manifest: api.ContainerManifest{ Version: "v1beta2", Containers: []api.Container{ { Name: "test", }, }, }, }, } got, err := client.CreatePod(pod) if err == nil { t.Fatalf("unexpected non-error: %v", err) } // get a created pod pod.DesiredState.Manifest.Containers[0].Image = "an-image" got, err = client.CreatePod(pod) if err != nil { t.Fatalf("unexpected error: %v", err) } if got.ID == "" { t.Errorf("unexpected empty pod ID %v", got) } // pod is shown, but not scheduled pods, err = client.ListPods(labels.Everything()) if err != nil { t.Fatalf("unexpected error: %v", err) } if len(pods.Items) != 1 { t.Errorf("expected one pod, got %#v", pods) } actual := pods.Items[0] if actual.ID != got.ID { t.Errorf("expected pod %#v, got %#v", got, actual) } if actual.CurrentState.Host != "" { t.Errorf("expected pod to be unscheduled, got %#v", actual) } }
// handleVersion writes the server's version information. func handleVersion(req *restful.Request, resp *restful.Response) { // TODO: use restful's Response methods writeRawJSON(http.StatusOK, version.Get(), resp.ResponseWriter) }
func TestClient(t *testing.T) { helper, err := master.NewEtcdHelper(newEtcdClient(), "v1beta1") if err != nil { t.Fatalf("unexpected error: %v", err) } var m *master.Master s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { m.Handler.ServeHTTP(w, req) })) defer s.Close() m = master.New(&master.Config{ Client: client.NewOrDie(&client.Config{Host: s.URL}), EtcdHelper: helper, KubeletClient: client.FakeKubeletClient{}, EnableLogsSupport: false, EnableProfiling: true, EnableUISupport: false, APIPrefix: "/api", Authorizer: apiserver.NewAlwaysAllowAuthorizer(), AdmissionControl: admit.NewAlwaysAdmit(), }) testCases := []string{ "v1beta1", "v1beta2", } for _, apiVersion := range testCases { ns := api.NamespaceDefault deleteAllEtcdKeys() client := client.NewOrDie(&client.Config{Host: s.URL, Version: apiVersion}) info, err := client.ServerVersion() if err != nil { t.Fatalf("unexpected error: %v", err) } if e, a := version.Get(), *info; !reflect.DeepEqual(e, a) { t.Errorf("expected %#v, got %#v", e, a) } pods, err := client.Pods(ns).List(labels.Everything()) if err != nil { t.Fatalf("unexpected error: %v", err) } if len(pods.Items) != 0 { t.Errorf("expected no pods, got %#v", pods) } // get a validation error pod := &api.Pod{ ObjectMeta: api.ObjectMeta{ GenerateName: "test", }, Spec: api.PodSpec{ Containers: []api.Container{ { Name: "test", }, }, }, } got, err := client.Pods(ns).Create(pod) if err == nil { t.Fatalf("unexpected non-error: %v", got) } // get a created pod pod.Spec.Containers[0].Image = "an-image" got, err = client.Pods(ns).Create(pod) if err != nil { t.Fatalf("unexpected error: %v", err) } if got.Name == "" { t.Errorf("unexpected empty pod Name %v", got) } // pod is shown, but not scheduled pods, err = client.Pods(ns).List(labels.Everything()) if err != nil { t.Fatalf("unexpected error: %v", err) } if len(pods.Items) != 1 { t.Errorf("expected one pod, got %#v", pods) } actual := pods.Items[0] if actual.Name != got.Name { t.Errorf("expected pod %#v, got %#v", got, actual) } if actual.Status.Host != "" { t.Errorf("expected pod to be unscheduled, got %#v", actual) } } }
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) } }
func TestClient(t *testing.T) { helper, err := master.NewEtcdHelper(newEtcdClient(), "v1beta1") if err != nil { t.Fatalf("unexpected error: %v", err) } m := master.New(&master.Config{ EtcdHelper: helper, KubeletClient: client.FakeKubeletClient{}, EnableLogsSupport: false, EnableUISupport: false, APIPrefix: "/api", Authorizer: apiserver.NewAlwaysAllowAuthorizer(), }) s := httptest.NewServer(m.Handler) defer s.Close() testCases := []string{ "v1beta1", "v1beta2", } for _, apiVersion := range testCases { ns := api.NamespaceDefault deleteAllEtcdKeys() client := client.NewOrDie(&client.Config{Host: s.URL, Version: apiVersion}) info, err := client.ServerVersion() if err != nil { t.Fatalf("unexpected error: %v", err) } if e, a := version.Get(), *info; !reflect.DeepEqual(e, a) { t.Errorf("expected %#v, got %#v", e, a) } pods, err := client.Pods(ns).List(labels.Everything()) if err != nil { t.Fatalf("unexpected error: %v", err) } if len(pods.Items) != 0 { t.Errorf("expected no pods, got %#v", pods) } // get a validation error pod := &api.Pod{ DesiredState: api.PodState{ Manifest: api.ContainerManifest{ Version: "v1beta2", Containers: []api.Container{ { Name: "test", }, }, }, }, } got, err := client.Pods(ns).Create(pod) if err == nil { t.Fatalf("unexpected non-error: %v", err) } // get a created pod pod.DesiredState.Manifest.Containers[0].Image = "an-image" got, err = client.Pods(ns).Create(pod) if err != nil { t.Fatalf("unexpected error: %v", err) } if got.Name == "" { t.Errorf("unexpected empty pod Name %v", got) } // pod is shown, but not scheduled pods, err = client.Pods(ns).List(labels.Everything()) if err != nil { t.Fatalf("unexpected error: %v", err) } if len(pods.Items) != 1 { t.Errorf("expected one pod, got %#v", pods) } actual := pods.Items[0] if actual.Name != got.Name { t.Errorf("expected pod %#v, got %#v", got, actual) } if actual.CurrentState.Host != "" { t.Errorf("expected pod to be unscheduled, got %#v", actual) } } }
func TestClient(t *testing.T) { _, s := framework.RunAMaster(t) defer s.Close() ns := api.NamespaceDefault framework.DeleteAllEtcdKeys() client := client.NewOrDie(&client.Config{Host: s.URL, Version: testapi.Version()}) info, err := client.ServerVersion() if err != nil { t.Fatalf("unexpected error: %v", err) } if e, a := version.Get(), *info; !reflect.DeepEqual(e, a) { t.Errorf("expected %#v, got %#v", e, a) } pods, err := client.Pods(ns).List(labels.Everything(), fields.Everything()) if err != nil { t.Fatalf("unexpected error: %v", err) } if len(pods.Items) != 0 { t.Errorf("expected no pods, got %#v", pods) } // get a validation error pod := &api.Pod{ ObjectMeta: api.ObjectMeta{ GenerateName: "test", }, Spec: api.PodSpec{ Containers: []api.Container{ { Name: "test", }, }, }, } got, err := client.Pods(ns).Create(pod) if err == nil { t.Fatalf("unexpected non-error: %v", got) } // get a created pod pod.Spec.Containers[0].Image = "an-image" got, err = client.Pods(ns).Create(pod) if err != nil { t.Fatalf("unexpected error: %v", err) } if got.Name == "" { t.Errorf("unexpected empty pod Name %v", got) } // pod is shown, but not scheduled pods, err = client.Pods(ns).List(labels.Everything(), fields.Everything()) if err != nil { t.Fatalf("unexpected error: %v", err) } if len(pods.Items) != 1 { t.Errorf("expected one pod, got %#v", pods) } actual := pods.Items[0] if actual.Name != got.Name { t.Errorf("expected pod %#v, got %#v", got, actual) } if actual.Spec.NodeName != "" { t.Errorf("expected pod to be unscheduled, got %#v", actual) } }
func TestBuildConfigClient(t *testing.T) { etcdClient := newEtcdClient() m := master.New(&master.Config{ EtcdServers: etcdClient.GetCluster(), }) osMux := http.NewServeMux() storage := map[string]apiserver.RESTStorage{ "builds": buildregistry.NewStorage(build.NewEtcdRegistry(etcdClient)), "buildConfigs": buildconfigregistry.NewStorage(build.NewEtcdRegistry(etcdClient)), } apiserver.NewAPIGroup(m.API_v1beta1()).InstallREST(osMux, "/api/v1beta1") apiserver.NewAPIGroup(storage, runtime.Codec).InstallREST(osMux, "/osapi/v1beta1") apiserver.InstallSupport(osMux) s := httptest.NewServer(osMux) kubeclient := client.NewOrDie(s.URL, nil) osclient, _ := osclient.New(s.URL, nil) info, err := kubeclient.ServerVersion() if err != nil { t.Fatalf("unexpected error: %v", err) } if e, a := version.Get(), *info; !reflect.DeepEqual(e, a) { t.Errorf("expected %#v, got %#v", e, a) } buildConfigs, err := osclient.ListBuildConfigs(labels.Everything()) if err != nil { t.Fatalf("unexpected error %v", err) } if len(buildConfigs.Items) != 0 { t.Errorf("expected no buildConfigs, got %#v", buildConfigs) } // get a validation error buildConfig := &api.BuildConfig{ Labels: map[string]string{ "label1": "value1", "label2": "value2", }, DesiredInput: api.BuildInput{ Type: api.DockerBuildType, SourceURI: "http://my.docker/build", ImageTag: "namespace/builtimage", BuilderImage: "anImage", }, } got, err := osclient.CreateBuildConfig(buildConfig) if err == nil { t.Fatalf("unexpected non-error: %v", err) } // get a created buildConfig buildConfig.DesiredInput.BuilderImage = "" got, err = osclient.CreateBuildConfig(buildConfig) if err != nil { t.Fatalf("unexpected error: %v", err) } if got.ID == "" { t.Errorf("unexpected empty buildConfig ID %v", got) } // get a list of buildConfigs buildConfigs, err = osclient.ListBuildConfigs(labels.Everything()) if err != nil { t.Fatalf("unexpected error: %v", err) } if len(buildConfigs.Items) != 1 { t.Errorf("expected one buildConfig, got %#v", buildConfigs) } actual := buildConfigs.Items[0] if actual.ID != got.ID { t.Errorf("expected buildConfig %#v, got %#v", got, actual) } // delete a buildConfig err = osclient.DeleteBuildConfig(got.ID) if err != nil { t.Fatalf("unexpected error %v", err) } buildConfigs, err = osclient.ListBuildConfigs(labels.Everything()) if err != nil { t.Fatalf("unexpected error %v", err) } if len(buildConfigs.Items) != 0 { t.Errorf("expected no buildConfigs, got %#v", buildConfigs) } }
func TestWebhookGithubPush(t *testing.T) { etcdClient := newEtcdClient() m := master.New(&master.Config{ EtcdServers: etcdClient.GetCluster(), }) osMux := http.NewServeMux() storage := map[string]apiserver.RESTStorage{ "builds": buildregistry.NewStorage(build.NewEtcdRegistry(etcdClient)), "buildConfigs": buildconfigregistry.NewStorage(build.NewEtcdRegistry(etcdClient)), } apiserver.NewAPIGroup(m.API_v1beta1()).InstallREST(osMux, "/api/v1beta1") osPrefix := "/osapi/v1beta1" apiserver.NewAPIGroup(storage, runtime.Codec).InstallREST(osMux, osPrefix) apiserver.InstallSupport(osMux) s := httptest.NewServer(osMux) kubeclient := client.NewOrDie(s.URL, nil) osClient, _ := osclient.New(s.URL, nil) whPrefix := osPrefix + "/buildConfigHooks/" osMux.Handle(whPrefix, http.StripPrefix(whPrefix, webhook.NewController(osClient, map[string]webhook.Plugin{ "github": github.New(), }))) info, err := kubeclient.ServerVersion() if err != nil { t.Fatalf("Unexpected error: %v", err) } if e, a := version.Get(), *info; !reflect.DeepEqual(e, a) { t.Errorf("Expected %#v, got %#v", e, a) } // create buildconfig buildConfig := &buildapi.BuildConfig{ JSONBase: kubeapi.JSONBase{ ID: "build100", }, DesiredInput: buildapi.BuildInput{ Type: buildapi.DockerBuildType, SourceURI: "http://my.docker/build", ImageTag: "namespace/builtimage", }, Secret: "secret101", } if _, err := osClient.CreateBuildConfig(buildConfig); err != nil { t.Fatalf("Unexpected error: %v", err) } // trigger build event sending push notification client := &http.Client{} data, err := ioutil.ReadFile("../../pkg/build/webhook/github/fixtures/pushevent.json") if err != nil { t.Fatalf("Failed to open pushevent.json: %v", err) } req, err := http.NewRequest("POST", s.URL+whPrefix+"build100/secret101/github", bytes.NewReader(data)) if err != nil { t.Fatalf("Error creating POST request: %v", err) } req.Header.Add("Content-Type", "application/json") req.Header.Add("User-Agent", "GitHub-Hookshot/github") req.Header.Add("X-Github-Event", "push") resp, err := client.Do(req) if err != nil { t.Fatalf("Failed posting webhook: %v", err) } body, _ := ioutil.ReadAll(resp.Body) if resp.StatusCode != http.StatusOK { t.Errorf("Wrong response code, expecting 200, got %s: %s!", resp.Status, string(body)) } // get a list of builds builds, err := osClient.ListBuilds(labels.Everything()) if err != nil { t.Fatalf("Unexpected error: %v", err) } if len(builds.Items) != 1 { t.Fatalf("Expected one build, got %#v", builds) } actual := builds.Items[0] if actual.Status != buildapi.BuildNew { t.Errorf("Expected %s, got %s", buildapi.BuildNew, actual.Status) } if !reflect.DeepEqual(actual.Input, buildConfig.DesiredInput) { t.Errorf("Expected %#v, got %#v", buildConfig.DesiredInput, actual.Input) } }
func GetClientVersion(w io.Writer) { fmt.Fprintf(w, "Client Version: %#v\n", version.Get()) }
func (c *Fake) ServerVersion() (*version.Info, error) { c.Invokes(FakeAction{Action: "get-version", Value: nil}, nil) versionInfo := version.Get() return &versionInfo, nil }
func main() { flag.Usage = func() { usage() } flag.Parse() util.InitLogs() defer util.FlushLogs() verflag.PrintAndExitIfRequested() var masterServer string if len(*httpServer) > 0 { masterServer = *httpServer } else if len(os.Getenv("KUBERNETES_MASTER")) > 0 { masterServer = os.Getenv("KUBERNETES_MASTER") } else { masterServer = "http://localhost:8080" } kubeClient, err := client.New(masterServer, nil) if err != nil { glog.Fatalf("Unable to parse %s as a URL: %v", masterServer, err) } // TODO: this won't work if TLS is enabled with client cert auth, but no // passwords are required. Refactor when we address client auth abstraction. if kubeClient.Secure() { auth, err := kubecfg.LoadAuthInfo(*authConfig, os.Stdin) if err != nil { glog.Fatalf("Error loading auth: %v", err) } kubeClient, err = client.New(masterServer, auth) if err != nil { glog.Fatalf("Unable to parse %s as a URL: %v", masterServer, err) } } if *serverVersion { got, err := kubeClient.ServerVersion() if err != nil { fmt.Printf("Couldn't read version from server: %v\n", err) os.Exit(1) } fmt.Printf("Server Version: %#v\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") server := kubecfg.NewProxyServer(*www, kubeClient) glog.Fatal(server.Serve()) } if len(flag.Args()) < 1 { usage() os.Exit(1) } method := flag.Arg(0) matchFound := executeAPIRequest(method, kubeClient) || executeControllerRequest(method, kubeClient) if matchFound == false { glog.Fatalf("Unknown command %s", method) } }