sync(k8s.io/kubernetes) ebb8d6e0fadfc95f3d64ccecc36c8ed2ac9224ef

Kubernetes-commit: ebb8d6e0fadfc95f3d64ccecc36c8ed2ac9224ef

.travis.yml

@@ -0,0 +1,8 @@
+language: go
+
+go_import_path: k8s.io/client-go
+
+go:
+  - 1.8.1
+
+script: go build ./...

1.4/Godeps/Godeps.json

@@ -1,116 +0,0 @@
-{
-	"ImportPath": "k8s.io/client-go/1.4",
-	"GoVersion": "go1.6",
-	"GodepVersion": "v74",
-	"Packages": [
-		"./..."
-	],
-	"Deps": [
-		{
-			"ImportPath": "github.com/blang/semver",
-			"Comment": "v3.0.1",
-			"Rev": "31b736133b98f26d5e078ec9eb591666edfd091f"
-		},
-		{
-			"ImportPath": "github.com/davecgh/go-spew/spew",
-			"Rev": "5215b55f46b2b919f50a1df0eaa5886afe4e3b3d"
-		},
-		{
-			"ImportPath": "github.com/docker/distribution/digest",
-			"Comment": "v2.4.0-rc.1-38-gcd27f17",
-			"Rev": "cd27f179f2c10c5d300e6d09025b538c475b0d51"
-		},
-		{
-			"ImportPath": "github.com/docker/distribution/reference",
-			"Comment": "v2.4.0-rc.1-38-gcd27f17",
-			"Rev": "cd27f179f2c10c5d300e6d09025b538c475b0d51"
-		},
-		{
-			"ImportPath": "github.com/emicklei/go-restful",
-			"Comment": "v1.2-79-g89ef8af",
-			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
-		},
-		{
-			"ImportPath": "github.com/emicklei/go-restful/log",
-			"Comment": "v1.2-79-g89ef8af",
-			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
-		},
-		{
-			"ImportPath": "github.com/emicklei/go-restful/swagger",
-			"Comment": "v1.2-79-g89ef8af",
-			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
-		},
-		{
-			"ImportPath": "github.com/ghodss/yaml",
-			"Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee"
-		},
-		{
-			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Comment": "v0.2-33-ge18d7aa",
-			"Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
-		},
-		{
-			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Comment": "v0.2-33-ge18d7aa",
-			"Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
-		},
-		{
-			"ImportPath": "github.com/golang/glog",
-			"Rev": "44145f04b68cf362d9c4df2182967c2275eaefed"
-		},
-		{
-			"ImportPath": "github.com/golang/groupcache/lru",
-			"Rev": "02826c3e79038b59d737d3b1c0a1d937f71a4433"
-		},
-		{
-			"ImportPath": "github.com/google/gofuzz",
-			"Rev": "bbcb9da2d746f8bdbd6a936686a0a6067ada0ec5"
-		},
-		{
-			"ImportPath": "github.com/imdario/mergo",
-			"Comment": "0.1.3-8-g6633656",
-			"Rev": "6633656539c1639d9d78127b7d47c622b5d7b6dc"
-		},
-		{
-			"ImportPath": "github.com/juju/ratelimit",
-			"Rev": "77ed1c8a01217656d2080ad51981f6e99adaa177"
-		},
-		{
-			"ImportPath": "github.com/pborman/uuid",
-			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
-		},
-		{
-			"ImportPath": "github.com/spf13/pflag",
-			"Rev": "1560c1005499d61b80f865c04d39ca7505bf7f0b"
-		},
-		{
-			"ImportPath": "github.com/ugorji/go/codec",
-			"Rev": "f1f1a805ed361a0e078bb537e4ea78cd37dcf065"
-		},
-		{
-			"ImportPath": "golang.org/x/net/context",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/net/http2",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/net/http2/hpack",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/net/lex/httplex",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "gopkg.in/inf.v0",
-			"Comment": "v0.9.0",
-			"Rev": "3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4"
-		},
-		{
-			"ImportPath": "gopkg.in/yaml.v2",
-			"Rev": "53feefa2559fb8dfa8d81baad31be332c97d6c77"
-		}
-	]
-}

1.4/LICENSE

@@ -1,202 +0,0 @@
-
-                                 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.

1.4/discovery/discovery_client.go

