Merge pull request #65410 from nikhita/cherrypick-jsoniter-bump-1.8

Automatic merge from submit-queue.

Manual cherrypick of #65034 to 1.8: make json serializer case sensitive

fixes partially https://github.com/kubernetes/kubernetes/issues/64612

This PR imports the latest jsoniterator library so that case sensitivity during unmarshalling is optional. The PR also sets Kubernetes json serializer to be case sensitive.

**Release note**:

```release-note
ACTION REQUIRED: Kubernetes JSON deserializer is now case-sensitive to restore compatibility with pre-1.8 servers. If your config files contains fields with wrong case, the config files will be now invalid.
```

/sig api-machinery
/kind bug
/assign caesarxuchao liggitt thockin sttts mbohlool

Kubernetes-commit: 14f8f040a211ecce6f848d1eb73be9c6f759bb93

.travis.yml

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

1.5/Godeps/Godeps.json

@@ -1,318 +0,0 @@
-{
-	"ImportPath": "k8s.io/client-go/1.5",
-	"GoVersion": "go1.6",
-	"GodepVersion": "v74",
-	"Packages": [
-		"./..."
-	],
-	"Deps": [
-		{
-			"ImportPath": "cloud.google.com/go/compute/metadata",
-			"Comment": "v0.1.0-115-g3b1ae45",
-			"Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
-		},
-		{
-			"ImportPath": "cloud.google.com/go/internal",
-			"Comment": "v0.1.0-115-g3b1ae45",
-			"Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
-		},
-		{
-			"ImportPath": "github.com/PuerkitoBio/purell",
-			"Comment": "v1.0.0",
-			"Rev": "8a290539e2e8629dbc4e6bad948158f790ec31f4"
-		},
-		{
-			"ImportPath": "github.com/PuerkitoBio/urlesc",
-			"Rev": "5bd2802263f21d8788851d5305584c82a5c75d7e"
-		},
-		{
-			"ImportPath": "github.com/blang/semver",
-			"Comment": "v3.0.1",
-			"Rev": "31b736133b98f26d5e078ec9eb591666edfd091f"
-		},
-		{
-			"ImportPath": "github.com/coreos/go-oidc/http",
-			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
-		},
-		{
-			"ImportPath": "github.com/coreos/go-oidc/jose",
-			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
-		},
-		{
-			"ImportPath": "github.com/coreos/go-oidc/key",
-			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
-		},
-		{
-			"ImportPath": "github.com/coreos/go-oidc/oauth2",
-			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
-		},
-		{
-			"ImportPath": "github.com/coreos/go-oidc/oidc",
-			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
-		},
-		{
-			"ImportPath": "github.com/coreos/pkg/health",
-			"Comment": "v2-8-gfa29b1d",
-			"Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
-		},
-		{
-			"ImportPath": "github.com/coreos/pkg/httputil",
-			"Comment": "v2-8-gfa29b1d",
-			"Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
-		},
-		{
-			"ImportPath": "github.com/coreos/pkg/timeutil",
-			"Comment": "v2-8-gfa29b1d",
-			"Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
-		},
-		{
-			"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/go-openapi/jsonpointer",
-			"Rev": "46af16f9f7b149af66e5d1bd010e3574dc06de98"
-		},
-		{
-			"ImportPath": "github.com/go-openapi/jsonreference",
-			"Rev": "13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272"
-		},
-		{
-			"ImportPath": "github.com/go-openapi/spec",
-			"Rev": "6aced65f8501fe1217321abf0749d354824ba2ff"
-		},
-		{
-			"ImportPath": "github.com/go-openapi/swag",
-			"Rev": "1d0bd113de87027671077d3c71eb3ac5d7dbba72"
-		},
-		{
-			"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/golang/protobuf/proto",
-			"Rev": "8616e8ee5e20a1704615e6c8d7afcdac06087a67"
-		},
-		{
-			"ImportPath": "github.com/google/gofuzz",
-			"Rev": "bbcb9da2d746f8bdbd6a936686a0a6067ada0ec5"
-		},
-		{
-			"ImportPath": "github.com/howeyc/gopass",
-			"Rev": "3ca23474a7c7203e0a0a070fd33508f6efdb9b3d"
-		},
-		{
-			"ImportPath": "github.com/imdario/mergo",
-			"Comment": "0.1.3-8-g6633656",
-			"Rev": "6633656539c1639d9d78127b7d47c622b5d7b6dc"
-		},
-		{
-			"ImportPath": "github.com/jonboulle/clockwork",
-			"Rev": "72f9bd7c4e0c2a40055ab3d0f09654f730cce982"
-		},
-		{
-			"ImportPath": "github.com/juju/ratelimit",
-			"Rev": "77ed1c8a01217656d2080ad51981f6e99adaa177"
-		},
-		{
-			"ImportPath": "github.com/mailru/easyjson/buffer",
-			"Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
-		},
-		{
-			"ImportPath": "github.com/mailru/easyjson/jlexer",
-			"Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
-		},
-		{
-			"ImportPath": "github.com/mailru/easyjson/jwriter",
-			"Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
-		},
-		{
-			"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/crypto/ssh/terminal",
-			"Rev": "1f22c0103821b9390939b6776727195525381532"
-		},
-		{
-			"ImportPath": "golang.org/x/net/context",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/net/context/ctxhttp",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/net/http2",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/net/http2/hpack",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/net/idna",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/net/lex/httplex",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-		},
-		{
-			"ImportPath": "golang.org/x/oauth2",
-			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
-		},
-		{
-			"ImportPath": "golang.org/x/oauth2/google",
-			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
-		},
-		{
-			"ImportPath": "golang.org/x/oauth2/internal",
-			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
-		},
-		{
-			"ImportPath": "golang.org/x/oauth2/jws",
-			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
-		},
-		{
-			"ImportPath": "golang.org/x/oauth2/jwt",
-			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
-		},
-		{
-			"ImportPath": "golang.org/x/sys/unix",
-			"Rev": "9c60d1c508f5134d1ca726b4641db998f2523357"
-		},
-		{
-			"ImportPath": "golang.org/x/text/cases",
-			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-		},
-		{
-			"ImportPath": "golang.org/x/text/internal/tag",
-			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-		},
-		{
-			"ImportPath": "golang.org/x/text/language",
-			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-		},
-		{
-			"ImportPath": "golang.org/x/text/runes",
-			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-		},
-		{
-			"ImportPath": "golang.org/x/text/secure/bidirule",
-			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-		},
-		{
-			"ImportPath": "golang.org/x/text/secure/precis",
-			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-		},
-		{
-			"ImportPath": "golang.org/x/text/transform",
-			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-		},
-		{
-			"ImportPath": "golang.org/x/text/unicode/bidi",
-			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-		},
-		{
-			"ImportPath": "golang.org/x/text/unicode/norm",
-			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-		},
-		{
-			"ImportPath": "golang.org/x/text/width",
-			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/app_identity",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/base",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/datastore",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/log",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/modules",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/remote_api",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "gopkg.in/inf.v0",
-			"Comment": "v0.9.0",
-			"Rev": "3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4"
-		},
-		{
-			"ImportPath": "gopkg.in/yaml.v2",
-			"Rev": "53feefa2559fb8dfa8d81baad31be332c97d6c77"
-		}
-	]
-}

1.5/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.5/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.5/pkg/api"
-	"k8s.io/client-go/1.5/pkg/api/errors"
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/api/v1"
-	"k8s.io/client-go/1.5/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/runtime/serializer"
-	"k8s.io/client-go/1.5/pkg/version"
-	"k8s.io/client-go/1.5/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.5/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.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/api/v1"
-	"k8s.io/client-go/1.5/pkg/version"
-	"k8s.io/client-go/1.5/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.5/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.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/api/v1"
-	"k8s.io/client-go/1.5/pkg/version"
-	"k8s.io/client-go/1.5/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.5/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.5/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.5/kubernetes/clientset.go

@@ -1,261 +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.5/discovery"
-	v1alpha1apps "k8s.io/client-go/1.5/kubernetes/typed/apps/v1alpha1"
-	v1beta1authentication "k8s.io/client-go/1.5/kubernetes/typed/authentication/v1beta1"
-	v1beta1authorization "k8s.io/client-go/1.5/kubernetes/typed/authorization/v1beta1"
-	v1autoscaling "k8s.io/client-go/1.5/kubernetes/typed/autoscaling/v1"
-	v1batch "k8s.io/client-go/1.5/kubernetes/typed/batch/v1"
-	v1alpha1certificates "k8s.io/client-go/1.5/kubernetes/typed/certificates/v1alpha1"
-	v1core "k8s.io/client-go/1.5/kubernetes/typed/core/v1"
-	v1beta1extensions "k8s.io/client-go/1.5/kubernetes/typed/extensions/v1beta1"
-	v1alpha1policy "k8s.io/client-go/1.5/kubernetes/typed/policy/v1alpha1"
-	v1alpha1rbac "k8s.io/client-go/1.5/kubernetes/typed/rbac/v1alpha1"
-	v1beta1storage "k8s.io/client-go/1.5/kubernetes/typed/storage/v1beta1"
-	"k8s.io/client-go/1.5/pkg/util/flowcontrol"
-	_ "k8s.io/client-go/1.5/plugin/pkg/client/auth"
-	rest "k8s.io/client-go/1.5/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.5/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_5 --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.5/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.5/discovery"
-	fakediscovery "k8s.io/client-go/1.5/discovery/fake"
-	clientset "k8s.io/client-go/1.5/kubernetes"
-	v1alpha1apps "k8s.io/client-go/1.5/kubernetes/typed/apps/v1alpha1"
-	fakev1alpha1apps "k8s.io/client-go/1.5/kubernetes/typed/apps/v1alpha1/fake"
-	v1beta1authentication "k8s.io/client-go/1.5/kubernetes/typed/authentication/v1beta1"
-	fakev1beta1authentication "k8s.io/client-go/1.5/kubernetes/typed/authentication/v1beta1/fake"
-	v1beta1authorization "k8s.io/client-go/1.5/kubernetes/typed/authorization/v1beta1"
-	fakev1beta1authorization "k8s.io/client-go/1.5/kubernetes/typed/authorization/v1beta1/fake"
-	v1autoscaling "k8s.io/client-go/1.5/kubernetes/typed/autoscaling/v1"
-	fakev1autoscaling "k8s.io/client-go/1.5/kubernetes/typed/autoscaling/v1/fake"
-	v1batch "k8s.io/client-go/1.5/kubernetes/typed/batch/v1"
-	fakev1batch "k8s.io/client-go/1.5/kubernetes/typed/batch/v1/fake"
-	v1alpha1certificates "k8s.io/client-go/1.5/kubernetes/typed/certificates/v1alpha1"
-	fakev1alpha1certificates "k8s.io/client-go/1.5/kubernetes/typed/certificates/v1alpha1/fake"
-	v1core "k8s.io/client-go/1.5/kubernetes/typed/core/v1"
-	fakev1core "k8s.io/client-go/1.5/kubernetes/typed/core/v1/fake"
-	v1beta1extensions "k8s.io/client-go/1.5/kubernetes/typed/extensions/v1beta1"
-	fakev1beta1extensions "k8s.io/client-go/1.5/kubernetes/typed/extensions/v1beta1/fake"
-	v1alpha1policy "k8s.io/client-go/1.5/kubernetes/typed/policy/v1alpha1"
-	fakev1alpha1policy "k8s.io/client-go/1.5/kubernetes/typed/policy/v1alpha1/fake"
-	v1alpha1rbac "k8s.io/client-go/1.5/kubernetes/typed/rbac/v1alpha1"
-	fakev1alpha1rbac "k8s.io/client-go/1.5/kubernetes/typed/rbac/v1alpha1/fake"
-	v1beta1storage "k8s.io/client-go/1.5/kubernetes/typed/storage/v1beta1"
-	fakev1beta1storage "k8s.io/client-go/1.5/kubernetes/typed/storage/v1beta1/fake"
-	"k8s.io/client-go/1.5/pkg/api"
-	"k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.5/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/watch"
-	"k8s.io/client-go/1.5/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.5/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_5 --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.5/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.5/pkg/api/install"
-	"k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	_ "k8s.io/client-go/1.5/pkg/apis/apps/install"
-	_ "k8s.io/client-go/1.5/pkg/apis/authentication/install"
-	_ "k8s.io/client-go/1.5/pkg/apis/authorization/install"
-	_ "k8s.io/client-go/1.5/pkg/apis/autoscaling/install"
-	_ "k8s.io/client-go/1.5/pkg/apis/batch/install"
-	_ "k8s.io/client-go/1.5/pkg/apis/certificates/install"
-	_ "k8s.io/client-go/1.5/pkg/apis/extensions/install"
-	_ "k8s.io/client-go/1.5/pkg/apis/policy/install"
-	_ "k8s.io/client-go/1.5/pkg/apis/rbac/install"
-	_ "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	registered "k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.5/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.5/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.5/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_5 --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.5/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_5 --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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1alpha1 "k8s.io/client-go/1.5/pkg/apis/apps/v1alpha1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	v1alpha1 "k8s.io/client-go/1.5/pkg/apis/apps/v1alpha1"
-	watch "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	registered "k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.5/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.5/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.5/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_5 --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.5/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_5 --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.5/kubernetes/typed/authorization/v1beta1/authorization_client.go

@@ -1,106 +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.5/pkg/api"
-	registered "k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.5/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.5/rest"
-)
-
-type AuthorizationInterface interface {
-	GetRESTClient() *rest.RESTClient
-	LocalSubjectAccessReviewsGetter
-	SelfSubjectAccessReviewsGetter
-	SubjectAccessReviewsGetter
-}
-
-// AuthorizationClient is used to interact with features provided by the Authorization group.
-type AuthorizationClient struct {
-	*rest.RESTClient
-}
-
-func (c *AuthorizationClient) LocalSubjectAccessReviews(namespace string) LocalSubjectAccessReviewInterface {
-	return newLocalSubjectAccessReviews(c, namespace)
-}
-
-func (c *AuthorizationClient) SelfSubjectAccessReviews() SelfSubjectAccessReviewInterface {
-	return newSelfSubjectAccessReviews(c)
-}
-
-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.5/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_5 --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.5/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_5 --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.5/kubernetes/typed/authorization/v1beta1/fake/fake_authorization_client.go

@@ -1,45 +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.5/kubernetes/typed/authorization/v1beta1"
-	rest "k8s.io/client-go/1.5/rest"
-	testing "k8s.io/client-go/1.5/testing"
-)
-
-type FakeAuthorization struct {
-	*testing.Fake
-}
-
-func (c *FakeAuthorization) LocalSubjectAccessReviews(namespace string) v1beta1.LocalSubjectAccessReviewInterface {
-	return &FakeLocalSubjectAccessReviews{c, namespace}
-}
-
-func (c *FakeAuthorization) SelfSubjectAccessReviews() v1beta1.SelfSubjectAccessReviewInterface {
-	return &FakeSelfSubjectAccessReviews{c}
-}
-
-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.5/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.5/pkg/api"
-	registered "k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.5/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.5/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.5/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_5 --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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/apis/autoscaling/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	registered "k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.5/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.5/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.5/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_5 --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.5/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_5 --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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/apis/batch/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	registered "k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.5/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.5/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.5/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_5 --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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1alpha1 "k8s.io/client-go/1.5/pkg/apis/certificates/v1alpha1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	registered "k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.5/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.5/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.5/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_5 --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.5/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_5 --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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/kubernetes/typed/core/v1"
-	rest "k8s.io/client-go/1.5/rest"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1 "k8s.io/client-go/1.5/pkg/api/v1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/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.5/kubernetes/typed/extensions/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_5 --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.5/kubernetes/typed/extensions/v1beta1/extensions_client.go

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

1.5/kubernetes/typed/extensions/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_5 --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.5/kubernetes/typed/extensions/v1beta1/fake/fake_extensions_client.go

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

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

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

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

1.5/kubernetes/typed/policy/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_5 --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.5/kubernetes/typed/policy/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_5 --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.5/kubernetes/typed/policy/v1alpha1/fake/fake_poddisruptionbudget.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.5/pkg/api"
-	unversioned "k8s.io/client-go/1.5/pkg/api/unversioned"
-	v1alpha1 "k8s.io/client-go/1.5/pkg/apis/policy/v1alpha1"
-	labels "k8s.io/client-go/1.5/pkg/labels"
-	watch "k8s.io/client-go/1.5/pkg/watch"
-	testing "k8s.io/client-go/1.5/testing"
-)
-
-// FakePodDisruptionBudgets implements PodDisruptionBudgetInterface
-type FakePodDisruptionBudgets struct {
-	Fake *FakePolicy
-	ns   string
-}
-
-var poddisruptionbudgetsResource = unversioned.GroupVersionResource{Group: "policy", Version: "v1alpha1", Resource: "poddisruptionbudgets"}
-
-func (c *FakePodDisruptionBudgets) Create(podDisruptionBudget *v1alpha1.PodDisruptionBudget) (result *v1alpha1.PodDisruptionBudget, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewCreateAction(poddisruptionbudgetsResource, c.ns, podDisruptionBudget), &v1alpha1.PodDisruptionBudget{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PodDisruptionBudget), err
-}
-
-func (c *FakePodDisruptionBudgets) Update(podDisruptionBudget *v1alpha1.PodDisruptionBudget) (result *v1alpha1.PodDisruptionBudget, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewUpdateAction(poddisruptionbudgetsResource, c.ns, podDisruptionBudget), &v1alpha1.PodDisruptionBudget{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PodDisruptionBudget), err
-}
-
-func (c *FakePodDisruptionBudgets) UpdateStatus(podDisruptionBudget *v1alpha1.PodDisruptionBudget) (*v1alpha1.PodDisruptionBudget, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewUpdateSubresourceAction(poddisruptionbudgetsResource, "status", c.ns, podDisruptionBudget), &v1alpha1.PodDisruptionBudget{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PodDisruptionBudget), err
-}
-
-func (c *FakePodDisruptionBudgets) Delete(name string, options *api.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewDeleteAction(poddisruptionbudgetsResource, c.ns, name), &v1alpha1.PodDisruptionBudget{})
-
-	return err
-}
-
-func (c *FakePodDisruptionBudgets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
-	action := testing.NewDeleteCollectionAction(poddisruptionbudgetsResource, c.ns, listOptions)
-
-	_, err := c.Fake.Invokes(action, &v1alpha1.PodDisruptionBudgetList{})
-	return err
-}
-
-func (c *FakePodDisruptionBudgets) Get(name string) (result *v1alpha1.PodDisruptionBudget, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewGetAction(poddisruptionbudgetsResource, c.ns, name), &v1alpha1.PodDisruptionBudget{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PodDisruptionBudget), err
-}
-
-func (c *FakePodDisruptionBudgets) List(opts api.ListOptions) (result *v1alpha1.PodDisruptionBudgetList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewListAction(poddisruptionbudgetsResource, c.ns, opts), &v1alpha1.PodDisruptionBudgetList{})
-
-	if obj == nil {
-		return nil, err
-	}
-
-	label := opts.LabelSelector
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &v1alpha1.PodDisruptionBudgetList{}
-	for _, item := range obj.(*v1alpha1.PodDisruptionBudgetList).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 podDisruptionBudgets.
-func (c *FakePodDisruptionBudgets) Watch(opts api.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewWatchAction(poddisruptionbudgetsResource, c.ns, opts))
-
-}
-
-// Patch applies the patch and returns the patched podDisruptionBudget.
-func (c *FakePodDisruptionBudgets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1alpha1.PodDisruptionBudget, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(poddisruptionbudgetsResource, c.ns, name, data, subresources...), &v1alpha1.PodDisruptionBudget{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PodDisruptionBudget), err
-}

