Merge pull request #22 from caesarxuchao/1.5

manually copy the fix the fake_pod_expansion.go

.travis.yml

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

1.5/Godeps/Godeps.json

@@ -1,7 +1,7 @@
 {
-	"ImportPath": "k8s.io/client-go",
-	"GoVersion": "go1.7",
-	"GodepVersion": "v79",
+	"ImportPath": "k8s.io/client-go/1.5",
+	"GoVersion": "go1.6",
+	"GodepVersion": "v74",
 	"Packages": [
 		"./..."
 	],
@@ -25,25 +25,30 @@
 			"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": "be73733bb8cc830d0205609b95d125215f8e9c70"
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-oidc/jose",
-			"Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-oidc/key",
-			"Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-oidc/oauth2",
-			"Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-oidc/oidc",
-			"Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
 		},
 		{
 			"ImportPath": "github.com/coreos/pkg/health",
@@ -76,18 +81,18 @@
 		},
 		{
 			"ImportPath": "github.com/emicklei/go-restful",
-			"Comment": "v1.2-96-g09691a3",
-			"Rev": "09691a3b6378b740595c1002f40c34dd5f218a22"
+			"Comment": "v1.2-79-g89ef8af",
+			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
 		},
 		{
 			"ImportPath": "github.com/emicklei/go-restful/log",
-			"Comment": "v1.2-96-g09691a3",
-			"Rev": "09691a3b6378b740595c1002f40c34dd5f218a22"
+			"Comment": "v1.2-79-g89ef8af",
+			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
 		},
 		{
 			"ImportPath": "github.com/emicklei/go-restful/swagger",
-			"Comment": "v1.2-96-g09691a3",
-			"Rev": "09691a3b6378b740595c1002f40c34dd5f218a22"
+			"Comment": "v1.2-79-g89ef8af",
+			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
 		},
 		{
 			"ImportPath": "github.com/ghodss/yaml",
@@ -133,7 +138,7 @@
 		},
 		{
 			"ImportPath": "github.com/google/gofuzz",
-			"Rev": "44d81051d367757e1c7c6a5a86423ece9afcf63c"
+			"Rev": "bbcb9da2d746f8bdbd6a936686a0a6067ada0ec5"
 		},
 		{
 			"ImportPath": "github.com/howeyc/gopass",
@@ -165,25 +170,20 @@
 			"Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
 		},
 		{
-			"ImportPath": "github.com/pmezard/go-difflib/difflib",
-			"Rev": "d8ed2627bdf02c080bf22230dbb337003b7aba2d"
+			"ImportPath": "github.com/pborman/uuid",
+			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
 		},
 		{
 			"ImportPath": "github.com/spf13/pflag",
-			"Rev": "9ff6c6923cfffbcd502984b8e0c80539a94968b7"
-		},
-		{
-			"ImportPath": "github.com/stretchr/testify/assert",
-			"Comment": "v1.0-88-ge3a8ff8",
-			"Rev": "e3a8ff8ce36581f87a15341206f205b1da467059"
+			"Rev": "1560c1005499d61b80f865c04d39ca7505bf7f0b"
 		},
 		{
 			"ImportPath": "github.com/ugorji/go/codec",
-			"Rev": "ded73eae5db7e7a0ef6f55aace87a2873c5d2b74"
+			"Rev": "f1f1a805ed361a0e078bb537e4ea78cd37dcf065"
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/ssh/terminal",
-			"Rev": "d172538b2cfce0c13cee31e647d0367aa8cd2486"
+			"Rev": "1f22c0103821b9390939b6776727195525381532"
 		},
 		{
 			"ImportPath": "golang.org/x/net/context",
@@ -231,7 +231,7 @@
 		},
 		{
 			"ImportPath": "golang.org/x/sys/unix",
-			"Rev": "8f0908ab3b2457e2e15403d3697c9ef5cb4b57a9"
+			"Rev": "9c60d1c508f5134d1ca726b4641db998f2523357"
 		},
 		{
 			"ImportPath": "golang.org/x/text/cases",
@@ -313,182 +313,6 @@
 		{
 			"ImportPath": "gopkg.in/yaml.v2",
 			"Rev": "53feefa2559fb8dfa8d81baad31be332c97d6c77"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/api/equality",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/api/errors",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/api/meta",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/api/resource",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery/announced",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery/registered",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/conversion",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/conversion/queryparams",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/fields",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/labels",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/openapi",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/runtime",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/runtime/schema",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/json",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/protobuf",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/recognizer",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/streaming",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/versioning",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/selection",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/types",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/diff",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/errors",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/framer",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/intstr",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/json",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/mergepatch",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/net",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/rand",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/runtime",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/sets",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/strategicpatch",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/validation",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/validation/field",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/wait",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/util/yaml",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/version",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/watch",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/json",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/reflect",
-			"Rev": "75b8dd260ef0469d96d578705a87cffd0e09dab8"
 		}
 	]
 }

1.5/LICENSE

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

1.5/discovery/discovery_client.go

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

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

