// NewForConfigOrDie creates a new Clientset for the given config and // panics if there is an error in the config. func NewForConfigOrDie(c *restclient.Config) *Clientset { var clientset Clientset clientset.CoreClient = v1core.NewForConfigOrDie(c) clientset.AuthorizationClient = v1beta1authorization.NewForConfigOrDie(c) clientset.AutoscalingClient = v1autoscaling.NewForConfigOrDie(c) clientset.BatchClient = v1batch.NewForConfigOrDie(c) clientset.ExtensionsClient = v1beta1extensions.NewForConfigOrDie(c) clientset.PolicyClient = v1alpha1policy.NewForConfigOrDie(c) clientset.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) return &clientset }
// NewForConfigOrDie creates a new Clientset for the given config and // panics if there is an error in the config. func NewForConfigOrDie(c *restclient.Config) *Clientset { var clientset Clientset clientset.CoreClient = v1core.NewForConfigOrDie(c) clientset.AppsClient = v1alpha1apps.NewForConfigOrDie(c) clientset.AuthenticationClient = v1beta1authentication.NewForConfigOrDie(c) clientset.AuthorizationClient = v1beta1authorization.NewForConfigOrDie(c) clientset.AutoscalingClient = v1autoscaling.NewForConfigOrDie(c) clientset.BatchClient = v1batch.NewForConfigOrDie(c) clientset.CertificatesClient = v1alpha1certificates.NewForConfigOrDie(c) clientset.ExtensionsClient = v1beta1extensions.NewForConfigOrDie(c) clientset.PolicyClient = v1alpha1policy.NewForConfigOrDie(c) clientset.RbacClient = v1alpha1rbac.NewForConfigOrDie(c) clientset.StorageClient = v1beta1storage.NewForConfigOrDie(c) clientset.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) return &clientset }
// startMasterOrDie starts a kubernetes master and an httpserver to handle api requests func startMasterOrDie(masterConfig *master.Config, incomingServer *httptest.Server, masterReceiver MasterReceiver) (*master.Master, *httptest.Server) { var m *master.Master var s *httptest.Server if incomingServer != nil { s = incomingServer } else { s = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { m.GenericAPIServer.Handler.ServeHTTP(w, req) })) } if masterConfig == nil { masterConfig = NewMasterConfig() masterConfig.GenericConfig.EnableProfiling = true masterConfig.GenericConfig.EnableSwaggerSupport = true masterConfig.GenericConfig.EnableOpenAPISupport = true masterConfig.GenericConfig.OpenAPIConfig.Info = &spec.Info{ InfoProps: spec.InfoProps{ Title: "Kubernetes", Version: "unversioned", }, } masterConfig.GenericConfig.OpenAPIConfig.DefaultResponse = &spec.Response{ ResponseProps: spec.ResponseProps{ Description: "Default Response.", }, } masterConfig.GenericConfig.OpenAPIConfig.Definitions = openapi.OpenAPIDefinitions } // set the loopback client config if masterConfig.GenericConfig.LoopbackClientConfig == nil { masterConfig.GenericConfig.LoopbackClientConfig = &restclient.Config{QPS: 50, Burst: 100, ContentConfig: restclient.ContentConfig{NegotiatedSerializer: api.Codecs}} } masterConfig.GenericConfig.LoopbackClientConfig.Host = s.URL privilegedLoopbackToken := uuid.NewRandom().String() // wrap any available authorizer tokens := make(map[string]*user.DefaultInfo) tokens[privilegedLoopbackToken] = &user.DefaultInfo{ Name: user.APIServerUser, UID: uuid.NewRandom().String(), Groups: []string{user.SystemPrivilegedGroup}, } tokenAuthenticator := authenticator.NewAuthenticatorFromTokens(tokens) if masterConfig.GenericConfig.Authenticator == nil { masterConfig.GenericConfig.Authenticator = authenticatorunion.New(tokenAuthenticator, authauthenticator.RequestFunc(alwaysEmpty)) } else { masterConfig.GenericConfig.Authenticator = authenticatorunion.New(tokenAuthenticator, masterConfig.GenericConfig.Authenticator) } if masterConfig.GenericConfig.Authorizer != nil { tokenAuthorizer := authorizer.NewPrivilegedGroups(user.SystemPrivilegedGroup) masterConfig.GenericConfig.Authorizer = authorizerunion.New(tokenAuthorizer, masterConfig.GenericConfig.Authorizer) } else { masterConfig.GenericConfig.Authorizer = alwaysAllow{} } masterConfig.GenericConfig.LoopbackClientConfig.BearerToken = privilegedLoopbackToken m, err := masterConfig.Complete().New() if err != nil { glog.Fatalf("error in bringing up the master: %v", err) } if masterReceiver != nil { masterReceiver.SetMaster(m) } cfg := *masterConfig.GenericConfig.LoopbackClientConfig cfg.ContentConfig.GroupVersion = &unversioned.GroupVersion{} privilegedClient, err := restclient.RESTClientFor(&cfg) if err != nil { glog.Fatal(err) } err = wait.PollImmediate(100*time.Millisecond, 30*time.Second, func() (bool, error) { result := privilegedClient.Get().AbsPath("/healthz").Do() status := 0 result.StatusCode(&status) if status == 200 { return true, nil } return false, nil }) if err != nil { glog.Fatal(err) } // TODO have this start method actually use the normal start sequence for the API server // this method never actually calls the `Run` method for the API server // fire the post hooks ourselves m.GenericAPIServer.RunPostStartHooks() // wait for services to be ready if masterConfig.EnableCoreControllers { // TODO Once /healthz is updated for posthooks, we'll wait for good health coreClient := coreclient.NewForConfigOrDie(&cfg) svcWatch, err := coreClient.Services(api.NamespaceDefault).Watch(v1.ListOptions{}) if err != nil { glog.Fatal(err) } _, err = watch.Until(30*time.Second, svcWatch, func(event watch.Event) (bool, error) { if event.Type != watch.Added { return false, nil } if event.Object.(*v1.Service).Name == "kubernetes" { return true, nil } return false, nil }) if err != nil { glog.Fatal(err) } } return m, s }
// TestUpdateNodeObjects represents a simple version of the behavior of node checkins at steady // state. This test allows for easy profiling of a realistic master scenario for baseline CPU // in very large clusters. It is disabled by default - start a kube-apiserver and pass // UPDATE_NODE_APISERVER as the host value. func TestUpdateNodeObjects(t *testing.T) { server := os.Getenv("UPDATE_NODE_APISERVER") if len(server) == 0 { t.Skip("UPDATE_NODE_APISERVER is not set") } c := clienttypedv1.NewForConfigOrDie(&restclient.Config{ QPS: 10000, Host: server, ContentConfig: restclient.ContentConfig{ AcceptContentTypes: "application/vnd.kubernetes.protobuf", ContentType: "application/vnd.kubernetes.protobuf", }, }) nodes := 400 listers := 5 watchers := 50 iterations := 10000 for i := 0; i < nodes*6; i++ { c.Nodes().Delete(fmt.Sprintf("node-%d", i), nil) _, err := c.Nodes().Create(&v1.Node{ ObjectMeta: v1.ObjectMeta{ Name: fmt.Sprintf("node-%d", i), }, }) if err != nil { t.Fatal(err) } } for k := 0; k < listers; k++ { go func(lister int) { for i := 0; i < iterations; i++ { _, err := c.Nodes().List(v1.ListOptions{}) if err != nil { fmt.Printf("[list:%d] error after %d: %v\n", lister, i, err) break } time.Sleep(time.Duration(lister)*10*time.Millisecond + 1500*time.Millisecond) } }(k) } for k := 0; k < watchers; k++ { go func(lister int) { w, err := c.Nodes().Watch(v1.ListOptions{}) if err != nil { fmt.Printf("[watch:%d] error: %v", k, err) return } i := 0 for r := range w.ResultChan() { i++ if _, ok := r.Object.(*v1.Node); !ok { fmt.Printf("[watch:%d] unexpected object after %d: %#v\n", lister, i, r) } if i%100 == 0 { fmt.Printf("[watch:%d] iteration %d ...\n", lister, i) } } fmt.Printf("[watch:%d] done\n", lister) }(k) } var wg sync.WaitGroup wg.Add(nodes - listers) for j := 0; j < nodes; j++ { go func(node int) { var lastCount int for i := 0; i < iterations; i++ { if i%100 == 0 { fmt.Printf("[%d] iteration %d ...\n", node, i) } if i%20 == 0 { _, err := c.Nodes().List(v1.ListOptions{}) if err != nil { fmt.Printf("[%d] error after %d: %v\n", node, i, err) break } } r, err := c.Nodes().List(v1.ListOptions{ FieldSelector: fmt.Sprintf("metadata.name=node-%d", node), ResourceVersion: "0", }) if err != nil { fmt.Printf("[%d] error after %d: %v\n", node, i, err) break } if len(r.Items) != 1 { fmt.Printf("[%d] error after %d: unexpected list count\n", node, i) break } n, err := c.Nodes().Get(fmt.Sprintf("node-%d", node)) if err != nil { fmt.Printf("[%d] error after %d: %v\n", node, i, err) break } if len(n.Status.Conditions) != lastCount { fmt.Printf("[%d] worker set %d, read %d conditions\n", node, lastCount, len(n.Status.Conditions)) break } previousCount := lastCount switch { case i%4 == 0: lastCount = 1 n.Status.Conditions = []v1.NodeCondition{ { Type: v1.NodeReady, Status: v1.ConditionTrue, Reason: "foo", }, } case i%4 == 1: lastCount = 2 n.Status.Conditions = []v1.NodeCondition{ { Type: v1.NodeReady, Status: v1.ConditionFalse, Reason: "foo", }, { Type: v1.NodeDiskPressure, Status: v1.ConditionTrue, Reason: "bar", }, } case i%4 == 1: lastCount = 0 n.Status.Conditions = nil } if _, err := c.Nodes().UpdateStatus(n); err != nil { if !errors.IsConflict(err) { fmt.Printf("[%d] error after %d: %v\n", node, i, err) break } lastCount = previousCount } } wg.Done() fmt.Printf("[%d] done\n", node) }(j) } wg.Wait() }
// New returns a new instance of Master from the given config. // Certain config fields will be set to a default value if unset. // Certain config fields must be specified, including: // KubeletClientConfig func (c completedConfig) New() (*Master, error) { if reflect.DeepEqual(c.KubeletClientConfig, kubeletclient.KubeletClientConfig{}) { return nil, fmt.Errorf("Master.New() called with empty config.KubeletClientConfig") } s, err := c.Config.GenericConfig.SkipComplete().New() // completion is done in Complete, no need for a second time if err != nil { return nil, err } if c.EnableUISupport { routes.UIRedirect{}.Install(s.HandlerContainer) } if c.EnableLogsSupport { routes.Logs{}.Install(s.HandlerContainer) } m := &Master{ GenericAPIServer: s, } restOptionsFactory := restOptionsFactory{ deleteCollectionWorkers: c.DeleteCollectionWorkers, enableGarbageCollection: c.GenericConfig.EnableGarbageCollection, storageFactory: c.StorageFactory, } if c.EnableWatchCache { restOptionsFactory.storageDecorator = genericregistry.StorageWithCacher } else { restOptionsFactory.storageDecorator = generic.UndecoratedStorage } // install legacy rest storage if c.GenericConfig.APIResourceConfigSource.AnyResourcesForVersionEnabled(apiv1.SchemeGroupVersion) { legacyRESTStorageProvider := corerest.LegacyRESTStorageProvider{ StorageFactory: c.StorageFactory, ProxyTransport: c.ProxyTransport, KubeletClientConfig: c.KubeletClientConfig, EventTTL: c.EventTTL, ServiceIPRange: c.ServiceIPRange, ServiceNodePortRange: c.ServiceNodePortRange, LoopbackClientConfig: c.GenericConfig.LoopbackClientConfig, } m.InstallLegacyAPI(c.Config, restOptionsFactory.NewFor, legacyRESTStorageProvider) } restStorageProviders := []RESTStorageProvider{ appsrest.RESTStorageProvider{}, authenticationrest.RESTStorageProvider{Authenticator: c.GenericConfig.Authenticator}, authorizationrest.RESTStorageProvider{Authorizer: c.GenericConfig.Authorizer}, autoscalingrest.RESTStorageProvider{}, batchrest.RESTStorageProvider{}, certificatesrest.RESTStorageProvider{}, extensionsrest.RESTStorageProvider{ResourceInterface: thirdparty.NewThirdPartyResourceServer(s, c.StorageFactory)}, policyrest.RESTStorageProvider{}, rbacrest.RESTStorageProvider{AuthorizerRBACSuperUser: c.GenericConfig.AuthorizerRBACSuperUser}, storagerest.RESTStorageProvider{}, } m.InstallAPIs(c.Config.GenericConfig.APIResourceConfigSource, restOptionsFactory.NewFor, restStorageProviders...) if c.Tunneler != nil { m.installTunneler(c.Tunneler, corev1client.NewForConfigOrDie(c.GenericConfig.LoopbackClientConfig).Nodes()) } return m, nil }