1.5/kubernetes/typed/policy/v1alpha1/policy_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.5/pkg/api"
-	registered "k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.5/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.5/rest"
-)
-
-type PolicyInterface interface {
-	GetRESTClient() *rest.RESTClient
-	PodDisruptionBudgetsGetter
-}
-
-// PolicyClient is used to interact with features provided by the Policy group.
-type PolicyClient struct {
-	*rest.RESTClient
-}
-
-func (c *PolicyClient) PodDisruptionBudgets(namespace string) PodDisruptionBudgetInterface {
-	return newPodDisruptionBudgets(c, namespace)
-}
-
-// NewForConfig creates a new PolicyClient for the given config.
-func NewForConfig(c *rest.Config) (*PolicyClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &PolicyClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new PolicyClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *PolicyClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new PolicyClient for the given RESTClient.
-func New(c *rest.RESTClient) *PolicyClient {
-	return &PolicyClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if policy group is not registered, return an error
-	g, err := registered.Group("policy")
-	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 *PolicyClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.5/kubernetes/typed/rbac/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_5 --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.5/kubernetes/typed/rbac/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_5 --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.5/kubernetes/typed/rbac/v1alpha1/rbac_client.go

@@ -1,111 +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.5/pkg/api"
-	registered "k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.5/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.5/rest"
-)
-
-type RbacInterface interface {
-	GetRESTClient() *rest.RESTClient
-	ClusterRolesGetter
-	ClusterRoleBindingsGetter
-	RolesGetter
-	RoleBindingsGetter
-}
-
-// RbacClient is used to interact with features provided by the Rbac group.
-type RbacClient struct {
-	*rest.RESTClient
-}
-
-func (c *RbacClient) ClusterRoles() ClusterRoleInterface {
-	return newClusterRoles(c)
-}
-
-func (c *RbacClient) ClusterRoleBindings() ClusterRoleBindingInterface {
-	return newClusterRoleBindings(c)
-}
-
-func (c *RbacClient) Roles(namespace string) RoleInterface {
-	return newRoles(c, namespace)
-}
-
-func (c *RbacClient) RoleBindings(namespace string) RoleBindingInterface {
-	return newRoleBindings(c, namespace)
-}
-
-// NewForConfig creates a new RbacClient for the given config.
-func NewForConfig(c *rest.Config) (*RbacClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &RbacClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new RbacClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *RbacClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new RbacClient for the given RESTClient.
-func New(c *rest.RESTClient) *RbacClient {
-	return &RbacClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if rbac group is not registered, return an error
-	g, err := registered.Group("rbac.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 *RbacClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.5/kubernetes/typed/storage/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_5 --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.5/kubernetes/typed/storage/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_5 --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.5/kubernetes/typed/storage/v1beta1/storage_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.5/pkg/api"
-	registered "k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	serializer "k8s.io/client-go/1.5/pkg/runtime/serializer"
-	rest "k8s.io/client-go/1.5/rest"
-)
-
-type StorageInterface interface {
-	GetRESTClient() *rest.RESTClient
-	StorageClassesGetter
-}
-
-// StorageClient is used to interact with features provided by the Storage group.
-type StorageClient struct {
-	*rest.RESTClient
-}
-
-func (c *StorageClient) StorageClasses() StorageClassInterface {
-	return newStorageClasses(c)
-}
-
-// NewForConfig creates a new StorageClient for the given config.
-func NewForConfig(c *rest.Config) (*StorageClient, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &StorageClient{client}, nil
-}
-
-// NewForConfigOrDie creates a new StorageClient for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *StorageClient {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new StorageClient for the given RESTClient.
-func New(c *rest.RESTClient) *StorageClient {
-	return &StorageClient{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	// if storage group is not registered, return an error
-	g, err := registered.Group("storage.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 *StorageClient) GetRESTClient() *rest.RESTClient {
-	if c == nil {
-		return nil
-	}
-	return c.RESTClient
-}

1.5/pkg/api/OWNERS

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

1.5/pkg/api/context.go

@@ -1,152 +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 api
-
-import (
-	stderrs "errors"
-	"time"
-
-	"golang.org/x/net/context"
-	"k8s.io/client-go/1.5/pkg/auth/user"
-	"k8s.io/client-go/1.5/pkg/types"
-)
-
-// Context carries values across API boundaries.
-// This context matches the context.Context interface
-// (https://blog.golang.org/context), for the purposes
-// of passing the api.Context through to the storage tier.
-// TODO: Determine the extent that this abstraction+interface
-// is used by the api, and whether we can remove.
-type Context interface {
-	// Value returns the value associated with key or nil if none.
-	Value(key interface{}) interface{}
-
-	// Deadline returns the time when this Context will be canceled, if any.
-	Deadline() (deadline time.Time, ok bool)
-
-	// Done returns a channel that is closed when this Context is canceled
-	// or times out.
-	Done() <-chan struct{}
-
-	// Err indicates why this context was canceled, after the Done channel
-	// is closed.
-	Err() error
-}
-
-// The key type is unexported to prevent collisions
-type key int
-
-const (
-	// namespaceKey is the context key for the request namespace.
-	namespaceKey key = iota
-
-	// userKey is the context key for the request user.
-	userKey
-
-	// uidKey is the context key for the uid to assign to an object on create.
-	uidKey
-
-	// userAgentKey is the context key for the request user agent.
-	userAgentKey
-)
-
-// NewContext instantiates a base context object for request flows.
-func NewContext() Context {
-	return context.TODO()
-}
-
-// NewDefaultContext instantiates a base context object for request flows in the default namespace
-func NewDefaultContext() Context {
-	return WithNamespace(NewContext(), NamespaceDefault)
-}
-
-// WithValue returns a copy of parent in which the value associated with key is val.
-func WithValue(parent Context, key interface{}, val interface{}) Context {
-	internalCtx, ok := parent.(context.Context)
-	if !ok {
-		panic(stderrs.New("Invalid context type"))
-	}
-	return context.WithValue(internalCtx, key, val)
-}
-
-// WithNamespace returns a copy of parent in which the namespace value is set
-func WithNamespace(parent Context, namespace string) Context {
-	return WithValue(parent, namespaceKey, namespace)
-}
-
-// NamespaceFrom returns the value of the namespace key on the ctx
-func NamespaceFrom(ctx Context) (string, bool) {
-	namespace, ok := ctx.Value(namespaceKey).(string)
-	return namespace, ok
-}
-
-// NamespaceValue returns the value of the namespace key on the ctx, or the empty string if none
-func NamespaceValue(ctx Context) string {
-	namespace, _ := NamespaceFrom(ctx)
-	return namespace
-}
-
-// ValidNamespace returns false if the namespace on the context differs from the resource.  If the resource has no namespace, it is set to the value in the context.
-func ValidNamespace(ctx Context, resource *ObjectMeta) bool {
-	ns, ok := NamespaceFrom(ctx)
-	if len(resource.Namespace) == 0 {
-		resource.Namespace = ns
-	}
-	return ns == resource.Namespace && ok
-}
-
-// WithNamespaceDefaultIfNone returns a context whose namespace is the default if and only if the parent context has no namespace value
-func WithNamespaceDefaultIfNone(parent Context) Context {
-	namespace, ok := NamespaceFrom(parent)
-	if !ok || len(namespace) == 0 {
-		return WithNamespace(parent, NamespaceDefault)
-	}
-	return parent
-}
-
-// WithUser returns a copy of parent in which the user value is set
-func WithUser(parent Context, user user.Info) Context {
-	return WithValue(parent, userKey, user)
-}
-
-// UserFrom returns the value of the user key on the ctx
-func UserFrom(ctx Context) (user.Info, bool) {
-	user, ok := ctx.Value(userKey).(user.Info)
-	return user, ok
-}
-
-// WithUID returns a copy of parent in which the uid value is set
-func WithUID(parent Context, uid types.UID) Context {
-	return WithValue(parent, uidKey, uid)
-}
-
-// UIDFrom returns the value of the uid key on the ctx
-func UIDFrom(ctx Context) (types.UID, bool) {
-	uid, ok := ctx.Value(uidKey).(types.UID)
-	return uid, ok
-}
-
-// WithUserAgent returns a copy of parent in which the user value is set
-func WithUserAgent(parent Context, userAgent string) Context {
-	return WithValue(parent, userAgentKey, userAgent)
-}
-
-// UserAgentFrom returns the value of the userAgent key on the ctx
-func UserAgentFrom(ctx Context) (string, bool) {
-	userAgent, ok := ctx.Value(userAgentKey).(string)
-	return userAgent, ok
-}

1.5/pkg/api/conversion.go

@@ -1,245 +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 api
-
-import (
-	"fmt"
-
-	"k8s.io/client-go/1.5/pkg/api/resource"
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/conversion"
-	"k8s.io/client-go/1.5/pkg/fields"
-	"k8s.io/client-go/1.5/pkg/labels"
-	"k8s.io/client-go/1.5/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/util/intstr"
-	utillabels "k8s.io/client-go/1.5/pkg/util/labels"
-	"k8s.io/client-go/1.5/pkg/util/validation/field"
-)
-
-func addConversionFuncs(scheme *runtime.Scheme) error {
-	return scheme.AddConversionFuncs(
-		Convert_unversioned_TypeMeta_To_unversioned_TypeMeta,
-
-		Convert_unversioned_ListMeta_To_unversioned_ListMeta,
-
-		Convert_intstr_IntOrString_To_intstr_IntOrString,
-
-		Convert_unversioned_Time_To_unversioned_Time,
-
-		Convert_Slice_string_To_unversioned_Time,
-
-		Convert_resource_Quantity_To_resource_Quantity,
-
-		Convert_string_To_labels_Selector,
-		Convert_labels_Selector_To_string,
-
-		Convert_string_To_fields_Selector,
-		Convert_fields_Selector_To_string,
-
-		Convert_Pointer_bool_To_bool,
-		Convert_bool_To_Pointer_bool,
-
-		Convert_Pointer_string_To_string,
-		Convert_string_To_Pointer_string,
-
-		Convert_Pointer_int64_To_int,
-		Convert_int_To_Pointer_int64,
-
-		Convert_Pointer_int32_To_int32,
-		Convert_int32_To_Pointer_int32,
-
-		Convert_Pointer_float64_To_float64,
-		Convert_float64_To_Pointer_float64,
-
-		Convert_map_to_unversioned_LabelSelector,
-		Convert_unversioned_LabelSelector_to_map,
-	)
-}
-
-func Convert_Pointer_float64_To_float64(in **float64, out *float64, s conversion.Scope) error {
-	if *in == nil {
-		*out = 0
-		return nil
-	}
-	*out = float64(**in)
-	return nil
-}
-
-func Convert_float64_To_Pointer_float64(in *float64, out **float64, s conversion.Scope) error {
-	temp := float64(*in)
-	*out = &temp
-	return nil
-}
-
-func Convert_Pointer_int32_To_int32(in **int32, out *int32, s conversion.Scope) error {
-	if *in == nil {
-		*out = 0
-		return nil
-	}
-	*out = int32(**in)
-	return nil
-}
-
-func Convert_int32_To_Pointer_int32(in *int32, out **int32, s conversion.Scope) error {
-	temp := int32(*in)
-	*out = &temp
-	return nil
-}
-
-func Convert_Pointer_int64_To_int(in **int64, out *int, s conversion.Scope) error {
-	if *in == nil {
-		*out = 0
-		return nil
-	}
-	*out = int(**in)
-	return nil
-}
-
-func Convert_int_To_Pointer_int64(in *int, out **int64, s conversion.Scope) error {
-	temp := int64(*in)
-	*out = &temp
-	return nil
-}
-
-func Convert_Pointer_string_To_string(in **string, out *string, s conversion.Scope) error {
-	if *in == nil {
-		*out = ""
-		return nil
-	}
-	*out = **in
-	return nil
-}
-
-func Convert_string_To_Pointer_string(in *string, out **string, s conversion.Scope) error {
-	if in == nil {
-		stringVar := ""
-		*out = &stringVar
-		return nil
-	}
-	*out = in
-	return nil
-}
-
-func Convert_Pointer_bool_To_bool(in **bool, out *bool, s conversion.Scope) error {
-	if *in == nil {
-		*out = false
-		return nil
-	}
-	*out = **in
-	return nil
-}
-
-func Convert_bool_To_Pointer_bool(in *bool, out **bool, s conversion.Scope) error {
-	if in == nil {
-		boolVar := false
-		*out = &boolVar
-		return nil
-	}
-	*out = in
-	return nil
-}
-
-func Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(in, out *unversioned.TypeMeta, s conversion.Scope) error {
-	// These values are explicitly not copied
-	//out.APIVersion = in.APIVersion
-	//out.Kind = in.Kind
-	return nil
-}
-
-func Convert_unversioned_ListMeta_To_unversioned_ListMeta(in, out *unversioned.ListMeta, s conversion.Scope) error {
-	*out = *in
-	return nil
-}
-
-func Convert_intstr_IntOrString_To_intstr_IntOrString(in, out *intstr.IntOrString, s conversion.Scope) error {
-	*out = *in
-	return nil
-}
-
-func Convert_unversioned_Time_To_unversioned_Time(in *unversioned.Time, out *unversioned.Time, s conversion.Scope) error {
-	// Cannot deep copy these, because time.Time has unexported fields.
-	*out = *in
-	return nil
-}
-
-// Convert_Slice_string_To_unversioned_Time allows converting a URL query parameter value
-func Convert_Slice_string_To_unversioned_Time(input *[]string, out *unversioned.Time, s conversion.Scope) error {
-	str := ""
-	if len(*input) > 0 {
-		str = (*input)[0]
-	}
-	return out.UnmarshalQueryParameter(str)
-}
-
-func Convert_string_To_labels_Selector(in *string, out *labels.Selector, s conversion.Scope) error {
-	selector, err := labels.Parse(*in)
-	if err != nil {
-		return err
-	}
-	*out = selector
-	return nil
-}
-
-func Convert_string_To_fields_Selector(in *string, out *fields.Selector, s conversion.Scope) error {
-	selector, err := fields.ParseSelector(*in)
-	if err != nil {
-		return err
-	}
-	*out = selector
-	return nil
-}
-
-func Convert_labels_Selector_To_string(in *labels.Selector, out *string, s conversion.Scope) error {
-	if *in == nil {
-		return nil
-	}
-	*out = (*in).String()
-	return nil
-}
-
-func Convert_fields_Selector_To_string(in *fields.Selector, out *string, s conversion.Scope) error {
-	if *in == nil {
-		return nil
-	}
-	*out = (*in).String()
-	return nil
-}
-
-func Convert_resource_Quantity_To_resource_Quantity(in *resource.Quantity, out *resource.Quantity, s conversion.Scope) error {
-	*out = *in
-	return nil
-}
-
-func Convert_map_to_unversioned_LabelSelector(in *map[string]string, out *unversioned.LabelSelector, s conversion.Scope) error {
-	if in == nil {
-		return nil
-	}
-	out = new(unversioned.LabelSelector)
-	for labelKey, labelValue := range *in {
-		utillabels.AddLabelToSelector(out, labelKey, labelValue)
-	}
-	return nil
-}
-
-func Convert_unversioned_LabelSelector_to_map(in *unversioned.LabelSelector, out *map[string]string, s conversion.Scope) error {
-	var err error
-	*out, err = unversioned.LabelSelectorAsMap(in)
-	if err != nil {
-		err = field.Invalid(field.NewPath("labelSelector"), *in, fmt.Sprintf("cannot convert to old selector: %v", err))
-	}
-	return err
-}

1.5/pkg/api/defaults.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 api
-
-import (
-	"k8s.io/client-go/1.5/pkg/fields"
-	"k8s.io/client-go/1.5/pkg/labels"
-	"k8s.io/client-go/1.5/pkg/runtime"
-)
-
-func addDefaultingFuncs(scheme *runtime.Scheme) error {
-	return scheme.AddDefaultingFuncs(
-		func(obj *ListOptions) {
-			if obj.LabelSelector == nil {
-				obj.LabelSelector = labels.Everything()
-			}
-			if obj.FieldSelector == nil {
-				obj.FieldSelector = fields.Everything()
-			}
-		},
-	)
-}

1.5/pkg/api/doc.go

@@ -1,24 +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.
-*/
-
-// +k8s:deepcopy-gen=package,register
-
-// Package api contains the latest (or "internal") version of the
-// Kubernetes API objects. This is the API objects as represented in memory.
-// The contract presented to clients is located in the versioned packages,
-// which are sub-directories. The first one is "v1". Those packages
-// describe how a particular version is serialized to storage/network.
-package api

1.5/pkg/api/errors/doc.go

@@ -1,18 +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 errors provides detailed error types for api field validation.
-package errors

1.5/pkg/api/errors/errors.go

@@ -1,461 +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 errors
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"strings"
-
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/util/validation/field"
-)
-
-// HTTP Status codes not in the golang http package.
-const (
-	StatusUnprocessableEntity = 422
-	StatusTooManyRequests     = 429
-	// HTTP recommendations are for servers to define 5xx error codes
-	// for scenarios not covered by behavior. In this case, ServerTimeout
-	// is an indication that a transient server error has occurred and the
-	// client *should* retry, with an optional Retry-After header to specify
-	// the back off window.
-	StatusServerTimeout = 504
-)
-
-// StatusError is an error intended for consumption by a REST API server; it can also be
-// reconstructed by clients from a REST response. Public to allow easy type switches.
-type StatusError struct {
-	ErrStatus unversioned.Status
-}
-
-// APIStatus is exposed by errors that can be converted to an api.Status object
-// for finer grained details.
-type APIStatus interface {
-	Status() unversioned.Status
-}
-
-var _ error = &StatusError{}
-
-// Error implements the Error interface.
-func (e *StatusError) Error() string {
-	return e.ErrStatus.Message
-}
-
-// Status allows access to e's status without having to know the detailed workings
-// of StatusError. Used by pkg/apiserver.
-func (e *StatusError) Status() unversioned.Status {
-	return e.ErrStatus
-}
-
-// DebugError reports extended info about the error to debug output.
-func (e *StatusError) DebugError() (string, []interface{}) {
-	if out, err := json.MarshalIndent(e.ErrStatus, "", "  "); err == nil {
-		return "server response object: %s", []interface{}{string(out)}
-	}
-	return "server response object: %#v", []interface{}{e.ErrStatus}
-}
-
-// UnexpectedObjectError can be returned by FromObject if it's passed a non-status object.
-type UnexpectedObjectError struct {
-	Object runtime.Object
-}
-
-// Error returns an error message describing 'u'.
-func (u *UnexpectedObjectError) Error() string {
-	return fmt.Sprintf("unexpected object: %v", u.Object)
-}
-
-// FromObject generates an StatusError from an unversioned.Status, if that is the type of obj; otherwise,
-// returns an UnexpecteObjectError.
-func FromObject(obj runtime.Object) error {
-	switch t := obj.(type) {
-	case *unversioned.Status:
-		return &StatusError{*t}
-	}
-	return &UnexpectedObjectError{obj}
-}
-
-// NewNotFound returns a new error which indicates that the resource of the kind and the name was not found.
-func NewNotFound(qualifiedResource unversioned.GroupResource, name string) *StatusError {
-	return &StatusError{unversioned.Status{
-		Status: unversioned.StatusFailure,
-		Code:   http.StatusNotFound,
-		Reason: unversioned.StatusReasonNotFound,
-		Details: &unversioned.StatusDetails{
-			Group: qualifiedResource.Group,
-			Kind:  qualifiedResource.Resource,
-			Name:  name,
-		},
-		Message: fmt.Sprintf("%s %q not found", qualifiedResource.String(), name),
-	}}
-}
-
-// NewAlreadyExists returns an error indicating the item requested exists by that identifier.
-func NewAlreadyExists(qualifiedResource unversioned.GroupResource, name string) *StatusError {
-	return &StatusError{unversioned.Status{
-		Status: unversioned.StatusFailure,
-		Code:   http.StatusConflict,
-		Reason: unversioned.StatusReasonAlreadyExists,
-		Details: &unversioned.StatusDetails{
-			Group: qualifiedResource.Group,
-			Kind:  qualifiedResource.Resource,
-			Name:  name,
-		},
-		Message: fmt.Sprintf("%s %q already exists", qualifiedResource.String(), name),
-	}}
-}
-
-// NewUnauthorized returns an error indicating the client is not authorized to perform the requested
-// action.
-func NewUnauthorized(reason string) *StatusError {
-	message := reason
-	if len(message) == 0 {
-		message = "not authorized"
-	}
-	return &StatusError{unversioned.Status{
-		Status:  unversioned.StatusFailure,
-		Code:    http.StatusUnauthorized,
-		Reason:  unversioned.StatusReasonUnauthorized,
-		Message: message,
-	}}
-}
-
-// NewForbidden returns an error indicating the requested action was forbidden
-func NewForbidden(qualifiedResource unversioned.GroupResource, name string, err error) *StatusError {
-	return &StatusError{unversioned.Status{
-		Status: unversioned.StatusFailure,
-		Code:   http.StatusForbidden,
-		Reason: unversioned.StatusReasonForbidden,
-		Details: &unversioned.StatusDetails{
-			Group: qualifiedResource.Group,
-			Kind:  qualifiedResource.Resource,
-			Name:  name,
-		},
-		Message: fmt.Sprintf("%s %q is forbidden: %v", qualifiedResource.String(), name, err),
-	}}
-}
-
-// NewConflict returns an error indicating the item can't be updated as provided.
-func NewConflict(qualifiedResource unversioned.GroupResource, name string, err error) *StatusError {
-	return &StatusError{unversioned.Status{
-		Status: unversioned.StatusFailure,
-		Code:   http.StatusConflict,
-		Reason: unversioned.StatusReasonConflict,
-		Details: &unversioned.StatusDetails{
-			Group: qualifiedResource.Group,
-			Kind:  qualifiedResource.Resource,
-			Name:  name,
-		},
-		Message: fmt.Sprintf("Operation cannot be fulfilled on %s %q: %v", qualifiedResource.String(), name, err),
-	}}
-}
-
-// NewGone returns an error indicating the item no longer available at the server and no forwarding address is known.
-func NewGone(message string) *StatusError {
-	return &StatusError{unversioned.Status{
-		Status:  unversioned.StatusFailure,
-		Code:    http.StatusGone,
-		Reason:  unversioned.StatusReasonGone,
-		Message: message,
-	}}
-}
-
-// NewInvalid returns an error indicating the item is invalid and cannot be processed.
-func NewInvalid(qualifiedKind unversioned.GroupKind, name string, errs field.ErrorList) *StatusError {
-	causes := make([]unversioned.StatusCause, 0, len(errs))
-	for i := range errs {
-		err := errs[i]
-		causes = append(causes, unversioned.StatusCause{
-			Type:    unversioned.CauseType(err.Type),
-			Message: err.ErrorBody(),
-			Field:   err.Field,
-		})
-	}
-	return &StatusError{unversioned.Status{
-		Status: unversioned.StatusFailure,
-		Code:   StatusUnprocessableEntity, // RFC 4918: StatusUnprocessableEntity
-		Reason: unversioned.StatusReasonInvalid,
-		Details: &unversioned.StatusDetails{
-			Group:  qualifiedKind.Group,
-			Kind:   qualifiedKind.Kind,
-			Name:   name,
-			Causes: causes,
-		},
-		Message: fmt.Sprintf("%s %q is invalid: %v", qualifiedKind.String(), name, errs.ToAggregate()),
-	}}
-}
-
-// NewBadRequest creates an error that indicates that the request is invalid and can not be processed.
-func NewBadRequest(reason string) *StatusError {
-	return &StatusError{unversioned.Status{
-		Status:  unversioned.StatusFailure,
-		Code:    http.StatusBadRequest,
-		Reason:  unversioned.StatusReasonBadRequest,
-		Message: reason,
-	}}
-}
-
-// NewServiceUnavailable creates an error that indicates that the requested service is unavailable.
-func NewServiceUnavailable(reason string) *StatusError {
-	return &StatusError{unversioned.Status{
-		Status:  unversioned.StatusFailure,
-		Code:    http.StatusServiceUnavailable,
-		Reason:  unversioned.StatusReasonServiceUnavailable,
-		Message: reason,
-	}}
-}
-
-// NewMethodNotSupported returns an error indicating the requested action is not supported on this kind.
-func NewMethodNotSupported(qualifiedResource unversioned.GroupResource, action string) *StatusError {
-	return &StatusError{unversioned.Status{
-		Status: unversioned.StatusFailure,
-		Code:   http.StatusMethodNotAllowed,
-		Reason: unversioned.StatusReasonMethodNotAllowed,
-		Details: &unversioned.StatusDetails{
-			Group: qualifiedResource.Group,
-			Kind:  qualifiedResource.Resource,
-		},
-		Message: fmt.Sprintf("%s is not supported on resources of kind %q", action, qualifiedResource.String()),
-	}}
-}
-
-// NewServerTimeout returns an error indicating the requested action could not be completed due to a
-// transient error, and the client should try again.
-func NewServerTimeout(qualifiedResource unversioned.GroupResource, operation string, retryAfterSeconds int) *StatusError {
-	return &StatusError{unversioned.Status{
-		Status: unversioned.StatusFailure,
-		Code:   http.StatusInternalServerError,
-		Reason: unversioned.StatusReasonServerTimeout,
-		Details: &unversioned.StatusDetails{
-			Group:             qualifiedResource.Group,
-			Kind:              qualifiedResource.Resource,
-			Name:              operation,
-			RetryAfterSeconds: int32(retryAfterSeconds),
-		},
-		Message: fmt.Sprintf("The %s operation against %s could not be completed at this time, please try again.", operation, qualifiedResource.String()),
-	}}
-}
-
-// NewServerTimeoutForKind should not exist.  Server timeouts happen when accessing resources, the Kind is just what we
-// happened to be looking at when the request failed.  This delegates to keep code sane, but we should work towards removing this.
-func NewServerTimeoutForKind(qualifiedKind unversioned.GroupKind, operation string, retryAfterSeconds int) *StatusError {
-	return NewServerTimeout(unversioned.GroupResource{Group: qualifiedKind.Group, Resource: qualifiedKind.Kind}, operation, retryAfterSeconds)
-}
-
-// NewInternalError returns an error indicating the item is invalid and cannot be processed.
-func NewInternalError(err error) *StatusError {
-	return &StatusError{unversioned.Status{
-		Status: unversioned.StatusFailure,
-		Code:   http.StatusInternalServerError,
-		Reason: unversioned.StatusReasonInternalError,
-		Details: &unversioned.StatusDetails{
-			Causes: []unversioned.StatusCause{{Message: err.Error()}},
-		},
-		Message: fmt.Sprintf("Internal error occurred: %v", err),
-	}}
-}
-
-// NewTimeoutError returns an error indicating that a timeout occurred before the request
-// could be completed.  Clients may retry, but the operation may still complete.
-func NewTimeoutError(message string, retryAfterSeconds int) *StatusError {
-	return &StatusError{unversioned.Status{
-		Status:  unversioned.StatusFailure,
-		Code:    StatusServerTimeout,
-		Reason:  unversioned.StatusReasonTimeout,
-		Message: fmt.Sprintf("Timeout: %s", message),
-		Details: &unversioned.StatusDetails{
-			RetryAfterSeconds: int32(retryAfterSeconds),
-		},
-	}}
-}
-
-// NewGenericServerResponse returns a new error for server responses that are not in a recognizable form.
-func NewGenericServerResponse(code int, verb string, qualifiedResource unversioned.GroupResource, name, serverMessage string, retryAfterSeconds int, isUnexpectedResponse bool) *StatusError {
-	reason := unversioned.StatusReasonUnknown
-	message := fmt.Sprintf("the server responded with the status code %d but did not return more information", code)
-	switch code {
-	case http.StatusConflict:
-		if verb == "POST" {
-			reason = unversioned.StatusReasonAlreadyExists
-		} else {
-			reason = unversioned.StatusReasonConflict
-		}
-		message = "the server reported a conflict"
-	case http.StatusNotFound:
-		reason = unversioned.StatusReasonNotFound
-		message = "the server could not find the requested resource"
-	case http.StatusBadRequest:
-		reason = unversioned.StatusReasonBadRequest
-		message = "the server rejected our request for an unknown reason"
-	case http.StatusUnauthorized:
-		reason = unversioned.StatusReasonUnauthorized
-		message = "the server has asked for the client to provide credentials"
-	case http.StatusForbidden:
-		reason = unversioned.StatusReasonForbidden
-		message = "the server does not allow access to the requested resource"
-	case http.StatusMethodNotAllowed:
-		reason = unversioned.StatusReasonMethodNotAllowed
-		message = "the server does not allow this method on the requested resource"
-	case StatusUnprocessableEntity:
-		reason = unversioned.StatusReasonInvalid
-		message = "the server rejected our request due to an error in our request"
-	case StatusServerTimeout:
-		reason = unversioned.StatusReasonServerTimeout
-		message = "the server cannot complete the requested operation at this time, try again later"
-	case StatusTooManyRequests:
-		reason = unversioned.StatusReasonTimeout
-		message = "the server has received too many requests and has asked us to try again later"
-	default:
-		if code >= 500 {
-			reason = unversioned.StatusReasonInternalError
-			message = fmt.Sprintf("an error on the server (%q) has prevented the request from succeeding", serverMessage)
-		}
-	}
-	switch {
-	case !qualifiedResource.Empty() && len(name) > 0:
-		message = fmt.Sprintf("%s (%s %s %s)", message, strings.ToLower(verb), qualifiedResource.String(), name)
-	case !qualifiedResource.Empty():
-		message = fmt.Sprintf("%s (%s %s)", message, strings.ToLower(verb), qualifiedResource.String())
-	}
-	var causes []unversioned.StatusCause
-	if isUnexpectedResponse {
-		causes = []unversioned.StatusCause{
-			{
-				Type:    unversioned.CauseTypeUnexpectedServerResponse,
-				Message: serverMessage,
-			},
-		}
-	} else {
-		causes = nil
-	}
-	return &StatusError{unversioned.Status{
-		Status: unversioned.StatusFailure,
-		Code:   int32(code),
-		Reason: reason,
-		Details: &unversioned.StatusDetails{
-			Group: qualifiedResource.Group,
-			Kind:  qualifiedResource.Resource,
-			Name:  name,
-
-			Causes:            causes,
-			RetryAfterSeconds: int32(retryAfterSeconds),
-		},
-		Message: message,
-	}}
-}
-
-// IsNotFound returns true if the specified error was created by NewNotFound.
-func IsNotFound(err error) bool {
-	return reasonForError(err) == unversioned.StatusReasonNotFound
-}
-
-// IsAlreadyExists determines if the err is an error which indicates that a specified resource already exists.
-func IsAlreadyExists(err error) bool {
-	return reasonForError(err) == unversioned.StatusReasonAlreadyExists
-}
-
-// IsConflict determines if the err is an error which indicates the provided update conflicts.
-func IsConflict(err error) bool {
-	return reasonForError(err) == unversioned.StatusReasonConflict
-}
-
-// IsInvalid determines if the err is an error which indicates the provided resource is not valid.
-func IsInvalid(err error) bool {
-	return reasonForError(err) == unversioned.StatusReasonInvalid
-}
-
-// IsMethodNotSupported determines if the err is an error which indicates the provided action could not
-// be performed because it is not supported by the server.
-func IsMethodNotSupported(err error) bool {
-	return reasonForError(err) == unversioned.StatusReasonMethodNotAllowed
-}
-
-// IsBadRequest determines if err is an error which indicates that the request is invalid.
-func IsBadRequest(err error) bool {
-	return reasonForError(err) == unversioned.StatusReasonBadRequest
-}
-
-// IsUnauthorized determines if err is an error which indicates that the request is unauthorized and
-// requires authentication by the user.
-func IsUnauthorized(err error) bool {
-	return reasonForError(err) == unversioned.StatusReasonUnauthorized
-}
-
-// IsForbidden determines if err is an error which indicates that the request is forbidden and cannot
-// be completed as requested.
-func IsForbidden(err error) bool {
-	return reasonForError(err) == unversioned.StatusReasonForbidden
-}
-
-// IsServerTimeout determines if err is an error which indicates that the request needs to be retried
-// by the client.
-func IsServerTimeout(err error) bool {
-	return reasonForError(err) == unversioned.StatusReasonServerTimeout
-}
-
-// IsInternalError determines if err is an error which indicates an internal server error.
-func IsInternalError(err error) bool {
-	return reasonForError(err) == unversioned.StatusReasonInternalError
-}
-
-// IsUnexpectedServerError returns true if the server response was not in the expected API format,
-// and may be the result of another HTTP actor.
-func IsUnexpectedServerError(err error) bool {
-	switch t := err.(type) {
-	case APIStatus:
-		if d := t.Status().Details; d != nil {
-			for _, cause := range d.Causes {
-				if cause.Type == unversioned.CauseTypeUnexpectedServerResponse {
-					return true
-				}
-			}
-		}
-	}
-	return false
-}
-
-// IsUnexpectedObjectError determines if err is due to an unexpected object from the master.
-func IsUnexpectedObjectError(err error) bool {
-	_, ok := err.(*UnexpectedObjectError)
-	return err != nil && ok
-}
-
-// SuggestsClientDelay returns true if this error suggests a client delay as well as the
-// suggested seconds to wait, or false if the error does not imply a wait.
-func SuggestsClientDelay(err error) (int, bool) {
-	switch t := err.(type) {
-	case APIStatus:
-		if t.Status().Details != nil {
-			switch t.Status().Reason {
-			case unversioned.StatusReasonServerTimeout, unversioned.StatusReasonTimeout:
-				return int(t.Status().Details.RetryAfterSeconds), true
-			}
-		}
-	}
-	return 0, false
-}
-
-func reasonForError(err error) unversioned.StatusReason {
-	switch t := err.(type) {
-	case APIStatus:
-		return t.Status().Reason
-	}
-	return unversioned.StatusReasonUnknown
-}

1.5/pkg/api/field_constants.go

@@ -1,38 +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 api
-
-// Field path constants that are specific to the internal API
-// representation.
-const (
-	NodeUnschedulableField = "spec.unschedulable"
-	ObjectNameField        = "metadata.name"
-	PodHostField           = "spec.nodeName"
-	PodStatusField         = "status.phase"
-	SecretTypeField        = "type"
-
-	EventReasonField                  = "reason"
-	EventSourceField                  = "source"
-	EventTypeField                    = "type"
-	EventInvolvedKindField            = "involvedObject.kind"
-	EventInvolvedNamespaceField       = "involvedObject.namespace"
-	EventInvolvedNameField            = "involvedObject.name"
-	EventInvolvedUIDField             = "involvedObject.uid"
-	EventInvolvedAPIVersionField      = "involvedObject.apiVersion"
-	EventInvolvedResourceVersionField = "involvedObject.resourceVersion"
-	EventInvolvedFieldPathField       = "involvedObject.fieldPath"
-)

1.5/pkg/api/generate.go

@@ -1,64 +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 api
-
-import (
-	"fmt"
-
-	utilrand "k8s.io/client-go/1.5/pkg/util/rand"
-)
-
-// NameGenerator generates names for objects. Some backends may have more information
-// available to guide selection of new names and this interface hides those details.
-type NameGenerator interface {
-	// GenerateName generates a valid name from the base name, adding a random suffix to the
-	// the base. If base is valid, the returned name must also be valid. The generator is
-	// responsible for knowing the maximum valid name length.
-	GenerateName(base string) string
-}
-
-// GenerateName will resolve the object name of the provided ObjectMeta to a generated version if
-// necessary. It expects that validation for ObjectMeta has already completed (that Base is a
-// valid name) and that the NameGenerator generates a name that is also valid.
-func GenerateName(u NameGenerator, meta *ObjectMeta) {
-	if len(meta.GenerateName) == 0 || len(meta.Name) != 0 {
-		return
-	}
-	meta.Name = u.GenerateName(meta.GenerateName)
-}
-
-// simpleNameGenerator generates random names.
-type simpleNameGenerator struct{}
-
-// SimpleNameGenerator is a generator that returns the name plus a random suffix of five alphanumerics
-// when a name is requested. The string is guaranteed to not exceed the length of a standard Kubernetes
-// name (63 characters)
-var SimpleNameGenerator NameGenerator = simpleNameGenerator{}
-
-const (
-	// TODO: make this flexible for non-core resources with alternate naming rules.
-	maxNameLength          = 63
-	randomLength           = 5
-	maxGeneratedNameLength = maxNameLength - randomLength
-)
-
-func (simpleNameGenerator) GenerateName(base string) string {
-	if len(base) > maxGeneratedNameLength {
-		base = base[:maxGeneratedNameLength]
-	}
-	return fmt.Sprintf("%s%s", base, utilrand.String(randomLength))
-}

1.5/pkg/api/helpers.go

@@ -1,600 +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 api
-
-import (
-	"crypto/md5"
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"strings"
-	"time"
-
-	"k8s.io/client-go/1.5/pkg/api/resource"
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/conversion"
-	"k8s.io/client-go/1.5/pkg/fields"
-	"k8s.io/client-go/1.5/pkg/labels"
-	"k8s.io/client-go/1.5/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/selection"
-	"k8s.io/client-go/1.5/pkg/types"
-	"k8s.io/client-go/1.5/pkg/util/sets"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-// Conversion error conveniently packages up errors in conversions.
-type ConversionError struct {
-	In, Out interface{}
-	Message string
-}
-
-// Return a helpful string about the error
-func (c *ConversionError) Error() string {
-	return spew.Sprintf(
-		"Conversion error: %s. (in: %v(%+v) out: %v)",
-		c.Message, reflect.TypeOf(c.In), c.In, reflect.TypeOf(c.Out),
-	)
-}
-
-// Semantic can do semantic deep equality checks for api objects.
-// Example: api.Semantic.DeepEqual(aPod, aPodWithNonNilButEmptyMaps) == true
-var Semantic = conversion.EqualitiesOrDie(
-	func(a, b resource.Quantity) bool {
-		// Ignore formatting, only care that numeric value stayed the same.
-		// TODO: if we decide it's important, it should be safe to start comparing the format.
-		//
-		// Uninitialized quantities are equivalent to 0 quantities.
-		return a.Cmp(b) == 0
-	},
-	func(a, b unversioned.Time) bool {
-		return a.UTC() == b.UTC()
-	},
-	func(a, b labels.Selector) bool {
-		return a.String() == b.String()
-	},
-	func(a, b fields.Selector) bool {
-		return a.String() == b.String()
-	},
-)
-
-var standardResourceQuotaScopes = sets.NewString(
-	string(ResourceQuotaScopeTerminating),
-	string(ResourceQuotaScopeNotTerminating),
-	string(ResourceQuotaScopeBestEffort),
-	string(ResourceQuotaScopeNotBestEffort),
-)
-
-// IsStandardResourceQuotaScope returns true if the scope is a standard value
-func IsStandardResourceQuotaScope(str string) bool {
-	return standardResourceQuotaScopes.Has(str)
-}
-
-var podObjectCountQuotaResources = sets.NewString(
-	string(ResourcePods),
-)
-
-var podComputeQuotaResources = sets.NewString(
-	string(ResourceCPU),
-	string(ResourceMemory),
-	string(ResourceLimitsCPU),
-	string(ResourceLimitsMemory),
-	string(ResourceRequestsCPU),
-	string(ResourceRequestsMemory),
-)
-
-// IsResourceQuotaScopeValidForResource returns true if the resource applies to the specified scope
-func IsResourceQuotaScopeValidForResource(scope ResourceQuotaScope, resource string) bool {
-	switch scope {
-	case ResourceQuotaScopeTerminating, ResourceQuotaScopeNotTerminating, ResourceQuotaScopeNotBestEffort:
-		return podObjectCountQuotaResources.Has(resource) || podComputeQuotaResources.Has(resource)
-	case ResourceQuotaScopeBestEffort:
-		return podObjectCountQuotaResources.Has(resource)
-	default:
-		return true
-	}
-}
-
-var standardContainerResources = sets.NewString(
-	string(ResourceCPU),
-	string(ResourceMemory),
-)
-
-// IsStandardContainerResourceName returns true if the container can make a resource request
-// for the specified resource
-func IsStandardContainerResourceName(str string) bool {
-	return standardContainerResources.Has(str)
-}
-
-var standardLimitRangeTypes = sets.NewString(
-	string(LimitTypePod),
-	string(LimitTypeContainer),
-)
-
-// IsStandardLimitRangeType returns true if the type is Pod or Container
-func IsStandardLimitRangeType(str string) bool {
-	return standardLimitRangeTypes.Has(str)
-}
-
-var standardQuotaResources = sets.NewString(
-	string(ResourceCPU),
-	string(ResourceMemory),
-	string(ResourceRequestsCPU),
-	string(ResourceRequestsMemory),
-	string(ResourceRequestsStorage),
-	string(ResourceLimitsCPU),
-	string(ResourceLimitsMemory),
-	string(ResourcePods),
-	string(ResourceQuotas),
-	string(ResourceServices),
-	string(ResourceReplicationControllers),
-	string(ResourceSecrets),
-	string(ResourcePersistentVolumeClaims),
-	string(ResourceConfigMaps),
-	string(ResourceServicesNodePorts),
-	string(ResourceServicesLoadBalancers),
-)
-
-// IsStandardQuotaResourceName returns true if the resource is known to
-// the quota tracking system
-func IsStandardQuotaResourceName(str string) bool {
-	return standardQuotaResources.Has(str)
-}
-
-var standardResources = sets.NewString(
-	string(ResourceCPU),
-	string(ResourceMemory),
-	string(ResourceRequestsCPU),
-	string(ResourceRequestsMemory),
-	string(ResourceLimitsCPU),
-	string(ResourceLimitsMemory),
-	string(ResourcePods),
-	string(ResourceQuotas),
-	string(ResourceServices),
-	string(ResourceReplicationControllers),
-	string(ResourceSecrets),
-	string(ResourceConfigMaps),
-	string(ResourcePersistentVolumeClaims),
-	string(ResourceStorage),
-)
-
-// IsStandardResourceName returns true if the resource is known to the system
-func IsStandardResourceName(str string) bool {
-	return standardResources.Has(str)
-}
-
-var integerResources = sets.NewString(
-	string(ResourcePods),
-	string(ResourceQuotas),
-	string(ResourceServices),
-	string(ResourceReplicationControllers),
-	string(ResourceSecrets),
-	string(ResourceConfigMaps),
-	string(ResourcePersistentVolumeClaims),
-	string(ResourceServicesNodePorts),
-	string(ResourceServicesLoadBalancers),
-)
-
-// IsIntegerResourceName returns true if the resource is measured in integer values
-func IsIntegerResourceName(str string) bool {
-	return integerResources.Has(str)
-}
-
-// NewDeleteOptions returns a DeleteOptions indicating the resource should
-// be deleted within the specified grace period. Use zero to indicate
-// immediate deletion. If you would prefer to use the default grace period,
-// use &api.DeleteOptions{} directly.
-func NewDeleteOptions(grace int64) *DeleteOptions {
-	return &DeleteOptions{GracePeriodSeconds: &grace}
-}
-
-// NewPreconditionDeleteOptions returns a DeleteOptions with a UID precondition set.
-func NewPreconditionDeleteOptions(uid string) *DeleteOptions {
-	u := types.UID(uid)
-	p := Preconditions{UID: &u}
-	return &DeleteOptions{Preconditions: &p}
-}
-
-// NewUIDPreconditions returns a Preconditions with UID set.
-func NewUIDPreconditions(uid string) *Preconditions {
-	u := types.UID(uid)
-	return &Preconditions{UID: &u}
-}
-
-// this function aims to check if the service's ClusterIP is set or not
-// the objective is not to perform validation here
-func IsServiceIPSet(service *Service) bool {
-	return service.Spec.ClusterIP != ClusterIPNone && service.Spec.ClusterIP != ""
-}
-
-// this function aims to check if the service's cluster IP is requested or not
-func IsServiceIPRequested(service *Service) bool {
-	// ExternalName services are CNAME aliases to external ones. Ignore the IP.
-	if service.Spec.Type == ServiceTypeExternalName {
-		return false
-	}
-	return service.Spec.ClusterIP == ""
-}
-
-var standardFinalizers = sets.NewString(
-	string(FinalizerKubernetes),
-	FinalizerOrphan,
-)
-
-func IsStandardFinalizerName(str string) bool {
-	return standardFinalizers.Has(str)
-}
-
-// SingleObject returns a ListOptions for watching a single object.
-func SingleObject(meta ObjectMeta) ListOptions {
-	return ListOptions{
-		FieldSelector:   fields.OneTermEqualSelector("metadata.name", meta.Name),
-		ResourceVersion: meta.ResourceVersion,
-	}
-}
-
-// AddToNodeAddresses appends the NodeAddresses to the passed-by-pointer slice,
-// only if they do not already exist
-func AddToNodeAddresses(addresses *[]NodeAddress, addAddresses ...NodeAddress) {
-	for _, add := range addAddresses {
-		exists := false
-		for _, existing := range *addresses {
-			if existing.Address == add.Address && existing.Type == add.Type {
-				exists = true
-				break
-			}
-		}
-		if !exists {
-			*addresses = append(*addresses, add)
-		}
-	}
-}
-
-func HashObject(obj runtime.Object, codec runtime.Codec) (string, error) {
-	data, err := runtime.Encode(codec, obj)
-	if err != nil {
-		return "", err
-	}
-	return fmt.Sprintf("%x", md5.Sum(data)), nil
-}
-
-// TODO: make method on LoadBalancerStatus?
-func LoadBalancerStatusEqual(l, r *LoadBalancerStatus) bool {
-	return ingressSliceEqual(l.Ingress, r.Ingress)
-}
-
-func ingressSliceEqual(lhs, rhs []LoadBalancerIngress) bool {
-	if len(lhs) != len(rhs) {
-		return false
-	}
-	for i := range lhs {
-		if !ingressEqual(&lhs[i], &rhs[i]) {
-			return false
-		}
-	}
-	return true
-}
-
-func ingressEqual(lhs, rhs *LoadBalancerIngress) bool {
-	if lhs.IP != rhs.IP {
-		return false
-	}
-	if lhs.Hostname != rhs.Hostname {
-		return false
-	}
-	return true
-}
-
-// TODO: make method on LoadBalancerStatus?
-func LoadBalancerStatusDeepCopy(lb *LoadBalancerStatus) *LoadBalancerStatus {
-	c := &LoadBalancerStatus{}
-	c.Ingress = make([]LoadBalancerIngress, len(lb.Ingress))
-	for i := range lb.Ingress {
-		c.Ingress[i] = lb.Ingress[i]
-	}
-	return c
-}
-
-// GetAccessModesAsString returns a string representation of an array of access modes.
-// modes, when present, are always in the same order: RWO,ROX,RWX.
-func GetAccessModesAsString(modes []PersistentVolumeAccessMode) string {
-	modes = removeDuplicateAccessModes(modes)
-	modesStr := []string{}
-	if containsAccessMode(modes, ReadWriteOnce) {
-		modesStr = append(modesStr, "RWO")
-	}
-	if containsAccessMode(modes, ReadOnlyMany) {
-		modesStr = append(modesStr, "ROX")
-	}
-	if containsAccessMode(modes, ReadWriteMany) {
-		modesStr = append(modesStr, "RWX")
-	}
-	return strings.Join(modesStr, ",")
-}
-
-// GetAccessModesAsString returns an array of AccessModes from a string created by GetAccessModesAsString
-func GetAccessModesFromString(modes string) []PersistentVolumeAccessMode {
-	strmodes := strings.Split(modes, ",")
-	accessModes := []PersistentVolumeAccessMode{}
-	for _, s := range strmodes {
-		s = strings.Trim(s, " ")
-		switch {
-		case s == "RWO":
-			accessModes = append(accessModes, ReadWriteOnce)
-		case s == "ROX":
-			accessModes = append(accessModes, ReadOnlyMany)
-		case s == "RWX":
-			accessModes = append(accessModes, ReadWriteMany)
-		}
-	}
-	return accessModes
-}
-
-// removeDuplicateAccessModes returns an array of access modes without any duplicates
-func removeDuplicateAccessModes(modes []PersistentVolumeAccessMode) []PersistentVolumeAccessMode {
-	accessModes := []PersistentVolumeAccessMode{}
-	for _, m := range modes {
-		if !containsAccessMode(accessModes, m) {
-			accessModes = append(accessModes, m)
-		}
-	}
-	return accessModes
-}
-
-func containsAccessMode(modes []PersistentVolumeAccessMode, mode PersistentVolumeAccessMode) bool {
-	for _, m := range modes {
-		if m == mode {
-			return true
-		}
-	}
-	return false
-}
-
-// ParseRFC3339 parses an RFC3339 date in either RFC3339Nano or RFC3339 format.
-func ParseRFC3339(s string, nowFn func() unversioned.Time) (unversioned.Time, error) {
-	if t, timeErr := time.Parse(time.RFC3339Nano, s); timeErr == nil {
-		return unversioned.Time{Time: t}, nil
-	}
-	t, err := time.Parse(time.RFC3339, s)
-	if err != nil {
-		return unversioned.Time{}, err
-	}
-	return unversioned.Time{Time: t}, nil
-}
-
-// NodeSelectorRequirementsAsSelector converts the []NodeSelectorRequirement api type into a struct that implements
-// labels.Selector.
-func NodeSelectorRequirementsAsSelector(nsm []NodeSelectorRequirement) (labels.Selector, error) {
-	if len(nsm) == 0 {
-		return labels.Nothing(), nil
-	}
-	selector := labels.NewSelector()
-	for _, expr := range nsm {
-		var op selection.Operator
-		switch expr.Operator {
-		case NodeSelectorOpIn:
-			op = selection.In
-		case NodeSelectorOpNotIn:
-			op = selection.NotIn
-		case NodeSelectorOpExists:
-			op = selection.Exists
-		case NodeSelectorOpDoesNotExist:
-			op = selection.DoesNotExist
-		case NodeSelectorOpGt:
-			op = selection.GreaterThan
-		case NodeSelectorOpLt:
-			op = selection.LessThan
-		default:
-			return nil, fmt.Errorf("%q is not a valid node selector operator", expr.Operator)
-		}
-		r, err := labels.NewRequirement(expr.Key, op, sets.NewString(expr.Values...))
-		if err != nil {
-			return nil, err
-		}
-		selector = selector.Add(*r)
-	}
-	return selector, nil
-}
-
-const (
-	// AffinityAnnotationKey represents the key of affinity data (json serialized)
-	// in the Annotations of a Pod.
-	AffinityAnnotationKey string = "scheduler.alpha.kubernetes.io/affinity"
-
-	// TolerationsAnnotationKey represents the key of tolerations data (json serialized)
-	// in the Annotations of a Pod.
-	TolerationsAnnotationKey string = "scheduler.alpha.kubernetes.io/tolerations"
-
-	// TaintsAnnotationKey represents the key of taints data (json serialized)
-	// in the Annotations of a Node.
-	TaintsAnnotationKey string = "scheduler.alpha.kubernetes.io/taints"
-
-	// SeccompPodAnnotationKey represents the key of a seccomp profile applied
-	// to all containers of a pod.
-	SeccompPodAnnotationKey string = "seccomp.security.alpha.kubernetes.io/pod"
-
-	// SeccompContainerAnnotationKeyPrefix represents the key of a seccomp profile applied
-	// to one container of a pod.
-	SeccompContainerAnnotationKeyPrefix string = "container.seccomp.security.alpha.kubernetes.io/"
-
-	// CreatedByAnnotation represents the key used to store the spec(json)
-	// used to create the resource.
-	CreatedByAnnotation = "kubernetes.io/created-by"
-
-	// PreferAvoidPodsAnnotationKey represents the key of preferAvoidPods data (json serialized)
-	// in the Annotations of a Node.
-	PreferAvoidPodsAnnotationKey string = "scheduler.alpha.kubernetes.io/preferAvoidPods"
-
-	// SysctlsPodAnnotationKey represents the key of sysctls which are set for the infrastructure
-	// container of a pod. The annotation value is a comma separated list of sysctl_name=value
-	// key-value pairs. Only a limited set of whitelisted and isolated sysctls is supported by
-	// the kubelet. Pods with other sysctls will fail to launch.
-	SysctlsPodAnnotationKey string = "security.alpha.kubernetes.io/sysctls"
-
-	// UnsafeSysctlsPodAnnotationKey represents the key of sysctls which are set for the infrastructure
-	// container of a pod. The annotation value is a comma separated list of sysctl_name=value
-	// key-value pairs. Unsafe sysctls must be explicitly enabled for a kubelet. They are properly
-	// namespaced to a pod or a container, but their isolation is usually unclear or weak. Their use
-	// is at-your-own-risk. Pods that attempt to set an unsafe sysctl that is not enabled for a kubelet
-	// will fail to launch.
-	UnsafeSysctlsPodAnnotationKey string = "security.alpha.kubernetes.io/unsafe-sysctls"
-)
-
-// GetAffinityFromPod gets the json serialized affinity data from Pod.Annotations
-// and converts it to the Affinity type in api.
-func GetAffinityFromPodAnnotations(annotations map[string]string) (*Affinity, error) {
-	if len(annotations) > 0 && annotations[AffinityAnnotationKey] != "" {
-		var affinity Affinity
-		err := json.Unmarshal([]byte(annotations[AffinityAnnotationKey]), &affinity)
-		if err != nil {
-			return nil, err
-		}
-		return &affinity, nil
-	}
-	return nil, nil
-}
-
-// GetTolerationsFromPodAnnotations gets the json serialized tolerations data from Pod.Annotations
-// and converts it to the []Toleration type in api.
-func GetTolerationsFromPodAnnotations(annotations map[string]string) ([]Toleration, error) {
-	var tolerations []Toleration
-	if len(annotations) > 0 && annotations[TolerationsAnnotationKey] != "" {
-		err := json.Unmarshal([]byte(annotations[TolerationsAnnotationKey]), &tolerations)
-		if err != nil {
-			return tolerations, err
-		}
-	}
-	return tolerations, nil
-}
-
-// GetTaintsFromNodeAnnotations gets the json serialized taints data from Pod.Annotations
-// and converts it to the []Taint type in api.
-func GetTaintsFromNodeAnnotations(annotations map[string]string) ([]Taint, error) {
-	var taints []Taint
-	if len(annotations) > 0 && annotations[TaintsAnnotationKey] != "" {
-		err := json.Unmarshal([]byte(annotations[TaintsAnnotationKey]), &taints)
-		if err != nil {
-			return []Taint{}, err
-		}
-	}
-	return taints, nil
-}
-
-// TolerationToleratesTaint checks if the toleration tolerates the taint.
-func TolerationToleratesTaint(toleration *Toleration, taint *Taint) bool {
-	if len(toleration.Effect) != 0 && toleration.Effect != taint.Effect {
-		return false
-	}
-
-	if toleration.Key != taint.Key {
-		return false
-	}
-	// TODO: Use proper defaulting when Toleration becomes a field of PodSpec
-	if (len(toleration.Operator) == 0 || toleration.Operator == TolerationOpEqual) && toleration.Value == taint.Value {
-		return true
-	}
-	if toleration.Operator == TolerationOpExists {
-		return true
-	}
-	return false
-
-}
-
-// TaintToleratedByTolerations checks if taint is tolerated by any of the tolerations.
-func TaintToleratedByTolerations(taint *Taint, tolerations []Toleration) bool {
-	tolerated := false
-	for i := range tolerations {
-		if TolerationToleratesTaint(&tolerations[i], taint) {
-			tolerated = true
-			break
-		}
-	}
-	return tolerated
-}
-
-// MatchTaint checks if the taint matches taintToMatch. Taints are unique by key:effect,
-// if the two taints have same key:effect, regard as they match.
-func (t *Taint) MatchTaint(taintToMatch Taint) bool {
-	return t.Key == taintToMatch.Key && t.Effect == taintToMatch.Effect
-}
-
-// taint.ToString() converts taint struct to string in format key=value:effect or key:effect.
-func (t *Taint) ToString() string {
-	if len(t.Value) == 0 {
-		return fmt.Sprintf("%v:%v", t.Key, t.Effect)
-	}
-	return fmt.Sprintf("%v=%v:%v", t.Key, t.Value, t.Effect)
-}
-
-func GetAvoidPodsFromNodeAnnotations(annotations map[string]string) (AvoidPods, error) {
-	var avoidPods AvoidPods
-	if len(annotations) > 0 && annotations[PreferAvoidPodsAnnotationKey] != "" {
-		err := json.Unmarshal([]byte(annotations[PreferAvoidPodsAnnotationKey]), &avoidPods)
-		if err != nil {
-			return avoidPods, err
-		}
-	}
-	return avoidPods, nil
-}
-
-// SysctlsFromPodAnnotations parses the sysctl annotations into a slice of safe Sysctls
-// and a slice of unsafe Sysctls. This is only a convenience wrapper around
-// SysctlsFromPodAnnotation.
-func SysctlsFromPodAnnotations(a map[string]string) ([]Sysctl, []Sysctl, error) {
-	safe, err := SysctlsFromPodAnnotation(a[SysctlsPodAnnotationKey])
-	if err != nil {
-		return nil, nil, err
-	}
-	unsafe, err := SysctlsFromPodAnnotation(a[UnsafeSysctlsPodAnnotationKey])
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return safe, unsafe, nil
-}
-
-// SysctlsFromPodAnnotation parses an annotation value into a slice of Sysctls.
-func SysctlsFromPodAnnotation(annotation string) ([]Sysctl, error) {
-	if len(annotation) == 0 {
-		return nil, nil
-	}
-
-	kvs := strings.Split(annotation, ",")
-	sysctls := make([]Sysctl, len(kvs))
-	for i, kv := range kvs {
-		cs := strings.Split(kv, "=")
-		if len(cs) != 2 {
-			return nil, fmt.Errorf("sysctl %q not of the format sysctl_name=value", kv)
-		}
-		sysctls[i].Name = cs[0]
-		sysctls[i].Value = cs[1]
-	}
-	return sysctls, nil
-}
-
-// PodAnnotationsFromSysctls creates an annotation value for a slice of Sysctls.
-func PodAnnotationsFromSysctls(sysctls []Sysctl) string {
-	if len(sysctls) == 0 {
-		return ""
-	}
-
-	kvs := make([]string, len(sysctls))
-	for i := range sysctls {
-		kvs[i] = fmt.Sprintf("%s=%s", sysctls[i].Name, sysctls[i].Value)
-	}
-	return strings.Join(kvs, ",")
-}

1.5/pkg/api/install/install.go

@@ -1,153 +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 install installs the v1 monolithic api, making it available as an
-// option to all of the API encoding/decoding machinery.
-package install
-
-import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/client-go/1.5/pkg/api"
-	"k8s.io/client-go/1.5/pkg/api/meta"
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/api/v1"
-	"k8s.io/client-go/1.5/pkg/apimachinery"
-	"k8s.io/client-go/1.5/pkg/apimachinery/registered"
-	"k8s.io/client-go/1.5/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/util/sets"
-)
-
-const importPrefix = "k8s.io/client-go/1.5/pkg/api"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []unversioned.GroupVersion{v1.SchemeGroupVersion}
-
-func init() {
-	registered.RegisterVersions(availableVersions)
-	externalVersions := []unversioned.GroupVersion{}
-	for _, v := range availableVersions {
-		if registered.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", api.GroupName)
-		return
-	}
-
-	if err := registered.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-}
-
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine registered.RegisterVersions, registered.EnableVersions and
-// registered.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []unversioned.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := registered.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	return nil
-}
-
-func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
-	// the list of kinds that are scoped at the root of the api hierarchy
-	// if a kind is not enumerated here, it is assumed to have a namespace scope
-	rootScoped := sets.NewString(
-		"Node",
-		"Namespace",
-		"PersistentVolume",
-		"ComponentStatus",
-	)
-
-	// these kinds should be excluded from the list of resources
-	ignoredKinds := sets.NewString(
-		"ListOptions",
-		"DeleteOptions",
-		"Status",
-		"PodLogOptions",
-		"PodExecOptions",
-		"PodAttachOptions",
-		"PodProxyOptions",
-		"NodeProxyOptions",
-		"ServiceProxyOptions",
-		"ThirdPartyResource",
-		"ThirdPartyResourceData",
-		"ThirdPartyResourceList")
-
-	mapper := api.NewDefaultRESTMapper(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
-
-	return mapper
-}
-
-// InterfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := registered.Group(api.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}
-
-func addVersionsToScheme(externalVersions ...unversioned.GroupVersion) {
-	// add the internal version to Scheme
-	if err := api.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
-		panic(err)
-	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !registered.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1.SchemeGroupVersion:
-			if err := v1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
-}

1.5/pkg/api/mapper.go

@@ -1,58 +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 api
-
-import (
-	"strings"
-
-	"k8s.io/client-go/1.5/pkg/api/meta"
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/util/sets"
-)
-
-// Instantiates a DefaultRESTMapper based on types registered in api.Scheme
-func NewDefaultRESTMapper(defaultGroupVersions []unversioned.GroupVersion, interfacesFunc meta.VersionInterfacesFunc,
-	importPathPrefix string, ignoredKinds, rootScoped sets.String) *meta.DefaultRESTMapper {
-	return NewDefaultRESTMapperFromScheme(defaultGroupVersions, interfacesFunc, importPathPrefix, ignoredKinds, rootScoped, Scheme)
-}
-
-// Instantiates a DefaultRESTMapper based on types registered in the given scheme.
-func NewDefaultRESTMapperFromScheme(defaultGroupVersions []unversioned.GroupVersion, interfacesFunc meta.VersionInterfacesFunc,
-	importPathPrefix string, ignoredKinds, rootScoped sets.String, scheme *runtime.Scheme) *meta.DefaultRESTMapper {
-
-	mapper := meta.NewDefaultRESTMapper(defaultGroupVersions, interfacesFunc)
-	// enumerate all supported versions, get the kinds, and register with the mapper how to address
-	// our resources.
-	for _, gv := range defaultGroupVersions {
-		for kind, oType := range scheme.KnownTypes(gv) {
-			gvk := gv.WithKind(kind)
-			// TODO: Remove import path check.
-			// We check the import path because we currently stuff both "api" and "extensions" objects
-			// into the same group within Scheme since Scheme has no notion of groups yet.
-			if !strings.Contains(oType.PkgPath(), importPathPrefix) || ignoredKinds.Has(kind) {
-				continue
-			}
-			scope := meta.RESTScopeNamespace
-			if rootScoped.Has(kind) {
-				scope = meta.RESTScopeRoot
-			}
-			mapper.Add(gvk, scope)
-		}
-	}
-	return mapper
-}

1.5/pkg/api/meta.go

@@ -1,140 +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 api
-
-import (
-	"k8s.io/client-go/1.5/pkg/api/meta"
-	"k8s.io/client-go/1.5/pkg/api/meta/metatypes"
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/conversion"
-	"k8s.io/client-go/1.5/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/types"
-	"k8s.io/client-go/1.5/pkg/util/uuid"
-)
-
-// FillObjectMetaSystemFields populates fields that are managed by the system on ObjectMeta.
-func FillObjectMetaSystemFields(ctx Context, meta *ObjectMeta) {
-	meta.CreationTimestamp = unversioned.Now()
-	// allows admission controllers to assign a UID earlier in the request processing
-	// to support tracking resources pending creation.
-	uid, found := UIDFrom(ctx)
-	if !found {
-		uid = uuid.NewUUID()
-	}
-	meta.UID = uid
-	meta.SelfLink = ""
-}
-
-// HasObjectMetaSystemFieldValues returns true if fields that are managed by the system on ObjectMeta have values.
-func HasObjectMetaSystemFieldValues(meta *ObjectMeta) bool {
-	return !meta.CreationTimestamp.Time.IsZero() ||
-		len(meta.UID) != 0
-}
-
-// ObjectMetaFor returns a pointer to a provided object's ObjectMeta.
-// TODO: allow runtime.Unknown to extract this object
-// TODO: Remove this function and use meta.Accessor() instead.
-func ObjectMetaFor(obj runtime.Object) (*ObjectMeta, error) {
-	v, err := conversion.EnforcePtr(obj)
-	if err != nil {
-		return nil, err
-	}
-	var meta *ObjectMeta
-	err = runtime.FieldPtr(v, "ObjectMeta", &meta)
-	return meta, err
-}
-
-// ListMetaFor returns a pointer to a provided object's ListMeta,
-// or an error if the object does not have that pointer.
-// TODO: allow runtime.Unknown to extract this object
-func ListMetaFor(obj runtime.Object) (*unversioned.ListMeta, error) {
-	v, err := conversion.EnforcePtr(obj)
-	if err != nil {
-		return nil, err
-	}
-	var meta *unversioned.ListMeta
-	err = runtime.FieldPtr(v, "ListMeta", &meta)
-	return meta, err
-}
-
-func (obj *ObjectMeta) GetObjectMeta() meta.Object { return obj }
-
-// Namespace implements meta.Object for any object with an ObjectMeta typed field. Allows
-// fast, direct access to metadata fields for API objects.
-func (meta *ObjectMeta) GetNamespace() string                   { return meta.Namespace }
-func (meta *ObjectMeta) SetNamespace(namespace string)          { meta.Namespace = namespace }
-func (meta *ObjectMeta) GetName() string                        { return meta.Name }
-func (meta *ObjectMeta) SetName(name string)                    { meta.Name = name }
-func (meta *ObjectMeta) GetGenerateName() string                { return meta.GenerateName }
-func (meta *ObjectMeta) SetGenerateName(generateName string)    { meta.GenerateName = generateName }
-func (meta *ObjectMeta) GetUID() types.UID                      { return meta.UID }
-func (meta *ObjectMeta) SetUID(uid types.UID)                   { meta.UID = uid }
-func (meta *ObjectMeta) GetResourceVersion() string             { return meta.ResourceVersion }
-func (meta *ObjectMeta) SetResourceVersion(version string)      { meta.ResourceVersion = version }
-func (meta *ObjectMeta) GetSelfLink() string                    { return meta.SelfLink }
-func (meta *ObjectMeta) SetSelfLink(selfLink string)            { meta.SelfLink = selfLink }
-func (meta *ObjectMeta) GetCreationTimestamp() unversioned.Time { return meta.CreationTimestamp }
-func (meta *ObjectMeta) SetCreationTimestamp(creationTimestamp unversioned.Time) {
-	meta.CreationTimestamp = creationTimestamp
-}
-func (meta *ObjectMeta) GetDeletionTimestamp() *unversioned.Time { return meta.DeletionTimestamp }
-func (meta *ObjectMeta) SetDeletionTimestamp(deletionTimestamp *unversioned.Time) {
-	meta.DeletionTimestamp = deletionTimestamp
-}
-func (meta *ObjectMeta) GetLabels() map[string]string                 { return meta.Labels }
-func (meta *ObjectMeta) SetLabels(labels map[string]string)           { meta.Labels = labels }
-func (meta *ObjectMeta) GetAnnotations() map[string]string            { return meta.Annotations }
-func (meta *ObjectMeta) SetAnnotations(annotations map[string]string) { meta.Annotations = annotations }
-func (meta *ObjectMeta) GetFinalizers() []string                      { return meta.Finalizers }
-func (meta *ObjectMeta) SetFinalizers(finalizers []string)            { meta.Finalizers = finalizers }
-
-func (meta *ObjectMeta) GetOwnerReferences() []metatypes.OwnerReference {
-	ret := make([]metatypes.OwnerReference, len(meta.OwnerReferences))
-	for i := 0; i < len(meta.OwnerReferences); i++ {
-		ret[i].Kind = meta.OwnerReferences[i].Kind
-		ret[i].Name = meta.OwnerReferences[i].Name
-		ret[i].UID = meta.OwnerReferences[i].UID
-		ret[i].APIVersion = meta.OwnerReferences[i].APIVersion
-		if meta.OwnerReferences[i].Controller != nil {
-			value := *meta.OwnerReferences[i].Controller
-			ret[i].Controller = &value
-		}
-	}
-	return ret
-}
-
-func (meta *ObjectMeta) SetOwnerReferences(references []metatypes.OwnerReference) {
-	newReferences := make([]OwnerReference, len(references))
-	for i := 0; i < len(references); i++ {
-		newReferences[i].Kind = references[i].Kind
-		newReferences[i].Name = references[i].Name
-		newReferences[i].UID = references[i].UID
-		newReferences[i].APIVersion = references[i].APIVersion
-		if references[i].Controller != nil {
-			value := *references[i].Controller
-			newReferences[i].Controller = &value
-		}
-	}
-	meta.OwnerReferences = newReferences
-}
-
-func (meta *ObjectMeta) GetClusterName() string {
-	return meta.ClusterName
-}
-func (meta *ObjectMeta) SetClusterName(clusterName string) {
-	meta.ClusterName = clusterName
-}

1.5/pkg/api/meta/doc.go

@@ -1,19 +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 meta provides functions for retrieving API metadata from objects
-// belonging to the Kubernetes API
-package meta

1.5/pkg/api/meta/errors.go

@@ -1,105 +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 meta
-
-import (
-	"fmt"
-
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-)
-
-// AmbiguousResourceError is returned if the RESTMapper finds multiple matches for a resource
-type AmbiguousResourceError struct {
-	PartialResource unversioned.GroupVersionResource
-
-	MatchingResources []unversioned.GroupVersionResource
-	MatchingKinds     []unversioned.GroupVersionKind
-}
-
-func (e *AmbiguousResourceError) Error() string {
-	switch {
-	case len(e.MatchingKinds) > 0 && len(e.MatchingResources) > 0:
-		return fmt.Sprintf("%v matches multiple resources %v and kinds %v", e.PartialResource, e.MatchingResources, e.MatchingKinds)
-	case len(e.MatchingKinds) > 0:
-		return fmt.Sprintf("%v matches multiple kinds %v", e.PartialResource, e.MatchingKinds)
-	case len(e.MatchingResources) > 0:
-		return fmt.Sprintf("%v matches multiple resources %v", e.PartialResource, e.MatchingResources)
-	}
-	return fmt.Sprintf("%v matches multiple resources or kinds", e.PartialResource)
-}
-
-// AmbiguousKindError is returned if the RESTMapper finds multiple matches for a kind
-type AmbiguousKindError struct {
-	PartialKind unversioned.GroupVersionKind
-
-	MatchingResources []unversioned.GroupVersionResource
-	MatchingKinds     []unversioned.GroupVersionKind
-}
-
-func (e *AmbiguousKindError) Error() string {
-	switch {
-	case len(e.MatchingKinds) > 0 && len(e.MatchingResources) > 0:
-		return fmt.Sprintf("%v matches multiple resources %v and kinds %v", e.PartialKind, e.MatchingResources, e.MatchingKinds)
-	case len(e.MatchingKinds) > 0:
-		return fmt.Sprintf("%v matches multiple kinds %v", e.PartialKind, e.MatchingKinds)
-	case len(e.MatchingResources) > 0:
-		return fmt.Sprintf("%v matches multiple resources %v", e.PartialKind, e.MatchingResources)
-	}
-	return fmt.Sprintf("%v matches multiple resources or kinds", e.PartialKind)
-}
-
-func IsAmbiguousError(err error) bool {
-	if err == nil {
-		return false
-	}
-	switch err.(type) {
-	case *AmbiguousResourceError, *AmbiguousKindError:
-		return true
-	default:
-		return false
-	}
-}
-
-// NoResourceMatchError is returned if the RESTMapper can't find any match for a resource
-type NoResourceMatchError struct {
-	PartialResource unversioned.GroupVersionResource
-}
-
-func (e *NoResourceMatchError) Error() string {
-	return fmt.Sprintf("no matches for %v", e.PartialResource)
-}
-
-// NoKindMatchError is returned if the RESTMapper can't find any match for a kind
-type NoKindMatchError struct {
-	PartialKind unversioned.GroupVersionKind
-}
-
-func (e *NoKindMatchError) Error() string {
-	return fmt.Sprintf("no matches for %v", e.PartialKind)
-}
-
-func IsNoMatchError(err error) bool {
-	if err == nil {
-		return false
-	}
-	switch err.(type) {
-	case *NoResourceMatchError, *NoKindMatchError:
-		return true
-	default:
-		return false
-	}
-}

1.5/pkg/api/meta/firsthit_restmapper.go

@@ -1,97 +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 meta
-
-import (
-	"fmt"
-
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	utilerrors "k8s.io/client-go/1.5/pkg/util/errors"
-)
-
-// FirstHitRESTMapper is a wrapper for multiple RESTMappers which returns the
-// first successful result for the singular requests
-type FirstHitRESTMapper struct {
-	MultiRESTMapper
-}
-
-func (m FirstHitRESTMapper) String() string {
-	return fmt.Sprintf("FirstHitRESTMapper{\n\t%v\n}", m.MultiRESTMapper)
-}
-
-func (m FirstHitRESTMapper) ResourceFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionResource, error) {
-	errors := []error{}
-	for _, t := range m.MultiRESTMapper {
-		ret, err := t.ResourceFor(resource)
-		if err == nil {
-			return ret, nil
-		}
-		errors = append(errors, err)
-	}
-
-	return unversioned.GroupVersionResource{}, collapseAggregateErrors(errors)
-}
-
-func (m FirstHitRESTMapper) KindFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionKind, error) {
-	errors := []error{}
-	for _, t := range m.MultiRESTMapper {
-		ret, err := t.KindFor(resource)
-		if err == nil {
-			return ret, nil
-		}
-		errors = append(errors, err)
-	}
-
-	return unversioned.GroupVersionKind{}, collapseAggregateErrors(errors)
-}
-
-// RESTMapping provides the REST mapping for the resource based on the
-// kind and version. This implementation supports multiple REST schemas and
-// return the first match.
-func (m FirstHitRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (*RESTMapping, error) {
-	errors := []error{}
-	for _, t := range m.MultiRESTMapper {
-		ret, err := t.RESTMapping(gk, versions...)
-		if err == nil {
-			return ret, nil
-		}
-		errors = append(errors, err)
-	}
-
-	return nil, collapseAggregateErrors(errors)
-}
-
-// collapseAggregateErrors returns the minimal errors.  it handles empty as nil, handles one item in a list
-// by returning the item, and collapses all NoMatchErrors to a single one (since they should all be the same)
-func collapseAggregateErrors(errors []error) error {
-	if len(errors) == 0 {
-		return nil
-	}
-	if len(errors) == 1 {
-		return errors[0]
-	}
-
-	allNoMatchErrors := true
-	for _, err := range errors {
-		allNoMatchErrors = allNoMatchErrors && IsNoMatchError(err)
-	}
-	if allNoMatchErrors {
-		return errors[0]
-	}
-
-	return utilerrors.NewAggregate(errors)
-}

1.5/pkg/api/meta/help.go

@@ -1,134 +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 meta
-
-import (
-	"fmt"
-	"reflect"
-
-	"k8s.io/client-go/1.5/pkg/conversion"
-	"k8s.io/client-go/1.5/pkg/runtime"
-)
-
-// IsListType returns true if the provided Object has a slice called Items
-func IsListType(obj runtime.Object) bool {
-	_, err := GetItemsPtr(obj)
-	return err == nil
-}
-
-// GetItemsPtr returns a pointer to the list object's Items member.
-// If 'list' doesn't have an Items member, it's not really a list type
-// and an error will be returned.
-// This function will either return a pointer to a slice, or an error, but not both.
-func GetItemsPtr(list runtime.Object) (interface{}, error) {
-	v, err := conversion.EnforcePtr(list)
-	if err != nil {
-		return nil, err
-	}
-	items := v.FieldByName("Items")
-	if !items.IsValid() {
-		return nil, fmt.Errorf("no Items field in %#v", list)
-	}
-	switch items.Kind() {
-	case reflect.Interface, reflect.Ptr:
-		target := reflect.TypeOf(items.Interface()).Elem()
-		if target.Kind() != reflect.Slice {
-			return nil, fmt.Errorf("items: Expected slice, got %s", target.Kind())
-		}
-		return items.Interface(), nil
-	case reflect.Slice:
-		return items.Addr().Interface(), nil
-	default:
-		return nil, fmt.Errorf("items: Expected slice, got %s", items.Kind())
-	}
-}
-
-// ExtractList returns obj's Items element as an array of runtime.Objects.
-// Returns an error if obj is not a List type (does not have an Items member).
-func ExtractList(obj runtime.Object) ([]runtime.Object, error) {
-	itemsPtr, err := GetItemsPtr(obj)
-	if err != nil {
-		return nil, err
-	}
-	items, err := conversion.EnforcePtr(itemsPtr)
-	if err != nil {
-		return nil, err
-	}
-	list := make([]runtime.Object, items.Len())
-	for i := range list {
-		raw := items.Index(i)
-		switch item := raw.Interface().(type) {
-		case runtime.RawExtension:
-			switch {
-			case item.Object != nil:
-				list[i] = item.Object
-			case item.Raw != nil:
-				// TODO: Set ContentEncoding and ContentType correctly.
-				list[i] = &runtime.Unknown{Raw: item.Raw}
-			default:
-				list[i] = nil
-			}
-		case runtime.Object:
-			list[i] = item
-		default:
-			var found bool
-			if list[i], found = raw.Addr().Interface().(runtime.Object); !found {
-				return nil, fmt.Errorf("%v: item[%v]: Expected object, got %#v(%s)", obj, i, raw.Interface(), raw.Kind())
-			}
-		}
-	}
-	return list, nil
-}
-
-// objectSliceType is the type of a slice of Objects
-var objectSliceType = reflect.TypeOf([]runtime.Object{})
-
-// SetList sets the given list object's Items member have the elements given in
-// objects.
-// Returns an error if list is not a List type (does not have an Items member),
-// or if any of the objects are not of the right type.
-func SetList(list runtime.Object, objects []runtime.Object) error {
-	itemsPtr, err := GetItemsPtr(list)
-	if err != nil {
-		return err
-	}
-	items, err := conversion.EnforcePtr(itemsPtr)
-	if err != nil {
-		return err
-	}
-	if items.Type() == objectSliceType {
-		items.Set(reflect.ValueOf(objects))
-		return nil
-	}
-	slice := reflect.MakeSlice(items.Type(), len(objects), len(objects))
-	for i := range objects {
-		dest := slice.Index(i)
-		src, err := conversion.EnforcePtr(objects[i])
-		if err != nil {
-			return err
-		}
-		if src.Type().AssignableTo(dest.Type()) {
-			dest.Set(src)
-		} else if src.Type().ConvertibleTo(dest.Type()) {
-			dest.Set(src.Convert(dest.Type()))
-		} else {
-			return fmt.Errorf("item[%d]: can't assign or convert %v into %v", i, src.Type(), dest.Type())
-		}
-	}
-	items.Set(slice)
-	return nil
-}

1.5/pkg/api/meta/interfaces.go

@@ -1,184 +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 meta
-
-import (
-	"k8s.io/client-go/1.5/pkg/api/meta/metatypes"
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/types"
-)
-
-// VersionInterfaces contains the interfaces one should use for dealing with types of a particular version.
-type VersionInterfaces struct {
-	runtime.ObjectConvertor
-	MetadataAccessor
-}
-
-type ObjectMetaAccessor interface {
-	GetObjectMeta() Object
-}
-
-// Object lets you work with object metadata from any of the versioned or
-// internal API objects. Attempting to set or retrieve a field on an object that does
-// not support that field (Name, UID, Namespace on lists) will be a no-op and return
-// a default value.
-type Object interface {
-	GetNamespace() string
-	SetNamespace(namespace string)
-	GetName() string
-	SetName(name string)
-	GetGenerateName() string
-	SetGenerateName(name string)
-	GetUID() types.UID
-	SetUID(uid types.UID)
-	GetResourceVersion() string
-	SetResourceVersion(version string)
-	GetSelfLink() string
-	SetSelfLink(selfLink string)
-	GetCreationTimestamp() unversioned.Time
-	SetCreationTimestamp(timestamp unversioned.Time)
-	GetDeletionTimestamp() *unversioned.Time
-	SetDeletionTimestamp(timestamp *unversioned.Time)
-	GetLabels() map[string]string
-	SetLabels(labels map[string]string)
-	GetAnnotations() map[string]string
-	SetAnnotations(annotations map[string]string)
-	GetFinalizers() []string
-	SetFinalizers(finalizers []string)
-	GetOwnerReferences() []metatypes.OwnerReference
-	SetOwnerReferences([]metatypes.OwnerReference)
-	GetClusterName() string
-	SetClusterName(clusterName string)
-}
-
-var _ Object = &runtime.Unstructured{}
-
-type ListMetaAccessor interface {
-	GetListMeta() List
-}
-
-// List lets you work with list metadata from any of the versioned or
-// internal API objects. Attempting to set or retrieve a field on an object that does
-// not support that field will be a no-op and return a default value.
-type List unversioned.List
-
-// Type exposes the type and APIVersion of versioned or internal API objects.
-type Type unversioned.Type
-
-// MetadataAccessor lets you work with object and list metadata from any of the versioned or
-// internal API objects. Attempting to set or retrieve a field on an object that does
-// not support that field (Name, UID, Namespace on lists) will be a no-op and return
-// a default value.
-//
-// MetadataAccessor exposes Interface in a way that can be used with multiple objects.
-type MetadataAccessor interface {
-	APIVersion(obj runtime.Object) (string, error)
-	SetAPIVersion(obj runtime.Object, version string) error
-
-	Kind(obj runtime.Object) (string, error)
-	SetKind(obj runtime.Object, kind string) error
-
-	Namespace(obj runtime.Object) (string, error)
-	SetNamespace(obj runtime.Object, namespace string) error
-
-	Name(obj runtime.Object) (string, error)
-	SetName(obj runtime.Object, name string) error
-
-	GenerateName(obj runtime.Object) (string, error)
-	SetGenerateName(obj runtime.Object, name string) error
-
-	UID(obj runtime.Object) (types.UID, error)
-	SetUID(obj runtime.Object, uid types.UID) error
-
-	SelfLink(obj runtime.Object) (string, error)
-	SetSelfLink(obj runtime.Object, selfLink string) error
-
-	Labels(obj runtime.Object) (map[string]string, error)
-	SetLabels(obj runtime.Object, labels map[string]string) error
-
-	Annotations(obj runtime.Object) (map[string]string, error)
-	SetAnnotations(obj runtime.Object, annotations map[string]string) error
-
-	runtime.ResourceVersioner
-}
-
-type RESTScopeName string
-
-const (
-	RESTScopeNameNamespace RESTScopeName = "namespace"
-	RESTScopeNameRoot      RESTScopeName = "root"
-)
-
-// RESTScope contains the information needed to deal with REST resources that are in a resource hierarchy
-type RESTScope interface {
-	// Name of the scope
-	Name() RESTScopeName
-	// ParamName is the optional name of the parameter that should be inserted in the resource url
-	// If empty, no param will be inserted
-	ParamName() string
-	// ArgumentName is the optional name that should be used for the variable holding the value.
-	ArgumentName() string
-	// ParamDescription is the optional description to use to document the parameter in api documentation
-	ParamDescription() string
-}
-
-// RESTMapping contains the information needed to deal with objects of a specific
-// resource and kind in a RESTful manner.
-type RESTMapping struct {
-	// Resource is a string representing the name of this resource as a REST client would see it
-	Resource string
-
-	GroupVersionKind unversioned.GroupVersionKind
-
-	// Scope contains the information needed to deal with REST Resources that are in a resource hierarchy
-	Scope RESTScope
-
-	runtime.ObjectConvertor
-	MetadataAccessor
-}
-
-// RESTMapper allows clients to map resources to kind, and map kind and version
-// to interfaces for manipulating those objects. It is primarily intended for
-// consumers of Kubernetes compatible REST APIs as defined in docs/devel/api-conventions.md.
-//
-// The Kubernetes API provides versioned resources and object kinds which are scoped
-// to API groups. In other words, kinds and resources should not be assumed to be
-// unique across groups.
-//
-// TODO: split into sub-interfaces
-type RESTMapper interface {
-	// KindFor takes a partial resource and returns the single match.  Returns an error if there are multiple matches
-	KindFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionKind, error)
-
-	// KindsFor takes a partial resource and returns the list of potential kinds in priority order
-	KindsFor(resource unversioned.GroupVersionResource) ([]unversioned.GroupVersionKind, error)
-
-	// ResourceFor takes a partial resource and returns the single match.  Returns an error if there are multiple matches
-	ResourceFor(input unversioned.GroupVersionResource) (unversioned.GroupVersionResource, error)
-
-	// ResourcesFor takes a partial resource and returns the list of potential resource in priority order
-	ResourcesFor(input unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error)
-
-	// RESTMapping identifies a preferred resource mapping for the provided group kind.
-	RESTMapping(gk unversioned.GroupKind, versions ...string) (*RESTMapping, error)
-	// RESTMappings returns all resource mappings for the provided group kind.
-	RESTMappings(gk unversioned.GroupKind) ([]*RESTMapping, error)
-
-	AliasesForResource(resource string) ([]string, bool)
-	ResourceSingularizer(resource string) (singular string, err error)
-}

1.5/pkg/api/meta/meta.go

@@ -1,567 +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 meta
-
-import (
-	"fmt"
-	"reflect"
-
-	"k8s.io/client-go/1.5/pkg/api/meta/metatypes"
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/conversion"
-	"k8s.io/client-go/1.5/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/types"
-
-	"github.com/golang/glog"
-)
-
-// errNotList is returned when an object implements the Object style interfaces but not the List style
-// interfaces.
-var errNotList = fmt.Errorf("object does not implement the List interfaces")
-
-// ListAccessor returns a List interface for the provided object or an error if the object does
-// not provide List.
-// IMPORTANT: Objects are a superset of lists, so all Objects return List metadata. Do not use this
-// check to determine whether an object *is* a List.
-// TODO: return bool instead of error
-func ListAccessor(obj interface{}) (List, error) {
-	switch t := obj.(type) {
-	case List:
-		return t, nil
-	case unversioned.List:
-		return t, nil
-	case ListMetaAccessor:
-		if m := t.GetListMeta(); m != nil {
-			return m, nil
-		}
-		return nil, errNotList
-	case unversioned.ListMetaAccessor:
-		if m := t.GetListMeta(); m != nil {
-			return m, nil
-		}
-		return nil, errNotList
-	case Object:
-		return t, nil
-	case ObjectMetaAccessor:
-		if m := t.GetObjectMeta(); m != nil {
-			return m, nil
-		}
-		return nil, errNotList
-	default:
-		return nil, errNotList
-	}
-}
-
-// errNotObject is returned when an object implements the List style interfaces but not the Object style
-// interfaces.
-var errNotObject = fmt.Errorf("object does not implement the Object interfaces")
-
-// Accessor takes an arbitrary object pointer and returns meta.Interface.
-// obj must be a pointer to an API type. An error is returned if the minimum
-// required fields are missing. Fields that are not required return the default
-// value and are a no-op if set.
-// TODO: return bool instead of error
-func Accessor(obj interface{}) (Object, error) {
-	switch t := obj.(type) {
-	case Object:
-		return t, nil
-	case ObjectMetaAccessor:
-		if m := t.GetObjectMeta(); m != nil {
-			return m, nil
-		}
-		return nil, errNotObject
-	case List, unversioned.List, ListMetaAccessor, unversioned.ListMetaAccessor:
-		return nil, errNotObject
-	default:
-		return nil, errNotObject
-	}
-}
-
-// TypeAccessor returns an interface that allows retrieving and modifying the APIVersion
-// and Kind of an in-memory internal object.
-// TODO: this interface is used to test code that does not have ObjectMeta or ListMeta
-// in round tripping (objects which can use apiVersion/kind, but do not fit the Kube
-// api conventions).
-func TypeAccessor(obj interface{}) (Type, error) {
-	if typed, ok := obj.(runtime.Object); ok {
-		return objectAccessor{typed}, nil
-	}
-	v, err := conversion.EnforcePtr(obj)
-	if err != nil {
-		return nil, err
-	}
-	t := v.Type()
-	if v.Kind() != reflect.Struct {
-		return nil, fmt.Errorf("expected struct, but got %v: %v (%#v)", v.Kind(), t, v.Interface())
-	}
-
-	typeMeta := v.FieldByName("TypeMeta")
-	if !typeMeta.IsValid() {
-		return nil, fmt.Errorf("struct %v lacks embedded TypeMeta type", t)
-	}
-	a := &genericAccessor{}
-	if err := extractFromTypeMeta(typeMeta, a); err != nil {
-		return nil, fmt.Errorf("unable to find type fields on %#v: %v", typeMeta, err)
-	}
-	return a, nil
-}
-
-type objectAccessor struct {
-	runtime.Object
-}
-
-func (obj objectAccessor) GetKind() string {
-	return obj.GetObjectKind().GroupVersionKind().Kind
-}
-
-func (obj objectAccessor) SetKind(kind string) {
-	gvk := obj.GetObjectKind().GroupVersionKind()
-	gvk.Kind = kind
-	obj.GetObjectKind().SetGroupVersionKind(gvk)
-}
-
-func (obj objectAccessor) GetAPIVersion() string {
-	return obj.GetObjectKind().GroupVersionKind().GroupVersion().String()
-}
-
-func (obj objectAccessor) SetAPIVersion(version string) {
-	gvk := obj.GetObjectKind().GroupVersionKind()
-	gv, err := unversioned.ParseGroupVersion(version)
-	if err != nil {
-		gv = unversioned.GroupVersion{Version: version}
-	}
-	gvk.Group, gvk.Version = gv.Group, gv.Version
-	obj.GetObjectKind().SetGroupVersionKind(gvk)
-}
-
-// NewAccessor returns a MetadataAccessor that can retrieve
-// or manipulate resource version on objects derived from core API
-// metadata concepts.
-func NewAccessor() MetadataAccessor {
-	return resourceAccessor{}
-}
-
-// resourceAccessor implements ResourceVersioner and SelfLinker.
-type resourceAccessor struct{}
-
-func (resourceAccessor) Kind(obj runtime.Object) (string, error) {
-	return objectAccessor{obj}.GetKind(), nil
-}
-
-func (resourceAccessor) SetKind(obj runtime.Object, kind string) error {
-	objectAccessor{obj}.SetKind(kind)
-	return nil
-}
-
-func (resourceAccessor) APIVersion(obj runtime.Object) (string, error) {
-	return objectAccessor{obj}.GetAPIVersion(), nil
-}
-
-func (resourceAccessor) SetAPIVersion(obj runtime.Object, version string) error {
-	objectAccessor{obj}.SetAPIVersion(version)
-	return nil
-}
-
-func (resourceAccessor) Namespace(obj runtime.Object) (string, error) {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return "", err
-	}
-	return accessor.GetNamespace(), nil
-}
-
-func (resourceAccessor) SetNamespace(obj runtime.Object, namespace string) error {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return err
-	}
-	accessor.SetNamespace(namespace)
-	return nil
-}
-
-func (resourceAccessor) Name(obj runtime.Object) (string, error) {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return "", err
-	}
-	return accessor.GetName(), nil
-}
-
-func (resourceAccessor) SetName(obj runtime.Object, name string) error {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return err
-	}
-	accessor.SetName(name)
-	return nil
-}
-
-func (resourceAccessor) GenerateName(obj runtime.Object) (string, error) {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return "", err
-	}
-	return accessor.GetGenerateName(), nil
-}
-
-func (resourceAccessor) SetGenerateName(obj runtime.Object, name string) error {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return err
-	}
-	accessor.SetGenerateName(name)
-	return nil
-}
-
-func (resourceAccessor) UID(obj runtime.Object) (types.UID, error) {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return "", err
-	}
-	return accessor.GetUID(), nil
-}
-
-func (resourceAccessor) SetUID(obj runtime.Object, uid types.UID) error {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return err
-	}
-	accessor.SetUID(uid)
-	return nil
-}
-
-func (resourceAccessor) SelfLink(obj runtime.Object) (string, error) {
-	accessor, err := ListAccessor(obj)
-	if err != nil {
-		return "", err
-	}
-	return accessor.GetSelfLink(), nil
-}
-
-func (resourceAccessor) SetSelfLink(obj runtime.Object, selfLink string) error {
-	accessor, err := ListAccessor(obj)
-	if err != nil {
-		return err
-	}
-	accessor.SetSelfLink(selfLink)
-	return nil
-}
-
-func (resourceAccessor) Labels(obj runtime.Object) (map[string]string, error) {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return nil, err
-	}
-	return accessor.GetLabels(), nil
-}
-
-func (resourceAccessor) SetLabels(obj runtime.Object, labels map[string]string) error {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return err
-	}
-	accessor.SetLabels(labels)
-	return nil
-}
-
-func (resourceAccessor) Annotations(obj runtime.Object) (map[string]string, error) {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return nil, err
-	}
-	return accessor.GetAnnotations(), nil
-}
-
-func (resourceAccessor) SetAnnotations(obj runtime.Object, annotations map[string]string) error {
-	accessor, err := Accessor(obj)
-	if err != nil {
-		return err
-	}
-	accessor.SetAnnotations(annotations)
-	return nil
-}
-
-func (resourceAccessor) ResourceVersion(obj runtime.Object) (string, error) {
-	accessor, err := ListAccessor(obj)
-	if err != nil {
-		return "", err
-	}
-	return accessor.GetResourceVersion(), nil
-}
-
-func (resourceAccessor) SetResourceVersion(obj runtime.Object, version string) error {
-	accessor, err := ListAccessor(obj)
-	if err != nil {
-		return err
-	}
-	accessor.SetResourceVersion(version)
-	return nil
-}
-
-// extractFromOwnerReference extracts v to o. v is the OwnerReferences field of an object.
-func extractFromOwnerReference(v reflect.Value, o *metatypes.OwnerReference) error {
-	if err := runtime.Field(v, "APIVersion", &o.APIVersion); err != nil {
-		return err
-	}
-	if err := runtime.Field(v, "Kind", &o.Kind); err != nil {
-		return err
-	}
-	if err := runtime.Field(v, "Name", &o.Name); err != nil {
-		return err
-	}
-	if err := runtime.Field(v, "UID", &o.UID); err != nil {
-		return err
-	}
-	var controllerPtr *bool
-	if err := runtime.Field(v, "Controller", &controllerPtr); err != nil {
-		return err
-	}
-	if controllerPtr != nil {
-		controller := *controllerPtr
-		o.Controller = &controller
-	}
-	return nil
-}
-
-// setOwnerReference sets v to o. v is the OwnerReferences field of an object.
-func setOwnerReference(v reflect.Value, o *metatypes.OwnerReference) error {
-	if err := runtime.SetField(o.APIVersion, v, "APIVersion"); err != nil {
-		return err
-	}
-	if err := runtime.SetField(o.Kind, v, "Kind"); err != nil {
-		return err
-	}
-	if err := runtime.SetField(o.Name, v, "Name"); err != nil {
-		return err
-	}
-	if err := runtime.SetField(o.UID, v, "UID"); err != nil {
-		return err
-	}
-	if o.Controller != nil {
-		controller := *(o.Controller)
-		if err := runtime.SetField(&controller, v, "Controller"); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// genericAccessor contains pointers to strings that can modify an arbitrary
-// struct and implements the Accessor interface.
-type genericAccessor struct {
-	namespace         *string
-	name              *string
-	generateName      *string
-	uid               *types.UID
-	apiVersion        *string
-	kind              *string
-	resourceVersion   *string
-	selfLink          *string
-	creationTimestamp *unversioned.Time
-	deletionTimestamp **unversioned.Time
-	labels            *map[string]string
-	annotations       *map[string]string
-	ownerReferences   reflect.Value
-	finalizers        *[]string
-}
-
-func (a genericAccessor) GetNamespace() string {
-	if a.namespace == nil {
-		return ""
-	}
-	return *a.namespace
-}
-
-func (a genericAccessor) SetNamespace(namespace string) {
-	if a.namespace == nil {
-		return
-	}
-	*a.namespace = namespace
-}
-
-func (a genericAccessor) GetName() string {
-	if a.name == nil {
-		return ""
-	}
-	return *a.name
-}
-
-func (a genericAccessor) SetName(name string) {
-	if a.name == nil {
-		return
-	}
-	*a.name = name
-}
-
-func (a genericAccessor) GetGenerateName() string {
-	if a.generateName == nil {
-		return ""
-	}
-	return *a.generateName
-}
-
-func (a genericAccessor) SetGenerateName(generateName string) {
-	if a.generateName == nil {
-		return
-	}
-	*a.generateName = generateName
-}
-
-func (a genericAccessor) GetUID() types.UID {
-	if a.uid == nil {
-		return ""
-	}
-	return *a.uid
-}
-
-func (a genericAccessor) SetUID(uid types.UID) {
-	if a.uid == nil {
-		return
-	}
-	*a.uid = uid
-}
-
-func (a genericAccessor) GetAPIVersion() string {
-	return *a.apiVersion
-}
-
-func (a genericAccessor) SetAPIVersion(version string) {
-	*a.apiVersion = version
-}
-
-func (a genericAccessor) GetKind() string {
-	return *a.kind
-}
-
-func (a genericAccessor) SetKind(kind string) {
-	*a.kind = kind
-}
-
-func (a genericAccessor) GetResourceVersion() string {
-	return *a.resourceVersion
-}
-
-func (a genericAccessor) SetResourceVersion(version string) {
-	*a.resourceVersion = version
-}
-
-func (a genericAccessor) GetSelfLink() string {
-	return *a.selfLink
-}
-
-func (a genericAccessor) SetSelfLink(selfLink string) {
-	*a.selfLink = selfLink
-}
-
-func (a genericAccessor) GetCreationTimestamp() unversioned.Time {
-	return *a.creationTimestamp
-}
-
-func (a genericAccessor) SetCreationTimestamp(timestamp unversioned.Time) {
-	*a.creationTimestamp = timestamp
-}
-
-func (a genericAccessor) GetDeletionTimestamp() *unversioned.Time {
-	return *a.deletionTimestamp
-}
-
-func (a genericAccessor) SetDeletionTimestamp(timestamp *unversioned.Time) {
-	*a.deletionTimestamp = timestamp
-}
-
-func (a genericAccessor) GetLabels() map[string]string {
-	if a.labels == nil {
-		return nil
-	}
-	return *a.labels
-}
-
-func (a genericAccessor) SetLabels(labels map[string]string) {
-	*a.labels = labels
-}
-
-func (a genericAccessor) GetAnnotations() map[string]string {
-	if a.annotations == nil {
-		return nil
-	}
-	return *a.annotations
-}
-
-func (a genericAccessor) SetAnnotations(annotations map[string]string) {
-	if a.annotations == nil {
-		emptyAnnotations := make(map[string]string)
-		a.annotations = &emptyAnnotations
-	}
-	*a.annotations = annotations
-}
-
-func (a genericAccessor) GetFinalizers() []string {
-	if a.finalizers == nil {
-		return nil
-	}
-	return *a.finalizers
-}
-
-func (a genericAccessor) SetFinalizers(finalizers []string) {
-	*a.finalizers = finalizers
-}
-
-func (a genericAccessor) GetOwnerReferences() []metatypes.OwnerReference {
-	var ret []metatypes.OwnerReference
-	s := a.ownerReferences
-	if s.Kind() != reflect.Ptr || s.Elem().Kind() != reflect.Slice {
-		glog.Errorf("expect %v to be a pointer to slice", s)
-		return ret
-	}
-	s = s.Elem()
-	// Set the capacity to one element greater to avoid copy if the caller later append an element.
-	ret = make([]metatypes.OwnerReference, s.Len(), s.Len()+1)
-	for i := 0; i < s.Len(); i++ {
-		if err := extractFromOwnerReference(s.Index(i), &ret[i]); err != nil {
-			glog.Errorf("extractFromOwnerReference failed: %v", err)
-			return ret
-		}
-	}
-	return ret
-}
-
-func (a genericAccessor) SetOwnerReferences(references []metatypes.OwnerReference) {
-	s := a.ownerReferences
-	if s.Kind() != reflect.Ptr || s.Elem().Kind() != reflect.Slice {
-		glog.Errorf("expect %v to be a pointer to slice", s)
-	}
-	s = s.Elem()
-	newReferences := reflect.MakeSlice(s.Type(), len(references), len(references))
-	for i := 0; i < len(references); i++ {
-		if err := setOwnerReference(newReferences.Index(i), &references[i]); err != nil {
-			glog.Errorf("setOwnerReference failed: %v", err)
-			return
-		}
-	}
-	s.Set(newReferences)
-}
-
-// extractFromTypeMeta extracts pointers to version and kind fields from an object
-func extractFromTypeMeta(v reflect.Value, a *genericAccessor) error {
-	if err := runtime.FieldPtr(v, "APIVersion", &a.apiVersion); err != nil {
-		return err
-	}
-	if err := runtime.FieldPtr(v, "Kind", &a.kind); err != nil {
-		return err
-	}
-	return nil
-}

1.5/pkg/api/meta/metatypes/types.go

@@ -1,30 +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.
-*/
-
-// The types defined in this package are used by the meta package to represent
-// the in-memory version of objects. We cannot reuse the __internal version of
-// API objects because it causes import cycle.
-package metatypes
-
-import "k8s.io/client-go/1.5/pkg/types"
-
-type OwnerReference struct {
-	APIVersion string
-	Kind       string
-	UID        types.UID
-	Name       string
-	Controller *bool
-}

1.5/pkg/api/meta/multirestmapper.go

@@ -1,231 +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 meta
-
-import (
-	"fmt"
-	"strings"
-
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	utilerrors "k8s.io/client-go/1.5/pkg/util/errors"
-	"k8s.io/client-go/1.5/pkg/util/sets"
-)
-
-// MultiRESTMapper is a wrapper for multiple RESTMappers.
-type MultiRESTMapper []RESTMapper
-
-func (m MultiRESTMapper) String() string {
-	nested := []string{}
-	for _, t := range m {
-		currString := fmt.Sprintf("%v", t)
-		splitStrings := strings.Split(currString, "\n")
-		nested = append(nested, strings.Join(splitStrings, "\n\t"))
-	}
-
-	return fmt.Sprintf("MultiRESTMapper{\n\t%s\n}", strings.Join(nested, "\n\t"))
-}
-
-// ResourceSingularizer converts a REST resource name from plural to singular (e.g., from pods to pod)
-// This implementation supports multiple REST schemas and return the first match.
-func (m MultiRESTMapper) ResourceSingularizer(resource string) (singular string, err error) {
-	for _, t := range m {
-		singular, err = t.ResourceSingularizer(resource)
-		if err == nil {
-			return
-		}
-	}
-	return
-}
-
-func (m MultiRESTMapper) ResourcesFor(resource unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error) {
-	allGVRs := []unversioned.GroupVersionResource{}
-	for _, t := range m {
-		gvrs, err := t.ResourcesFor(resource)
-		// ignore "no match" errors, but any other error percolates back up
-		if IsNoMatchError(err) {
-			continue
-		}
-		if err != nil {
-			return nil, err
-		}
-
-		// walk the existing values to de-dup
-		for _, curr := range gvrs {
-			found := false
-			for _, existing := range allGVRs {
-				if curr == existing {
-					found = true
-					break
-				}
-			}
-
-			if !found {
-				allGVRs = append(allGVRs, curr)
-			}
-		}
-	}
-
-	if len(allGVRs) == 0 {
-		return nil, &NoResourceMatchError{PartialResource: resource}
-	}
-
-	return allGVRs, nil
-}
-
-func (m MultiRESTMapper) KindsFor(resource unversioned.GroupVersionResource) (gvk []unversioned.GroupVersionKind, err error) {
-	allGVKs := []unversioned.GroupVersionKind{}
-	for _, t := range m {
-		gvks, err := t.KindsFor(resource)
-		// ignore "no match" errors, but any other error percolates back up
-		if IsNoMatchError(err) {
-			continue
-		}
-		if err != nil {
-			return nil, err
-		}
-
-		// walk the existing values to de-dup
-		for _, curr := range gvks {
-			found := false
-			for _, existing := range allGVKs {
-				if curr == existing {
-					found = true
-					break
-				}
-			}
-
-			if !found {
-				allGVKs = append(allGVKs, curr)
-			}
-		}
-	}
-
-	if len(allGVKs) == 0 {
-		return nil, &NoResourceMatchError{PartialResource: resource}
-	}
-
-	return allGVKs, nil
-}
-
-func (m MultiRESTMapper) ResourceFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionResource, error) {
-	resources, err := m.ResourcesFor(resource)
-	if err != nil {
-		return unversioned.GroupVersionResource{}, err
-	}
-	if len(resources) == 1 {
-		return resources[0], nil
-	}
-
-	return unversioned.GroupVersionResource{}, &AmbiguousResourceError{PartialResource: resource, MatchingResources: resources}
-}
-
-func (m MultiRESTMapper) KindFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionKind, error) {
-	kinds, err := m.KindsFor(resource)
-	if err != nil {
-		return unversioned.GroupVersionKind{}, err
-	}
-	if len(kinds) == 1 {
-		return kinds[0], nil
-	}
-
-	return unversioned.GroupVersionKind{}, &AmbiguousResourceError{PartialResource: resource, MatchingKinds: kinds}
-}
-
-// RESTMapping provides the REST mapping for the resource based on the
-// kind and version. This implementation supports multiple REST schemas and
-// return the first match.
-func (m MultiRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (*RESTMapping, error) {
-	allMappings := []*RESTMapping{}
-	errors := []error{}
-
-	for _, t := range m {
-		currMapping, err := t.RESTMapping(gk, versions...)
-		// ignore "no match" errors, but any other error percolates back up
-		if IsNoMatchError(err) {
-			continue
-		}
-		if err != nil {
-			errors = append(errors, err)
-			continue
-		}
-
-		allMappings = append(allMappings, currMapping)
-	}
-
-	// if we got exactly one mapping, then use it even if other requested failed
-	if len(allMappings) == 1 {
-		return allMappings[0], nil
-	}
-	if len(allMappings) > 1 {
-		var kinds []unversioned.GroupVersionKind
-		for _, m := range allMappings {
-			kinds = append(kinds, m.GroupVersionKind)
-		}
-		return nil, &AmbiguousKindError{PartialKind: gk.WithVersion(""), MatchingKinds: kinds}
-	}
-	if len(errors) > 0 {
-		return nil, utilerrors.NewAggregate(errors)
-	}
-	return nil, &NoKindMatchError{PartialKind: gk.WithVersion("")}
-}
-
-// RESTMappings returns all possible RESTMappings for the provided group kind, or an error
-// if the type is not recognized.
-func (m MultiRESTMapper) RESTMappings(gk unversioned.GroupKind) ([]*RESTMapping, error) {
-	var allMappings []*RESTMapping
-	var errors []error
-
-	for _, t := range m {
-		currMappings, err := t.RESTMappings(gk)
-		// ignore "no match" errors, but any other error percolates back up
-		if IsNoMatchError(err) {
-			continue
-		}
-		if err != nil {
-			errors = append(errors, err)
-			continue
-		}
-		allMappings = append(allMappings, currMappings...)
-	}
-	if len(errors) > 0 {
-		return nil, utilerrors.NewAggregate(errors)
-	}
-	if len(allMappings) == 0 {
-		return nil, &NoKindMatchError{PartialKind: gk.WithVersion("")}
-	}
-	return allMappings, nil
-}
-
-// AliasesForResource finds the first alias response for the provided mappers.
-func (m MultiRESTMapper) AliasesForResource(alias string) ([]string, bool) {
-	seenAliases := sets.NewString()
-	allAliases := []string{}
-	handled := false
-
-	for _, t := range m {
-		if currAliases, currOk := t.AliasesForResource(alias); currOk {
-			for _, currAlias := range currAliases {
-				if !seenAliases.Has(currAlias) {
-					allAliases = append(allAliases, currAlias)
-					seenAliases.Insert(currAlias)
-				}
-			}
-			handled = true
-		}
-	}
-	return allAliases, handled
-}

1.5/pkg/api/meta/priority.go

@@ -1,226 +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 meta
-
-import (
-	"fmt"
-
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-)
-
-const (
-	AnyGroup    = "*"
-	AnyVersion  = "*"
-	AnyResource = "*"
-	AnyKind     = "*"
-)
-
-// PriorityRESTMapper is a wrapper for automatically choosing a particular Resource or Kind
-// when multiple matches are possible
-type PriorityRESTMapper struct {
-	// Delegate is the RESTMapper to use to locate all the Kind and Resource matches
-	Delegate RESTMapper
-
-	// ResourcePriority is a list of priority patterns to apply to matching resources.
-	// The list of all matching resources is narrowed based on the patterns until only one remains.
-	// A pattern with no matches is skipped.  A pattern with more than one match uses its
-	// matches as the list to continue matching against.
-	ResourcePriority []unversioned.GroupVersionResource
-
-	// KindPriority is a list of priority patterns to apply to matching kinds.
-	// The list of all matching kinds is narrowed based on the patterns until only one remains.
-	// A pattern with no matches is skipped.  A pattern with more than one match uses its
-	// matches as the list to continue matching against.
-	KindPriority []unversioned.GroupVersionKind
-}
-
-func (m PriorityRESTMapper) String() string {
-	return fmt.Sprintf("PriorityRESTMapper{\n\t%v\n\t%v\n\t%v\n}", m.ResourcePriority, m.KindPriority, m.Delegate)
-}
-
-// ResourceFor finds all resources, then passes them through the ResourcePriority patterns to find a single matching hit.
-func (m PriorityRESTMapper) ResourceFor(partiallySpecifiedResource unversioned.GroupVersionResource) (unversioned.GroupVersionResource, error) {
-	originalGVRs, err := m.Delegate.ResourcesFor(partiallySpecifiedResource)
-	if err != nil {
-		return unversioned.GroupVersionResource{}, err
-	}
-	if len(originalGVRs) == 1 {
-		return originalGVRs[0], nil
-	}
-
-	remainingGVRs := append([]unversioned.GroupVersionResource{}, originalGVRs...)
-	for _, pattern := range m.ResourcePriority {
-		matchedGVRs := []unversioned.GroupVersionResource{}
-		for _, gvr := range remainingGVRs {
-			if resourceMatches(pattern, gvr) {
-				matchedGVRs = append(matchedGVRs, gvr)
-			}
-		}
-
-		switch len(matchedGVRs) {
-		case 0:
-			// if you have no matches, then nothing matched this pattern just move to the next
-			continue
-		case 1:
-			// one match, return
-			return matchedGVRs[0], nil
-		default:
-			// more than one match, use the matched hits as the list moving to the next pattern.
-			// this way you can have a series of selection criteria
-			remainingGVRs = matchedGVRs
-		}
-	}
-
-	return unversioned.GroupVersionResource{}, &AmbiguousResourceError{PartialResource: partiallySpecifiedResource, MatchingResources: originalGVRs}
-}
-
-// KindFor finds all kinds, then passes them through the KindPriority patterns to find a single matching hit.
-func (m PriorityRESTMapper) KindFor(partiallySpecifiedResource unversioned.GroupVersionResource) (unversioned.GroupVersionKind, error) {
-	originalGVKs, err := m.Delegate.KindsFor(partiallySpecifiedResource)
-	if err != nil {
-		return unversioned.GroupVersionKind{}, err
-	}
-	if len(originalGVKs) == 1 {
-		return originalGVKs[0], nil
-	}
-
-	remainingGVKs := append([]unversioned.GroupVersionKind{}, originalGVKs...)
-	for _, pattern := range m.KindPriority {
-		matchedGVKs := []unversioned.GroupVersionKind{}
-		for _, gvr := range remainingGVKs {
-			if kindMatches(pattern, gvr) {
-				matchedGVKs = append(matchedGVKs, gvr)
-			}
-		}
-
-		switch len(matchedGVKs) {
-		case 0:
-			// if you have no matches, then nothing matched this pattern just move to the next
-			continue
-		case 1:
-			// one match, return
-			return matchedGVKs[0], nil
-		default:
-			// more than one match, use the matched hits as the list moving to the next pattern.
-			// this way you can have a series of selection criteria
-			remainingGVKs = matchedGVKs
-		}
-	}
-
-	return unversioned.GroupVersionKind{}, &AmbiguousResourceError{PartialResource: partiallySpecifiedResource, MatchingKinds: originalGVKs}
-}
-
-func resourceMatches(pattern unversioned.GroupVersionResource, resource unversioned.GroupVersionResource) bool {
-	if pattern.Group != AnyGroup && pattern.Group != resource.Group {
-		return false
-	}
-	if pattern.Version != AnyVersion && pattern.Version != resource.Version {
-		return false
-	}
-	if pattern.Resource != AnyResource && pattern.Resource != resource.Resource {
-		return false
-	}
-
-	return true
-}
-
-func kindMatches(pattern unversioned.GroupVersionKind, kind unversioned.GroupVersionKind) bool {
-	if pattern.Group != AnyGroup && pattern.Group != kind.Group {
-		return false
-	}
-	if pattern.Version != AnyVersion && pattern.Version != kind.Version {
-		return false
-	}
-	if pattern.Kind != AnyKind && pattern.Kind != kind.Kind {
-		return false
-	}
-
-	return true
-}
-
-func (m PriorityRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (mapping *RESTMapping, err error) {
-	mappings, err := m.Delegate.RESTMappings(gk)
-	if err != nil {
-		return nil, err
-	}
-
-	// any versions the user provides take priority
-	priorities := m.KindPriority
-	if len(versions) > 0 {
-		priorities = make([]unversioned.GroupVersionKind, 0, len(m.KindPriority)+len(versions))
-		for _, version := range versions {
-			gv, err := unversioned.ParseGroupVersion(version)
-			if err != nil {
-				return nil, err
-			}
-			priorities = append(priorities, gv.WithKind(AnyKind))
-		}
-		priorities = append(priorities, m.KindPriority...)
-	}
-
-	remaining := append([]*RESTMapping{}, mappings...)
-	for _, pattern := range priorities {
-		var matching []*RESTMapping
-		for _, m := range remaining {
-			if kindMatches(pattern, m.GroupVersionKind) {
-				matching = append(matching, m)
-			}
-		}
-
-		switch len(matching) {
-		case 0:
-			// if you have no matches, then nothing matched this pattern just move to the next
-			continue
-		case 1:
-			// one match, return
-			return matching[0], nil
-		default:
-			// more than one match, use the matched hits as the list moving to the next pattern.
-			// this way you can have a series of selection criteria
-			remaining = matching
-		}
-	}
-	if len(remaining) == 1 {
-		return remaining[0], nil
-	}
-
-	var kinds []unversioned.GroupVersionKind
-	for _, m := range mappings {
-		kinds = append(kinds, m.GroupVersionKind)
-	}
-	return nil, &AmbiguousKindError{PartialKind: gk.WithVersion(""), MatchingKinds: kinds}
-}
-
-func (m PriorityRESTMapper) RESTMappings(gk unversioned.GroupKind) ([]*RESTMapping, error) {
-	return m.Delegate.RESTMappings(gk)
-}
-
-func (m PriorityRESTMapper) AliasesForResource(alias string) (aliases []string, ok bool) {
-	return m.Delegate.AliasesForResource(alias)
-}
-
-func (m PriorityRESTMapper) ResourceSingularizer(resource string) (singular string, err error) {
-	return m.Delegate.ResourceSingularizer(resource)
-}
-
-func (m PriorityRESTMapper) ResourcesFor(partiallySpecifiedResource unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error) {
-	return m.Delegate.ResourcesFor(partiallySpecifiedResource)
-}
-
-func (m PriorityRESTMapper) KindsFor(partiallySpecifiedResource unversioned.GroupVersionResource) (gvk []unversioned.GroupVersionKind, err error) {
-	return m.Delegate.KindsFor(partiallySpecifiedResource)
-}

1.5/pkg/api/meta/restmapper.go

@@ -1,601 +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.
-*/
-
-// TODO: move everything in this file to pkg/api/rest
-package meta
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/runtime"
-)
-
-// Implements RESTScope interface
-type restScope struct {
-	name             RESTScopeName
-	paramName        string
-	argumentName     string
-	paramDescription string
-}
-
-func (r *restScope) Name() RESTScopeName {
-	return r.name
-}
-func (r *restScope) ParamName() string {
-	return r.paramName
-}
-func (r *restScope) ArgumentName() string {
-	return r.argumentName
-}
-func (r *restScope) ParamDescription() string {
-	return r.paramDescription
-}
-
-var RESTScopeNamespace = &restScope{
-	name:             RESTScopeNameNamespace,
-	paramName:        "namespaces",
-	argumentName:     "namespace",
-	paramDescription: "object name and auth scope, such as for teams and projects",
-}
-
-var RESTScopeRoot = &restScope{
-	name: RESTScopeNameRoot,
-}
-
-// DefaultRESTMapper exposes mappings between the types defined in a
-// runtime.Scheme. It assumes that all types defined the provided scheme
-// can be mapped with the provided MetadataAccessor and Codec interfaces.
-//
-// The resource name of a Kind is defined as the lowercase,
-// English-plural version of the Kind string.
-// When converting from resource to Kind, the singular version of the
-// resource name is also accepted for convenience.
-//
-// TODO: Only accept plural for some operations for increased control?
-// (`get pod bar` vs `get pods bar`)
-type DefaultRESTMapper struct {
-	defaultGroupVersions []unversioned.GroupVersion
-
-	resourceToKind       map[unversioned.GroupVersionResource]unversioned.GroupVersionKind
-	kindToPluralResource map[unversioned.GroupVersionKind]unversioned.GroupVersionResource
-	kindToScope          map[unversioned.GroupVersionKind]RESTScope
-	singularToPlural     map[unversioned.GroupVersionResource]unversioned.GroupVersionResource
-	pluralToSingular     map[unversioned.GroupVersionResource]unversioned.GroupVersionResource
-
-	interfacesFunc VersionInterfacesFunc
-
-	// aliasToResource is used for mapping aliases to resources
-	aliasToResource map[string][]string
-}
-
-func (m *DefaultRESTMapper) String() string {
-	return fmt.Sprintf("DefaultRESTMapper{kindToPluralResource=%v}", m.kindToPluralResource)
-}
-
-var _ RESTMapper = &DefaultRESTMapper{}
-
-// VersionInterfacesFunc returns the appropriate typer, and metadata accessor for a
-// given api version, or an error if no such api version exists.
-type VersionInterfacesFunc func(version unversioned.GroupVersion) (*VersionInterfaces, error)
-
-// NewDefaultRESTMapper initializes a mapping between Kind and APIVersion
-// to a resource name and back based on the objects in a runtime.Scheme
-// and the Kubernetes API conventions. Takes a group name, a priority list of the versions
-// to search when an object has no default version (set empty to return an error),
-// and a function that retrieves the correct metadata for a given version.
-func NewDefaultRESTMapper(defaultGroupVersions []unversioned.GroupVersion, f VersionInterfacesFunc) *DefaultRESTMapper {
-	resourceToKind := make(map[unversioned.GroupVersionResource]unversioned.GroupVersionKind)
-	kindToPluralResource := make(map[unversioned.GroupVersionKind]unversioned.GroupVersionResource)
-	kindToScope := make(map[unversioned.GroupVersionKind]RESTScope)
-	singularToPlural := make(map[unversioned.GroupVersionResource]unversioned.GroupVersionResource)
-	pluralToSingular := make(map[unversioned.GroupVersionResource]unversioned.GroupVersionResource)
-	aliasToResource := make(map[string][]string)
-	// TODO: verify name mappings work correctly when versions differ
-
-	return &DefaultRESTMapper{
-		resourceToKind:       resourceToKind,
-		kindToPluralResource: kindToPluralResource,
-		kindToScope:          kindToScope,
-		defaultGroupVersions: defaultGroupVersions,
-		singularToPlural:     singularToPlural,
-		pluralToSingular:     pluralToSingular,
-		aliasToResource:      aliasToResource,
-		interfacesFunc:       f,
-	}
-}
-
-func (m *DefaultRESTMapper) Add(kind unversioned.GroupVersionKind, scope RESTScope) {
-	plural, singular := KindToResource(kind)
-
-	m.singularToPlural[singular] = plural
-	m.pluralToSingular[plural] = singular
-
-	m.resourceToKind[singular] = kind
-	m.resourceToKind[plural] = kind
-
-	m.kindToPluralResource[kind] = plural
-	m.kindToScope[kind] = scope
-}
-
-// unpluralizedSuffixes is a list of resource suffixes that are the same plural and singular
-// This is only is only necessary because some bits of code are lazy and don't actually use the RESTMapper like they should.
-// TODO eliminate this so that different callers can correctly map to resources.  This probably means updating all
-// callers to use the RESTMapper they mean.
-var unpluralizedSuffixes = []string{
-	"endpoints",
-}
-
-// KindToResource converts Kind to a resource name.
-// Broken. This method only "sort of" works when used outside of this package.  It assumes that Kinds and Resources match
-// and they aren't guaranteed to do so.
-func KindToResource(kind unversioned.GroupVersionKind) ( /*plural*/ unversioned.GroupVersionResource /*singular*/, unversioned.GroupVersionResource) {
-	kindName := kind.Kind
-	if len(kindName) == 0 {
-		return unversioned.GroupVersionResource{}, unversioned.GroupVersionResource{}
-	}
-	singularName := strings.ToLower(kindName)
-	singular := kind.GroupVersion().WithResource(singularName)
-
-	for _, skip := range unpluralizedSuffixes {
-		if strings.HasSuffix(singularName, skip) {
-			return singular, singular
-		}
-	}
-
-	switch string(singularName[len(singularName)-1]) {
-	case "s":
-		return kind.GroupVersion().WithResource(singularName + "es"), singular
-	case "y":
-		return kind.GroupVersion().WithResource(strings.TrimSuffix(singularName, "y") + "ies"), singular
-	}
-
-	return kind.GroupVersion().WithResource(singularName + "s"), singular
-}
-
-// ResourceSingularizer implements RESTMapper
-// It converts a resource name from plural to singular (e.g., from pods to pod)
-func (m *DefaultRESTMapper) ResourceSingularizer(resourceType string) (string, error) {
-	partialResource := unversioned.GroupVersionResource{Resource: resourceType}
-	resources, err := m.ResourcesFor(partialResource)
-	if err != nil {
-		return resourceType, err
-	}
-
-	singular := unversioned.GroupVersionResource{}
-	for _, curr := range resources {
-		currSingular, ok := m.pluralToSingular[curr]
-		if !ok {
-			continue
-		}
-		if singular.Empty() {
-			singular = currSingular
-			continue
-		}
-
-		if currSingular.Resource != singular.Resource {
-			return resourceType, fmt.Errorf("multiple possible singular resources (%v) found for %v", resources, resourceType)
-		}
-	}
-
-	if singular.Empty() {
-		return resourceType, fmt.Errorf("no singular of resource %v has been defined", resourceType)
-	}
-
-	return singular.Resource, nil
-}
-
-// coerceResourceForMatching makes the resource lower case and converts internal versions to unspecified (legacy behavior)
-func coerceResourceForMatching(resource unversioned.GroupVersionResource) unversioned.GroupVersionResource {
-	resource.Resource = strings.ToLower(resource.Resource)
-	if resource.Version == runtime.APIVersionInternal {
-		resource.Version = ""
-	}
-
-	return resource
-}
-
-func (m *DefaultRESTMapper) ResourcesFor(input unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error) {
-	resource := coerceResourceForMatching(input)
-
-	hasResource := len(resource.Resource) > 0
-	hasGroup := len(resource.Group) > 0
-	hasVersion := len(resource.Version) > 0
-
-	if !hasResource {
-		return nil, fmt.Errorf("a resource must be present, got: %v", resource)
-	}
-
-	ret := []unversioned.GroupVersionResource{}
-	switch {
-	case hasGroup && hasVersion:
-		// fully qualified.  Find the exact match
-		for plural, singular := range m.pluralToSingular {
-			if singular == resource {
-				ret = append(ret, plural)
-				break
-			}
-			if plural == resource {
-				ret = append(ret, plural)
-				break
-			}
-		}
-
-	case hasGroup:
-		// given a group, prefer an exact match.  If you don't find one, resort to a prefix match on group
-		foundExactMatch := false
-		requestedGroupResource := resource.GroupResource()
-		for plural, singular := range m.pluralToSingular {
-			if singular.GroupResource() == requestedGroupResource {
-				foundExactMatch = true
-				ret = append(ret, plural)
-			}
-			if plural.GroupResource() == requestedGroupResource {
-				foundExactMatch = true
-				ret = append(ret, plural)
-			}
-		}
-
-		// if you didn't find an exact match, match on group prefixing. This allows storageclass.storage to match
-		// storageclass.storage.k8s.io
-		if !foundExactMatch {
-			for plural, singular := range m.pluralToSingular {
-				if !strings.HasPrefix(plural.Group, requestedGroupResource.Group) {
-					continue
-				}
-				if singular.Resource == requestedGroupResource.Resource {
-					ret = append(ret, plural)
-				}
-				if plural.Resource == requestedGroupResource.Resource {
-					ret = append(ret, plural)
-				}
-			}
-
-		}
-
-	case hasVersion:
-		for plural, singular := range m.pluralToSingular {
-			if singular.Version == resource.Version && singular.Resource == resource.Resource {
-				ret = append(ret, plural)
-			}
-			if plural.Version == resource.Version && plural.Resource == resource.Resource {
-				ret = append(ret, plural)
-			}
-		}
-
-	default:
-		for plural, singular := range m.pluralToSingular {
-			if singular.Resource == resource.Resource {
-				ret = append(ret, plural)
-			}
-			if plural.Resource == resource.Resource {
-				ret = append(ret, plural)
-			}
-		}
-	}
-
-	if len(ret) == 0 {
-		return nil, &NoResourceMatchError{PartialResource: resource}
-	}
-
-	sort.Sort(resourceByPreferredGroupVersion{ret, m.defaultGroupVersions})
-	return ret, nil
-}
-
-func (m *DefaultRESTMapper) ResourceFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionResource, error) {
-	resources, err := m.ResourcesFor(resource)
-	if err != nil {
-		return unversioned.GroupVersionResource{}, err
-	}
-	if len(resources) == 1 {
-		return resources[0], nil
-	}
-
-	return unversioned.GroupVersionResource{}, &AmbiguousResourceError{PartialResource: resource, MatchingResources: resources}
-}
-
-func (m *DefaultRESTMapper) KindsFor(input unversioned.GroupVersionResource) ([]unversioned.GroupVersionKind, error) {
-	resource := coerceResourceForMatching(input)
-
-	hasResource := len(resource.Resource) > 0
-	hasGroup := len(resource.Group) > 0
-	hasVersion := len(resource.Version) > 0
-
-	if !hasResource {
-		return nil, fmt.Errorf("a resource must be present, got: %v", resource)
-	}
-
-	ret := []unversioned.GroupVersionKind{}
-	switch {
-	// fully qualified.  Find the exact match
-	case hasGroup && hasVersion:
-		kind, exists := m.resourceToKind[resource]
-		if exists {
-			ret = append(ret, kind)
-		}
-
-	case hasGroup:
-		foundExactMatch := false
-		requestedGroupResource := resource.GroupResource()
-		for currResource, currKind := range m.resourceToKind {
-			if currResource.GroupResource() == requestedGroupResource {
-				foundExactMatch = true
-				ret = append(ret, currKind)
-			}
-		}
-
-		// if you didn't find an exact match, match on group prefixing. This allows storageclass.storage to match
-		// storageclass.storage.k8s.io
-		if !foundExactMatch {
-			for currResource, currKind := range m.resourceToKind {
-				if !strings.HasPrefix(currResource.Group, requestedGroupResource.Group) {
-					continue
-				}
-				if currResource.Resource == requestedGroupResource.Resource {
-					ret = append(ret, currKind)
-				}
-			}
-
-		}
-
-	case hasVersion:
-		for currResource, currKind := range m.resourceToKind {
-			if currResource.Version == resource.Version && currResource.Resource == resource.Resource {
-				ret = append(ret, currKind)
-			}
-		}
-
-	default:
-		for currResource, currKind := range m.resourceToKind {
-			if currResource.Resource == resource.Resource {
-				ret = append(ret, currKind)
-			}
-		}
-	}
-
-	if len(ret) == 0 {
-		return nil, &NoResourceMatchError{PartialResource: input}
-	}
-
-	sort.Sort(kindByPreferredGroupVersion{ret, m.defaultGroupVersions})
-	return ret, nil
-}
-
-func (m *DefaultRESTMapper) KindFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionKind, error) {
-	kinds, err := m.KindsFor(resource)
-	if err != nil {
-		return unversioned.GroupVersionKind{}, err
-	}
-	if len(kinds) == 1 {
-		return kinds[0], nil
-	}
-
-	return unversioned.GroupVersionKind{}, &AmbiguousResourceError{PartialResource: resource, MatchingKinds: kinds}
-}
-
-type kindByPreferredGroupVersion struct {
-	list      []unversioned.GroupVersionKind
-	sortOrder []unversioned.GroupVersion
-}
-
-func (o kindByPreferredGroupVersion) Len() int      { return len(o.list) }
-func (o kindByPreferredGroupVersion) Swap(i, j int) { o.list[i], o.list[j] = o.list[j], o.list[i] }
-func (o kindByPreferredGroupVersion) Less(i, j int) bool {
-	lhs := o.list[i]
-	rhs := o.list[j]
-	if lhs == rhs {
-		return false
-	}
-
-	if lhs.GroupVersion() == rhs.GroupVersion() {
-		return lhs.Kind < rhs.Kind
-	}
-
-	// otherwise, the difference is in the GroupVersion, so we need to sort with respect to the preferred order
-	lhsIndex := -1
-	rhsIndex := -1
-
-	for i := range o.sortOrder {
-		if o.sortOrder[i] == lhs.GroupVersion() {
-			lhsIndex = i
-		}
-		if o.sortOrder[i] == rhs.GroupVersion() {
-			rhsIndex = i
-		}
-	}
-
-	if rhsIndex == -1 {
-		return true
-	}
-
-	return lhsIndex < rhsIndex
-}
-
-type resourceByPreferredGroupVersion struct {
-	list      []unversioned.GroupVersionResource
-	sortOrder []unversioned.GroupVersion
-}
-
-func (o resourceByPreferredGroupVersion) Len() int      { return len(o.list) }
-func (o resourceByPreferredGroupVersion) Swap(i, j int) { o.list[i], o.list[j] = o.list[j], o.list[i] }
-func (o resourceByPreferredGroupVersion) Less(i, j int) bool {
-	lhs := o.list[i]
-	rhs := o.list[j]
-	if lhs == rhs {
-		return false
-	}
-
-	if lhs.GroupVersion() == rhs.GroupVersion() {
-		return lhs.Resource < rhs.Resource
-	}
-
-	// otherwise, the difference is in the GroupVersion, so we need to sort with respect to the preferred order
-	lhsIndex := -1
-	rhsIndex := -1
-
-	for i := range o.sortOrder {
-		if o.sortOrder[i] == lhs.GroupVersion() {
-			lhsIndex = i
-		}
-		if o.sortOrder[i] == rhs.GroupVersion() {
-			rhsIndex = i
-		}
-	}
-
-	if rhsIndex == -1 {
-		return true
-	}
-
-	return lhsIndex < rhsIndex
-}
-
-// RESTMapping returns a struct representing the resource path and conversion interfaces a
-// RESTClient should use to operate on the provided group/kind in order of versions. If a version search
-// order is not provided, the search order provided to DefaultRESTMapper will be used to resolve which
-// version should be used to access the named group/kind.
-// TODO: consider refactoring to use RESTMappings in a way that preserves version ordering and preference
-func (m *DefaultRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (*RESTMapping, error) {
-	// Pick an appropriate version
-	var gvk *unversioned.GroupVersionKind
-	hadVersion := false
-	for _, version := range versions {
-		if len(version) == 0 || version == runtime.APIVersionInternal {
-			continue
-		}
-
-		currGVK := gk.WithVersion(version)
-		hadVersion = true
-		if _, ok := m.kindToPluralResource[currGVK]; ok {
-			gvk = &currGVK
-			break
-		}
-	}
-	// Use the default preferred versions
-	if !hadVersion && (gvk == nil) {
-		for _, gv := range m.defaultGroupVersions {
-			if gv.Group != gk.Group {
-				continue
-			}
-
-			currGVK := gk.WithVersion(gv.Version)
-			if _, ok := m.kindToPluralResource[currGVK]; ok {
-				gvk = &currGVK
-				break
-			}
-		}
-	}
-	if gvk == nil {
-		return nil, &NoKindMatchError{PartialKind: gk.WithVersion("")}
-	}
-
-	// Ensure we have a REST mapping
-	resource, ok := m.kindToPluralResource[*gvk]
-	if !ok {
-		found := []unversioned.GroupVersion{}
-		for _, gv := range m.defaultGroupVersions {
-			if _, ok := m.kindToPluralResource[*gvk]; ok {
-				found = append(found, gv)
-			}
-		}
-		if len(found) > 0 {
-			return nil, fmt.Errorf("object with kind %q exists in versions %v, not %v", gvk.Kind, found, gvk.GroupVersion().String())
-		}
-		return nil, fmt.Errorf("the provided version %q and kind %q cannot be mapped to a supported object", gvk.GroupVersion().String(), gvk.Kind)
-	}
-
-	// Ensure we have a REST scope
-	scope, ok := m.kindToScope[*gvk]
-	if !ok {
-		return nil, fmt.Errorf("the provided version %q and kind %q cannot be mapped to a supported scope", gvk.GroupVersion().String(), gvk.Kind)
-	}
-
-	interfaces, err := m.interfacesFunc(gvk.GroupVersion())
-	if err != nil {
-		return nil, fmt.Errorf("the provided version %q has no relevant versions: %v", gvk.GroupVersion().String(), err)
-	}
-
-	retVal := &RESTMapping{
-		Resource:         resource.Resource,
-		GroupVersionKind: *gvk,
-		Scope:            scope,
-
-		ObjectConvertor:  interfaces.ObjectConvertor,
-		MetadataAccessor: interfaces.MetadataAccessor,
-	}
-
-	return retVal, nil
-}
-
-// 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 (m *DefaultRESTMapper) RESTMappings(gk unversioned.GroupKind) ([]*RESTMapping, error) {
-	// Use the default preferred versions
-	var mappings []*RESTMapping
-	for _, gv := range m.defaultGroupVersions {
-		if gv.Group != gk.Group {
-			continue
-		}
-
-		gvk := gk.WithVersion(gv.Version)
-		gvr, ok := m.kindToPluralResource[gvk]
-		if !ok {
-			continue
-		}
-
-		// Ensure we have a REST scope
-		scope, ok := m.kindToScope[gvk]
-		if !ok {
-			return nil, fmt.Errorf("the provided version %q and kind %q cannot be mapped to a supported scope", gvk.GroupVersion(), gvk.Kind)
-		}
-
-		interfaces, err := m.interfacesFunc(gvk.GroupVersion())
-		if err != nil {
-			return nil, fmt.Errorf("the provided version %q has no relevant versions: %v", gvk.GroupVersion().String(), err)
-		}
-
-		mappings = append(mappings, &RESTMapping{
-			Resource:         gvr.Resource,
-			GroupVersionKind: gvk,
-			Scope:            scope,
-
-			ObjectConvertor:  interfaces.ObjectConvertor,
-			MetadataAccessor: interfaces.MetadataAccessor,
-		})
-	}
-
-	if len(mappings) == 0 {
-		return nil, &NoResourceMatchError{PartialResource: unversioned.GroupVersionResource{Group: gk.Group, Resource: gk.Kind}}
-	}
-	return mappings, nil
-}
-
-// AddResourceAlias maps aliases to resources
-func (m *DefaultRESTMapper) AddResourceAlias(alias string, resources ...string) {
-	if len(resources) == 0 {
-		return
-	}
-	m.aliasToResource[alias] = resources
-}
-
-// AliasesForResource returns whether a resource has an alias or not
-func (m *DefaultRESTMapper) AliasesForResource(alias string) ([]string, bool) {
-	if res, ok := m.aliasToResource[alias]; ok {
-		return res, true
-	}
-	return nil, false
-}

