Delete cloud-controller-manager

2be81c81 · Darren Shepherd · bf33ea74 · bf33ea74 · bf33ea74 · bf33ea74
Commit 2be81c81 authored Oct 07, 2018 by Darren Shepherd
29 changed files
--- a/cmd/cloud-controller-manager/BUILD
+++ b/cmd/cloud-controller-manager/BUILD
-package(default_visibility = ["//visibility:public"])
-
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_binary",
-    "go_library",
-)
-load("//pkg/version:def.bzl", "version_x_defs")
-
-go_binary(
-    name = "cloud-controller-manager",
-    embed = [":go_default_library"],
-    pure = "on",
-    x_defs = version_x_defs(),
-)
-
-go_library(
-    name = "go_default_library",
-    srcs = ["controller-manager.go"],
-    importpath = "k8s.io/kubernetes/cmd/cloud-controller-manager",
-    deps = [
-        "//cmd/cloud-controller-manager/app:go_default_library",
-        "//pkg/client/metrics/prometheus:go_default_library",
-        "//pkg/cloudprovider/providers:go_default_library",
-        "//pkg/version/prometheus:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/util/flag:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/util/logs:go_default_library",
-        "//vendor/github.com/spf13/pflag:go_default_library",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [
-        ":package-srcs",
-        "//cmd/cloud-controller-manager/app:all-srcs",
-    ],
-    tags = ["automanaged"],
-)
--- a/cmd/cloud-controller-manager/OWNERS
+++ b/cmd/cloud-controller-manager/OWNERS
-approvers:
- thockin
- luxas
- wlan0
- andrewsykim
-reviewers:
- thockin
- luxas
- wlan0
- andrewsykim
- stewart-yu
-labels:
- sig/api-machinery
- sig/cloud-provider
--- a/cmd/cloud-controller-manager/app/BUILD
+++ b/cmd/cloud-controller-manager/app/BUILD
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["controllermanager.go"],
-    importpath = "k8s.io/kubernetes/cmd/cloud-controller-manager/app",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//cmd/cloud-controller-manager/app/config:go_default_library",
-        "//cmd/cloud-controller-manager/app/options:go_default_library",
-        "//cmd/controller-manager/app:go_default_library",
-        "//pkg/cloudprovider:go_default_library",
-        "//pkg/controller/cloud:go_default_library",
-        "//pkg/controller/route:go_default_library",
-        "//pkg/controller/service:go_default_library",
-        "//pkg/util/configz:go_default_library",
-        "//pkg/util/flag:go_default_library",
-        "//pkg/version/verflag:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/uuid:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/server:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/util/flag:go_default_library",
-        "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
-        "//staging/src/k8s.io/client-go/tools/leaderelection:go_default_library",
-        "//staging/src/k8s.io/client-go/tools/leaderelection/resourcelock:go_default_library",
-        "//vendor/github.com/golang/glog:go_default_library",
-        "//vendor/github.com/spf13/cobra:go_default_library",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [
-        ":package-srcs",
-        "//cmd/cloud-controller-manager/app/apis/config:all-srcs",
-        "//cmd/cloud-controller-manager/app/config:all-srcs",
-        "//cmd/cloud-controller-manager/app/options:all-srcs",
-        "//cmd/cloud-controller-manager/app/testing:all-srcs",
-    ],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)
--- a/cmd/cloud-controller-manager/app/apis/config/BUILD
+++ b/cmd/cloud-controller-manager/app/apis/config/BUILD
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "doc.go",
-        "register.go",
-        "types.go",
-        "zz_generated.deepcopy.go",
-    ],
-    importpath = "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//pkg/controller/apis/config:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [
-        ":package-srcs",
-        "//cmd/cloud-controller-manager/app/apis/config/scheme:all-srcs",
-        "//cmd/cloud-controller-manager/app/apis/config/v1alpha1:all-srcs",
-    ],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)
--- a/cmd/cloud-controller-manager/app/apis/config/doc.go
+++ b/cmd/cloud-controller-manager/app/apis/config/doc.go
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// +k8s:deepcopy-gen=package
-// +groupName=cloudcontrollermanager.config.k8s.io
-
-package config // import "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config"
--- a/cmd/cloud-controller-manager/app/apis/config/register.go
+++ b/cmd/cloud-controller-manager/app/apis/config/register.go
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package config
-
-import (
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-// GroupName is the group name used in this package
-const GroupName = "cloudcontrollermanager.config.k8s.io"
-
-// SchemeGroupVersion is group version used to register these objects
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
-
-var (
-	// SchemeBuilder is the scheme builder with scheme init functions to run for this API package
-	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
-	// AddToScheme is a global function that registers this API group & version to a scheme
-	AddToScheme = SchemeBuilder.AddToScheme
-)
-
-// addKnownTypes registers known types to the given scheme
-func addKnownTypes(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&CloudControllerManagerConfiguration{},
-	)
-	return nil
-}
--- a/cmd/cloud-controller-manager/app/apis/config/scheme/BUILD
+++ b/cmd/cloud-controller-manager/app/apis/config/scheme/BUILD
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["scheme.go"],
-    importpath = "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config/scheme",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//cmd/cloud-controller-manager/app/apis/config:go_default_library",
-        "//cmd/cloud-controller-manager/app/apis/config/v1alpha1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)
--- a/cmd/cloud-controller-manager/app/apis/config/scheme/scheme.go
+++ b/cmd/cloud-controller-manager/app/apis/config/scheme/scheme.go
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package scheme
-
-import (
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/serializer"
-	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
-	"k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config"
-	"k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config/v1alpha1"
-)
-
-var (
-	// Scheme defines methods for serializing and deserializing API objects.
-	Scheme = runtime.NewScheme()
-	// Codecs provides methods for retrieving codecs and serializers for specific
-	// versions and content types.
-	Codecs = serializer.NewCodecFactory(Scheme)
-)
-
-func init() {
-	AddToScheme(Scheme)
-}
-
-// AddToScheme adds the types of this group into the given scheme.
-func AddToScheme(scheme *runtime.Scheme) {
-	utilruntime.Must(config.AddToScheme(scheme))
-	utilruntime.Must(v1alpha1.AddToScheme(scheme))
-	utilruntime.Must(scheme.SetVersionPriority(v1alpha1.SchemeGroupVersion))
-}
--- a/cmd/cloud-controller-manager/app/apis/config/types.go
+++ b/cmd/cloud-controller-manager/app/apis/config/types.go
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package config
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	kubectrlmgrconfig "k8s.io/kubernetes/pkg/controller/apis/config"
-)
-
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-
-// CloudControllerManagerConfiguration contains elements describing cloud-controller manager.
-type CloudControllerManagerConfiguration struct {
-	metav1.TypeMeta
-
-	// Generic holds configuration for a generic controller-manager
-	Generic kubectrlmgrconfig.GenericControllerManagerConfiguration
-	// KubeCloudSharedConfiguration holds configuration for shared related features
-	// both in cloud controller manager and kube-controller manager.
-	KubeCloudShared kubectrlmgrconfig.KubeCloudSharedConfiguration
-
-	// ServiceControllerConfiguration holds configuration for ServiceController
-	// related features.
-	ServiceController kubectrlmgrconfig.ServiceControllerConfiguration
-
-	// NodeStatusUpdateFrequency is the frequency at which the controller updates nodes' status
-	NodeStatusUpdateFrequency metav1.Duration
-}
--- a/cmd/cloud-controller-manager/app/apis/config/v1alpha1/BUILD
+++ b/cmd/cloud-controller-manager/app/apis/config/v1alpha1/BUILD
-load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "defaults.go",
-        "doc.go",
-        "register.go",
-        "types.go",
-        "zz_generated.conversion.go",
-        "zz_generated.deepcopy.go",
-        "zz_generated.defaults.go",
-    ],
-    importpath = "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config/v1alpha1",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//cmd/cloud-controller-manager/app/apis/config:go_default_library",
-        "//pkg/controller/apis/config/v1alpha1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/conversion:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
-        "//staging/src/k8s.io/kube-controller-manager/config/v1alpha1:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["defaults_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//staging/src/k8s.io/api/core/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)
--- a/cmd/cloud-controller-manager/app/apis/config/v1alpha1/defaults.go
+++ b/cmd/cloud-controller-manager/app/apis/config/v1alpha1/defaults.go
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package v1alpha1
-
-import (
-	"time"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	kubectrlmgrconfigv1alpha1 "k8s.io/kubernetes/pkg/controller/apis/config/v1alpha1"
-)
-
-func addDefaultingFuncs(scheme *runtime.Scheme) error {
-	return RegisterDefaults(scheme)
-}
-
-func SetDefaults_CloudControllerManagerConfiguration(obj *CloudControllerManagerConfiguration) {
-	zero := metav1.Duration{}
-	if obj.NodeStatusUpdateFrequency == zero {
-		obj.NodeStatusUpdateFrequency = metav1.Duration{Duration: 5 * time.Minute}
-	}
-
-	// These defaults override the recommended defaults from the apimachineryconfigv1alpha1 package that are applied automatically
-	// These client-connection defaults are specific to the cloud-controller-manager
-	if obj.Generic.ClientConnection.QPS == 0 {
-		obj.Generic.ClientConnection.QPS = 20
-	}
-	if obj.Generic.ClientConnection.Burst == 0 {
-		obj.Generic.ClientConnection.Burst = 30
-	}
-
-	// Use the default RecommendedDefaultGenericControllerManagerConfiguration options
-	kubectrlmgrconfigv1alpha1.RecommendedDefaultGenericControllerManagerConfiguration(&obj.Generic)
-}
--- a/cmd/cloud-controller-manager/app/apis/config/v1alpha1/defaults_test.go
+++ b/cmd/cloud-controller-manager/app/apis/config/v1alpha1/defaults_test.go
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package v1alpha1
-
-import (
-	"encoding/json"
-	"reflect"
-	"testing"
-
-	"k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-)
-
-func TestCloudControllerManagerDefaultsRoundTrip(t *testing.T) {
-	ks1 := &CloudControllerManagerConfiguration{}
-	SetDefaults_CloudControllerManagerConfiguration(ks1)
-	cm, err := convertObjToConfigMap("CloudControllerManagerConfiguration", ks1)
-	if err != nil {
-		t.Errorf("unexpected ConvertObjToConfigMap error %v", err)
-	}
-
-	ks2 := &CloudControllerManagerConfiguration{}
-	if err = json.Unmarshal([]byte(cm.Data["CloudControllerManagerConfiguration"]), ks2); err != nil {
-		t.Errorf("unexpected error unserializing cloud controller manager config %v", err)
-	}
-
-	if !reflect.DeepEqual(ks2, ks1) {
-		t.Errorf("Expected:\n%#v\n\nGot:\n%#v", ks1, ks2)
-	}
-}
-
-// convertObjToConfigMap converts an object to a ConfigMap.
-// This is specifically meant for ComponentConfigs.
-func convertObjToConfigMap(name string, obj runtime.Object) (*v1.ConfigMap, error) {
-	eJSONBytes, err := json.Marshal(obj)
-	if err != nil {
-		return nil, err
-	}
-	cm := &v1.ConfigMap{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: name,
-		},
-		Data: map[string]string{
-			name: string(eJSONBytes[:]),
-		},
-	}
-	return cm, nil
-}
--- a/cmd/cloud-controller-manager/app/apis/config/v1alpha1/doc.go
+++ b/cmd/cloud-controller-manager/app/apis/config/v1alpha1/doc.go
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Note: The referenced generic ComponentConfig packages with conversions
-// between the types (e.g. the external package) needs to be given as an
-// input to conversion-gen for it to find the native conversation funcs to
-// call.
-
-// +k8s:deepcopy-gen=package
-// +k8s:conversion-gen=k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config
-// +k8s:conversion-gen=k8s.io/apimachinery/pkg/apis/config/v1alpha1
-// +k8s:conversion-gen=k8s.io/apiserver/pkg/apis/config/v1alpha1
-// +k8s:conversion-gen=k8s.io/kubernetes/pkg/controller/apis/config/v1alpha1
-// +k8s:openapi-gen=true
-// +k8s:defaulter-gen=TypeMeta
-// +groupName=cloudcontrollermanager.config.k8s.io
-
-package v1alpha1 // import "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config/v1alpha1"
--- a/cmd/cloud-controller-manager/app/apis/config/v1alpha1/register.go
+++ b/cmd/cloud-controller-manager/app/apis/config/v1alpha1/register.go
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package v1alpha1
-
-import (
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-// GroupName is the group name use in this package
-const GroupName = "cloudcontrollermanager.config.k8s.io"
-
-// SchemeGroupVersion is group version used to register these objects
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}
-
-var (
-	// SchemeBuilder is the scheme builder with scheme init functions to run for this API package
-	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
-	// localSchemeBuilder ïs a pointer to SchemeBuilder instance. Using localSchemeBuilder
-	// defaulting and conversion init funcs are registered as well.
-	localSchemeBuilder = &SchemeBuilder
-	// AddToScheme is a global function that registers this API group & version to a scheme
-	AddToScheme = localSchemeBuilder.AddToScheme
-)
-
-func init() {
-	// We only register manually written functions here. The registration of the
-	// generated functions takes place in the generated files. The separation
-	// makes the code compile even when the generated files are missing.
-	localSchemeBuilder.Register(addDefaultingFuncs)
-}
-
-// addKnownTypes registers known types to the given scheme
-func addKnownTypes(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&CloudControllerManagerConfiguration{},
-	)
-	return nil
-}
--- a/cmd/cloud-controller-manager/app/apis/config/v1alpha1/types.go
+++ b/cmd/cloud-controller-manager/app/apis/config/v1alpha1/types.go
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package v1alpha1
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	kubectrlmgrconfigv1alpha1 "k8s.io/kube-controller-manager/config/v1alpha1"
-)
-
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-
-type CloudControllerManagerConfiguration struct {
-	metav1.TypeMeta `json:",inline"`
-
-	// Generic holds configuration for a generic controller-manager
-	Generic kubectrlmgrconfigv1alpha1.GenericControllerManagerConfiguration
-	// KubeCloudSharedConfiguration holds configuration for shared related features
-	// both in cloud controller manager and kube-controller manager.
-	KubeCloudShared kubectrlmgrconfigv1alpha1.KubeCloudSharedConfiguration
-	// ServiceControllerConfiguration holds configuration for ServiceController
-	// related features.
-	ServiceController kubectrlmgrconfigv1alpha1.ServiceControllerConfiguration
-	// NodeStatusUpdateFrequency is the frequency at which the controller updates nodes' status
-	NodeStatusUpdateFrequency metav1.Duration
-}
--- a/cmd/cloud-controller-manager/app/apis/config/v1alpha1/zz_generated.conversion.go
+++ b/cmd/cloud-controller-manager/app/apis/config/v1alpha1/zz_generated.conversion.go
-// +build !ignore_autogenerated
-
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by conversion-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	conversion "k8s.io/apimachinery/pkg/conversion"
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	config "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config"
-	configv1alpha1 "k8s.io/kubernetes/pkg/controller/apis/config/v1alpha1"
-)
-
-func init() {
-	localSchemeBuilder.Register(RegisterConversions)
-}
-
-// RegisterConversions adds conversion functions to the given scheme.
-// Public to allow building arbitrary schemes.
-func RegisterConversions(s *runtime.Scheme) error {
-	if err := s.AddGeneratedConversionFunc((*CloudControllerManagerConfiguration)(nil), (*config.CloudControllerManagerConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_v1alpha1_CloudControllerManagerConfiguration_To_config_CloudControllerManagerConfiguration(a.(*CloudControllerManagerConfiguration), b.(*config.CloudControllerManagerConfiguration), scope)
-	}); err != nil {
-		return err
-	}
-	if err := s.AddGeneratedConversionFunc((*config.CloudControllerManagerConfiguration)(nil), (*CloudControllerManagerConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_config_CloudControllerManagerConfiguration_To_v1alpha1_CloudControllerManagerConfiguration(a.(*config.CloudControllerManagerConfiguration), b.(*CloudControllerManagerConfiguration), scope)
-	}); err != nil {
-		return err
-	}
-	return nil
-}
-
-func autoConvert_v1alpha1_CloudControllerManagerConfiguration_To_config_CloudControllerManagerConfiguration(in *CloudControllerManagerConfiguration, out *config.CloudControllerManagerConfiguration, s conversion.Scope) error {
-	if err := configv1alpha1.Convert_v1alpha1_GenericControllerManagerConfiguration_To_config_GenericControllerManagerConfiguration(&in.Generic, &out.Generic, s); err != nil {
-		return err
-	}
-	if err := configv1alpha1.Convert_v1alpha1_KubeCloudSharedConfiguration_To_config_KubeCloudSharedConfiguration(&in.KubeCloudShared, &out.KubeCloudShared, s); err != nil {
-		return err
-	}
-	if err := configv1alpha1.Convert_v1alpha1_ServiceControllerConfiguration_To_config_ServiceControllerConfiguration(&in.ServiceController, &out.ServiceController, s); err != nil {
-		return err
-	}
-	out.NodeStatusUpdateFrequency = in.NodeStatusUpdateFrequency
-	return nil
-}
-
-// Convert_v1alpha1_CloudControllerManagerConfiguration_To_config_CloudControllerManagerConfiguration is an autogenerated conversion function.
-func Convert_v1alpha1_CloudControllerManagerConfiguration_To_config_CloudControllerManagerConfiguration(in *CloudControllerManagerConfiguration, out *config.CloudControllerManagerConfiguration, s conversion.Scope) error {
-	return autoConvert_v1alpha1_CloudControllerManagerConfiguration_To_config_CloudControllerManagerConfiguration(in, out, s)
-}
-
-func autoConvert_config_CloudControllerManagerConfiguration_To_v1alpha1_CloudControllerManagerConfiguration(in *config.CloudControllerManagerConfiguration, out *CloudControllerManagerConfiguration, s conversion.Scope) error {
-	if err := configv1alpha1.Convert_config_GenericControllerManagerConfiguration_To_v1alpha1_GenericControllerManagerConfiguration(&in.Generic, &out.Generic, s); err != nil {
-		return err
-	}
-	if err := configv1alpha1.Convert_config_KubeCloudSharedConfiguration_To_v1alpha1_KubeCloudSharedConfiguration(&in.KubeCloudShared, &out.KubeCloudShared, s); err != nil {
-		return err
-	}
-	if err := configv1alpha1.Convert_config_ServiceControllerConfiguration_To_v1alpha1_ServiceControllerConfiguration(&in.ServiceController, &out.ServiceController, s); err != nil {
-		return err
-	}
-	out.NodeStatusUpdateFrequency = in.NodeStatusUpdateFrequency
-	return nil
-}
-
-// Convert_config_CloudControllerManagerConfiguration_To_v1alpha1_CloudControllerManagerConfiguration is an autogenerated conversion function.
-func Convert_config_CloudControllerManagerConfiguration_To_v1alpha1_CloudControllerManagerConfiguration(in *config.CloudControllerManagerConfiguration, out *CloudControllerManagerConfiguration, s conversion.Scope) error {
-	return autoConvert_config_CloudControllerManagerConfiguration_To_v1alpha1_CloudControllerManagerConfiguration(in, out, s)
-}
--- a/cmd/cloud-controller-manager/app/apis/config/v1alpha1/zz_generated.deepcopy.go
+++ b/cmd/cloud-controller-manager/app/apis/config/v1alpha1/zz_generated.deepcopy.go
-// +build !ignore_autogenerated
-
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by deepcopy-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	runtime "k8s.io/apimachinery/pkg/runtime"
-)
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *CloudControllerManagerConfiguration) DeepCopyInto(out *CloudControllerManagerConfiguration) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.Generic.DeepCopyInto(&out.Generic)
-	in.KubeCloudShared.DeepCopyInto(&out.KubeCloudShared)
-	out.ServiceController = in.ServiceController
-	out.NodeStatusUpdateFrequency = in.NodeStatusUpdateFrequency
-	return
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudControllerManagerConfiguration.
-func (in *CloudControllerManagerConfiguration) DeepCopy() *CloudControllerManagerConfiguration {
-	if in == nil {
-		return nil
-	}
-	out := new(CloudControllerManagerConfiguration)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *CloudControllerManagerConfiguration) DeepCopyObject() runtime.Object {
-	if c := in.DeepCopy(); c != nil {
-		return c
-	}
-	return nil
-}
--- a/cmd/cloud-controller-manager/app/apis/config/v1alpha1/zz_generated.defaults.go
+++ b/cmd/cloud-controller-manager/app/apis/config/v1alpha1/zz_generated.defaults.go
-// +build !ignore_autogenerated
-
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by defaulter-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	configv1alpha1 "k8s.io/kubernetes/pkg/controller/apis/config/v1alpha1"
-)
-
-// RegisterDefaults adds defaulters functions to the given scheme.
-// Public to allow building arbitrary schemes.
-// All generated defaulters are covering - they call all nested defaulters.
-func RegisterDefaults(scheme *runtime.Scheme) error {
-	scheme.AddTypeDefaultingFunc(&CloudControllerManagerConfiguration{}, func(obj interface{}) {
-		SetObjectDefaults_CloudControllerManagerConfiguration(obj.(*CloudControllerManagerConfiguration))
-	})
-	return nil
-}
-
-func SetObjectDefaults_CloudControllerManagerConfiguration(in *CloudControllerManagerConfiguration) {
-	SetDefaults_CloudControllerManagerConfiguration(in)
-	configv1alpha1.SetDefaults_KubeCloudSharedConfiguration(&in.KubeCloudShared)
-	configv1alpha1.SetDefaults_ServiceControllerConfiguration(&in.ServiceController)
-}
--- a/cmd/cloud-controller-manager/app/apis/config/zz_generated.deepcopy.go
+++ b/cmd/cloud-controller-manager/app/apis/config/zz_generated.deepcopy.go
-// +build !ignore_autogenerated
-
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by deepcopy-gen. DO NOT EDIT.
-
-package config
-
-import (
-	runtime "k8s.io/apimachinery/pkg/runtime"
-)
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *CloudControllerManagerConfiguration) DeepCopyInto(out *CloudControllerManagerConfiguration) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.Generic.DeepCopyInto(&out.Generic)
-	out.KubeCloudShared = in.KubeCloudShared
-	out.ServiceController = in.ServiceController
-	out.NodeStatusUpdateFrequency = in.NodeStatusUpdateFrequency
-	return
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloudControllerManagerConfiguration.
-func (in *CloudControllerManagerConfiguration) DeepCopy() *CloudControllerManagerConfiguration {
-	if in == nil {
-		return nil
-	}
-	out := new(CloudControllerManagerConfiguration)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *CloudControllerManagerConfiguration) DeepCopyObject() runtime.Object {
-	if c := in.DeepCopy(); c != nil {
-		return c
-	}
-	return nil
-}
--- a/cmd/cloud-controller-manager/app/config/BUILD
+++ b/cmd/cloud-controller-manager/app/config/BUILD
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["config.go"],
-    importpath = "k8s.io/kubernetes/cmd/cloud-controller-manager/app/config",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//cmd/cloud-controller-manager/app/apis/config:go_default_library",
-        "//pkg/controller:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/server:go_default_library",
-        "//staging/src/k8s.io/client-go/informers:go_default_library",
-        "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
-        "//staging/src/k8s.io/client-go/rest:go_default_library",
-        "//staging/src/k8s.io/client-go/tools/record:go_default_library",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)
--- a/cmd/cloud-controller-manager/app/config/config.go
+++ b/cmd/cloud-controller-manager/app/config/config.go
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package app
-
-import (
-	apiserver "k8s.io/apiserver/pkg/server"
-	"k8s.io/client-go/informers"
-	clientset "k8s.io/client-go/kubernetes"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/tools/record"
-	ccmconfig "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config"
-	"k8s.io/kubernetes/pkg/controller"
-)
-
-// Config is the main context object for the cloud controller manager.
-type Config struct {
-	ComponentConfig ccmconfig.CloudControllerManagerConfiguration
-
-	SecureServing *apiserver.SecureServingInfo
-	// LoopbackClientConfig is a config for a privileged loopback connection
-	LoopbackClientConfig *restclient.Config
-
-	// TODO: remove deprecated insecure serving
-	InsecureServing *apiserver.DeprecatedInsecureServingInfo
-	Authentication  apiserver.AuthenticationInfo
-	Authorization   apiserver.AuthorizationInfo
-
-	// the general kube client
-	Client *clientset.Clientset
-
-	// the client only used for leader election
-	LeaderElectionClient *clientset.Clientset
-
-	// the rest config for the master
-	Kubeconfig *restclient.Config
-
-	// the event sink
-	EventRecorder record.EventRecorder
-
-	// ClientBuilder will provide a client for this controller to use
-	ClientBuilder controller.ControllerClientBuilder
-
-	// VersionedClient will provide a client for informers
-	VersionedClient clientset.Interface
-
-	// SharedInformers gives access to informers for the controller.
-	SharedInformers informers.SharedInformerFactory
-}
-
-type completedConfig struct {
-	*Config
-}
-
-// CompletedConfig same as Config, just to swap private object.
-type CompletedConfig struct {
-	// Embed a private pointer that cannot be instantiated outside of this package.
-	*completedConfig
-}
-
-// Complete fills in any fields not set that are required to have valid data. It's mutating the receiver.
-func (c *Config) Complete() *CompletedConfig {
-	cc := completedConfig{c}
-
-	apiserver.AuthorizeClientBearerToken(c.LoopbackClientConfig, &c.Authentication, &c.Authorization)
-
-	return &CompletedConfig{&cc}
-}
--- a/cmd/cloud-controller-manager/app/controllermanager.go
+++ b/cmd/cloud-controller-manager/app/controllermanager.go
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package app
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"time"
-
-	"github.com/golang/glog"
-	"github.com/spf13/cobra"
-
-	"k8s.io/apimachinery/pkg/util/uuid"
-	"k8s.io/apimachinery/pkg/util/wait"
-	"k8s.io/apiserver/pkg/server"
-	apiserverflag "k8s.io/apiserver/pkg/util/flag"
-	"k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/tools/leaderelection"
-	"k8s.io/client-go/tools/leaderelection/resourcelock"
-	cloudcontrollerconfig "k8s.io/kubernetes/cmd/cloud-controller-manager/app/config"
-	"k8s.io/kubernetes/cmd/cloud-controller-manager/app/options"
-	genericcontrollermanager "k8s.io/kubernetes/cmd/controller-manager/app"
-	"k8s.io/kubernetes/pkg/cloudprovider"
-	cloudcontrollers "k8s.io/kubernetes/pkg/controller/cloud"
-	servicecontroller "k8s.io/kubernetes/pkg/controller/service"
-	"k8s.io/kubernetes/pkg/util/configz"
-	utilflag "k8s.io/kubernetes/pkg/util/flag"
-	"k8s.io/kubernetes/pkg/version/verflag"
-)
-
-const (
-	// ControllerStartJitter is the jitter value used when starting controller managers.
-	ControllerStartJitter = 1.0
-)
-
-// NewCloudControllerManagerCommand creates a *cobra.Command object with default parameters
-func NewCloudControllerManagerCommand() *cobra.Command {
-	s, err := options.NewCloudControllerManagerOptions()
-	if err != nil {
-		glog.Fatalf("unable to initialize command options: %v", err)
-	}
-
-	cmd := &cobra.Command{
-		Use: "cloud-controller-manager",
-		Long: `The Cloud controller manager is a daemon that embeds
-the cloud specific control loops shipped with Kubernetes.`,
-		Run: func(cmd *cobra.Command, args []string) {
-			verflag.PrintAndExitIfRequested()
-			utilflag.PrintFlags(cmd.Flags())
-
-			c, err := s.Config()
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "%v\n", err)
-				os.Exit(1)
-			}
-
-			if err := Run(c.Complete(), wait.NeverStop); err != nil {
-				fmt.Fprintf(os.Stderr, "%v\n", err)
-				os.Exit(1)
-			}
-
-		},
-	}
-
-	fs := cmd.Flags()
-	namedFlagSets := s.Flags()
-	for _, f := range namedFlagSets.FlagSets {
-		fs.AddFlagSet(f)
-	}
-	usageFmt := "Usage:\n  %s\n"
-	cols, _, _ := apiserverflag.TerminalSize(cmd.OutOrStdout())
-	cmd.SetUsageFunc(func(cmd *cobra.Command) error {
-		fmt.Fprintf(cmd.OutOrStderr(), usageFmt, cmd.UseLine())
-		apiserverflag.PrintSections(cmd.OutOrStderr(), namedFlagSets, cols)
-		return nil
-	})
-	cmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
-		fmt.Fprintf(cmd.OutOrStdout(), "%s\n\n"+usageFmt, cmd.Long, cmd.UseLine())
-		apiserverflag.PrintSections(cmd.OutOrStdout(), namedFlagSets, cols)
-	})
-
-	return cmd
-}
-
-// Run runs the ExternalCMServer.  This should never exit.
-func Run(c *cloudcontrollerconfig.CompletedConfig, stopCh <-chan struct{}) error {
-	cloud, err := cloudprovider.InitCloudProvider(c.ComponentConfig.KubeCloudShared.CloudProvider.Name, c.ComponentConfig.KubeCloudShared.CloudProvider.CloudConfigFile)
-	if err != nil {
-		glog.Fatalf("Cloud provider could not be initialized: %v", err)
-	}
-	if cloud == nil {
-		glog.Fatalf("cloud provider is nil")
-	}
-
-	if cloud.HasClusterID() == false {
-		if c.ComponentConfig.KubeCloudShared.AllowUntaggedCloud == true {
-			glog.Warning("detected a cluster without a ClusterID.  A ClusterID will be required in the future.  Please tag your cluster to avoid any future issues")
-		} else {
-			glog.Fatalf("no ClusterID found.  A ClusterID is required for the cloud provider to function properly.  This check can be bypassed by setting the allow-untagged-cloud option")
-		}
-	}
-
-	// setup /configz endpoint
-	if cz, err := configz.New("componentconfig"); err == nil {
-		cz.Set(c.ComponentConfig)
-	} else {
-		glog.Errorf("unable to register configz: %c", err)
-	}
-
-	// Start the controller manager HTTP server
-	if c.SecureServing != nil {
-		unsecuredMux := genericcontrollermanager.NewBaseHandler(&c.ComponentConfig.Generic.Debugging)
-		handler := genericcontrollermanager.BuildHandlerChain(unsecuredMux, &c.Authorization, &c.Authentication)
-		if err := c.SecureServing.Serve(handler, 0, stopCh); err != nil {
-			return err
-		}
-	}
-	if c.InsecureServing != nil {
-		unsecuredMux := genericcontrollermanager.NewBaseHandler(&c.ComponentConfig.Generic.Debugging)
-		insecureSuperuserAuthn := server.AuthenticationInfo{Authenticator: &server.InsecureSuperuser{}}
-		handler := genericcontrollermanager.BuildHandlerChain(unsecuredMux, nil, &insecureSuperuserAuthn)
-		if err := c.InsecureServing.Serve(handler, 0, stopCh); err != nil {
-			return err
-		}
-	}
-
-	run := func(ctx context.Context) {
-		if err := startControllers(c, ctx.Done(), cloud); err != nil {
-			glog.Fatalf("error running controllers: %v", err)
-		}
-	}
-
-	if !c.ComponentConfig.Generic.LeaderElection.LeaderElect {
-		run(context.TODO())
-		panic("unreachable")
-	}
-
-	// Identity used to distinguish between multiple cloud controller manager instances
-	id, err := os.Hostname()
-	if err != nil {
-		return err
-	}
-	// add a uniquifier so that two processes on the same host don't accidentally both become active
-	id = id + "_" + string(uuid.NewUUID())
-
-	// Lock required for leader election
-	rl, err := resourcelock.New(c.ComponentConfig.Generic.LeaderElection.ResourceLock,
-		"kube-system",
-		"cloud-controller-manager",
-		c.LeaderElectionClient.CoreV1(),
-		resourcelock.ResourceLockConfig{
-			Identity:      id,
-			EventRecorder: c.EventRecorder,
-		})
-	if err != nil {
-		glog.Fatalf("error creating lock: %v", err)
-	}
-
-	// Try and become the leader and start cloud controller manager loops
-	leaderelection.RunOrDie(context.TODO(), leaderelection.LeaderElectionConfig{
-		Lock:          rl,
-		LeaseDuration: c.ComponentConfig.Generic.LeaderElection.LeaseDuration.Duration,
-		RenewDeadline: c.ComponentConfig.Generic.LeaderElection.RenewDeadline.Duration,
-		RetryPeriod:   c.ComponentConfig.Generic.LeaderElection.RetryPeriod.Duration,
-		Callbacks: leaderelection.LeaderCallbacks{
-			OnStartedLeading: run,
-			OnStoppedLeading: func() {
-				glog.Fatalf("leaderelection lost")
-			},
-		},
-	})
-	panic("unreachable")
-}
-
-// startControllers starts the cloud specific controller loops.
-func startControllers(c *cloudcontrollerconfig.CompletedConfig, stop <-chan struct{}, cloud cloudprovider.Interface) error {
-	// Function to build the kube client object
-	client := func(serviceAccountName string) kubernetes.Interface {
-		return c.ClientBuilder.ClientOrDie(serviceAccountName)
-	}
-	if cloud != nil {
-		// Initialize the cloud provider with a reference to the clientBuilder
-		cloud.Initialize(c.ClientBuilder)
-	}
-	// Start the CloudNodeController
-	nodeController := cloudcontrollers.NewCloudNodeController(
-		c.SharedInformers.Core().V1().Nodes(),
-		client("cloud-node-controller"), cloud,
-		c.ComponentConfig.KubeCloudShared.NodeMonitorPeriod.Duration,
-		c.ComponentConfig.NodeStatusUpdateFrequency.Duration)
-
-	nodeController.Run(stop)
-	time.Sleep(wait.Jitter(c.ComponentConfig.Generic.ControllerStartInterval.Duration, ControllerStartJitter))
-
-	// Start the PersistentVolumeLabelController
-	pvlController := cloudcontrollers.NewPersistentVolumeLabelController(client("pvl-controller"), cloud)
-	go pvlController.Run(5, stop)
-	time.Sleep(wait.Jitter(c.ComponentConfig.Generic.ControllerStartInterval.Duration, ControllerStartJitter))
-
-	// Start the service controller
-	serviceController, err := servicecontroller.New(
-		cloud,
-		client("service-controller"),
-		c.SharedInformers.Core().V1().Services(),
-		c.SharedInformers.Core().V1().Nodes(),
-		c.ComponentConfig.KubeCloudShared.ClusterName,
-	)
-	if err != nil {
-		glog.Errorf("Failed to start service controller: %v", err)
-	} else {
-		go serviceController.Run(stop, int(c.ComponentConfig.ServiceController.ConcurrentServiceSyncs))
-		time.Sleep(wait.Jitter(c.ComponentConfig.Generic.ControllerStartInterval.Duration, ControllerStartJitter))
-	}
-
-	// If apiserver is not running we should wait for some time and fail only then. This is particularly
-	// important when we start apiserver and controller manager at the same time.
-	err = genericcontrollermanager.WaitForAPIServer(c.VersionedClient, 10*time.Second)
-	if err != nil {
-		glog.Fatalf("Failed to wait for apiserver being healthy: %v", err)
-	}
-
-	c.SharedInformers.Start(stop)
-
-	select {}
-}
--- a/cmd/cloud-controller-manager/app/options/BUILD
+++ b/cmd/cloud-controller-manager/app/options/BUILD
-package(default_visibility = ["//visibility:public"])
-
-load(
-    "@io_bazel_rules_go//go:def.bzl",
-    "go_library",
-    "go_test",
-)
-
-go_library(
-    name = "go_default_library",
-    srcs = ["options.go"],
-    importpath = "k8s.io/kubernetes/cmd/cloud-controller-manager/app/options",
-    deps = [
-        "//cmd/cloud-controller-manager/app/apis/config:go_default_library",
-        "//cmd/cloud-controller-manager/app/apis/config/scheme:go_default_library",
-        "//cmd/cloud-controller-manager/app/apis/config/v1alpha1:go_default_library",
-        "//cmd/cloud-controller-manager/app/config:go_default_library",
-        "//cmd/controller-manager/app/options:go_default_library",
-        "//pkg/api/legacyscheme:go_default_library",
-        "//pkg/controller:go_default_library",
-        "//pkg/features:go_default_library",
-        "//pkg/master/ports:go_default_library",
-        "//staging/src/k8s.io/api/core/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/errors:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/server/options:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/util/flag:go_default_library",
-        "//staging/src/k8s.io/client-go/informers:go_default_library",
-        "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
-        "//staging/src/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
-        "//staging/src/k8s.io/client-go/rest:go_default_library",
-        "//staging/src/k8s.io/client-go/tools/clientcmd:go_default_library",
-        "//staging/src/k8s.io/client-go/tools/record:go_default_library",
-        "//vendor/github.com/golang/glog:go_default_library",
-    ],
-)
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["options_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//cmd/controller-manager/app/options:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/config:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/diff:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/apis/config:go_default_library",
-        "//staging/src/k8s.io/apiserver/pkg/server/options:go_default_library",
-        "//vendor/github.com/spf13/pflag:go_default_library",
-    ],
-)
--- a/cmd/cloud-controller-manager/app/options/options.go
+++ b/cmd/cloud-controller-manager/app/options/options.go
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package options
-
-import (
-	"fmt"
-	"math/rand"
-	"net"
-	"time"
-
-	"github.com/golang/glog"
-
-	"k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	utilerrors "k8s.io/apimachinery/pkg/util/errors"
-	apiserveroptions "k8s.io/apiserver/pkg/server/options"
-	utilfeature "k8s.io/apiserver/pkg/util/feature"
-	apiserverflag "k8s.io/apiserver/pkg/util/flag"
-	"k8s.io/client-go/informers"
-	clientset "k8s.io/client-go/kubernetes"
-	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/tools/clientcmd"
-	"k8s.io/client-go/tools/record"
-	ccmconfig "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config"
-	ccmconfigscheme "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config/scheme"
-	ccmconfigv1alpha1 "k8s.io/kubernetes/cmd/cloud-controller-manager/app/apis/config/v1alpha1"
-	cloudcontrollerconfig "k8s.io/kubernetes/cmd/cloud-controller-manager/app/config"
-	cmoptions "k8s.io/kubernetes/cmd/controller-manager/app/options"
-	"k8s.io/kubernetes/pkg/api/legacyscheme"
-	"k8s.io/kubernetes/pkg/controller"
-	"k8s.io/kubernetes/pkg/master/ports"
-	// add the kubernetes feature gates
-	_ "k8s.io/kubernetes/pkg/features"
-)
-
-const (
-	// CloudControllerManagerUserAgent is the userAgent name when starting cloud-controller managers.
-	CloudControllerManagerUserAgent = "cloud-controller-manager"
-)
-
-// CloudControllerManagerOptions is the main context object for the controller manager.
-type CloudControllerManagerOptions struct {
-	Generic           *cmoptions.GenericControllerManagerConfigurationOptions
-	KubeCloudShared   *cmoptions.KubeCloudSharedOptions
-	ServiceController *cmoptions.ServiceControllerOptions
-
-	SecureServing *apiserveroptions.SecureServingOptionsWithLoopback
-	// TODO: remove insecure serving mode
-	InsecureServing *apiserveroptions.DeprecatedInsecureServingOptionsWithLoopback
-	Authentication  *apiserveroptions.DelegatingAuthenticationOptions
-	Authorization   *apiserveroptions.DelegatingAuthorizationOptions
-
-	Master     string
-	Kubeconfig string
-
-	// NodeStatusUpdateFrequency is the frequency at which the controller updates nodes' status
-	NodeStatusUpdateFrequency metav1.Duration
-}
-
-// NewCloudControllerManagerOptions creates a new ExternalCMServer with a default config.
-func NewCloudControllerManagerOptions() (*CloudControllerManagerOptions, error) {
-	componentConfig, err := NewDefaultComponentConfig(ports.InsecureCloudControllerManagerPort)
-	if err != nil {
-		return nil, err
-	}
-
-	s := CloudControllerManagerOptions{
-		Generic:         cmoptions.NewGenericControllerManagerConfigurationOptions(componentConfig.Generic),
-		KubeCloudShared: cmoptions.NewKubeCloudSharedOptions(componentConfig.KubeCloudShared),
-		ServiceController: &cmoptions.ServiceControllerOptions{
-			ConcurrentServiceSyncs: componentConfig.ServiceController.ConcurrentServiceSyncs,
-		},
-		SecureServing: apiserveroptions.NewSecureServingOptions().WithLoopback(),
-		InsecureServing: (&apiserveroptions.DeprecatedInsecureServingOptions{
-			BindAddress: net.ParseIP(componentConfig.Generic.Address),
-			BindPort:    int(componentConfig.Generic.Port),
-			BindNetwork: "tcp",
-		}).WithLoopback(),
-		Authentication:            apiserveroptions.NewDelegatingAuthenticationOptions(),
-		Authorization:             apiserveroptions.NewDelegatingAuthorizationOptions(),
-		NodeStatusUpdateFrequency: componentConfig.NodeStatusUpdateFrequency,
-	}
-
-	s.Authentication.RemoteKubeConfigFileOptional = true
-	s.Authorization.RemoteKubeConfigFileOptional = true
-	s.Authorization.AlwaysAllowPaths = []string{"/healthz"}
-
-	s.SecureServing.ServerCert.CertDirectory = "/var/run/kubernetes"
-	s.SecureServing.ServerCert.PairName = "cloud-controller-manager"
-	s.SecureServing.BindPort = ports.CloudControllerManagerPort
-
-	return &s, nil
-}
-
-// NewDefaultComponentConfig returns cloud-controller manager configuration object.
-func NewDefaultComponentConfig(insecurePort int32) (*ccmconfig.CloudControllerManagerConfiguration, error) {
-	versioned := &ccmconfigv1alpha1.CloudControllerManagerConfiguration{}
-	ccmconfigscheme.Scheme.Default(versioned)
-
-	internal := &ccmconfig.CloudControllerManagerConfiguration{}
-	if err := ccmconfigscheme.Scheme.Convert(versioned, internal, nil); err != nil {
-		return nil, err
-	}
-	internal.Generic.Port = insecurePort
-	return internal, nil
-}
-
-// Flags returns flags for a specific APIServer by section name
-func (o *CloudControllerManagerOptions) Flags() apiserverflag.NamedFlagSets {
-	fss := apiserverflag.NamedFlagSets{}
-	o.Generic.AddFlags(&fss, []string{}, []string{})
-	// TODO: Implement the --controllers flag fully for the ccm
-	fss.FlagSet("generic").MarkHidden("controllers")
-	o.KubeCloudShared.AddFlags(fss.FlagSet("generic"))
-	o.ServiceController.AddFlags(fss.FlagSet("service controller"))
-
-	o.SecureServing.AddFlags(fss.FlagSet("secure serving"))
-	o.InsecureServing.AddUnqualifiedFlags(fss.FlagSet("insecure serving"))
-	o.Authentication.AddFlags(fss.FlagSet("authentication"))
-	o.Authorization.AddFlags(fss.FlagSet("authorization"))
-
-	fs := fss.FlagSet("misc")
-	fs.StringVar(&o.Master, "master", o.Master, "The address of the Kubernetes API server (overrides any value in kubeconfig).")
-	fs.StringVar(&o.Kubeconfig, "kubeconfig", o.Kubeconfig, "Path to kubeconfig file with authorization and master location information.")
-	fs.DurationVar(&o.NodeStatusUpdateFrequency.Duration, "node-status-update-frequency", o.NodeStatusUpdateFrequency.Duration, "Specifies how often the controller updates nodes' status.")
-
-	utilfeature.DefaultFeatureGate.AddFlag(fss.FlagSet("generic"))
-
-	return fss
-}
-
-// ApplyTo fills up cloud controller manager config with options.
-func (o *CloudControllerManagerOptions) ApplyTo(c *cloudcontrollerconfig.Config, userAgent string) error {
-	var err error
-	if err = o.Generic.ApplyTo(&c.ComponentConfig.Generic); err != nil {
-		return err
-	}
-	if err = o.KubeCloudShared.ApplyTo(&c.ComponentConfig.KubeCloudShared); err != nil {
-		return err
-	}
-	if err = o.ServiceController.ApplyTo(&c.ComponentConfig.ServiceController); err != nil {
-		return err
-	}
-	if err = o.InsecureServing.ApplyTo(&c.InsecureServing, &c.LoopbackClientConfig); err != nil {
-		return err
-	}
-	if err = o.SecureServing.ApplyTo(&c.SecureServing, &c.LoopbackClientConfig); err != nil {
-		return err
-	}
-	if o.SecureServing.BindPort != 0 || o.SecureServing.Listener != nil {
-		if err = o.Authentication.ApplyTo(&c.Authentication, c.SecureServing, nil); err != nil {
-			return err
-		}
-		if err = o.Authorization.ApplyTo(&c.Authorization); err != nil {
-			return err
-		}
-	}
-
-	c.Kubeconfig, err = clientcmd.BuildConfigFromFlags(o.Master, o.Kubeconfig)
-	if err != nil {
-		return err
-	}
-	c.Kubeconfig.ContentConfig.ContentType = o.Generic.ClientConnection.ContentType
-	c.Kubeconfig.QPS = o.Generic.ClientConnection.QPS
-	c.Kubeconfig.Burst = int(o.Generic.ClientConnection.Burst)
-
-	c.Client, err = clientset.NewForConfig(restclient.AddUserAgent(c.Kubeconfig, userAgent))
-	if err != nil {
-		return err
-	}
-
-	c.LeaderElectionClient = clientset.NewForConfigOrDie(restclient.AddUserAgent(c.Kubeconfig, "leader-election"))
-
-	c.EventRecorder = createRecorder(c.Client, userAgent)
-
-	rootClientBuilder := controller.SimpleControllerClientBuilder{
-		ClientConfig: c.Kubeconfig,
-	}
-	if c.ComponentConfig.KubeCloudShared.UseServiceAccountCredentials {
-		c.ClientBuilder = controller.SAControllerClientBuilder{
-			ClientConfig:         restclient.AnonymousClientConfig(c.Kubeconfig),
-			CoreClient:           c.Client.CoreV1(),
-			AuthenticationClient: c.Client.AuthenticationV1(),
-			Namespace:            metav1.NamespaceSystem,
-		}
-	} else {
-		c.ClientBuilder = rootClientBuilder
-	}
-	c.VersionedClient = rootClientBuilder.ClientOrDie("shared-informers")
-	c.SharedInformers = informers.NewSharedInformerFactory(c.VersionedClient, resyncPeriod(c)())
-
-	// sync back to component config
-	// TODO: find more elegant way than syncing back the values.
-	c.ComponentConfig.Generic.Port = int32(o.InsecureServing.BindPort)
-	c.ComponentConfig.Generic.Address = o.InsecureServing.BindAddress.String()
-
-	c.ComponentConfig.NodeStatusUpdateFrequency = o.NodeStatusUpdateFrequency
-
-	return nil
-}
-
-// Validate is used to validate config before launching the cloud controller manager
-func (o *CloudControllerManagerOptions) Validate() error {
-	errors := []error{}
-
-	errors = append(errors, o.Generic.Validate(nil, nil)...)
-	errors = append(errors, o.KubeCloudShared.Validate()...)
-	errors = append(errors, o.ServiceController.Validate()...)
-	errors = append(errors, o.SecureServing.Validate()...)
-	errors = append(errors, o.InsecureServing.Validate()...)
-	errors = append(errors, o.Authentication.Validate()...)
-	errors = append(errors, o.Authorization.Validate()...)
-
-	if len(o.KubeCloudShared.CloudProvider.Name) == 0 {
-		errors = append(errors, fmt.Errorf("--cloud-provider cannot be empty"))
-	}
-
-	return utilerrors.NewAggregate(errors)
-}
-
-// resyncPeriod computes the time interval a shared informer waits before resyncing with the api server
-func resyncPeriod(c *cloudcontrollerconfig.Config) func() time.Duration {
-	return func() time.Duration {
-		factor := rand.Float64() + 1
-		return time.Duration(float64(c.ComponentConfig.Generic.MinResyncPeriod.Nanoseconds()) * factor)
-	}
-}
-
-// Config return a cloud controller manager config objective
-func (o *CloudControllerManagerOptions) Config() (*cloudcontrollerconfig.Config, error) {
-	if err := o.Validate(); err != nil {
-		return nil, err
-	}
-
-	if err := o.SecureServing.MaybeDefaultWithSelfSignedCerts("localhost", nil, []net.IP{net.ParseIP("127.0.0.1")}); err != nil {
-		return nil, fmt.Errorf("error creating self-signed certificates: %v", err)
-	}
-
-	c := &cloudcontrollerconfig.Config{}
-	if err := o.ApplyTo(c, CloudControllerManagerUserAgent); err != nil {
-		return nil, err
-	}
-
-	return c, nil
-}
-
-func createRecorder(kubeClient clientset.Interface, userAgent string) record.EventRecorder {
-	eventBroadcaster := record.NewBroadcaster()
-	eventBroadcaster.StartLogging(glog.Infof)
-	eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: kubeClient.CoreV1().Events("")})
-	// TODO: remove dependence on the legacyscheme
-	return eventBroadcaster.NewRecorder(legacyscheme.Scheme, v1.EventSource{Component: userAgent})
-}
--- a/cmd/cloud-controller-manager/app/options/options_test.go
+++ b/cmd/cloud-controller-manager/app/options/options_test.go
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package options
-
-import (
-	"net"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/spf13/pflag"
-
-	apimachineryconfig "k8s.io/apimachinery/pkg/apis/config"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/diff"
-	apiserverconfig "k8s.io/apiserver/pkg/apis/config"
-	apiserveroptions "k8s.io/apiserver/pkg/server/options"
-	cmoptions "k8s.io/kubernetes/cmd/controller-manager/app/options"
-)
-
-func TestDefaultFlags(t *testing.T) {
-	s, _ := NewCloudControllerManagerOptions()
-
-	expected := &CloudControllerManagerOptions{
-		Generic: &cmoptions.GenericControllerManagerConfigurationOptions{
-			Port:            10253,     // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
-			Address:         "0.0.0.0", // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
-			MinResyncPeriod: metav1.Duration{Duration: 12 * time.Hour},
-			ClientConnection: apimachineryconfig.ClientConnectionConfiguration{
-				ContentType: "application/vnd.kubernetes.protobuf",
-				QPS:         20.0,
-				Burst:       30,
-			},
-			ControllerStartInterval: metav1.Duration{Duration: 0},
-			LeaderElection: apiserverconfig.LeaderElectionConfiguration{
-				ResourceLock:  "endpoints",
-				LeaderElect:   true,
-				LeaseDuration: metav1.Duration{Duration: 15 * time.Second},
-				RenewDeadline: metav1.Duration{Duration: 10 * time.Second},
-				RetryPeriod:   metav1.Duration{Duration: 2 * time.Second},
-			},
-			Debugging: &cmoptions.DebuggingOptions{
-				EnableContentionProfiling: false,
-			},
-			Controllers: []string{"*"},
-		},
-		KubeCloudShared: &cmoptions.KubeCloudSharedOptions{
-			RouteReconciliationPeriod: metav1.Duration{Duration: 10 * time.Second},
-			NodeMonitorPeriod:         metav1.Duration{Duration: 5 * time.Second},
-			ClusterName:               "kubernetes",
-			ClusterCIDR:               "",
-			AllocateNodeCIDRs:         false,
-			CIDRAllocatorType:         "",
-			ConfigureCloudRoutes:      true,
-			CloudProvider: &cmoptions.CloudProviderOptions{
-				Name:            "",
-				CloudConfigFile: "",
-			},
-		},
-		ServiceController: &cmoptions.ServiceControllerOptions{
-			ConcurrentServiceSyncs: 1,
-		},
-		SecureServing: (&apiserveroptions.SecureServingOptions{
-			BindPort:    10258,
-			BindAddress: net.ParseIP("0.0.0.0"),
-			ServerCert: apiserveroptions.GeneratableKeyCert{
-				CertDirectory: "/var/run/kubernetes",
-				PairName:      "cloud-controller-manager",
-			},
-			HTTP2MaxStreamsPerConnection: 0,
-		}).WithLoopback(),
-		InsecureServing: (&apiserveroptions.DeprecatedInsecureServingOptions{
-			BindAddress: net.ParseIP("0.0.0.0"),
-			BindPort:    int(10253),
-			BindNetwork: "tcp",
-		}).WithLoopback(),
-		Authentication: &apiserveroptions.DelegatingAuthenticationOptions{
-			CacheTTL:   10 * time.Second,
-			ClientCert: apiserveroptions.ClientCertAuthenticationOptions{},
-			RequestHeader: apiserveroptions.RequestHeaderAuthenticationOptions{
-				UsernameHeaders:     []string{"x-remote-user"},
-				GroupHeaders:        []string{"x-remote-group"},
-				ExtraHeaderPrefixes: []string{"x-remote-extra-"},
-			},
-			RemoteKubeConfigFileOptional: true,
-		},
-		Authorization: &apiserveroptions.DelegatingAuthorizationOptions{
-			AllowCacheTTL:                10 * time.Second,
-			DenyCacheTTL:                 10 * time.Second,
-			RemoteKubeConfigFileOptional: true,
-			AlwaysAllowPaths:             []string{"/healthz"}, // note: this does not match /healthz/ or
-		},
-		Kubeconfig: "",
-		Master:     "",
-		NodeStatusUpdateFrequency: metav1.Duration{Duration: 5 * time.Minute},
-	}
-	if !reflect.DeepEqual(expected, s) {
-		t.Errorf("Got different run options than expected.\nDifference detected on:\n%s", diff.ObjectReflectDiff(expected, s))
-	}
-}
-
-func TestAddFlags(t *testing.T) {
-	fs := pflag.NewFlagSet("addflagstest", pflag.ContinueOnError)
-	s, _ := NewCloudControllerManagerOptions()
-	for _, f := range s.Flags().FlagSets {
-		fs.AddFlagSet(f)
-	}
-
-	args := []string{
-		"--address=192.168.4.10",
-		"--allocate-node-cidrs=true",
-		"--bind-address=192.168.4.21",
-		"--cert-dir=/a/b/c",
-		"--cloud-config=/cloud-config",
-		"--cloud-provider=gce",
-		"--cluster-cidr=1.2.3.4/24",
-		"--cluster-name=k8s",
-		"--configure-cloud-routes=false",
-		"--contention-profiling=true",
-		"--controller-start-interval=2m",
-		"--http2-max-streams-per-connection=47",
-		"--kube-api-burst=100",
-		"--kube-api-content-type=application/vnd.kubernetes.protobuf",
-		"--kube-api-qps=50.0",
-		"--kubeconfig=/kubeconfig",
-		"--leader-elect=false",
-		"--leader-elect-lease-duration=30s",
-		"--leader-elect-renew-deadline=15s",
-		"--leader-elect-resource-lock=configmap",
-		"--leader-elect-retry-period=5s",
-		"--master=192.168.4.20",
-		"--min-resync-period=100m",
-		"--node-status-update-frequency=10m",
-		"--port=10000",
-		"--profiling=false",
-		"--route-reconciliation-period=30s",
-		"--secure-port=10001",
-		"--use-service-account-credentials=false",
-	}
-	fs.Parse(args)
-
-	expected := &CloudControllerManagerOptions{
-		Generic: &cmoptions.GenericControllerManagerConfigurationOptions{
-			Port:            10253,     // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
-			Address:         "0.0.0.0", // Note: InsecureServingOptions.ApplyTo will write the flag value back into the component config
-			MinResyncPeriod: metav1.Duration{Duration: 100 * time.Minute},
-			ClientConnection: apimachineryconfig.ClientConnectionConfiguration{
-				ContentType: "application/vnd.kubernetes.protobuf",
-				QPS:         50.0,
-				Burst:       100,
-			},
-			ControllerStartInterval: metav1.Duration{Duration: 2 * time.Minute},
-			LeaderElection: apiserverconfig.LeaderElectionConfiguration{
-				ResourceLock:  "configmap",
-				LeaderElect:   false,
-				LeaseDuration: metav1.Duration{Duration: 30 * time.Second},
-				RenewDeadline: metav1.Duration{Duration: 15 * time.Second},
-				RetryPeriod:   metav1.Duration{Duration: 5 * time.Second},
-			},
-			Debugging: &cmoptions.DebuggingOptions{
-				EnableContentionProfiling: true,
-			},
-			Controllers: []string{"*"},
-		},
-		KubeCloudShared: &cmoptions.KubeCloudSharedOptions{
-			CloudProvider: &cmoptions.CloudProviderOptions{
-				Name:            "gce",
-				CloudConfigFile: "/cloud-config",
-			},
-			RouteReconciliationPeriod: metav1.Duration{Duration: 30 * time.Second},
-			NodeMonitorPeriod:         metav1.Duration{Duration: 5 * time.Second},
-			ClusterName:               "k8s",
-			ClusterCIDR:               "1.2.3.4/24",
-			AllocateNodeCIDRs:         true,
-			CIDRAllocatorType:         "RangeAllocator",
-			ConfigureCloudRoutes:      false,
-		},
-		ServiceController: &cmoptions.ServiceControllerOptions{
-			ConcurrentServiceSyncs: 1,
-		},
-		SecureServing: (&apiserveroptions.SecureServingOptions{
-			BindPort:    10001,
-			BindAddress: net.ParseIP("192.168.4.21"),
-			ServerCert: apiserveroptions.GeneratableKeyCert{
-				CertDirectory: "/a/b/c",
-				PairName:      "cloud-controller-manager",
-			},
-			HTTP2MaxStreamsPerConnection: 47,
-		}).WithLoopback(),
-		InsecureServing: (&apiserveroptions.DeprecatedInsecureServingOptions{
-			BindAddress: net.ParseIP("192.168.4.10"),
-			BindPort:    int(10000),
-			BindNetwork: "tcp",
-		}).WithLoopback(),
-		Authentication: &apiserveroptions.DelegatingAuthenticationOptions{
-			CacheTTL:   10 * time.Second,
-			ClientCert: apiserveroptions.ClientCertAuthenticationOptions{},
-			RequestHeader: apiserveroptions.RequestHeaderAuthenticationOptions{
-				UsernameHeaders:     []string{"x-remote-user"},
-				GroupHeaders:        []string{"x-remote-group"},
-				ExtraHeaderPrefixes: []string{"x-remote-extra-"},
-			},
-			RemoteKubeConfigFileOptional: true,
-		},
-		Authorization: &apiserveroptions.DelegatingAuthorizationOptions{
-			AllowCacheTTL:                10 * time.Second,
-			DenyCacheTTL:                 10 * time.Second,
-			RemoteKubeConfigFileOptional: true,
-			AlwaysAllowPaths:             []string{"/healthz"}, // note: this does not match /healthz/ or
-		},
-		Kubeconfig: "/kubeconfig",
-		Master:     "192.168.4.20",
-		NodeStatusUpdateFrequency: metav1.Duration{Duration: 10 * time.Minute},
-	}
-	if !reflect.DeepEqual(expected, s) {
-		t.Errorf("Got different run options than expected.\nDifference detected on:\n%s", diff.ObjectReflectDiff(expected, s))
-	}
-}
--- a/cmd/cloud-controller-manager/app/testing/BUILD
+++ b/cmd/cloud-controller-manager/app/testing/BUILD
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
-
-filegroup(
-    name = "package-srcs",
-    srcs = glob(["**"]),
-    tags = ["automanaged"],
-    visibility = ["//visibility:private"],
-)
-
-filegroup(
-    name = "all-srcs",
-    srcs = [":package-srcs"],
-    tags = ["automanaged"],
-    visibility = ["//visibility:public"],
-)
-
-go_library(
-    name = "go_default_library",
-    srcs = ["testserver.go"],
-    importpath = "k8s.io/kubernetes/cmd/cloud-controller-manager/app/testing",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//cmd/cloud-controller-manager/app:go_default_library",
-        "//cmd/cloud-controller-manager/app/config:go_default_library",
-        "//cmd/cloud-controller-manager/app/options:go_default_library",
-        "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
-        "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
-        "//staging/src/k8s.io/client-go/rest:go_default_library",
-        "//vendor/github.com/spf13/pflag:go_default_library",
-    ],
-)
--- a/cmd/cloud-controller-manager/app/testing/testserver.go
+++ b/cmd/cloud-controller-manager/app/testing/testserver.go
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package testing
-
-import (
-	"fmt"
-	"io/ioutil"
-	"net"
-	"os"
-	"time"
-
-	"github.com/spf13/pflag"
-
-	"k8s.io/apimachinery/pkg/util/wait"
-	"k8s.io/client-go/kubernetes"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/kubernetes/cmd/cloud-controller-manager/app"
-	cloudcontrollerconfig "k8s.io/kubernetes/cmd/cloud-controller-manager/app/config"
-	"k8s.io/kubernetes/cmd/cloud-controller-manager/app/options"
-)
-
-// TearDownFunc is to be called to tear down a test server.
-type TearDownFunc func()
-
-// TestServer return values supplied by kube-test-ApiServer
-type TestServer struct {
-	LoopbackClientConfig *restclient.Config // Rest client config using the magic token
-	Options              *options.CloudControllerManagerOptions
-	Config               *cloudcontrollerconfig.Config
-	TearDownFn           TearDownFunc // TearDown function
-	TmpDir               string       // Temp Dir used, by the apiserver
-}
-
-// Logger allows t.Testing and b.Testing to be passed to StartTestServer and StartTestServerOrDie
-type Logger interface {
-	Errorf(format string, args ...interface{})
-	Fatalf(format string, args ...interface{})
-	Logf(format string, args ...interface{})
-}
-
-// StartTestServer starts a cloud-controller-manager. A rest client config and a tear-down func,
-// and location of the tmpdir are returned.
-//
-// Note: we return a tear-down func instead of a stop channel because the later will leak temporary
-// 		 files that because Golang testing's call to os.Exit will not give a stop channel go routine
-// 		 enough time to remove temporary files.
-func StartTestServer(t Logger, customFlags []string) (result TestServer, err error) {
-	stopCh := make(chan struct{})
-	tearDown := func() {
-		close(stopCh)
-		if len(result.TmpDir) != 0 {
-			os.RemoveAll(result.TmpDir)
-		}
-	}
-	defer func() {
-		if result.TearDownFn == nil {
-			tearDown()
-		}
-	}()
-
-	result.TmpDir, err = ioutil.TempDir("", "cloud-controller-manager")
-	if err != nil {
-		return result, fmt.Errorf("failed to create temp dir: %v", err)
-	}
-
-	fs := pflag.NewFlagSet("test", pflag.PanicOnError)
-
-	s, err := options.NewCloudControllerManagerOptions()
-	if err != nil {
-		return TestServer{}, err
-	}
-	namedFlagSets := s.Flags()
-	for _, f := range namedFlagSets.FlagSets {
-		fs.AddFlagSet(f)
-	}
-	fs.Parse(customFlags)
-
-	if s.SecureServing.BindPort != 0 {
-		s.SecureServing.Listener, s.SecureServing.BindPort, err = createListenerOnFreePort()
-		if err != nil {
-			return result, fmt.Errorf("failed to create listener: %v", err)
-		}
-		s.SecureServing.ServerCert.CertDirectory = result.TmpDir
-
-		t.Logf("cloud-controller-manager will listen securely on port %d...", s.SecureServing.BindPort)
-	}
-
-	if s.InsecureServing.BindPort != 0 {
-		s.InsecureServing.Listener, s.InsecureServing.BindPort, err = createListenerOnFreePort()
-		if err != nil {
-			return result, fmt.Errorf("failed to create listener: %v", err)
-		}
-
-		t.Logf("cloud-controller-manager will listen insecurely on port %d...", s.InsecureServing.BindPort)
-	}
-
-	config, err := s.Config()
-	if err != nil {
-		return result, fmt.Errorf("failed to create config from options: %v", err)
-	}
-
-	go func(stopCh <-chan struct{}) {
-		if err := app.Run(config.Complete(), stopCh); err != nil {
-			t.Errorf("cloud-apiserver failed run: %v", err)
-		}
-	}(stopCh)
-
-	t.Logf("Waiting for /healthz to be ok...")
-	client, err := kubernetes.NewForConfig(config.LoopbackClientConfig)
-	if err != nil {
-		return result, fmt.Errorf("failed to create a client: %v", err)
-	}
-	err = wait.Poll(100*time.Millisecond, 30*time.Second, func() (bool, error) {
-		result := client.CoreV1().RESTClient().Get().AbsPath("/healthz").Do()
-		status := 0
-		result.StatusCode(&status)
-		if status == 200 {
-			return true, nil
-		}
-		return false, nil
-	})
-	if err != nil {
-		return result, fmt.Errorf("failed to wait for /healthz to return ok: %v", err)
-	}
-
-	// from here the caller must call tearDown
-	result.LoopbackClientConfig = config.LoopbackClientConfig
-	result.Options = s
-	result.Config = config
-	result.TearDownFn = tearDown
-
-	return result, nil
-}
-
-// StartTestServerOrDie calls StartTestServer t.Fatal if it does not succeed.
-func StartTestServerOrDie(t Logger, flags []string) *TestServer {
-	result, err := StartTestServer(t, flags)
-	if err == nil {
-		return &result
-	}
-
-	t.Fatalf("failed to launch server: %v", err)
-	return nil
-}
-
-func createListenerOnFreePort() (net.Listener, int, error) {
-	ln, err := net.Listen("tcp", ":0")
-	if err != nil {
-		return nil, 0, err
-	}
-
-	// get port
-	tcpAddr, ok := ln.Addr().(*net.TCPAddr)
-	if !ok {
-		ln.Close()
-		return nil, 0, fmt.Errorf("invalid listen address: %q", ln.Addr().String())
-	}
-
-	return ln, tcpAddr.Port, nil
-}
--- a/cmd/cloud-controller-manager/controller-manager.go
+++ b/cmd/cloud-controller-manager/controller-manager.go
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// The external controller manager is responsible for running controller loops that
-// are cloud provider dependent. It uses the API to listen to new events on resources.
-
-package main
-
-import (
-	goflag "flag"
-	"fmt"
-	"math/rand"
-	"os"
-	"time"
-
-	utilflag "k8s.io/apiserver/pkg/util/flag"
-	"k8s.io/apiserver/pkg/util/logs"
-	"k8s.io/kubernetes/cmd/cloud-controller-manager/app"
-	_ "k8s.io/kubernetes/pkg/client/metrics/prometheus" // for client metric registration
-	// NOTE: Importing all in-tree cloud-providers is not required when
-	// implementing an out-of-tree cloud-provider.
-	_ "k8s.io/kubernetes/pkg/cloudprovider/providers"
-	_ "k8s.io/kubernetes/pkg/version/prometheus" // for version metric registration
-
-	"github.com/spf13/pflag"
-)
-
-func main() {
-	rand.Seed(time.Now().UTC().UnixNano())
-
-	command := app.NewCloudControllerManagerCommand()
-
-	// TODO: once we switch everything over to Cobra commands, we can go back to calling
-	// utilflag.InitFlags() (by removing its pflag.Parse() call). For now, we have to set the
-	// normalize func and add the go flag set by hand.
-	pflag.CommandLine.SetNormalizeFunc(utilflag.WordSepNormalizeFunc)
-	pflag.CommandLine.AddGoFlagSet(goflag.CommandLine)
-	// utilflag.InitFlags()
-	logs.InitLogs()
-	defer logs.FlushLogs()
-
-	if err := command.Execute(); err != nil {
-		fmt.Fprintf(os.Stderr, "error: %v\n", err)
-		os.Exit(1)
-	}
-}
--- a/cmd/hyperkube/main.go
+++ b/cmd/hyperkube/main.go
@@ -35,7 +35,6 @@ import (
 	"k8s.io/apiserver/pkg/server"
 	utilflag "k8s.io/apiserver/pkg/util/flag"
 	"k8s.io/apiserver/pkg/util/logs"
-	cloudcontrollermanager "k8s.io/kubernetes/cmd/cloud-controller-manager/app"
 	kubeapiserver "k8s.io/kubernetes/cmd/kube-apiserver/app"
 	kubecontrollermanager "k8s.io/kubernetes/cmd/kube-controller-manager/app"
 	kubeproxy "k8s.io/kubernetes/cmd/kube-proxy/app"
@@ -113,7 +112,6 @@ func NewHyperKubeCommand(stopCh <-chan struct{}) (*cobra.Command, []func() *cobr
 	}
 	kubectlCmd := func() *cobra.Command { return kubectl.NewDefaultKubectlCommand() }
 	kubelet := func() *cobra.Command { return kubelet.NewKubeletCommand(stopCh) }
-	cloudController := func() *cobra.Command { return cloudcontrollermanager.NewCloudControllerManagerCommand() }

 	commandFns := []func() *cobra.Command{
 		apiserver,
@@ -122,7 +120,6 @@ func NewHyperKubeCommand(stopCh <-chan struct{}) (*cobra.Command, []func() *cobr
 		scheduler,
 		kubectlCmd,
 		kubelet,
-		cloudController,
 	}

 	makeSymlinksFlag := false