@@ -0,0 +1,82 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fake
+
+import (
+	"github.com/emicklei/go-restful/swagger"
+	"k8s.io/client-go/1.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.go

@@ -20,46 +20,42 @@ import (
 	"fmt"
 	"sync"
 
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/api/meta"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-
-	"github.com/golang/glog"
+	"k8s.io/client-go/1.5/pkg/api/errors"
+	"k8s.io/client-go/1.5/pkg/api/meta"
+	"k8s.io/client-go/1.5/pkg/api/unversioned"
 )
 
 // APIGroupResources is an API group with a mapping of versions to
 // resources.
 type APIGroupResources struct {
-	Group metav1.APIGroup
+	Group unversioned.APIGroup
 	// A mapping of version string to a slice of APIResources for
 	// that version.
-	VersionedResources map[string][]metav1.APIResource
+	VersionedResources map[string][]unversioned.APIResource
 }
 
 // NewRESTMapper returns a PriorityRESTMapper based on the discovered
-// groups and resources passed in.
+// groups and resourced passed in.
 func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.VersionInterfacesFunc) meta.RESTMapper {
 	unionMapper := meta.MultiRESTMapper{}
 
 	var groupPriority []string
-	// /v1 is special.  It should always come first
-	resourcePriority := []schema.GroupVersionResource{{Group: "", Version: "v1", Resource: meta.AnyResource}}
-	kindPriority := []schema.GroupVersionKind{{Group: "", Version: "v1", Kind: meta.AnyKind}}
+	var resourcePriority []unversioned.GroupVersionResource
+	var kindPriority []unversioned.GroupVersionKind
 
 	for _, group := range groupResources {
 		groupPriority = append(groupPriority, group.Group.Name)
 
 		if len(group.Group.PreferredVersion.Version) != 0 {
-			preferred := group.Group.PreferredVersion.Version
-			if _, ok := group.VersionedResources[preferred]; ok {
-				resourcePriority = append(resourcePriority, schema.GroupVersionResource{
+			preffered := group.Group.PreferredVersion.Version
+			if _, ok := group.VersionedResources[preffered]; ok {
+				resourcePriority = append(resourcePriority, unversioned.GroupVersionResource{
 					Group:    group.Group.Name,
 					Version:  group.Group.PreferredVersion.Version,
 					Resource: meta.AnyResource,
 				})
 
-				kindPriority = append(kindPriority, schema.GroupVersionKind{
+				kindPriority = append(kindPriority, unversioned.GroupVersionKind{
 					Group:   group.Group.Name,
 					Version: group.Group.PreferredVersion.Version,
 					Kind:    meta.AnyKind,
@@ -73,8 +69,8 @@ func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.V
 				continue
 			}
 
-			gv := schema.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
-			versionMapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{gv}, versionInterfaces)
+			gv := unversioned.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
+			versionMapper := meta.NewDefaultRESTMapper([]unversioned.GroupVersion{gv}, versionInterfaces)
 
 			for _, resource := range resources {
 				scope := meta.RESTScopeNamespace
@@ -92,12 +88,12 @@ func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.V
 	}
 
 	for _, group := range groupPriority {
-		resourcePriority = append(resourcePriority, schema.GroupVersionResource{
+		resourcePriority = append(resourcePriority, unversioned.GroupVersionResource{
 			Group:    group,
 			Version:  meta.AnyVersion,
 			Resource: meta.AnyResource,
 		})
-		kindPriority = append(kindPriority, schema.GroupVersionKind{
+		kindPriority = append(kindPriority, unversioned.GroupVersionKind{
 			Group:   group,
 			Version: meta.AnyVersion,
 			Kind:    meta.AnyKind,
@@ -122,7 +118,7 @@ func GetAPIGroupResources(cl DiscoveryInterface) ([]*APIGroupResources, error) {
 	for _, group := range apiGroups.Groups {
 		groupResources := &APIGroupResources{
 			Group:              group,
-			VersionedResources: make(map[string][]metav1.APIResource),
+			VersionedResources: make(map[string][]unversioned.APIResource),
 		}
 		for _, version := range group.Versions {
 			resources, err := cl.ServerResourcesForGroupVersion(version.GroupVersion)
@@ -145,14 +141,14 @@ func GetAPIGroupResources(cl DiscoveryInterface) ([]*APIGroupResources, error) {
 type DeferredDiscoveryRESTMapper struct {
 	initMu           sync.Mutex
 	delegate         meta.RESTMapper
-	cl               CachedDiscoveryInterface
+	cl               DiscoveryInterface
 	versionInterface meta.VersionInterfacesFunc
 }
 
 // NewDeferredDiscoveryRESTMapper returns a
 // DeferredDiscoveryRESTMapper that will lazily query the provided
 // client for discovery information to do REST mappings.
-func NewDeferredDiscoveryRESTMapper(cl CachedDiscoveryInterface, versionInterface meta.VersionInterfacesFunc) *DeferredDiscoveryRESTMapper {
+func NewDeferredDiscoveryRESTMapper(cl DiscoveryInterface, versionInterface meta.VersionInterfacesFunc) *DeferredDiscoveryRESTMapper {
 	return &DeferredDiscoveryRESTMapper{
 		cl:               cl,
 		versionInterface: versionInterface,
@@ -179,118 +175,79 @@ func (d *DeferredDiscoveryRESTMapper) getDelegate() (meta.RESTMapper, error) {
 // Reset resets the internally cached Discovery information and will
 // cause the next mapping request to re-discover.
 func (d *DeferredDiscoveryRESTMapper) Reset() {
-	glog.V(5).Info("Invalidating discovery information")
-
 	d.initMu.Lock()
-	defer d.initMu.Unlock()
-
-	d.cl.Invalidate()
 	d.delegate = nil
+	d.initMu.Unlock()
 }
 
 // KindFor takes a partial resource and returns back the single match.
 // It returns an error if there are multiple matches.
-func (d *DeferredDiscoveryRESTMapper) KindFor(resource schema.GroupVersionResource) (gvk schema.GroupVersionKind, err error) {
+func (d *DeferredDiscoveryRESTMapper) KindFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionKind, error) {
 	del, err := d.getDelegate()
 	if err != nil {
-		return schema.GroupVersionKind{}, err
+		return unversioned.GroupVersionKind{}, err
 	}
-	gvk, err = del.KindFor(resource)
-	if err != nil && !d.cl.Fresh() {
-		d.Reset()
-		gvk, err = d.KindFor(resource)
-	}
-	return
+	return del.KindFor(resource)
 }
 
 // KindsFor takes a partial resource and returns back the list of
 // potential kinds in priority order.
-func (d *DeferredDiscoveryRESTMapper) KindsFor(resource schema.GroupVersionResource) (gvks []schema.GroupVersionKind, err error) {
+func (d *DeferredDiscoveryRESTMapper) KindsFor(resource unversioned.GroupVersionResource) ([]unversioned.GroupVersionKind, error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	gvks, err = del.KindsFor(resource)
-	if len(gvks) == 0 && !d.cl.Fresh() {
-		d.Reset()
-		gvks, err = d.KindsFor(resource)
-	}
-	return
+	return del.KindsFor(resource)
 }
 
 // ResourceFor takes a partial resource and returns back the single
 // match. It returns an error if there are multiple matches.
-func (d *DeferredDiscoveryRESTMapper) ResourceFor(input schema.GroupVersionResource) (gvr schema.GroupVersionResource, err error) {
+func (d *DeferredDiscoveryRESTMapper) ResourceFor(input unversioned.GroupVersionResource) (unversioned.GroupVersionResource, error) {
 	del, err := d.getDelegate()
 	if err != nil {
-		return schema.GroupVersionResource{}, err
+		return unversioned.GroupVersionResource{}, err
 	}
-	gvr, err = del.ResourceFor(input)
-	if err != nil && !d.cl.Fresh() {
-		d.Reset()
-		gvr, err = d.ResourceFor(input)
-	}
-	return
+	return del.ResourceFor(input)
 }
 
 // ResourcesFor takes a partial resource and returns back the list of
 // potential resource in priority order.
-func (d *DeferredDiscoveryRESTMapper) ResourcesFor(input schema.GroupVersionResource) (gvrs []schema.GroupVersionResource, err error) {
+func (d *DeferredDiscoveryRESTMapper) ResourcesFor(input unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	gvrs, err = del.ResourcesFor(input)
-	if len(gvrs) == 0 && !d.cl.Fresh() {
-		d.Reset()
-		gvrs, err = d.ResourcesFor(input)
-	}
-	return
+	return del.ResourcesFor(input)
 }
 
 // RESTMapping identifies a preferred resource mapping for the
 // provided group kind.
-func (d *DeferredDiscoveryRESTMapper) RESTMapping(gk schema.GroupKind, versions ...string) (m *meta.RESTMapping, err error) {
+func (d *DeferredDiscoveryRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (*meta.RESTMapping, error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	m, err = del.RESTMapping(gk, versions...)
-	if err != nil && !d.cl.Fresh() {
-		d.Reset()
-		m, err = d.RESTMapping(gk, versions...)
-	}
-	return
+	return del.RESTMapping(gk, versions...)
 }
 
 // RESTMappings returns the RESTMappings for the provided group kind
 // in a rough internal preferred order. If no kind is found, it will
 // return a NoResourceMatchError.
-func (d *DeferredDiscoveryRESTMapper) RESTMappings(gk schema.GroupKind, versions ...string) (ms []*meta.RESTMapping, err error) {
+func (d *DeferredDiscoveryRESTMapper) RESTMappings(gk unversioned.GroupKind) ([]*meta.RESTMapping, error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	ms, err = del.RESTMappings(gk, versions...)
-	if len(ms) == 0 && !d.cl.Fresh() {
-		d.Reset()
-		ms, err = d.RESTMappings(gk, versions...)
-	}
-	return
+	return del.RESTMappings(gk)
 }
 
 // AliasesForResource returns whether a resource has an alias or not.
-func (d *DeferredDiscoveryRESTMapper) AliasesForResource(resource string) (as []string, ok bool) {
+func (d *DeferredDiscoveryRESTMapper) AliasesForResource(resource string) ([]string, bool) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, false
 	}
-	as, ok = del.AliasesForResource(resource)
-	if len(as) == 0 && !d.cl.Fresh() {
-		d.Reset()
-		as, ok = d.AliasesForResource(resource)
-	}
-	return
+	return del.AliasesForResource(resource)
 }
 
 // ResourceSingularizer converts a resource name from plural to
@@ -300,12 +257,7 @@ func (d *DeferredDiscoveryRESTMapper) ResourceSingularizer(resource string) (sin
 	if err != nil {
 		return resource, err
 	}
-	singular, err = del.ResourceSingularizer(resource)
-	if err != nil && !d.cl.Fresh() {
-		d.Reset()
-		singular, err = d.ResourceSingularizer(resource)
-	}
-	return
+	return del.ResourceSingularizer(resource)
 }
 
 func (d *DeferredDiscoveryRESTMapper) String() string {

1.5/discovery/restmapper_test.go

@@ -0,0 +1,176 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package discovery
+
+import (
+	"reflect"
+	"testing"
+
+	"k8s.io/client-go/1.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/discovery/unstructured.go

@@ -19,20 +19,20 @@ package discovery
 import (
 	"fmt"
 
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/1.5/pkg/api/unversioned"
+	"k8s.io/client-go/1.5/pkg/runtime"
 )
 
 // UnstructuredObjectTyper provides a runtime.ObjectTyper implmentation for
 // runtime.Unstructured object based on discovery information.
 type UnstructuredObjectTyper struct {
-	registered map[schema.GroupVersionKind]bool
+	registered map[unversioned.GroupVersionKind]bool
 }
 
 // NewUnstructuredObjectTyper returns a runtime.ObjectTyper for
 // unstructred objects based on discovery information.
 func NewUnstructuredObjectTyper(groupResources []*APIGroupResources) *UnstructuredObjectTyper {
-	dot := &UnstructuredObjectTyper{registered: make(map[schema.GroupVersionKind]bool)}
+	dot := &UnstructuredObjectTyper{registered: make(map[unversioned.GroupVersionKind]bool)}
 	for _, group := range groupResources {
 		for _, discoveryVersion := range group.Group.Versions {
 			resources, ok := group.VersionedResources[discoveryVersion.Version]
@@ -40,7 +40,7 @@ func NewUnstructuredObjectTyper(groupResources []*APIGroupResources) *Unstructur
 				continue
 			}
 
-			gv := schema.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
+			gv := unversioned.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
 			for _, resource := range resources {
 				dot.registered[gv.WithKind(resource.Kind)] = true
 			}
@@ -50,39 +50,39 @@ func NewUnstructuredObjectTyper(groupResources []*APIGroupResources) *Unstructur
 }
 
 // ObjectKind returns the group,version,kind of the provided object, or an error
-// if the object in not runtime.Unstructured or has no group,version,kind
+// if the object in not *runtime.Unstructured or has no group,version,kind
 // information.
-func (d *UnstructuredObjectTyper) ObjectKind(obj runtime.Object) (schema.GroupVersionKind, error) {
-	if _, ok := obj.(runtime.Unstructured); !ok {
-		return schema.GroupVersionKind{}, fmt.Errorf("type %T is invalid for dynamic object typer", obj)
+func (d *UnstructuredObjectTyper) ObjectKind(obj runtime.Object) (unversioned.GroupVersionKind, error) {
+	if _, ok := obj.(*runtime.Unstructured); !ok {
+		return unversioned.GroupVersionKind{}, fmt.Errorf("type %T is invalid for dynamic object typer", obj)
 	}
 
 	return obj.GetObjectKind().GroupVersionKind(), nil
 }
 
 // ObjectKinds returns a slice of one element with the group,version,kind of the
-// provided object, or an error if the object is not runtime.Unstructured or
+// provided object, or an error if the object is not *runtime.Unstructured or
 // has no group,version,kind information. unversionedType will always be false
 // because runtime.Unstructured object should always have group,version,kind
 // information set.
-func (d *UnstructuredObjectTyper) ObjectKinds(obj runtime.Object) (gvks []schema.GroupVersionKind, unversionedType bool, err error) {
+func (d *UnstructuredObjectTyper) ObjectKinds(obj runtime.Object) (gvks []unversioned.GroupVersionKind, unversionedType bool, err error) {
 	gvk, err := d.ObjectKind(obj)
 	if err != nil {
 		return nil, false, err
 	}
 
-	return []schema.GroupVersionKind{gvk}, false, nil
+	return []unversioned.GroupVersionKind{gvk}, false, nil
 }
 
 // Recognizes returns true if the provided group,version,kind was in the
 // discovery information.
-func (d *UnstructuredObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool {
+func (d *UnstructuredObjectTyper) Recognizes(gvk unversioned.GroupVersionKind) bool {
 	return d.registered[gvk]
 }
 
-// IsUnversioned returns false always because runtime.Unstructured objects
+// IsUnversioned returns false always because *runtime.Unstructured objects
 // should always have group,version,kind information set. ok will be true if the
-// object's group,version,kind is api.Registry.
+// object's group,version,kind is registered.
 func (d *UnstructuredObjectTyper) IsUnversioned(obj runtime.Object) (unversioned bool, ok bool) {
 	gvk, err := d.ObjectKind(obj)
 	if err != nil {

1.5/dynamic/client.go

@@ -26,30 +26,27 @@ import (
 	"net/url"
 	"strings"
 
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/conversion/queryparams"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/runtime/serializer"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/watch"
-	"k8s.io/client-go/pkg/api"
-	"k8s.io/client-go/pkg/api/v1"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/util/flowcontrol"
+	"k8s.io/client-go/1.5/pkg/api"
+	"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/conversion/queryparams"
+	"k8s.io/client-go/1.5/pkg/runtime"
+	"k8s.io/client-go/1.5/pkg/runtime/serializer"
+	"k8s.io/client-go/1.5/pkg/util/flowcontrol"
+	"k8s.io/client-go/1.5/pkg/watch"
+	"k8s.io/client-go/1.5/rest"
 )
 
 // Client is a Kubernetes client that allows you to access metadata
 // and manipulate metadata of a Kubernetes API group.
 type Client struct {
-	cl             *restclient.RESTClient
+	cl             *rest.RESTClient
 	parameterCodec runtime.ParameterCodec
 }
 
 // NewClient returns a new client based on the passed in config. The
 // codec is ignored, as the dynamic client uses it's own codec.
-func NewClient(conf *restclient.Config) (*Client, error) {
+func NewClient(conf *rest.Config) (*Client, error) {
 	// avoid changing the original config
 	confCopy := *conf
 	conf = &confCopy
@@ -66,10 +63,10 @@ func NewClient(conf *restclient.Config) (*Client, error) {
 	}
 
 	if len(conf.UserAgent) == 0 {
-		conf.UserAgent = restclient.DefaultKubernetesUserAgent()
+		conf.UserAgent = rest.DefaultKubernetesUserAgent()
 	}
 
-	cl, err := restclient.RESTClientFor(conf)
+	cl, err := rest.RESTClientFor(conf)
 	if err != nil {
 		return nil, err
 	}
@@ -85,7 +82,7 @@ func (c *Client) GetRateLimiter() flowcontrol.RateLimiter {
 // Resource returns an API interface to the specified resource for this client's
 // group and version. If resource is not a namespaced resource, then namespace
 // is ignored. The ResourceClient inherits the parameter codec of c.
-func (c *Client) Resource(resource *metav1.APIResource, namespace string) *ResourceClient {
+func (c *Client) Resource(resource *unversioned.APIResource, namespace string) *ResourceClient {
 	return &ResourceClient{
 		cl:             c.cl,
 		resource:       resource,
@@ -105,14 +102,14 @@ func (c *Client) ParameterCodec(parameterCodec runtime.ParameterCodec) *Client {
 // ResourceClient is an API interface to a specific resource under a
 // dynamic client.
 type ResourceClient struct {
-	cl             *restclient.RESTClient
-	resource       *metav1.APIResource
+	cl             *rest.RESTClient
+	resource       *unversioned.APIResource
 	ns             string
 	parameterCodec runtime.ParameterCodec
 }
 
 // List returns a list of objects for this resource.
-func (rc *ResourceClient) List(opts metav1.ListOptions) (runtime.Object, error) {
+func (rc *ResourceClient) List(opts runtime.Object) (runtime.Object, error) {
 	parameterEncoder := rc.parameterCodec
 	if parameterEncoder == nil {
 		parameterEncoder = defaultParameterEncoder
@@ -120,14 +117,14 @@ func (rc *ResourceClient) List(opts metav1.ListOptions) (runtime.Object, error)
 	return rc.cl.Get().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
-		VersionedParams(&opts, parameterEncoder).
+		VersionedParams(opts, parameterEncoder).
 		Do().
 		Get()
 }
 
 // Get gets the resource with the specified name.
-func (rc *ResourceClient) Get(name string) (*unstructured.Unstructured, error) {
-	result := new(unstructured.Unstructured)
+func (rc *ResourceClient) Get(name string) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
 	err := rc.cl.Get().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
@@ -138,7 +135,7 @@ func (rc *ResourceClient) Get(name string) (*unstructured.Unstructured, error) {
 }
 
 // Delete deletes the resource with the specified name.
-func (rc *ResourceClient) Delete(name string, opts *metav1.DeleteOptions) error {
+func (rc *ResourceClient) Delete(name string, opts *v1.DeleteOptions) error {
 	return rc.cl.Delete().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
@@ -149,7 +146,7 @@ func (rc *ResourceClient) Delete(name string, opts *metav1.DeleteOptions) error
 }
 
 // DeleteCollection deletes a collection of objects.
-func (rc *ResourceClient) DeleteCollection(deleteOptions *metav1.DeleteOptions, listOptions metav1.ListOptions) error {
+func (rc *ResourceClient) DeleteCollection(deleteOptions *v1.DeleteOptions, listOptions runtime.Object) error {
 	parameterEncoder := rc.parameterCodec
 	if parameterEncoder == nil {
 		parameterEncoder = defaultParameterEncoder
@@ -157,15 +154,15 @@ func (rc *ResourceClient) DeleteCollection(deleteOptions *metav1.DeleteOptions,
 	return rc.cl.Delete().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
-		VersionedParams(&listOptions, parameterEncoder).
+		VersionedParams(listOptions, parameterEncoder).
 		Body(deleteOptions).
 		Do().
 		Error()
 }
 
 // Create creates the provided resource.
-func (rc *ResourceClient) Create(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	result := new(unstructured.Unstructured)
+func (rc *ResourceClient) Create(obj *runtime.Unstructured) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
 	err := rc.cl.Post().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
@@ -176,8 +173,8 @@ func (rc *ResourceClient) Create(obj *unstructured.Unstructured) (*unstructured.
 }
 
 // Update updates the provided resource.
-func (rc *ResourceClient) Update(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	result := new(unstructured.Unstructured)
+func (rc *ResourceClient) Update(obj *runtime.Unstructured) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
 	if len(obj.GetName()) == 0 {
 		return result, errors.New("object missing name")
 	}
@@ -192,21 +189,21 @@ func (rc *ResourceClient) Update(obj *unstructured.Unstructured) (*unstructured.
 }
 
 // Watch returns a watch.Interface that watches the resource.
-func (rc *ResourceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+func (rc *ResourceClient) Watch(opts runtime.Object) (watch.Interface, error) {
 	parameterEncoder := rc.parameterCodec
 	if parameterEncoder == nil {
 		parameterEncoder = defaultParameterEncoder
 	}
-	opts.Watch = true
 	return rc.cl.Get().
+		Prefix("watch").
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
-		VersionedParams(&opts, parameterEncoder).
+		VersionedParams(opts, parameterEncoder).
 		Watch()
 }
 
-func (rc *ResourceClient) Patch(name string, pt types.PatchType, data []byte) (*unstructured.Unstructured, error) {
-	result := new(unstructured.Unstructured)
+func (rc *ResourceClient) Patch(name string, pt api.PatchType, data []byte) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
 	err := rc.cl.Patch(pt).
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
@@ -221,14 +218,14 @@ func (rc *ResourceClient) Patch(name string, pt types.PatchType, data []byte) (*
 // with special handling for Status objects.
 type dynamicCodec struct{}
 
-func (dynamicCodec) Decode(data []byte, gvk *schema.GroupVersionKind, obj runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
-	obj, gvk, err := unstructured.UnstructuredJSONScheme.Decode(data, gvk, obj)
+func (dynamicCodec) Decode(data []byte, gvk *unversioned.GroupVersionKind, obj runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error) {
+	obj, gvk, err := runtime.UnstructuredJSONScheme.Decode(data, gvk, obj)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	if _, ok := obj.(*metav1.Status); !ok && strings.ToLower(gvk.Kind) == "status" {
-		obj = &metav1.Status{}
+	if _, ok := obj.(*unversioned.Status); !ok && strings.ToLower(gvk.Kind) == "status" {
+		obj = &unversioned.Status{}
 		err := json.Unmarshal(data, obj)
 		if err != nil {
 			return nil, nil, err
@@ -239,27 +236,18 @@ func (dynamicCodec) Decode(data []byte, gvk *schema.GroupVersionKind, obj runtim
 }
 
 func (dynamicCodec) Encode(obj runtime.Object, w io.Writer) error {
-	return unstructured.UnstructuredJSONScheme.Encode(obj, w)
+	return runtime.UnstructuredJSONScheme.Encode(obj, w)
 }
 
-// ContentConfig returns a restclient.ContentConfig for dynamic types.
-func ContentConfig() restclient.ContentConfig {
-	var jsonInfo runtime.SerializerInfo
-	// TODO: api.Codecs here should become "pkg/apis/server/scheme" which is the minimal core you need
-	// to talk to a kubernetes server
-	for _, info := range api.Codecs.SupportedMediaTypes() {
-		if info.MediaType == runtime.ContentTypeJSON {
-			jsonInfo = info
-			break
-		}
-	}
-
-	jsonInfo.Serializer = dynamicCodec{}
-	jsonInfo.PrettySerializer = nil
-	return restclient.ContentConfig{
+// ContentConfig returns a rest.ContentConfig for dynamic types.
+func ContentConfig() rest.ContentConfig {
+	// TODO: it's questionable that this should be using anything other than unstructured schema and JSON
+	codec := dynamicCodec{}
+	streamingInfo, _ := api.Codecs.StreamingSerializerForMediaType("application/json;stream=watch", nil)
+	return rest.ContentConfig{
 		AcceptContentTypes:   runtime.ContentTypeJSON,
 		ContentType:          runtime.ContentTypeJSON,
-		NegotiatedSerializer: serializer.NegotiatedSerializerWrapper(jsonInfo),
+		NegotiatedSerializer: serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: codec}, streamingInfo),
 	}
 }
 
@@ -267,11 +255,11 @@ func ContentConfig() restclient.ContentConfig {
 // parameters without trying to convert to the target version.
 type parameterCodec struct{}
 
-func (parameterCodec) EncodeParameters(obj runtime.Object, to schema.GroupVersion) (url.Values, error) {
+func (parameterCodec) EncodeParameters(obj runtime.Object, to unversioned.GroupVersion) (url.Values, error) {
 	return queryparams.Convert(obj)
 }
 
-func (parameterCodec) DecodeParameters(parameters url.Values, from schema.GroupVersion, into runtime.Object) error {
+func (parameterCodec) DecodeParameters(parameters url.Values, from unversioned.GroupVersion, into runtime.Object) error {
 	return errors.New("DecodeParameters not implemented on dynamic parameterCodec")
 }
 
@@ -279,7 +267,7 @@ var defaultParameterEncoder runtime.ParameterCodec = parameterCodec{}
 
 type versionedParameterEncoderWithV1Fallback struct{}
 
-func (versionedParameterEncoderWithV1Fallback) EncodeParameters(obj runtime.Object, to schema.GroupVersion) (url.Values, error) {
+func (versionedParameterEncoderWithV1Fallback) EncodeParameters(obj runtime.Object, to unversioned.GroupVersion) (url.Values, error) {
 	ret, err := api.ParameterCodec.EncodeParameters(obj, to)
 	if err != nil && runtime.IsNotRegisteredError(err) {
 		// fallback to v1
@@ -288,7 +276,7 @@ func (versionedParameterEncoderWithV1Fallback) EncodeParameters(obj runtime.Obje
 	return ret, err
 }
 
-func (versionedParameterEncoderWithV1Fallback) DecodeParameters(parameters url.Values, from schema.GroupVersion, into runtime.Object) error {
+func (versionedParameterEncoderWithV1Fallback) DecodeParameters(parameters url.Values, from unversioned.GroupVersion, into runtime.Object) error {
 	return errors.New("DecodeParameters not implemented on versionedParameterEncoderWithV1Fallback")
 }
 

1.5/dynamic/client_pool.go

@@ -19,28 +19,30 @@ package dynamic
 import (
 	"sync"
 
-	"k8s.io/apimachinery/pkg/api/meta"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/pkg/api"
-	restclient "k8s.io/client-go/rest"
+	"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/runtime"
+	"k8s.io/client-go/1.5/pkg/runtime/serializer"
+	"k8s.io/client-go/1.5/rest"
 )
 
 // ClientPool manages a pool of dynamic clients.
 type ClientPool interface {
 	// ClientForGroupVersionKind returns a client configured for the specified groupVersionResource.
 	// Resource may be empty.
-	ClientForGroupVersionResource(resource schema.GroupVersionResource) (*Client, error)
+	ClientForGroupVersionResource(resource unversioned.GroupVersionResource) (*Client, error)
 	// ClientForGroupVersionKind returns a client configured for the specified groupVersionKind.
 	// Kind may be empty.
-	ClientForGroupVersionKind(kind schema.GroupVersionKind) (*Client, error)
+	ClientForGroupVersionKind(kind unversioned.GroupVersionKind) (*Client, error)
 }
 
 // APIPathResolverFunc knows how to convert a groupVersion to its API path. The Kind field is
 // optional.
-type APIPathResolverFunc func(kind schema.GroupVersionKind) string
+type APIPathResolverFunc func(kind unversioned.GroupVersionKind) string
 
 // LegacyAPIPathResolverFunc can resolve paths properly with the legacy API.
-func LegacyAPIPathResolverFunc(kind schema.GroupVersionKind) string {
+func LegacyAPIPathResolverFunc(kind unversioned.GroupVersionKind) string {
 	if len(kind.Group) == 0 {
 		return "/api"
 	}
@@ -51,8 +53,8 @@ func LegacyAPIPathResolverFunc(kind schema.GroupVersionKind) string {
 // is asked to retrieve. This type is thread safe.
 type clientPoolImpl struct {
 	lock                sync.RWMutex
-	config              *restclient.Config
-	clients             map[schema.GroupVersion]*Client
+	config              *rest.Config
+	clients             map[unversioned.GroupVersion]*Client
 	apiPathResolverFunc APIPathResolverFunc
 	mapper              meta.RESTMapper
 }
@@ -60,31 +62,23 @@ type clientPoolImpl struct {
 // NewClientPool returns a ClientPool from the specified config. It reuses clients for the the same
 // group version. It is expected this type may be wrapped by specific logic that special cases certain
 // resources or groups.
-func NewClientPool(config *restclient.Config, mapper meta.RESTMapper, apiPathResolverFunc APIPathResolverFunc) ClientPool {
+func NewClientPool(config *rest.Config, mapper meta.RESTMapper, apiPathResolverFunc APIPathResolverFunc) ClientPool {
 	confCopy := *config
-
 	return &clientPoolImpl{
 		config:              &confCopy,
-		clients:             map[schema.GroupVersion]*Client{},
+		clients:             map[unversioned.GroupVersion]*Client{},
 		apiPathResolverFunc: apiPathResolverFunc,
 		mapper:              mapper,
 	}
 }
 
-// Instantiates a new dynamic client pool with the given config.
-func NewDynamicClientPool(cfg *restclient.Config) ClientPool {
-	// TODO: should use a dynamic RESTMapper built from the discovery results.
-	restMapper := api.Registry.RESTMapper()
-	return NewClientPool(cfg, restMapper, LegacyAPIPathResolverFunc)
-}
-
 // ClientForGroupVersionResource uses the provided RESTMapper to identify the appropriate resource. Resource may
 // be empty. If no matching kind is found the underlying client for that group is still returned.
-func (c *clientPoolImpl) ClientForGroupVersionResource(resource schema.GroupVersionResource) (*Client, error) {
+func (c *clientPoolImpl) ClientForGroupVersionResource(resource unversioned.GroupVersionResource) (*Client, error) {
 	kinds, err := c.mapper.KindsFor(resource)
 	if err != nil {
 		if meta.IsNoMatchError(err) {
-			return c.ClientForGroupVersionKind(schema.GroupVersionKind{Group: resource.Group, Version: resource.Version})
+			return c.ClientForGroupVersionKind(unversioned.GroupVersionKind{Group: resource.Group, Version: resource.Version})
 		}
 		return nil, err
 	}
@@ -93,7 +87,7 @@ func (c *clientPoolImpl) ClientForGroupVersionResource(resource schema.GroupVers
 
 // ClientForGroupVersion returns a client for the specified groupVersion, creates one if none exists. Kind
 // in the GroupVersionKind may be empty.
-func (c *clientPoolImpl) ClientForGroupVersionKind(kind schema.GroupVersionKind) (*Client, error) {
+func (c *clientPoolImpl) ClientForGroupVersionKind(kind unversioned.GroupVersionKind) (*Client, error) {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
@@ -114,6 +108,11 @@ func (c *clientPoolImpl) ClientForGroupVersionKind(kind schema.GroupVersionKind)
 	// we need to make a client
 	conf.GroupVersion = &gv
 
+	if conf.NegotiatedSerializer == nil {
+		streamingInfo, _ := api.Codecs.StreamingSerializerForMediaType("application/json;stream=watch", nil)
+		conf.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: dynamicCodec{}}, streamingInfo)
+	}
+
 	dynamicClient, err := NewClient(conf)
 	if err != nil {
 		return nil, err

1.5/dynamic/client_test.go

@@ -25,15 +25,14 @@ import (
 	"reflect"
 	"testing"
 
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/runtime/serializer/streaming"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/watch"
-	restclient "k8s.io/client-go/rest"
-	restclientwatch "k8s.io/client-go/rest/watch"
+	"k8s.io/client-go/1.5/pkg/api"
+	"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/streaming"
+	"k8s.io/client-go/1.5/pkg/watch"
+	"k8s.io/client-go/1.5/pkg/watch/versioned"
+	"k8s.io/client-go/1.5/rest"
 )
 
 func getJSON(version, kind, name string) []byte {
@@ -46,8 +45,8 @@ func getListJSON(version, kind string, items ...[]byte) []byte {
 	return []byte(json)
 }
 
-func getObject(version, kind, name string) *unstructured.Unstructured {
-	return &unstructured.Unstructured{
+func getObject(version, kind, name string) *runtime.Unstructured {
+	return &runtime.Unstructured{
 		Object: map[string]interface{}{
 			"apiVersion": version,
 			"kind":       kind,
@@ -58,11 +57,11 @@ func getObject(version, kind, name string) *unstructured.Unstructured {
 	}
 }
 
-func getClientServer(gv *schema.GroupVersion, h func(http.ResponseWriter, *http.Request)) (*Client, *httptest.Server, error) {
+func getClientServer(gv *unversioned.GroupVersion, h func(http.ResponseWriter, *http.Request)) (*Client, *httptest.Server, error) {
 	srv := httptest.NewServer(http.HandlerFunc(h))
-	cl, err := NewClient(&restclient.Config{
+	cl, err := NewClient(&rest.Config{
 		Host:          srv.URL,
-		ContentConfig: restclient.ContentConfig{GroupVersion: gv},
+		ContentConfig: rest.ContentConfig{GroupVersion: gv},
 	})
 	if err != nil {
 		srv.Close()
@@ -77,7 +76,7 @@ func TestList(t *testing.T) {
 		namespace string
 		path      string
 		resp      []byte
-		want      *unstructured.UnstructuredList
+		want      *runtime.UnstructuredList
 	}{
 		{
 			name: "normal_list",
@@ -85,12 +84,12 @@ func TestList(t *testing.T) {
 			resp: getListJSON("vTest", "rTestList",
 				getJSON("vTest", "rTest", "item1"),
 				getJSON("vTest", "rTest", "item2")),
-			want: &unstructured.UnstructuredList{
+			want: &runtime.UnstructuredList{
 				Object: map[string]interface{}{
 					"apiVersion": "vTest",
 					"kind":       "rTestList",
 				},
-				Items: []*unstructured.Unstructured{
+				Items: []*runtime.Unstructured{
 					getObject("vTest", "rTest", "item1"),
 					getObject("vTest", "rTest", "item2"),
 				},
@@ -103,12 +102,12 @@ func TestList(t *testing.T) {
 			resp: getListJSON("vTest", "rTestList",
 				getJSON("vTest", "rTest", "item1"),
 				getJSON("vTest", "rTest", "item2")),
-			want: &unstructured.UnstructuredList{
+			want: &runtime.UnstructuredList{
 				Object: map[string]interface{}{
 					"apiVersion": "vTest",
 					"kind":       "rTestList",
 				},
-				Items: []*unstructured.Unstructured{
+				Items: []*runtime.Unstructured{
 					getObject("vTest", "rTest", "item1"),
 					getObject("vTest", "rTest", "item2"),
 				},
@@ -116,8 +115,8 @@ func TestList(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("List(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
@@ -136,7 +135,7 @@ func TestList(t *testing.T) {
 		}
 		defer srv.Close()
 
-		got, err := cl.Resource(resource, tc.namespace).List(metav1.ListOptions{})
+		got, err := cl.Resource(resource, tc.namespace).List(&v1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when listing %q: %v", tc.name, err)
 			continue
@@ -154,7 +153,7 @@ func TestGet(t *testing.T) {
 		name      string
 		path      string
 		resp      []byte
-		want      *unstructured.Unstructured
+		want      *runtime.Unstructured
 	}{
 		{
 			name: "normal_get",
@@ -171,8 +170,8 @@ func TestGet(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("Get(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
@@ -204,9 +203,9 @@ func TestGet(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	statusOK := &metav1.Status{
-		TypeMeta: metav1.TypeMeta{Kind: "Status"},
-		Status:   metav1.StatusSuccess,
+	statusOK := &unversioned.Status{
+		TypeMeta: unversioned.TypeMeta{Kind: "Status"},
+		Status:   unversioned.StatusSuccess,
 	}
 	tcs := []struct {
 		namespace string
@@ -224,8 +223,8 @@ func TestDelete(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "DELETE" {
 				t.Errorf("Delete(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
@@ -236,7 +235,7 @@ func TestDelete(t *testing.T) {
 			}
 
 			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
-			unstructured.UnstructuredJSONScheme.Encode(statusOK, w)
+			runtime.UnstructuredJSONScheme.Encode(statusOK, w)
 		})
 		if err != nil {
 			t.Errorf("unexpected error when creating client: %v", err)
@@ -253,9 +252,9 @@ func TestDelete(t *testing.T) {
 }
 
 func TestDeleteCollection(t *testing.T) {
-	statusOK := &metav1.Status{
-		TypeMeta: metav1.TypeMeta{Kind: "Status"},
-		Status:   metav1.StatusSuccess,
+	statusOK := &unversioned.Status{
+		TypeMeta: unversioned.TypeMeta{Kind: "Status"},
+		Status:   unversioned.StatusSuccess,
 	}
 	tcs := []struct {
 		namespace string
@@ -273,8 +272,8 @@ func TestDeleteCollection(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "DELETE" {
 				t.Errorf("DeleteCollection(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
@@ -285,7 +284,7 @@ func TestDeleteCollection(t *testing.T) {
 			}
 
 			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
-			unstructured.UnstructuredJSONScheme.Encode(statusOK, w)
+			runtime.UnstructuredJSONScheme.Encode(statusOK, w)
 		})
 		if err != nil {
 			t.Errorf("unexpected error when creating client: %v", err)
@@ -293,7 +292,7 @@ func TestDeleteCollection(t *testing.T) {
 		}
 		defer srv.Close()
 
-		err = cl.Resource(resource, tc.namespace).DeleteCollection(nil, metav1.ListOptions{})
+		err = cl.Resource(resource, tc.namespace).DeleteCollection(nil, &v1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when deleting collection %q: %v", tc.name, err)
 			continue
@@ -305,7 +304,7 @@ func TestCreate(t *testing.T) {
 	tcs := []struct {
 		name      string
 		namespace string
-		obj       *unstructured.Unstructured
+		obj       *runtime.Unstructured
 		path      string
 	}{
 		{
@@ -321,8 +320,8 @@ func TestCreate(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "POST" {
 				t.Errorf("Create(%q) got HTTP method %s. wanted POST", tc.name, r.Method)
@@ -364,7 +363,7 @@ func TestUpdate(t *testing.T) {
 	tcs := []struct {
 		name      string
 		namespace string
-		obj       *unstructured.Unstructured
+		obj       *runtime.Unstructured
 		path      string
 	}{
 		{
@@ -380,8 +379,8 @@ func TestUpdate(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "PUT" {
 				t.Errorf("Update(%q) got HTTP method %s. wanted PUT", tc.name, r.Method)
@@ -425,12 +424,10 @@ func TestWatch(t *testing.T) {
 		namespace string
 		events    []watch.Event
 		path      string
-		query     string
 	}{
 		{
-			name:  "normal_watch",
-			path:  "/api/gtest/vtest/rtest",
-			query: "watch=true",
+			name: "normal_watch",
+			path: "/api/gtest/vtest/watch/rtest",
 			events: []watch.Event{
 				{Type: watch.Added, Object: getObject("vTest", "rTest", "normal_watch")},
 				{Type: watch.Modified, Object: getObject("vTest", "rTest", "normal_watch")},
@@ -440,8 +437,7 @@ func TestWatch(t *testing.T) {
 		{
 			name:      "namespaced_watch",
 			namespace: "nstest",
-			path:      "/api/gtest/vtest/namespaces/nstest/rtest",
-			query:     "watch=true",
+			path:      "/api/gtest/vtest/watch/namespaces/nstest/rtest",
 			events: []watch.Event{
 				{Type: watch.Added, Object: getObject("vTest", "rTest", "namespaced_watch")},
 				{Type: watch.Modified, Object: getObject("vTest", "rTest", "namespaced_watch")},
@@ -450,8 +446,8 @@ func TestWatch(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("Watch(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
@@ -460,11 +456,8 @@ func TestWatch(t *testing.T) {
 			if r.URL.Path != tc.path {
 				t.Errorf("Watch(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
 			}
-			if r.URL.RawQuery != tc.query {
-				t.Errorf("Watch(%q) got query %s. wanted %s", tc.name, r.URL.RawQuery, tc.query)
-			}
 
-			enc := restclientwatch.NewEncoder(streaming.NewEncoder(w, dynamicCodec{}), dynamicCodec{})
+			enc := versioned.NewEncoder(streaming.NewEncoder(w, dynamicCodec{}), dynamicCodec{})
 			for _, e := range tc.events {
 				enc.Encode(&e)
 			}
@@ -475,7 +468,7 @@ func TestWatch(t *testing.T) {
 		}
 		defer srv.Close()
 
-		watcher, err := cl.Resource(resource, tc.namespace).Watch(metav1.ListOptions{})
+		watcher, err := cl.Resource(resource, tc.namespace).Watch(&v1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when watching %q: %v", tc.name, err)
 			continue
@@ -495,7 +488,7 @@ func TestPatch(t *testing.T) {
 		name      string
 		namespace string
 		patch     []byte
-		want      *unstructured.Unstructured
+		want      *runtime.Unstructured
 		path      string
 	}{
 		{
@@ -513,8 +506,8 @@ func TestPatch(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "PATCH" {
 				t.Errorf("Patch(%q) got HTTP method %s. wanted PATCH", tc.name, r.Method)
@@ -525,8 +518,8 @@ func TestPatch(t *testing.T) {
 			}
 
 			content := r.Header.Get("Content-Type")
-			if content != string(types.StrategicMergePatchType) {
-				t.Errorf("Patch(%q) got Content-Type %s. wanted %s", tc.name, content, types.StrategicMergePatchType)
+			if content != string(api.StrategicMergePatchType) {
+				t.Errorf("Patch(%q) got Content-Type %s. wanted %s", tc.name, content, api.StrategicMergePatchType)
 			}
 
 			data, err := ioutil.ReadAll(r.Body)
@@ -536,7 +529,6 @@ func TestPatch(t *testing.T) {
 				return
 			}
 
-			w.Header().Set("Content-Type", "application/json")
 			w.Write(data)
 		})
 		if err != nil {
@@ -545,7 +537,7 @@ func TestPatch(t *testing.T) {
 		}
 		defer srv.Close()
 
-		got, err := cl.Resource(resource, tc.namespace).Patch(tc.name, types.StrategicMergePatchType, tc.patch)
+		got, err := cl.Resource(resource, tc.namespace).Patch(tc.name, api.StrategicMergePatchType, tc.patch)
 		if err != nil {
 			t.Errorf("unexpected error when patching %q: %v", tc.name, err)
 			continue

1.5/dynamic/dynamic_util.go

@@ -19,27 +19,25 @@ package dynamic
 import (
 	"fmt"
 
-	"k8s.io/apimachinery/pkg/api/meta"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
+	"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"
 )
 
 // VersionInterfaces provides an object converter and metadata
 // accessor appropriate for use with unstructured objects.
-func VersionInterfaces(schema.GroupVersion) (*meta.VersionInterfaces, error) {
+func VersionInterfaces(unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
 	return &meta.VersionInterfaces{
-		ObjectConvertor:  &unstructured.UnstructuredObjectConverter{},
+		ObjectConvertor:  &runtime.UnstructuredObjectConverter{},
 		MetadataAccessor: meta.NewAccessor(),
 	}, nil
 }
 
 // NewDiscoveryRESTMapper returns a RESTMapper based on discovery information.
-func NewDiscoveryRESTMapper(resources []*metav1.APIResourceList, versionFunc meta.VersionInterfacesFunc) (*meta.DefaultRESTMapper, error) {
+func NewDiscoveryRESTMapper(resources []*unversioned.APIResourceList, versionFunc meta.VersionInterfacesFunc) (*meta.DefaultRESTMapper, error) {
 	rm := meta.NewDefaultRESTMapper(nil, versionFunc)
 	for _, resourceList := range resources {
-		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
+		gv, err := unversioned.ParseGroupVersion(resourceList.GroupVersion)
 		if err != nil {
 			return nil, err
 		}
@@ -57,16 +55,16 @@ func NewDiscoveryRESTMapper(resources []*metav1.APIResourceList, versionFunc met
 }
 
 // ObjectTyper provides an ObjectTyper implementation for
-// unstructured.Unstructured object based on discovery information.
+// runtime.Unstructured object based on discovery information.
 type ObjectTyper struct {
-	registered map[schema.GroupVersionKind]bool
+	registered map[unversioned.GroupVersionKind]bool
 }
 
 // NewObjectTyper constructs an ObjectTyper from discovery information.
-func NewObjectTyper(resources []*metav1.APIResourceList) (runtime.ObjectTyper, error) {
-	ot := &ObjectTyper{registered: make(map[schema.GroupVersionKind]bool)}
+func NewObjectTyper(resources []*unversioned.APIResourceList) (runtime.ObjectTyper, error) {
+	ot := &ObjectTyper{registered: make(map[unversioned.GroupVersionKind]bool)}
 	for _, resourceList := range resources {
-		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
+		gv, err := unversioned.ParseGroupVersion(resourceList.GroupVersion)
 		if err != nil {
 			return nil, err
 		}
@@ -80,17 +78,17 @@ func NewObjectTyper(resources []*metav1.APIResourceList) (runtime.ObjectTyper, e
 
 // ObjectKinds returns a slice of one element with the
 // group,version,kind of the provided object, or an error if the
-// object is not *unstructured.Unstructured or has no group,version,kind
+// object is not *runtime.Unstructured or has no group,version,kind
 // information.
-func (ot *ObjectTyper) ObjectKinds(obj runtime.Object) ([]schema.GroupVersionKind, bool, error) {
-	if _, ok := obj.(*unstructured.Unstructured); !ok {
+func (ot *ObjectTyper) ObjectKinds(obj runtime.Object) ([]unversioned.GroupVersionKind, bool, error) {
+	if _, ok := obj.(*runtime.Unstructured); !ok {
 		return nil, false, fmt.Errorf("type %T is invalid for dynamic object typer", obj)
 	}
-	return []schema.GroupVersionKind{obj.GetObjectKind().GroupVersionKind()}, false, nil
+	return []unversioned.GroupVersionKind{obj.GetObjectKind().GroupVersionKind()}, false, nil
 }
 
 // Recognizes returns true if the provided group,version,kind was in
 // the discovery information.
-func (ot *ObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool {
+func (ot *ObjectTyper) Recognizes(gvk unversioned.GroupVersionKind) bool {
 	return ot.registered[gvk]
 }

1.5/dynamic/dynamic_util_test.go

@@ -19,15 +19,14 @@ package dynamic
 import (
 	"testing"
 
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/1.5/pkg/api/unversioned"
 )
 
 func TestDiscoveryRESTMapper(t *testing.T) {
-	resources := []*metav1.APIResourceList{
+	resources := []*unversioned.APIResourceList{
 		{
 			GroupVersion: "test/beta1",
-			APIResources: []metav1.APIResource{
+			APIResources: []unversioned.APIResource{
 				{
 					Name:       "test_kinds",
 					Namespaced: true,
@@ -37,7 +36,7 @@ func TestDiscoveryRESTMapper(t *testing.T) {
 		},
 	}
 
-	gvk := schema.GroupVersionKind{
+	gvk := unversioned.GroupVersionKind{
 		Group:   "test",
 		Version: "beta1",
 		Kind:    "test_kind",
@@ -48,7 +47,7 @@ func TestDiscoveryRESTMapper(t *testing.T) {
 		t.Fatalf("unexpected error creating mapper: %s", err)
 	}
 
-	for _, res := range []schema.GroupVersionResource{
+	for _, res := range []unversioned.GroupVersionResource{
 		{
 			Group:    "test",
 			Version:  "beta1",

1.5/kubernetes/clientset.go

@@ -0,0 +1,261 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package 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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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

@@ -0,0 +1,138 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT 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

@@ -14,19 +14,7 @@ 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
-
-import (
-	"k8s.io/client-go/pkg/api/v1"
-	core "k8s.io/client-go/testing"
-)
-
-func (c *FakeNodes) PatchStatus(nodeName string, data []byte) (*v1.Node, error) {
-	obj, err := c.Fake.Invokes(
-		core.NewRootPatchSubresourceAction(nodesResource, nodeName, data, "status"), &v1.Node{})
-	if obj == nil {
-		return nil, err
-	}
-
-	return obj.(*v1.Node), err
-}

1.5/kubernetes/import_known_versions.go

@@ -20,23 +20,22 @@ package kubernetes
 import (
 	"fmt"
 
-	"k8s.io/client-go/pkg/api"
-	_ "k8s.io/client-go/pkg/api/install"
-	_ "k8s.io/client-go/pkg/apis/apps/install"
-	_ "k8s.io/client-go/pkg/apis/authentication/install"
-	_ "k8s.io/client-go/pkg/apis/authorization/install"
-	_ "k8s.io/client-go/pkg/apis/autoscaling/install"
-	_ "k8s.io/client-go/pkg/apis/batch/install"
-	_ "k8s.io/client-go/pkg/apis/certificates/install"
-	_ "k8s.io/client-go/pkg/apis/extensions/install"
-	_ "k8s.io/client-go/pkg/apis/policy/install"
-	_ "k8s.io/client-go/pkg/apis/rbac/install"
-	_ "k8s.io/client-go/pkg/apis/settings/install"
-	_ "k8s.io/client-go/pkg/apis/storage/install"
+	_ "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 := api.Registry.ValidateEnvRequestedVersions(); len(missingVersions) != 0 {
+	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

@@ -0,0 +1,96 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package 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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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_apps_client.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	v1beta1 "k8s.io/client-go/kubernetes/typed/storage/v1beta1"
-	rest "k8s.io/client-go/rest"
-	testing "k8s.io/client-go/testing"
+	v1alpha1 "k8s.io/client-go/1.5/kubernetes/typed/apps/v1alpha1"
+	rest "k8s.io/client-go/1.5/rest"
+	testing "k8s.io/client-go/1.5/testing"
 )
 
-type FakeStorageV1beta1 struct {
+type FakeApps struct {
 	*testing.Fake
 }
 
-func (c *FakeStorageV1beta1) StorageClasses() v1beta1.StorageClassInterface {
-	return &FakeStorageClasses{c}
+func (c *FakeApps) PetSets(namespace string) v1alpha1.PetSetInterface {
+	return &FakePetSets{c, namespace}
 }
 
-// RESTClient returns a RESTClient that is used to communicate
+// GetRESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *FakeStorageV1beta1) RESTClient() rest.Interface {
-	var ret *rest.RESTClient
-	return ret
+func (c *FakeApps) GetRESTClient() *rest.RESTClient {
+	return nil
 }

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

@@ -0,0 +1,127 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fake
+
+import (
+	api "k8s.io/client-go/1.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/generated_expansion.go

@@ -14,5 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// +groupName=rbac.authorization.k8s.io
 package v1alpha1
+
+type PetSetExpansion interface{}

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

@@ -0,0 +1,165 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package 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

@@ -0,0 +1,96 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1beta1
+
+import (
+	api "k8s.io/client-go/1.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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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/authentication/v1beta1/fake/fake_authentication_client.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	v1 "k8s.io/client-go/kubernetes/typed/authentication/v1"
-	rest "k8s.io/client-go/rest"
-	testing "k8s.io/client-go/testing"
+	v1beta1 "k8s.io/client-go/1.5/kubernetes/typed/authentication/v1beta1"
+	rest "k8s.io/client-go/1.5/rest"
+	testing "k8s.io/client-go/1.5/testing"
 )
 
-type FakeAuthenticationV1 struct {
+type FakeAuthentication struct {
 	*testing.Fake
 }
 
-func (c *FakeAuthenticationV1) TokenReviews() v1.TokenReviewInterface {
+func (c *FakeAuthentication) TokenReviews() v1beta1.TokenReviewInterface {
 	return &FakeTokenReviews{c}
 }
 
-// RESTClient returns a RESTClient that is used to communicate
+// GetRESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *FakeAuthenticationV1) RESTClient() rest.Interface {
-	var ret *rest.RESTClient
-	return ret
+func (c *FakeAuthentication) GetRESTClient() *rest.RESTClient {
+	return nil
 }

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -18,5 +18,5 @@ package fake
 
 // FakeTokenReviews implements TokenReviewInterface
 type FakeTokenReviews struct {
-	Fake *FakeAuthenticationV1
+	Fake *FakeAuthentication
 }

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

@@ -14,5 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// +groupName=authentication.k8s.io
 package v1beta1
+
+type TokenReviewExpansion interface{}

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -16,10 +16,6 @@ limitations under the License.
 
 package v1beta1
 
-import (
-	rest "k8s.io/client-go/rest"
-)
-
 // TokenReviewsGetter has a method to return a TokenReviewInterface.
 // A group's client should implement this interface.
 type TokenReviewsGetter interface {
@@ -33,12 +29,12 @@ type TokenReviewInterface interface {
 
 // tokenReviews implements TokenReviewInterface
 type tokenReviews struct {
-	client rest.Interface
+	client *AuthenticationClient
 }
 
 // newTokenReviews returns a TokenReviews
-func newTokenReviews(c *AuthenticationV1beta1Client) *tokenReviews {
+func newTokenReviews(c *AuthenticationClient) *tokenReviews {
 	return &tokenReviews{
-		client: c.RESTClient(),
+		client: c,
 	}
 }

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

@@ -0,0 +1,106 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT 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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,30 +17,29 @@ limitations under the License.
 package fake
 
 import (
-	v1 "k8s.io/client-go/kubernetes/typed/authorization/v1"
-	rest "k8s.io/client-go/rest"
-	testing "k8s.io/client-go/testing"
+	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 FakeAuthorizationV1 struct {
+type FakeAuthorization struct {
 	*testing.Fake
 }
 
-func (c *FakeAuthorizationV1) LocalSubjectAccessReviews(namespace string) v1.LocalSubjectAccessReviewInterface {
+func (c *FakeAuthorization) LocalSubjectAccessReviews(namespace string) v1beta1.LocalSubjectAccessReviewInterface {
 	return &FakeLocalSubjectAccessReviews{c, namespace}
 }
 
-func (c *FakeAuthorizationV1) SelfSubjectAccessReviews() v1.SelfSubjectAccessReviewInterface {
+func (c *FakeAuthorization) SelfSubjectAccessReviews() v1beta1.SelfSubjectAccessReviewInterface {
 	return &FakeSelfSubjectAccessReviews{c}
 }
 
-func (c *FakeAuthorizationV1) SubjectAccessReviews() v1.SubjectAccessReviewInterface {
+func (c *FakeAuthorization) SubjectAccessReviews() v1beta1.SubjectAccessReviewInterface {
 	return &FakeSubjectAccessReviews{c}
 }
 
-// RESTClient returns a RESTClient that is used to communicate
+// GetRESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *FakeAuthorizationV1) RESTClient() rest.Interface {
-	var ret *rest.RESTClient
-	return ret
+func (c *FakeAuthorization) GetRESTClient() *rest.RESTClient {
+	return nil
 }

1.5/kubernetes/typed/authorization/v1beta1/fake/fake_localsubjectaccessreview.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -18,6 +18,6 @@ package fake
 
 // FakeLocalSubjectAccessReviews implements LocalSubjectAccessReviewInterface
 type FakeLocalSubjectAccessReviews struct {
-	Fake *FakeAuthorizationV1
+	Fake *FakeAuthorization
 	ns   string
 }

1.5/kubernetes/typed/authorization/v1beta1/fake/fake_selfsubjectaccessreview.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -18,5 +18,5 @@ package fake
 
 // FakeSelfSubjectAccessReviews implements SelfSubjectAccessReviewInterface
 type FakeSelfSubjectAccessReviews struct {
-	Fake *FakeAuthorizationV1
+	Fake *FakeAuthorization
 }

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -18,5 +18,5 @@ package fake
 
 // FakeSubjectAccessReviews implements SubjectAccessReviewInterface
 type FakeSubjectAccessReviews struct {
-	Fake *FakeAuthorizationV1
+	Fake *FakeAuthorization
 }

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

@@ -17,11 +17,12 @@ limitations under the License.
 package fake
 
 import (
-	authorizationapi "k8s.io/client-go/pkg/apis/authorization/v1beta1"
-	core "k8s.io/client-go/testing"
+	authorizationapi "k8s.io/client-go/1.5/pkg/apis/authorization/v1beta1"
+
+	"k8s.io/client-go/1.5/testing"
 )
 
 func (c *FakeSubjectAccessReviews) Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
-	obj, err := c.Fake.Invokes(core.NewRootCreateAction(authorizationapi.SchemeGroupVersion.WithResource("subjectaccessreviews"), sar), &authorizationapi.SubjectAccessReview{})
+	obj, err := c.Fake.Invokes(testing.NewRootCreateAction(authorizationapi.SchemeGroupVersion.WithResource("subjectaccessreviews"), sar), &authorizationapi.SubjectAccessReview{})
 	return obj.(*authorizationapi.SubjectAccessReview), err
 }

1.5/kubernetes/typed/authorization/v1beta1/generated_expansion.go

@@ -14,5 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// +groupName=certificates.k8s.io
 package v1beta1
+
+type LocalSubjectAccessReviewExpansion interface{}
+
+type SelfSubjectAccessReviewExpansion interface{}

1.5/kubernetes/typed/authorization/v1beta1/localsubjectaccessreview.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -16,10 +16,6 @@ limitations under the License.
 
 package v1beta1
 
-import (
-	rest "k8s.io/client-go/rest"
-)
-
 // LocalSubjectAccessReviewsGetter has a method to return a LocalSubjectAccessReviewInterface.
 // A group's client should implement this interface.
 type LocalSubjectAccessReviewsGetter interface {
@@ -33,14 +29,14 @@ type LocalSubjectAccessReviewInterface interface {
 
 // localSubjectAccessReviews implements LocalSubjectAccessReviewInterface
 type localSubjectAccessReviews struct {
-	client rest.Interface
+	client *AuthorizationClient
 	ns     string
 }
 
 // newLocalSubjectAccessReviews returns a LocalSubjectAccessReviews
-func newLocalSubjectAccessReviews(c *AuthorizationV1beta1Client, namespace string) *localSubjectAccessReviews {
+func newLocalSubjectAccessReviews(c *AuthorizationClient, namespace string) *localSubjectAccessReviews {
 	return &localSubjectAccessReviews{
-		client: c.RESTClient(),
+		client: c,
 		ns:     namespace,
 	}
 }

1.5/kubernetes/typed/authorization/v1beta1/selfsubjectaccessreview.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -16,10 +16,6 @@ limitations under the License.
 
 package v1beta1
 
-import (
-	rest "k8s.io/client-go/rest"
-)
-
 // SelfSubjectAccessReviewsGetter has a method to return a SelfSubjectAccessReviewInterface.
 // A group's client should implement this interface.
 type SelfSubjectAccessReviewsGetter interface {
@@ -33,12 +29,12 @@ type SelfSubjectAccessReviewInterface interface {
 
 // selfSubjectAccessReviews implements SelfSubjectAccessReviewInterface
 type selfSubjectAccessReviews struct {
-	client rest.Interface
+	client *AuthorizationClient
 }
 
 // newSelfSubjectAccessReviews returns a SelfSubjectAccessReviews
-func newSelfSubjectAccessReviews(c *AuthorizationV1beta1Client) *selfSubjectAccessReviews {
+func newSelfSubjectAccessReviews(c *AuthorizationClient) *selfSubjectAccessReviews {
 	return &selfSubjectAccessReviews{
-		client: c.RESTClient(),
+		client: c,
 	}
 }

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -16,10 +16,6 @@ limitations under the License.
 
 package v1beta1
 
-import (
-	rest "k8s.io/client-go/rest"
-)
-
 // SubjectAccessReviewsGetter has a method to return a SubjectAccessReviewInterface.
 // A group's client should implement this interface.
 type SubjectAccessReviewsGetter interface {
@@ -33,12 +29,12 @@ type SubjectAccessReviewInterface interface {
 
 // subjectAccessReviews implements SubjectAccessReviewInterface
 type subjectAccessReviews struct {
-	client rest.Interface
+	client *AuthorizationClient
 }
 
 // newSubjectAccessReviews returns a SubjectAccessReviews
-func newSubjectAccessReviews(c *AuthorizationV1beta1Client) *subjectAccessReviews {
+func newSubjectAccessReviews(c *AuthorizationClient) *subjectAccessReviews {
 	return &subjectAccessReviews{
-		client: c.RESTClient(),
+		client: c,
 	}
 }

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

@@ -17,7 +17,7 @@ limitations under the License.
 package v1beta1
 
 import (
-	authorizationapi "k8s.io/client-go/pkg/apis/authorization/v1beta1"
+	authorizationapi "k8s.io/client-go/1.5/pkg/apis/authorization/v1beta1"
 )
 
 // The SubjectAccessReviewExpansion interface allows manually adding extra methods to the AuthorizationInterface.

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

@@ -0,0 +1,96 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+	api "k8s.io/client-go/1.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/doc.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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/autoscaling/v1/fake/doc.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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_autoscaling_client.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	v1 "k8s.io/client-go/kubernetes/typed/autoscaling/v1"
-	rest "k8s.io/client-go/rest"
-	testing "k8s.io/client-go/testing"
+	v1 "k8s.io/client-go/1.5/kubernetes/typed/autoscaling/v1"
+	rest "k8s.io/client-go/1.5/rest"
+	testing "k8s.io/client-go/1.5/testing"
 )
 
-type FakeAutoscalingV1 struct {
+type FakeAutoscaling struct {
 	*testing.Fake
 }
 
-func (c *FakeAutoscalingV1) HorizontalPodAutoscalers(namespace string) v1.HorizontalPodAutoscalerInterface {
+func (c *FakeAutoscaling) HorizontalPodAutoscalers(namespace string) v1.HorizontalPodAutoscalerInterface {
 	return &FakeHorizontalPodAutoscalers{c, namespace}
 }
 
-// RESTClient returns a RESTClient that is used to communicate
+// GetRESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *FakeAutoscalingV1) RESTClient() rest.Interface {
-	var ret *rest.RESTClient
-	return ret
+func (c *FakeAutoscaling) GetRESTClient() *rest.RESTClient {
+	return nil
 }

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/apis/autoscaling/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeAutoscalingV1
+	Fake *FakeAutoscaling
 	ns   string
 }
 
-var horizontalpodautoscalersResource = schema.GroupVersionResource{Group: "autoscaling", Version: "v1", Resource: "horizontalpodautoscalers"}
+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.
@@ -64,21 +63,21 @@ func (c *FakeHorizontalPodAutoscalers) UpdateStatus(horizontalPodAutoscaler *v1.
 	return obj.(*v1.HorizontalPodAutoscaler), err
 }
 
-func (c *FakeHorizontalPodAutoscalers) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.HorizontalPodAutoscaler, err error) {
+func (c *FakeHorizontalPodAutoscalers) Get(name string) (result *v1.HorizontalPodAutoscaler, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(horizontalpodautoscalersResource, c.ns, name), &v1.HorizontalPodAutoscaler{})
 
@@ -88,7 +87,7 @@ func (c *FakeHorizontalPodAutoscalers) Get(name string, options meta_v1.GetOptio
 	return obj.(*v1.HorizontalPodAutoscaler), err
 }
 
-func (c *FakeHorizontalPodAutoscalers) List(opts meta_v1.ListOptions) (result *v1.HorizontalPodAutoscalerList, err error) {
+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{})
 
@@ -96,7 +95,7 @@ func (c *FakeHorizontalPodAutoscalers) List(opts meta_v1.ListOptions) (result *v
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -110,14 +109,14 @@ func (c *FakeHorizontalPodAutoscalers) List(opts meta_v1.ListOptions) (result *v
 }
 
 // Watch returns a watch.Interface that watches the requested horizontalPodAutoscalers.
-func (c *FakeHorizontalPodAutoscalers) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.HorizontalPodAutoscaler, err error) {
+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{})
 

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,12 +17,9 @@ limitations under the License.
 package v1
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	v1 "k8s.io/client-go/pkg/apis/autoscaling/v1"
-	rest "k8s.io/client-go/rest"
+	api "k8s.io/client-go/1.5/pkg/api"
+	v1 "k8s.io/client-go/1.5/pkg/apis/autoscaling/v1"
+	watch "k8s.io/client-go/1.5/pkg/watch"
 )
 
 // HorizontalPodAutoscalersGetter has a method to return a HorizontalPodAutoscalerInterface.
@@ -36,25 +33,25 @@ type HorizontalPodAutoscalerInterface interface {
 	Create(*v1.HorizontalPodAutoscaler) (*v1.HorizontalPodAutoscaler, error)
 	Update(*v1.HorizontalPodAutoscaler) (*v1.HorizontalPodAutoscaler, error)
 	UpdateStatus(*v1.HorizontalPodAutoscaler) (*v1.HorizontalPodAutoscaler, error)
-	Delete(name string, options *meta_v1.DeleteOptions) error
-	DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error
-	Get(name string, options meta_v1.GetOptions) (*v1.HorizontalPodAutoscaler, error)
-	List(opts meta_v1.ListOptions) (*v1.HorizontalPodAutoscalerList, error)
-	Watch(opts meta_v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.HorizontalPodAutoscaler, err error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.HorizontalPodAutoscaler, error)
+	List(opts api.ListOptions) (*v1.HorizontalPodAutoscalerList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.HorizontalPodAutoscaler, err error)
 	HorizontalPodAutoscalerExpansion
 }
 
 // horizontalPodAutoscalers implements HorizontalPodAutoscalerInterface
 type horizontalPodAutoscalers struct {
-	client rest.Interface
+	client *AutoscalingClient
 	ns     string
 }
 
 // newHorizontalPodAutoscalers returns a HorizontalPodAutoscalers
-func newHorizontalPodAutoscalers(c *AutoscalingV1Client, namespace string) *horizontalPodAutoscalers {
+func newHorizontalPodAutoscalers(c *AutoscalingClient, namespace string) *horizontalPodAutoscalers {
 	return &horizontalPodAutoscalers{
-		client: c.RESTClient(),
+		client: c,
 		ns:     namespace,
 	}
 }
@@ -84,9 +81,6 @@ func (c *horizontalPodAutoscalers) Update(horizontalPodAutoscaler *v1.Horizontal
 	return
 }
 
-// UpdateStatus was generated because the type contains a Status member.
-// Add a +genclientstatus=false comment above the type to avoid generating UpdateStatus().
-
 func (c *horizontalPodAutoscalers) UpdateStatus(horizontalPodAutoscaler *v1.HorizontalPodAutoscaler) (result *v1.HorizontalPodAutoscaler, err error) {
 	result = &v1.HorizontalPodAutoscaler{}
 	err = c.client.Put().
@@ -101,7 +95,7 @@ func (c *horizontalPodAutoscalers) UpdateStatus(horizontalPodAutoscaler *v1.Hori
 }
 
 // Delete takes name of the horizontalPodAutoscaler and deletes it. Returns an error if one occurs.
-func (c *horizontalPodAutoscalers) Delete(name string, options *meta_v1.DeleteOptions) error {
+func (c *horizontalPodAutoscalers) Delete(name string, options *api.DeleteOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("horizontalpodautoscalers").
@@ -112,53 +106,52 @@ func (c *horizontalPodAutoscalers) Delete(name string, options *meta_v1.DeleteOp
 }
 
 // DeleteCollection deletes a collection of objects.
-func (c *horizontalPodAutoscalers) DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+func (c *horizontalPodAutoscalers) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("horizontalpodautoscalers").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
+		VersionedParams(&listOptions, api.ParameterCodec).
 		Body(options).
 		Do().
 		Error()
 }
 
 // Get takes name of the horizontalPodAutoscaler, and returns the corresponding horizontalPodAutoscaler object, and an error if there is any.
-func (c *horizontalPodAutoscalers) Get(name string, options meta_v1.GetOptions) (result *v1.HorizontalPodAutoscaler, err error) {
+func (c *horizontalPodAutoscalers) Get(name string) (result *v1.HorizontalPodAutoscaler, err error) {
 	result = &v1.HorizontalPodAutoscaler{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("horizontalpodautoscalers").
 		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // List takes label and field selectors, and returns the list of HorizontalPodAutoscalers that match those selectors.
-func (c *horizontalPodAutoscalers) List(opts meta_v1.ListOptions) (result *v1.HorizontalPodAutoscalerList, err error) {
+func (c *horizontalPodAutoscalers) List(opts api.ListOptions) (result *v1.HorizontalPodAutoscalerList, err error) {
 	result = &v1.HorizontalPodAutoscalerList{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("horizontalpodautoscalers").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // Watch returns a watch.Interface that watches the requested horizontalPodAutoscalers.
-func (c *horizontalPodAutoscalers) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
-	opts.Watch = true
+func (c *horizontalPodAutoscalers) Watch(opts api.ListOptions) (watch.Interface, error) {
 	return c.client.Get().
+		Prefix("watch").
 		Namespace(c.ns).
 		Resource("horizontalpodautoscalers").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Watch()
 }
 
 // Patch applies the patch and returns the patched horizontalPodAutoscaler.
-func (c *horizontalPodAutoscalers) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.HorizontalPodAutoscaler, err error) {
+func (c *horizontalPodAutoscalers) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.HorizontalPodAutoscaler, err error) {
 	result = &v1.HorizontalPodAutoscaler{}
 	err = c.client.Patch(pt).
 		Namespace(c.ns).

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

@@ -0,0 +1,96 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+	api "k8s.io/client-go/1.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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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

@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_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_batch_client.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	v1 "k8s.io/client-go/kubernetes/typed/batch/v1"
-	rest "k8s.io/client-go/rest"
-	testing "k8s.io/client-go/testing"
+	v1 "k8s.io/client-go/1.5/kubernetes/typed/batch/v1"
+	rest "k8s.io/client-go/1.5/rest"
+	testing "k8s.io/client-go/1.5/testing"
 )
 
-type FakeBatchV1 struct {
+type FakeBatch struct {
 	*testing.Fake
 }
 
-func (c *FakeBatchV1) Jobs(namespace string) v1.JobInterface {
+func (c *FakeBatch) Jobs(namespace string) v1.JobInterface {
 	return &FakeJobs{c, namespace}
 }
 
-// RESTClient returns a RESTClient that is used to communicate
+// GetRESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *FakeBatchV1) RESTClient() rest.Interface {
-	var ret *rest.RESTClient
-	return ret
+func (c *FakeBatch) GetRESTClient() *rest.RESTClient {
+	return nil
 }

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/apis/batch/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeBatchV1
+	Fake *FakeBatch
 	ns   string
 }
 
-var jobsResource = schema.GroupVersionResource{Group: "batch", Version: "v1", Resource: "jobs"}
+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.
@@ -64,21 +63,21 @@ func (c *FakeJobs) UpdateStatus(job *v1.Job) (*v1.Job, error) {
 	return obj.(*v1.Job), err
 }
 
-func (c *FakeJobs) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.Job, err error) {
+func (c *FakeJobs) Get(name string) (result *v1.Job, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(jobsResource, c.ns, name), &v1.Job{})
 
@@ -88,7 +87,7 @@ func (c *FakeJobs) Get(name string, options meta_v1.GetOptions) (result *v1.Job,
 	return obj.(*v1.Job), err
 }
 
-func (c *FakeJobs) List(opts meta_v1.ListOptions) (result *v1.JobList, err error) {
+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{})
 
@@ -96,7 +95,7 @@ func (c *FakeJobs) List(opts meta_v1.ListOptions) (result *v1.JobList, err error
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -110,14 +109,14 @@ func (c *FakeJobs) List(opts meta_v1.ListOptions) (result *v1.JobList, err error
 }
 
 // Watch returns a watch.Interface that watches the requested jobs.
-func (c *FakeJobs) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.Job, err error) {
+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{})
 

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

@@ -15,3 +15,5 @@ limitations under the License.
 */
 
 package v1
+
+type JobExpansion interface{}

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,12 +17,9 @@ limitations under the License.
 package v1
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	v1 "k8s.io/client-go/pkg/apis/batch/v1"
-	rest "k8s.io/client-go/rest"
+	api "k8s.io/client-go/1.5/pkg/api"
+	v1 "k8s.io/client-go/1.5/pkg/apis/batch/v1"
+	watch "k8s.io/client-go/1.5/pkg/watch"
 )
 
 // JobsGetter has a method to return a JobInterface.
@@ -36,25 +33,25 @@ type JobInterface interface {
 	Create(*v1.Job) (*v1.Job, error)
 	Update(*v1.Job) (*v1.Job, error)
 	UpdateStatus(*v1.Job) (*v1.Job, error)
-	Delete(name string, options *meta_v1.DeleteOptions) error
-	DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error
-	Get(name string, options meta_v1.GetOptions) (*v1.Job, error)
-	List(opts meta_v1.ListOptions) (*v1.JobList, error)
-	Watch(opts meta_v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.Job, err error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Job, error)
+	List(opts api.ListOptions) (*v1.JobList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Job, err error)
 	JobExpansion
 }
 
 // jobs implements JobInterface
 type jobs struct {
-	client rest.Interface
+	client *BatchClient
 	ns     string
 }
 
 // newJobs returns a Jobs
-func newJobs(c *BatchV1Client, namespace string) *jobs {
+func newJobs(c *BatchClient, namespace string) *jobs {
 	return &jobs{
-		client: c.RESTClient(),
+		client: c,
 		ns:     namespace,
 	}
 }
@@ -84,9 +81,6 @@ func (c *jobs) Update(job *v1.Job) (result *v1.Job, err error) {
 	return
 }
 
-// UpdateStatus was generated because the type contains a Status member.
-// Add a +genclientstatus=false comment above the type to avoid generating UpdateStatus().
-
 func (c *jobs) UpdateStatus(job *v1.Job) (result *v1.Job, err error) {
 	result = &v1.Job{}
 	err = c.client.Put().
@@ -101,7 +95,7 @@ func (c *jobs) UpdateStatus(job *v1.Job) (result *v1.Job, err error) {
 }
 
 // Delete takes name of the job and deletes it. Returns an error if one occurs.
-func (c *jobs) Delete(name string, options *meta_v1.DeleteOptions) error {
+func (c *jobs) Delete(name string, options *api.DeleteOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("jobs").
@@ -112,53 +106,52 @@ func (c *jobs) Delete(name string, options *meta_v1.DeleteOptions) error {
 }
 
 // DeleteCollection deletes a collection of objects.
-func (c *jobs) DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+func (c *jobs) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("jobs").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
+		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, options meta_v1.GetOptions) (result *v1.Job, err error) {
+func (c *jobs) Get(name string) (result *v1.Job, err error) {
 	result = &v1.Job{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("jobs").
 		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
 		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 meta_v1.ListOptions) (result *v1.JobList, err error) {
+func (c *jobs) List(opts api.ListOptions) (result *v1.JobList, err error) {
 	result = &v1.JobList{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("jobs").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // Watch returns a watch.Interface that watches the requested jobs.
-func (c *jobs) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
-	opts.Watch = true
+func (c *jobs) Watch(opts api.ListOptions) (watch.Interface, error) {
 	return c.client.Get().
+		Prefix("watch").
 		Namespace(c.ns).
 		Resource("jobs").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Watch()
 }
 
 // Patch applies the patch and returns the patched job.
-func (c *jobs) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.Job, err error) {
+func (c *jobs) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Job, err error) {
 	result = &v1.Job{}
 	err = c.client.Patch(pt).
 		Namespace(c.ns).

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

@@ -0,0 +1,96 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package 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/certificatesigningrequest.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,15 +14,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package v1beta1
+package v1alpha1
 
 import (
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	v1beta1 "k8s.io/client-go/pkg/apis/certificates/v1beta1"
-	rest "k8s.io/client-go/rest"
+	api "k8s.io/client-go/1.5/pkg/api"
+	v1alpha1 "k8s.io/client-go/1.5/pkg/apis/certificates/v1alpha1"
+	watch "k8s.io/client-go/1.5/pkg/watch"
 )
 
 // CertificateSigningRequestsGetter has a method to return a CertificateSigningRequestInterface.
@@ -33,33 +30,33 @@ type CertificateSigningRequestsGetter interface {
 
 // CertificateSigningRequestInterface has methods to work with CertificateSigningRequest resources.
 type CertificateSigningRequestInterface interface {
-	Create(*v1beta1.CertificateSigningRequest) (*v1beta1.CertificateSigningRequest, error)
-	Update(*v1beta1.CertificateSigningRequest) (*v1beta1.CertificateSigningRequest, error)
-	UpdateStatus(*v1beta1.CertificateSigningRequest) (*v1beta1.CertificateSigningRequest, error)
-	Delete(name string, options *v1.DeleteOptions) error
-	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
-	Get(name string, options v1.GetOptions) (*v1beta1.CertificateSigningRequest, error)
-	List(opts v1.ListOptions) (*v1beta1.CertificateSigningRequestList, error)
-	Watch(opts v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.CertificateSigningRequest, err error)
+	Create(*v1alpha1.CertificateSigningRequest) (*v1alpha1.CertificateSigningRequest, error)
+	Update(*v1alpha1.CertificateSigningRequest) (*v1alpha1.CertificateSigningRequest, error)
+	UpdateStatus(*v1alpha1.CertificateSigningRequest) (*v1alpha1.CertificateSigningRequest, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1alpha1.CertificateSigningRequest, error)
+	List(opts api.ListOptions) (*v1alpha1.CertificateSigningRequestList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1alpha1.CertificateSigningRequest, err error)
 	CertificateSigningRequestExpansion
 }
 
 // certificateSigningRequests implements CertificateSigningRequestInterface
 type certificateSigningRequests struct {
-	client rest.Interface
+	client *CertificatesClient
 }
 
 // newCertificateSigningRequests returns a CertificateSigningRequests
-func newCertificateSigningRequests(c *CertificatesV1beta1Client) *certificateSigningRequests {
+func newCertificateSigningRequests(c *CertificatesClient) *certificateSigningRequests {
 	return &certificateSigningRequests{
-		client: c.RESTClient(),
+		client: c,
 	}
 }
 
 // Create takes the representation of a certificateSigningRequest and creates it.  Returns the server's representation of the certificateSigningRequest, and an error, if there is any.
-func (c *certificateSigningRequests) Create(certificateSigningRequest *v1beta1.CertificateSigningRequest) (result *v1beta1.CertificateSigningRequest, err error) {
-	result = &v1beta1.CertificateSigningRequest{}
+func (c *certificateSigningRequests) Create(certificateSigningRequest *v1alpha1.CertificateSigningRequest) (result *v1alpha1.CertificateSigningRequest, err error) {
+	result = &v1alpha1.CertificateSigningRequest{}
 	err = c.client.Post().
 		Resource("certificatesigningrequests").
 		Body(certificateSigningRequest).
@@ -69,8 +66,8 @@ func (c *certificateSigningRequests) Create(certificateSigningRequest *v1beta1.C
 }
 
 // Update takes the representation of a certificateSigningRequest and updates it. Returns the server's representation of the certificateSigningRequest, and an error, if there is any.
-func (c *certificateSigningRequests) Update(certificateSigningRequest *v1beta1.CertificateSigningRequest) (result *v1beta1.CertificateSigningRequest, err error) {
-	result = &v1beta1.CertificateSigningRequest{}
+func (c *certificateSigningRequests) Update(certificateSigningRequest *v1alpha1.CertificateSigningRequest) (result *v1alpha1.CertificateSigningRequest, err error) {
+	result = &v1alpha1.CertificateSigningRequest{}
 	err = c.client.Put().
 		Resource("certificatesigningrequests").
 		Name(certificateSigningRequest.Name).
@@ -80,11 +77,8 @@ func (c *certificateSigningRequests) Update(certificateSigningRequest *v1beta1.C
 	return
 }
 
-// UpdateStatus was generated because the type contains a Status member.
-// Add a +genclientstatus=false comment above the type to avoid generating UpdateStatus().
-
-func (c *certificateSigningRequests) UpdateStatus(certificateSigningRequest *v1beta1.CertificateSigningRequest) (result *v1beta1.CertificateSigningRequest, err error) {
-	result = &v1beta1.CertificateSigningRequest{}
+func (c *certificateSigningRequests) UpdateStatus(certificateSigningRequest *v1alpha1.CertificateSigningRequest) (result *v1alpha1.CertificateSigningRequest, err error) {
+	result = &v1alpha1.CertificateSigningRequest{}
 	err = c.client.Put().
 		Resource("certificatesigningrequests").
 		Name(certificateSigningRequest.Name).
@@ -96,7 +90,7 @@ func (c *certificateSigningRequests) UpdateStatus(certificateSigningRequest *v1b
 }
 
 // Delete takes name of the certificateSigningRequest and deletes it. Returns an error if one occurs.
-func (c *certificateSigningRequests) Delete(name string, options *v1.DeleteOptions) error {
+func (c *certificateSigningRequests) Delete(name string, options *api.DeleteOptions) error {
 	return c.client.Delete().
 		Resource("certificatesigningrequests").
 		Name(name).
@@ -106,50 +100,49 @@ func (c *certificateSigningRequests) Delete(name string, options *v1.DeleteOptio
 }
 
 // DeleteCollection deletes a collection of objects.
-func (c *certificateSigningRequests) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+func (c *certificateSigningRequests) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
 	return c.client.Delete().
 		Resource("certificatesigningrequests").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
+		VersionedParams(&listOptions, api.ParameterCodec).
 		Body(options).
 		Do().
 		Error()
 }
 
 // Get takes name of the certificateSigningRequest, and returns the corresponding certificateSigningRequest object, and an error if there is any.
-func (c *certificateSigningRequests) Get(name string, options v1.GetOptions) (result *v1beta1.CertificateSigningRequest, err error) {
-	result = &v1beta1.CertificateSigningRequest{}
+func (c *certificateSigningRequests) Get(name string) (result *v1alpha1.CertificateSigningRequest, err error) {
+	result = &v1alpha1.CertificateSigningRequest{}
 	err = c.client.Get().
 		Resource("certificatesigningrequests").
 		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // List takes label and field selectors, and returns the list of CertificateSigningRequests that match those selectors.
-func (c *certificateSigningRequests) List(opts v1.ListOptions) (result *v1beta1.CertificateSigningRequestList, err error) {
-	result = &v1beta1.CertificateSigningRequestList{}
+func (c *certificateSigningRequests) List(opts api.ListOptions) (result *v1alpha1.CertificateSigningRequestList, err error) {
+	result = &v1alpha1.CertificateSigningRequestList{}
 	err = c.client.Get().
 		Resource("certificatesigningrequests").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // Watch returns a watch.Interface that watches the requested certificateSigningRequests.
-func (c *certificateSigningRequests) Watch(opts v1.ListOptions) (watch.Interface, error) {
-	opts.Watch = true
+func (c *certificateSigningRequests) Watch(opts api.ListOptions) (watch.Interface, error) {
 	return c.client.Get().
+		Prefix("watch").
 		Resource("certificatesigningrequests").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Watch()
 }
 
 // Patch applies the patch and returns the patched certificateSigningRequest.
-func (c *certificateSigningRequests) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.CertificateSigningRequest, err error) {
-	result = &v1beta1.CertificateSigningRequest{}
+func (c *certificateSigningRequests) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1alpha1.CertificateSigningRequest, err error) {
+	result = &v1alpha1.CertificateSigningRequest{}
 	err = c.client.Patch(pt).
 		Resource("certificatesigningrequests").
 		SubResource(subresources...).

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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/certificates/v1alpha1/fake/doc.go

@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_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_certificates_client.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	v1beta1 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1"
-	rest "k8s.io/client-go/rest"
-	testing "k8s.io/client-go/testing"
+	v1alpha1 "k8s.io/client-go/1.5/kubernetes/typed/certificates/v1alpha1"
+	rest "k8s.io/client-go/1.5/rest"
+	testing "k8s.io/client-go/1.5/testing"
 )
 
-type FakeCertificatesV1beta1 struct {
+type FakeCertificates struct {
 	*testing.Fake
 }
 
-func (c *FakeCertificatesV1beta1) CertificateSigningRequests() v1beta1.CertificateSigningRequestInterface {
+func (c *FakeCertificates) CertificateSigningRequests() v1alpha1.CertificateSigningRequestInterface {
 	return &FakeCertificateSigningRequests{c}
 }
 
-// RESTClient returns a RESTClient that is used to communicate
+// GetRESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *FakeCertificatesV1beta1) RESTClient() rest.Interface {
-	var ret *rest.RESTClient
-	return ret
+func (c *FakeCertificates) GetRESTClient() *rest.RESTClient {
+	return nil
 }

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

@@ -0,0 +1,118 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fake
+
+import (
+	api "k8s.io/client-go/1.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/certificates/v1alpha1/generated_expansion.go

@@ -14,4 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package v1beta1
+package v1alpha1
+
+type CertificateSigningRequestExpansion interface{}

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,12 +17,9 @@ limitations under the License.
 package v1
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	rest "k8s.io/client-go/rest"
+	api "k8s.io/client-go/1.5/pkg/api"
+	v1 "k8s.io/client-go/1.5/pkg/api/v1"
+	watch "k8s.io/client-go/1.5/pkg/watch"
 )
 
 // ComponentStatusesGetter has a method to return a ComponentStatusInterface.
@@ -35,24 +32,24 @@ type ComponentStatusesGetter interface {
 type ComponentStatusInterface interface {
 	Create(*v1.ComponentStatus) (*v1.ComponentStatus, error)
 	Update(*v1.ComponentStatus) (*v1.ComponentStatus, error)
-	Delete(name string, options *meta_v1.DeleteOptions) error
-	DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error
-	Get(name string, options meta_v1.GetOptions) (*v1.ComponentStatus, error)
-	List(opts meta_v1.ListOptions) (*v1.ComponentStatusList, error)
-	Watch(opts meta_v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.ComponentStatus, err error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.ComponentStatus, error)
+	List(opts api.ListOptions) (*v1.ComponentStatusList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ComponentStatus, err error)
 	ComponentStatusExpansion
 }
 
 // componentStatuses implements ComponentStatusInterface
 type componentStatuses struct {
-	client rest.Interface
+	client *CoreClient
 }
 
 // newComponentStatuses returns a ComponentStatuses
-func newComponentStatuses(c *CoreV1Client) *componentStatuses {
+func newComponentStatuses(c *CoreClient) *componentStatuses {
 	return &componentStatuses{
-		client: c.RESTClient(),
+		client: c,
 	}
 }
 
@@ -80,7 +77,7 @@ func (c *componentStatuses) Update(componentStatus *v1.ComponentStatus) (result
 }
 
 // Delete takes name of the componentStatus and deletes it. Returns an error if one occurs.
-func (c *componentStatuses) Delete(name string, options *meta_v1.DeleteOptions) error {
+func (c *componentStatuses) Delete(name string, options *api.DeleteOptions) error {
 	return c.client.Delete().
 		Resource("componentstatuses").
 		Name(name).
@@ -90,49 +87,48 @@ func (c *componentStatuses) Delete(name string, options *meta_v1.DeleteOptions)
 }
 
 // DeleteCollection deletes a collection of objects.
-func (c *componentStatuses) DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+func (c *componentStatuses) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
 	return c.client.Delete().
 		Resource("componentstatuses").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
+		VersionedParams(&listOptions, api.ParameterCodec).
 		Body(options).
 		Do().
 		Error()
 }
 
 // Get takes name of the componentStatus, and returns the corresponding componentStatus object, and an error if there is any.
-func (c *componentStatuses) Get(name string, options meta_v1.GetOptions) (result *v1.ComponentStatus, err error) {
+func (c *componentStatuses) Get(name string) (result *v1.ComponentStatus, err error) {
 	result = &v1.ComponentStatus{}
 	err = c.client.Get().
 		Resource("componentstatuses").
 		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // List takes label and field selectors, and returns the list of ComponentStatuses that match those selectors.
-func (c *componentStatuses) List(opts meta_v1.ListOptions) (result *v1.ComponentStatusList, err error) {
+func (c *componentStatuses) List(opts api.ListOptions) (result *v1.ComponentStatusList, err error) {
 	result = &v1.ComponentStatusList{}
 	err = c.client.Get().
 		Resource("componentstatuses").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // Watch returns a watch.Interface that watches the requested componentStatuses.
-func (c *componentStatuses) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
-	opts.Watch = true
+func (c *componentStatuses) Watch(opts api.ListOptions) (watch.Interface, error) {
 	return c.client.Get().
+		Prefix("watch").
 		Resource("componentstatuses").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Watch()
 }
 
 // Patch applies the patch and returns the patched componentStatus.
-func (c *componentStatuses) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.ComponentStatus, err error) {
+func (c *componentStatuses) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ComponentStatus, err error) {
 	result = &v1.ComponentStatus{}
 	err = c.client.Patch(pt).
 		Resource("componentstatuses").

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,12 +17,9 @@ limitations under the License.
 package v1
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	rest "k8s.io/client-go/rest"
+	api "k8s.io/client-go/1.5/pkg/api"
+	v1 "k8s.io/client-go/1.5/pkg/api/v1"
+	watch "k8s.io/client-go/1.5/pkg/watch"
 )
 
 // ConfigMapsGetter has a method to return a ConfigMapInterface.
@@ -35,25 +32,25 @@ type ConfigMapsGetter interface {
 type ConfigMapInterface interface {
 	Create(*v1.ConfigMap) (*v1.ConfigMap, error)
 	Update(*v1.ConfigMap) (*v1.ConfigMap, error)
-	Delete(name string, options *meta_v1.DeleteOptions) error
-	DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error
-	Get(name string, options meta_v1.GetOptions) (*v1.ConfigMap, error)
-	List(opts meta_v1.ListOptions) (*v1.ConfigMapList, error)
-	Watch(opts meta_v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.ConfigMap, err error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.ConfigMap, error)
+	List(opts api.ListOptions) (*v1.ConfigMapList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ConfigMap, err error)
 	ConfigMapExpansion
 }
 
 // configMaps implements ConfigMapInterface
 type configMaps struct {
-	client rest.Interface
+	client *CoreClient
 	ns     string
 }
 
 // newConfigMaps returns a ConfigMaps
-func newConfigMaps(c *CoreV1Client, namespace string) *configMaps {
+func newConfigMaps(c *CoreClient, namespace string) *configMaps {
 	return &configMaps{
-		client: c.RESTClient(),
+		client: c,
 		ns:     namespace,
 	}
 }
@@ -84,7 +81,7 @@ func (c *configMaps) Update(configMap *v1.ConfigMap) (result *v1.ConfigMap, err
 }
 
 // Delete takes name of the configMap and deletes it. Returns an error if one occurs.
-func (c *configMaps) Delete(name string, options *meta_v1.DeleteOptions) error {
+func (c *configMaps) Delete(name string, options *api.DeleteOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("configmaps").
@@ -95,53 +92,52 @@ func (c *configMaps) Delete(name string, options *meta_v1.DeleteOptions) error {
 }
 
 // DeleteCollection deletes a collection of objects.
-func (c *configMaps) DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+func (c *configMaps) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("configmaps").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
+		VersionedParams(&listOptions, api.ParameterCodec).
 		Body(options).
 		Do().
 		Error()
 }
 
 // Get takes name of the configMap, and returns the corresponding configMap object, and an error if there is any.
-func (c *configMaps) Get(name string, options meta_v1.GetOptions) (result *v1.ConfigMap, err error) {
+func (c *configMaps) Get(name string) (result *v1.ConfigMap, err error) {
 	result = &v1.ConfigMap{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("configmaps").
 		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // List takes label and field selectors, and returns the list of ConfigMaps that match those selectors.
-func (c *configMaps) List(opts meta_v1.ListOptions) (result *v1.ConfigMapList, err error) {
+func (c *configMaps) List(opts api.ListOptions) (result *v1.ConfigMapList, err error) {
 	result = &v1.ConfigMapList{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("configmaps").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // Watch returns a watch.Interface that watches the requested configMaps.
-func (c *configMaps) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
-	opts.Watch = true
+func (c *configMaps) Watch(opts api.ListOptions) (watch.Interface, error) {
 	return c.client.Get().
+		Prefix("watch").
 		Namespace(c.ns).
 		Resource("configmaps").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Watch()
 }
 
 // Patch applies the patch and returns the patched configMap.
-func (c *configMaps) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.ConfigMap, err error) {
+func (c *configMaps) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.ConfigMap, err error) {
 	result = &v1.ConfigMap{}
 	err = c.client.Patch(pt).
 		Namespace(c.ns).

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

@@ -0,0 +1,171 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT 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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// This package is generated by client-gen with custom arguments.
+// 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/endpoints.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,12 +17,9 @@ limitations under the License.
 package v1
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	rest "k8s.io/client-go/rest"
+	api "k8s.io/client-go/1.5/pkg/api"
+	v1 "k8s.io/client-go/1.5/pkg/api/v1"
+	watch "k8s.io/client-go/1.5/pkg/watch"
 )
 
 // EndpointsGetter has a method to return a EndpointsInterface.
@@ -35,25 +32,25 @@ type EndpointsGetter interface {
 type EndpointsInterface interface {
 	Create(*v1.Endpoints) (*v1.Endpoints, error)
 	Update(*v1.Endpoints) (*v1.Endpoints, error)
-	Delete(name string, options *meta_v1.DeleteOptions) error
-	DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error
-	Get(name string, options meta_v1.GetOptions) (*v1.Endpoints, error)
-	List(opts meta_v1.ListOptions) (*v1.EndpointsList, error)
-	Watch(opts meta_v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.Endpoints, err error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Endpoints, error)
+	List(opts api.ListOptions) (*v1.EndpointsList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Endpoints, err error)
 	EndpointsExpansion
 }
 
 // endpoints implements EndpointsInterface
 type endpoints struct {
-	client rest.Interface
+	client *CoreClient
 	ns     string
 }
 
 // newEndpoints returns a Endpoints
-func newEndpoints(c *CoreV1Client, namespace string) *endpoints {
+func newEndpoints(c *CoreClient, namespace string) *endpoints {
 	return &endpoints{
-		client: c.RESTClient(),
+		client: c,
 		ns:     namespace,
 	}
 }
@@ -84,7 +81,7 @@ func (c *endpoints) Update(endpoints *v1.Endpoints) (result *v1.Endpoints, err e
 }
 
 // Delete takes name of the endpoints and deletes it. Returns an error if one occurs.
-func (c *endpoints) Delete(name string, options *meta_v1.DeleteOptions) error {
+func (c *endpoints) Delete(name string, options *api.DeleteOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("endpoints").
@@ -95,53 +92,52 @@ func (c *endpoints) Delete(name string, options *meta_v1.DeleteOptions) error {
 }
 
 // DeleteCollection deletes a collection of objects.
-func (c *endpoints) DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+func (c *endpoints) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("endpoints").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
+		VersionedParams(&listOptions, api.ParameterCodec).
 		Body(options).
 		Do().
 		Error()
 }
 
 // Get takes name of the endpoints, and returns the corresponding endpoints object, and an error if there is any.
-func (c *endpoints) Get(name string, options meta_v1.GetOptions) (result *v1.Endpoints, err error) {
+func (c *endpoints) Get(name string) (result *v1.Endpoints, err error) {
 	result = &v1.Endpoints{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("endpoints").
 		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // List takes label and field selectors, and returns the list of Endpoints that match those selectors.
-func (c *endpoints) List(opts meta_v1.ListOptions) (result *v1.EndpointsList, err error) {
+func (c *endpoints) List(opts api.ListOptions) (result *v1.EndpointsList, err error) {
 	result = &v1.EndpointsList{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("endpoints").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // Watch returns a watch.Interface that watches the requested endpoints.
-func (c *endpoints) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
-	opts.Watch = true
+func (c *endpoints) Watch(opts api.ListOptions) (watch.Interface, error) {
 	return c.client.Get().
+		Prefix("watch").
 		Namespace(c.ns).
 		Resource("endpoints").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Watch()
 }
 
 // Patch applies the patch and returns the patched endpoints.
-func (c *endpoints) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.Endpoints, err error) {
+func (c *endpoints) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Endpoints, err error) {
 	result = &v1.Endpoints{}
 	err = c.client.Patch(pt).
 		Namespace(c.ns).

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,12 +17,9 @@ limitations under the License.
 package v1
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	rest "k8s.io/client-go/rest"
+	api "k8s.io/client-go/1.5/pkg/api"
+	v1 "k8s.io/client-go/1.5/pkg/api/v1"
+	watch "k8s.io/client-go/1.5/pkg/watch"
 )
 
 // EventsGetter has a method to return a EventInterface.
@@ -35,25 +32,25 @@ type EventsGetter interface {
 type EventInterface interface {
 	Create(*v1.Event) (*v1.Event, error)
 	Update(*v1.Event) (*v1.Event, error)
-	Delete(name string, options *meta_v1.DeleteOptions) error
-	DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error
-	Get(name string, options meta_v1.GetOptions) (*v1.Event, error)
-	List(opts meta_v1.ListOptions) (*v1.EventList, error)
-	Watch(opts meta_v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.Event, err error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Event, error)
+	List(opts api.ListOptions) (*v1.EventList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Event, err error)
 	EventExpansion
 }
 
 // events implements EventInterface
 type events struct {
-	client rest.Interface
+	client *CoreClient
 	ns     string
 }
 
 // newEvents returns a Events
-func newEvents(c *CoreV1Client, namespace string) *events {
+func newEvents(c *CoreClient, namespace string) *events {
 	return &events{
-		client: c.RESTClient(),
+		client: c,
 		ns:     namespace,
 	}
 }
@@ -84,7 +81,7 @@ func (c *events) Update(event *v1.Event) (result *v1.Event, err error) {
 }
 
 // Delete takes name of the event and deletes it. Returns an error if one occurs.
-func (c *events) Delete(name string, options *meta_v1.DeleteOptions) error {
+func (c *events) Delete(name string, options *api.DeleteOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("events").
@@ -95,53 +92,52 @@ func (c *events) Delete(name string, options *meta_v1.DeleteOptions) error {
 }
 
 // DeleteCollection deletes a collection of objects.
-func (c *events) DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+func (c *events) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("events").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
+		VersionedParams(&listOptions, api.ParameterCodec).
 		Body(options).
 		Do().
 		Error()
 }
 
 // Get takes name of the event, and returns the corresponding event object, and an error if there is any.
-func (c *events) Get(name string, options meta_v1.GetOptions) (result *v1.Event, err error) {
+func (c *events) Get(name string) (result *v1.Event, err error) {
 	result = &v1.Event{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("events").
 		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // List takes label and field selectors, and returns the list of Events that match those selectors.
-func (c *events) List(opts meta_v1.ListOptions) (result *v1.EventList, err error) {
+func (c *events) List(opts api.ListOptions) (result *v1.EventList, err error) {
 	result = &v1.EventList{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("events").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // Watch returns a watch.Interface that watches the requested events.
-func (c *events) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
-	opts.Watch = true
+func (c *events) Watch(opts api.ListOptions) (watch.Interface, error) {
 	return c.client.Get().
+		Prefix("watch").
 		Namespace(c.ns).
 		Resource("events").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Watch()
 }
 
 // Patch applies the patch and returns the patched event.
-func (c *events) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.Event, err error) {
+func (c *events) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Event, err error) {
 	result = &v1.Event{}
 	err = c.client.Patch(pt).
 		Namespace(c.ns).

1.5/kubernetes/typed/core/v1/event_expansion.go

@@ -19,11 +19,10 @@ package v1
 import (
 	"fmt"
 
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/fields"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/client-go/pkg/api/v1"
+	"k8s.io/client-go/1.5/pkg/api"
+	"k8s.io/client-go/1.5/pkg/api/v1"
+	"k8s.io/client-go/1.5/pkg/fields"
+	"k8s.io/client-go/1.5/pkg/runtime"
 )
 
 // The EventExpansion interface allows manually adding extra methods to the EventInterface.
@@ -34,7 +33,7 @@ type EventExpansion interface {
 	UpdateWithEventNamespace(event *v1.Event) (*v1.Event, error)
 	PatchWithEventNamespace(event *v1.Event, data []byte) (*v1.Event, error)
 	// Search finds events about the specified object
-	Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*v1.EventList, error)
+	Search(objOrRef runtime.Object) (*v1.EventList, error)
 	// Returns the appropriate field selector based on the API version being used to communicate with the server.
 	// The returned field selector can be used with List and Watch to filter desired events.
 	GetFieldSelector(involvedObjectName, involvedObjectNamespace, involvedObjectKind, involvedObjectUID *string) fields.Selector
@@ -85,7 +84,7 @@ func (e *events) PatchWithEventNamespace(incompleteEvent *v1.Event, data []byte)
 		return nil, fmt.Errorf("can't patch an event with namespace '%v' in namespace '%v'", incompleteEvent.Namespace, e.ns)
 	}
 	result := &v1.Event{}
-	err := e.client.Patch(types.StrategicMergePatchType).
+	err := e.client.Patch(api.StrategicMergePatchType).
 		NamespaceIfScoped(incompleteEvent.Namespace, len(incompleteEvent.Namespace) > 0).
 		Resource("events").
 		Name(incompleteEvent.Name).
@@ -98,8 +97,8 @@ func (e *events) PatchWithEventNamespace(incompleteEvent *v1.Event, data []byte)
 // Search finds events about the specified object. The namespace of the
 // object must match this event's client namespace unless the event client
 // was made with the "" namespace.
-func (e *events) Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*v1.EventList, error) {
-	ref, err := v1.GetReference(scheme, objOrRef)
+func (e *events) Search(objOrRef runtime.Object) (*v1.EventList, error) {
+	ref, err := api.GetReference(objOrRef)
 	if err != nil {
 		return nil, err
 	}
@@ -117,7 +116,7 @@ func (e *events) Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*v1.Ev
 		refUID = &stringRefUID
 	}
 	fieldSelector := e.GetFieldSelector(&ref.Name, &ref.Namespace, refKind, refUID)
-	return e.List(metav1.ListOptions{FieldSelector: fieldSelector.String()})
+	return e.List(api.ListOptions{FieldSelector: fieldSelector})
 }
 
 // Returns the appropriate field selector based on the API version being used to communicate with the server.

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

@@ -0,0 +1,20 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// This package is generated by client-gen with arguments: --clientset-name=release_1_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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,21 +17,20 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 }
 
-var componentstatusesResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "componentstatuses"}
+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.
@@ -51,20 +50,20 @@ func (c *FakeComponentStatuses) Update(componentStatus *v1.ComponentStatus) (res
 	return obj.(*v1.ComponentStatus), err
 }
 
-func (c *FakeComponentStatuses) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.ComponentStatus, err error) {
+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 {
@@ -73,14 +72,14 @@ func (c *FakeComponentStatuses) Get(name string, options meta_v1.GetOptions) (re
 	return obj.(*v1.ComponentStatus), err
 }
 
-func (c *FakeComponentStatuses) List(opts meta_v1.ListOptions) (result *v1.ComponentStatusList, err error) {
+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, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -94,13 +93,13 @@ func (c *FakeComponentStatuses) List(opts meta_v1.ListOptions) (result *v1.Compo
 }
 
 // Watch returns a watch.Interface that watches the requested componentStatuses.
-func (c *FakeComponentStatuses) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.ComponentStatus, err error) {
+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 {

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var configmapsResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "configmaps"}
+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.
@@ -54,21 +53,21 @@ func (c *FakeConfigMaps) Update(configMap *v1.ConfigMap) (result *v1.ConfigMap,
 	return obj.(*v1.ConfigMap), err
 }
 
-func (c *FakeConfigMaps) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.ConfigMap, err error) {
+func (c *FakeConfigMaps) Get(name string) (result *v1.ConfigMap, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(configmapsResource, c.ns, name), &v1.ConfigMap{})
 
@@ -78,7 +77,7 @@ func (c *FakeConfigMaps) Get(name string, options meta_v1.GetOptions) (result *v
 	return obj.(*v1.ConfigMap), err
 }
 
-func (c *FakeConfigMaps) List(opts meta_v1.ListOptions) (result *v1.ConfigMapList, err error) {
+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{})
 
@@ -86,7 +85,7 @@ func (c *FakeConfigMaps) List(opts meta_v1.ListOptions) (result *v1.ConfigMapLis
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -100,14 +99,14 @@ func (c *FakeConfigMaps) List(opts meta_v1.ListOptions) (result *v1.ConfigMapLis
 }
 
 // Watch returns a watch.Interface that watches the requested configMaps.
-func (c *FakeConfigMaps) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.ConfigMap, err error) {
+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{})
 

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

@@ -0,0 +1,97 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT 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,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var endpointsResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "endpoints"}
+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.
@@ -54,21 +53,21 @@ func (c *FakeEndpoints) Update(endpoints *v1.Endpoints) (result *v1.Endpoints, e
 	return obj.(*v1.Endpoints), err
 }
 
-func (c *FakeEndpoints) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.Endpoints, err error) {
+func (c *FakeEndpoints) Get(name string) (result *v1.Endpoints, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(endpointsResource, c.ns, name), &v1.Endpoints{})
 
@@ -78,7 +77,7 @@ func (c *FakeEndpoints) Get(name string, options meta_v1.GetOptions) (result *v1
 	return obj.(*v1.Endpoints), err
 }
 
-func (c *FakeEndpoints) List(opts meta_v1.ListOptions) (result *v1.EndpointsList, err error) {
+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{})
 
@@ -86,7 +85,7 @@ func (c *FakeEndpoints) List(opts meta_v1.ListOptions) (result *v1.EndpointsList
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -100,14 +99,14 @@ func (c *FakeEndpoints) List(opts meta_v1.ListOptions) (result *v1.EndpointsList
 }
 
 // Watch returns a watch.Interface that watches the requested endpoints.
-func (c *FakeEndpoints) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.Endpoints, err error) {
+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{})
 

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var eventsResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "events"}
+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.
@@ -54,21 +53,21 @@ func (c *FakeEvents) Update(event *v1.Event) (result *v1.Event, err error) {
 	return obj.(*v1.Event), err
 }
 
-func (c *FakeEvents) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.Event, err error) {
+func (c *FakeEvents) Get(name string) (result *v1.Event, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(eventsResource, c.ns, name), &v1.Event{})
 
@@ -78,7 +77,7 @@ func (c *FakeEvents) Get(name string, options meta_v1.GetOptions) (result *v1.Ev
 	return obj.(*v1.Event), err
 }
 
-func (c *FakeEvents) List(opts meta_v1.ListOptions) (result *v1.EventList, err error) {
+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{})
 
@@ -86,7 +85,7 @@ func (c *FakeEvents) List(opts meta_v1.ListOptions) (result *v1.EventList, err e
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -100,14 +99,14 @@ func (c *FakeEvents) List(opts meta_v1.ListOptions) (result *v1.EventList, err e
 }
 
 // Watch returns a watch.Interface that watches the requested events.
-func (c *FakeEvents) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.Event, err error) {
+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{})
 

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

@@ -17,17 +17,17 @@ limitations under the License.
 package fake
 
 import (
-	"k8s.io/apimachinery/pkg/fields"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/client-go/pkg/api"
-	"k8s.io/client-go/pkg/api/v1"
-	core "k8s.io/client-go/testing"
+	"k8s.io/client-go/1.5/pkg/api"
+	"k8s.io/client-go/1.5/pkg/api/v1"
+	"k8s.io/client-go/1.5/pkg/fields"
+	"k8s.io/client-go/1.5/pkg/runtime"
+	"k8s.io/client-go/1.5/testing"
 )
 
 func (c *FakeEvents) CreateWithEventNamespace(event *v1.Event) (*v1.Event, error) {
-	action := core.NewRootCreateAction(eventsResource, event)
+	action := testing.NewRootCreateAction(eventsResource, event)
 	if c.ns != "" {
-		action = core.NewCreateAction(eventsResource, c.ns, event)
+		action = testing.NewCreateAction(eventsResource, c.ns, event)
 	}
 	obj, err := c.Fake.Invokes(action, event)
 	if obj == nil {
@@ -39,9 +39,9 @@ func (c *FakeEvents) CreateWithEventNamespace(event *v1.Event) (*v1.Event, error
 
 // Update replaces an existing event. Returns the copy of the event the server returns, or an error.
 func (c *FakeEvents) UpdateWithEventNamespace(event *v1.Event) (*v1.Event, error) {
-	action := core.NewRootUpdateAction(eventsResource, event)
+	action := testing.NewRootUpdateAction(eventsResource, event)
 	if c.ns != "" {
-		action = core.NewUpdateAction(eventsResource, c.ns, event)
+		action = testing.NewUpdateAction(eventsResource, c.ns, event)
 	}
 	obj, err := c.Fake.Invokes(action, event)
 	if obj == nil {
@@ -53,9 +53,9 @@ func (c *FakeEvents) UpdateWithEventNamespace(event *v1.Event) (*v1.Event, error
 
 // PatchWithEventNamespace patches an existing event. Returns the copy of the event the server returns, or an error.
 func (c *FakeEvents) PatchWithEventNamespace(event *v1.Event, data []byte) (*v1.Event, error) {
-	action := core.NewRootPatchAction(eventsResource, event.Name, data)
+	action := testing.NewRootPatchAction(eventsResource, event.Name, data)
 	if c.ns != "" {
-		action = core.NewPatchAction(eventsResource, c.ns, event.Name, data)
+		action = testing.NewPatchAction(eventsResource, c.ns, event.Name, data)
 	}
 	obj, err := c.Fake.Invokes(action, event)
 	if obj == nil {
@@ -66,10 +66,10 @@ func (c *FakeEvents) PatchWithEventNamespace(event *v1.Event, data []byte) (*v1.
 }
 
 // Search returns a list of events matching the specified object.
-func (c *FakeEvents) Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*v1.EventList, error) {
-	action := core.NewRootListAction(eventsResource, api.ListOptions{})
+func (c *FakeEvents) Search(objOrRef runtime.Object) (*v1.EventList, error) {
+	action := testing.NewRootListAction(eventsResource, api.ListOptions{})
 	if c.ns != "" {
-		action = core.NewListAction(eventsResource, c.ns, api.ListOptions{})
+		action = testing.NewListAction(eventsResource, c.ns, api.ListOptions{})
 	}
 	obj, err := c.Fake.Invokes(action, &v1.EventList{})
 	if obj == nil {
@@ -80,7 +80,7 @@ func (c *FakeEvents) Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*v
 }
 
 func (c *FakeEvents) GetFieldSelector(involvedObjectName, involvedObjectNamespace, involvedObjectKind, involvedObjectUID *string) fields.Selector {
-	action := core.GenericActionImpl{}
+	action := testing.GenericActionImpl{}
 	action.Verb = "get-field-selector"
 	action.Resource = eventsResource
 

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var limitrangesResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "limitranges"}
+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.
@@ -54,21 +53,21 @@ func (c *FakeLimitRanges) Update(limitRange *v1.LimitRange) (result *v1.LimitRan
 	return obj.(*v1.LimitRange), err
 }
 
-func (c *FakeLimitRanges) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.LimitRange, err error) {
+func (c *FakeLimitRanges) Get(name string) (result *v1.LimitRange, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(limitrangesResource, c.ns, name), &v1.LimitRange{})
 
@@ -78,7 +77,7 @@ func (c *FakeLimitRanges) Get(name string, options meta_v1.GetOptions) (result *
 	return obj.(*v1.LimitRange), err
 }
 
-func (c *FakeLimitRanges) List(opts meta_v1.ListOptions) (result *v1.LimitRangeList, err error) {
+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{})
 
@@ -86,7 +85,7 @@ func (c *FakeLimitRanges) List(opts meta_v1.ListOptions) (result *v1.LimitRangeL
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -100,14 +99,14 @@ func (c *FakeLimitRanges) List(opts meta_v1.ListOptions) (result *v1.LimitRangeL
 }
 
 // Watch returns a watch.Interface that watches the requested limitRanges.
-func (c *FakeLimitRanges) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.LimitRange, err error) {
+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{})
 

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,21 +17,20 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 }
 
-var namespacesResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "namespaces"}
+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.
@@ -60,20 +59,20 @@ func (c *FakeNamespaces) UpdateStatus(namespace *v1.Namespace) (*v1.Namespace, e
 	return obj.(*v1.Namespace), err
 }
 
-func (c *FakeNamespaces) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.Namespace, err error) {
+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 {
@@ -82,14 +81,14 @@ func (c *FakeNamespaces) Get(name string, options meta_v1.GetOptions) (result *v
 	return obj.(*v1.Namespace), err
 }
 
-func (c *FakeNamespaces) List(opts meta_v1.ListOptions) (result *v1.NamespaceList, err error) {
+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, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -103,13 +102,13 @@ func (c *FakeNamespaces) List(opts meta_v1.ListOptions) (result *v1.NamespaceLis
 }
 
 // Watch returns a watch.Interface that watches the requested namespaces.
-func (c *FakeNamespaces) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.Namespace, err error) {
+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 {

1.5/kubernetes/typed/core/v1/fake/fake_namespace_expansion.go

@@ -17,12 +17,12 @@ limitations under the License.
 package fake
 
 import (
-	"k8s.io/client-go/pkg/api/v1"
-	core "k8s.io/client-go/testing"
+	"k8s.io/client-go/1.5/pkg/api/v1"
+	"k8s.io/client-go/1.5/testing"
 )
 
 func (c *FakeNamespaces) Finalize(namespace *v1.Namespace) (*v1.Namespace, error) {
-	action := core.CreateActionImpl{}
+	action := testing.CreateActionImpl{}
 	action.Verb = "create"
 	action.Resource = namespacesResource
 	action.Subresource = "finalize"

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,21 +17,20 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 }
 
-var nodesResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "nodes"}
+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.
@@ -60,20 +59,20 @@ func (c *FakeNodes) UpdateStatus(node *v1.Node) (*v1.Node, error) {
 	return obj.(*v1.Node), err
 }
 
-func (c *FakeNodes) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.Node, err error) {
+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 {
@@ -82,14 +81,14 @@ func (c *FakeNodes) Get(name string, options meta_v1.GetOptions) (result *v1.Nod
 	return obj.(*v1.Node), err
 }
 
-func (c *FakeNodes) List(opts meta_v1.ListOptions) (result *v1.NodeList, err error) {
+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, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -103,13 +102,13 @@ func (c *FakeNodes) List(opts meta_v1.ListOptions) (result *v1.NodeList, err err
 }
 
 // Watch returns a watch.Interface that watches the requested nodes.
-func (c *FakeNodes) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.Node, err error) {
+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 {

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,21 +17,20 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 }
 
-var persistentvolumesResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "persistentvolumes"}
+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.
@@ -60,20 +59,20 @@ func (c *FakePersistentVolumes) UpdateStatus(persistentVolume *v1.PersistentVolu
 	return obj.(*v1.PersistentVolume), err
 }
 
-func (c *FakePersistentVolumes) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.PersistentVolume, err error) {
+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 {
@@ -82,14 +81,14 @@ func (c *FakePersistentVolumes) Get(name string, options meta_v1.GetOptions) (re
 	return obj.(*v1.PersistentVolume), err
 }
 
-func (c *FakePersistentVolumes) List(opts meta_v1.ListOptions) (result *v1.PersistentVolumeList, err error) {
+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, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -103,13 +102,13 @@ func (c *FakePersistentVolumes) List(opts meta_v1.ListOptions) (result *v1.Persi
 }
 
 // Watch returns a watch.Interface that watches the requested persistentVolumes.
-func (c *FakePersistentVolumes) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.PersistentVolume, err error) {
+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 {

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var persistentvolumeclaimsResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "persistentvolumeclaims"}
+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.
@@ -64,21 +63,21 @@ func (c *FakePersistentVolumeClaims) UpdateStatus(persistentVolumeClaim *v1.Pers
 	return obj.(*v1.PersistentVolumeClaim), err
 }
 
-func (c *FakePersistentVolumeClaims) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.PersistentVolumeClaim, err error) {
+func (c *FakePersistentVolumeClaims) Get(name string) (result *v1.PersistentVolumeClaim, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(persistentvolumeclaimsResource, c.ns, name), &v1.PersistentVolumeClaim{})
 
@@ -88,7 +87,7 @@ func (c *FakePersistentVolumeClaims) Get(name string, options meta_v1.GetOptions
 	return obj.(*v1.PersistentVolumeClaim), err
 }
 
-func (c *FakePersistentVolumeClaims) List(opts meta_v1.ListOptions) (result *v1.PersistentVolumeClaimList, err error) {
+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{})
 
@@ -96,7 +95,7 @@ func (c *FakePersistentVolumeClaims) List(opts meta_v1.ListOptions) (result *v1.
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -110,14 +109,14 @@ func (c *FakePersistentVolumeClaims) List(opts meta_v1.ListOptions) (result *v1.
 }
 
 // Watch returns a watch.Interface that watches the requested persistentVolumeClaims.
-func (c *FakePersistentVolumeClaims) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.PersistentVolumeClaim, err error) {
+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{})
 

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var podsResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}
+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.
@@ -64,21 +63,21 @@ func (c *FakePods) UpdateStatus(pod *v1.Pod) (*v1.Pod, error) {
 	return obj.(*v1.Pod), err
 }
 
-func (c *FakePods) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.Pod, err error) {
+func (c *FakePods) Get(name string) (result *v1.Pod, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(podsResource, c.ns, name), &v1.Pod{})
 
@@ -88,7 +87,7 @@ func (c *FakePods) Get(name string, options meta_v1.GetOptions) (result *v1.Pod,
 	return obj.(*v1.Pod), err
 }
 
-func (c *FakePods) List(opts meta_v1.ListOptions) (result *v1.PodList, err error) {
+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{})
 
@@ -96,7 +95,7 @@ func (c *FakePods) List(opts meta_v1.ListOptions) (result *v1.PodList, err error
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -110,14 +109,14 @@ func (c *FakePods) List(opts meta_v1.ListOptions) (result *v1.PodList, err error
 }
 
 // Watch returns a watch.Interface that watches the requested pods.
-func (c *FakePods) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.Pod, err error) {
+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{})
 

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

@@ -17,14 +17,14 @@ limitations under the License.
 package fake
 
 import (
-	"k8s.io/client-go/pkg/api/v1"
-	policy "k8s.io/client-go/pkg/apis/policy/v1beta1"
-	restclient "k8s.io/client-go/rest"
-	core "k8s.io/client-go/testing"
+	"k8s.io/client-go/1.5/pkg/api/v1"
+	"k8s.io/client-go/1.5/pkg/apis/policy/v1alpha1"
+	"k8s.io/client-go/1.5/rest"
+	"k8s.io/client-go/1.5/testing"
 )
 
 func (c *FakePods) Bind(binding *v1.Binding) error {
-	action := core.CreateActionImpl{}
+	action := testing.CreateActionImpl{}
 	action.Verb = "create"
 	action.Resource = podsResource
 	action.Subresource = "bindings"
@@ -34,8 +34,8 @@ func (c *FakePods) Bind(binding *v1.Binding) error {
 	return err
 }
 
-func (c *FakePods) GetLogs(name string, opts *v1.PodLogOptions) *restclient.Request {
-	action := core.GenericActionImpl{}
+func (c *FakePods) GetLogs(name string, opts *v1.PodLogOptions) *rest.Request {
+	action := testing.GenericActionImpl{}
 	action.Verb = "get"
 	action.Namespace = c.ns
 	action.Resource = podsResource
@@ -43,11 +43,11 @@ func (c *FakePods) GetLogs(name string, opts *v1.PodLogOptions) *restclient.Requ
 	action.Value = opts
 
 	_, _ = c.Fake.Invokes(action, &v1.Pod{})
-	return &restclient.Request{}
+	return &rest.Request{}
 }
 
-func (c *FakePods) Evict(eviction *policy.Eviction) error {
-	action := core.CreateActionImpl{}
+func (c *FakePods) Evict(eviction *v1alpha1.Eviction) error {
+	action := testing.CreateActionImpl{}
 	action.Verb = "create"
 	action.Resource = podsResource
 	action.Subresource = "eviction"

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var podtemplatesResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "podtemplates"}
+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.
@@ -54,21 +53,21 @@ func (c *FakePodTemplates) Update(podTemplate *v1.PodTemplate) (result *v1.PodTe
 	return obj.(*v1.PodTemplate), err
 }
 
-func (c *FakePodTemplates) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.PodTemplate, err error) {
+func (c *FakePodTemplates) Get(name string) (result *v1.PodTemplate, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(podtemplatesResource, c.ns, name), &v1.PodTemplate{})
 
@@ -78,7 +77,7 @@ func (c *FakePodTemplates) Get(name string, options meta_v1.GetOptions) (result
 	return obj.(*v1.PodTemplate), err
 }
 
-func (c *FakePodTemplates) List(opts meta_v1.ListOptions) (result *v1.PodTemplateList, err error) {
+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{})
 
@@ -86,7 +85,7 @@ func (c *FakePodTemplates) List(opts meta_v1.ListOptions) (result *v1.PodTemplat
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -100,14 +99,14 @@ func (c *FakePodTemplates) List(opts meta_v1.ListOptions) (result *v1.PodTemplat
 }
 
 // Watch returns a watch.Interface that watches the requested podTemplates.
-func (c *FakePodTemplates) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.PodTemplate, err error) {
+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{})
 

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var replicationcontrollersResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "replicationcontrollers"}
+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.
@@ -64,21 +63,21 @@ func (c *FakeReplicationControllers) UpdateStatus(replicationController *v1.Repl
 	return obj.(*v1.ReplicationController), err
 }
 
-func (c *FakeReplicationControllers) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.ReplicationController, err error) {
+func (c *FakeReplicationControllers) Get(name string) (result *v1.ReplicationController, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(replicationcontrollersResource, c.ns, name), &v1.ReplicationController{})
 
@@ -88,7 +87,7 @@ func (c *FakeReplicationControllers) Get(name string, options meta_v1.GetOptions
 	return obj.(*v1.ReplicationController), err
 }
 
-func (c *FakeReplicationControllers) List(opts meta_v1.ListOptions) (result *v1.ReplicationControllerList, err error) {
+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{})
 
@@ -96,7 +95,7 @@ func (c *FakeReplicationControllers) List(opts meta_v1.ListOptions) (result *v1.
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -110,14 +109,14 @@ func (c *FakeReplicationControllers) List(opts meta_v1.ListOptions) (result *v1.
 }
 
 // Watch returns a watch.Interface that watches the requested replicationControllers.
-func (c *FakeReplicationControllers) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.ReplicationController, err error) {
+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{})
 

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var resourcequotasResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "resourcequotas"}
+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.
@@ -64,21 +63,21 @@ func (c *FakeResourceQuotas) UpdateStatus(resourceQuota *v1.ResourceQuota) (*v1.
 	return obj.(*v1.ResourceQuota), err
 }
 
-func (c *FakeResourceQuotas) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.ResourceQuota, err error) {
+func (c *FakeResourceQuotas) Get(name string) (result *v1.ResourceQuota, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(resourcequotasResource, c.ns, name), &v1.ResourceQuota{})
 
@@ -88,7 +87,7 @@ func (c *FakeResourceQuotas) Get(name string, options meta_v1.GetOptions) (resul
 	return obj.(*v1.ResourceQuota), err
 }
 
-func (c *FakeResourceQuotas) List(opts meta_v1.ListOptions) (result *v1.ResourceQuotaList, err error) {
+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{})
 
@@ -96,7 +95,7 @@ func (c *FakeResourceQuotas) List(opts meta_v1.ListOptions) (result *v1.Resource
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -110,14 +109,14 @@ func (c *FakeResourceQuotas) List(opts meta_v1.ListOptions) (result *v1.Resource
 }
 
 // Watch returns a watch.Interface that watches the requested resourceQuotas.
-func (c *FakeResourceQuotas) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.ResourceQuota, err error) {
+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{})
 

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var secretsResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "secrets"}
+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.
@@ -54,21 +53,21 @@ func (c *FakeSecrets) Update(secret *v1.Secret) (result *v1.Secret, err error) {
 	return obj.(*v1.Secret), err
 }
 
-func (c *FakeSecrets) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.Secret, err error) {
+func (c *FakeSecrets) Get(name string) (result *v1.Secret, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(secretsResource, c.ns, name), &v1.Secret{})
 
@@ -78,7 +77,7 @@ func (c *FakeSecrets) Get(name string, options meta_v1.GetOptions) (result *v1.S
 	return obj.(*v1.Secret), err
 }
 
-func (c *FakeSecrets) List(opts meta_v1.ListOptions) (result *v1.SecretList, err error) {
+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{})
 
@@ -86,7 +85,7 @@ func (c *FakeSecrets) List(opts meta_v1.ListOptions) (result *v1.SecretList, err
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -100,14 +99,14 @@ func (c *FakeSecrets) List(opts meta_v1.ListOptions) (result *v1.SecretList, err
 }
 
 // Watch returns a watch.Interface that watches the requested secrets.
-func (c *FakeSecrets) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.Secret, err error) {
+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{})
 

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var servicesResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "services"}
+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.
@@ -64,21 +63,21 @@ func (c *FakeServices) UpdateStatus(service *v1.Service) (*v1.Service, error) {
 	return obj.(*v1.Service), err
 }
 
-func (c *FakeServices) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.Service, err error) {
+func (c *FakeServices) Get(name string) (result *v1.Service, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(servicesResource, c.ns, name), &v1.Service{})
 
@@ -88,7 +87,7 @@ func (c *FakeServices) Get(name string, options meta_v1.GetOptions) (result *v1.
 	return obj.(*v1.Service), err
 }
 
-func (c *FakeServices) List(opts meta_v1.ListOptions) (result *v1.ServiceList, err error) {
+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{})
 
@@ -96,7 +95,7 @@ func (c *FakeServices) List(opts meta_v1.ListOptions) (result *v1.ServiceList, e
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -110,14 +109,14 @@ func (c *FakeServices) List(opts meta_v1.ListOptions) (result *v1.ServiceList, e
 }
 
 // Watch returns a watch.Interface that watches the requested services.
-func (c *FakeServices) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.Service, err error) {
+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{})
 

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

@@ -17,10 +17,10 @@ limitations under the License.
 package fake
 
 import (
-	restclient "k8s.io/client-go/rest"
-	core "k8s.io/client-go/testing"
+	"k8s.io/client-go/1.5/rest"
+	"k8s.io/client-go/1.5/testing"
 )
 
-func (c *FakeServices) ProxyGet(scheme, name, port, path string, params map[string]string) restclient.ResponseWrapper {
-	return c.Fake.InvokesProxy(core.NewProxyGetAction(servicesResource, c.ns, scheme, name, port, path, params))
+func (c *FakeServices) ProxyGet(scheme, name, port, path string, params map[string]string) rest.ResponseWrapper {
+	return c.Fake.InvokesProxy(testing.NewProxyGetAction(servicesResource, c.ns, scheme, name, port, path, params))
 }

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,22 +17,21 @@ limitations under the License.
 package fake
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	testing "k8s.io/client-go/testing"
+	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 *FakeCoreV1
+	Fake *FakeCore
 	ns   string
 }
 
-var serviceaccountsResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "serviceaccounts"}
+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.
@@ -54,21 +53,21 @@ func (c *FakeServiceAccounts) Update(serviceAccount *v1.ServiceAccount) (result
 	return obj.(*v1.ServiceAccount), err
 }
 
-func (c *FakeServiceAccounts) Delete(name string, options *meta_v1.DeleteOptions) error {
+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 *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+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, options meta_v1.GetOptions) (result *v1.ServiceAccount, err error) {
+func (c *FakeServiceAccounts) Get(name string) (result *v1.ServiceAccount, err error) {
 	obj, err := c.Fake.
 		Invokes(testing.NewGetAction(serviceaccountsResource, c.ns, name), &v1.ServiceAccount{})
 
@@ -78,7 +77,7 @@ func (c *FakeServiceAccounts) Get(name string, options meta_v1.GetOptions) (resu
 	return obj.(*v1.ServiceAccount), err
 }
 
-func (c *FakeServiceAccounts) List(opts meta_v1.ListOptions) (result *v1.ServiceAccountList, err error) {
+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{})
 
@@ -86,7 +85,7 @@ func (c *FakeServiceAccounts) List(opts meta_v1.ListOptions) (result *v1.Service
 		return nil, err
 	}
 
-	label, _, _ := testing.ExtractFromListOptions(opts)
+	label := opts.LabelSelector
 	if label == nil {
 		label = labels.Everything()
 	}
@@ -100,14 +99,14 @@ func (c *FakeServiceAccounts) List(opts meta_v1.ListOptions) (result *v1.Service
 }
 
 // Watch returns a watch.Interface that watches the requested serviceAccounts.
-func (c *FakeServiceAccounts) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
+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 types.PatchType, data []byte, subresources ...string) (result *v1.ServiceAccount, err error) {
+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{})
 

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -24,6 +24,8 @@ type EndpointsExpansion interface{}
 
 type LimitRangeExpansion interface{}
 
+type NodeExpansion interface{}
+
 type PersistentVolumeExpansion interface{}
 
 type PersistentVolumeClaimExpansion interface{}

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,12 +17,9 @@ limitations under the License.
 package v1
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	rest "k8s.io/client-go/rest"
+	api "k8s.io/client-go/1.5/pkg/api"
+	v1 "k8s.io/client-go/1.5/pkg/api/v1"
+	watch "k8s.io/client-go/1.5/pkg/watch"
 )
 
 // LimitRangesGetter has a method to return a LimitRangeInterface.
@@ -35,25 +32,25 @@ type LimitRangesGetter interface {
 type LimitRangeInterface interface {
 	Create(*v1.LimitRange) (*v1.LimitRange, error)
 	Update(*v1.LimitRange) (*v1.LimitRange, error)
-	Delete(name string, options *meta_v1.DeleteOptions) error
-	DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error
-	Get(name string, options meta_v1.GetOptions) (*v1.LimitRange, error)
-	List(opts meta_v1.ListOptions) (*v1.LimitRangeList, error)
-	Watch(opts meta_v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.LimitRange, err error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.LimitRange, error)
+	List(opts api.ListOptions) (*v1.LimitRangeList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.LimitRange, err error)
 	LimitRangeExpansion
 }
 
 // limitRanges implements LimitRangeInterface
 type limitRanges struct {
-	client rest.Interface
+	client *CoreClient
 	ns     string
 }
 
 // newLimitRanges returns a LimitRanges
-func newLimitRanges(c *CoreV1Client, namespace string) *limitRanges {
+func newLimitRanges(c *CoreClient, namespace string) *limitRanges {
 	return &limitRanges{
-		client: c.RESTClient(),
+		client: c,
 		ns:     namespace,
 	}
 }
@@ -84,7 +81,7 @@ func (c *limitRanges) Update(limitRange *v1.LimitRange) (result *v1.LimitRange,
 }
 
 // Delete takes name of the limitRange and deletes it. Returns an error if one occurs.
-func (c *limitRanges) Delete(name string, options *meta_v1.DeleteOptions) error {
+func (c *limitRanges) Delete(name string, options *api.DeleteOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("limitranges").
@@ -95,53 +92,52 @@ func (c *limitRanges) Delete(name string, options *meta_v1.DeleteOptions) error
 }
 
 // DeleteCollection deletes a collection of objects.
-func (c *limitRanges) DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+func (c *limitRanges) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
 	return c.client.Delete().
 		Namespace(c.ns).
 		Resource("limitranges").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
+		VersionedParams(&listOptions, api.ParameterCodec).
 		Body(options).
 		Do().
 		Error()
 }
 
 // Get takes name of the limitRange, and returns the corresponding limitRange object, and an error if there is any.
-func (c *limitRanges) Get(name string, options meta_v1.GetOptions) (result *v1.LimitRange, err error) {
+func (c *limitRanges) Get(name string) (result *v1.LimitRange, err error) {
 	result = &v1.LimitRange{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("limitranges").
 		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // List takes label and field selectors, and returns the list of LimitRanges that match those selectors.
-func (c *limitRanges) List(opts meta_v1.ListOptions) (result *v1.LimitRangeList, err error) {
+func (c *limitRanges) List(opts api.ListOptions) (result *v1.LimitRangeList, err error) {
 	result = &v1.LimitRangeList{}
 	err = c.client.Get().
 		Namespace(c.ns).
 		Resource("limitranges").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // Watch returns a watch.Interface that watches the requested limitRanges.
-func (c *limitRanges) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
-	opts.Watch = true
+func (c *limitRanges) Watch(opts api.ListOptions) (watch.Interface, error) {
 	return c.client.Get().
+		Prefix("watch").
 		Namespace(c.ns).
 		Resource("limitranges").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Watch()
 }
 
 // Patch applies the patch and returns the patched limitRange.
-func (c *limitRanges) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.LimitRange, err error) {
+func (c *limitRanges) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.LimitRange, err error) {
 	result = &v1.LimitRange{}
 	err = c.client.Patch(pt).
 		Namespace(c.ns).

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

@@ -1,5 +1,5 @@
 /*
-Copyright 2017 The Kubernetes Authors.
+Copyright 2016 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,12 +17,9 @@ limitations under the License.
 package v1
 
 import (
-	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	v1 "k8s.io/client-go/pkg/api/v1"
-	rest "k8s.io/client-go/rest"
+	api "k8s.io/client-go/1.5/pkg/api"
+	v1 "k8s.io/client-go/1.5/pkg/api/v1"
+	watch "k8s.io/client-go/1.5/pkg/watch"
 )
 
 // NamespacesGetter has a method to return a NamespaceInterface.
@@ -36,24 +33,24 @@ type NamespaceInterface interface {
 	Create(*v1.Namespace) (*v1.Namespace, error)
 	Update(*v1.Namespace) (*v1.Namespace, error)
 	UpdateStatus(*v1.Namespace) (*v1.Namespace, error)
-	Delete(name string, options *meta_v1.DeleteOptions) error
-	DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error
-	Get(name string, options meta_v1.GetOptions) (*v1.Namespace, error)
-	List(opts meta_v1.ListOptions) (*v1.NamespaceList, error)
-	Watch(opts meta_v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.Namespace, err error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*v1.Namespace, error)
+	List(opts api.ListOptions) (*v1.NamespaceList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Namespace, err error)
 	NamespaceExpansion
 }
 
 // namespaces implements NamespaceInterface
 type namespaces struct {
-	client rest.Interface
+	client *CoreClient
 }
 
 // newNamespaces returns a Namespaces
-func newNamespaces(c *CoreV1Client) *namespaces {
+func newNamespaces(c *CoreClient) *namespaces {
 	return &namespaces{
-		client: c.RESTClient(),
+		client: c,
 	}
 }
 
@@ -80,9 +77,6 @@ func (c *namespaces) Update(namespace *v1.Namespace) (result *v1.Namespace, err
 	return
 }
 
-// UpdateStatus was generated because the type contains a Status member.
-// Add a +genclientstatus=false comment above the type to avoid generating UpdateStatus().
-
 func (c *namespaces) UpdateStatus(namespace *v1.Namespace) (result *v1.Namespace, err error) {
 	result = &v1.Namespace{}
 	err = c.client.Put().
@@ -96,7 +90,7 @@ func (c *namespaces) UpdateStatus(namespace *v1.Namespace) (result *v1.Namespace
 }
 
 // Delete takes name of the namespace and deletes it. Returns an error if one occurs.
-func (c *namespaces) Delete(name string, options *meta_v1.DeleteOptions) error {
+func (c *namespaces) Delete(name string, options *api.DeleteOptions) error {
 	return c.client.Delete().
 		Resource("namespaces").
 		Name(name).
@@ -106,49 +100,48 @@ func (c *namespaces) Delete(name string, options *meta_v1.DeleteOptions) error {
 }
 
 // DeleteCollection deletes a collection of objects.
-func (c *namespaces) DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
+func (c *namespaces) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
 	return c.client.Delete().
 		Resource("namespaces").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
+		VersionedParams(&listOptions, api.ParameterCodec).
 		Body(options).
 		Do().
 		Error()
 }
 
 // Get takes name of the namespace, and returns the corresponding namespace object, and an error if there is any.
-func (c *namespaces) Get(name string, options meta_v1.GetOptions) (result *v1.Namespace, err error) {
+func (c *namespaces) Get(name string) (result *v1.Namespace, err error) {
 	result = &v1.Namespace{}
 	err = c.client.Get().
 		Resource("namespaces").
 		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // List takes label and field selectors, and returns the list of Namespaces that match those selectors.
-func (c *namespaces) List(opts meta_v1.ListOptions) (result *v1.NamespaceList, err error) {
+func (c *namespaces) List(opts api.ListOptions) (result *v1.NamespaceList, err error) {
 	result = &v1.NamespaceList{}
 	err = c.client.Get().
 		Resource("namespaces").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Do().
 		Into(result)
 	return
 }
 
 // Watch returns a watch.Interface that watches the requested namespaces.
-func (c *namespaces) Watch(opts meta_v1.ListOptions) (watch.Interface, error) {
-	opts.Watch = true
+func (c *namespaces) Watch(opts api.ListOptions) (watch.Interface, error) {
 	return c.client.Get().
+		Prefix("watch").
 		Resource("namespaces").
-		VersionedParams(&opts, scheme.ParameterCodec).
+		VersionedParams(&opts, api.ParameterCodec).
 		Watch()
 }
 
 // Patch applies the patch and returns the patched namespace.
-func (c *namespaces) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.Namespace, err error) {
+func (c *namespaces) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1.Namespace, err error) {
 	result = &v1.Namespace{}
 	err = c.client.Patch(pt).
 		Resource("namespaces").