1.5/pkg/api/meta/unstructured.go

@@ -1,31 +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 meta
-
-import (
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/runtime"
-)
-
-// InterfacesForUnstructured returns VersionInterfaces suitable for
-// dealing with runtime.Unstructured objects.
-func InterfacesForUnstructured(unversioned.GroupVersion) (*VersionInterfaces, error) {
-	return &VersionInterfaces{
-		ObjectConvertor:  &runtime.UnstructuredObjectConverter{},
-		MetadataAccessor: NewAccessor(),
-	}, nil
-}

1.5/pkg/api/register.go

@@ -1,139 +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 api
-
-import (
-	"k8s.io/client-go/1.5/pkg/api/unversioned"
-	"k8s.io/client-go/1.5/pkg/runtime"
-	"k8s.io/client-go/1.5/pkg/runtime/serializer"
-)
-
-// Scheme is the default instance of runtime.Scheme to which types in the Kubernetes API are already registered.
-// NOTE: If you are copying this file to start a new api group, STOP! Copy the
-// extensions group instead. This Scheme is special and should appear ONLY in
-// the api group, unless you really know what you're doing.
-// TODO(lavalamp): make the above error impossible.
-var Scheme = runtime.NewScheme()
-
-// Codecs provides access to encoding and decoding for the scheme
-var Codecs = serializer.NewCodecFactory(Scheme)
-
-// GroupName is the group name use in this package
-const GroupName = ""
-
-// SchemeGroupVersion is group version used to register these objects
-var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}
-
-// Unversioned is group version for unversioned API objects
-// TODO: this should be v1 probably
-var Unversioned = unversioned.GroupVersion{Group: "", Version: "v1"}
-
-// ParameterCodec handles versioning of objects that are converted to query parameters.
-var ParameterCodec = runtime.NewParameterCodec(Scheme)
-
-// Kind takes an unqualified kind and returns a Group qualified GroupKind
-func Kind(kind string) unversioned.GroupKind {
-	return SchemeGroupVersion.WithKind(kind).GroupKind()
-}
-
-// Resource takes an unqualified resource and returns a Group qualified GroupResource
-func Resource(resource string) unversioned.GroupResource {
-	return SchemeGroupVersion.WithResource(resource).GroupResource()
-}
-
-var (
-	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, addDefaultingFuncs)
-	AddToScheme   = SchemeBuilder.AddToScheme
-)
-
-func init() {
-	// TODO(lavalamp): move this call to scheme builder above.  Can't
-	// remove it from here because lots of people inappropriately rely on it
-	// (specifically the unversioned time conversion). Can't have it in
-	// both places because then it gets double registered.  Consequence of
-	// current state is that it only ever gets registered in the main
-	// api.Scheme, even though everyone that uses anything from unversioned
-	// needs these.
-	if err := addConversionFuncs(Scheme); err != nil {
-		// Programmer error.
-		panic(err)
-	}
-}
-
-func addKnownTypes(scheme *runtime.Scheme) error {
-	if err := scheme.AddIgnoredConversionType(&unversioned.TypeMeta{}, &unversioned.TypeMeta{}); err != nil {
-		return err
-	}
-	scheme.AddKnownTypes(SchemeGroupVersion,
-		&Pod{},
-		&PodList{},
-		&PodStatusResult{},
-		&PodTemplate{},
-		&PodTemplateList{},
-		&ReplicationControllerList{},
-		&ReplicationController{},
-		&ServiceList{},
-		&Service{},
-		&ServiceProxyOptions{},
-		&NodeList{},
-		&Node{},
-		&NodeProxyOptions{},
-		&Endpoints{},
-		&EndpointsList{},
-		&Binding{},
-		&Event{},
-		&EventList{},
-		&List{},
-		&LimitRange{},
-		&LimitRangeList{},
-		&ResourceQuota{},
-		&ResourceQuotaList{},
-		&Namespace{},
-		&NamespaceList{},
-		&ServiceAccount{},
-		&ServiceAccountList{},
-		&Secret{},
-		&SecretList{},
-		&PersistentVolume{},
-		&PersistentVolumeList{},
-		&PersistentVolumeClaim{},
-		&PersistentVolumeClaimList{},
-		&DeleteOptions{},
-		&ListOptions{},
-		&PodAttachOptions{},
-		&PodLogOptions{},
-		&PodExecOptions{},
-		&PodProxyOptions{},
-		&ComponentStatus{},
-		&ComponentStatusList{},
-		&SerializedReference{},
-		&RangeAllocation{},
-		&ConfigMap{},
-		&ConfigMapList{},
-	)
-
-	// Register Unversioned types under their own special group
-	scheme.AddUnversionedTypes(Unversioned,
-		&unversioned.ExportOptions{},
-		&unversioned.Status{},
-		&unversioned.APIVersions{},
-		&unversioned.APIGroupList{},
-		&unversioned.APIGroup{},
-		&unversioned.APIResourceList{},
-	)
-	return nil
-}

