func setup(t *testing.T) (*garbagecollector.GarbageCollector, clientset.Interface) { var m *master.Master s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { m.Handler.ServeHTTP(w, req) })) // TODO: close the http server masterConfig := framework.NewIntegrationTestMasterConfig() masterConfig.EnableCoreControllers = false m, err := master.New(masterConfig) if err != nil { t.Fatalf("Error in bringing up the master: %v", err) } framework.DeleteAllEtcdKeys() clientSet, err := clientset.NewForConfig(&restclient.Config{Host: s.URL}) if err != nil { t.Fatalf("Error in create clientset: %v", err) } groupVersionResources, err := clientSet.Discovery().ServerPreferredResources() if err != nil { t.Fatalf("Failed to get supported resources from server: %v", err) } clientPool := dynamic.NewClientPool(&restclient.Config{Host: s.URL}, dynamic.LegacyAPIPathResolverFunc) gc, err := garbagecollector.NewGarbageCollector(clientPool, groupVersionResources) if err != nil { t.Fatalf("Failed to create garbage collector") } return gc, clientSet }
func rmSetup(t *testing.T, enableGarbageCollector bool) (*httptest.Server, *replication.ReplicationManager, cache.SharedIndexInformer, clientset.Interface) { masterConfig := framework.NewIntegrationTestMasterConfig() _, s := framework.RunAMaster(masterConfig) config := restclient.Config{Host: s.URL} clientSet, err := clientset.NewForConfig(&config) if err != nil { t.Fatalf("Error in create clientset: %v", err) } resyncPeriod := 12 * time.Hour resyncPeriodFunc := func() time.Duration { return resyncPeriod } podInformer := informers.NewPodInformer(internalclientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "pod-informer")), resyncPeriod) rm := replication.NewReplicationManager( podInformer, internalclientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "replication-controller")), resyncPeriodFunc, replication.BurstReplicas, 4096, enableGarbageCollector, ) if err != nil { t.Fatalf("Failed to create replication manager") } return s, rm, podInformer, clientSet }
func setup(t *testing.T) (*httptest.Server, *garbagecollector.GarbageCollector, clientset.Interface) { masterConfig := framework.NewIntegrationTestMasterConfig() masterConfig.EnableCoreControllers = false masterConfig.EnableGarbageCollection = true _, s := framework.RunAMaster(masterConfig) clientSet, err := clientset.NewForConfig(&restclient.Config{Host: s.URL}) if err != nil { t.Fatalf("Error in create clientset: %v", err) } groupVersionResources, err := clientSet.Discovery().ServerPreferredResources() if err != nil { t.Fatalf("Failed to get supported resources from server: %v", err) } config := &restclient.Config{Host: s.URL} config.ContentConfig.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: metaonly.NewMetadataCodecFactory()} metaOnlyClientPool := dynamic.NewClientPool(config, registered.RESTMapper(), dynamic.LegacyAPIPathResolverFunc) config.ContentConfig.NegotiatedSerializer = nil clientPool := dynamic.NewClientPool(config, registered.RESTMapper(), dynamic.LegacyAPIPathResolverFunc) gc, err := garbagecollector.NewGarbageCollector(metaOnlyClientPool, clientPool, registered.RESTMapper(), groupVersionResources) if err != nil { t.Fatalf("Failed to create garbage collector") } return s, gc, clientSet }
// TODO: evaluate using pkg/client/clientcmd func newKubeClient(dnsConfig *options.KubeDNSConfig) (clientset.Interface, error) { var ( config *restclient.Config err error ) if dnsConfig.KubeMasterURL != "" && dnsConfig.KubeConfigFile == "" { // Only --kube-master-url was provided. config = &restclient.Config{ Host: dnsConfig.KubeMasterURL, ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: "v1"}}, } } else { // We either have: // 1) --kube-master-url and --kubecfg-file // 2) just --kubecfg-file // 3) neither flag // In any case, the logic is the same. If (3), this will automatically // fall back on the service account token. overrides := &kclientcmd.ConfigOverrides{} overrides.ClusterInfo.Server = dnsConfig.KubeMasterURL // might be "", but that is OK rules := &kclientcmd.ClientConfigLoadingRules{ExplicitPath: dnsConfig.KubeConfigFile} // might be "", but that is OK if config, err = kclientcmd.NewNonInteractiveDeferredLoadingClientConfig(rules, overrides).ClientConfig(); err != nil { return nil, err } } glog.Infof("Using %s for kubernetes master", config.Host) glog.Infof("Using kubernetes API %v", config.GroupVersion) return clientset.NewForConfig(config) }
func rmSetup(t *testing.T, enableGarbageCollector bool) (*httptest.Server, *replicaset.ReplicaSetController, cache.SharedIndexInformer, cache.SharedIndexInformer, clientset.Interface) { masterConfig := framework.NewIntegrationTestMasterConfig() _, s := framework.RunAMaster(masterConfig) config := restclient.Config{Host: s.URL} clientSet, err := clientset.NewForConfig(&config) if err != nil { t.Fatalf("Error in create clientset: %v", err) } resyncPeriod := 12 * time.Hour informers := informers.NewSharedInformerFactory(internalclientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "rs-informers")), resyncPeriod) rm := replicaset.NewReplicaSetController( informers.ReplicaSets(), informers.Pods(), internalclientset.NewForConfigOrDie(restclient.AddUserAgent(&config, "replicaset-controller")), replicaset.BurstReplicas, 4096, enableGarbageCollector, ) if err != nil { t.Fatalf("Failed to create replicaset controller") } return s, rm, informers.ReplicaSets().Informer(), informers.Pods().Informer(), clientSet }
func setup(t *testing.T) (*httptest.Server, *garbagecollector.GarbageCollector, clientset.Interface) { masterConfig := framework.NewIntegrationTestMasterConfig() masterConfig.EnableCoreControllers = false _, s := framework.RunAMaster(masterConfig) clientSet, err := clientset.NewForConfig(&restclient.Config{Host: s.URL}) if err != nil { t.Fatalf("Error in create clientset: %v", err) } groupVersionResources, err := clientSet.Discovery().ServerPreferredResources() if err != nil { t.Fatalf("Failed to get supported resources from server: %v", err) } clientPool := dynamic.NewClientPool(&restclient.Config{Host: s.URL}, dynamic.LegacyAPIPathResolverFunc) gc, err := garbagecollector.NewGarbageCollector(clientPool, groupVersionResources) if err != nil { t.Fatalf("Failed to create garbage collector") } return s, gc, clientSet }
// BeforeEach gets a client and makes a namespace. func (f *Framework) BeforeEach() { // The fact that we need this feels like a bug in ginkgo. // https://github.com/onsi/ginkgo/issues/222 f.cleanupHandle = AddCleanupAction(f.AfterEach) if f.Client == nil { By("Creating a kubernetes client") config, err := LoadConfig() Expect(err).NotTo(HaveOccurred()) config.QPS = f.options.ClientQPS config.Burst = f.options.ClientBurst if TestContext.KubeAPIContentType != "" { config.ContentType = TestContext.KubeAPIContentType } c, err := loadClientFromConfig(config) Expect(err).NotTo(HaveOccurred()) f.Client = c f.Clientset_1_2, err = release_1_2.NewForConfig(config) f.Clientset_1_3, err = release_1_3.NewForConfig(config) Expect(err).NotTo(HaveOccurred()) clientRepoConfig := getClientRepoConfig(config) f.StagingClient, err = release_1_4.NewForConfig(clientRepoConfig) Expect(err).NotTo(HaveOccurred()) } if f.federated { if f.FederationClient == nil { By("Creating a federated kubernetes client") var err error f.FederationClient, err = LoadFederationClient() Expect(err).NotTo(HaveOccurred()) } if f.FederationClientset == nil { By("Creating an unversioned federation Clientset") var err error f.FederationClientset, err = LoadFederationClientset() Expect(err).NotTo(HaveOccurred()) } if f.FederationClientset_1_3 == nil { By("Creating a release 1.3 federation Clientset") var err error f.FederationClientset_1_3, err = LoadFederationClientset_1_3() Expect(err).NotTo(HaveOccurred()) } if f.FederationClientset_1_4 == nil { By("Creating a release 1.4 federation Clientset") var err error f.FederationClientset_1_4, err = LoadFederationClientset_1_4() Expect(err).NotTo(HaveOccurred()) } By("Waiting for federation-apiserver to be ready") err := WaitForFederationApiserverReady(f.FederationClientset) Expect(err).NotTo(HaveOccurred()) By("federation-apiserver is ready") } By("Building a namespace api object") namespace, err := f.CreateNamespace(f.BaseName, map[string]string{ "e2e-framework": f.BaseName, }) Expect(err).NotTo(HaveOccurred()) f.Namespace = namespace if TestContext.VerifyServiceAccount { By("Waiting for a default service account to be provisioned in namespace") err = WaitForDefaultServiceAccountInNamespace(f.Client, namespace.Name) Expect(err).NotTo(HaveOccurred()) } else { Logf("Skipping waiting for service account") } if TestContext.GatherKubeSystemResourceUsageData != "false" && TestContext.GatherKubeSystemResourceUsageData != "none" { f.gatherer, err = NewResourceUsageGatherer(f.Client, ResourceGathererOptions{ inKubemark: ProviderIs("kubemark"), masterOnly: TestContext.GatherKubeSystemResourceUsageData == "master", }) if err != nil { Logf("Error while creating NewResourceUsageGatherer: %v", err) } else { go f.gatherer.startGatheringData() } } if TestContext.GatherLogsSizes { f.logsSizeWaitGroup = sync.WaitGroup{} f.logsSizeWaitGroup.Add(1) f.logsSizeCloseChannel = make(chan bool) f.logsSizeVerifier = NewLogsVerifier(f.Client, f.logsSizeCloseChannel) go func() { f.logsSizeVerifier.Run() f.logsSizeWaitGroup.Done() }() } }
func main() { // First log our starting config, and then set up. log.Infof("Invoked by %v", os.Args) flag.Parse() // Perform further validation of flags. if *deployment == "" { log.Fatal("Must specify a deployment.") } if *threshold < 0 || *threshold > 100 { log.Fatalf("Threshold must be between 0 and 100 inclusively, was %d.", threshold) } log.Infof("Watching namespace: %s, pod: %s, container: %s.", *podNamespace, *podName, *containerName) log.Infof("cpu: %s, extra_cpu: %s, memory: %s, extra_memory: %s, storage: %s, extra_storage: %s", *baseCPU, *cpuPerNode, *baseMemory, *memoryPerNode, *baseStorage, *storagePerNode) // Set up work objects. config, err := restclient.InClusterConfig() if err != nil { log.Fatal(err) } clientset, err := client.NewForConfig(config) if err != nil { log.Fatal(err) } k8s := nanny.NewKubernetesClient(*podNamespace, *deployment, *podName, *containerName, clientset) var resources []nanny.Resource // Monitor only the resources specified. if *baseCPU != noValue { resources = append(resources, nanny.Resource{ Base: resource.MustParse(*baseCPU), ExtraPerNode: resource.MustParse(*cpuPerNode), Name: "cpu", }) } if *baseMemory != noValue { resources = append(resources, nanny.Resource{ Base: resource.MustParse(*baseMemory), ExtraPerNode: resource.MustParse(*memoryPerNode), Name: "memory", }) } if *baseStorage != noValue { resources = append(resources, nanny.Resource{ Base: resource.MustParse(*baseStorage), ExtraPerNode: resource.MustParse(*memoryPerNode), Name: "storage", }) } log.Infof("Resources: %+v", resources) var est nanny.ResourceEstimator if *estimator == "linear" { est = nanny.LinearEstimator{ Resources: resources, } } else if *estimator == "exponential" { est = nanny.ExponentialEstimator{ Resources: resources, ScaleFactor: 1.5, } } else { log.Fatalf("Estimator %s not supported", *estimator) } // Begin nannying. nanny.PollAPIServer(k8s, est, *containerName, pollPeriod, uint64(*threshold)) }