Add glide.yaml and vendor deps

vendor/k8s.io/kubernetes/pkg/registry/extensions/rest/BUILD

@@ -0,0 +1,58 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "storage_extensions.go",
+        "thirdparty_controller.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/api/rest:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/apis/extensions/v1beta1:go_default_library",
+        "//pkg/client/clientset_generated/internalclientset/typed/extensions/internalversion:go_default_library",
+        "//pkg/genericapiserver:go_default_library",
+        "//pkg/registry:go_default_library",
+        "//pkg/registry/autoscaling/horizontalpodautoscaler/etcd:go_default_library",
+        "//pkg/registry/batch/job/etcd:go_default_library",
+        "//pkg/registry/extensions/controller/etcd:go_default_library",
+        "//pkg/registry/extensions/daemonset/etcd:go_default_library",
+        "//pkg/registry/extensions/deployment/etcd:go_default_library",
+        "//pkg/registry/extensions/ingress/etcd:go_default_library",
+        "//pkg/registry/extensions/networkpolicy/etcd:go_default_library",
+        "//pkg/registry/extensions/podsecuritypolicy/etcd:go_default_library",
+        "//pkg/registry/extensions/replicaset/etcd:go_default_library",
+        "//pkg/registry/extensions/thirdpartyresource/etcd:go_default_library",
+        "//pkg/registry/extensions/thirdpartyresourcedata:go_default_library",
+        "//pkg/runtime:go_default_library",
+        "//pkg/util/runtime:go_default_library",
+        "//pkg/util/sets:go_default_library",
+        "//pkg/util/wait:go_default_library",
+        "//vendor:github.com/golang/glog",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["thirdparty_controller_test.go"],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api:go_default_library",
+        "//pkg/apis/extensions:go_default_library",
+        "//pkg/registry/extensions/thirdpartyresourcedata:go_default_library",
+        "//pkg/util/sets:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/registry/extensions/rest/storage_extensions.go