1.5/pkg/api/requestcontext.go

@@ -1,117 +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 api
-
-import (
-	"errors"
-	"net/http"
-	"sync"
-
-	"github.com/golang/glog"
-)
-
-// RequestContextMapper keeps track of the context associated with a particular request
-type RequestContextMapper interface {
-	// Get returns the context associated with the given request (if any), and true if the request has an associated context, and false if it does not.
-	Get(req *http.Request) (Context, bool)
-	// Update maps the request to the given context. If no context was previously associated with the request, an error is returned.
-	// Update should only be called with a descendant context of the previously associated context.
-	// Updating to an unrelated context may return an error in the future.
-	// The context associated with a request should only be updated by a limited set of callers.
-	// Valid examples include the authentication layer, or an audit/tracing layer.
-	Update(req *http.Request, context Context) error
-}
-
-type requestContextMap struct {
-	contexts map[*http.Request]Context
-	lock     sync.Mutex
-}
-
-// NewRequestContextMapper returns a new RequestContextMapper.
-// The returned mapper must be added as a request filter using NewRequestContextFilter.
-func NewRequestContextMapper() RequestContextMapper {
-	return &requestContextMap{
-		contexts: make(map[*http.Request]Context),
-	}
-}
-
-// Get returns the context associated with the given request (if any), and true if the request has an associated context, and false if it does not.
-// Get will only return a valid context when called from inside the filter chain set up by NewRequestContextFilter()
-func (c *requestContextMap) Get(req *http.Request) (Context, bool) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	context, ok := c.contexts[req]
-	return context, ok
-}
-
-// Update maps the request to the given context.
-// If no context was previously associated with the request, an error is returned and the context is ignored.
-func (c *requestContextMap) Update(req *http.Request, context Context) error {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	if _, ok := c.contexts[req]; !ok {
-		return errors.New("No context associated")
-	}
-	// TODO: ensure the new context is a descendant of the existing one
-	c.contexts[req] = context
-	return nil
-}
-
-// init maps the request to the given context and returns true if there was no context associated with the request already.
-// if a context was already associated with the request, it ignores the given context and returns false.
-// init is intentionally unexported to ensure that all init calls are paired with a remove after a request is handled
-func (c *requestContextMap) init(req *http.Request, context Context) bool {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	if _, exists := c.contexts[req]; exists {
-		return false
-	}
-	c.contexts[req] = context
-	return true
-}
-
-// remove is intentionally unexported to ensure that the context is not removed until a request is handled
-func (c *requestContextMap) remove(req *http.Request) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	delete(c.contexts, req)
-}
-
-// WithRequestContext ensures there is a Context object associated with the request before calling the passed handler.
-// After the passed handler runs, the context is cleaned up.
-func WithRequestContext(handler http.Handler, mapper RequestContextMapper) http.Handler {
-	rcMap, ok := mapper.(*requestContextMap)
-	if !ok {
-		glog.Fatal("Unknown RequestContextMapper implementation.")
-	}
-
-	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		if rcMap.init(req, NewContext()) {
-			// If we were the ones to successfully initialize, pair with a remove
-			defer rcMap.remove(req)
-		}
-		handler.ServeHTTP(w, req)
-	})
-}
-
-// IsEmpty returns true if there are no contexts registered, or an error if it could not be determined. Intended for use by tests.
-func IsEmpty(requestsToContexts RequestContextMapper) (bool, error) {
-	if requestsToContexts, ok := requestsToContexts.(*requestContextMap); ok {
-		return len(requestsToContexts.contexts) == 0, nil
-	}
-	return true, errors.New("Unknown RequestContextMapper implementation")
-}