@@ -1,345 +0,0 @@
-/*
-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"
-	"sort"
-	"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"
-	"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
-		}
-		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
-}
-
-// ErrGroupDiscoveryFailed is returned if one or more API groups fail to load.
-type ErrGroupDiscoveryFailed struct {
-	// Groups is a list of the groups that failed to load and the error cause
-	Groups map[unversioned.GroupVersion]error
-}
-
-// Error implements the error interface
-func (e *ErrGroupDiscoveryFailed) Error() string {
-	var groups []string
-	for k, v := range e.Groups {
-		groups = append(groups, fmt.Sprintf("%s: %v", k, v))
-	}
-	sort.Strings(groups)
-	return fmt.Sprintf("unable to retrieve the complete list of server APIs: %s", strings.Join(groups, ", "))
-}
-
-// IsGroupDiscoveryFailedError returns true if the provided error indicates the server was unable to discover
-// a complete list of APIs for the client to use.
-func IsGroupDiscoveryFailedError(err error) bool {
-	_, ok := err.(*ErrGroupDiscoveryFailed)
-	return err != nil && ok
-}
-
-// 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
-	}
-
-	var failedGroups map[unversioned.GroupVersion]error
-	for _, apiGroup := range serverGroupList.Groups {
-		preferredVersion := apiGroup.PreferredVersion
-		groupVersion := unversioned.GroupVersion{Group: apiGroup.Name, Version: preferredVersion.Version}
-		apiResourceList, err := d.ServerResourcesForGroupVersion(preferredVersion.GroupVersion)
-		if err != nil {
-			if failedGroups == nil {
-				failedGroups = make(map[unversioned.GroupVersion]error)
-			}
-			failedGroups[groupVersion] = err
-			continue
-		}
-		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))
-		}
-	}
-	if len(failedGroups) > 0 {
-		return results, &ErrGroupDiscoveryFailed{Groups: failedGroups}
-	}
-	return results, nil
-}
-
-// 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.Empty() {
-		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
-}

1.4/discovery/discovery_client_test.go

@@ -1,456 +0,0 @@
-/*
-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{
-			{Name: "pods", Namespaced: true, Kind: "Pod"},
-			{Name: "services", Namespaced: true, Kind: "Service"},
-			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
-		},
-	}
-	beta := unversioned.APIResourceList{
-		GroupVersion: "extensions/v1",
-		APIResources: []unversioned.APIResource{
-			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
-			{Name: "ingresses", Namespaced: true, Kind: "Ingress"},
-			{Name: "jobs", Namespaced: true, Kind: "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)
-	}
-}
-
-func TestGetServerPreferredResources(t *testing.T) {
-	stable := unversioned.APIResourceList{
-		GroupVersion: "v1",
-		APIResources: []unversioned.APIResource{
-			{Name: "pods", Namespaced: true, Kind: "Pod"},
-			{Name: "services", Namespaced: true, Kind: "Service"},
-			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
-		},
-	}
-	/*beta := unversioned.APIResourceList{
-		GroupVersion: "extensions/v1",
-		APIResources: []unversioned.APIResource{
-			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
-			{Name: "ingresses", Namespaced: true, Kind: "Ingress"},
-			{Name: "jobs", Namespaced: true, Kind: "Job"},
-		},
-	}*/
-	tests := []struct {
-		resourcesList *unversioned.APIResourceList
-		response      func(w http.ResponseWriter, req *http.Request)
-		expectErr     func(err error) bool
-	}{
-		{
-			resourcesList: &stable,
-			expectErr:     IsGroupDiscoveryFailedError,
-			response: func(w http.ResponseWriter, req *http.Request) {
-				var list interface{}
-				switch req.URL.Path {
-				case "/apis/extensions/v1beta1":
-					w.WriteHeader(http.StatusInternalServerError)
-					return
-				case "/api/v1":
-					list = &stable
-				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)
-			},
-		},
-		{
-			resourcesList: nil,
-			expectErr:     IsGroupDiscoveryFailedError,
-			response: func(w http.ResponseWriter, req *http.Request) {
-				var list interface{}
-				switch req.URL.Path {
-				case "/apis/extensions/v1beta1":
-					w.WriteHeader(http.StatusInternalServerError)
-					return
-				case "/api/v1":
-					w.WriteHeader(http.StatusInternalServerError)
-				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)
-			},
-		},
-		/*{
-			resourcesList: &stable,
-		},*/
-	}
-	for _, test := range tests {
-		server := httptest.NewServer(http.HandlerFunc(test.response))
-		defer server.Close()
-
-		client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
-		got, err := client.ServerPreferredResources()
-		if test.expectErr != nil {
-			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)
-		}
-		server.Close()
-	}
-}

1.4/discovery/fake/discovery.go

