generated staging area

pkg/client/clientset_generated/release_1_4/import_known_versions.go

@@ -22,6 +22,7 @@ import (
 
 	_ "k8s.io/kubernetes/pkg/api/install"
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
+	_ "k8s.io/kubernetes/pkg/apis/authorization/install"
 	_ "k8s.io/kubernetes/pkg/apis/autoscaling/install"
 	_ "k8s.io/kubernetes/pkg/apis/batch/install"
 	_ "k8s.io/kubernetes/pkg/apis/extensions/install"

staging/src/k8s.io/client-go/1.4/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   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.

staging/src/k8s.io/client-go/1.4/discovery/client_test.go

@@ -0,0 +1,322 @@
+/*
+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 discovery
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+
+	"github.com/emicklei/go-restful/swagger"
+
+	"k8s.io/client-go/1.4/pkg/api/unversioned"
+	"k8s.io/client-go/1.4/pkg/api/v1"
+	"k8s.io/client-go/1.4/pkg/version"
+	"k8s.io/client-go/1.4/rest"
+)
+
+func TestGetServerVersion(t *testing.T) {
+	expect := version.Info{
+		Major:     "foo",
+		Minor:     "bar",
+		GitCommit: "baz",
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		output, err := json.Marshal(expect)
+		if err != nil {
+			t.Errorf("unexpected encoding error: %v", err)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		w.Write(output)
+	}))
+	defer server.Close()
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+
+	got, err := client.ServerVersion()
+	if err != nil {
+		t.Fatalf("unexpected encoding error: %v", err)
+	}
+	if e, a := expect, *got; !reflect.DeepEqual(e, a) {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+}
+
+func TestGetServerGroupsWithV1Server(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		var obj interface{}
+		switch req.URL.Path {
+		case "/api":
+			obj = &unversioned.APIVersions{
+				Versions: []string{
+					"v1",
+				},
+			}
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+		output, err := json.Marshal(obj)
+		if err != nil {
+			t.Fatalf("unexpected encoding error: %v", err)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		w.Write(output)
+	}))
+	defer server.Close()
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+	// ServerGroups should not return an error even if server returns error at /api and /apis
+	apiGroupList, err := client.ServerGroups()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	groupVersions := unversioned.ExtractGroupVersions(apiGroupList)
+	if !reflect.DeepEqual(groupVersions, []string{"v1"}) {
+		t.Errorf("expected: %q, got: %q", []string{"v1"}, groupVersions)
+	}
+}
+
+func TestGetServerGroupsWithBrokenServer(t *testing.T) {
+	for _, statusCode := range []int{http.StatusNotFound, http.StatusForbidden} {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+			w.WriteHeader(statusCode)
+		}))
+		defer server.Close()
+		client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+		// ServerGroups should not return an error even if server returns Not Found or Forbidden error at all end points
+		apiGroupList, err := client.ServerGroups()
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		groupVersions := unversioned.ExtractGroupVersions(apiGroupList)
+		if len(groupVersions) != 0 {
+			t.Errorf("expected empty list, got: %q", groupVersions)
+		}
+	}
+}
+
+func TestGetServerResourcesWithV1Server(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		var obj interface{}
+		switch req.URL.Path {
+		case "/api":
+			obj = &unversioned.APIVersions{
+				Versions: []string{
+					"v1",
+				},
+			}
+		default:
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+		output, err := json.Marshal(obj)
+		if err != nil {
+			t.Errorf("unexpected encoding error: %v", err)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		w.Write(output)
+	}))
+	defer server.Close()
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+	// ServerResources should not return an error even if server returns error at /api/v1.
+	resourceMap, err := client.ServerResources()
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if _, found := resourceMap["v1"]; !found {
+		t.Errorf("missing v1 in resource map")
+	}
+
+}
+
+func TestGetServerResources(t *testing.T) {
+	stable := unversioned.APIResourceList{
+		GroupVersion: "v1",
+		APIResources: []unversioned.APIResource{
+			{"pods", true, "Pod"},
+			{"services", true, "Service"},
+			{"namespaces", false, "Namespace"},
+		},
+	}
+	beta := unversioned.APIResourceList{
+		GroupVersion: "extensions/v1",
+		APIResources: []unversioned.APIResource{
+			{"deployments", true, "Deployment"},
+			{"ingresses", true, "Ingress"},
+			{"jobs", true, "Job"},
+		},
+	}
+	tests := []struct {
+		resourcesList *unversioned.APIResourceList
+		path          string
+		request       string
+		expectErr     bool
+	}{
+		{
+			resourcesList: &stable,
+			path:          "/api/v1",
+			request:       "v1",
+			expectErr:     false,
+		},
+		{
+			resourcesList: &beta,
+			path:          "/apis/extensions/v1beta1",
+			request:       "extensions/v1beta1",
+			expectErr:     false,
+		},
+		{
+			resourcesList: &stable,
+			path:          "/api/v1",
+			request:       "foobar",
+			expectErr:     true,
+		},
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		var list interface{}
+		switch req.URL.Path {
+		case "/api/v1":
+			list = &stable
+		case "/apis/extensions/v1beta1":
+			list = &beta
+		case "/api":
+			list = &unversioned.APIVersions{
+				Versions: []string{
+					"v1",
+				},
+			}
+		case "/apis":
+			list = &unversioned.APIGroupList{
+				Groups: []unversioned.APIGroup{
+					{
+						Versions: []unversioned.GroupVersionForDiscovery{
+							{GroupVersion: "extensions/v1beta1"},
+						},
+					},
+				},
+			}
+		default:
+			t.Logf("unexpected request: %s", req.URL.Path)
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+		output, err := json.Marshal(list)
+		if err != nil {
+			t.Errorf("unexpected encoding error: %v", err)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		w.Write(output)
+	}))
+	defer server.Close()
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+	for _, test := range tests {
+		got, err := client.ServerResourcesForGroupVersion(test.request)
+		if test.expectErr {
+			if err == nil {
+				t.Error("unexpected non-error")
+			}
+			continue
+		}
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			continue
+		}
+		if !reflect.DeepEqual(got, test.resourcesList) {
+			t.Errorf("expected:\n%v\ngot:\n%v\n", test.resourcesList, got)
+		}
+	}
+
+	resourceMap, err := client.ServerResources()
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	for _, api := range []string{"v1", "extensions/v1beta1"} {
+		if _, found := resourceMap[api]; !found {
+			t.Errorf("missing expected api: %s", api)
+		}
+	}
+}
+
+func swaggerSchemaFakeServer() (*httptest.Server, error) {
+	request := 1
+	var sErr error
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		var resp interface{}
+		if request == 1 {
+			resp = unversioned.APIVersions{Versions: []string{"v1", "v2", "v3"}}
+			request++
+		} else {
+			resp = swagger.ApiDeclaration{}
+		}
+		output, err := json.Marshal(resp)
+		if err != nil {
+			sErr = err
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		w.Write(output)
+	}))
+	return server, sErr
+}
+
+func TestGetSwaggerSchema(t *testing.T) {
+	expect := swagger.ApiDeclaration{}
+
+	server, err := swaggerSchemaFakeServer()
+	if err != nil {
+		t.Errorf("unexpected encoding error: %v", err)
+	}
+	defer server.Close()
+
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+	got, err := client.SwaggerSchema(v1.SchemeGroupVersion)
+	if err != nil {
+		t.Fatalf("unexpected encoding error: %v", err)
+	}
+	if e, a := expect, *got; !reflect.DeepEqual(e, a) {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+}
+
+func TestGetSwaggerSchemaFail(t *testing.T) {
+	expErr := "API version: api.group/v4 is not supported by the server. Use one of: [v1 v2 v3]"
+
+	server, err := swaggerSchemaFakeServer()
+	if err != nil {
+		t.Errorf("unexpected encoding error: %v", err)
+	}
+	defer server.Close()
+
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+	got, err := client.SwaggerSchema(unversioned.GroupVersion{Group: "api.group", Version: "v4"})
+	if got != nil {
+		t.Fatalf("unexpected response: %v", got)
+	}
+	if err.Error() != expErr {
+		t.Errorf("expected an error, got %v", err)
+	}
+}

staging/src/k8s.io/client-go/1.4/discovery/discovery_client.go

@@ -0,0 +1,317 @@
+/*
+Copyright 2015 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 discovery
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/emicklei/go-restful/swagger"
+
+	"k8s.io/client-go/1.4/pkg/api"
+	"k8s.io/client-go/1.4/pkg/api/errors"
+	"k8s.io/client-go/1.4/pkg/api/unversioned"
+	"k8s.io/client-go/1.4/pkg/api/v1"
+	"k8s.io/client-go/1.4/pkg/runtime"
+	"k8s.io/client-go/1.4/pkg/runtime/serializer"
+	utilerrors "k8s.io/client-go/1.4/pkg/util/errors"
+	"k8s.io/client-go/1.4/pkg/version"
+	"k8s.io/client-go/1.4/rest"
+)
+
+// DiscoveryInterface holds the methods that discover server-supported API groups,
+// versions and resources.
+type DiscoveryInterface interface {
+	ServerGroupsInterface
+	ServerResourcesInterface
+	ServerVersionInterface
+	SwaggerSchemaInterface
+}
+
+// ServerGroupsInterface has methods for obtaining supported groups on the API server
+type ServerGroupsInterface interface {
+	// ServerGroups returns the supported groups, with information like supported versions and the
+	// preferred version.
+	ServerGroups() (*unversioned.APIGroupList, error)
+}
+
+// ServerResourcesInterface has methods for obtaining supported resources on the API server
+type ServerResourcesInterface interface {
+	// ServerResourcesForGroupVersion returns the supported resources for a group and version.
+	ServerResourcesForGroupVersion(groupVersion string) (*unversioned.APIResourceList, error)
+	// ServerResources returns the supported resources for all groups and versions.
+	ServerResources() (map[string]*unversioned.APIResourceList, error)
+	// ServerPreferredResources returns the supported resources with the version preferred by the
+	// server.
+	ServerPreferredResources() ([]unversioned.GroupVersionResource, error)
+	// ServerPreferredNamespacedResources returns the supported namespaced resources with the
+	// version preferred by the server.
+	ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error)
+}
+
+// ServerVersionInterface has a method for retrieving the server's version.
+type ServerVersionInterface interface {
+	// ServerVersion retrieves and parses the server's version (git version).
+	ServerVersion() (*version.Info, error)
+}
+
+// SwaggerSchemaInterface has a method to retrieve the swagger schema.
+type SwaggerSchemaInterface interface {
+	// SwaggerSchema retrieves and parses the swagger API schema the server supports.
+	SwaggerSchema(version unversioned.GroupVersion) (*swagger.ApiDeclaration, error)
+}
+
+// DiscoveryClient implements the functions that discover server-supported API groups,
+// versions and resources.
+type DiscoveryClient struct {
+	*rest.RESTClient
+
+	LegacyPrefix string
+}
+
+// Convert unversioned.APIVersions to unversioned.APIGroup. APIVersions is used by legacy v1, so
+// group would be "".
+func apiVersionsToAPIGroup(apiVersions *unversioned.APIVersions) (apiGroup unversioned.APIGroup) {
+	groupVersions := []unversioned.GroupVersionForDiscovery{}
+	for _, version := range apiVersions.Versions {
+		groupVersion := unversioned.GroupVersionForDiscovery{
+			GroupVersion: version,
+			Version:      version,
+		}
+		groupVersions = append(groupVersions, groupVersion)
+	}
+	apiGroup.Versions = groupVersions
+	// There should be only one groupVersion returned at /api
+	apiGroup.PreferredVersion = groupVersions[0]
+	return
+}
+
+// ServerGroups returns the supported groups, with information like supported versions and the
+// preferred version.
+func (d *DiscoveryClient) ServerGroups() (apiGroupList *unversioned.APIGroupList, err error) {
+	// Get the groupVersions exposed at /api
+	v := &unversioned.APIVersions{}
+	err = d.Get().AbsPath(d.LegacyPrefix).Do().Into(v)
+	apiGroup := unversioned.APIGroup{}
+	if err == nil {
+		apiGroup = apiVersionsToAPIGroup(v)
+	}
+	if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {
+		return nil, err
+	}
+
+	// Get the groupVersions exposed at /apis
+	apiGroupList = &unversioned.APIGroupList{}
+	err = d.Get().AbsPath("/apis").Do().Into(apiGroupList)
+	if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {
+		return nil, err
+	}
+	// to be compatible with a v1.0 server, if it's a 403 or 404, ignore and return whatever we got from /api
+	if err != nil && (errors.IsNotFound(err) || errors.IsForbidden(err)) {
+		apiGroupList = &unversioned.APIGroupList{}
+	}
+
+	// append the group retrieved from /api to the list
+	apiGroupList.Groups = append(apiGroupList.Groups, apiGroup)
+	return apiGroupList, nil
+}
+
+// ServerResourcesForGroupVersion returns the supported resources for a group and version.
+func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (resources *unversioned.APIResourceList, err error) {
+	url := url.URL{}
+	if len(groupVersion) == 0 {
+		return nil, fmt.Errorf("groupVersion shouldn't be empty")
+	}
+	if len(d.LegacyPrefix) > 0 && groupVersion == "v1" {
+		url.Path = d.LegacyPrefix + "/" + groupVersion
+	} else {
+		url.Path = "/apis/" + groupVersion
+	}
+	resources = &unversioned.APIResourceList{}
+	err = d.Get().AbsPath(url.String()).Do().Into(resources)
+	if err != nil {
+		// ignore 403 or 404 error to be compatible with an v1.0 server.
+		if groupVersion == "v1" && (errors.IsNotFound(err) || errors.IsForbidden(err)) {
+			return resources, nil
+		} else {
+			return nil, err
+		}
+	}
+	return resources, nil
+}
+
+// ServerResources returns the supported resources for all groups and versions.
+func (d *DiscoveryClient) ServerResources() (map[string]*unversioned.APIResourceList, error) {
+	apiGroups, err := d.ServerGroups()
+	if err != nil {
+		return nil, err
+	}
+	groupVersions := unversioned.ExtractGroupVersions(apiGroups)
+	result := map[string]*unversioned.APIResourceList{}
+	for _, groupVersion := range groupVersions {
+		resources, err := d.ServerResourcesForGroupVersion(groupVersion)
+		if err != nil {
+			return nil, err
+		}
+		result[groupVersion] = resources
+	}
+	return result, nil
+}
+
+// serverPreferredResources returns the supported resources with the version preferred by the
+// server. If namespaced is true, only namespaced resources will be returned.
+func (d *DiscoveryClient) serverPreferredResources(namespaced bool) ([]unversioned.GroupVersionResource, error) {
+	results := []unversioned.GroupVersionResource{}
+	serverGroupList, err := d.ServerGroups()
+	if err != nil {
+		return results, err
+	}
+
+	allErrs := []error{}
+	for _, apiGroup := range serverGroupList.Groups {
+		preferredVersion := apiGroup.PreferredVersion
+		apiResourceList, err := d.ServerResourcesForGroupVersion(preferredVersion.GroupVersion)
+		if err != nil {
+			allErrs = append(allErrs, err)
+			continue
+		}
+		groupVersion := unversioned.GroupVersion{Group: apiGroup.Name, Version: preferredVersion.Version}
+		for _, apiResource := range apiResourceList.APIResources {
+			// ignore the root scoped resources if "namespaced" is true.
+			if namespaced && !apiResource.Namespaced {
+				continue
+			}
+			if strings.Contains(apiResource.Name, "/") {
+				continue
+			}
+			results = append(results, groupVersion.WithResource(apiResource.Name))
+		}
+	}
+	return results, utilerrors.NewAggregate(allErrs)
+}
+
+// ServerPreferredResources returns the supported resources with the version preferred by the
+// server.
+func (d *DiscoveryClient) ServerPreferredResources() ([]unversioned.GroupVersionResource, error) {
+	return d.serverPreferredResources(false)
+}
+
+// ServerPreferredNamespacedResources returns the supported namespaced resources with the
+// version preferred by the server.
+func (d *DiscoveryClient) ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error) {
+	return d.serverPreferredResources(true)
+}
+
+// ServerVersion retrieves and parses the server's version (git version).
+func (d *DiscoveryClient) ServerVersion() (*version.Info, error) {
+	body, err := d.Get().AbsPath("/version").Do().Raw()
+	if err != nil {
+		return nil, err
+	}
+	var info version.Info
+	err = json.Unmarshal(body, &info)
+	if err != nil {
+		return nil, fmt.Errorf("got '%s': %v", string(body), err)
+	}
+	return &info, nil
+}
+
+// SwaggerSchema retrieves and parses the swagger API schema the server supports.
+func (d *DiscoveryClient) SwaggerSchema(version unversioned.GroupVersion) (*swagger.ApiDeclaration, error) {
+	if version.IsEmpty() {
+		return nil, fmt.Errorf("groupVersion cannot be empty")
+	}
+
+	groupList, err := d.ServerGroups()
+	if err != nil {
+		return nil, err
+	}
+	groupVersions := unversioned.ExtractGroupVersions(groupList)
+	// This check also takes care the case that kubectl is newer than the running endpoint
+	if stringDoesntExistIn(version.String(), groupVersions) {
+		return nil, fmt.Errorf("API version: %v is not supported by the server. Use one of: %v", version, groupVersions)
+	}
+	var path string
+	if len(d.LegacyPrefix) > 0 && version == v1.SchemeGroupVersion {
+		path = "/swaggerapi" + d.LegacyPrefix + "/" + version.Version
+	} else {
+		path = "/swaggerapi/apis/" + version.Group + "/" + version.Version
+	}
+
+	body, err := d.Get().AbsPath(path).Do().Raw()
+	if err != nil {
+		return nil, err
+	}
+	var schema swagger.ApiDeclaration
+	err = json.Unmarshal(body, &schema)
+	if err != nil {
+		return nil, fmt.Errorf("got '%s': %v", string(body), err)
+	}
+	return &schema, nil
+}
+
+func setDiscoveryDefaults(config *rest.Config) error {
+	config.APIPath = ""
+	config.GroupVersion = nil
+	codec := runtime.NoopEncoder{Decoder: api.Codecs.UniversalDecoder()}
+	config.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(
+		runtime.SerializerInfo{Serializer: codec},
+		runtime.StreamSerializerInfo{},
+	)
+	if len(config.UserAgent) == 0 {
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+	return nil
+}
+
+// NewDiscoveryClientForConfig creates a new DiscoveryClient for the given config. This client
+// can be used to discover supported resources in the API server.
+func NewDiscoveryClientForConfig(c *rest.Config) (*DiscoveryClient, error) {
+	config := *c
+	if err := setDiscoveryDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.UnversionedRESTClientFor(&config)
+	return &DiscoveryClient{RESTClient: client, LegacyPrefix: "/api"}, err
+}
+
+// NewDiscoveryClientForConfig creates a new DiscoveryClient for the given config. If
+// there is an error, it panics.
+func NewDiscoveryClientForConfigOrDie(c *rest.Config) *DiscoveryClient {
+	client, err := NewDiscoveryClientForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+
+}
+
+// New creates a new DiscoveryClient for the given RESTClient.
+func NewDiscoveryClient(c *rest.RESTClient) *DiscoveryClient {
+	return &DiscoveryClient{RESTClient: c, LegacyPrefix: "/api"}
+}
+
+func stringDoesntExistIn(str string, slice []string) bool {
+	for _, s := range slice {
+		if s == str {
+			return false
+		}
+	}
+	return true
+}

staging/src/k8s.io/client-go/1.4/discovery/fake/discovery.go

@@ -0,0 +1,82 @@
+/*
+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 fake
+
+import (
+	"github.com/emicklei/go-restful/swagger"
+	"k8s.io/client-go/1.4/pkg/api/unversioned"
+	"k8s.io/client-go/1.4/pkg/api/v1"
+	"k8s.io/client-go/1.4/pkg/version"
+	"k8s.io/client-go/1.4/testing"
+)
+
+type FakeDiscovery struct {
+	*testing.Fake
+}
+
+func (c *FakeDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*unversioned.APIResourceList, error) {
+	action := testing.ActionImpl{
+		Verb:     "get",
+		Resource: unversioned.GroupVersionResource{Resource: "resource"},
+	}
+	c.Invokes(action, nil)
+	return c.Resources[groupVersion], nil
+}
+
+func (c *FakeDiscovery) ServerResources() (map[string]*unversioned.APIResourceList, error) {
+	action := testing.ActionImpl{
+		Verb:     "get",
+		Resource: unversioned.GroupVersionResource{Resource: "resource"},
+	}
+	c.Invokes(action, nil)
+	return c.Resources, nil
+}
+
+func (c *FakeDiscovery) ServerPreferredResources() ([]unversioned.GroupVersionResource, error) {
+	return nil, nil
+}
+
+func (c *FakeDiscovery) ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error) {
+	return nil, nil
+}
+
+func (c *FakeDiscovery) ServerGroups() (*unversioned.APIGroupList, error) {
+	return nil, nil
+}
+
+func (c *FakeDiscovery) ServerVersion() (*version.Info, error) {
+	action := testing.ActionImpl{}
+	action.Verb = "get"
+	action.Resource = unversioned.GroupVersionResource{Resource: "version"}
+
+	c.Invokes(action, nil)
+	versionInfo := version.Get()
+	return &versionInfo, nil
+}
+
+func (c *FakeDiscovery) SwaggerSchema(version unversioned.GroupVersion) (*swagger.ApiDeclaration, error) {
+	action := testing.ActionImpl{}
+	action.Verb = "get"
+	if version == v1.SchemeGroupVersion {
+		action.Resource = unversioned.GroupVersionResource{Resource: "/swaggerapi/api/" + version.Version}
+	} else {
+		action.Resource = unversioned.GroupVersionResource{Resource: "/swaggerapi/apis/" + version.Group + "/" + version.Version}
+	}
+
+	c.Invokes(action, nil)
+	return &swagger.ApiDeclaration{}, nil
+}

staging/src/k8s.io/client-go/1.4/discovery/restmapper.go

@@ -0,0 +1,261 @@
+/*
+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 discovery
+
+import (
+	"sync"
+
+	"k8s.io/client-go/1.4/pkg/api/errors"
+	"k8s.io/client-go/1.4/pkg/api/meta"
+	"k8s.io/client-go/1.4/pkg/api/unversioned"
+)
+
+// APIGroupResources is an API group with a mapping of versions to
+// resources.
+type APIGroupResources struct {
+	Group unversioned.APIGroup
+	// A mapping of version string to a slice of APIResources for
+	// that version.
+	VersionedResources map[string][]unversioned.APIResource
+}
+
+// NewRESTMapper returns a PriorityRESTMapper based on the discovered
+// groups and resourced passed in.
+func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.VersionInterfacesFunc) meta.RESTMapper {
+	unionMapper := meta.MultiRESTMapper{}
+
+	var groupPriority []string
+	var resourcePriority []unversioned.GroupVersionResource
+	var kindPriority []unversioned.GroupVersionKind
+
+	for _, group := range groupResources {
+		groupPriority = append(groupPriority, group.Group.Name)
+
+		if len(group.Group.PreferredVersion.Version) != 0 {
+			preffered := group.Group.PreferredVersion.Version
+			if _, ok := group.VersionedResources[preffered]; ok {
+				resourcePriority = append(resourcePriority, unversioned.GroupVersionResource{
+					Group:    group.Group.Name,
+					Version:  group.Group.PreferredVersion.Version,
+					Resource: meta.AnyResource,
+				})
+
+				kindPriority = append(kindPriority, unversioned.GroupVersionKind{
+					Group:   group.Group.Name,
+					Version: group.Group.PreferredVersion.Version,
+					Kind:    meta.AnyKind,
+				})
+			}
+		}
+
+		for _, discoveryVersion := range group.Group.Versions {
+			resources, ok := group.VersionedResources[discoveryVersion.Version]
+			if !ok {
+				continue
+			}
+
+			gv := unversioned.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
+			versionMapper := meta.NewDefaultRESTMapper([]unversioned.GroupVersion{gv}, versionInterfaces)
+
+			for _, resource := range resources {
+				scope := meta.RESTScopeNamespace
+				if !resource.Namespaced {
+					scope = meta.RESTScopeRoot
+				}
+				versionMapper.Add(gv.WithKind(resource.Kind), scope)
+				// TODO only do this if it supports listing
+				versionMapper.Add(gv.WithKind(resource.Kind+"List"), scope)
+			}
+			unionMapper = append(unionMapper, versionMapper)
+		}
+	}
+
+	for _, group := range groupPriority {
+		resourcePriority = append(resourcePriority, unversioned.GroupVersionResource{
+			Group:    group,
+			Version:  meta.AnyVersion,
+			Resource: meta.AnyResource,
+		})
+		kindPriority = append(kindPriority, unversioned.GroupVersionKind{
+			Group:   group,
+			Version: meta.AnyVersion,
+			Kind:    meta.AnyKind,
+		})
+	}
+
+	return meta.PriorityRESTMapper{
+		Delegate:         unionMapper,
+		ResourcePriority: resourcePriority,
+		KindPriority:     kindPriority,
+	}
+}
+
+// GetAPIGroupResources uses the provided discovery client to gather
+// discovery information and populate a slice of APIGroupResources.
+func GetAPIGroupResources(cl DiscoveryInterface) ([]*APIGroupResources, error) {
+	apiGroups, err := cl.ServerGroups()
+	if err != nil {
+		return nil, err
+	}
+	var result []*APIGroupResources
+	for _, group := range apiGroups.Groups {
+		groupResources := &APIGroupResources{
+			Group:              group,
+			VersionedResources: make(map[string][]unversioned.APIResource),
+		}
+		for _, version := range group.Versions {
+			resources, err := cl.ServerResourcesForGroupVersion(version.GroupVersion)
+			if err != nil {
+				if errors.IsNotFound(err) {
+					continue // ignore as this can race with deletion of 3rd party APIs
+				}
+				return nil, err
+			}
+			groupResources.VersionedResources[version.Version] = resources.APIResources
+		}
+		result = append(result, groupResources)
+	}
+	return result, nil
+}
+
+// DeferredDiscoveryRESTMapper is a RESTMapper that will defer
+// initialization of the RESTMapper until the first mapping is
+// requested.
+type DeferredDiscoveryRESTMapper struct {
+	initMu           sync.Mutex
+	delegate         meta.RESTMapper
+	cl               DiscoveryInterface
+	versionInterface meta.VersionInterfacesFunc
+}
+
+// NewDeferredDiscoveryRESTMapper returns a
+// DeferredDiscoveryRESTMapper that will lazily query the provided
+// client for discovery information to do REST mappings.
+func NewDeferredDiscoveryRESTMapper(cl DiscoveryInterface, versionInterface meta.VersionInterfacesFunc) *DeferredDiscoveryRESTMapper {
+	return &DeferredDiscoveryRESTMapper{
+		cl:               cl,
+		versionInterface: versionInterface,
+	}
+}
+
+func (d *DeferredDiscoveryRESTMapper) getDelegate() (meta.RESTMapper, error) {
+	d.initMu.Lock()
+	defer d.initMu.Unlock()
+
+	if d.delegate != nil {
+		return d.delegate, nil
+	}
+
+	groupResources, err := GetAPIGroupResources(d.cl)
+	if err != nil {
+		return nil, err
+	}
+
+	d.delegate = NewRESTMapper(groupResources, d.versionInterface)
+	return d.delegate, err
+}
+
+// Reset resets the internally cached Discovery information and will
+// cause the next mapping request to re-discover.
+func (d *DeferredDiscoveryRESTMapper) Reset() {
+	d.initMu.Lock()
+	d.delegate = nil
+	d.initMu.Unlock()
+}
+
+// KindFor takes a partial resource and returns back the single match.
+// It returns an error if there are multiple matches.
+func (d *DeferredDiscoveryRESTMapper) KindFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionKind, error) {
+	del, err := d.getDelegate()
+	if err != nil {
+		return unversioned.GroupVersionKind{}, err
+	}
+	return del.KindFor(resource)
+}
+
+// KindsFor takes a partial resource and returns back the list of
+// potential kinds in priority order.
+func (d *DeferredDiscoveryRESTMapper) KindsFor(resource unversioned.GroupVersionResource) ([]unversioned.GroupVersionKind, error) {
+	del, err := d.getDelegate()
+	if err != nil {
+		return nil, err
+	}
+	return del.KindsFor(resource)
+}
+
+// ResourceFor takes a partial resource and returns back the single
+// match. It returns an error if there are multiple matches.
+func (d *DeferredDiscoveryRESTMapper) ResourceFor(input unversioned.GroupVersionResource) (unversioned.GroupVersionResource, error) {
+	del, err := d.getDelegate()
+	if err != nil {
+		return unversioned.GroupVersionResource{}, err
+	}
+	return del.ResourceFor(input)
+}
+
+// ResourcesFor takes a partial resource and returns back the list of
+// potential resource in priority order.
+func (d *DeferredDiscoveryRESTMapper) ResourcesFor(input unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error) {
+	del, err := d.getDelegate()
+	if err != nil {
+		return nil, err
+	}
+	return del.ResourcesFor(input)
+}
+
+// RESTMapping identifies a preferred resource mapping for the
+// provided group kind.
+func (d *DeferredDiscoveryRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (*meta.RESTMapping, error) {
+	del, err := d.getDelegate()
+	if err != nil {
+		return nil, err
+	}
+	return del.RESTMapping(gk, versions...)
+}
+
+// RESTMappings returns the RESTMappings for the provided group kind
+// in a rough internal preferred order. If no kind is found, it will
+// return a NoResourceMatchError.
+func (d *DeferredDiscoveryRESTMapper) RESTMappings(gk unversioned.GroupKind) ([]*meta.RESTMapping, error) {
+	del, err := d.getDelegate()
+	if err != nil {
+		return nil, err
+	}
+	return del.RESTMappings(gk)
+}
+
+// AliasesForResource returns whether a resource has an alias or not.
+func (d *DeferredDiscoveryRESTMapper) AliasesForResource(resource string) ([]string, bool) {
+	del, err := d.getDelegate()
+	if err != nil {
+		return nil, false
+	}
+	return del.AliasesForResource(resource)
+}
+
+// ResourceSingularizer converts a resource name from plural to
+// singular (e.g., from pods to pod).
+func (d *DeferredDiscoveryRESTMapper) ResourceSingularizer(resource string) (singular string, err error) {
+	del, err := d.getDelegate()
+	if err != nil {
+		return resource, err
+	}
+	return del.ResourceSingularizer(resource)
+}
+
+// Make sure it satisfies the interface
+var _ meta.RESTMapper = &DeferredDiscoveryRESTMapper{}

staging/src/k8s.io/client-go/1.4/discovery/restmapper_test.go

@@ -0,0 +1,176 @@
+/*
+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 discovery
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/client-go/1.4/pkg/api/unversioned"
+)
+
+func TestRESTMapper(t *testing.T) {
+	resources := []*APIGroupResources{
+		{
+			Group: unversioned.APIGroup{
+				Versions: []unversioned.GroupVersionForDiscovery{
+					{Version: "v1"},
+					{Version: "v2"},
+				},
+				PreferredVersion: unversioned.GroupVersionForDiscovery{Version: "v1"},
+			},
+			VersionedResources: map[string][]unversioned.APIResource{
+				"v1": {
+					{Name: "pods", Namespaced: true, Kind: "Pod"},
+				},
+				"v2": {
+					{Name: "pods", Namespaced: true, Kind: "Pod"},
+				},
+			},
+		},
+		{
+			Group: unversioned.APIGroup{
+				Name: "extensions",
+				Versions: []unversioned.GroupVersionForDiscovery{
+					{Version: "v1beta"},
+				},
+				PreferredVersion: unversioned.GroupVersionForDiscovery{Version: "v1beta"},
+			},
+			VersionedResources: map[string][]unversioned.APIResource{
+				"v1beta": {
+					{Name: "jobs", Namespaced: true, Kind: "Job"},
+				},
+			},
+		},
+	}
+
+	restMapper := NewRESTMapper(resources, nil)
+
+	kindTCs := []struct {
+		input unversioned.GroupVersionResource
+		want  unversioned.GroupVersionKind
+	}{
+		{
+			input: unversioned.GroupVersionResource{
+				Version:  "v1",
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionKind{
+				Version: "v1",
+				Kind:    "Pod",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Version:  "v2",
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionKind{
+				Version: "v2",
+				Kind:    "Pod",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionKind{
+				Version: "v1",
+				Kind:    "Pod",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Resource: "jobs",
+			},
+			want: unversioned.GroupVersionKind{
+				Group:   "extensions",
+				Version: "v1beta",
+				Kind:    "Job",
+			},
+		},
+	}
+
+	for _, tc := range kindTCs {
+		got, err := restMapper.KindFor(tc.input)
+		if err != nil {
+			t.Errorf("KindFor(%#v) unexpected error: %v", tc.input, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("KindFor(%#v) = %#v, want %#v", tc.input, got, tc.want)
+		}
+	}
+
+	resourceTCs := []struct {
+		input unversioned.GroupVersionResource
+		want  unversioned.GroupVersionResource
+	}{
+		{
+			input: unversioned.GroupVersionResource{
+				Version:  "v1",
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionResource{
+				Version:  "v1",
+				Resource: "pods",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Version:  "v2",
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionResource{
+				Version:  "v2",
+				Resource: "pods",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Resource: "pods",
+			},
+			want: unversioned.GroupVersionResource{
+				Version:  "v1",
+				Resource: "pods",
+			},
+		},
+		{
+			input: unversioned.GroupVersionResource{
+				Resource: "jobs",
+			},
+			want: unversioned.GroupVersionResource{
+				Group:    "extensions",
+				Version:  "v1beta",
+				Resource: "jobs",
+			},
+		},
+	}
+
+	for _, tc := range resourceTCs {
+		got, err := restMapper.ResourceFor(tc.input)
+		if err != nil {
+			t.Errorf("ResourceFor(%#v) unexpected error: %v", tc.input, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("ResourceFor(%#v) = %#v, want %#v", tc.input, got, tc.want)
+		}
+	}
+}

staging/src/k8s.io/client-go/1.4/dynamic/client.go

@@ -0,0 +1,289 @@
+/*
+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 dynamic provides a client interface to arbitrary Kubernetes
+// APIs that exposes common high level operations and exposes common
+// metadata.
+package dynamic
+
+import (
+	"encoding/json"
+	"errors"
+	"io"
+	"net/url"
+	"strings"
+
+	"k8s.io/client-go/1.4/pkg/api"
+	"k8s.io/client-go/1.4/pkg/api/unversioned"
+	"k8s.io/client-go/1.4/pkg/api/v1"
+	"k8s.io/client-go/1.4/pkg/conversion/queryparams"
+	"k8s.io/client-go/1.4/pkg/runtime"
+	"k8s.io/client-go/1.4/pkg/runtime/serializer"
+	"k8s.io/client-go/1.4/pkg/watch"
+	"k8s.io/client-go/1.4/rest"
+)
+
+// Client is a Kubernetes client that allows you to access metadata
+// and manipulate metadata of a Kubernetes API group.
+type Client struct {
+	cl *rest.RESTClient
+}
+
+type ClientWithParameterCodec struct {
+	client         *Client
+	parameterCodec runtime.ParameterCodec
+}
+
+// NewClient returns a new client based on the passed in config. The
+// codec is ignored, as the dynamic client uses it's own codec.
+func NewClient(conf *rest.Config) (*Client, error) {
+	// avoid changing the original config
+	confCopy := *conf
+	conf = &confCopy
+
+	codec := dynamicCodec{}
+
+	// TODO: it's questionable that this should be using anything other than unstructured schema and JSON
+	conf.ContentType = runtime.ContentTypeJSON
+	conf.AcceptContentTypes = runtime.ContentTypeJSON
+	streamingInfo, _ := api.Codecs.StreamingSerializerForMediaType("application/json;stream=watch", nil)
+	conf.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: codec}, streamingInfo)
+
+	if conf.APIPath == "" {
+		conf.APIPath = "/api"
+	}
+
+	if len(conf.UserAgent) == 0 {
+		conf.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+
+	cl, err := rest.RESTClientFor(conf)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Client{cl: cl}, nil
+}
+
+// Resource returns an API interface to the specified resource for this client's
+// group and version. If resource is not a namespaced resource, then namespace
+// is ignored.
+func (c *Client) Resource(resource *unversioned.APIResource, namespace string) *ResourceClient {
+	return &ResourceClient{
+		cl:       c.cl,
+		resource: resource,
+		ns:       namespace,
+	}
+}
+
+// ParameterCodec wraps a parameterCodec around the Client.
+func (c *Client) ParameterCodec(parameterCodec runtime.ParameterCodec) *ClientWithParameterCodec {
+	return &ClientWithParameterCodec{
+		client:         c,
+		parameterCodec: parameterCodec,
+	}
+}
+
+// Resource returns an API interface to the specified resource for this client's
+// group and version. If resource is not a namespaced resource, then namespace
+// is ignored. The ResourceClient inherits the parameter codec of c.
+func (c *ClientWithParameterCodec) Resource(resource *unversioned.APIResource, namespace string) *ResourceClient {
+	return &ResourceClient{
+		cl:             c.client.cl,
+		resource:       resource,
+		ns:             namespace,
+		parameterCodec: c.parameterCodec,
+	}
+}
+
+// ResourceClient is an API interface to a specific resource under a
+// dynamic client.
+type ResourceClient struct {
+	cl             *rest.RESTClient
+	resource       *unversioned.APIResource
+	ns             string
+	parameterCodec runtime.ParameterCodec
+}
+
+// List returns a list of objects for this resource.
+func (rc *ResourceClient) List(opts runtime.Object) (*runtime.UnstructuredList, error) {
+	result := new(runtime.UnstructuredList)
+	parameterEncoder := rc.parameterCodec
+	if parameterEncoder == nil {
+		parameterEncoder = defaultParameterEncoder
+	}
+	err := rc.cl.Get().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		VersionedParams(opts, parameterEncoder).
+		Do().
+		Into(result)
+	return result, err
+}
+
+// Get gets the resource with the specified name.
+func (rc *ResourceClient) Get(name string) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
+	err := rc.cl.Get().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		Name(name).
+		Do().
+		Into(result)
+	return result, err
+}
+
+// Delete deletes the resource with the specified name.
+func (rc *ResourceClient) Delete(name string, opts *v1.DeleteOptions) error {
+	return rc.cl.Delete().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		Name(name).
+		Body(opts).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (rc *ResourceClient) DeleteCollection(deleteOptions *v1.DeleteOptions, listOptions runtime.Object) error {
+	parameterEncoder := rc.parameterCodec
+	if parameterEncoder == nil {
+		parameterEncoder = defaultParameterEncoder
+	}
+	return rc.cl.Delete().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		VersionedParams(listOptions, parameterEncoder).
+		Body(deleteOptions).
+		Do().
+		Error()
+}
+
+// Create creates the provided resource.
+func (rc *ResourceClient) Create(obj *runtime.Unstructured) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
+	err := rc.cl.Post().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		Body(obj).
+		Do().
+		Into(result)
+	return result, err
+}
+
+// Update updates the provided resource.
+func (rc *ResourceClient) Update(obj *runtime.Unstructured) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
+	if len(obj.GetName()) == 0 {
+		return result, errors.New("object missing name")
+	}
+	err := rc.cl.Put().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		Name(obj.GetName()).
+		Body(obj).
+		Do().
+		Into(result)
+	return result, err
+}
+
+// Watch returns a watch.Interface that watches the resource.
+func (rc *ResourceClient) Watch(opts runtime.Object) (watch.Interface, error) {
+	parameterEncoder := rc.parameterCodec
+	if parameterEncoder == nil {
+		parameterEncoder = defaultParameterEncoder
+	}
+	return rc.cl.Get().
+		Prefix("watch").
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		VersionedParams(opts, parameterEncoder).
+		Watch()
+}
+
+func (rc *ResourceClient) Patch(name string, pt api.PatchType, data []byte) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
+	err := rc.cl.Patch(pt).
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return result, err
+}
+
+// dynamicCodec is a codec that wraps the standard unstructured codec
+// with special handling for Status objects.
+type dynamicCodec struct{}
+
+func (dynamicCodec) Decode(data []byte, gvk *unversioned.GroupVersionKind, obj runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error) {
+	obj, gvk, err := runtime.UnstructuredJSONScheme.Decode(data, gvk, obj)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if _, ok := obj.(*unversioned.Status); !ok && strings.ToLower(gvk.Kind) == "status" {
+		obj = &unversioned.Status{}
+		err := json.Unmarshal(data, obj)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	return obj, gvk, nil
+}
+
+func (dynamicCodec) Encode(obj runtime.Object, w io.Writer) error {
+	return runtime.UnstructuredJSONScheme.Encode(obj, w)
+}
+
+// paramaterCodec is a codec converts an API object to query
+// parameters without trying to convert to the target version.
+type parameterCodec struct{}
+
+func (parameterCodec) EncodeParameters(obj runtime.Object, to unversioned.GroupVersion) (url.Values, error) {
+	return queryparams.Convert(obj)
+}
+
+func (parameterCodec) DecodeParameters(parameters url.Values, from unversioned.GroupVersion, into runtime.Object) error {
+	return errors.New("DecodeParameters not implemented on dynamic parameterCodec")
+}
+
+var defaultParameterEncoder runtime.ParameterCodec = parameterCodec{}
+
+type versionedParameterEncoderWithV1Fallback struct{}
+
+func (versionedParameterEncoderWithV1Fallback) EncodeParameters(obj runtime.Object, to unversioned.GroupVersion) (url.Values, error) {
+	ret, err := api.ParameterCodec.EncodeParameters(obj, to)
+	if err != nil && runtime.IsNotRegisteredError(err) {
+		// fallback to v1
+		return api.ParameterCodec.EncodeParameters(obj, v1.SchemeGroupVersion)
+	}
+	return ret, err
+}
+
+func (versionedParameterEncoderWithV1Fallback) DecodeParameters(parameters url.Values, from unversioned.GroupVersion, into runtime.Object) error {
+	return errors.New("DecodeParameters not implemented on versionedParameterEncoderWithV1Fallback")
+}
+
+// VersionedParameterEncoderWithV1Fallback is useful for encoding query
+// parameters for thirdparty resources. It tries to convert object to the
+// specified version before converting it to query parameters, and falls back to
+// converting to v1 if the object is not registered in the specified version.
+// For the record, currently API server always treats query parameters sent to a
+// thirdparty resource endpoint as v1.
+var VersionedParameterEncoderWithV1Fallback runtime.ParameterCodec = versionedParameterEncoderWithV1Fallback{}

staging/src/k8s.io/client-go/1.4/dynamic/client_pool.go

@@ -0,0 +1,86 @@
+/*
+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 dynamic
+
+import (
+	"sync"
+
+	"k8s.io/client-go/1.4/pkg/api/unversioned"
+	"k8s.io/client-go/1.4/rest"
+)
+
+// ClientPool manages a pool of dynamic clients.
+type ClientPool interface {
+	// ClientForGroupVersion returns a client configured for the specified groupVersion.
+	ClientForGroupVersion(groupVersion unversioned.GroupVersion) (*Client, error)
+}
+
+// APIPathResolverFunc knows how to convert a groupVersion to its API path.
+type APIPathResolverFunc func(groupVersion unversioned.GroupVersion) string
+
+// LegacyAPIPathResolverFunc can resolve paths properly with the legacy API.
+func LegacyAPIPathResolverFunc(groupVersion unversioned.GroupVersion) string {
+	if len(groupVersion.Group) == 0 {
+		return "/api"
+	}
+	return "/apis"
+}
+
+// clientPoolImpl implements Factory
+type clientPoolImpl struct {
+	lock                sync.RWMutex
+	config              *rest.Config
+	clients             map[unversioned.GroupVersion]*Client
+	apiPathResolverFunc APIPathResolverFunc
+}
+
+// NewClientPool returns a ClientPool from the specified config
+func NewClientPool(config *rest.Config, apiPathResolverFunc APIPathResolverFunc) ClientPool {
+	confCopy := *config
+	return &clientPoolImpl{
+		config:              &confCopy,
+		clients:             map[unversioned.GroupVersion]*Client{},
+		apiPathResolverFunc: apiPathResolverFunc,
+	}
+}
+
+// ClientForGroupVersion returns a client for the specified groupVersion, creates one if none exists
+func (c *clientPoolImpl) ClientForGroupVersion(groupVersion unversioned.GroupVersion) (*Client, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	// do we have a client already configured?
+	if existingClient, found := c.clients[groupVersion]; found {
+		return existingClient, nil
+	}
+
+	// avoid changing the original config
+	confCopy := *c.config
+	conf := &confCopy
+
+	// we need to set the api path based on group version, if no group, default to legacy path
+	conf.APIPath = c.apiPathResolverFunc(groupVersion)
+
+	// we need to make a client
+	conf.GroupVersion = &groupVersion
+	dynamicClient, err := NewClient(conf)
+	if err != nil {
+		return nil, err
+	}
+	c.clients[groupVersion] = dynamicClient
+	return dynamicClient, nil
+}

staging/src/k8s.io/client-go/1.4/dynamic/client_test.go

@@ -0,0 +1,550 @@
+/*
+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 dynamic
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+
+	"k8s.io/client-go/1.4/pkg/api"
+	"k8s.io/client-go/1.4/pkg/api/unversioned"
+	"k8s.io/client-go/1.4/pkg/api/v1"
+	"k8s.io/client-go/1.4/pkg/runtime"
+	"k8s.io/client-go/1.4/pkg/runtime/serializer/streaming"
+	"k8s.io/client-go/1.4/pkg/watch"
+	"k8s.io/client-go/1.4/pkg/watch/versioned"
+	"k8s.io/client-go/1.4/rest"
+)
+
+func getJSON(version, kind, name string) []byte {
+	return []byte(fmt.Sprintf(`{"apiVersion": %q, "kind": %q, "metadata": {"name": %q}}`, version, kind, name))
+}
+
+func getListJSON(version, kind string, items ...[]byte) []byte {
+	json := fmt.Sprintf(`{"apiVersion": %q, "kind": %q, "items": [%s]}`,
+		version, kind, bytes.Join(items, []byte(",")))
+	return []byte(json)
+}
+
+func getObject(version, kind, name string) *runtime.Unstructured {
+	return &runtime.Unstructured{
+		Object: map[string]interface{}{
+			"apiVersion": version,
+			"kind":       kind,
+			"metadata": map[string]interface{}{
+				"name": name,
+			},
+		},
+	}
+}
+
+func getClientServer(gv *unversioned.GroupVersion, h func(http.ResponseWriter, *http.Request)) (*Client, *httptest.Server, error) {
+	srv := httptest.NewServer(http.HandlerFunc(h))
+	cl, err := NewClient(&rest.Config{
+		Host:          srv.URL,
+		ContentConfig: rest.ContentConfig{GroupVersion: gv},
+	})
+	if err != nil {
+		srv.Close()
+		return nil, nil, err
+	}
+	return cl, srv, nil
+}
+
+func TestList(t *testing.T) {
+	tcs := []struct {
+		name      string
+		namespace string
+		path      string
+		resp      []byte
+		want      *runtime.UnstructuredList
+	}{
+		{
+			name: "normal_list",
+			path: "/api/gtest/vtest/rtest",
+			resp: getListJSON("vTest", "rTestList",
+				getJSON("vTest", "rTest", "item1"),
+				getJSON("vTest", "rTest", "item2")),
+			want: &runtime.UnstructuredList{
+				Object: map[string]interface{}{
+					"apiVersion": "vTest",
+					"kind":       "rTestList",
+				},
+				Items: []*runtime.Unstructured{
+					getObject("vTest", "rTest", "item1"),
+					getObject("vTest", "rTest", "item2"),
+				},
+			},
+		},
+		{
+			name:      "namespaced_list",
+			namespace: "nstest",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest",
+			resp: getListJSON("vTest", "rTestList",
+				getJSON("vTest", "rTest", "item1"),
+				getJSON("vTest", "rTest", "item2")),
+			want: &runtime.UnstructuredList{
+				Object: map[string]interface{}{
+					"apiVersion": "vTest",
+					"kind":       "rTestList",
+				},
+				Items: []*runtime.Unstructured{
+					getObject("vTest", "rTest", "item1"),
+					getObject("vTest", "rTest", "item2"),
+				},
+			},
+		},
+	}
+	for _, tc := range tcs {
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "GET" {
+				t.Errorf("List(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("List(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			w.Write(tc.resp)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).List(&v1.ListOptions{})
+		if err != nil {
+			t.Errorf("unexpected error when listing %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("List(%q) want: %v\ngot: %v", tc.name, tc.want, got)
+		}
+	}
+}
+
+func TestGet(t *testing.T) {
+	tcs := []struct {
+		namespace string
+		name      string
+		path      string
+		resp      []byte
+		want      *runtime.Unstructured
+	}{
+		{
+			name: "normal_get",
+			path: "/api/gtest/vtest/rtest/normal_get",
+			resp: getJSON("vTest", "rTest", "normal_get"),
+			want: getObject("vTest", "rTest", "normal_get"),
+		},
+		{
+			namespace: "nstest",
+			name:      "namespaced_get",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_get",
+			resp:      getJSON("vTest", "rTest", "namespaced_get"),
+			want:      getObject("vTest", "rTest", "namespaced_get"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "GET" {
+				t.Errorf("Get(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Get(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			w.Write(tc.resp)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Get(tc.name)
+		if err != nil {
+			t.Errorf("unexpected error when getting %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("Get(%q) want: %v\ngot: %v", tc.name, tc.want, got)
+		}
+	}
+}
+
+func TestDelete(t *testing.T) {
+	statusOK := &unversioned.Status{
+		TypeMeta: unversioned.TypeMeta{Kind: "Status"},
+		Status:   unversioned.StatusSuccess,
+	}
+	tcs := []struct {
+		namespace string
+		name      string
+		path      string
+	}{
+		{
+			name: "normal_delete",
+			path: "/api/gtest/vtest/rtest/normal_delete",
+		},
+		{
+			namespace: "nstest",
+			name:      "namespaced_delete",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_delete",
+		},
+	}
+	for _, tc := range tcs {
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "DELETE" {
+				t.Errorf("Delete(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Delete(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			runtime.UnstructuredJSONScheme.Encode(statusOK, w)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		err = cl.Resource(resource, tc.namespace).Delete(tc.name, nil)
+		if err != nil {
+			t.Errorf("unexpected error when deleting %q: %v", tc.name, err)
+			continue
+		}
+	}
+}
+
+func TestDeleteCollection(t *testing.T) {
+	statusOK := &unversioned.Status{
+		TypeMeta: unversioned.TypeMeta{Kind: "Status"},
+		Status:   unversioned.StatusSuccess,
+	}
+	tcs := []struct {
+		namespace string
+		name      string
+		path      string
+	}{
+		{
+			name: "normal_delete_collection",
+			path: "/api/gtest/vtest/rtest",
+		},
+		{
+			namespace: "nstest",
+			name:      "namespaced_delete_collection",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest",
+		},
+	}
+	for _, tc := range tcs {
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "DELETE" {
+				t.Errorf("DeleteCollection(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("DeleteCollection(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			runtime.UnstructuredJSONScheme.Encode(statusOK, w)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		err = cl.Resource(resource, tc.namespace).DeleteCollection(nil, &v1.ListOptions{})
+		if err != nil {
+			t.Errorf("unexpected error when deleting collection %q: %v", tc.name, err)
+			continue
+		}
+	}
+}
+
+func TestCreate(t *testing.T) {
+	tcs := []struct {
+		name      string
+		namespace string
+		obj       *runtime.Unstructured
+		path      string
+	}{
+		{
+			name: "normal_create",
+			path: "/api/gtest/vtest/rtest",
+			obj:  getObject("vTest", "rTest", "normal_create"),
+		},
+		{
+			name:      "namespaced_create",
+			namespace: "nstest",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest",
+			obj:       getObject("vTest", "rTest", "namespaced_create"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "POST" {
+				t.Errorf("Create(%q) got HTTP method %s. wanted POST", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Create(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			data, err := ioutil.ReadAll(r.Body)
+			if err != nil {
+				t.Errorf("Create(%q) unexpected error reading body: %v", tc.name, err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			w.Write(data)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Create(tc.obj)
+		if err != nil {
+			t.Errorf("unexpected error when creating %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.obj) {
+			t.Errorf("Create(%q) want: %v\ngot: %v", tc.name, tc.obj, got)
+		}
+	}
+}
+
+func TestUpdate(t *testing.T) {
+	tcs := []struct {
+		name      string
+		namespace string
+		obj       *runtime.Unstructured
+		path      string
+	}{
+		{
+			name: "normal_update",
+			path: "/api/gtest/vtest/rtest/normal_update",
+			obj:  getObject("vTest", "rTest", "normal_update"),
+		},
+		{
+			name:      "namespaced_update",
+			namespace: "nstest",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_update",
+			obj:       getObject("vTest", "rTest", "namespaced_update"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "PUT" {
+				t.Errorf("Update(%q) got HTTP method %s. wanted PUT", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Update(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			data, err := ioutil.ReadAll(r.Body)
+			if err != nil {
+				t.Errorf("Update(%q) unexpected error reading body: %v", tc.name, err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			w.Write(data)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Update(tc.obj)
+		if err != nil {
+			t.Errorf("unexpected error when updating %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.obj) {
+			t.Errorf("Update(%q) want: %v\ngot: %v", tc.name, tc.obj, got)
+		}
+	}
+}
+
+func TestWatch(t *testing.T) {
+	tcs := []struct {
+		name      string
+		namespace string
+		events    []watch.Event
+		path      string
+	}{
+		{
+			name: "normal_watch",
+			path: "/api/gtest/vtest/watch/rtest",
+			events: []watch.Event{
+				{Type: watch.Added, Object: getObject("vTest", "rTest", "normal_watch")},
+				{Type: watch.Modified, Object: getObject("vTest", "rTest", "normal_watch")},
+				{Type: watch.Deleted, Object: getObject("vTest", "rTest", "normal_watch")},
+			},
+		},
+		{
+			name:      "namespaced_watch",
+			namespace: "nstest",
+			path:      "/api/gtest/vtest/watch/namespaces/nstest/rtest",
+			events: []watch.Event{
+				{Type: watch.Added, Object: getObject("vTest", "rTest", "namespaced_watch")},
+				{Type: watch.Modified, Object: getObject("vTest", "rTest", "namespaced_watch")},
+				{Type: watch.Deleted, Object: getObject("vTest", "rTest", "namespaced_watch")},
+			},
+		},
+	}
+	for _, tc := range tcs {
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "GET" {
+				t.Errorf("Watch(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Watch(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			enc := versioned.NewEncoder(streaming.NewEncoder(w, dynamicCodec{}), dynamicCodec{})
+			for _, e := range tc.events {
+				enc.Encode(&e)
+			}
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		watcher, err := cl.Resource(resource, tc.namespace).Watch(&v1.ListOptions{})
+		if err != nil {
+			t.Errorf("unexpected error when watching %q: %v", tc.name, err)
+			continue
+		}
+
+		for _, want := range tc.events {
+			got := <-watcher.ResultChan()
+			if !reflect.DeepEqual(got, want) {
+				t.Errorf("Watch(%q) want: %v\ngot: %v", tc.name, want, got)
+			}
+		}
+	}
+}
+
+func TestPatch(t *testing.T) {
+	tcs := []struct {
+		name      string
+		namespace string
+		patch     []byte
+		want      *runtime.Unstructured
+		path      string
+	}{
+		{
+			name:  "normal_patch",
+			path:  "/api/gtest/vtest/rtest/normal_patch",
+			patch: getJSON("vTest", "rTest", "normal_patch"),
+			want:  getObject("vTest", "rTest", "normal_patch"),
+		},
+		{
+			name:      "namespaced_patch",
+			namespace: "nstest",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_patch",
+			patch:     getJSON("vTest", "rTest", "namespaced_patch"),
+			want:      getObject("vTest", "rTest", "namespaced_patch"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "PATCH" {
+				t.Errorf("Patch(%q) got HTTP method %s. wanted PATCH", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Patch(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			content := r.Header.Get("Content-Type")
+			if content != string(api.StrategicMergePatchType) {
+				t.Errorf("Patch(%q) got Content-Type %s. wanted %s", tc.name, content, api.StrategicMergePatchType)
+			}
+
+			data, err := ioutil.ReadAll(r.Body)
+			if err != nil {
+				t.Errorf("Patch(%q) unexpected error reading body: %v", tc.name, err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			w.Write(data)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Patch(tc.name, api.StrategicMergePatchType, tc.patch)
+		if err != nil {
+			t.Errorf("unexpected error when patching %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("Patch(%q) want: %v\ngot: %v", tc.name, tc.want, got)
+		}
+	}
+}

staging/src/k8s.io/client-go/1.4/dynamic/dynamic_util.go

@@ -0,0 +1,94 @@
+/*
+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 dynamic
+
+import (
+	"fmt"
+
+	"k8s.io/client-go/1.4/pkg/api/meta"
+	"k8s.io/client-go/1.4/pkg/api/unversioned"
+	"k8s.io/client-go/1.4/pkg/runtime"
+)
+
+// VersionInterfaces provides an object converter and metadata
+// accessor appropriate for use with unstructured objects.
+func VersionInterfaces(unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
+	return &meta.VersionInterfaces{
+		ObjectConvertor:  &runtime.UnstructuredObjectConverter{},
+		MetadataAccessor: meta.NewAccessor(),
+	}, nil
+}
+
+// NewDiscoveryRESTMapper returns a RESTMapper based on discovery information.
+func NewDiscoveryRESTMapper(resources []*unversioned.APIResourceList, versionFunc meta.VersionInterfacesFunc) (*meta.DefaultRESTMapper, error) {
+	rm := meta.NewDefaultRESTMapper(nil, versionFunc)
+	for _, resourceList := range resources {
+		gv, err := unversioned.ParseGroupVersion(resourceList.GroupVersion)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, resource := range resourceList.APIResources {
+			gvk := gv.WithKind(resource.Kind)
+			scope := meta.RESTScopeRoot
+			if resource.Namespaced {
+				scope = meta.RESTScopeNamespace
+			}
+			rm.Add(gvk, scope)
+		}
+	}
+	return rm, nil
+}
+
+// ObjectTyper provides an ObjectTyper implementation for
+// runtime.Unstructured object based on discovery information.
+type ObjectTyper struct {
+	registered map[unversioned.GroupVersionKind]bool
+}
+
+// NewObjectTyper constructs an ObjectTyper from discovery information.
+func NewObjectTyper(resources []*unversioned.APIResourceList) (runtime.ObjectTyper, error) {
+	ot := &ObjectTyper{registered: make(map[unversioned.GroupVersionKind]bool)}
+	for _, resourceList := range resources {
+		gv, err := unversioned.ParseGroupVersion(resourceList.GroupVersion)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, resource := range resourceList.APIResources {
+			ot.registered[gv.WithKind(resource.Kind)] = true
+		}
+	}
+	return ot, nil
+}
+
+// ObjectKinds returns a slice of one element with the
+// group,version,kind of the provided object, or an error if the
+// object is not *runtime.Unstructured or has no group,version,kind
+// information.
+func (ot *ObjectTyper) ObjectKinds(obj runtime.Object) ([]unversioned.GroupVersionKind, bool, error) {
+	if _, ok := obj.(*runtime.Unstructured); !ok {
+		return nil, false, fmt.Errorf("type %T is invalid for dynamic object typer", obj)
+	}
+	return []unversioned.GroupVersionKind{obj.GetObjectKind().GroupVersionKind()}, false, nil
+}
+
+// Recognizes returns true if the provided group,version,kind was in
+// the discovery information.
+func (ot *ObjectTyper) Recognizes(gvk unversioned.GroupVersionKind) bool {
+	return ot.registered[gvk]
+}

staging/src/k8s.io/client-go/1.4/dynamic/dynamic_util_test.go

@@ -0,0 +1,78 @@
+/*
+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 dynamic
+
+import (
+	"testing"
+
+	"k8s.io/client-go/1.4/pkg/api/unversioned"
+)
+
+func TestDiscoveryRESTMapper(t *testing.T) {
+	resources := []*unversioned.APIResourceList{
+		{
+			GroupVersion: "test/beta1",
+			APIResources: []unversioned.APIResource{
+				{
+					Name:       "test_kinds",
+					Namespaced: true,
+					Kind:       "test_kind",
+				},
+			},
+		},
+	}
+
+	gvk := unversioned.GroupVersionKind{
+		Group:   "test",
+		Version: "beta1",
+		Kind:    "test_kind",
+	}
+
+	mapper, err := NewDiscoveryRESTMapper(resources, VersionInterfaces)
+	if err != nil {
+		t.Fatalf("unexpected error creating mapper: %s", err)
+	}
+
+	for _, res := range []unversioned.GroupVersionResource{
+		{
+			Group:    "test",
+			Version:  "beta1",
+			Resource: "test_kinds",
+		},
+		{
+			Version:  "beta1",
+			Resource: "test_kinds",
+		},
+		{
+			Group:    "test",
+			Resource: "test_kinds",
+		},
+		{
+			Resource: "test_kinds",
+		},
+	} {
+		got, err := mapper.KindFor(res)
+		if err != nil {
+			t.Errorf("KindFor(%#v) unexpected error: %s", res, err)
+			continue
+		}
+
+		if got != gvk {
+			t.Errorf("KindFor(%#v) = %#v; want %#v", res, got, gvk)
+		}
+	}
+}

staging/src/k8s.io/client-go/1.4/kubernetes/clientset.go

@@ -0,0 +1,158 @@
+/*
+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 kubernetes
+
+import (
+	"github.com/golang/glog"
+	discovery "k8s.io/client-go/1.4/discovery"
+	v1beta1authorization "k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1"
+	v1autoscaling "k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1"
+	v1batch "k8s.io/client-go/1.4/kubernetes/typed/batch/v1"
+	v1core "k8s.io/client-go/1.4/kubernetes/typed/core/v1"
+	v1beta1extensions "k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1"
+	"k8s.io/client-go/1.4/pkg/util/flowcontrol"
+	rest "k8s.io/client-go/1.4/rest"
+)
+
+type Interface interface {
+	Discovery() discovery.DiscoveryInterface
+	Core() v1core.CoreInterface
+	Authorization() v1beta1authorization.AuthorizationInterface
+	Autoscaling() v1autoscaling.AutoscalingInterface
+	Batch() v1batch.BatchInterface
+	Extensions() v1beta1extensions.ExtensionsInterface
+}
+
+// Clientset contains the clients for groups. Each group has exactly one
+// version included in a Clientset.
+type Clientset struct {
+	*discovery.DiscoveryClient
+	*v1core.CoreClient
+	*v1beta1authorization.AuthorizationClient
+	*v1autoscaling.AutoscalingClient
+	*v1batch.BatchClient
+	*v1beta1extensions.ExtensionsClient
+}
+
+// Core retrieves the CoreClient
+func (c *Clientset) Core() v1core.CoreInterface {
+	if c == nil {
+		return nil
+	}
+	return c.CoreClient
+}
+
+// Authorization retrieves the AuthorizationClient
+func (c *Clientset) Authorization() v1beta1authorization.AuthorizationInterface {
+	if c == nil {
+		return nil
+	}
+	return c.AuthorizationClient
+}
+
+// Autoscaling retrieves the AutoscalingClient
+func (c *Clientset) Autoscaling() v1autoscaling.AutoscalingInterface {
+	if c == nil {
+		return nil
+	}
+	return c.AutoscalingClient
+}
+
+// Batch retrieves the BatchClient
+func (c *Clientset) Batch() v1batch.BatchInterface {
+	if c == nil {
+		return nil
+	}
+	return c.BatchClient
+}
+
+// Extensions retrieves the ExtensionsClient
+func (c *Clientset) Extensions() v1beta1extensions.ExtensionsInterface {
+	if c == nil {
+		return nil
+	}
+	return c.ExtensionsClient
+}
+
+// Discovery retrieves the DiscoveryClient
+func (c *Clientset) Discovery() discovery.DiscoveryInterface {
+	return c.DiscoveryClient
+}
+
+// NewForConfig creates a new Clientset for the given config.
+func NewForConfig(c *rest.Config) (*Clientset, error) {
+	configShallowCopy := *c
+	if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {
+		configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)
+	}
+	var clientset Clientset
+	var err error
+	clientset.CoreClient, err = v1core.NewForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
+	clientset.AuthorizationClient, err = v1beta1authorization.NewForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
+	clientset.AutoscalingClient, err = v1autoscaling.NewForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
+	clientset.BatchClient, err = v1batch.NewForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
+	clientset.ExtensionsClient, err = v1beta1extensions.NewForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
+
+	clientset.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy)
+	if err != nil {
+		glog.Errorf("failed to create the DiscoveryClient: %v", err)
+		return nil, err
+	}
+	return &clientset, nil
+}
+
+// NewForConfigOrDie creates a new Clientset for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *Clientset {
+	var clientset Clientset
+	clientset.CoreClient = v1core.NewForConfigOrDie(c)
+	clientset.AuthorizationClient = v1beta1authorization.NewForConfigOrDie(c)
+	clientset.AutoscalingClient = v1autoscaling.NewForConfigOrDie(c)
+	clientset.BatchClient = v1batch.NewForConfigOrDie(c)
+	clientset.ExtensionsClient = v1beta1extensions.NewForConfigOrDie(c)
+
+	clientset.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
+	return &clientset
+}
+
+// New creates a new Clientset for the given RESTClient.
+func New(c *rest.RESTClient) *Clientset {
+	var clientset Clientset
+	clientset.CoreClient = v1core.New(c)
+	clientset.AuthorizationClient = v1beta1authorization.New(c)
+	clientset.AutoscalingClient = v1autoscaling.New(c)
+	clientset.BatchClient = v1batch.New(c)
+	clientset.ExtensionsClient = v1beta1extensions.New(c)
+
+	clientset.DiscoveryClient = discovery.NewDiscoveryClient(c)
+	return &clientset
+}

staging/src/k8s.io/client-go/1.4/kubernetes/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// This package has the automatically generated clientset.
+package kubernetes

staging/src/k8s.io/client-go/1.4/kubernetes/fake/clientset_generated.go

@@ -0,0 +1,96 @@
+/*
+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 fake
+
+import (
+	"k8s.io/client-go/1.4/discovery"
+	fakediscovery "k8s.io/client-go/1.4/discovery/fake"
+	clientset "k8s.io/client-go/1.4/kubernetes"
+	v1beta1authorization "k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1"
+	fakev1beta1authorization "k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1/fake"
+	v1autoscaling "k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1"
+	fakev1autoscaling "k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1/fake"
+	v1batch "k8s.io/client-go/1.4/kubernetes/typed/batch/v1"
+	fakev1batch "k8s.io/client-go/1.4/kubernetes/typed/batch/v1/fake"
+	v1core "k8s.io/client-go/1.4/kubernetes/typed/core/v1"
+	fakev1core "k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake"
+	v1beta1extensions "k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1"
+	fakev1beta1extensions "k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake"
+	"k8s.io/client-go/1.4/pkg/api"
+	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
+	"k8s.io/client-go/1.4/pkg/runtime"
+	"k8s.io/client-go/1.4/pkg/watch"
+	"k8s.io/client-go/1.4/testing"
+)
+
+// NewSimpleClientset returns a clientset that will respond with the provided objects.
+// It's backed by a very simple object tracker that processes creates, updates and deletions as-is,
+// without applying any validations and/or defaults. It shouldn't be considered a replacement
+// for a real clientset and is mostly useful in simple unit tests.
+func NewSimpleClientset(objects ...runtime.Object) *Clientset {
+	o := testing.NewObjectTracker(api.Scheme, api.Codecs.UniversalDecoder())
+	for _, obj := range objects {
+		if err := o.Add(obj); err != nil {
+			panic(err)
+		}
+	}
+
+	fakePtr := testing.Fake{}
+	fakePtr.AddReactor("*", "*", testing.ObjectReaction(o, registered.RESTMapper()))
+
+	fakePtr.AddWatchReactor("*", testing.DefaultWatchReactor(watch.NewFake(), nil))
+
+	return &Clientset{fakePtr}
+}
+
+// Clientset implements clientset.Interface. Meant to be embedded into a
+// struct to get a default implementation. This makes faking out just the method
+// you want to test easier.
+type Clientset struct {
+	testing.Fake
+}
+
+func (c *Clientset) Discovery() discovery.DiscoveryInterface {
+	return &fakediscovery.FakeDiscovery{Fake: &c.Fake}
+}
+
+var _ clientset.Interface = &Clientset{}
+
+// Core retrieves the CoreClient
+func (c *Clientset) Core() v1core.CoreInterface {
+	return &fakev1core.FakeCore{Fake: &c.Fake}
+}
+
+// Authorization retrieves the AuthorizationClient
+func (c *Clientset) Authorization() v1beta1authorization.AuthorizationInterface {
+	return &fakev1beta1authorization.FakeAuthorization{Fake: &c.Fake}
+}
+
+// Autoscaling retrieves the AutoscalingClient
+func (c *Clientset) Autoscaling() v1autoscaling.AutoscalingInterface {
+	return &fakev1autoscaling.FakeAutoscaling{Fake: &c.Fake}
+}
+
+// Batch retrieves the BatchClient
+func (c *Clientset) Batch() v1batch.BatchInterface {
+	return &fakev1batch.FakeBatch{Fake: &c.Fake}
+}
+
+// Extensions retrieves the ExtensionsClient
+func (c *Clientset) Extensions() v1beta1extensions.ExtensionsInterface {
+	return &fakev1beta1extensions.FakeExtensions{Fake: &c.Fake}
+}

staging/src/k8s.io/client-go/1.4/kubernetes/fake/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// This package has the automatically generated fake clientset.
+package fake

staging/src/k8s.io/client-go/1.4/kubernetes/import_known_versions.go

@@ -0,0 +1,35 @@
+/*
+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 kubernetes
+
+// These imports are the API groups the client will support.
+import (
+	"fmt"
+
+	_ "k8s.io/client-go/1.4/pkg/api/install"
+	"k8s.io/client-go/1.4/pkg/apimachinery/registered"
+	_ "k8s.io/client-go/1.4/pkg/apis/authorization/install"
+	_ "k8s.io/client-go/1.4/pkg/apis/autoscaling/install"
+	_ "k8s.io/client-go/1.4/pkg/apis/batch/install"
+	_ "k8s.io/client-go/1.4/pkg/apis/extensions/install"
+)
+
+func init() {
+	if missingVersions := registered.ValidateEnvRequestedVersions(); len(missingVersions) != 0 {
+		panic(fmt.Sprintf("KUBE_API_VERSIONS contains versions that are not installed: %q.", missingVersions))
+	}
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1/authorization_client.go

@@ -0,0 +1,96 @@
+/*
+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 v1beta1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
+	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
+	rest "k8s.io/client-go/1.4/rest"
+)
+
+type AuthorizationInterface interface {
+	GetRESTClient() *rest.RESTClient
+	SubjectAccessReviewsGetter
+}
+
+// AuthorizationClient is used to interact with features provided by the Authorization group.
+type AuthorizationClient struct {
+	*rest.RESTClient
+}
+
+func (c *AuthorizationClient) SubjectAccessReviews() SubjectAccessReviewInterface {
+	return newSubjectAccessReviews(c)
+}
+
+// NewForConfig creates a new AuthorizationClient for the given config.
+func NewForConfig(c *rest.Config) (*AuthorizationClient, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.RESTClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return &AuthorizationClient{client}, nil
+}
+
+// NewForConfigOrDie creates a new AuthorizationClient for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *AuthorizationClient {
+	client, err := NewForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+// New creates a new AuthorizationClient for the given RESTClient.
+func New(c *rest.RESTClient) *AuthorizationClient {
+	return &AuthorizationClient{c}
+}
+
+func setConfigDefaults(config *rest.Config) error {
+	// if authorization group is not registered, return an error
+	g, err := registered.Group("authorization.k8s.io")
+	if err != nil {
+		return err
+	}
+	config.APIPath = "/apis"
+	if config.UserAgent == "" {
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+	// TODO: Unconditionally set the config.Version, until we fix the config.
+	//if config.Version == "" {
+	copyGroupVersion := g.GroupVersion
+	config.GroupVersion = &copyGroupVersion
+	//}
+
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
+
+	return nil
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *AuthorizationClient) GetRESTClient() *rest.RESTClient {
+	if c == nil {
+		return nil
+	}
+	return c.RESTClient
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// This package has the automatically generated typed clients.
+package v1beta1

staging/src/k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1/fake/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// Package fake has the automatically generated clients.
+package fake

staging/src/k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1/fake/fake_authorization_client.go

@@ -0,0 +1,37 @@
+/*
+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 fake
+
+import (
+	v1beta1 "k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1"
+	rest "k8s.io/client-go/1.4/rest"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+type FakeAuthorization struct {
+	*testing.Fake
+}
+
+func (c *FakeAuthorization) SubjectAccessReviews() v1beta1.SubjectAccessReviewInterface {
+	return &FakeSubjectAccessReviews{c}
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeAuthorization) GetRESTClient() *rest.RESTClient {
+	return nil
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1/fake/fake_generated_expansion.go

@@ -0,0 +1,28 @@
+/*
+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 fake
+
+import (
+	authorizationapi "k8s.io/client-go/1.4/pkg/apis/authorization/v1beta1"
+
+	"k8s.io/client-go/1.4/testing"
+)
+
+func (c *FakeSubjectAccessReviews) Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
+	obj, err := c.Fake.Invokes(testing.NewRootCreateAction(authorizationapi.SchemeGroupVersion.WithResource("subjectaccessreviews"), sar), &authorizationapi.SubjectAccessReview{})
+	return obj.(*authorizationapi.SubjectAccessReview), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1/fake/fake_subjectaccessreview.go

@@ -0,0 +1,22 @@
+/*
+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 fake
+
+// FakeSubjectAccessReviews implements SubjectAccessReviewInterface
+type FakeSubjectAccessReviews struct {
+	Fake *FakeAuthorization
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1/generated_expansion.go

@@ -0,0 +1,36 @@
+/*
+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 v1beta1
+
+import (
+	authorizationapi "k8s.io/client-go/1.4/pkg/apis/authorization/v1beta1"
+)
+
+// The PodExpansion interface allows manually adding extra methods to the PodInterface.
+type SubjectAccessReviewExpansion interface {
+	Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error)
+}
+
+func (c *subjectAccessReviews) Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
+	result = &authorizationapi.SubjectAccessReview{}
+	err = c.client.Post().
+		Resource("subjectaccessreviews").
+		Body(sar).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/authorization/v1beta1/subjectaccessreview.go

@@ -0,0 +1,40 @@
+/*
+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 v1beta1
+
+// SubjectAccessReviewsGetter has a method to return a SubjectAccessReviewInterface.
+// A group's client should implement this interface.
+type SubjectAccessReviewsGetter interface {
+	SubjectAccessReviews() SubjectAccessReviewInterface
+}
+
+// SubjectAccessReviewInterface has methods to work with SubjectAccessReview resources.
+type SubjectAccessReviewInterface interface {
+	SubjectAccessReviewExpansion
+}
+
+// subjectAccessReviews implements SubjectAccessReviewInterface
+type subjectAccessReviews struct {
+	client *AuthorizationClient
+}
+
+// newSubjectAccessReviews returns a SubjectAccessReviews
+func newSubjectAccessReviews(c *AuthorizationClient) *subjectAccessReviews {
+	return &subjectAccessReviews{
+		client: c,
+	}
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1/autoscaling_client.go

@@ -0,0 +1,96 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
+	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
+	rest "k8s.io/client-go/1.4/rest"
+)
+
+type AutoscalingInterface interface {
+	GetRESTClient() *rest.RESTClient
+	HorizontalPodAutoscalersGetter
+}
+
+// AutoscalingClient is used to interact with features provided by the Autoscaling group.
+type AutoscalingClient struct {
+	*rest.RESTClient
+}
+
+func (c *AutoscalingClient) HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface {
+	return newHorizontalPodAutoscalers(c, namespace)
+}
+
+// NewForConfig creates a new AutoscalingClient for the given config.
+func NewForConfig(c *rest.Config) (*AutoscalingClient, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.RESTClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return &AutoscalingClient{client}, nil
+}
+
+// NewForConfigOrDie creates a new AutoscalingClient for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *AutoscalingClient {
+	client, err := NewForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+// New creates a new AutoscalingClient for the given RESTClient.
+func New(c *rest.RESTClient) *AutoscalingClient {
+	return &AutoscalingClient{c}
+}
+
+func setConfigDefaults(config *rest.Config) error {
+	// if autoscaling group is not registered, return an error
+	g, err := registered.Group("autoscaling")
+	if err != nil {
+		return err
+	}
+	config.APIPath = "/apis"
+	if config.UserAgent == "" {
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+	// TODO: Unconditionally set the config.Version, until we fix the config.
+	//if config.Version == "" {
+	copyGroupVersion := g.GroupVersion
+	config.GroupVersion = &copyGroupVersion
+	//}
+
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
+
+	return nil
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *AutoscalingClient) GetRESTClient() *rest.RESTClient {
+	if c == nil {
+		return nil
+	}
+	return c.RESTClient
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// This package has the automatically generated typed clients.
+package v1

staging/src/k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1/fake/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// Package fake has the automatically generated clients.
+package fake

staging/src/k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1/fake/fake_autoscaling_client.go

@@ -0,0 +1,37 @@
+/*
+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 fake
+
+import (
+	v1 "k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1"
+	rest "k8s.io/client-go/1.4/rest"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+type FakeAutoscaling struct {
+	*testing.Fake
+}
+
+func (c *FakeAutoscaling) HorizontalPodAutoscalers(namespace string) v1.HorizontalPodAutoscalerInterface {
+	return &FakeHorizontalPodAutoscalers{c, namespace}
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeAutoscaling) GetRESTClient() *rest.RESTClient {
+	return nil
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1/fake/fake_horizontalpodautoscaler.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/apis/autoscaling/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeHorizontalPodAutoscalers implements HorizontalPodAutoscalerInterface
+type FakeHorizontalPodAutoscalers struct {
+	Fake *FakeAutoscaling
+	ns   string
+}
+
+var horizontalpodautoscalersResource = unversioned.GroupVersionResource{Group: "autoscaling", Version: "v1", Resource: "horizontalpodautoscalers"}
+
+func (c *FakeHorizontalPodAutoscalers) Create(horizontalPodAutoscaler *v1.HorizontalPodAutoscaler) (result *v1.HorizontalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(horizontalpodautoscalersResource, c.ns, horizontalPodAutoscaler), &v1.HorizontalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.HorizontalPodAutoscaler), err
+}
+
+func (c *FakeHorizontalPodAutoscalers) Update(horizontalPodAutoscaler *v1.HorizontalPodAutoscaler) (result *v1.HorizontalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(horizontalpodautoscalersResource, c.ns, horizontalPodAutoscaler), &v1.HorizontalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.HorizontalPodAutoscaler), err
+}
+
+func (c *FakeHorizontalPodAutoscalers) UpdateStatus(horizontalPodAutoscaler *v1.HorizontalPodAutoscaler) (*v1.HorizontalPodAutoscaler, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(horizontalpodautoscalersResource, "status", c.ns, horizontalPodAutoscaler), &v1.HorizontalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.HorizontalPodAutoscaler), err
+}
+
+func (c *FakeHorizontalPodAutoscalers) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(horizontalpodautoscalersResource, c.ns, name), &v1.HorizontalPodAutoscaler{})
+
+	return err
+}
+
+func (c *FakeHorizontalPodAutoscalers) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(horizontalpodautoscalersResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.HorizontalPodAutoscalerList{})
+	return err
+}
+
+func (c *FakeHorizontalPodAutoscalers) Get(name string) (result *v1.HorizontalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(horizontalpodautoscalersResource, c.ns, name), &v1.HorizontalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.HorizontalPodAutoscaler), err
+}
+
+func (c *FakeHorizontalPodAutoscalers) List(opts api.ListOptions) (result *v1.HorizontalPodAutoscalerList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(horizontalpodautoscalersResource, c.ns, opts), &v1.HorizontalPodAutoscalerList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.HorizontalPodAutoscalerList{}
+	for _, item := range obj.(*v1.HorizontalPodAutoscalerList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested horizontalPodAutoscalers.
+func (c *FakeHorizontalPodAutoscalers) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(horizontalpodautoscalersResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched horizontalPodAutoscaler.
+func (c *FakeHorizontalPodAutoscalers) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.HorizontalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(horizontalpodautoscalersResource, c.ns, name, data, subresources...), &v1.HorizontalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.HorizontalPodAutoscaler), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1/generated_expansion.go

@@ -0,0 +1,19 @@
+/*
+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 v1
+
+type HorizontalPodAutoscalerExpansion interface{}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/autoscaling/v1/horizontalpodautoscaler.go

@@ -0,0 +1,165 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/apis/autoscaling/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// HorizontalPodAutoscalersGetter has a method to return a HorizontalPodAutoscalerInterface.
+// A group's client should implement this interface.
+type HorizontalPodAutoscalersGetter interface {
+	HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface
+}
+
+// HorizontalPodAutoscalerInterface has methods to work with HorizontalPodAutoscaler resources.
+type HorizontalPodAutoscalerInterface interface {
+	Create(*v1.HorizontalPodAutoscaler) (*v1.HorizontalPodAutoscaler, error)
+	Update(*v1.HorizontalPodAutoscaler) (*v1.HorizontalPodAutoscaler, error)
+	UpdateStatus(*v1.HorizontalPodAutoscaler) (*v1.HorizontalPodAutoscaler, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.HorizontalPodAutoscaler, error)
+	List(opts api.ListOptions) (*v1.HorizontalPodAutoscalerList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.HorizontalPodAutoscaler, err error)
+	HorizontalPodAutoscalerExpansion
+}
+
+// horizontalPodAutoscalers implements HorizontalPodAutoscalerInterface
+type horizontalPodAutoscalers struct {
+	client *AutoscalingClient
+	ns     string
+}
+
+// newHorizontalPodAutoscalers returns a HorizontalPodAutoscalers
+func newHorizontalPodAutoscalers(c *AutoscalingClient, namespace string) *horizontalPodAutoscalers {
+	return &horizontalPodAutoscalers{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a horizontalPodAutoscaler and creates it.  Returns the server's representation of the horizontalPodAutoscaler, and an error, if there is any.
+func (c *horizontalPodAutoscalers) Create(horizontalPodAutoscaler *v1.HorizontalPodAutoscaler) (result *v1.HorizontalPodAutoscaler, err error) {
+	result = &v1.HorizontalPodAutoscaler{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		Body(horizontalPodAutoscaler).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a horizontalPodAutoscaler and updates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if there is any.
+func (c *horizontalPodAutoscalers) Update(horizontalPodAutoscaler *v1.HorizontalPodAutoscaler) (result *v1.HorizontalPodAutoscaler, err error) {
+	result = &v1.HorizontalPodAutoscaler{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		Name(horizontalPodAutoscaler.Name).
+		Body(horizontalPodAutoscaler).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *horizontalPodAutoscalers) UpdateStatus(horizontalPodAutoscaler *v1.HorizontalPodAutoscaler) (result *v1.HorizontalPodAutoscaler, err error) {
+	result = &v1.HorizontalPodAutoscaler{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		Name(horizontalPodAutoscaler.Name).
+		SubResource("status").
+		Body(horizontalPodAutoscaler).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the horizontalPodAutoscaler and deletes it. Returns an error if one occurs.
+func (c *horizontalPodAutoscalers) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *horizontalPodAutoscalers) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the horizontalPodAutoscaler, and returns the corresponding horizontalPodAutoscaler object, and an error if there is any.
+func (c *horizontalPodAutoscalers) Get(name string) (result *v1.HorizontalPodAutoscaler, err error) {
+	result = &v1.HorizontalPodAutoscaler{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of HorizontalPodAutoscalers that match those selectors.
+func (c *horizontalPodAutoscalers) List(opts api.ListOptions) (result *v1.HorizontalPodAutoscalerList, err error) {
+	result = &v1.HorizontalPodAutoscalerList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested horizontalPodAutoscalers.
+func (c *horizontalPodAutoscalers) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched horizontalPodAutoscaler.
+func (c *horizontalPodAutoscalers) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.HorizontalPodAutoscaler, err error) {
+	result = &v1.HorizontalPodAutoscaler{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/batch/v1/batch_client.go

@@ -0,0 +1,96 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
+	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
+	rest "k8s.io/client-go/1.4/rest"
+)
+
+type BatchInterface interface {
+	GetRESTClient() *rest.RESTClient
+	JobsGetter
+}
+
+// BatchClient is used to interact with features provided by the Batch group.
+type BatchClient struct {
+	*rest.RESTClient
+}
+
+func (c *BatchClient) Jobs(namespace string) JobInterface {
+	return newJobs(c, namespace)
+}
+
+// NewForConfig creates a new BatchClient for the given config.
+func NewForConfig(c *rest.Config) (*BatchClient, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.RESTClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return &BatchClient{client}, nil
+}
+
+// NewForConfigOrDie creates a new BatchClient for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *BatchClient {
+	client, err := NewForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+// New creates a new BatchClient for the given RESTClient.
+func New(c *rest.RESTClient) *BatchClient {
+	return &BatchClient{c}
+}
+
+func setConfigDefaults(config *rest.Config) error {
+	// if batch group is not registered, return an error
+	g, err := registered.Group("batch")
+	if err != nil {
+		return err
+	}
+	config.APIPath = "/apis"
+	if config.UserAgent == "" {
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+	// TODO: Unconditionally set the config.Version, until we fix the config.
+	//if config.Version == "" {
+	copyGroupVersion := g.GroupVersion
+	config.GroupVersion = &copyGroupVersion
+	//}
+
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
+
+	return nil
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *BatchClient) GetRESTClient() *rest.RESTClient {
+	if c == nil {
+		return nil
+	}
+	return c.RESTClient
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/batch/v1/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// This package has the automatically generated typed clients.
+package v1

staging/src/k8s.io/client-go/1.4/kubernetes/typed/batch/v1/fake/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// Package fake has the automatically generated clients.
+package fake

staging/src/k8s.io/client-go/1.4/kubernetes/typed/batch/v1/fake/fake_batch_client.go

@@ -0,0 +1,37 @@
+/*
+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 fake
+
+import (
+	v1 "k8s.io/client-go/1.4/kubernetes/typed/batch/v1"
+	rest "k8s.io/client-go/1.4/rest"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+type FakeBatch struct {
+	*testing.Fake
+}
+
+func (c *FakeBatch) Jobs(namespace string) v1.JobInterface {
+	return &FakeJobs{c, namespace}
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeBatch) GetRESTClient() *rest.RESTClient {
+	return nil
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/batch/v1/fake/fake_job.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/apis/batch/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeJobs implements JobInterface
+type FakeJobs struct {
+	Fake *FakeBatch
+	ns   string
+}
+
+var jobsResource = unversioned.GroupVersionResource{Group: "batch", Version: "v1", Resource: "jobs"}
+
+func (c *FakeJobs) Create(job *v1.Job) (result *v1.Job, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(jobsResource, c.ns, job), &v1.Job{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Job), err
+}
+
+func (c *FakeJobs) Update(job *v1.Job) (result *v1.Job, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(jobsResource, c.ns, job), &v1.Job{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Job), err
+}
+
+func (c *FakeJobs) UpdateStatus(job *v1.Job) (*v1.Job, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(jobsResource, "status", c.ns, job), &v1.Job{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Job), err
+}
+
+func (c *FakeJobs) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(jobsResource, c.ns, name), &v1.Job{})
+
+	return err
+}
+
+func (c *FakeJobs) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(jobsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.JobList{})
+	return err
+}
+
+func (c *FakeJobs) Get(name string) (result *v1.Job, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(jobsResource, c.ns, name), &v1.Job{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Job), err
+}
+
+func (c *FakeJobs) List(opts api.ListOptions) (result *v1.JobList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(jobsResource, c.ns, opts), &v1.JobList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.JobList{}
+	for _, item := range obj.(*v1.JobList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested jobs.
+func (c *FakeJobs) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(jobsResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched job.
+func (c *FakeJobs) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Job, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(jobsResource, c.ns, name, data, subresources...), &v1.Job{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Job), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/batch/v1/generated_expansion.go

@@ -0,0 +1,19 @@
+/*
+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 v1
+
+type JobExpansion interface{}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/batch/v1/job.go

@@ -0,0 +1,165 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/apis/batch/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// JobsGetter has a method to return a JobInterface.
+// A group's client should implement this interface.
+type JobsGetter interface {
+	Jobs(namespace string) JobInterface
+}
+
+// JobInterface has methods to work with Job resources.
+type JobInterface interface {
+	Create(*v1.Job) (*v1.Job, error)
+	Update(*v1.Job) (*v1.Job, error)
+	UpdateStatus(*v1.Job) (*v1.Job, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Job, error)
+	List(opts api.ListOptions) (*v1.JobList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Job, err error)
+	JobExpansion
+}
+
+// jobs implements JobInterface
+type jobs struct {
+	client *BatchClient
+	ns     string
+}
+
+// newJobs returns a Jobs
+func newJobs(c *BatchClient, namespace string) *jobs {
+	return &jobs{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a job and creates it.  Returns the server's representation of the job, and an error, if there is any.
+func (c *jobs) Create(job *v1.Job) (result *v1.Job, err error) {
+	result = &v1.Job{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("jobs").
+		Body(job).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a job and updates it. Returns the server's representation of the job, and an error, if there is any.
+func (c *jobs) Update(job *v1.Job) (result *v1.Job, err error) {
+	result = &v1.Job{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("jobs").
+		Name(job.Name).
+		Body(job).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *jobs) UpdateStatus(job *v1.Job) (result *v1.Job, err error) {
+	result = &v1.Job{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("jobs").
+		Name(job.Name).
+		SubResource("status").
+		Body(job).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the job and deletes it. Returns an error if one occurs.
+func (c *jobs) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("jobs").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *jobs) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("jobs").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the job, and returns the corresponding job object, and an error if there is any.
+func (c *jobs) Get(name string) (result *v1.Job, err error) {
+	result = &v1.Job{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("jobs").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Jobs that match those selectors.
+func (c *jobs) List(opts api.ListOptions) (result *v1.JobList, err error) {
+	result = &v1.JobList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("jobs").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested jobs.
+func (c *jobs) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("jobs").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched job.
+func (c *jobs) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Job, err error) {
+	result = &v1.Job{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("jobs").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/componentstatus.go

@@ -0,0 +1,141 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// ComponentStatusesGetter has a method to return a ComponentStatusInterface.
+// A group's client should implement this interface.
+type ComponentStatusesGetter interface {
+	ComponentStatuses() ComponentStatusInterface
+}
+
+// ComponentStatusInterface has methods to work with ComponentStatus resources.
+type ComponentStatusInterface interface {
+	Create(*v1.ComponentStatus) (*v1.ComponentStatus, error)
+	Update(*v1.ComponentStatus) (*v1.ComponentStatus, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.ComponentStatus, error)
+	List(opts api.ListOptions) (*v1.ComponentStatusList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ComponentStatus, err error)
+	ComponentStatusExpansion
+}
+
+// componentStatuses implements ComponentStatusInterface
+type componentStatuses struct {
+	client *CoreClient
+}
+
+// newComponentStatuses returns a ComponentStatuses
+func newComponentStatuses(c *CoreClient) *componentStatuses {
+	return &componentStatuses{
+		client: c,
+	}
+}
+
+// Create takes the representation of a componentStatus and creates it.  Returns the server's representation of the componentStatus, and an error, if there is any.
+func (c *componentStatuses) Create(componentStatus *v1.ComponentStatus) (result *v1.ComponentStatus, err error) {
+	result = &v1.ComponentStatus{}
+	err = c.client.Post().
+		Resource("componentstatuses").
+		Body(componentStatus).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a componentStatus and updates it. Returns the server's representation of the componentStatus, and an error, if there is any.
+func (c *componentStatuses) Update(componentStatus *v1.ComponentStatus) (result *v1.ComponentStatus, err error) {
+	result = &v1.ComponentStatus{}
+	err = c.client.Put().
+		Resource("componentstatuses").
+		Name(componentStatus.Name).
+		Body(componentStatus).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the componentStatus and deletes it. Returns an error if one occurs.
+func (c *componentStatuses) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("componentstatuses").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *componentStatuses) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Resource("componentstatuses").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the componentStatus, and returns the corresponding componentStatus object, and an error if there is any.
+func (c *componentStatuses) Get(name string) (result *v1.ComponentStatus, err error) {
+	result = &v1.ComponentStatus{}
+	err = c.client.Get().
+		Resource("componentstatuses").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of ComponentStatuses that match those selectors.
+func (c *componentStatuses) List(opts api.ListOptions) (result *v1.ComponentStatusList, err error) {
+	result = &v1.ComponentStatusList{}
+	err = c.client.Get().
+		Resource("componentstatuses").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested componentStatuses.
+func (c *componentStatuses) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Resource("componentstatuses").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched componentStatus.
+func (c *componentStatuses) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ComponentStatus, err error) {
+	result = &v1.ComponentStatus{}
+	err = c.client.Patch(pt).
+		Resource("componentstatuses").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/configmap.go

@@ -0,0 +1,151 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// ConfigMapsGetter has a method to return a ConfigMapInterface.
+// A group's client should implement this interface.
+type ConfigMapsGetter interface {
+	ConfigMaps(namespace string) ConfigMapInterface
+}
+
+// ConfigMapInterface has methods to work with ConfigMap resources.
+type ConfigMapInterface interface {
+	Create(*v1.ConfigMap) (*v1.ConfigMap, error)
+	Update(*v1.ConfigMap) (*v1.ConfigMap, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.ConfigMap, error)
+	List(opts api.ListOptions) (*v1.ConfigMapList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ConfigMap, err error)
+	ConfigMapExpansion
+}
+
+// configMaps implements ConfigMapInterface
+type configMaps struct {
+	client *CoreClient
+	ns     string
+}
+
+// newConfigMaps returns a ConfigMaps
+func newConfigMaps(c *CoreClient, namespace string) *configMaps {
+	return &configMaps{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a configMap and creates it.  Returns the server's representation of the configMap, and an error, if there is any.
+func (c *configMaps) Create(configMap *v1.ConfigMap) (result *v1.ConfigMap, err error) {
+	result = &v1.ConfigMap{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("configmaps").
+		Body(configMap).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a configMap and updates it. Returns the server's representation of the configMap, and an error, if there is any.
+func (c *configMaps) Update(configMap *v1.ConfigMap) (result *v1.ConfigMap, err error) {
+	result = &v1.ConfigMap{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("configmaps").
+		Name(configMap.Name).
+		Body(configMap).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the configMap and deletes it. Returns an error if one occurs.
+func (c *configMaps) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("configmaps").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *configMaps) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("configmaps").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the configMap, and returns the corresponding configMap object, and an error if there is any.
+func (c *configMaps) Get(name string) (result *v1.ConfigMap, err error) {
+	result = &v1.ConfigMap{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("configmaps").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of ConfigMaps that match those selectors.
+func (c *configMaps) List(opts api.ListOptions) (result *v1.ConfigMapList, err error) {
+	result = &v1.ConfigMapList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("configmaps").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested configMaps.
+func (c *configMaps) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("configmaps").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched configMap.
+func (c *configMaps) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ConfigMap, err error) {
+	result = &v1.ConfigMap{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("configmaps").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/core_client.go

@@ -0,0 +1,166 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
+	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
+	rest "k8s.io/client-go/1.4/rest"
+)
+
+type CoreInterface interface {
+	GetRESTClient() *rest.RESTClient
+	ComponentStatusesGetter
+	ConfigMapsGetter
+	EndpointsGetter
+	EventsGetter
+	LimitRangesGetter
+	NamespacesGetter
+	NodesGetter
+	PersistentVolumesGetter
+	PodsGetter
+	PodTemplatesGetter
+	ReplicationControllersGetter
+	ResourceQuotasGetter
+	SecretsGetter
+	ServicesGetter
+	ServiceAccountsGetter
+}
+
+// CoreClient is used to interact with features provided by the Core group.
+type CoreClient struct {
+	*rest.RESTClient
+}
+
+func (c *CoreClient) ComponentStatuses() ComponentStatusInterface {
+	return newComponentStatuses(c)
+}
+
+func (c *CoreClient) ConfigMaps(namespace string) ConfigMapInterface {
+	return newConfigMaps(c, namespace)
+}
+
+func (c *CoreClient) Endpoints(namespace string) EndpointsInterface {
+	return newEndpoints(c, namespace)
+}
+
+func (c *CoreClient) Events(namespace string) EventInterface {
+	return newEvents(c, namespace)
+}
+
+func (c *CoreClient) LimitRanges(namespace string) LimitRangeInterface {
+	return newLimitRanges(c, namespace)
+}
+
+func (c *CoreClient) Namespaces() NamespaceInterface {
+	return newNamespaces(c)
+}
+
+func (c *CoreClient) Nodes() NodeInterface {
+	return newNodes(c)
+}
+
+func (c *CoreClient) PersistentVolumes() PersistentVolumeInterface {
+	return newPersistentVolumes(c)
+}
+
+func (c *CoreClient) Pods(namespace string) PodInterface {
+	return newPods(c, namespace)
+}
+
+func (c *CoreClient) PodTemplates(namespace string) PodTemplateInterface {
+	return newPodTemplates(c, namespace)
+}
+
+func (c *CoreClient) ReplicationControllers(namespace string) ReplicationControllerInterface {
+	return newReplicationControllers(c, namespace)
+}
+
+func (c *CoreClient) ResourceQuotas(namespace string) ResourceQuotaInterface {
+	return newResourceQuotas(c, namespace)
+}
+
+func (c *CoreClient) Secrets(namespace string) SecretInterface {
+	return newSecrets(c, namespace)
+}
+
+func (c *CoreClient) Services(namespace string) ServiceInterface {
+	return newServices(c, namespace)
+}
+
+func (c *CoreClient) ServiceAccounts(namespace string) ServiceAccountInterface {
+	return newServiceAccounts(c, namespace)
+}
+
+// NewForConfig creates a new CoreClient for the given config.
+func NewForConfig(c *rest.Config) (*CoreClient, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.RESTClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return &CoreClient{client}, nil
+}
+
+// NewForConfigOrDie creates a new CoreClient for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *CoreClient {
+	client, err := NewForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+// New creates a new CoreClient for the given RESTClient.
+func New(c *rest.RESTClient) *CoreClient {
+	return &CoreClient{c}
+}
+
+func setConfigDefaults(config *rest.Config) error {
+	// if core group is not registered, return an error
+	g, err := registered.Group("")
+	if err != nil {
+		return err
+	}
+	config.APIPath = "/api"
+	if config.UserAgent == "" {
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+	// TODO: Unconditionally set the config.Version, until we fix the config.
+	//if config.Version == "" {
+	copyGroupVersion := g.GroupVersion
+	config.GroupVersion = &copyGroupVersion
+	//}
+
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
+
+	return nil
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *CoreClient) GetRESTClient() *rest.RESTClient {
+	if c == nil {
+		return nil
+	}
+	return c.RESTClient
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// This package has the automatically generated typed clients.
+package v1

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/endpoints.go

@@ -0,0 +1,151 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// EndpointsGetter has a method to return a EndpointsInterface.
+// A group's client should implement this interface.
+type EndpointsGetter interface {
+	Endpoints(namespace string) EndpointsInterface
+}
+
+// EndpointsInterface has methods to work with Endpoints resources.
+type EndpointsInterface interface {
+	Create(*v1.Endpoints) (*v1.Endpoints, error)
+	Update(*v1.Endpoints) (*v1.Endpoints, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Endpoints, error)
+	List(opts api.ListOptions) (*v1.EndpointsList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Endpoints, err error)
+	EndpointsExpansion
+}
+
+// endpoints implements EndpointsInterface
+type endpoints struct {
+	client *CoreClient
+	ns     string
+}
+
+// newEndpoints returns a Endpoints
+func newEndpoints(c *CoreClient, namespace string) *endpoints {
+	return &endpoints{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a endpoints and creates it.  Returns the server's representation of the endpoints, and an error, if there is any.
+func (c *endpoints) Create(endpoints *v1.Endpoints) (result *v1.Endpoints, err error) {
+	result = &v1.Endpoints{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("endpoints").
+		Body(endpoints).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a endpoints and updates it. Returns the server's representation of the endpoints, and an error, if there is any.
+func (c *endpoints) Update(endpoints *v1.Endpoints) (result *v1.Endpoints, err error) {
+	result = &v1.Endpoints{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("endpoints").
+		Name(endpoints.Name).
+		Body(endpoints).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the endpoints and deletes it. Returns an error if one occurs.
+func (c *endpoints) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("endpoints").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *endpoints) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("endpoints").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the endpoints, and returns the corresponding endpoints object, and an error if there is any.
+func (c *endpoints) Get(name string) (result *v1.Endpoints, err error) {
+	result = &v1.Endpoints{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("endpoints").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Endpoints that match those selectors.
+func (c *endpoints) List(opts api.ListOptions) (result *v1.EndpointsList, err error) {
+	result = &v1.EndpointsList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("endpoints").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested endpoints.
+func (c *endpoints) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("endpoints").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched endpoints.
+func (c *endpoints) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Endpoints, err error) {
+	result = &v1.Endpoints{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("endpoints").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/event.go

@@ -0,0 +1,151 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// EventsGetter has a method to return a EventInterface.
+// A group's client should implement this interface.
+type EventsGetter interface {
+	Events(namespace string) EventInterface
+}
+
+// EventInterface has methods to work with Event resources.
+type EventInterface interface {
+	Create(*v1.Event) (*v1.Event, error)
+	Update(*v1.Event) (*v1.Event, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Event, error)
+	List(opts api.ListOptions) (*v1.EventList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Event, err error)
+	EventExpansion
+}
+
+// events implements EventInterface
+type events struct {
+	client *CoreClient
+	ns     string
+}
+
+// newEvents returns a Events
+func newEvents(c *CoreClient, namespace string) *events {
+	return &events{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a event and creates it.  Returns the server's representation of the event, and an error, if there is any.
+func (c *events) Create(event *v1.Event) (result *v1.Event, err error) {
+	result = &v1.Event{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("events").
+		Body(event).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a event and updates it. Returns the server's representation of the event, and an error, if there is any.
+func (c *events) Update(event *v1.Event) (result *v1.Event, err error) {
+	result = &v1.Event{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("events").
+		Name(event.Name).
+		Body(event).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the event and deletes it. Returns an error if one occurs.
+func (c *events) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("events").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *events) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("events").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the event, and returns the corresponding event object, and an error if there is any.
+func (c *events) Get(name string) (result *v1.Event, err error) {
+	result = &v1.Event{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("events").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Events that match those selectors.
+func (c *events) List(opts api.ListOptions) (result *v1.EventList, err error) {
+	result = &v1.EventList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("events").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested events.
+func (c *events) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("events").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched event.
+func (c *events) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Event, err error) {
+	result = &v1.Event{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("events").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// Package fake has the automatically generated clients.
+package fake

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_componentstatus.go

@@ -0,0 +1,109 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeComponentStatuses implements ComponentStatusInterface
+type FakeComponentStatuses struct {
+	Fake *FakeCore
+}
+
+var componentstatusesResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "componentstatuses"}
+
+func (c *FakeComponentStatuses) Create(componentStatus *v1.ComponentStatus) (result *v1.ComponentStatus, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(componentstatusesResource, componentStatus), &v1.ComponentStatus{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ComponentStatus), err
+}
+
+func (c *FakeComponentStatuses) Update(componentStatus *v1.ComponentStatus) (result *v1.ComponentStatus, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(componentstatusesResource, componentStatus), &v1.ComponentStatus{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ComponentStatus), err
+}
+
+func (c *FakeComponentStatuses) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(componentstatusesResource, name), &v1.ComponentStatus{})
+	return err
+}
+
+func (c *FakeComponentStatuses) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(componentstatusesResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.ComponentStatusList{})
+	return err
+}
+
+func (c *FakeComponentStatuses) Get(name string) (result *v1.ComponentStatus, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(componentstatusesResource, name), &v1.ComponentStatus{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ComponentStatus), err
+}
+
+func (c *FakeComponentStatuses) List(opts api.ListOptions) (result *v1.ComponentStatusList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(componentstatusesResource, opts), &v1.ComponentStatusList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.ComponentStatusList{}
+	for _, item := range obj.(*v1.ComponentStatusList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested componentStatuses.
+func (c *FakeComponentStatuses) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(componentstatusesResource, opts))
+}
+
+// Patch applies the patch and returns the patched componentStatus.
+func (c *FakeComponentStatuses) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ComponentStatus, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(componentstatusesResource, name, data, subresources...), &v1.ComponentStatus{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ComponentStatus), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_configmap.go

@@ -0,0 +1,117 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeConfigMaps implements ConfigMapInterface
+type FakeConfigMaps struct {
+	Fake *FakeCore
+	ns   string
+}
+
+var configmapsResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "configmaps"}
+
+func (c *FakeConfigMaps) Create(configMap *v1.ConfigMap) (result *v1.ConfigMap, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(configmapsResource, c.ns, configMap), &v1.ConfigMap{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ConfigMap), err
+}
+
+func (c *FakeConfigMaps) Update(configMap *v1.ConfigMap) (result *v1.ConfigMap, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(configmapsResource, c.ns, configMap), &v1.ConfigMap{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ConfigMap), err
+}
+
+func (c *FakeConfigMaps) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(configmapsResource, c.ns, name), &v1.ConfigMap{})
+
+	return err
+}
+
+func (c *FakeConfigMaps) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(configmapsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.ConfigMapList{})
+	return err
+}
+
+func (c *FakeConfigMaps) Get(name string) (result *v1.ConfigMap, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(configmapsResource, c.ns, name), &v1.ConfigMap{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ConfigMap), err
+}
+
+func (c *FakeConfigMaps) List(opts api.ListOptions) (result *v1.ConfigMapList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(configmapsResource, c.ns, opts), &v1.ConfigMapList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.ConfigMapList{}
+	for _, item := range obj.(*v1.ConfigMapList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested configMaps.
+func (c *FakeConfigMaps) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(configmapsResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched configMap.
+func (c *FakeConfigMaps) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ConfigMap, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(configmapsResource, c.ns, name, data, subresources...), &v1.ConfigMap{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ConfigMap), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_core_client.go

@@ -0,0 +1,93 @@
+/*
+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 fake
+
+import (
+	v1 "k8s.io/client-go/1.4/kubernetes/typed/core/v1"
+	rest "k8s.io/client-go/1.4/rest"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+type FakeCore struct {
+	*testing.Fake
+}
+
+func (c *FakeCore) ComponentStatuses() v1.ComponentStatusInterface {
+	return &FakeComponentStatuses{c}
+}
+
+func (c *FakeCore) ConfigMaps(namespace string) v1.ConfigMapInterface {
+	return &FakeConfigMaps{c, namespace}
+}
+
+func (c *FakeCore) Endpoints(namespace string) v1.EndpointsInterface {
+	return &FakeEndpoints{c, namespace}
+}
+
+func (c *FakeCore) Events(namespace string) v1.EventInterface {
+	return &FakeEvents{c, namespace}
+}
+
+func (c *FakeCore) LimitRanges(namespace string) v1.LimitRangeInterface {
+	return &FakeLimitRanges{c, namespace}
+}
+
+func (c *FakeCore) Namespaces() v1.NamespaceInterface {
+	return &FakeNamespaces{c}
+}
+
+func (c *FakeCore) Nodes() v1.NodeInterface {
+	return &FakeNodes{c}
+}
+
+func (c *FakeCore) PersistentVolumes() v1.PersistentVolumeInterface {
+	return &FakePersistentVolumes{c}
+}
+
+func (c *FakeCore) Pods(namespace string) v1.PodInterface {
+	return &FakePods{c, namespace}
+}
+
+func (c *FakeCore) PodTemplates(namespace string) v1.PodTemplateInterface {
+	return &FakePodTemplates{c, namespace}
+}
+
+func (c *FakeCore) ReplicationControllers(namespace string) v1.ReplicationControllerInterface {
+	return &FakeReplicationControllers{c, namespace}
+}
+
+func (c *FakeCore) ResourceQuotas(namespace string) v1.ResourceQuotaInterface {
+	return &FakeResourceQuotas{c, namespace}
+}
+
+func (c *FakeCore) Secrets(namespace string) v1.SecretInterface {
+	return &FakeSecrets{c, namespace}
+}
+
+func (c *FakeCore) Services(namespace string) v1.ServiceInterface {
+	return &FakeServices{c, namespace}
+}
+
+func (c *FakeCore) ServiceAccounts(namespace string) v1.ServiceAccountInterface {
+	return &FakeServiceAccounts{c, namespace}
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeCore) GetRESTClient() *rest.RESTClient {
+	return nil
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_endpoints.go

@@ -0,0 +1,117 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeEndpoints implements EndpointsInterface
+type FakeEndpoints struct {
+	Fake *FakeCore
+	ns   string
+}
+
+var endpointsResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "endpoints"}
+
+func (c *FakeEndpoints) Create(endpoints *v1.Endpoints) (result *v1.Endpoints, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(endpointsResource, c.ns, endpoints), &v1.Endpoints{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Endpoints), err
+}
+
+func (c *FakeEndpoints) Update(endpoints *v1.Endpoints) (result *v1.Endpoints, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(endpointsResource, c.ns, endpoints), &v1.Endpoints{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Endpoints), err
+}
+
+func (c *FakeEndpoints) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(endpointsResource, c.ns, name), &v1.Endpoints{})
+
+	return err
+}
+
+func (c *FakeEndpoints) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(endpointsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.EndpointsList{})
+	return err
+}
+
+func (c *FakeEndpoints) Get(name string) (result *v1.Endpoints, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(endpointsResource, c.ns, name), &v1.Endpoints{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Endpoints), err
+}
+
+func (c *FakeEndpoints) List(opts api.ListOptions) (result *v1.EndpointsList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(endpointsResource, c.ns, opts), &v1.EndpointsList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.EndpointsList{}
+	for _, item := range obj.(*v1.EndpointsList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested endpoints.
+func (c *FakeEndpoints) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(endpointsResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched endpoints.
+func (c *FakeEndpoints) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Endpoints, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(endpointsResource, c.ns, name, data, subresources...), &v1.Endpoints{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Endpoints), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_event.go

@@ -0,0 +1,117 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeEvents implements EventInterface
+type FakeEvents struct {
+	Fake *FakeCore
+	ns   string
+}
+
+var eventsResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "events"}
+
+func (c *FakeEvents) Create(event *v1.Event) (result *v1.Event, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(eventsResource, c.ns, event), &v1.Event{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Event), err
+}
+
+func (c *FakeEvents) Update(event *v1.Event) (result *v1.Event, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(eventsResource, c.ns, event), &v1.Event{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Event), err
+}
+
+func (c *FakeEvents) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(eventsResource, c.ns, name), &v1.Event{})
+
+	return err
+}
+
+func (c *FakeEvents) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(eventsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.EventList{})
+	return err
+}
+
+func (c *FakeEvents) Get(name string) (result *v1.Event, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(eventsResource, c.ns, name), &v1.Event{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Event), err
+}
+
+func (c *FakeEvents) List(opts api.ListOptions) (result *v1.EventList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(eventsResource, c.ns, opts), &v1.EventList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.EventList{}
+	for _, item := range obj.(*v1.EventList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested events.
+func (c *FakeEvents) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(eventsResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched event.
+func (c *FakeEvents) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Event, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(eventsResource, c.ns, name, data, subresources...), &v1.Event{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Event), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_limitrange.go

@@ -0,0 +1,117 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeLimitRanges implements LimitRangeInterface
+type FakeLimitRanges struct {
+	Fake *FakeCore
+	ns   string
+}
+
+var limitrangesResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "limitranges"}
+
+func (c *FakeLimitRanges) Create(limitRange *v1.LimitRange) (result *v1.LimitRange, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(limitrangesResource, c.ns, limitRange), &v1.LimitRange{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.LimitRange), err
+}
+
+func (c *FakeLimitRanges) Update(limitRange *v1.LimitRange) (result *v1.LimitRange, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(limitrangesResource, c.ns, limitRange), &v1.LimitRange{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.LimitRange), err
+}
+
+func (c *FakeLimitRanges) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(limitrangesResource, c.ns, name), &v1.LimitRange{})
+
+	return err
+}
+
+func (c *FakeLimitRanges) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(limitrangesResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.LimitRangeList{})
+	return err
+}
+
+func (c *FakeLimitRanges) Get(name string) (result *v1.LimitRange, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(limitrangesResource, c.ns, name), &v1.LimitRange{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.LimitRange), err
+}
+
+func (c *FakeLimitRanges) List(opts api.ListOptions) (result *v1.LimitRangeList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(limitrangesResource, c.ns, opts), &v1.LimitRangeList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.LimitRangeList{}
+	for _, item := range obj.(*v1.LimitRangeList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested limitRanges.
+func (c *FakeLimitRanges) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(limitrangesResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched limitRange.
+func (c *FakeLimitRanges) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.LimitRange, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(limitrangesResource, c.ns, name, data, subresources...), &v1.LimitRange{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.LimitRange), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_namespace.go

@@ -0,0 +1,118 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeNamespaces implements NamespaceInterface
+type FakeNamespaces struct {
+	Fake *FakeCore
+}
+
+var namespacesResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "namespaces"}
+
+func (c *FakeNamespaces) Create(namespace *v1.Namespace) (result *v1.Namespace, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(namespacesResource, namespace), &v1.Namespace{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Namespace), err
+}
+
+func (c *FakeNamespaces) Update(namespace *v1.Namespace) (result *v1.Namespace, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(namespacesResource, namespace), &v1.Namespace{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Namespace), err
+}
+
+func (c *FakeNamespaces) UpdateStatus(namespace *v1.Namespace) (*v1.Namespace, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateSubresourceAction(namespacesResource, "status", namespace), &v1.Namespace{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Namespace), err
+}
+
+func (c *FakeNamespaces) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(namespacesResource, name), &v1.Namespace{})
+	return err
+}
+
+func (c *FakeNamespaces) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(namespacesResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.NamespaceList{})
+	return err
+}
+
+func (c *FakeNamespaces) Get(name string) (result *v1.Namespace, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(namespacesResource, name), &v1.Namespace{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Namespace), err
+}
+
+func (c *FakeNamespaces) List(opts api.ListOptions) (result *v1.NamespaceList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(namespacesResource, opts), &v1.NamespaceList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.NamespaceList{}
+	for _, item := range obj.(*v1.NamespaceList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested namespaces.
+func (c *FakeNamespaces) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(namespacesResource, opts))
+}
+
+// Patch applies the patch and returns the patched namespace.
+func (c *FakeNamespaces) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Namespace, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(namespacesResource, name, data, subresources...), &v1.Namespace{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Namespace), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_node.go

@@ -0,0 +1,118 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeNodes implements NodeInterface
+type FakeNodes struct {
+	Fake *FakeCore
+}
+
+var nodesResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "nodes"}
+
+func (c *FakeNodes) Create(node *v1.Node) (result *v1.Node, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(nodesResource, node), &v1.Node{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Node), err
+}
+
+func (c *FakeNodes) Update(node *v1.Node) (result *v1.Node, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(nodesResource, node), &v1.Node{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Node), err
+}
+
+func (c *FakeNodes) UpdateStatus(node *v1.Node) (*v1.Node, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateSubresourceAction(nodesResource, "status", node), &v1.Node{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Node), err
+}
+
+func (c *FakeNodes) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(nodesResource, name), &v1.Node{})
+	return err
+}
+
+func (c *FakeNodes) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(nodesResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.NodeList{})
+	return err
+}
+
+func (c *FakeNodes) Get(name string) (result *v1.Node, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(nodesResource, name), &v1.Node{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Node), err
+}
+
+func (c *FakeNodes) List(opts api.ListOptions) (result *v1.NodeList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(nodesResource, opts), &v1.NodeList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.NodeList{}
+	for _, item := range obj.(*v1.NodeList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested nodes.
+func (c *FakeNodes) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(nodesResource, opts))
+}
+
+// Patch applies the patch and returns the patched node.
+func (c *FakeNodes) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Node, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(nodesResource, name, data, subresources...), &v1.Node{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Node), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_persistentvolume.go

@@ -0,0 +1,118 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakePersistentVolumes implements PersistentVolumeInterface
+type FakePersistentVolumes struct {
+	Fake *FakeCore
+}
+
+var persistentvolumesResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "persistentvolumes"}
+
+func (c *FakePersistentVolumes) Create(persistentVolume *v1.PersistentVolume) (result *v1.PersistentVolume, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(persistentvolumesResource, persistentVolume), &v1.PersistentVolume{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.PersistentVolume), err
+}
+
+func (c *FakePersistentVolumes) Update(persistentVolume *v1.PersistentVolume) (result *v1.PersistentVolume, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(persistentvolumesResource, persistentVolume), &v1.PersistentVolume{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.PersistentVolume), err
+}
+
+func (c *FakePersistentVolumes) UpdateStatus(persistentVolume *v1.PersistentVolume) (*v1.PersistentVolume, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateSubresourceAction(persistentvolumesResource, "status", persistentVolume), &v1.PersistentVolume{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.PersistentVolume), err
+}
+
+func (c *FakePersistentVolumes) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(persistentvolumesResource, name), &v1.PersistentVolume{})
+	return err
+}
+
+func (c *FakePersistentVolumes) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(persistentvolumesResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.PersistentVolumeList{})
+	return err
+}
+
+func (c *FakePersistentVolumes) Get(name string) (result *v1.PersistentVolume, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(persistentvolumesResource, name), &v1.PersistentVolume{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.PersistentVolume), err
+}
+
+func (c *FakePersistentVolumes) List(opts api.ListOptions) (result *v1.PersistentVolumeList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(persistentvolumesResource, opts), &v1.PersistentVolumeList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.PersistentVolumeList{}
+	for _, item := range obj.(*v1.PersistentVolumeList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested persistentVolumes.
+func (c *FakePersistentVolumes) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(persistentvolumesResource, opts))
+}
+
+// Patch applies the patch and returns the patched persistentVolume.
+func (c *FakePersistentVolumes) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.PersistentVolume, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(persistentvolumesResource, name, data, subresources...), &v1.PersistentVolume{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.PersistentVolume), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_pod.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakePods implements PodInterface
+type FakePods struct {
+	Fake *FakeCore
+	ns   string
+}
+
+var podsResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}
+
+func (c *FakePods) Create(pod *v1.Pod) (result *v1.Pod, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(podsResource, c.ns, pod), &v1.Pod{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Pod), err
+}
+
+func (c *FakePods) Update(pod *v1.Pod) (result *v1.Pod, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(podsResource, c.ns, pod), &v1.Pod{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Pod), err
+}
+
+func (c *FakePods) UpdateStatus(pod *v1.Pod) (*v1.Pod, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(podsResource, "status", c.ns, pod), &v1.Pod{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Pod), err
+}
+
+func (c *FakePods) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(podsResource, c.ns, name), &v1.Pod{})
+
+	return err
+}
+
+func (c *FakePods) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(podsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.PodList{})
+	return err
+}
+
+func (c *FakePods) Get(name string) (result *v1.Pod, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(podsResource, c.ns, name), &v1.Pod{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Pod), err
+}
+
+func (c *FakePods) List(opts api.ListOptions) (result *v1.PodList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(podsResource, c.ns, opts), &v1.PodList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.PodList{}
+	for _, item := range obj.(*v1.PodList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested pods.
+func (c *FakePods) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(podsResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched pod.
+func (c *FakePods) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Pod, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(podsResource, c.ns, name, data, subresources...), &v1.Pod{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Pod), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_podtemplate.go

@@ -0,0 +1,117 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakePodTemplates implements PodTemplateInterface
+type FakePodTemplates struct {
+	Fake *FakeCore
+	ns   string
+}
+
+var podtemplatesResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "podtemplates"}
+
+func (c *FakePodTemplates) Create(podTemplate *v1.PodTemplate) (result *v1.PodTemplate, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(podtemplatesResource, c.ns, podTemplate), &v1.PodTemplate{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.PodTemplate), err
+}
+
+func (c *FakePodTemplates) Update(podTemplate *v1.PodTemplate) (result *v1.PodTemplate, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(podtemplatesResource, c.ns, podTemplate), &v1.PodTemplate{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.PodTemplate), err
+}
+
+func (c *FakePodTemplates) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(podtemplatesResource, c.ns, name), &v1.PodTemplate{})
+
+	return err
+}
+
+func (c *FakePodTemplates) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(podtemplatesResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.PodTemplateList{})
+	return err
+}
+
+func (c *FakePodTemplates) Get(name string) (result *v1.PodTemplate, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(podtemplatesResource, c.ns, name), &v1.PodTemplate{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.PodTemplate), err
+}
+
+func (c *FakePodTemplates) List(opts api.ListOptions) (result *v1.PodTemplateList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(podtemplatesResource, c.ns, opts), &v1.PodTemplateList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.PodTemplateList{}
+	for _, item := range obj.(*v1.PodTemplateList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested podTemplates.
+func (c *FakePodTemplates) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(podtemplatesResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched podTemplate.
+func (c *FakePodTemplates) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.PodTemplate, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(podtemplatesResource, c.ns, name, data, subresources...), &v1.PodTemplate{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.PodTemplate), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_replicationcontroller.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeReplicationControllers implements ReplicationControllerInterface
+type FakeReplicationControllers struct {
+	Fake *FakeCore
+	ns   string
+}
+
+var replicationcontrollersResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "replicationcontrollers"}
+
+func (c *FakeReplicationControllers) Create(replicationController *v1.ReplicationController) (result *v1.ReplicationController, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(replicationcontrollersResource, c.ns, replicationController), &v1.ReplicationController{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ReplicationController), err
+}
+
+func (c *FakeReplicationControllers) Update(replicationController *v1.ReplicationController) (result *v1.ReplicationController, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(replicationcontrollersResource, c.ns, replicationController), &v1.ReplicationController{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ReplicationController), err
+}
+
+func (c *FakeReplicationControllers) UpdateStatus(replicationController *v1.ReplicationController) (*v1.ReplicationController, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(replicationcontrollersResource, "status", c.ns, replicationController), &v1.ReplicationController{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ReplicationController), err
+}
+
+func (c *FakeReplicationControllers) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(replicationcontrollersResource, c.ns, name), &v1.ReplicationController{})
+
+	return err
+}
+
+func (c *FakeReplicationControllers) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(replicationcontrollersResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.ReplicationControllerList{})
+	return err
+}
+
+func (c *FakeReplicationControllers) Get(name string) (result *v1.ReplicationController, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(replicationcontrollersResource, c.ns, name), &v1.ReplicationController{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ReplicationController), err
+}
+
+func (c *FakeReplicationControllers) List(opts api.ListOptions) (result *v1.ReplicationControllerList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(replicationcontrollersResource, c.ns, opts), &v1.ReplicationControllerList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.ReplicationControllerList{}
+	for _, item := range obj.(*v1.ReplicationControllerList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested replicationControllers.
+func (c *FakeReplicationControllers) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(replicationcontrollersResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched replicationController.
+func (c *FakeReplicationControllers) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ReplicationController, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(replicationcontrollersResource, c.ns, name, data, subresources...), &v1.ReplicationController{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ReplicationController), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_resourcequota.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeResourceQuotas implements ResourceQuotaInterface
+type FakeResourceQuotas struct {
+	Fake *FakeCore
+	ns   string
+}
+
+var resourcequotasResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "resourcequotas"}
+
+func (c *FakeResourceQuotas) Create(resourceQuota *v1.ResourceQuota) (result *v1.ResourceQuota, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(resourcequotasResource, c.ns, resourceQuota), &v1.ResourceQuota{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ResourceQuota), err
+}
+
+func (c *FakeResourceQuotas) Update(resourceQuota *v1.ResourceQuota) (result *v1.ResourceQuota, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(resourcequotasResource, c.ns, resourceQuota), &v1.ResourceQuota{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ResourceQuota), err
+}
+
+func (c *FakeResourceQuotas) UpdateStatus(resourceQuota *v1.ResourceQuota) (*v1.ResourceQuota, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(resourcequotasResource, "status", c.ns, resourceQuota), &v1.ResourceQuota{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ResourceQuota), err
+}
+
+func (c *FakeResourceQuotas) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(resourcequotasResource, c.ns, name), &v1.ResourceQuota{})
+
+	return err
+}
+
+func (c *FakeResourceQuotas) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(resourcequotasResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.ResourceQuotaList{})
+	return err
+}
+
+func (c *FakeResourceQuotas) Get(name string) (result *v1.ResourceQuota, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(resourcequotasResource, c.ns, name), &v1.ResourceQuota{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ResourceQuota), err
+}
+
+func (c *FakeResourceQuotas) List(opts api.ListOptions) (result *v1.ResourceQuotaList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(resourcequotasResource, c.ns, opts), &v1.ResourceQuotaList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.ResourceQuotaList{}
+	for _, item := range obj.(*v1.ResourceQuotaList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested resourceQuotas.
+func (c *FakeResourceQuotas) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(resourcequotasResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched resourceQuota.
+func (c *FakeResourceQuotas) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ResourceQuota, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(resourcequotasResource, c.ns, name, data, subresources...), &v1.ResourceQuota{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ResourceQuota), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_secret.go

@@ -0,0 +1,117 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeSecrets implements SecretInterface
+type FakeSecrets struct {
+	Fake *FakeCore
+	ns   string
+}
+
+var secretsResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "secrets"}
+
+func (c *FakeSecrets) Create(secret *v1.Secret) (result *v1.Secret, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(secretsResource, c.ns, secret), &v1.Secret{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Secret), err
+}
+
+func (c *FakeSecrets) Update(secret *v1.Secret) (result *v1.Secret, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(secretsResource, c.ns, secret), &v1.Secret{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Secret), err
+}
+
+func (c *FakeSecrets) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(secretsResource, c.ns, name), &v1.Secret{})
+
+	return err
+}
+
+func (c *FakeSecrets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(secretsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.SecretList{})
+	return err
+}
+
+func (c *FakeSecrets) Get(name string) (result *v1.Secret, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(secretsResource, c.ns, name), &v1.Secret{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Secret), err
+}
+
+func (c *FakeSecrets) List(opts api.ListOptions) (result *v1.SecretList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(secretsResource, c.ns, opts), &v1.SecretList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.SecretList{}
+	for _, item := range obj.(*v1.SecretList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested secrets.
+func (c *FakeSecrets) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(secretsResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched secret.
+func (c *FakeSecrets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Secret, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(secretsResource, c.ns, name, data, subresources...), &v1.Secret{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Secret), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_service.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeServices implements ServiceInterface
+type FakeServices struct {
+	Fake *FakeCore
+	ns   string
+}
+
+var servicesResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "services"}
+
+func (c *FakeServices) Create(service *v1.Service) (result *v1.Service, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(servicesResource, c.ns, service), &v1.Service{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Service), err
+}
+
+func (c *FakeServices) Update(service *v1.Service) (result *v1.Service, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(servicesResource, c.ns, service), &v1.Service{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Service), err
+}
+
+func (c *FakeServices) UpdateStatus(service *v1.Service) (*v1.Service, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(servicesResource, "status", c.ns, service), &v1.Service{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Service), err
+}
+
+func (c *FakeServices) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(servicesResource, c.ns, name), &v1.Service{})
+
+	return err
+}
+
+func (c *FakeServices) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(servicesResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.ServiceList{})
+	return err
+}
+
+func (c *FakeServices) Get(name string) (result *v1.Service, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(servicesResource, c.ns, name), &v1.Service{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Service), err
+}
+
+func (c *FakeServices) List(opts api.ListOptions) (result *v1.ServiceList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(servicesResource, c.ns, opts), &v1.ServiceList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.ServiceList{}
+	for _, item := range obj.(*v1.ServiceList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested services.
+func (c *FakeServices) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(servicesResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched service.
+func (c *FakeServices) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Service, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(servicesResource, c.ns, name, data, subresources...), &v1.Service{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.Service), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/fake/fake_serviceaccount.go

@@ -0,0 +1,117 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeServiceAccounts implements ServiceAccountInterface
+type FakeServiceAccounts struct {
+	Fake *FakeCore
+	ns   string
+}
+
+var serviceaccountsResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "serviceaccounts"}
+
+func (c *FakeServiceAccounts) Create(serviceAccount *v1.ServiceAccount) (result *v1.ServiceAccount, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(serviceaccountsResource, c.ns, serviceAccount), &v1.ServiceAccount{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ServiceAccount), err
+}
+
+func (c *FakeServiceAccounts) Update(serviceAccount *v1.ServiceAccount) (result *v1.ServiceAccount, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(serviceaccountsResource, c.ns, serviceAccount), &v1.ServiceAccount{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ServiceAccount), err
+}
+
+func (c *FakeServiceAccounts) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(serviceaccountsResource, c.ns, name), &v1.ServiceAccount{})
+
+	return err
+}
+
+func (c *FakeServiceAccounts) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(serviceaccountsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1.ServiceAccountList{})
+	return err
+}
+
+func (c *FakeServiceAccounts) Get(name string) (result *v1.ServiceAccount, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(serviceaccountsResource, c.ns, name), &v1.ServiceAccount{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ServiceAccount), err
+}
+
+func (c *FakeServiceAccounts) List(opts api.ListOptions) (result *v1.ServiceAccountList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(serviceaccountsResource, c.ns, opts), &v1.ServiceAccountList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1.ServiceAccountList{}
+	for _, item := range obj.(*v1.ServiceAccountList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested serviceAccounts.
+func (c *FakeServiceAccounts) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(serviceaccountsResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched serviceAccount.
+func (c *FakeServiceAccounts) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ServiceAccount, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(serviceaccountsResource, c.ns, name, data, subresources...), &v1.ServiceAccount{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1.ServiceAccount), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/generated_expansion.go

@@ -0,0 +1,47 @@
+/*
+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 v1
+
+type ComponentStatusExpansion interface{}
+
+type ConfigMapExpansion interface{}
+
+type EndpointsExpansion interface{}
+
+type EventExpansion interface{}
+
+type LimitRangeExpansion interface{}
+
+type NamespaceExpansion interface{}
+
+type NodeExpansion interface{}
+
+type PersistentVolumeExpansion interface{}
+
+type PodExpansion interface{}
+
+type PodTemplateExpansion interface{}
+
+type ReplicationControllerExpansion interface{}
+
+type ResourceQuotaExpansion interface{}
+
+type SecretExpansion interface{}
+
+type ServiceExpansion interface{}
+
+type ServiceAccountExpansion interface{}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/limitrange.go

@@ -0,0 +1,151 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// LimitRangesGetter has a method to return a LimitRangeInterface.
+// A group's client should implement this interface.
+type LimitRangesGetter interface {
+	LimitRanges(namespace string) LimitRangeInterface
+}
+
+// LimitRangeInterface has methods to work with LimitRange resources.
+type LimitRangeInterface interface {
+	Create(*v1.LimitRange) (*v1.LimitRange, error)
+	Update(*v1.LimitRange) (*v1.LimitRange, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.LimitRange, error)
+	List(opts api.ListOptions) (*v1.LimitRangeList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.LimitRange, err error)
+	LimitRangeExpansion
+}
+
+// limitRanges implements LimitRangeInterface
+type limitRanges struct {
+	client *CoreClient
+	ns     string
+}
+
+// newLimitRanges returns a LimitRanges
+func newLimitRanges(c *CoreClient, namespace string) *limitRanges {
+	return &limitRanges{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a limitRange and creates it.  Returns the server's representation of the limitRange, and an error, if there is any.
+func (c *limitRanges) Create(limitRange *v1.LimitRange) (result *v1.LimitRange, err error) {
+	result = &v1.LimitRange{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("limitranges").
+		Body(limitRange).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a limitRange and updates it. Returns the server's representation of the limitRange, and an error, if there is any.
+func (c *limitRanges) Update(limitRange *v1.LimitRange) (result *v1.LimitRange, err error) {
+	result = &v1.LimitRange{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("limitranges").
+		Name(limitRange.Name).
+		Body(limitRange).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the limitRange and deletes it. Returns an error if one occurs.
+func (c *limitRanges) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("limitranges").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *limitRanges) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("limitranges").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the limitRange, and returns the corresponding limitRange object, and an error if there is any.
+func (c *limitRanges) Get(name string) (result *v1.LimitRange, err error) {
+	result = &v1.LimitRange{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("limitranges").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of LimitRanges that match those selectors.
+func (c *limitRanges) List(opts api.ListOptions) (result *v1.LimitRangeList, err error) {
+	result = &v1.LimitRangeList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("limitranges").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested limitRanges.
+func (c *limitRanges) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("limitranges").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched limitRange.
+func (c *limitRanges) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.LimitRange, err error) {
+	result = &v1.LimitRange{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("limitranges").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/namespace.go

@@ -0,0 +1,154 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// NamespacesGetter has a method to return a NamespaceInterface.
+// A group's client should implement this interface.
+type NamespacesGetter interface {
+	Namespaces() NamespaceInterface
+}
+
+// NamespaceInterface has methods to work with Namespace resources.
+type NamespaceInterface interface {
+	Create(*v1.Namespace) (*v1.Namespace, error)
+	Update(*v1.Namespace) (*v1.Namespace, error)
+	UpdateStatus(*v1.Namespace) (*v1.Namespace, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Namespace, error)
+	List(opts api.ListOptions) (*v1.NamespaceList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Namespace, err error)
+	NamespaceExpansion
+}
+
+// namespaces implements NamespaceInterface
+type namespaces struct {
+	client *CoreClient
+}
+
+// newNamespaces returns a Namespaces
+func newNamespaces(c *CoreClient) *namespaces {
+	return &namespaces{
+		client: c,
+	}
+}
+
+// Create takes the representation of a namespace and creates it.  Returns the server's representation of the namespace, and an error, if there is any.
+func (c *namespaces) Create(namespace *v1.Namespace) (result *v1.Namespace, err error) {
+	result = &v1.Namespace{}
+	err = c.client.Post().
+		Resource("namespaces").
+		Body(namespace).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a namespace and updates it. Returns the server's representation of the namespace, and an error, if there is any.
+func (c *namespaces) Update(namespace *v1.Namespace) (result *v1.Namespace, err error) {
+	result = &v1.Namespace{}
+	err = c.client.Put().
+		Resource("namespaces").
+		Name(namespace.Name).
+		Body(namespace).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *namespaces) UpdateStatus(namespace *v1.Namespace) (result *v1.Namespace, err error) {
+	result = &v1.Namespace{}
+	err = c.client.Put().
+		Resource("namespaces").
+		Name(namespace.Name).
+		SubResource("status").
+		Body(namespace).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the namespace and deletes it. Returns an error if one occurs.
+func (c *namespaces) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("namespaces").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *namespaces) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Resource("namespaces").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the namespace, and returns the corresponding namespace object, and an error if there is any.
+func (c *namespaces) Get(name string) (result *v1.Namespace, err error) {
+	result = &v1.Namespace{}
+	err = c.client.Get().
+		Resource("namespaces").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Namespaces that match those selectors.
+func (c *namespaces) List(opts api.ListOptions) (result *v1.NamespaceList, err error) {
+	result = &v1.NamespaceList{}
+	err = c.client.Get().
+		Resource("namespaces").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested namespaces.
+func (c *namespaces) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Resource("namespaces").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched namespace.
+func (c *namespaces) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Namespace, err error) {
+	result = &v1.Namespace{}
+	err = c.client.Patch(pt).
+		Resource("namespaces").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/node.go

@@ -0,0 +1,154 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// NodesGetter has a method to return a NodeInterface.
+// A group's client should implement this interface.
+type NodesGetter interface {
+	Nodes() NodeInterface
+}
+
+// NodeInterface has methods to work with Node resources.
+type NodeInterface interface {
+	Create(*v1.Node) (*v1.Node, error)
+	Update(*v1.Node) (*v1.Node, error)
+	UpdateStatus(*v1.Node) (*v1.Node, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Node, error)
+	List(opts api.ListOptions) (*v1.NodeList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Node, err error)
+	NodeExpansion
+}
+
+// nodes implements NodeInterface
+type nodes struct {
+	client *CoreClient
+}
+
+// newNodes returns a Nodes
+func newNodes(c *CoreClient) *nodes {
+	return &nodes{
+		client: c,
+	}
+}
+
+// Create takes the representation of a node and creates it.  Returns the server's representation of the node, and an error, if there is any.
+func (c *nodes) Create(node *v1.Node) (result *v1.Node, err error) {
+	result = &v1.Node{}
+	err = c.client.Post().
+		Resource("nodes").
+		Body(node).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a node and updates it. Returns the server's representation of the node, and an error, if there is any.
+func (c *nodes) Update(node *v1.Node) (result *v1.Node, err error) {
+	result = &v1.Node{}
+	err = c.client.Put().
+		Resource("nodes").
+		Name(node.Name).
+		Body(node).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *nodes) UpdateStatus(node *v1.Node) (result *v1.Node, err error) {
+	result = &v1.Node{}
+	err = c.client.Put().
+		Resource("nodes").
+		Name(node.Name).
+		SubResource("status").
+		Body(node).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the node and deletes it. Returns an error if one occurs.
+func (c *nodes) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("nodes").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *nodes) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Resource("nodes").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the node, and returns the corresponding node object, and an error if there is any.
+func (c *nodes) Get(name string) (result *v1.Node, err error) {
+	result = &v1.Node{}
+	err = c.client.Get().
+		Resource("nodes").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Nodes that match those selectors.
+func (c *nodes) List(opts api.ListOptions) (result *v1.NodeList, err error) {
+	result = &v1.NodeList{}
+	err = c.client.Get().
+		Resource("nodes").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested nodes.
+func (c *nodes) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Resource("nodes").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched node.
+func (c *nodes) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Node, err error) {
+	result = &v1.Node{}
+	err = c.client.Patch(pt).
+		Resource("nodes").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/persistentvolume.go

@@ -0,0 +1,154 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// PersistentVolumesGetter has a method to return a PersistentVolumeInterface.
+// A group's client should implement this interface.
+type PersistentVolumesGetter interface {
+	PersistentVolumes() PersistentVolumeInterface
+}
+
+// PersistentVolumeInterface has methods to work with PersistentVolume resources.
+type PersistentVolumeInterface interface {
+	Create(*v1.PersistentVolume) (*v1.PersistentVolume, error)
+	Update(*v1.PersistentVolume) (*v1.PersistentVolume, error)
+	UpdateStatus(*v1.PersistentVolume) (*v1.PersistentVolume, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.PersistentVolume, error)
+	List(opts api.ListOptions) (*v1.PersistentVolumeList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.PersistentVolume, err error)
+	PersistentVolumeExpansion
+}
+
+// persistentVolumes implements PersistentVolumeInterface
+type persistentVolumes struct {
+	client *CoreClient
+}
+
+// newPersistentVolumes returns a PersistentVolumes
+func newPersistentVolumes(c *CoreClient) *persistentVolumes {
+	return &persistentVolumes{
+		client: c,
+	}
+}
+
+// Create takes the representation of a persistentVolume and creates it.  Returns the server's representation of the persistentVolume, and an error, if there is any.
+func (c *persistentVolumes) Create(persistentVolume *v1.PersistentVolume) (result *v1.PersistentVolume, err error) {
+	result = &v1.PersistentVolume{}
+	err = c.client.Post().
+		Resource("persistentvolumes").
+		Body(persistentVolume).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a persistentVolume and updates it. Returns the server's representation of the persistentVolume, and an error, if there is any.
+func (c *persistentVolumes) Update(persistentVolume *v1.PersistentVolume) (result *v1.PersistentVolume, err error) {
+	result = &v1.PersistentVolume{}
+	err = c.client.Put().
+		Resource("persistentvolumes").
+		Name(persistentVolume.Name).
+		Body(persistentVolume).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *persistentVolumes) UpdateStatus(persistentVolume *v1.PersistentVolume) (result *v1.PersistentVolume, err error) {
+	result = &v1.PersistentVolume{}
+	err = c.client.Put().
+		Resource("persistentvolumes").
+		Name(persistentVolume.Name).
+		SubResource("status").
+		Body(persistentVolume).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the persistentVolume and deletes it. Returns an error if one occurs.
+func (c *persistentVolumes) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("persistentvolumes").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *persistentVolumes) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Resource("persistentvolumes").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the persistentVolume, and returns the corresponding persistentVolume object, and an error if there is any.
+func (c *persistentVolumes) Get(name string) (result *v1.PersistentVolume, err error) {
+	result = &v1.PersistentVolume{}
+	err = c.client.Get().
+		Resource("persistentvolumes").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of PersistentVolumes that match those selectors.
+func (c *persistentVolumes) List(opts api.ListOptions) (result *v1.PersistentVolumeList, err error) {
+	result = &v1.PersistentVolumeList{}
+	err = c.client.Get().
+		Resource("persistentvolumes").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested persistentVolumes.
+func (c *persistentVolumes) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Resource("persistentvolumes").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched persistentVolume.
+func (c *persistentVolumes) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.PersistentVolume, err error) {
+	result = &v1.PersistentVolume{}
+	err = c.client.Patch(pt).
+		Resource("persistentvolumes").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/pod.go

@@ -0,0 +1,165 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// PodsGetter has a method to return a PodInterface.
+// A group's client should implement this interface.
+type PodsGetter interface {
+	Pods(namespace string) PodInterface
+}
+
+// PodInterface has methods to work with Pod resources.
+type PodInterface interface {
+	Create(*v1.Pod) (*v1.Pod, error)
+	Update(*v1.Pod) (*v1.Pod, error)
+	UpdateStatus(*v1.Pod) (*v1.Pod, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Pod, error)
+	List(opts api.ListOptions) (*v1.PodList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Pod, err error)
+	PodExpansion
+}
+
+// pods implements PodInterface
+type pods struct {
+	client *CoreClient
+	ns     string
+}
+
+// newPods returns a Pods
+func newPods(c *CoreClient, namespace string) *pods {
+	return &pods{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a pod and creates it.  Returns the server's representation of the pod, and an error, if there is any.
+func (c *pods) Create(pod *v1.Pod) (result *v1.Pod, err error) {
+	result = &v1.Pod{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("pods").
+		Body(pod).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a pod and updates it. Returns the server's representation of the pod, and an error, if there is any.
+func (c *pods) Update(pod *v1.Pod) (result *v1.Pod, err error) {
+	result = &v1.Pod{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("pods").
+		Name(pod.Name).
+		Body(pod).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *pods) UpdateStatus(pod *v1.Pod) (result *v1.Pod, err error) {
+	result = &v1.Pod{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("pods").
+		Name(pod.Name).
+		SubResource("status").
+		Body(pod).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the pod and deletes it. Returns an error if one occurs.
+func (c *pods) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("pods").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *pods) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("pods").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the pod, and returns the corresponding pod object, and an error if there is any.
+func (c *pods) Get(name string) (result *v1.Pod, err error) {
+	result = &v1.Pod{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("pods").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Pods that match those selectors.
+func (c *pods) List(opts api.ListOptions) (result *v1.PodList, err error) {
+	result = &v1.PodList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("pods").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested pods.
+func (c *pods) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("pods").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched pod.
+func (c *pods) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Pod, err error) {
+	result = &v1.Pod{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("pods").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/podtemplate.go

@@ -0,0 +1,151 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// PodTemplatesGetter has a method to return a PodTemplateInterface.
+// A group's client should implement this interface.
+type PodTemplatesGetter interface {
+	PodTemplates(namespace string) PodTemplateInterface
+}
+
+// PodTemplateInterface has methods to work with PodTemplate resources.
+type PodTemplateInterface interface {
+	Create(*v1.PodTemplate) (*v1.PodTemplate, error)
+	Update(*v1.PodTemplate) (*v1.PodTemplate, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.PodTemplate, error)
+	List(opts api.ListOptions) (*v1.PodTemplateList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.PodTemplate, err error)
+	PodTemplateExpansion
+}
+
+// podTemplates implements PodTemplateInterface
+type podTemplates struct {
+	client *CoreClient
+	ns     string
+}
+
+// newPodTemplates returns a PodTemplates
+func newPodTemplates(c *CoreClient, namespace string) *podTemplates {
+	return &podTemplates{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a podTemplate and creates it.  Returns the server's representation of the podTemplate, and an error, if there is any.
+func (c *podTemplates) Create(podTemplate *v1.PodTemplate) (result *v1.PodTemplate, err error) {
+	result = &v1.PodTemplate{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("podtemplates").
+		Body(podTemplate).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a podTemplate and updates it. Returns the server's representation of the podTemplate, and an error, if there is any.
+func (c *podTemplates) Update(podTemplate *v1.PodTemplate) (result *v1.PodTemplate, err error) {
+	result = &v1.PodTemplate{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("podtemplates").
+		Name(podTemplate.Name).
+		Body(podTemplate).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the podTemplate and deletes it. Returns an error if one occurs.
+func (c *podTemplates) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("podtemplates").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *podTemplates) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("podtemplates").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the podTemplate, and returns the corresponding podTemplate object, and an error if there is any.
+func (c *podTemplates) Get(name string) (result *v1.PodTemplate, err error) {
+	result = &v1.PodTemplate{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("podtemplates").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of PodTemplates that match those selectors.
+func (c *podTemplates) List(opts api.ListOptions) (result *v1.PodTemplateList, err error) {
+	result = &v1.PodTemplateList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("podtemplates").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested podTemplates.
+func (c *podTemplates) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("podtemplates").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched podTemplate.
+func (c *podTemplates) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.PodTemplate, err error) {
+	result = &v1.PodTemplate{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("podtemplates").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/replicationcontroller.go

@@ -0,0 +1,165 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// ReplicationControllersGetter has a method to return a ReplicationControllerInterface.
+// A group's client should implement this interface.
+type ReplicationControllersGetter interface {
+	ReplicationControllers(namespace string) ReplicationControllerInterface
+}
+
+// ReplicationControllerInterface has methods to work with ReplicationController resources.
+type ReplicationControllerInterface interface {
+	Create(*v1.ReplicationController) (*v1.ReplicationController, error)
+	Update(*v1.ReplicationController) (*v1.ReplicationController, error)
+	UpdateStatus(*v1.ReplicationController) (*v1.ReplicationController, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.ReplicationController, error)
+	List(opts api.ListOptions) (*v1.ReplicationControllerList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ReplicationController, err error)
+	ReplicationControllerExpansion
+}
+
+// replicationControllers implements ReplicationControllerInterface
+type replicationControllers struct {
+	client *CoreClient
+	ns     string
+}
+
+// newReplicationControllers returns a ReplicationControllers
+func newReplicationControllers(c *CoreClient, namespace string) *replicationControllers {
+	return &replicationControllers{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a replicationController and creates it.  Returns the server's representation of the replicationController, and an error, if there is any.
+func (c *replicationControllers) Create(replicationController *v1.ReplicationController) (result *v1.ReplicationController, err error) {
+	result = &v1.ReplicationController{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("replicationcontrollers").
+		Body(replicationController).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a replicationController and updates it. Returns the server's representation of the replicationController, and an error, if there is any.
+func (c *replicationControllers) Update(replicationController *v1.ReplicationController) (result *v1.ReplicationController, err error) {
+	result = &v1.ReplicationController{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("replicationcontrollers").
+		Name(replicationController.Name).
+		Body(replicationController).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *replicationControllers) UpdateStatus(replicationController *v1.ReplicationController) (result *v1.ReplicationController, err error) {
+	result = &v1.ReplicationController{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("replicationcontrollers").
+		Name(replicationController.Name).
+		SubResource("status").
+		Body(replicationController).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the replicationController and deletes it. Returns an error if one occurs.
+func (c *replicationControllers) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("replicationcontrollers").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *replicationControllers) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("replicationcontrollers").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the replicationController, and returns the corresponding replicationController object, and an error if there is any.
+func (c *replicationControllers) Get(name string) (result *v1.ReplicationController, err error) {
+	result = &v1.ReplicationController{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("replicationcontrollers").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of ReplicationControllers that match those selectors.
+func (c *replicationControllers) List(opts api.ListOptions) (result *v1.ReplicationControllerList, err error) {
+	result = &v1.ReplicationControllerList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("replicationcontrollers").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested replicationControllers.
+func (c *replicationControllers) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("replicationcontrollers").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched replicationController.
+func (c *replicationControllers) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ReplicationController, err error) {
+	result = &v1.ReplicationController{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("replicationcontrollers").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/resourcequota.go

@@ -0,0 +1,165 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// ResourceQuotasGetter has a method to return a ResourceQuotaInterface.
+// A group's client should implement this interface.
+type ResourceQuotasGetter interface {
+	ResourceQuotas(namespace string) ResourceQuotaInterface
+}
+
+// ResourceQuotaInterface has methods to work with ResourceQuota resources.
+type ResourceQuotaInterface interface {
+	Create(*v1.ResourceQuota) (*v1.ResourceQuota, error)
+	Update(*v1.ResourceQuota) (*v1.ResourceQuota, error)
+	UpdateStatus(*v1.ResourceQuota) (*v1.ResourceQuota, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.ResourceQuota, error)
+	List(opts api.ListOptions) (*v1.ResourceQuotaList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ResourceQuota, err error)
+	ResourceQuotaExpansion
+}
+
+// resourceQuotas implements ResourceQuotaInterface
+type resourceQuotas struct {
+	client *CoreClient
+	ns     string
+}
+
+// newResourceQuotas returns a ResourceQuotas
+func newResourceQuotas(c *CoreClient, namespace string) *resourceQuotas {
+	return &resourceQuotas{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a resourceQuota and creates it.  Returns the server's representation of the resourceQuota, and an error, if there is any.
+func (c *resourceQuotas) Create(resourceQuota *v1.ResourceQuota) (result *v1.ResourceQuota, err error) {
+	result = &v1.ResourceQuota{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("resourcequotas").
+		Body(resourceQuota).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a resourceQuota and updates it. Returns the server's representation of the resourceQuota, and an error, if there is any.
+func (c *resourceQuotas) Update(resourceQuota *v1.ResourceQuota) (result *v1.ResourceQuota, err error) {
+	result = &v1.ResourceQuota{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("resourcequotas").
+		Name(resourceQuota.Name).
+		Body(resourceQuota).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *resourceQuotas) UpdateStatus(resourceQuota *v1.ResourceQuota) (result *v1.ResourceQuota, err error) {
+	result = &v1.ResourceQuota{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("resourcequotas").
+		Name(resourceQuota.Name).
+		SubResource("status").
+		Body(resourceQuota).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the resourceQuota and deletes it. Returns an error if one occurs.
+func (c *resourceQuotas) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("resourcequotas").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *resourceQuotas) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("resourcequotas").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the resourceQuota, and returns the corresponding resourceQuota object, and an error if there is any.
+func (c *resourceQuotas) Get(name string) (result *v1.ResourceQuota, err error) {
+	result = &v1.ResourceQuota{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("resourcequotas").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of ResourceQuotas that match those selectors.
+func (c *resourceQuotas) List(opts api.ListOptions) (result *v1.ResourceQuotaList, err error) {
+	result = &v1.ResourceQuotaList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("resourcequotas").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested resourceQuotas.
+func (c *resourceQuotas) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("resourcequotas").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched resourceQuota.
+func (c *resourceQuotas) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ResourceQuota, err error) {
+	result = &v1.ResourceQuota{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("resourcequotas").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/secret.go

@@ -0,0 +1,151 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// SecretsGetter has a method to return a SecretInterface.
+// A group's client should implement this interface.
+type SecretsGetter interface {
+	Secrets(namespace string) SecretInterface
+}
+
+// SecretInterface has methods to work with Secret resources.
+type SecretInterface interface {
+	Create(*v1.Secret) (*v1.Secret, error)
+	Update(*v1.Secret) (*v1.Secret, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Secret, error)
+	List(opts api.ListOptions) (*v1.SecretList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Secret, err error)
+	SecretExpansion
+}
+
+// secrets implements SecretInterface
+type secrets struct {
+	client *CoreClient
+	ns     string
+}
+
+// newSecrets returns a Secrets
+func newSecrets(c *CoreClient, namespace string) *secrets {
+	return &secrets{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a secret and creates it.  Returns the server's representation of the secret, and an error, if there is any.
+func (c *secrets) Create(secret *v1.Secret) (result *v1.Secret, err error) {
+	result = &v1.Secret{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("secrets").
+		Body(secret).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a secret and updates it. Returns the server's representation of the secret, and an error, if there is any.
+func (c *secrets) Update(secret *v1.Secret) (result *v1.Secret, err error) {
+	result = &v1.Secret{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("secrets").
+		Name(secret.Name).
+		Body(secret).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the secret and deletes it. Returns an error if one occurs.
+func (c *secrets) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("secrets").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *secrets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("secrets").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the secret, and returns the corresponding secret object, and an error if there is any.
+func (c *secrets) Get(name string) (result *v1.Secret, err error) {
+	result = &v1.Secret{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("secrets").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Secrets that match those selectors.
+func (c *secrets) List(opts api.ListOptions) (result *v1.SecretList, err error) {
+	result = &v1.SecretList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("secrets").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested secrets.
+func (c *secrets) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("secrets").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched secret.
+func (c *secrets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Secret, err error) {
+	result = &v1.Secret{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("secrets").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/service.go

@@ -0,0 +1,165 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// ServicesGetter has a method to return a ServiceInterface.
+// A group's client should implement this interface.
+type ServicesGetter interface {
+	Services(namespace string) ServiceInterface
+}
+
+// ServiceInterface has methods to work with Service resources.
+type ServiceInterface interface {
+	Create(*v1.Service) (*v1.Service, error)
+	Update(*v1.Service) (*v1.Service, error)
+	UpdateStatus(*v1.Service) (*v1.Service, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Service, error)
+	List(opts api.ListOptions) (*v1.ServiceList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Service, err error)
+	ServiceExpansion
+}
+
+// services implements ServiceInterface
+type services struct {
+	client *CoreClient
+	ns     string
+}
+
+// newServices returns a Services
+func newServices(c *CoreClient, namespace string) *services {
+	return &services{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a service and creates it.  Returns the server's representation of the service, and an error, if there is any.
+func (c *services) Create(service *v1.Service) (result *v1.Service, err error) {
+	result = &v1.Service{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("services").
+		Body(service).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a service and updates it. Returns the server's representation of the service, and an error, if there is any.
+func (c *services) Update(service *v1.Service) (result *v1.Service, err error) {
+	result = &v1.Service{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("services").
+		Name(service.Name).
+		Body(service).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *services) UpdateStatus(service *v1.Service) (result *v1.Service, err error) {
+	result = &v1.Service{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("services").
+		Name(service.Name).
+		SubResource("status").
+		Body(service).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the service and deletes it. Returns an error if one occurs.
+func (c *services) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("services").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *services) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("services").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the service, and returns the corresponding service object, and an error if there is any.
+func (c *services) Get(name string) (result *v1.Service, err error) {
+	result = &v1.Service{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("services").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Services that match those selectors.
+func (c *services) List(opts api.ListOptions) (result *v1.ServiceList, err error) {
+	result = &v1.ServiceList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("services").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested services.
+func (c *services) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("services").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched service.
+func (c *services) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Service, err error) {
+	result = &v1.Service{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("services").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/core/v1/serviceaccount.go

@@ -0,0 +1,151 @@
+/*
+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 v1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1 "k8s.io/client-go/1.4/pkg/api/v1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// ServiceAccountsGetter has a method to return a ServiceAccountInterface.
+// A group's client should implement this interface.
+type ServiceAccountsGetter interface {
+	ServiceAccounts(namespace string) ServiceAccountInterface
+}
+
+// ServiceAccountInterface has methods to work with ServiceAccount resources.
+type ServiceAccountInterface interface {
+	Create(*v1.ServiceAccount) (*v1.ServiceAccount, error)
+	Update(*v1.ServiceAccount) (*v1.ServiceAccount, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.ServiceAccount, error)
+	List(opts api.ListOptions) (*v1.ServiceAccountList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ServiceAccount, err error)
+	ServiceAccountExpansion
+}
+
+// serviceAccounts implements ServiceAccountInterface
+type serviceAccounts struct {
+	client *CoreClient
+	ns     string
+}
+
+// newServiceAccounts returns a ServiceAccounts
+func newServiceAccounts(c *CoreClient, namespace string) *serviceAccounts {
+	return &serviceAccounts{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a serviceAccount and creates it.  Returns the server's representation of the serviceAccount, and an error, if there is any.
+func (c *serviceAccounts) Create(serviceAccount *v1.ServiceAccount) (result *v1.ServiceAccount, err error) {
+	result = &v1.ServiceAccount{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("serviceaccounts").
+		Body(serviceAccount).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a serviceAccount and updates it. Returns the server's representation of the serviceAccount, and an error, if there is any.
+func (c *serviceAccounts) Update(serviceAccount *v1.ServiceAccount) (result *v1.ServiceAccount, err error) {
+	result = &v1.ServiceAccount{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("serviceaccounts").
+		Name(serviceAccount.Name).
+		Body(serviceAccount).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the serviceAccount and deletes it. Returns an error if one occurs.
+func (c *serviceAccounts) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("serviceaccounts").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *serviceAccounts) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("serviceaccounts").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the serviceAccount, and returns the corresponding serviceAccount object, and an error if there is any.
+func (c *serviceAccounts) Get(name string) (result *v1.ServiceAccount, err error) {
+	result = &v1.ServiceAccount{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("serviceaccounts").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of ServiceAccounts that match those selectors.
+func (c *serviceAccounts) List(opts api.ListOptions) (result *v1.ServiceAccountList, err error) {
+	result = &v1.ServiceAccountList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("serviceaccounts").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested serviceAccounts.
+func (c *serviceAccounts) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("serviceaccounts").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched serviceAccount.
+func (c *serviceAccounts) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ServiceAccount, err error) {
+	result = &v1.ServiceAccount{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("serviceaccounts").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/daemonset.go

@@ -0,0 +1,165 @@
+/*
+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 v1beta1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// DaemonSetsGetter has a method to return a DaemonSetInterface.
+// A group's client should implement this interface.
+type DaemonSetsGetter interface {
+	DaemonSets(namespace string) DaemonSetInterface
+}
+
+// DaemonSetInterface has methods to work with DaemonSet resources.
+type DaemonSetInterface interface {
+	Create(*v1beta1.DaemonSet) (*v1beta1.DaemonSet, error)
+	Update(*v1beta1.DaemonSet) (*v1beta1.DaemonSet, error)
+	UpdateStatus(*v1beta1.DaemonSet) (*v1beta1.DaemonSet, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1beta1.DaemonSet, error)
+	List(opts api.ListOptions) (*v1beta1.DaemonSetList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.DaemonSet, err error)
+	DaemonSetExpansion
+}
+
+// daemonSets implements DaemonSetInterface
+type daemonSets struct {
+	client *ExtensionsClient
+	ns     string
+}
+
+// newDaemonSets returns a DaemonSets
+func newDaemonSets(c *ExtensionsClient, namespace string) *daemonSets {
+	return &daemonSets{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a daemonSet and creates it.  Returns the server's representation of the daemonSet, and an error, if there is any.
+func (c *daemonSets) Create(daemonSet *v1beta1.DaemonSet) (result *v1beta1.DaemonSet, err error) {
+	result = &v1beta1.DaemonSet{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("daemonsets").
+		Body(daemonSet).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a daemonSet and updates it. Returns the server's representation of the daemonSet, and an error, if there is any.
+func (c *daemonSets) Update(daemonSet *v1beta1.DaemonSet) (result *v1beta1.DaemonSet, err error) {
+	result = &v1beta1.DaemonSet{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("daemonsets").
+		Name(daemonSet.Name).
+		Body(daemonSet).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *daemonSets) UpdateStatus(daemonSet *v1beta1.DaemonSet) (result *v1beta1.DaemonSet, err error) {
+	result = &v1beta1.DaemonSet{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("daemonsets").
+		Name(daemonSet.Name).
+		SubResource("status").
+		Body(daemonSet).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the daemonSet and deletes it. Returns an error if one occurs.
+func (c *daemonSets) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("daemonsets").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *daemonSets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("daemonsets").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the daemonSet, and returns the corresponding daemonSet object, and an error if there is any.
+func (c *daemonSets) Get(name string) (result *v1beta1.DaemonSet, err error) {
+	result = &v1beta1.DaemonSet{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("daemonsets").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of DaemonSets that match those selectors.
+func (c *daemonSets) List(opts api.ListOptions) (result *v1beta1.DaemonSetList, err error) {
+	result = &v1beta1.DaemonSetList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("daemonsets").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested daemonSets.
+func (c *daemonSets) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("daemonsets").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched daemonSet.
+func (c *daemonSets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.DaemonSet, err error) {
+	result = &v1beta1.DaemonSet{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("daemonsets").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/deployment.go

@@ -0,0 +1,165 @@
+/*
+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 v1beta1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// DeploymentsGetter has a method to return a DeploymentInterface.
+// A group's client should implement this interface.
+type DeploymentsGetter interface {
+	Deployments(namespace string) DeploymentInterface
+}
+
+// DeploymentInterface has methods to work with Deployment resources.
+type DeploymentInterface interface {
+	Create(*v1beta1.Deployment) (*v1beta1.Deployment, error)
+	Update(*v1beta1.Deployment) (*v1beta1.Deployment, error)
+	UpdateStatus(*v1beta1.Deployment) (*v1beta1.Deployment, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1beta1.Deployment, error)
+	List(opts api.ListOptions) (*v1beta1.DeploymentList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.Deployment, err error)
+	DeploymentExpansion
+}
+
+// deployments implements DeploymentInterface
+type deployments struct {
+	client *ExtensionsClient
+	ns     string
+}
+
+// newDeployments returns a Deployments
+func newDeployments(c *ExtensionsClient, namespace string) *deployments {
+	return &deployments{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a deployment and creates it.  Returns the server's representation of the deployment, and an error, if there is any.
+func (c *deployments) Create(deployment *v1beta1.Deployment) (result *v1beta1.Deployment, err error) {
+	result = &v1beta1.Deployment{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("deployments").
+		Body(deployment).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a deployment and updates it. Returns the server's representation of the deployment, and an error, if there is any.
+func (c *deployments) Update(deployment *v1beta1.Deployment) (result *v1beta1.Deployment, err error) {
+	result = &v1beta1.Deployment{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("deployments").
+		Name(deployment.Name).
+		Body(deployment).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *deployments) UpdateStatus(deployment *v1beta1.Deployment) (result *v1beta1.Deployment, err error) {
+	result = &v1beta1.Deployment{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("deployments").
+		Name(deployment.Name).
+		SubResource("status").
+		Body(deployment).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the deployment and deletes it. Returns an error if one occurs.
+func (c *deployments) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("deployments").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *deployments) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("deployments").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the deployment, and returns the corresponding deployment object, and an error if there is any.
+func (c *deployments) Get(name string) (result *v1beta1.Deployment, err error) {
+	result = &v1beta1.Deployment{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("deployments").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Deployments that match those selectors.
+func (c *deployments) List(opts api.ListOptions) (result *v1beta1.DeploymentList, err error) {
+	result = &v1beta1.DeploymentList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("deployments").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested deployments.
+func (c *deployments) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("deployments").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched deployment.
+func (c *deployments) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.Deployment, err error) {
+	result = &v1beta1.Deployment{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("deployments").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// This package has the automatically generated typed clients.
+package v1beta1

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/extensions_client.go

@@ -0,0 +1,141 @@
+/*
+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 v1beta1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	registered "k8s.io/client-go/1.4/pkg/apimachinery/registered"
+	serializer "k8s.io/client-go/1.4/pkg/runtime/serializer"
+	rest "k8s.io/client-go/1.4/rest"
+)
+
+type ExtensionsInterface interface {
+	GetRESTClient() *rest.RESTClient
+	DaemonSetsGetter
+	DeploymentsGetter
+	HorizontalPodAutoscalersGetter
+	IngressesGetter
+	JobsGetter
+	PodSecurityPoliciesGetter
+	ReplicaSetsGetter
+	ScalesGetter
+	StorageClassesGetter
+	ThirdPartyResourcesGetter
+}
+
+// ExtensionsClient is used to interact with features provided by the Extensions group.
+type ExtensionsClient struct {
+	*rest.RESTClient
+}
+
+func (c *ExtensionsClient) DaemonSets(namespace string) DaemonSetInterface {
+	return newDaemonSets(c, namespace)
+}
+
+func (c *ExtensionsClient) Deployments(namespace string) DeploymentInterface {
+	return newDeployments(c, namespace)
+}
+
+func (c *ExtensionsClient) HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface {
+	return newHorizontalPodAutoscalers(c, namespace)
+}
+
+func (c *ExtensionsClient) Ingresses(namespace string) IngressInterface {
+	return newIngresses(c, namespace)
+}
+
+func (c *ExtensionsClient) Jobs(namespace string) JobInterface {
+	return newJobs(c, namespace)
+}
+
+func (c *ExtensionsClient) PodSecurityPolicies() PodSecurityPolicyInterface {
+	return newPodSecurityPolicies(c)
+}
+
+func (c *ExtensionsClient) ReplicaSets(namespace string) ReplicaSetInterface {
+	return newReplicaSets(c, namespace)
+}
+
+func (c *ExtensionsClient) Scales(namespace string) ScaleInterface {
+	return newScales(c, namespace)
+}
+
+func (c *ExtensionsClient) StorageClasses() StorageClassInterface {
+	return newStorageClasses(c)
+}
+
+func (c *ExtensionsClient) ThirdPartyResources() ThirdPartyResourceInterface {
+	return newThirdPartyResources(c)
+}
+
+// NewForConfig creates a new ExtensionsClient for the given config.
+func NewForConfig(c *rest.Config) (*ExtensionsClient, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.RESTClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return &ExtensionsClient{client}, nil
+}
+
+// NewForConfigOrDie creates a new ExtensionsClient for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *ExtensionsClient {
+	client, err := NewForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+// New creates a new ExtensionsClient for the given RESTClient.
+func New(c *rest.RESTClient) *ExtensionsClient {
+	return &ExtensionsClient{c}
+}
+
+func setConfigDefaults(config *rest.Config) error {
+	// if extensions group is not registered, return an error
+	g, err := registered.Group("extensions")
+	if err != nil {
+		return err
+	}
+	config.APIPath = "/apis"
+	if config.UserAgent == "" {
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+	// TODO: Unconditionally set the config.Version, until we fix the config.
+	//if config.Version == "" {
+	copyGroupVersion := g.GroupVersion
+	config.GroupVersion = &copyGroupVersion
+	//}
+
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}
+
+	return nil
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *ExtensionsClient) GetRESTClient() *rest.RESTClient {
+	if c == nil {
+		return nil
+	}
+	return c.RESTClient
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/doc.go

@@ -0,0 +1,20 @@
+/*
+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.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_4 --input=[api/v1,authorization/v1beta1,autoscaling/v1,batch/v1,extensions/v1beta1]
+
+// Package fake has the automatically generated clients.
+package fake

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/fake_daemonset.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeDaemonSets implements DaemonSetInterface
+type FakeDaemonSets struct {
+	Fake *FakeExtensions
+	ns   string
+}
+
+var daemonsetsResource = unversioned.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "daemonsets"}
+
+func (c *FakeDaemonSets) Create(daemonSet *v1beta1.DaemonSet) (result *v1beta1.DaemonSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(daemonsetsResource, c.ns, daemonSet), &v1beta1.DaemonSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.DaemonSet), err
+}
+
+func (c *FakeDaemonSets) Update(daemonSet *v1beta1.DaemonSet) (result *v1beta1.DaemonSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(daemonsetsResource, c.ns, daemonSet), &v1beta1.DaemonSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.DaemonSet), err
+}
+
+func (c *FakeDaemonSets) UpdateStatus(daemonSet *v1beta1.DaemonSet) (*v1beta1.DaemonSet, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(daemonsetsResource, "status", c.ns, daemonSet), &v1beta1.DaemonSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.DaemonSet), err
+}
+
+func (c *FakeDaemonSets) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(daemonsetsResource, c.ns, name), &v1beta1.DaemonSet{})
+
+	return err
+}
+
+func (c *FakeDaemonSets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(daemonsetsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1beta1.DaemonSetList{})
+	return err
+}
+
+func (c *FakeDaemonSets) Get(name string) (result *v1beta1.DaemonSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(daemonsetsResource, c.ns, name), &v1beta1.DaemonSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.DaemonSet), err
+}
+
+func (c *FakeDaemonSets) List(opts api.ListOptions) (result *v1beta1.DaemonSetList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(daemonsetsResource, c.ns, opts), &v1beta1.DaemonSetList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1beta1.DaemonSetList{}
+	for _, item := range obj.(*v1beta1.DaemonSetList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested daemonSets.
+func (c *FakeDaemonSets) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(daemonsetsResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched daemonSet.
+func (c *FakeDaemonSets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.DaemonSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(daemonsetsResource, c.ns, name, data, subresources...), &v1beta1.DaemonSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.DaemonSet), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/fake_deployment.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeDeployments implements DeploymentInterface
+type FakeDeployments struct {
+	Fake *FakeExtensions
+	ns   string
+}
+
+var deploymentsResource = unversioned.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "deployments"}
+
+func (c *FakeDeployments) Create(deployment *v1beta1.Deployment) (result *v1beta1.Deployment, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(deploymentsResource, c.ns, deployment), &v1beta1.Deployment{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Deployment), err
+}
+
+func (c *FakeDeployments) Update(deployment *v1beta1.Deployment) (result *v1beta1.Deployment, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(deploymentsResource, c.ns, deployment), &v1beta1.Deployment{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Deployment), err
+}
+
+func (c *FakeDeployments) UpdateStatus(deployment *v1beta1.Deployment) (*v1beta1.Deployment, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(deploymentsResource, "status", c.ns, deployment), &v1beta1.Deployment{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Deployment), err
+}
+
+func (c *FakeDeployments) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(deploymentsResource, c.ns, name), &v1beta1.Deployment{})
+
+	return err
+}
+
+func (c *FakeDeployments) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(deploymentsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1beta1.DeploymentList{})
+	return err
+}
+
+func (c *FakeDeployments) Get(name string) (result *v1beta1.Deployment, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(deploymentsResource, c.ns, name), &v1beta1.Deployment{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Deployment), err
+}
+
+func (c *FakeDeployments) List(opts api.ListOptions) (result *v1beta1.DeploymentList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(deploymentsResource, c.ns, opts), &v1beta1.DeploymentList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1beta1.DeploymentList{}
+	for _, item := range obj.(*v1beta1.DeploymentList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested deployments.
+func (c *FakeDeployments) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(deploymentsResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched deployment.
+func (c *FakeDeployments) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.Deployment, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(deploymentsResource, c.ns, name, data, subresources...), &v1beta1.Deployment{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Deployment), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/fake_extensions_client.go

@@ -0,0 +1,73 @@
+/*
+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 fake
+
+import (
+	v1beta1 "k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1"
+	rest "k8s.io/client-go/1.4/rest"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+type FakeExtensions struct {
+	*testing.Fake
+}
+
+func (c *FakeExtensions) DaemonSets(namespace string) v1beta1.DaemonSetInterface {
+	return &FakeDaemonSets{c, namespace}
+}
+
+func (c *FakeExtensions) Deployments(namespace string) v1beta1.DeploymentInterface {
+	return &FakeDeployments{c, namespace}
+}
+
+func (c *FakeExtensions) HorizontalPodAutoscalers(namespace string) v1beta1.HorizontalPodAutoscalerInterface {
+	return &FakeHorizontalPodAutoscalers{c, namespace}
+}
+
+func (c *FakeExtensions) Ingresses(namespace string) v1beta1.IngressInterface {
+	return &FakeIngresses{c, namespace}
+}
+
+func (c *FakeExtensions) Jobs(namespace string) v1beta1.JobInterface {
+	return &FakeJobs{c, namespace}
+}
+
+func (c *FakeExtensions) PodSecurityPolicies() v1beta1.PodSecurityPolicyInterface {
+	return &FakePodSecurityPolicies{c}
+}
+
+func (c *FakeExtensions) ReplicaSets(namespace string) v1beta1.ReplicaSetInterface {
+	return &FakeReplicaSets{c, namespace}
+}
+
+func (c *FakeExtensions) Scales(namespace string) v1beta1.ScaleInterface {
+	return &FakeScales{c, namespace}
+}
+
+func (c *FakeExtensions) StorageClasses() v1beta1.StorageClassInterface {
+	return &FakeStorageClasses{c}
+}
+
+func (c *FakeExtensions) ThirdPartyResources() v1beta1.ThirdPartyResourceInterface {
+	return &FakeThirdPartyResources{c}
+}
+
+// GetRESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeExtensions) GetRESTClient() *rest.RESTClient {
+	return nil
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/fake_horizontalpodautoscaler.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeHorizontalPodAutoscalers implements HorizontalPodAutoscalerInterface
+type FakeHorizontalPodAutoscalers struct {
+	Fake *FakeExtensions
+	ns   string
+}
+
+var horizontalpodautoscalersResource = unversioned.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "horizontalpodautoscalers"}
+
+func (c *FakeHorizontalPodAutoscalers) Create(horizontalPodAutoscaler *v1beta1.HorizontalPodAutoscaler) (result *v1beta1.HorizontalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(horizontalpodautoscalersResource, c.ns, horizontalPodAutoscaler), &v1beta1.HorizontalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.HorizontalPodAutoscaler), err
+}
+
+func (c *FakeHorizontalPodAutoscalers) Update(horizontalPodAutoscaler *v1beta1.HorizontalPodAutoscaler) (result *v1beta1.HorizontalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(horizontalpodautoscalersResource, c.ns, horizontalPodAutoscaler), &v1beta1.HorizontalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.HorizontalPodAutoscaler), err
+}
+
+func (c *FakeHorizontalPodAutoscalers) UpdateStatus(horizontalPodAutoscaler *v1beta1.HorizontalPodAutoscaler) (*v1beta1.HorizontalPodAutoscaler, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(horizontalpodautoscalersResource, "status", c.ns, horizontalPodAutoscaler), &v1beta1.HorizontalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.HorizontalPodAutoscaler), err
+}
+
+func (c *FakeHorizontalPodAutoscalers) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(horizontalpodautoscalersResource, c.ns, name), &v1beta1.HorizontalPodAutoscaler{})
+
+	return err
+}
+
+func (c *FakeHorizontalPodAutoscalers) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(horizontalpodautoscalersResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1beta1.HorizontalPodAutoscalerList{})
+	return err
+}
+
+func (c *FakeHorizontalPodAutoscalers) Get(name string) (result *v1beta1.HorizontalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(horizontalpodautoscalersResource, c.ns, name), &v1beta1.HorizontalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.HorizontalPodAutoscaler), err
+}
+
+func (c *FakeHorizontalPodAutoscalers) List(opts api.ListOptions) (result *v1beta1.HorizontalPodAutoscalerList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(horizontalpodautoscalersResource, c.ns, opts), &v1beta1.HorizontalPodAutoscalerList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1beta1.HorizontalPodAutoscalerList{}
+	for _, item := range obj.(*v1beta1.HorizontalPodAutoscalerList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested horizontalPodAutoscalers.
+func (c *FakeHorizontalPodAutoscalers) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(horizontalpodautoscalersResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched horizontalPodAutoscaler.
+func (c *FakeHorizontalPodAutoscalers) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.HorizontalPodAutoscaler, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(horizontalpodautoscalersResource, c.ns, name, data, subresources...), &v1beta1.HorizontalPodAutoscaler{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.HorizontalPodAutoscaler), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/fake_ingress.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeIngresses implements IngressInterface
+type FakeIngresses struct {
+	Fake *FakeExtensions
+	ns   string
+}
+
+var ingressesResource = unversioned.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "ingresses"}
+
+func (c *FakeIngresses) Create(ingress *v1beta1.Ingress) (result *v1beta1.Ingress, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(ingressesResource, c.ns, ingress), &v1beta1.Ingress{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Ingress), err
+}
+
+func (c *FakeIngresses) Update(ingress *v1beta1.Ingress) (result *v1beta1.Ingress, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(ingressesResource, c.ns, ingress), &v1beta1.Ingress{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Ingress), err
+}
+
+func (c *FakeIngresses) UpdateStatus(ingress *v1beta1.Ingress) (*v1beta1.Ingress, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(ingressesResource, "status", c.ns, ingress), &v1beta1.Ingress{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Ingress), err
+}
+
+func (c *FakeIngresses) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(ingressesResource, c.ns, name), &v1beta1.Ingress{})
+
+	return err
+}
+
+func (c *FakeIngresses) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(ingressesResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1beta1.IngressList{})
+	return err
+}
+
+func (c *FakeIngresses) Get(name string) (result *v1beta1.Ingress, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(ingressesResource, c.ns, name), &v1beta1.Ingress{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Ingress), err
+}
+
+func (c *FakeIngresses) List(opts api.ListOptions) (result *v1beta1.IngressList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(ingressesResource, c.ns, opts), &v1beta1.IngressList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1beta1.IngressList{}
+	for _, item := range obj.(*v1beta1.IngressList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested ingresses.
+func (c *FakeIngresses) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(ingressesResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched ingress.
+func (c *FakeIngresses) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.Ingress, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(ingressesResource, c.ns, name, data, subresources...), &v1beta1.Ingress{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Ingress), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/fake_job.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeJobs implements JobInterface
+type FakeJobs struct {
+	Fake *FakeExtensions
+	ns   string
+}
+
+var jobsResource = unversioned.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "jobs"}
+
+func (c *FakeJobs) Create(job *v1beta1.Job) (result *v1beta1.Job, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(jobsResource, c.ns, job), &v1beta1.Job{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Job), err
+}
+
+func (c *FakeJobs) Update(job *v1beta1.Job) (result *v1beta1.Job, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(jobsResource, c.ns, job), &v1beta1.Job{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Job), err
+}
+
+func (c *FakeJobs) UpdateStatus(job *v1beta1.Job) (*v1beta1.Job, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(jobsResource, "status", c.ns, job), &v1beta1.Job{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Job), err
+}
+
+func (c *FakeJobs) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(jobsResource, c.ns, name), &v1beta1.Job{})
+
+	return err
+}
+
+func (c *FakeJobs) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(jobsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1beta1.JobList{})
+	return err
+}
+
+func (c *FakeJobs) Get(name string) (result *v1beta1.Job, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(jobsResource, c.ns, name), &v1beta1.Job{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Job), err
+}
+
+func (c *FakeJobs) List(opts api.ListOptions) (result *v1beta1.JobList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(jobsResource, c.ns, opts), &v1beta1.JobList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1beta1.JobList{}
+	for _, item := range obj.(*v1beta1.JobList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested jobs.
+func (c *FakeJobs) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(jobsResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched job.
+func (c *FakeJobs) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.Job, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(jobsResource, c.ns, name, data, subresources...), &v1beta1.Job{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.Job), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/fake_podsecuritypolicy.go

@@ -0,0 +1,109 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakePodSecurityPolicies implements PodSecurityPolicyInterface
+type FakePodSecurityPolicies struct {
+	Fake *FakeExtensions
+}
+
+var podsecuritypoliciesResource = unversioned.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "podsecuritypolicies"}
+
+func (c *FakePodSecurityPolicies) Create(podSecurityPolicy *v1beta1.PodSecurityPolicy) (result *v1beta1.PodSecurityPolicy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(podsecuritypoliciesResource, podSecurityPolicy), &v1beta1.PodSecurityPolicy{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.PodSecurityPolicy), err
+}
+
+func (c *FakePodSecurityPolicies) Update(podSecurityPolicy *v1beta1.PodSecurityPolicy) (result *v1beta1.PodSecurityPolicy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(podsecuritypoliciesResource, podSecurityPolicy), &v1beta1.PodSecurityPolicy{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.PodSecurityPolicy), err
+}
+
+func (c *FakePodSecurityPolicies) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(podsecuritypoliciesResource, name), &v1beta1.PodSecurityPolicy{})
+	return err
+}
+
+func (c *FakePodSecurityPolicies) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(podsecuritypoliciesResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1beta1.PodSecurityPolicyList{})
+	return err
+}
+
+func (c *FakePodSecurityPolicies) Get(name string) (result *v1beta1.PodSecurityPolicy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(podsecuritypoliciesResource, name), &v1beta1.PodSecurityPolicy{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.PodSecurityPolicy), err
+}
+
+func (c *FakePodSecurityPolicies) List(opts api.ListOptions) (result *v1beta1.PodSecurityPolicyList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(podsecuritypoliciesResource, opts), &v1beta1.PodSecurityPolicyList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1beta1.PodSecurityPolicyList{}
+	for _, item := range obj.(*v1beta1.PodSecurityPolicyList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested podSecurityPolicies.
+func (c *FakePodSecurityPolicies) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(podsecuritypoliciesResource, opts))
+}
+
+// Patch applies the patch and returns the patched podSecurityPolicy.
+func (c *FakePodSecurityPolicies) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.PodSecurityPolicy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(podsecuritypoliciesResource, name, data, subresources...), &v1beta1.PodSecurityPolicy{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.PodSecurityPolicy), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/fake_replicaset.go

@@ -0,0 +1,127 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeReplicaSets implements ReplicaSetInterface
+type FakeReplicaSets struct {
+	Fake *FakeExtensions
+	ns   string
+}
+
+var replicasetsResource = unversioned.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "replicasets"}
+
+func (c *FakeReplicaSets) Create(replicaSet *v1beta1.ReplicaSet) (result *v1beta1.ReplicaSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(replicasetsResource, c.ns, replicaSet), &v1beta1.ReplicaSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.ReplicaSet), err
+}
+
+func (c *FakeReplicaSets) Update(replicaSet *v1beta1.ReplicaSet) (result *v1beta1.ReplicaSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(replicasetsResource, c.ns, replicaSet), &v1beta1.ReplicaSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.ReplicaSet), err
+}
+
+func (c *FakeReplicaSets) UpdateStatus(replicaSet *v1beta1.ReplicaSet) (*v1beta1.ReplicaSet, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(replicasetsResource, "status", c.ns, replicaSet), &v1beta1.ReplicaSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.ReplicaSet), err
+}
+
+func (c *FakeReplicaSets) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(replicasetsResource, c.ns, name), &v1beta1.ReplicaSet{})
+
+	return err
+}
+
+func (c *FakeReplicaSets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(replicasetsResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1beta1.ReplicaSetList{})
+	return err
+}
+
+func (c *FakeReplicaSets) Get(name string) (result *v1beta1.ReplicaSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(replicasetsResource, c.ns, name), &v1beta1.ReplicaSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.ReplicaSet), err
+}
+
+func (c *FakeReplicaSets) List(opts api.ListOptions) (result *v1beta1.ReplicaSetList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(replicasetsResource, c.ns, opts), &v1beta1.ReplicaSetList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1beta1.ReplicaSetList{}
+	for _, item := range obj.(*v1beta1.ReplicaSetList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested replicaSets.
+func (c *FakeReplicaSets) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(replicasetsResource, c.ns, opts))
+
+}
+
+// Patch applies the patch and returns the patched replicaSet.
+func (c *FakeReplicaSets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.ReplicaSet, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(replicasetsResource, c.ns, name, data, subresources...), &v1beta1.ReplicaSet{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.ReplicaSet), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/fake_scale.go

@@ -0,0 +1,23 @@
+/*
+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 fake
+
+// FakeScales implements ScaleInterface
+type FakeScales struct {
+	Fake *FakeExtensions
+	ns   string
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/fake_storageclass.go

@@ -0,0 +1,109 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeStorageClasses implements StorageClassInterface
+type FakeStorageClasses struct {
+	Fake *FakeExtensions
+}
+
+var storageclassesResource = unversioned.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "storageclasses"}
+
+func (c *FakeStorageClasses) Create(storageClass *v1beta1.StorageClass) (result *v1beta1.StorageClass, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(storageclassesResource, storageClass), &v1beta1.StorageClass{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.StorageClass), err
+}
+
+func (c *FakeStorageClasses) Update(storageClass *v1beta1.StorageClass) (result *v1beta1.StorageClass, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(storageclassesResource, storageClass), &v1beta1.StorageClass{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.StorageClass), err
+}
+
+func (c *FakeStorageClasses) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(storageclassesResource, name), &v1beta1.StorageClass{})
+	return err
+}
+
+func (c *FakeStorageClasses) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(storageclassesResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1beta1.StorageClassList{})
+	return err
+}
+
+func (c *FakeStorageClasses) Get(name string) (result *v1beta1.StorageClass, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(storageclassesResource, name), &v1beta1.StorageClass{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.StorageClass), err
+}
+
+func (c *FakeStorageClasses) List(opts api.ListOptions) (result *v1beta1.StorageClassList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(storageclassesResource, opts), &v1beta1.StorageClassList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1beta1.StorageClassList{}
+	for _, item := range obj.(*v1beta1.StorageClassList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested storageClasses.
+func (c *FakeStorageClasses) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(storageclassesResource, opts))
+}
+
+// Patch applies the patch and returns the patched storageClass.
+func (c *FakeStorageClasses) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.StorageClass, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(storageclassesResource, name, data, subresources...), &v1beta1.StorageClass{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.StorageClass), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/fake/fake_thirdpartyresource.go

@@ -0,0 +1,109 @@
+/*
+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 fake
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	unversioned "k8s.io/client-go/1.4/pkg/api/unversioned"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	labels "k8s.io/client-go/1.4/pkg/labels"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+	testing "k8s.io/client-go/1.4/testing"
+)
+
+// FakeThirdPartyResources implements ThirdPartyResourceInterface
+type FakeThirdPartyResources struct {
+	Fake *FakeExtensions
+}
+
+var thirdpartyresourcesResource = unversioned.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "thirdpartyresources"}
+
+func (c *FakeThirdPartyResources) Create(thirdPartyResource *v1beta1.ThirdPartyResource) (result *v1beta1.ThirdPartyResource, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(thirdpartyresourcesResource, thirdPartyResource), &v1beta1.ThirdPartyResource{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.ThirdPartyResource), err
+}
+
+func (c *FakeThirdPartyResources) Update(thirdPartyResource *v1beta1.ThirdPartyResource) (result *v1beta1.ThirdPartyResource, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(thirdpartyresourcesResource, thirdPartyResource), &v1beta1.ThirdPartyResource{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.ThirdPartyResource), err
+}
+
+func (c *FakeThirdPartyResources) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(thirdpartyresourcesResource, name), &v1beta1.ThirdPartyResource{})
+	return err
+}
+
+func (c *FakeThirdPartyResources) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(thirdpartyresourcesResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1beta1.ThirdPartyResourceList{})
+	return err
+}
+
+func (c *FakeThirdPartyResources) Get(name string) (result *v1beta1.ThirdPartyResource, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(thirdpartyresourcesResource, name), &v1beta1.ThirdPartyResource{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.ThirdPartyResource), err
+}
+
+func (c *FakeThirdPartyResources) List(opts api.ListOptions) (result *v1beta1.ThirdPartyResourceList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(thirdpartyresourcesResource, opts), &v1beta1.ThirdPartyResourceList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1beta1.ThirdPartyResourceList{}
+	for _, item := range obj.(*v1beta1.ThirdPartyResourceList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested thirdPartyResources.
+func (c *FakeThirdPartyResources) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(thirdpartyresourcesResource, opts))
+}
+
+// Patch applies the patch and returns the patched thirdPartyResource.
+func (c *FakeThirdPartyResources) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.ThirdPartyResource, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(thirdpartyresourcesResource, name, data, subresources...), &v1beta1.ThirdPartyResource{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.ThirdPartyResource), err
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/generated_expansion.go

@@ -0,0 +1,37 @@
+/*
+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 v1beta1
+
+type DaemonSetExpansion interface{}
+
+type DeploymentExpansion interface{}
+
+type HorizontalPodAutoscalerExpansion interface{}
+
+type IngressExpansion interface{}
+
+type JobExpansion interface{}
+
+type PodSecurityPolicyExpansion interface{}
+
+type ReplicaSetExpansion interface{}
+
+type ScaleExpansion interface{}
+
+type ThirdPartyResourceExpansion interface{}
+
+type StorageClassExpansion interface{}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/horizontalpodautoscaler.go

@@ -0,0 +1,165 @@
+/*
+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 v1beta1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// HorizontalPodAutoscalersGetter has a method to return a HorizontalPodAutoscalerInterface.
+// A group's client should implement this interface.
+type HorizontalPodAutoscalersGetter interface {
+	HorizontalPodAutoscalers(namespace string) HorizontalPodAutoscalerInterface
+}
+
+// HorizontalPodAutoscalerInterface has methods to work with HorizontalPodAutoscaler resources.
+type HorizontalPodAutoscalerInterface interface {
+	Create(*v1beta1.HorizontalPodAutoscaler) (*v1beta1.HorizontalPodAutoscaler, error)
+	Update(*v1beta1.HorizontalPodAutoscaler) (*v1beta1.HorizontalPodAutoscaler, error)
+	UpdateStatus(*v1beta1.HorizontalPodAutoscaler) (*v1beta1.HorizontalPodAutoscaler, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1beta1.HorizontalPodAutoscaler, error)
+	List(opts api.ListOptions) (*v1beta1.HorizontalPodAutoscalerList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.HorizontalPodAutoscaler, err error)
+	HorizontalPodAutoscalerExpansion
+}
+
+// horizontalPodAutoscalers implements HorizontalPodAutoscalerInterface
+type horizontalPodAutoscalers struct {
+	client *ExtensionsClient
+	ns     string
+}
+
+// newHorizontalPodAutoscalers returns a HorizontalPodAutoscalers
+func newHorizontalPodAutoscalers(c *ExtensionsClient, namespace string) *horizontalPodAutoscalers {
+	return &horizontalPodAutoscalers{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a horizontalPodAutoscaler and creates it.  Returns the server's representation of the horizontalPodAutoscaler, and an error, if there is any.
+func (c *horizontalPodAutoscalers) Create(horizontalPodAutoscaler *v1beta1.HorizontalPodAutoscaler) (result *v1beta1.HorizontalPodAutoscaler, err error) {
+	result = &v1beta1.HorizontalPodAutoscaler{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		Body(horizontalPodAutoscaler).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a horizontalPodAutoscaler and updates it. Returns the server's representation of the horizontalPodAutoscaler, and an error, if there is any.
+func (c *horizontalPodAutoscalers) Update(horizontalPodAutoscaler *v1beta1.HorizontalPodAutoscaler) (result *v1beta1.HorizontalPodAutoscaler, err error) {
+	result = &v1beta1.HorizontalPodAutoscaler{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		Name(horizontalPodAutoscaler.Name).
+		Body(horizontalPodAutoscaler).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *horizontalPodAutoscalers) UpdateStatus(horizontalPodAutoscaler *v1beta1.HorizontalPodAutoscaler) (result *v1beta1.HorizontalPodAutoscaler, err error) {
+	result = &v1beta1.HorizontalPodAutoscaler{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		Name(horizontalPodAutoscaler.Name).
+		SubResource("status").
+		Body(horizontalPodAutoscaler).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the horizontalPodAutoscaler and deletes it. Returns an error if one occurs.
+func (c *horizontalPodAutoscalers) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *horizontalPodAutoscalers) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the horizontalPodAutoscaler, and returns the corresponding horizontalPodAutoscaler object, and an error if there is any.
+func (c *horizontalPodAutoscalers) Get(name string) (result *v1beta1.HorizontalPodAutoscaler, err error) {
+	result = &v1beta1.HorizontalPodAutoscaler{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of HorizontalPodAutoscalers that match those selectors.
+func (c *horizontalPodAutoscalers) List(opts api.ListOptions) (result *v1beta1.HorizontalPodAutoscalerList, err error) {
+	result = &v1beta1.HorizontalPodAutoscalerList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested horizontalPodAutoscalers.
+func (c *horizontalPodAutoscalers) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched horizontalPodAutoscaler.
+func (c *horizontalPodAutoscalers) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.HorizontalPodAutoscaler, err error) {
+	result = &v1beta1.HorizontalPodAutoscaler{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("horizontalpodautoscalers").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/ingress.go

@@ -0,0 +1,165 @@
+/*
+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 v1beta1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// IngressesGetter has a method to return a IngressInterface.
+// A group's client should implement this interface.
+type IngressesGetter interface {
+	Ingresses(namespace string) IngressInterface
+}
+
+// IngressInterface has methods to work with Ingress resources.
+type IngressInterface interface {
+	Create(*v1beta1.Ingress) (*v1beta1.Ingress, error)
+	Update(*v1beta1.Ingress) (*v1beta1.Ingress, error)
+	UpdateStatus(*v1beta1.Ingress) (*v1beta1.Ingress, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1beta1.Ingress, error)
+	List(opts api.ListOptions) (*v1beta1.IngressList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.Ingress, err error)
+	IngressExpansion
+}
+
+// ingresses implements IngressInterface
+type ingresses struct {
+	client *ExtensionsClient
+	ns     string
+}
+
+// newIngresses returns a Ingresses
+func newIngresses(c *ExtensionsClient, namespace string) *ingresses {
+	return &ingresses{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a ingress and creates it.  Returns the server's representation of the ingress, and an error, if there is any.
+func (c *ingresses) Create(ingress *v1beta1.Ingress) (result *v1beta1.Ingress, err error) {
+	result = &v1beta1.Ingress{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("ingresses").
+		Body(ingress).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a ingress and updates it. Returns the server's representation of the ingress, and an error, if there is any.
+func (c *ingresses) Update(ingress *v1beta1.Ingress) (result *v1beta1.Ingress, err error) {
+	result = &v1beta1.Ingress{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("ingresses").
+		Name(ingress.Name).
+		Body(ingress).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *ingresses) UpdateStatus(ingress *v1beta1.Ingress) (result *v1beta1.Ingress, err error) {
+	result = &v1beta1.Ingress{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("ingresses").
+		Name(ingress.Name).
+		SubResource("status").
+		Body(ingress).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the ingress and deletes it. Returns an error if one occurs.
+func (c *ingresses) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("ingresses").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *ingresses) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("ingresses").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the ingress, and returns the corresponding ingress object, and an error if there is any.
+func (c *ingresses) Get(name string) (result *v1beta1.Ingress, err error) {
+	result = &v1beta1.Ingress{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("ingresses").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Ingresses that match those selectors.
+func (c *ingresses) List(opts api.ListOptions) (result *v1beta1.IngressList, err error) {
+	result = &v1beta1.IngressList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("ingresses").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested ingresses.
+func (c *ingresses) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("ingresses").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched ingress.
+func (c *ingresses) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.Ingress, err error) {
+	result = &v1beta1.Ingress{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("ingresses").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/job.go

@@ -0,0 +1,165 @@
+/*
+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 v1beta1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// JobsGetter has a method to return a JobInterface.
+// A group's client should implement this interface.
+type JobsGetter interface {
+	Jobs(namespace string) JobInterface
+}
+
+// JobInterface has methods to work with Job resources.
+type JobInterface interface {
+	Create(*v1beta1.Job) (*v1beta1.Job, error)
+	Update(*v1beta1.Job) (*v1beta1.Job, error)
+	UpdateStatus(*v1beta1.Job) (*v1beta1.Job, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1beta1.Job, error)
+	List(opts api.ListOptions) (*v1beta1.JobList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.Job, err error)
+	JobExpansion
+}
+
+// jobs implements JobInterface
+type jobs struct {
+	client *ExtensionsClient
+	ns     string
+}
+
+// newJobs returns a Jobs
+func newJobs(c *ExtensionsClient, namespace string) *jobs {
+	return &jobs{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a job and creates it.  Returns the server's representation of the job, and an error, if there is any.
+func (c *jobs) Create(job *v1beta1.Job) (result *v1beta1.Job, err error) {
+	result = &v1beta1.Job{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("jobs").
+		Body(job).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a job and updates it. Returns the server's representation of the job, and an error, if there is any.
+func (c *jobs) Update(job *v1beta1.Job) (result *v1beta1.Job, err error) {
+	result = &v1beta1.Job{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("jobs").
+		Name(job.Name).
+		Body(job).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *jobs) UpdateStatus(job *v1beta1.Job) (result *v1beta1.Job, err error) {
+	result = &v1beta1.Job{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("jobs").
+		Name(job.Name).
+		SubResource("status").
+		Body(job).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the job and deletes it. Returns an error if one occurs.
+func (c *jobs) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("jobs").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *jobs) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("jobs").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the job, and returns the corresponding job object, and an error if there is any.
+func (c *jobs) Get(name string) (result *v1beta1.Job, err error) {
+	result = &v1beta1.Job{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("jobs").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of Jobs that match those selectors.
+func (c *jobs) List(opts api.ListOptions) (result *v1beta1.JobList, err error) {
+	result = &v1beta1.JobList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("jobs").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested jobs.
+func (c *jobs) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("jobs").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched job.
+func (c *jobs) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.Job, err error) {
+	result = &v1beta1.Job{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("jobs").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/podsecuritypolicy.go

@@ -0,0 +1,141 @@
+/*
+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 v1beta1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// PodSecurityPoliciesGetter has a method to return a PodSecurityPolicyInterface.
+// A group's client should implement this interface.
+type PodSecurityPoliciesGetter interface {
+	PodSecurityPolicies() PodSecurityPolicyInterface
+}
+
+// PodSecurityPolicyInterface has methods to work with PodSecurityPolicy resources.
+type PodSecurityPolicyInterface interface {
+	Create(*v1beta1.PodSecurityPolicy) (*v1beta1.PodSecurityPolicy, error)
+	Update(*v1beta1.PodSecurityPolicy) (*v1beta1.PodSecurityPolicy, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1beta1.PodSecurityPolicy, error)
+	List(opts api.ListOptions) (*v1beta1.PodSecurityPolicyList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.PodSecurityPolicy, err error)
+	PodSecurityPolicyExpansion
+}
+
+// podSecurityPolicies implements PodSecurityPolicyInterface
+type podSecurityPolicies struct {
+	client *ExtensionsClient
+}
+
+// newPodSecurityPolicies returns a PodSecurityPolicies
+func newPodSecurityPolicies(c *ExtensionsClient) *podSecurityPolicies {
+	return &podSecurityPolicies{
+		client: c,
+	}
+}
+
+// Create takes the representation of a podSecurityPolicy and creates it.  Returns the server's representation of the podSecurityPolicy, and an error, if there is any.
+func (c *podSecurityPolicies) Create(podSecurityPolicy *v1beta1.PodSecurityPolicy) (result *v1beta1.PodSecurityPolicy, err error) {
+	result = &v1beta1.PodSecurityPolicy{}
+	err = c.client.Post().
+		Resource("podsecuritypolicies").
+		Body(podSecurityPolicy).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a podSecurityPolicy and updates it. Returns the server's representation of the podSecurityPolicy, and an error, if there is any.
+func (c *podSecurityPolicies) Update(podSecurityPolicy *v1beta1.PodSecurityPolicy) (result *v1beta1.PodSecurityPolicy, err error) {
+	result = &v1beta1.PodSecurityPolicy{}
+	err = c.client.Put().
+		Resource("podsecuritypolicies").
+		Name(podSecurityPolicy.Name).
+		Body(podSecurityPolicy).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the podSecurityPolicy and deletes it. Returns an error if one occurs.
+func (c *podSecurityPolicies) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("podsecuritypolicies").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *podSecurityPolicies) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Resource("podsecuritypolicies").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the podSecurityPolicy, and returns the corresponding podSecurityPolicy object, and an error if there is any.
+func (c *podSecurityPolicies) Get(name string) (result *v1beta1.PodSecurityPolicy, err error) {
+	result = &v1beta1.PodSecurityPolicy{}
+	err = c.client.Get().
+		Resource("podsecuritypolicies").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of PodSecurityPolicies that match those selectors.
+func (c *podSecurityPolicies) List(opts api.ListOptions) (result *v1beta1.PodSecurityPolicyList, err error) {
+	result = &v1beta1.PodSecurityPolicyList{}
+	err = c.client.Get().
+		Resource("podsecuritypolicies").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested podSecurityPolicies.
+func (c *podSecurityPolicies) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Resource("podsecuritypolicies").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched podSecurityPolicy.
+func (c *podSecurityPolicies) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.PodSecurityPolicy, err error) {
+	result = &v1beta1.PodSecurityPolicy{}
+	err = c.client.Patch(pt).
+		Resource("podsecuritypolicies").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/replicaset.go

@@ -0,0 +1,165 @@
+/*
+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 v1beta1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// ReplicaSetsGetter has a method to return a ReplicaSetInterface.
+// A group's client should implement this interface.
+type ReplicaSetsGetter interface {
+	ReplicaSets(namespace string) ReplicaSetInterface
+}
+
+// ReplicaSetInterface has methods to work with ReplicaSet resources.
+type ReplicaSetInterface interface {
+	Create(*v1beta1.ReplicaSet) (*v1beta1.ReplicaSet, error)
+	Update(*v1beta1.ReplicaSet) (*v1beta1.ReplicaSet, error)
+	UpdateStatus(*v1beta1.ReplicaSet) (*v1beta1.ReplicaSet, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1beta1.ReplicaSet, error)
+	List(opts api.ListOptions) (*v1beta1.ReplicaSetList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.ReplicaSet, err error)
+	ReplicaSetExpansion
+}
+
+// replicaSets implements ReplicaSetInterface
+type replicaSets struct {
+	client *ExtensionsClient
+	ns     string
+}
+
+// newReplicaSets returns a ReplicaSets
+func newReplicaSets(c *ExtensionsClient, namespace string) *replicaSets {
+	return &replicaSets{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a replicaSet and creates it.  Returns the server's representation of the replicaSet, and an error, if there is any.
+func (c *replicaSets) Create(replicaSet *v1beta1.ReplicaSet) (result *v1beta1.ReplicaSet, err error) {
+	result = &v1beta1.ReplicaSet{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("replicasets").
+		Body(replicaSet).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a replicaSet and updates it. Returns the server's representation of the replicaSet, and an error, if there is any.
+func (c *replicaSets) Update(replicaSet *v1beta1.ReplicaSet) (result *v1beta1.ReplicaSet, err error) {
+	result = &v1beta1.ReplicaSet{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("replicasets").
+		Name(replicaSet.Name).
+		Body(replicaSet).
+		Do().
+		Into(result)
+	return
+}
+
+func (c *replicaSets) UpdateStatus(replicaSet *v1beta1.ReplicaSet) (result *v1beta1.ReplicaSet, err error) {
+	result = &v1beta1.ReplicaSet{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("replicasets").
+		Name(replicaSet.Name).
+		SubResource("status").
+		Body(replicaSet).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the replicaSet and deletes it. Returns an error if one occurs.
+func (c *replicaSets) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("replicasets").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *replicaSets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("replicasets").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the replicaSet, and returns the corresponding replicaSet object, and an error if there is any.
+func (c *replicaSets) Get(name string) (result *v1beta1.ReplicaSet, err error) {
+	result = &v1beta1.ReplicaSet{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("replicasets").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of ReplicaSets that match those selectors.
+func (c *replicaSets) List(opts api.ListOptions) (result *v1beta1.ReplicaSetList, err error) {
+	result = &v1beta1.ReplicaSetList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("replicasets").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested replicaSets.
+func (c *replicaSets) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("replicasets").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched replicaSet.
+func (c *replicaSets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.ReplicaSet, err error) {
+	result = &v1beta1.ReplicaSet{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("replicasets").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/scale.go

@@ -0,0 +1,42 @@
+/*
+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 v1beta1
+
+// ScalesGetter has a method to return a ScaleInterface.
+// A group's client should implement this interface.
+type ScalesGetter interface {
+	Scales(namespace string) ScaleInterface
+}
+
+// ScaleInterface has methods to work with Scale resources.
+type ScaleInterface interface {
+	ScaleExpansion
+}
+
+// scales implements ScaleInterface
+type scales struct {
+	client *ExtensionsClient
+	ns     string
+}
+
+// newScales returns a Scales
+func newScales(c *ExtensionsClient, namespace string) *scales {
+	return &scales{
+		client: c,
+		ns:     namespace,
+	}
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/storageclass.go

@@ -0,0 +1,141 @@
+/*
+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 v1beta1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// StorageClassesGetter has a method to return a StorageClassInterface.
+// A group's client should implement this interface.
+type StorageClassesGetter interface {
+	StorageClasses() StorageClassInterface
+}
+
+// StorageClassInterface has methods to work with StorageClass resources.
+type StorageClassInterface interface {
+	Create(*v1beta1.StorageClass) (*v1beta1.StorageClass, error)
+	Update(*v1beta1.StorageClass) (*v1beta1.StorageClass, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1beta1.StorageClass, error)
+	List(opts api.ListOptions) (*v1beta1.StorageClassList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.StorageClass, err error)
+	StorageClassExpansion
+}
+
+// storageClasses implements StorageClassInterface
+type storageClasses struct {
+	client *ExtensionsClient
+}
+
+// newStorageClasses returns a StorageClasses
+func newStorageClasses(c *ExtensionsClient) *storageClasses {
+	return &storageClasses{
+		client: c,
+	}
+}
+
+// Create takes the representation of a storageClass and creates it.  Returns the server's representation of the storageClass, and an error, if there is any.
+func (c *storageClasses) Create(storageClass *v1beta1.StorageClass) (result *v1beta1.StorageClass, err error) {
+	result = &v1beta1.StorageClass{}
+	err = c.client.Post().
+		Resource("storageclasses").
+		Body(storageClass).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a storageClass and updates it. Returns the server's representation of the storageClass, and an error, if there is any.
+func (c *storageClasses) Update(storageClass *v1beta1.StorageClass) (result *v1beta1.StorageClass, err error) {
+	result = &v1beta1.StorageClass{}
+	err = c.client.Put().
+		Resource("storageclasses").
+		Name(storageClass.Name).
+		Body(storageClass).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the storageClass and deletes it. Returns an error if one occurs.
+func (c *storageClasses) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("storageclasses").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *storageClasses) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Resource("storageclasses").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the storageClass, and returns the corresponding storageClass object, and an error if there is any.
+func (c *storageClasses) Get(name string) (result *v1beta1.StorageClass, err error) {
+	result = &v1beta1.StorageClass{}
+	err = c.client.Get().
+		Resource("storageclasses").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of StorageClasses that match those selectors.
+func (c *storageClasses) List(opts api.ListOptions) (result *v1beta1.StorageClassList, err error) {
+	result = &v1beta1.StorageClassList{}
+	err = c.client.Get().
+		Resource("storageclasses").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested storageClasses.
+func (c *storageClasses) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Resource("storageclasses").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched storageClass.
+func (c *storageClasses) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.StorageClass, err error) {
+	result = &v1beta1.StorageClass{}
+	err = c.client.Patch(pt).
+		Resource("storageclasses").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1/thirdpartyresource.go

@@ -0,0 +1,141 @@
+/*
+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 v1beta1
+
+import (
+	api "k8s.io/client-go/1.4/pkg/api"
+	v1beta1 "k8s.io/client-go/1.4/pkg/apis/extensions/v1beta1"
+	watch "k8s.io/client-go/1.4/pkg/watch"
+)
+
+// ThirdPartyResourcesGetter has a method to return a ThirdPartyResourceInterface.
+// A group's client should implement this interface.
+type ThirdPartyResourcesGetter interface {
+	ThirdPartyResources() ThirdPartyResourceInterface
+}
+
+// ThirdPartyResourceInterface has methods to work with ThirdPartyResource resources.
+type ThirdPartyResourceInterface interface {
+	Create(*v1beta1.ThirdPartyResource) (*v1beta1.ThirdPartyResource, error)
+	Update(*v1beta1.ThirdPartyResource) (*v1beta1.ThirdPartyResource, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1beta1.ThirdPartyResource, error)
+	List(opts api.ListOptions) (*v1beta1.ThirdPartyResourceList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.ThirdPartyResource, err error)
+	ThirdPartyResourceExpansion
+}
+
+// thirdPartyResources implements ThirdPartyResourceInterface
+type thirdPartyResources struct {
+	client *ExtensionsClient
+}
+
+// newThirdPartyResources returns a ThirdPartyResources
+func newThirdPartyResources(c *ExtensionsClient) *thirdPartyResources {
+	return &thirdPartyResources{
+		client: c,
+	}
+}
+
+// Create takes the representation of a thirdPartyResource and creates it.  Returns the server's representation of the thirdPartyResource, and an error, if there is any.
+func (c *thirdPartyResources) Create(thirdPartyResource *v1beta1.ThirdPartyResource) (result *v1beta1.ThirdPartyResource, err error) {
+	result = &v1beta1.ThirdPartyResource{}
+	err = c.client.Post().
+		Resource("thirdpartyresources").
+		Body(thirdPartyResource).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a thirdPartyResource and updates it. Returns the server's representation of the thirdPartyResource, and an error, if there is any.
+func (c *thirdPartyResources) Update(thirdPartyResource *v1beta1.ThirdPartyResource) (result *v1beta1.ThirdPartyResource, err error) {
+	result = &v1beta1.ThirdPartyResource{}
+	err = c.client.Put().
+		Resource("thirdpartyresources").
+		Name(thirdPartyResource.Name).
+		Body(thirdPartyResource).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the thirdPartyResource and deletes it. Returns an error if one occurs.
+func (c *thirdPartyResources) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("thirdpartyresources").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *thirdPartyResources) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Resource("thirdpartyresources").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the thirdPartyResource, and returns the corresponding thirdPartyResource object, and an error if there is any.
+func (c *thirdPartyResources) Get(name string) (result *v1beta1.ThirdPartyResource, err error) {
+	result = &v1beta1.ThirdPartyResource{}
+	err = c.client.Get().
+		Resource("thirdpartyresources").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of ThirdPartyResources that match those selectors.
+func (c *thirdPartyResources) List(opts api.ListOptions) (result *v1beta1.ThirdPartyResourceList, err error) {
+	result = &v1beta1.ThirdPartyResourceList{}
+	err = c.client.Get().
+		Resource("thirdpartyresources").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested thirdPartyResources.
+func (c *thirdPartyResources) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Resource("thirdpartyresources").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched thirdPartyResource.
+func (c *thirdPartyResources) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1beta1.ThirdPartyResource, err error) {
+	result = &v1beta1.ThirdPartyResource{}
+	err = c.client.Patch(pt).
+		Resource("thirdpartyresources").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

staging/src/k8s.io/client-go/1.4/pkg/api/OWNERS

@@ -0,0 +1,6 @@
+assignees:
+  - bgrant0607
+  - erictune
+  - lavalamp
+  - smarterclayton
+  - thockin