1.5/pkg/api/resource/amount.go

@@ -1,299 +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 resource
-
-import (
-	"math/big"
-	"strconv"
-
-	inf "gopkg.in/inf.v0"
-)
-
-// Scale is used for getting and setting the base-10 scaled value.
-// Base-2 scales are omitted for mathematical simplicity.
-// See Quantity.ScaledValue for more details.
-type Scale int32
-
-// infScale adapts a Scale value to an inf.Scale value.
-func (s Scale) infScale() inf.Scale {
-	return inf.Scale(-s) // inf.Scale is upside-down
-}
-
-const (
-	Nano  Scale = -9
-	Micro Scale = -6
-	Milli Scale = -3
-	Kilo  Scale = 3
-	Mega  Scale = 6
-	Giga  Scale = 9
-	Tera  Scale = 12
-	Peta  Scale = 15
-	Exa   Scale = 18
-)
-
-var (
-	Zero = int64Amount{}
-
-	// Used by quantity strings - treat as read only
-	zeroBytes = []byte("0")
-)
-
-// int64Amount represents a fixed precision numerator and arbitrary scale exponent. It is faster
-// than operations on inf.Dec for values that can be represented as int64.
-// +k8s:openapi-gen=true
-type int64Amount struct {
-	value int64
-	scale Scale
-}
-
-// Sign returns 0 if the value is zero, -1 if it is less than 0, or 1 if it is greater than 0.
-func (a int64Amount) Sign() int {
-	switch {
-	case a.value == 0:
-		return 0
-	case a.value > 0:
-		return 1
-	default:
-		return -1
-	}
-}
-
-// AsInt64 returns the current amount as an int64 at scale 0, or false if the value cannot be
-// represented in an int64 OR would result in a loss of precision. This method is intended as
-// an optimization to avoid calling AsDec.
-func (a int64Amount) AsInt64() (int64, bool) {
-	if a.scale == 0 {
-		return a.value, true
-	}
-	if a.scale < 0 {
-		// TODO: attempt to reduce factors, although it is assumed that factors are reduced prior
-		// to the int64Amount being created.
-		return 0, false
-	}
-	return positiveScaleInt64(a.value, a.scale)
-}
-
-// AsScaledInt64 returns an int64 representing the value of this amount at the specified scale,
-// rounding up, or false if that would result in overflow. (1e20).AsScaledInt64(1) would result
-// in overflow because 1e19 is not representable as an int64. Note that setting a scale larger
-// than the current value may result in loss of precision - i.e. (1e-6).AsScaledInt64(0) would
-// return 1, because 0.000001 is rounded up to 1.
-func (a int64Amount) AsScaledInt64(scale Scale) (result int64, ok bool) {
-	if a.scale < scale {
-		result, _ = negativeScaleInt64(a.value, scale-a.scale)
-		return result, true
-	}
-	return positiveScaleInt64(a.value, a.scale-scale)
-}
-
-// AsDec returns an inf.Dec representation of this value.
-func (a int64Amount) AsDec() *inf.Dec {
-	var base inf.Dec
-	base.SetUnscaled(a.value)
-	base.SetScale(inf.Scale(-a.scale))
-	return &base
-}
-
-// Cmp returns 0 if a and b are equal, 1 if a is greater than b, or -1 if a is less than b.
-func (a int64Amount) Cmp(b int64Amount) int {
-	switch {
-	case a.scale == b.scale:
-		// compare only the unscaled portion
-	case a.scale > b.scale:
-		result, remainder, exact := divideByScaleInt64(b.value, a.scale-b.scale)
-		if !exact {
-			return a.AsDec().Cmp(b.AsDec())
-		}
-		if result == a.value {
-			switch {
-			case remainder == 0:
-				return 0
-			case remainder > 0:
-				return -1
-			default:
-				return 1
-			}
-		}
-		b.value = result
-	default:
-		result, remainder, exact := divideByScaleInt64(a.value, b.scale-a.scale)
-		if !exact {
-			return a.AsDec().Cmp(b.AsDec())
-		}
-		if result == b.value {
-			switch {
-			case remainder == 0:
-				return 0
-			case remainder > 0:
-				return 1
-			default:
-				return -1
-			}
-		}
-		a.value = result
-	}
-
-	switch {
-	case a.value == b.value:
-		return 0
-	case a.value < b.value:
-		return -1
-	default:
-		return 1
-	}
-}
-
-// Add adds two int64Amounts together, matching scales. It will return false and not mutate
-// a if overflow or underflow would result.
-func (a *int64Amount) Add(b int64Amount) bool {
-	switch {
-	case b.value == 0:
-		return true
-	case a.value == 0:
-		a.value = b.value
-		a.scale = b.scale
-		return true
-	case a.scale == b.scale:
-		c, ok := int64Add(a.value, b.value)
-		if !ok {
-			return false
-		}
-		a.value = c
-	case a.scale > b.scale:
-		c, ok := positiveScaleInt64(a.value, a.scale-b.scale)
-		if !ok {
-			return false
-		}
-		c, ok = int64Add(c, b.value)
-		if !ok {
-			return false
-		}
-		a.scale = b.scale
-		a.value = c
-	default:
-		c, ok := positiveScaleInt64(b.value, b.scale-a.scale)
-		if !ok {
-			return false
-		}
-		c, ok = int64Add(a.value, c)
-		if !ok {
-			return false
-		}
-		a.value = c
-	}
-	return true
-}
-
-// Sub removes the value of b from the current amount, or returns false if underflow would result.
-func (a *int64Amount) Sub(b int64Amount) bool {
-	return a.Add(int64Amount{value: -b.value, scale: b.scale})
-}
-
-// AsScale adjusts this amount to set a minimum scale, rounding up, and returns true iff no precision
-// was lost. (1.1e5).AsScale(5) would return 1.1e5, but (1.1e5).AsScale(6) would return 1e6.
-func (a int64Amount) AsScale(scale Scale) (int64Amount, bool) {
-	if a.scale >= scale {
-		return a, true
-	}
-	result, exact := negativeScaleInt64(a.value, scale-a.scale)
-	return int64Amount{value: result, scale: scale}, exact
-}
-
-// AsCanonicalBytes accepts a buffer to write the base-10 string value of this field to, and returns
-// either that buffer or a larger buffer and the current exponent of the value. The value is adjusted
-// until the exponent is a multiple of 3 - i.e. 1.1e5 would return "110", 3.
-func (a int64Amount) AsCanonicalBytes(out []byte) (result []byte, exponent int32) {
-	mantissa := a.value
-	exponent = int32(a.scale)
-
-	amount, times := removeInt64Factors(mantissa, 10)
-	exponent += int32(times)
-
-	// make sure exponent is a multiple of 3
-	var ok bool
-	switch exponent % 3 {
-	case 1, -2:
-		amount, ok = int64MultiplyScale10(amount)
-		if !ok {
-			return infDecAmount{a.AsDec()}.AsCanonicalBytes(out)
-		}
-		exponent = exponent - 1
-	case 2, -1:
-		amount, ok = int64MultiplyScale100(amount)
-		if !ok {
-			return infDecAmount{a.AsDec()}.AsCanonicalBytes(out)
-		}
-		exponent = exponent - 2
-	}
-	return strconv.AppendInt(out, amount, 10), exponent
-}
-
-// AsCanonicalBase1024Bytes accepts a buffer to write the base-1024 string value of this field to, and returns
-// either that buffer or a larger buffer and the current exponent of the value. 2048 is 2 * 1024 ^ 1 and would
-// return []byte("2048"), 1.
-func (a int64Amount) AsCanonicalBase1024Bytes(out []byte) (result []byte, exponent int32) {
-	value, ok := a.AsScaledInt64(0)
-	if !ok {
-		return infDecAmount{a.AsDec()}.AsCanonicalBase1024Bytes(out)
-	}
-	amount, exponent := removeInt64Factors(value, 1024)
-	return strconv.AppendInt(out, amount, 10), exponent
-}
-
-// infDecAmount implements common operations over an inf.Dec that are specific to the quantity
-// representation.
-type infDecAmount struct {
-	*inf.Dec
-}
-
-// AsScale adjusts this amount to set a minimum scale, rounding up, and returns true iff no precision
-// was lost. (1.1e5).AsScale(5) would return 1.1e5, but (1.1e5).AsScale(6) would return 1e6.
-func (a infDecAmount) AsScale(scale Scale) (infDecAmount, bool) {
-	tmp := &inf.Dec{}
-	tmp.Round(a.Dec, scale.infScale(), inf.RoundUp)
-	return infDecAmount{tmp}, tmp.Cmp(a.Dec) == 0
-}
-
-// AsCanonicalBytes accepts a buffer to write the base-10 string value of this field to, and returns
-// either that buffer or a larger buffer and the current exponent of the value. The value is adjusted
-// until the exponent is a multiple of 3 - i.e. 1.1e5 would return "110", 3.
-func (a infDecAmount) AsCanonicalBytes(out []byte) (result []byte, exponent int32) {
-	mantissa := a.Dec.UnscaledBig()
-	exponent = int32(-a.Dec.Scale())
-	amount := big.NewInt(0).Set(mantissa)
-	// move all factors of 10 into the exponent for easy reasoning
-	amount, times := removeBigIntFactors(amount, bigTen)
-	exponent += times
-
-	// make sure exponent is a multiple of 3
-	for exponent%3 != 0 {
-		amount.Mul(amount, bigTen)
-		exponent--
-	}
-
-	return append(out, amount.String()...), exponent
-}
-
-// AsCanonicalBase1024Bytes accepts a buffer to write the base-1024 string value of this field to, and returns
-// either that buffer or a larger buffer and the current exponent of the value. 2048 is 2 * 1024 ^ 1 and would
-// return []byte("2048"), 1.
-func (a infDecAmount) AsCanonicalBase1024Bytes(out []byte) (result []byte, exponent int32) {
-	tmp := &inf.Dec{}
-	tmp.Round(a.Dec, 0, inf.RoundUp)
-	amount, exponent := removeBigIntFactors(tmp.UnscaledBig(), big1024)
-	return append(out, amount.String()...), exponent
-}