@@ -1,82 +0,0 @@
-/*
-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
-}

1.4/discovery/restmapper.go

@@ -1,263 +0,0 @@
-/*
-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)
-			}
-			// TODO why is this type not in discovery (at least for "v1")
-			versionMapper.Add(gv.WithKind("List"), meta.RESTScopeRoot)
-			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{}

1.4/discovery/restmapper_test.go

@@ -1,176 +0,0 @@
-/*
-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)
-		}
-	}
-}

1.4/discovery/unstructured.go

@@ -1,95 +0,0 @@
-/*
-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 (
-	"fmt"
-
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/runtime"
-)
-
-// UnstructuredObjectTyper provides a runtime.ObjectTyper implmentation for
-// runtime.Unstructured object based on discovery information.
-type UnstructuredObjectTyper struct {
-	registered map[unversioned.GroupVersionKind]bool
-}
-
-// NewUnstructuredObjectTyper returns a runtime.ObjectTyper for
-// unstructred objects based on discovery information.
-func NewUnstructuredObjectTyper(groupResources []*APIGroupResources) *UnstructuredObjectTyper {
-	dot := &UnstructuredObjectTyper{registered: make(map[unversioned.GroupVersionKind]bool)}
-	for _, group := range groupResources {
-		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}
-			for _, resource := range resources {
-				dot.registered[gv.WithKind(resource.Kind)] = true
-			}
-		}
-	}
-	return dot
-}
-
-// ObjectKind returns the group,version,kind of the provided object, or an error
-// if the object in not *runtime.Unstructured or has no group,version,kind
-// information.
-func (d *UnstructuredObjectTyper) ObjectKind(obj runtime.Object) (unversioned.GroupVersionKind, error) {
-	if _, ok := obj.(*runtime.Unstructured); !ok {
-		return unversioned.GroupVersionKind{}, fmt.Errorf("type %T is invalid for dynamic object typer", obj)
-	}
-
-	return obj.GetObjectKind().GroupVersionKind(), 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. unversionedType will always be false
-// because runtime.Unstructured object should always have group,version,kind
-// information set.
-func (d *UnstructuredObjectTyper) ObjectKinds(obj runtime.Object) (gvks []unversioned.GroupVersionKind, unversionedType bool, err error) {
-	gvk, err := d.ObjectKind(obj)
-	if err != nil {
-		return nil, false, err
-	}
-
-	return []unversioned.GroupVersionKind{gvk}, false, nil
-}
-
-// Recognizes returns true if the provided group,version,kind was in the
-// discovery information.
-func (d *UnstructuredObjectTyper) Recognizes(gvk unversioned.GroupVersionKind) bool {
-	return d.registered[gvk]
-}
-
-// IsUnversioned returns false always because *runtime.Unstructured objects
-// should always have group,version,kind information set. ok will be true if the
-// object's group,version,kind is registered.
-func (d *UnstructuredObjectTyper) IsUnversioned(obj runtime.Object) (unversioned bool, ok bool) {
-	gvk, err := d.ObjectKind(obj)
-	if err != nil {
-		return false, false
-	}
-
-	return false, d.registered[gvk]
-}
-
-var _ runtime.ObjectTyper = &UnstructuredObjectTyper{}

1.4/dynamic/client.go

@@ -1,289 +0,0 @@
-/*
-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/util/flowcontrol"
-	"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
-	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
-
-	contentConfig := ContentConfig()
-	contentConfig.GroupVersion = conf.GroupVersion
-	if conf.NegotiatedSerializer != nil {
-		contentConfig.NegotiatedSerializer = conf.NegotiatedSerializer
-	}
-	conf.ContentConfig = contentConfig
-
-	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
-}
-
-// GetRateLimiter returns rate limier.
-func (c *Client) GetRateLimiter() flowcontrol.RateLimiter {
-	return c.cl.GetRateLimiter()
-}
-
-// 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 *Client) Resource(resource *unversioned.APIResource, namespace string) *ResourceClient {
-	return &ResourceClient{
-		cl:             c.cl,
-		resource:       resource,
-		ns:             namespace,
-		parameterCodec: c.parameterCodec,
-	}
-}
-
-// ParameterCodec returns a client with the provided parameter codec.
-func (c *Client) ParameterCodec(parameterCodec runtime.ParameterCodec) *Client {
-	return &Client{
-		cl:             c.cl,
-		parameterCodec: 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.Object, error) {
-	parameterEncoder := rc.parameterCodec
-	if parameterEncoder == nil {
-		parameterEncoder = defaultParameterEncoder
-	}
-	return rc.cl.Get().
-		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
-		Resource(rc.resource.Name).
-		VersionedParams(opts, parameterEncoder).
-		Do().
-		Get()
-}
-
-// 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)
-}
-
-// ContentConfig returns a rest.ContentConfig for dynamic types.
-func ContentConfig() rest.ContentConfig {
-	// TODO: it's questionable that this should be using anything other than unstructured schema and JSON
-	codec := dynamicCodec{}
-	streamingInfo, _ := api.Codecs.StreamingSerializerForMediaType("application/json;stream=watch", nil)
-	return rest.ContentConfig{
-		AcceptContentTypes:   runtime.ContentTypeJSON,
-		ContentType:          runtime.ContentTypeJSON,
-		NegotiatedSerializer: serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: codec}, streamingInfo),
-	}
-}
-
-// 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{}

1.4/dynamic/client_pool.go

@@ -1,95 +0,0 @@
-/*
-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"
-	"k8s.io/client-go/1.4/pkg/api/unversioned"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/pkg/runtime/serializer"
-	"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
-
-	if conf.NegotiatedSerializer == nil {
-		streamingInfo, _ := api.Codecs.StreamingSerializerForMediaType("application/json;stream=watch", nil)
-		conf.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: dynamicCodec{}}, streamingInfo)
-	}
-
-	dynamicClient, err := NewClient(conf)
-	if err != nil {
-		return nil, err
-	}
-	c.clients[groupVersion] = dynamicClient
-	return dynamicClient, nil
-}

1.4/dynamic/client_test.go

@@ -1,550 +0,0 @@
-/*
-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)
-		}
-	}
-}

1.4/dynamic/dynamic_util.go

@@ -1,94 +0,0 @@
-/*
-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]
-}

1.4/kubernetes/clientset.go

@@ -1,260 +0,0 @@
-/*
-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"
-	v1alpha1apps "k8s.io/client-go/1.4/kubernetes/typed/apps/v1alpha1"
-	v1beta1authentication "k8s.io/client-go/1.4/kubernetes/typed/authentication/v1beta1"
-	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"
-	v1alpha1certificates "k8s.io/client-go/1.4/kubernetes/typed/certificates/v1alpha1"
-	v1core "k8s.io/client-go/1.4/kubernetes/typed/core/v1"
-	v1beta1extensions "k8s.io/client-go/1.4/kubernetes/typed/extensions/v1beta1"
-	v1alpha1policy "k8s.io/client-go/1.4/kubernetes/typed/policy/v1alpha1"
-	v1alpha1rbac "k8s.io/client-go/1.4/kubernetes/typed/rbac/v1alpha1"
-	v1beta1storage "k8s.io/client-go/1.4/kubernetes/typed/storage/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
-	Apps() v1alpha1apps.AppsInterface
-	Authentication() v1beta1authentication.AuthenticationInterface
-	Authorization() v1beta1authorization.AuthorizationInterface
-	Autoscaling() v1autoscaling.AutoscalingInterface
-	Batch() v1batch.BatchInterface
-	Certificates() v1alpha1certificates.CertificatesInterface
-	Extensions() v1beta1extensions.ExtensionsInterface
-	Policy() v1alpha1policy.PolicyInterface
-	Rbac() v1alpha1rbac.RbacInterface
-	Storage() v1beta1storage.StorageInterface
-}
-
-// Clientset contains the clients for groups. Each group has exactly one
-// version included in a Clientset.
-type Clientset struct {
-	*discovery.DiscoveryClient
-	*v1core.CoreClient
-	*v1alpha1apps.AppsClient
-	*v1beta1authentication.AuthenticationClient
-	*v1beta1authorization.AuthorizationClient
-	*v1autoscaling.AutoscalingClient
-	*v1batch.BatchClient
-	*v1alpha1certificates.CertificatesClient
-	*v1beta1extensions.ExtensionsClient
-	*v1alpha1policy.PolicyClient
-	*v1alpha1rbac.RbacClient
-	*v1beta1storage.StorageClient
-}
-
-// Core retrieves the CoreClient
-func (c *Clientset) Core() v1core.CoreInterface {
-	if c == nil {
-		return nil
-	}
-	return c.CoreClient
-}
-
-// Apps retrieves the AppsClient
-func (c *Clientset) Apps() v1alpha1apps.AppsInterface {
-	if c == nil {
-		return nil
-	}
-	return c.AppsClient
-}
-
-// Authentication retrieves the AuthenticationClient
-func (c *Clientset) Authentication() v1beta1authentication.AuthenticationInterface {
-	if c == nil {
-		return nil
-	}
-	return c.AuthenticationClient
-}
-
-// 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
-}
-
-// Certificates retrieves the CertificatesClient
-func (c *Clientset) Certificates() v1alpha1certificates.CertificatesInterface {
-	if c == nil {
-		return nil
-	}
-	return c.CertificatesClient
-}
-
-// Extensions retrieves the ExtensionsClient
-func (c *Clientset) Extensions() v1beta1extensions.ExtensionsInterface {
-	if c == nil {
-		return nil
-	}
-	return c.ExtensionsClient
-}
-
-// Policy retrieves the PolicyClient
-func (c *Clientset) Policy() v1alpha1policy.PolicyInterface {
-	if c == nil {
-		return nil
-	}
-	return c.PolicyClient
-}
-
-// Rbac retrieves the RbacClient
-func (c *Clientset) Rbac() v1alpha1rbac.RbacInterface {
-	if c == nil {
-		return nil
-	}
-	return c.RbacClient
-}
-
-// Storage retrieves the StorageClient
-func (c *Clientset) Storage() v1beta1storage.StorageInterface {
-	if c == nil {
-		return nil
-	}
-	return c.StorageClient
-}
-
-// 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.AppsClient, err = v1alpha1apps.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.AuthenticationClient, err = v1beta1authentication.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.CertificatesClient, err = v1alpha1certificates.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.ExtensionsClient, err = v1beta1extensions.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.PolicyClient, err = v1alpha1policy.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.RbacClient, err = v1alpha1rbac.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	clientset.StorageClient, err = v1beta1storage.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.AppsClient = v1alpha1apps.NewForConfigOrDie(c)
-	clientset.AuthenticationClient = v1beta1authentication.NewForConfigOrDie(c)
-	clientset.AuthorizationClient = v1beta1authorization.NewForConfigOrDie(c)
-	clientset.AutoscalingClient = v1autoscaling.NewForConfigOrDie(c)
-	clientset.BatchClient = v1batch.NewForConfigOrDie(c)
-	clientset.CertificatesClient = v1alpha1certificates.NewForConfigOrDie(c)
-	clientset.ExtensionsClient = v1beta1extensions.NewForConfigOrDie(c)
-	clientset.PolicyClient = v1alpha1policy.NewForConfigOrDie(c)
-	clientset.RbacClient = v1alpha1rbac.NewForConfigOrDie(c)
-	clientset.StorageClient = v1beta1storage.NewForConfigOrDie(c)
-
-	clientset.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
-	return &clientset
-}
-
-// New creates a new Clientset for the given RESTClient.
-func New(c *rest.RESTClient) *Clientset {
-	var clientset Clientset
-	clientset.CoreClient = v1core.New(c)
-	clientset.AppsClient = v1alpha1apps.New(c)
-	clientset.AuthenticationClient = v1beta1authentication.New(c)
-	clientset.AuthorizationClient = v1beta1authorization.New(c)
-	clientset.AutoscalingClient = v1autoscaling.New(c)
-	clientset.BatchClient = v1batch.New(c)
-	clientset.CertificatesClient = v1alpha1certificates.New(c)
-	clientset.ExtensionsClient = v1beta1extensions.New(c)
-	clientset.PolicyClient = v1alpha1policy.New(c)
-	clientset.RbacClient = v1alpha1rbac.New(c)
-	clientset.StorageClient = v1beta1storage.New(c)
-
-	clientset.DiscoveryClient = discovery.NewDiscoveryClient(c)
-	return &clientset
-}

1.4/kubernetes/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// This package has the automatically generated clientset.
-package kubernetes

1.4/kubernetes/fake/clientset_generated.go

@@ -1,138 +0,0 @@
-/*
-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"
-	v1alpha1apps "k8s.io/client-go/1.4/kubernetes/typed/apps/v1alpha1"
-	fakev1alpha1apps "k8s.io/client-go/1.4/kubernetes/typed/apps/v1alpha1/fake"
-	v1beta1authentication "k8s.io/client-go/1.4/kubernetes/typed/authentication/v1beta1"
-	fakev1beta1authentication "k8s.io/client-go/1.4/kubernetes/typed/authentication/v1beta1/fake"
-	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"
-	v1alpha1certificates "k8s.io/client-go/1.4/kubernetes/typed/certificates/v1alpha1"
-	fakev1alpha1certificates "k8s.io/client-go/1.4/kubernetes/typed/certificates/v1alpha1/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"
-	v1alpha1policy "k8s.io/client-go/1.4/kubernetes/typed/policy/v1alpha1"
-	fakev1alpha1policy "k8s.io/client-go/1.4/kubernetes/typed/policy/v1alpha1/fake"
-	v1alpha1rbac "k8s.io/client-go/1.4/kubernetes/typed/rbac/v1alpha1"
-	fakev1alpha1rbac "k8s.io/client-go/1.4/kubernetes/typed/rbac/v1alpha1/fake"
-	v1beta1storage "k8s.io/client-go/1.4/kubernetes/typed/storage/v1beta1"
-	fakev1beta1storage "k8s.io/client-go/1.4/kubernetes/typed/storage/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}
-}
-
-// Apps retrieves the AppsClient
-func (c *Clientset) Apps() v1alpha1apps.AppsInterface {
-	return &fakev1alpha1apps.FakeApps{Fake: &c.Fake}
-}
-
-// Authentication retrieves the AuthenticationClient
-func (c *Clientset) Authentication() v1beta1authentication.AuthenticationInterface {
-	return &fakev1beta1authentication.FakeAuthentication{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}
-}
-
-// Certificates retrieves the CertificatesClient
-func (c *Clientset) Certificates() v1alpha1certificates.CertificatesInterface {
-	return &fakev1alpha1certificates.FakeCertificates{Fake: &c.Fake}
-}
-
-// Extensions retrieves the ExtensionsClient
-func (c *Clientset) Extensions() v1beta1extensions.ExtensionsInterface {
-	return &fakev1beta1extensions.FakeExtensions{Fake: &c.Fake}
-}
-
-// Policy retrieves the PolicyClient
-func (c *Clientset) Policy() v1alpha1policy.PolicyInterface {
-	return &fakev1alpha1policy.FakePolicy{Fake: &c.Fake}
-}
-
-// Rbac retrieves the RbacClient
-func (c *Clientset) Rbac() v1alpha1rbac.RbacInterface {
-	return &fakev1alpha1rbac.FakeRbac{Fake: &c.Fake}
-}
-
-// Storage retrieves the StorageClient
-func (c *Clientset) Storage() v1beta1storage.StorageInterface {
-	return &fakev1beta1storage.FakeStorage{Fake: &c.Fake}
-}

1.4/kubernetes/fake/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// This package has the automatically generated fake clientset.
-package fake

1.4/kubernetes/import_known_versions.go

@@ -1,41 +0,0 @@
-/*
-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/apps/install"
-	_ "k8s.io/client-go/1.4/pkg/apis/authentication/install"
-	_ "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/certificates/install"
-	_ "k8s.io/client-go/1.4/pkg/apis/extensions/install"
-	_ "k8s.io/client-go/1.4/pkg/apis/policy/install"
-	_ "k8s.io/client-go/1.4/pkg/apis/rbac/install"
-	_ "k8s.io/client-go/1.4/pkg/apis/storage/install"
-)
-
-func init() {
-	if missingVersions := registered.ValidateEnvRequestedVersions(); len(missingVersions) != 0 {
-		panic(fmt.Sprintf("KUBE_API_VERSIONS contains versions that are not installed: %q.", missingVersions))
-	}
-}

1.4/kubernetes/typed/apps/v1alpha1/apps_client.go

@@ -1,96 +0,0 @@
-/*
-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 v1alpha1
-
-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 AppsInterface interface {
-	GetRESTClient() *rest.RESTClient
-	PetSetsGetter
-}
-
-// AppsClient is used to interact with features provided by the Apps group.
-type AppsClient struct {
-	*rest.RESTClient
-}
-
-func (c *AppsClient) PetSets(namespace string) PetSetInterface {
-	return newPetSets(c, namespace)
-}
-
-// NewForConfig creates a new AppsClient for the given config.
-func NewForConfig(c *rest.Config) (*AppsClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &AppsClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new AppsClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *AppsClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new AppsClient for the given RESTClient.
-func New(c *rest.RESTClient) *AppsClient {
-	return &AppsClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if apps group is not registered, return an error
-	g, err := registered.Group("apps")
-	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 *AppsClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/apps/v1alpha1/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// This package has the automatically generated typed clients.
-package v1alpha1

1.4/kubernetes/typed/apps/v1alpha1/fake/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/apps/v1alpha1/fake/fake_apps_client.go

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

1.4/kubernetes/typed/apps/v1alpha1/fake/fake_petset.go

@@ -1,127 +0,0 @@
-/*
-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"
-	v1alpha1 "k8s.io/client-go/1.4/pkg/apis/apps/v1alpha1"
-	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"
-)
-
-// FakePetSets implements PetSetInterface
-type FakePetSets struct {
-	Fake *FakeApps
-	ns   string
-}
-
-var petsetsResource = unversioned.GroupVersionResource{Group: "apps", Version: "v1alpha1", Resource: "petsets"}
-
-func (c *FakePetSets) Create(petSet *v1alpha1.PetSet) (result *v1alpha1.PetSet, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewCreateAction(petsetsResource, c.ns, petSet), &v1alpha1.PetSet{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PetSet), err
-}
-
-func (c *FakePetSets) Update(petSet *v1alpha1.PetSet) (result *v1alpha1.PetSet, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewUpdateAction(petsetsResource, c.ns, petSet), &v1alpha1.PetSet{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PetSet), err
-}
-
-func (c *FakePetSets) UpdateStatus(petSet *v1alpha1.PetSet) (*v1alpha1.PetSet, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewUpdateSubresourceAction(petsetsResource, "status", c.ns, petSet), &v1alpha1.PetSet{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PetSet), err
-}
-
-func (c *FakePetSets) Delete(name string, options *api.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewDeleteAction(petsetsResource, c.ns, name), &v1alpha1.PetSet{})
-
-	return err
-}
-
-func (c *FakePetSets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
-	action := testing.NewDeleteCollectionAction(petsetsResource, c.ns, listOptions)
-
-	_, err := c.Fake.Invokes(action, &v1alpha1.PetSetList{})
-	return err
-}
-
-func (c *FakePetSets) Get(name string) (result *v1alpha1.PetSet, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewGetAction(petsetsResource, c.ns, name), &v1alpha1.PetSet{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PetSet), err
-}
-
-func (c *FakePetSets) List(opts api.ListOptions) (result *v1alpha1.PetSetList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewListAction(petsetsResource, c.ns, opts), &v1alpha1.PetSetList{})
-
-	if obj == nil {
-		return nil, err
-	}
-
-	label := opts.LabelSelector
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &v1alpha1.PetSetList{}
-	for _, item := range obj.(*v1alpha1.PetSetList).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 petSets.
-func (c *FakePetSets) Watch(opts api.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewWatchAction(petsetsResource, c.ns, opts))
-
-}
-
-// Patch applies the patch and returns the patched petSet.
-func (c *FakePetSets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1alpha1.PetSet, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(petsetsResource, c.ns, name, data, subresources...), &v1alpha1.PetSet{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PetSet), err
-}

1.4/kubernetes/typed/apps/v1alpha1/generated_expansion.go

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

1.4/kubernetes/typed/apps/v1alpha1/petset.go

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

1.4/kubernetes/typed/authentication/v1beta1/authentication_client.go

@@ -1,96 +0,0 @@
-/*
-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 AuthenticationInterface interface {
-	GetRESTClient() *rest.RESTClient
-	TokenReviewsGetter
-}
-
-// AuthenticationClient is used to interact with features provided by the Authentication group.
-type AuthenticationClient struct {
-	*rest.RESTClient
-}
-
-func (c *AuthenticationClient) TokenReviews() TokenReviewInterface {
-	return newTokenReviews(c)
-}
-
-// NewForConfig creates a new AuthenticationClient for the given config.
-func NewForConfig(c *rest.Config) (*AuthenticationClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &AuthenticationClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new AuthenticationClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *AuthenticationClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new AuthenticationClient for the given RESTClient.
-func New(c *rest.RESTClient) *AuthenticationClient {
-	return &AuthenticationClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if authentication group is not registered, return an error
-	g, err := registered.Group("authentication.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 *AuthenticationClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/authentication/v1beta1/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// This package has the automatically generated typed clients.
-package v1beta1

1.4/kubernetes/typed/authentication/v1beta1/fake/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/authentication/v1beta1/fake/fake_authentication_client.go

@@ -1,37 +0,0 @@
-/*
-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/authentication/v1beta1"
-	rest "k8s.io/client-go/1.4/rest"
-	testing "k8s.io/client-go/1.4/testing"
-)
-
-type FakeAuthentication struct {
-	*testing.Fake
-}
-
-func (c *FakeAuthentication) TokenReviews() v1beta1.TokenReviewInterface {
-	return &FakeTokenReviews{c}
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *FakeAuthentication) GetRESTClient() *rest.RESTClient {
-	return nil
-}

1.4/kubernetes/typed/authentication/v1beta1/fake/fake_tokenreview.go

@@ -1,22 +0,0 @@
-/*
-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
-
-// FakeTokenReviews implements TokenReviewInterface
-type FakeTokenReviews struct {
-	Fake *FakeAuthentication
-}

1.4/kubernetes/typed/authentication/v1beta1/generated_expansion.go

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

1.4/kubernetes/typed/authentication/v1beta1/tokenreview.go

@@ -1,40 +0,0 @@
-/*
-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
-
-// TokenReviewsGetter has a method to return a TokenReviewInterface.
-// A group's client should implement this interface.
-type TokenReviewsGetter interface {
-	TokenReviews() TokenReviewInterface
-}
-
-// TokenReviewInterface has methods to work with TokenReview resources.
-type TokenReviewInterface interface {
-	TokenReviewExpansion
-}
-
-// tokenReviews implements TokenReviewInterface
-type tokenReviews struct {
-	client *AuthenticationClient
-}
-
-// newTokenReviews returns a TokenReviews
-func newTokenReviews(c *AuthenticationClient) *tokenReviews {
-	return &tokenReviews{
-		client: c,
-	}
-}

1.4/kubernetes/typed/authorization/v1beta1/authorization_client.go

@@ -1,96 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/authorization/v1beta1/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// This package has the automatically generated typed clients.
-package v1beta1

1.4/kubernetes/typed/authorization/v1beta1/fake/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/authorization/v1beta1/fake/fake_authorization_client.go

@@ -1,37 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/authorization/v1beta1/fake/fake_subjectaccessreview.go

@@ -1,22 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/authorization/v1beta1/fake/fake_subjectaccessreview_expansion.go

@@ -1,28 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/authorization/v1beta1/subjectaccessreview.go

@@ -1,40 +0,0 @@
-/*
-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,
-	}
-}

1.4/kubernetes/typed/authorization/v1beta1/subjectaccessreview_expansion.go

@@ -1,36 +0,0 @@
-/*
-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 SubjectAccessReviewExpansion interface allows manually adding extra methods to the AuthorizationInterface.
-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
-}

1.4/kubernetes/typed/autoscaling/v1/autoscaling_client.go

@@ -1,96 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/autoscaling/v1/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// This package has the automatically generated typed clients.
-package v1

1.4/kubernetes/typed/autoscaling/v1/fake/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/autoscaling/v1/fake/fake_autoscaling_client.go

@@ -1,37 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/autoscaling/v1/fake/fake_horizontalpodautoscaler.go

@@ -1,127 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/autoscaling/v1/generated_expansion.go

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

1.4/kubernetes/typed/autoscaling/v1/horizontalpodautoscaler.go

@@ -1,165 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/batch/v1/batch_client.go

@@ -1,96 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/batch/v1/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// This package has the automatically generated typed clients.
-package v1

1.4/kubernetes/typed/batch/v1/fake/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/batch/v1/fake/fake_batch_client.go

@@ -1,37 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/batch/v1/fake/fake_job.go

@@ -1,127 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/batch/v1/generated_expansion.go

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

1.4/kubernetes/typed/batch/v1/job.go

@@ -1,165 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/certificates/v1alpha1/certificates_client.go

@@ -1,96 +0,0 @@
-/*
-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 v1alpha1
-
-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 CertificatesInterface interface {
-	GetRESTClient() *rest.RESTClient
-	CertificateSigningRequestsGetter
-}
-
-// CertificatesClient is used to interact with features provided by the Certificates group.
-type CertificatesClient struct {
-	*rest.RESTClient
-}
-
-func (c *CertificatesClient) CertificateSigningRequests() CertificateSigningRequestInterface {
-	return newCertificateSigningRequests(c)
-}
-
-// NewForConfig creates a new CertificatesClient for the given config.
-func NewForConfig(c *rest.Config) (*CertificatesClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &CertificatesClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new CertificatesClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *CertificatesClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new CertificatesClient for the given RESTClient.
-func New(c *rest.RESTClient) *CertificatesClient {
-	return &CertificatesClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if certificates group is not registered, return an error
-	g, err := registered.Group("certificates.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 *CertificatesClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.4/kubernetes/typed/certificates/v1alpha1/certificatesigningrequest.go

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

1.4/kubernetes/typed/certificates/v1alpha1/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// This package has the automatically generated typed clients.
-package v1alpha1

1.4/kubernetes/typed/certificates/v1alpha1/fake/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/certificates/v1alpha1/fake/fake_certificates_client.go

@@ -1,37 +0,0 @@
-/*
-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 (
-	v1alpha1 "k8s.io/client-go/1.4/kubernetes/typed/certificates/v1alpha1"
-	rest "k8s.io/client-go/1.4/rest"
-	testing "k8s.io/client-go/1.4/testing"
-)
-
-type FakeCertificates struct {
-	*testing.Fake
-}
-
-func (c *FakeCertificates) CertificateSigningRequests() v1alpha1.CertificateSigningRequestInterface {
-	return &FakeCertificateSigningRequests{c}
-}
-
-// GetRESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *FakeCertificates) GetRESTClient() *rest.RESTClient {
-	return nil
-}

1.4/kubernetes/typed/certificates/v1alpha1/fake/fake_certificatesigningrequest.go

@@ -1,118 +0,0 @@
-/*
-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"
-	v1alpha1 "k8s.io/client-go/1.4/pkg/apis/certificates/v1alpha1"
-	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"
-)
-
-// FakeCertificateSigningRequests implements CertificateSigningRequestInterface
-type FakeCertificateSigningRequests struct {
-	Fake *FakeCertificates
-}
-
-var certificatesigningrequestsResource = unversioned.GroupVersionResource{Group: "certificates.k8s.io", Version: "v1alpha1", Resource: "certificatesigningrequests"}
-
-func (c *FakeCertificateSigningRequests) Create(certificateSigningRequest *v1alpha1.CertificateSigningRequest) (result *v1alpha1.CertificateSigningRequest, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootCreateAction(certificatesigningrequestsResource, certificateSigningRequest), &v1alpha1.CertificateSigningRequest{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.CertificateSigningRequest), err
-}
-
-func (c *FakeCertificateSigningRequests) Update(certificateSigningRequest *v1alpha1.CertificateSigningRequest) (result *v1alpha1.CertificateSigningRequest, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootUpdateAction(certificatesigningrequestsResource, certificateSigningRequest), &v1alpha1.CertificateSigningRequest{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.CertificateSigningRequest), err
-}
-
-func (c *FakeCertificateSigningRequests) UpdateStatus(certificateSigningRequest *v1alpha1.CertificateSigningRequest) (*v1alpha1.CertificateSigningRequest, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootUpdateSubresourceAction(certificatesigningrequestsResource, "status", certificateSigningRequest), &v1alpha1.CertificateSigningRequest{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.CertificateSigningRequest), err
-}
-
-func (c *FakeCertificateSigningRequests) Delete(name string, options *api.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewRootDeleteAction(certificatesigningrequestsResource, name), &v1alpha1.CertificateSigningRequest{})
-	return err
-}
-
-func (c *FakeCertificateSigningRequests) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
-	action := testing.NewRootDeleteCollectionAction(certificatesigningrequestsResource, listOptions)
-
-	_, err := c.Fake.Invokes(action, &v1alpha1.CertificateSigningRequestList{})
-	return err
-}
-
-func (c *FakeCertificateSigningRequests) Get(name string) (result *v1alpha1.CertificateSigningRequest, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootGetAction(certificatesigningrequestsResource, name), &v1alpha1.CertificateSigningRequest{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.CertificateSigningRequest), err
-}
-
-func (c *FakeCertificateSigningRequests) List(opts api.ListOptions) (result *v1alpha1.CertificateSigningRequestList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootListAction(certificatesigningrequestsResource, opts), &v1alpha1.CertificateSigningRequestList{})
-	if obj == nil {
-		return nil, err
-	}
-
-	label := opts.LabelSelector
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &v1alpha1.CertificateSigningRequestList{}
-	for _, item := range obj.(*v1alpha1.CertificateSigningRequestList).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 certificateSigningRequests.
-func (c *FakeCertificateSigningRequests) Watch(opts api.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewRootWatchAction(certificatesigningrequestsResource, opts))
-}
-
-// Patch applies the patch and returns the patched certificateSigningRequest.
-func (c *FakeCertificateSigningRequests) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1alpha1.CertificateSigningRequest, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(certificatesigningrequestsResource, name, data, subresources...), &v1alpha1.CertificateSigningRequest{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.CertificateSigningRequest), err
-}

1.4/kubernetes/typed/certificates/v1alpha1/generated_expansion.go

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

1.4/kubernetes/typed/core/v1/componentstatus.go

@@ -1,141 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/configmap.go

@@ -1,151 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/core_client.go

@@ -1,171 +0,0 @@
-/*
-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
-	PersistentVolumeClaimsGetter
-	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) PersistentVolumeClaims(namespace string) PersistentVolumeClaimInterface {
-	return newPersistentVolumeClaims(c, namespace)
-}
-
-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
-}

1.4/kubernetes/typed/core/v1/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// This package has the automatically generated typed clients.
-package v1

1.4/kubernetes/typed/core/v1/endpoints.go

@@ -1,151 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/event.go

@@ -1,151 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/doc.go

@@ -1,20 +0,0 @@
-/*
-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,apps/v1alpha1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,certificates/v1alpha1,extensions/v1beta1,policy/v1alpha1,rbac/v1alpha1,storage/v1beta1]
-
-// Package fake has the automatically generated clients.
-package fake

1.4/kubernetes/typed/core/v1/fake/fake_componentstatus.go

@@ -1,109 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_configmap.go

@@ -1,117 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_core_client.go

@@ -1,97 +0,0 @@
-/*
-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) PersistentVolumeClaims(namespace string) v1.PersistentVolumeClaimInterface {
-	return &FakePersistentVolumeClaims{c, namespace}
-}
-
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_endpoints.go

@@ -1,117 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_event.go

@@ -1,117 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_event_expansion.go

@@ -1,89 +0,0 @@
-/*
-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 fake
-
-import (
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/v1"
-	"k8s.io/client-go/1.4/pkg/fields"
-	"k8s.io/client-go/1.4/pkg/runtime"
-	"k8s.io/client-go/1.4/testing"
-)
-
-func (c *FakeEvents) CreateWithEventNamespace(event *v1.Event) (*v1.Event, error) {
-	action := testing.NewRootCreateAction(eventsResource, event)
-	if c.ns != "" {
-		action = testing.NewCreateAction(eventsResource, c.ns, event)
-	}
-	obj, err := c.Fake.Invokes(action, event)
-	if obj == nil {
-		return nil, err
-	}
-
-	return obj.(*v1.Event), err
-}
-
-// Update replaces an existing event. Returns the copy of the event the server returns, or an error.
-func (c *FakeEvents) UpdateWithEventNamespace(event *v1.Event) (*v1.Event, error) {
-	action := testing.NewRootUpdateAction(eventsResource, event)
-	if c.ns != "" {
-		action = testing.NewUpdateAction(eventsResource, c.ns, event)
-	}
-	obj, err := c.Fake.Invokes(action, event)
-	if obj == nil {
-		return nil, err
-	}
-
-	return obj.(*v1.Event), err
-}
-
-// PatchWithEventNamespace patches an existing event. Returns the copy of the event the server returns, or an error.
-func (c *FakeEvents) PatchWithEventNamespace(event *v1.Event, data []byte) (*v1.Event, error) {
-	action := testing.NewRootPatchAction(eventsResource, event.Name, data)
-	if c.ns != "" {
-		action = testing.NewPatchAction(eventsResource, c.ns, event.Name, data)
-	}
-	obj, err := c.Fake.Invokes(action, event)
-	if obj == nil {
-		return nil, err
-	}
-
-	return obj.(*v1.Event), err
-}
-
-// Search returns a list of events matching the specified object.
-func (c *FakeEvents) Search(objOrRef runtime.Object) (*v1.EventList, error) {
-	action := testing.NewRootListAction(eventsResource, api.ListOptions{})
-	if c.ns != "" {
-		action = testing.NewListAction(eventsResource, c.ns, api.ListOptions{})
-	}
-	obj, err := c.Fake.Invokes(action, &v1.EventList{})
-	if obj == nil {
-		return nil, err
-	}
-
-	return obj.(*v1.EventList), err
-}
-
-func (c *FakeEvents) GetFieldSelector(involvedObjectName, involvedObjectNamespace, involvedObjectKind, involvedObjectUID *string) fields.Selector {
-	action := testing.GenericActionImpl{}
-	action.Verb = "get-field-selector"
-	action.Resource = eventsResource
-
-	c.Fake.Invokes(action, nil)
-	return fields.Everything()
-}

1.4/kubernetes/typed/core/v1/fake/fake_limitrange.go

@@ -1,117 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_namespace.go

@@ -1,118 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_node.go

@@ -1,118 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_persistentvolume.go

@@ -1,118 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_persistentvolumeclaim.go

@@ -1,127 +0,0 @@
-/*
-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"
-)
-
-// FakePersistentVolumeClaims implements PersistentVolumeClaimInterface
-type FakePersistentVolumeClaims struct {
-	Fake *FakeCore
-	ns   string
-}
-
-var persistentvolumeclaimsResource = unversioned.GroupVersionResource{Group: "", Version: "v1", Resource: "persistentvolumeclaims"}
-
-func (c *FakePersistentVolumeClaims) Create(persistentVolumeClaim *v1.PersistentVolumeClaim) (result *v1.PersistentVolumeClaim, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewCreateAction(persistentvolumeclaimsResource, c.ns, persistentVolumeClaim), &v1.PersistentVolumeClaim{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1.PersistentVolumeClaim), err
-}
-
-func (c *FakePersistentVolumeClaims) Update(persistentVolumeClaim *v1.PersistentVolumeClaim) (result *v1.PersistentVolumeClaim, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewUpdateAction(persistentvolumeclaimsResource, c.ns, persistentVolumeClaim), &v1.PersistentVolumeClaim{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1.PersistentVolumeClaim), err
-}
-
-func (c *FakePersistentVolumeClaims) UpdateStatus(persistentVolumeClaim *v1.PersistentVolumeClaim) (*v1.PersistentVolumeClaim, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewUpdateSubresourceAction(persistentvolumeclaimsResource, "status", c.ns, persistentVolumeClaim), &v1.PersistentVolumeClaim{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1.PersistentVolumeClaim), err
-}
-
-func (c *FakePersistentVolumeClaims) Delete(name string, options *api.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewDeleteAction(persistentvolumeclaimsResource, c.ns, name), &v1.PersistentVolumeClaim{})
-
-	return err
-}
-
-func (c *FakePersistentVolumeClaims) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
-	action := testing.NewDeleteCollectionAction(persistentvolumeclaimsResource, c.ns, listOptions)
-
-	_, err := c.Fake.Invokes(action, &v1.PersistentVolumeClaimList{})
-	return err
-}
-
-func (c *FakePersistentVolumeClaims) Get(name string) (result *v1.PersistentVolumeClaim, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewGetAction(persistentvolumeclaimsResource, c.ns, name), &v1.PersistentVolumeClaim{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1.PersistentVolumeClaim), err
-}
-
-func (c *FakePersistentVolumeClaims) List(opts api.ListOptions) (result *v1.PersistentVolumeClaimList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewListAction(persistentvolumeclaimsResource, c.ns, opts), &v1.PersistentVolumeClaimList{})
-
-	if obj == nil {
-		return nil, err
-	}
-
-	label := opts.LabelSelector
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &v1.PersistentVolumeClaimList{}
-	for _, item := range obj.(*v1.PersistentVolumeClaimList).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 persistentVolumeClaims.
-func (c *FakePersistentVolumeClaims) Watch(opts api.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewWatchAction(persistentvolumeclaimsResource, c.ns, opts))
-
-}
-
-// Patch applies the patch and returns the patched persistentVolumeClaim.
-func (c *FakePersistentVolumeClaims) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.PersistentVolumeClaim, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(persistentvolumeclaimsResource, c.ns, name, data, subresources...), &v1.PersistentVolumeClaim{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1.PersistentVolumeClaim), err
-}

1.4/kubernetes/typed/core/v1/fake/fake_pod.go

@@ -1,127 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_pod_expansion.go

@@ -1,46 +0,0 @@
-/*
-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 fake
-
-import (
-	"k8s.io/client-go/1.4/pkg/api/v1"
-	"k8s.io/client-go/1.4/rest"
-	"k8s.io/client-go/1.4/testing"
-)
-
-func (c *FakePods) Bind(binding *v1.Binding) error {
-	action := testing.CreateActionImpl{}
-	action.Verb = "create"
-	action.Resource = podsResource
-	action.Subresource = "bindings"
-	action.Object = binding
-
-	_, err := c.Fake.Invokes(action, binding)
-	return err
-}
-
-func (c *FakePods) GetLogs(name string, opts *v1.PodLogOptions) *rest.Request {
-	action := testing.GenericActionImpl{}
-	action.Verb = "get"
-	action.Namespace = c.ns
-	action.Resource = podsResource
-	action.Subresource = "logs"
-	action.Value = opts
-
-	_, _ = c.Fake.Invokes(action, &v1.Pod{})
-	return &rest.Request{}
-}

1.4/kubernetes/typed/core/v1/fake/fake_podtemplate.go

@@ -1,117 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_replicationcontroller.go

@@ -1,127 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_resourcequota.go

@@ -1,127 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_secret.go

@@ -1,117 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_service.go

@@ -1,127 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/fake/fake_service_expansion.go

@@ -1,26 +0,0 @@
-/*
-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 fake
-
-import (
-	"k8s.io/client-go/1.4/rest"
-	"k8s.io/client-go/1.4/testing"
-)
-
-func (c *FakeServices) ProxyGet(scheme, name, port, path string, params map[string]string) rest.ResponseWrapper {
-	return c.Fake.InvokesProxy(testing.NewProxyGetAction(servicesResource, c.ns, scheme, name, port, path, params))
-}

1.4/kubernetes/typed/core/v1/fake/fake_serviceaccount.go

@@ -1,117 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/generated_expansion.go

@@ -1,41 +0,0 @@
-/*
-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 LimitRangeExpansion interface{}
-
-type NodeExpansion interface{}
-
-type PersistentVolumeExpansion interface{}
-
-type PersistentVolumeClaimExpansion interface{}
-
-type PodTemplateExpansion interface{}
-
-type ReplicationControllerExpansion interface{}
-
-type ResourceQuotaExpansion interface{}
-
-type SecretExpansion interface{}
-
-type ServiceAccountExpansion interface{}

1.4/kubernetes/typed/core/v1/limitrange.go

@@ -1,151 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/namespace.go

@@ -1,154 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/node.go

@@ -1,154 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/persistentvolume.go

@@ -1,154 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/persistentvolumeclaim.go

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

1.4/kubernetes/typed/core/v1/pod.go

@@ -1,165 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/pod_expansion.go

@@ -1,39 +0,0 @@
-/*
-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 (
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/pkg/api/v1"
-	"k8s.io/client-go/1.4/rest"
-)
-
-// The PodExpansion interface allows manually adding extra methods to the PodInterface.
-type PodExpansion interface {
-	Bind(binding *v1.Binding) error
-	GetLogs(name string, opts *v1.PodLogOptions) *rest.Request
-}
-
-// Bind applies the provided binding to the named pod in the current namespace (binding.Namespace is ignored).
-func (c *pods) Bind(binding *v1.Binding) error {
-	return c.client.Post().Namespace(c.ns).Resource("pods").Name(binding.Name).SubResource("binding").Body(binding).Do().Error()
-}
-
-// Get constructs a request for getting the logs for a pod
-func (c *pods) GetLogs(name string, opts *v1.PodLogOptions) *rest.Request {
-	return c.client.Get().Namespace(c.ns).Name(name).Resource("pods").SubResource("log").VersionedParams(opts, api.ParameterCodec)
-}

1.4/kubernetes/typed/core/v1/podtemplate.go

@@ -1,151 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/replicationcontroller.go

@@ -1,165 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/resourcequota.go

@@ -1,165 +0,0 @@
-/*
-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
-}

1.4/kubernetes/typed/core/v1/secret.go

@@ -1,151 +0,0 @@
-/*
-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
-}