@@ -0,0 +1,145 @@
+/*
+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 rest
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/golang/glog"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/rest"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	extensionsapiv1beta1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
+	extensionsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/internalversion"
+	"k8s.io/kubernetes/pkg/genericapiserver"
+	"k8s.io/kubernetes/pkg/registry"
+	horizontalpodautoscaleretcd "k8s.io/kubernetes/pkg/registry/autoscaling/horizontalpodautoscaler/etcd"
+	jobetcd "k8s.io/kubernetes/pkg/registry/batch/job/etcd"
+	expcontrolleretcd "k8s.io/kubernetes/pkg/registry/extensions/controller/etcd"
+	daemonetcd "k8s.io/kubernetes/pkg/registry/extensions/daemonset/etcd"
+	deploymentetcd "k8s.io/kubernetes/pkg/registry/extensions/deployment/etcd"
+	ingressetcd "k8s.io/kubernetes/pkg/registry/extensions/ingress/etcd"
+	networkpolicyetcd "k8s.io/kubernetes/pkg/registry/extensions/networkpolicy/etcd"
+	pspetcd "k8s.io/kubernetes/pkg/registry/extensions/podsecuritypolicy/etcd"
+	replicasetetcd "k8s.io/kubernetes/pkg/registry/extensions/replicaset/etcd"
+	thirdpartyresourceetcd "k8s.io/kubernetes/pkg/registry/extensions/thirdpartyresource/etcd"
+	utilruntime "k8s.io/kubernetes/pkg/util/runtime"
+	"k8s.io/kubernetes/pkg/util/wait"
+)
+
+type RESTStorageProvider struct {
+	ResourceInterface ResourceInterface
+}
+
+func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource genericapiserver.APIResourceConfigSource, restOptionsGetter registry.RESTOptionsGetter) (genericapiserver.APIGroupInfo, bool) {
+	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(extensions.GroupName)
+
+	if apiResourceConfigSource.AnyResourcesForVersionEnabled(extensionsapiv1beta1.SchemeGroupVersion) {
+		apiGroupInfo.VersionedResourcesStorageMap[extensionsapiv1beta1.SchemeGroupVersion.Version] = p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter)
+		apiGroupInfo.GroupMeta.GroupVersion = extensionsapiv1beta1.SchemeGroupVersion
+	}
+
+	return apiGroupInfo, true
+}
+
+func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource genericapiserver.APIResourceConfigSource, restOptionsGetter registry.RESTOptionsGetter) map[string]rest.Storage {
+	version := extensionsapiv1beta1.SchemeGroupVersion
+
+	storage := map[string]rest.Storage{}
+
+	if apiResourceConfigSource.ResourceEnabled(version.WithResource("horizontalpodautoscalers")) {
+		hpaStorage, hpaStatusStorage := horizontalpodautoscaleretcd.NewREST(restOptionsGetter(extensions.Resource("horizontalpodautoscalers")))
+		storage["horizontalpodautoscalers"] = hpaStorage
+		storage["horizontalpodautoscalers/status"] = hpaStatusStorage
+
+		controllerStorage := expcontrolleretcd.NewStorage(restOptionsGetter(api.Resource("replicationControllers")))
+		storage["replicationcontrollers"] = controllerStorage.ReplicationController
+		storage["replicationcontrollers/scale"] = controllerStorage.Scale
+	}
+	if apiResourceConfigSource.ResourceEnabled(version.WithResource("thirdpartyresources")) {
+		thirdPartyResourceStorage := thirdpartyresourceetcd.NewREST(restOptionsGetter(extensions.Resource("thirdpartyresources")))
+		storage["thirdpartyresources"] = thirdPartyResourceStorage
+	}
+
+	if apiResourceConfigSource.ResourceEnabled(version.WithResource("daemonsets")) {
+		daemonSetStorage, daemonSetStatusStorage := daemonetcd.NewREST(restOptionsGetter(extensions.Resource("daemonsets")))
+		storage["daemonsets"] = daemonSetStorage
+		storage["daemonsets/status"] = daemonSetStatusStorage
+	}
+	if apiResourceConfigSource.ResourceEnabled(version.WithResource("deployments")) {
+		deploymentStorage := deploymentetcd.NewStorage(restOptionsGetter(extensions.Resource("deployments")))
+		storage["deployments"] = deploymentStorage.Deployment
+		storage["deployments/status"] = deploymentStorage.Status
+		storage["deployments/rollback"] = deploymentStorage.Rollback
+		storage["deployments/scale"] = deploymentStorage.Scale
+	}
+	if apiResourceConfigSource.ResourceEnabled(version.WithResource("jobs")) {
+		jobsStorage, jobsStatusStorage := jobetcd.NewREST(restOptionsGetter(extensions.Resource("jobs")))
+		storage["jobs"] = jobsStorage
+		storage["jobs/status"] = jobsStatusStorage
+	}
+	if apiResourceConfigSource.ResourceEnabled(version.WithResource("ingresses")) {
+		ingressStorage, ingressStatusStorage := ingressetcd.NewREST(restOptionsGetter(extensions.Resource("ingresses")))
+		storage["ingresses"] = ingressStorage
+		storage["ingresses/status"] = ingressStatusStorage
+	}
+	if apiResourceConfigSource.ResourceEnabled(version.WithResource("podsecuritypolicy")) {
+		podSecurityExtensionsStorage := pspetcd.NewREST(restOptionsGetter(extensions.Resource("podsecuritypolicy")))
+		storage["podSecurityPolicies"] = podSecurityExtensionsStorage
+	}
+	if apiResourceConfigSource.ResourceEnabled(version.WithResource("replicasets")) {
+		replicaSetStorage := replicasetetcd.NewStorage(restOptionsGetter(extensions.Resource("replicasets")))
+		storage["replicasets"] = replicaSetStorage.ReplicaSet
+		storage["replicasets/status"] = replicaSetStorage.Status
+		storage["replicasets/scale"] = replicaSetStorage.Scale
+	}
+	if apiResourceConfigSource.ResourceEnabled(version.WithResource("networkpolicies")) {
+		networkExtensionsStorage := networkpolicyetcd.NewREST(restOptionsGetter(extensions.Resource("networkpolicies")))
+		storage["networkpolicies"] = networkExtensionsStorage
+	}
+
+	return storage
+}
+
+func (p RESTStorageProvider) PostStartHook() (string, genericapiserver.PostStartHookFunc, error) {
+	return "extensions/third-party-resources", p.postStartHookFunc, nil
+}
+func (p RESTStorageProvider) postStartHookFunc(hookContext genericapiserver.PostStartHookContext) error {
+	clientset, err := extensionsclient.NewForConfig(hookContext.LoopbackClientConfig)
+	if err != nil {
+		utilruntime.HandleError(fmt.Errorf("unable to initialize clusterroles: %v", err))
+		return nil
+	}
+
+	thirdPartyControl := ThirdPartyController{
+		master: p.ResourceInterface,
+		client: clientset,
+	}
+	go wait.Forever(func() {
+		if err := thirdPartyControl.SyncResources(); err != nil {
+			glog.Warningf("third party resource sync failed: %v", err)
+		}
+	}, 10*time.Second)
+
+	return nil
+}
+
+func (p RESTStorageProvider) GroupName() string {
+	return extensions.GroupName
+}

vendor/k8s.io/kubernetes/pkg/registry/extensions/rest/thirdparty_controller.go

@@ -0,0 +1,131 @@
+/*
+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 rest
+
+import (
+	"fmt"
+	"strings"
+
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	extensionsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/internalversion"
+	"k8s.io/kubernetes/pkg/registry/extensions/thirdpartyresourcedata"
+	"k8s.io/kubernetes/pkg/runtime"
+	"k8s.io/kubernetes/pkg/util/sets"
+)
+
+// ResourceInterface is the interface for the parts of the master that know how to add/remove
+// third party resources.  Extracted into an interface for injection for testing.
+type ResourceInterface interface {
+	// Remove a third party resource based on the RESTful path for that resource, the path is <api-group-path>/<resource-plural-name>
+	RemoveThirdPartyResource(path string) error
+	// Install a third party resource described by 'rsrc'
+	InstallThirdPartyResource(rsrc *extensions.ThirdPartyResource) error
+	// Is a particular third party resource currently installed?
+	HasThirdPartyResource(rsrc *extensions.ThirdPartyResource) (bool, error)
+	// List all currently installed third party resources, the returned
+	// names are of the form <api-group-path>/<resource-plural-name>
+	ListThirdPartyResources() []string
+}
+
+const thirdpartyprefix = "/apis"
+
+// ThirdPartyController is a control loop that knows how to synchronize ThirdPartyResource objects with
+// RESTful resources which are present in the API server.
+type ThirdPartyController struct {
+	master ResourceInterface
+	client extensionsclient.ThirdPartyResourcesGetter
+}
+
+// SyncOneResource synchronizes a single resource with RESTful resources on the master
+func (t *ThirdPartyController) SyncOneResource(rsrc *extensions.ThirdPartyResource) error {
+	// TODO: we also need to test if the existing installed resource matches the resource we are sync-ing.
+	// Currently, if there is an older, incompatible resource installed, we won't remove it.  We should detect
+	// older, incompatible resources and remove them before testing if the resource exists.
+	hasResource, err := t.master.HasThirdPartyResource(rsrc)
+	if err != nil {
+		return err
+	}
+	if !hasResource {
+		return t.master.InstallThirdPartyResource(rsrc)
+	}
+	return nil
+}
+
+// Synchronize all resources with RESTful resources on the master
+func (t *ThirdPartyController) SyncResources() error {
+	list, err := t.client.ThirdPartyResources().List(api.ListOptions{})
+	if err != nil {
+		return err
+	}
+	return t.syncResourceList(list)
+}
+
+func (t *ThirdPartyController) syncResourceList(list runtime.Object) error {
+	existing := sets.String{}
+	switch list := list.(type) {
+	case *extensions.ThirdPartyResourceList:
+		// Loop across all schema objects for third party resources
+		for ix := range list.Items {
+			item := &list.Items[ix]
+			// extract the api group and resource kind from the schema
+			_, group, err := thirdpartyresourcedata.ExtractApiGroupAndKind(item)
+			if err != nil {
+				return err
+			}
+			// place it in the set of resources that we expect, so that we don't delete it in the delete pass
+			existing.Insert(MakeThirdPartyPath(group))
+			// ensure a RESTful resource for this schema exists on the master
+			if err := t.SyncOneResource(item); err != nil {
+				return err
+			}
+		}
+	default:
+		return fmt.Errorf("expected a *ThirdPartyResourceList, got %#v", list)
+	}
+	// deletion phase, get all installed RESTful resources
+	installed := t.master.ListThirdPartyResources()
+	for _, installedAPI := range installed {
+		found := false
+		// search across the expected restful resources to see if this resource belongs to one of the expected ones
+		for _, apiPath := range existing.List() {
+			if installedAPI == apiPath || strings.HasPrefix(installedAPI, apiPath+"/") {
+				found = true
+				break
+			}
+		}
+		// not expected, delete the resource
+		if !found {
+			if err := t.master.RemoveThirdPartyResource(installedAPI); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func MakeThirdPartyPath(group string) string {
+	if len(group) == 0 {
+		return thirdpartyprefix
+	}
+	return thirdpartyprefix + "/" + group
+}
+
+func GetThirdPartyGroupName(path string) string {
+	return strings.TrimPrefix(strings.TrimPrefix(path, thirdpartyprefix), "/")
+}

vendor/k8s.io/kubernetes/pkg/registry/extensions/rest/thirdparty_controller_test.go

@@ -0,0 +1,177 @@
+/*
+Copyright 2014 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 rest
+
+import (
+	"testing"
+
+	"k8s.io/kubernetes/pkg/api"
+	expapi "k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/registry/extensions/thirdpartyresourcedata"
+	"k8s.io/kubernetes/pkg/util/sets"
+)
+
+type FakeAPIInterface struct {
+	removed   []string
+	installed []*expapi.ThirdPartyResource
+	apis      []string
+	t         *testing.T
+}
+
+func (f *FakeAPIInterface) RemoveThirdPartyResource(path string) error {
+	f.removed = append(f.removed, path)
+	return nil
+}
+
+func (f *FakeAPIInterface) InstallThirdPartyResource(rsrc *expapi.ThirdPartyResource) error {
+	f.installed = append(f.installed, rsrc)
+	_, group, _ := thirdpartyresourcedata.ExtractApiGroupAndKind(rsrc)
+	f.apis = append(f.apis, MakeThirdPartyPath(group))
+	return nil
+}
+
+func (f *FakeAPIInterface) HasThirdPartyResource(rsrc *expapi.ThirdPartyResource) (bool, error) {
+	if f.apis == nil {
+		return false, nil
+	}
+	_, group, _ := thirdpartyresourcedata.ExtractApiGroupAndKind(rsrc)
+	path := MakeThirdPartyPath(group)
+	for _, api := range f.apis {
+		if api == path {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+func (f *FakeAPIInterface) ListThirdPartyResources() []string {
+	return f.apis
+}
+
+func TestSyncAPIs(t *testing.T) {
+	resourcesNamed := func(names ...string) []expapi.ThirdPartyResource {
+		result := []expapi.ThirdPartyResource{}
+		for _, name := range names {
+			result = append(result, expapi.ThirdPartyResource{ObjectMeta: api.ObjectMeta{Name: name}})
+		}
+		return result
+	}
+
+	tests := []struct {
+		list              *expapi.ThirdPartyResourceList
+		apis              []string
+		expectedInstalled []string
+		expectedRemoved   []string
+		name              string
+	}{
+		{
+			list: &expapi.ThirdPartyResourceList{
+				Items: resourcesNamed("foo.example.com"),
+			},
+			expectedInstalled: []string{"foo.example.com"},
+			name:              "simple add",
+		},
+		{
+			list: &expapi.ThirdPartyResourceList{
+				Items: resourcesNamed("foo.example.com"),
+			},
+			apis: []string{
+				"/apis/example.com",
+				"/apis/example.com/v1",
+			},
+			name: "does nothing",
+		},
+		{
+			list: &expapi.ThirdPartyResourceList{
+				Items: resourcesNamed("foo.example.com"),
+			},
+			apis: []string{
+				"/apis/example.com",
+				"/apis/example.com/v1",
+				"/apis/example.co",
+				"/apis/example.co/v1",
+			},
+			name: "deletes substring API",
+			expectedRemoved: []string{
+				"/apis/example.co",
+				"/apis/example.co/v1",
+			},
+		},
+		{
+			list: &expapi.ThirdPartyResourceList{
+				Items: resourcesNamed("foo.example.com", "foo.company.com"),
+			},
+			apis: []string{
+				"/apis/company.com",
+				"/apis/company.com/v1",
+			},
+			expectedInstalled: []string{"foo.example.com"},
+			name:              "adds with existing",
+		},
+		{
+			list: &expapi.ThirdPartyResourceList{
+				Items: resourcesNamed("foo.example.com"),
+			},
+			apis: []string{
+				"/apis/company.com",
+				"/apis/company.com/v1",
+			},
+			expectedInstalled: []string{"foo.example.com"},
+			expectedRemoved:   []string{"/apis/company.com", "/apis/company.com/v1"},
+			name:              "removes with existing",
+		},
+	}
+
+	for _, test := range tests {
+		fake := FakeAPIInterface{
+			apis: test.apis,
+			t:    t,
+		}
+
+		cntrl := ThirdPartyController{master: &fake}
+
+		if err := cntrl.syncResourceList(test.list); err != nil {
+			t.Errorf("[%s] unexpected error: %v", test.name, err)
+		}
+		if len(test.expectedInstalled) != len(fake.installed) {
+			t.Errorf("[%s] unexpected installed APIs: %d, expected %d (%#v)", test.name, len(fake.installed), len(test.expectedInstalled), fake.installed[0])
+			continue
+		} else {
+			names := sets.String{}
+			for ix := range fake.installed {
+				names.Insert(fake.installed[ix].Name)
+			}
+			for _, name := range test.expectedInstalled {
+				if !names.Has(name) {
+					t.Errorf("[%s] missing installed API: %s", test.name, name)
+				}
+			}
+		}
+		if len(test.expectedRemoved) != len(fake.removed) {
+			t.Errorf("[%s] unexpected installed APIs: %d, expected %d", test.name, len(fake.removed), len(test.expectedRemoved))
+			continue
+		} else {
+			names := sets.String{}
+			names.Insert(fake.removed...)
+			for _, name := range test.expectedRemoved {
+				if !names.Has(name) {
+					t.Errorf("[%s] missing removed API: %s (%s)", test.name, name, names)
+				}
+			}
+		}
+	}
+}