1.5/pkg/api/resource/generated.pb.go

@@ -1,69 +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.
-*/
-
-// Code generated by protoc-gen-gogo.
-// source: k8s.io/kubernetes/pkg/api/resource/generated.proto
-// DO NOT EDIT!
-
-/*
-	Package resource is a generated protocol buffer package.
-
-	It is generated from these files:
-		k8s.io/kubernetes/pkg/api/resource/generated.proto
-
-	It has these top-level messages:
-		Quantity
-*/
-package resource
-
-import proto "github.com/gogo/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-const _ = proto.GoGoProtoPackageIsVersion1
-
-func (m *Quantity) Reset()                    { *m = Quantity{} }
-func (*Quantity) ProtoMessage()               {}
-func (*Quantity) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
-
-func init() {
-	proto.RegisterType((*Quantity)(nil), "k8s.io.client-go.1.5.pkg.api.resource.Quantity")
-}
-
-var fileDescriptorGenerated = []byte{
-	// 222 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x32, 0xca, 0xb6, 0x28, 0xd6,
-	0xcb, 0xcc, 0xd7, 0xcf, 0x2e, 0x4d, 0x4a, 0x2d, 0xca, 0x4b, 0x2d, 0x49, 0x2d, 0xd6, 0x2f, 0xc8,
-	0x4e, 0xd7, 0x4f, 0x2c, 0xc8, 0xd4, 0x2f, 0x4a, 0x2d, 0xce, 0x2f, 0x2d, 0x4a, 0x4e, 0xd5, 0x4f,
-	0x4f, 0xcd, 0x4b, 0x2d, 0x4a, 0x2c, 0x49, 0x4d, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52,
-	0x82, 0xe8, 0xd1, 0x43, 0xe8, 0xd1, 0x03, 0xea, 0xd1, 0x03, 0xea, 0xd1, 0x83, 0xe9, 0x91, 0xd2,
-	0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0x4f, 0xcf, 0xd7,
-	0x07, 0x6b, 0x4d, 0x2a, 0x4d, 0x03, 0xf3, 0xc0, 0x1c, 0x30, 0x0b, 0x62, 0xa4, 0x94, 0x21, 0x76,
-	0x67, 0x94, 0x96, 0x64, 0xe6, 0xe8, 0x67, 0xe6, 0x95, 0x14, 0x97, 0x14, 0xa1, 0xbb, 0x42, 0xc9,
-	0x82, 0x8b, 0x23, 0xb0, 0x34, 0x31, 0xaf, 0x24, 0xb3, 0xa4, 0x52, 0x48, 0x8c, 0x8b, 0x0d, 0xa8,
-	0x24, 0x33, 0x2f, 0x5d, 0x82, 0x51, 0x81, 0x51, 0x83, 0x33, 0x08, 0xca, 0xb3, 0x12, 0x99, 0xb1,
-	0x40, 0x9e, 0xa1, 0x63, 0xa1, 0x3c, 0xc3, 0x04, 0x20, 0x5e, 0x00, 0xc4, 0x0d, 0x77, 0x14, 0x18,
-	0x9c, 0xb4, 0x4e, 0x3c, 0x94, 0x63, 0xb8, 0x00, 0xc4, 0x37, 0x80, 0xb8, 0xe1, 0x91, 0x1c, 0xe3,
-	0x09, 0x20, 0xbe, 0x00, 0xc4, 0x0f, 0x80, 0x78, 0xc2, 0x63, 0x39, 0x86, 0x28, 0x0e, 0x98, 0x3f,
-	0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0x90, 0x1c, 0x7f, 0xff, 0x20, 0x01, 0x00, 0x00,
-}

1.5/pkg/api/resource/generated.proto

@@ -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.
-*/
-
-
-// This file was autogenerated by go-to-protobuf. Do not edit it manually!
-
-syntax = 'proto2';
-
-package k8s.io.kubernetes.pkg.api.resource;
-
-import "k8s.io/kubernetes/pkg/util/intstr/generated.proto";
-
-// Package-wide variables from generator "generated".
-option go_package = "resource";
-
-// Quantity is a fixed-point representation of a number.
-// It provides convenient marshaling/unmarshaling in JSON and YAML,
-// in addition to String() and Int64() accessors.
-// 
-// The serialization format is:
-// 
-// <quantity>        ::= <signedNumber><suffix>
-//   (Note that <suffix> may be empty, from the "" case in <decimalSI>.)
-// <digit>           ::= 0 | 1 | ... | 9
-// <digits>          ::= <digit> | <digit><digits>
-// <number>          ::= <digits> | <digits>.<digits> | <digits>. | .<digits>
-// <sign>            ::= "+" | "-"
-// <signedNumber>    ::= <number> | <sign><number>
-// <suffix>          ::= <binarySI> | <decimalExponent> | <decimalSI>
-// <binarySI>        ::= Ki | Mi | Gi | Ti | Pi | Ei
-//   (International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)
-// <decimalSI>       ::= m | "" | k | M | G | T | P | E
-//   (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)
-// <decimalExponent> ::= "e" <signedNumber> | "E" <signedNumber>
-// 
-// No matter which of the three exponent forms is used, no quantity may represent
-// a number greater than 2^63-1 in magnitude, nor may it have more than 3 decimal
-// places. Numbers larger or more precise will be capped or rounded up.
-// (E.g.: 0.1m will rounded up to 1m.)
-// This may be extended in the future if we require larger or smaller quantities.
-// 
-// When a Quantity is parsed from a string, it will remember the type of suffix
-// it had, and will use the same type again when it is serialized.
-// 
-// Before serializing, Quantity will be put in "canonical form".
-// This means that Exponent/suffix will be adjusted up or down (with a
-// corresponding increase or decrease in Mantissa) such that:
-//   a. No precision is lost
-//   b. No fractional digits will be emitted
-//   c. The exponent (or suffix) is as large as possible.
-// The sign will be omitted unless the number is negative.
-// 
-// Examples:
-//   1.5 will be serialized as "1500m"
-//   1.5Gi will be serialized as "1536Mi"
-// 
-// NOTE: We reserve the right to amend this canonical format, perhaps to
-//   allow 1.5 to be canonical.
-// TODO: Remove above disclaimer after all bikeshedding about format is over,
-//   or after March 2015.
-// 
-// Note that the quantity will NEVER be internally represented by a
-// floating point number. That is the whole point of this exercise.
-// 
-// Non-canonical values will still parse as long as they are well formed,
-// but will be re-emitted in their canonical form. (So always use canonical
-// form, or don't diff.)
-// 
-// This format is intended to make it difficult to use these numbers without
-// writing some sort of special handling code in the hopes that that will
-// cause implementors to also use a fixed point implementation.
-// 
-// +protobuf=true
-// +protobuf.embed=string
-// +protobuf.options.marshal=false
-// +protobuf.options.(gogoproto.goproto_stringer)=false
-// +k8s:openapi-gen=true
-message Quantity {
-  optional string string = 1;
-}
-