remove useless go moudle

Signed-off-by: hongming <talonwan@yunify.com>

vendor/k8s.io/kubectl/LICENSE

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

vendor/k8s.io/kubectl/pkg/util/openapi/OWNERS

@@ -1,6 +0,0 @@
-# See the OWNERS docs at https://go.k8s.io/owners
-
-approvers:
-- apelisse
-reviewers:
-- apelisse

vendor/k8s.io/kubectl/pkg/util/openapi/doc.go

@@ -1,21 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 openapi is a collection of libraries for fetching the openapi spec
-// from a Kubernetes server and then indexing the type definitions.
-// The openapi spec contains the object model definitions and extensions metadata
-// such as the patchStrategy and patchMergeKey for creating patches.
-package openapi // k8s.io/kubectl/pkg/util/openapi

vendor/k8s.io/kubectl/pkg/util/openapi/dryrun.go

@@ -1,65 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 openapi
-
-import (
-	"errors"
-
-	openapi_v2 "github.com/googleapis/gnostic/OpenAPIv2"
-	yaml "gopkg.in/yaml.v2"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-func hasGVKExtension(extensions []*openapi_v2.NamedAny, gvk schema.GroupVersionKind) bool {
-	for _, extension := range extensions {
-		if extension.GetValue().GetYaml() == "" ||
-			extension.GetName() != "x-kubernetes-group-version-kind" {
-			continue
-		}
-		var value map[string]string
-		err := yaml.Unmarshal([]byte(extension.GetValue().GetYaml()), &value)
-		if err != nil {
-			continue
-		}
-
-		if value["group"] == gvk.Group && value["kind"] == gvk.Kind && value["version"] == gvk.Version {
-			return true
-		}
-		return false
-	}
-	return false
-}
-
-// SupportsDryRun is a method that let's us look in the OpenAPI if the
-// specific group-version-kind supports the dryRun query parameter for
-// the PATCH end-point.
-func SupportsDryRun(doc *openapi_v2.Document, gvk schema.GroupVersionKind) (bool, error) {
-	for _, path := range doc.GetPaths().GetPath() {
-		// Is this describing the gvk we're looking for?
-		if !hasGVKExtension(path.GetValue().GetPatch().GetVendorExtension(), gvk) {
-			continue
-		}
-		for _, param := range path.GetValue().GetPatch().GetParameters() {
-			if param.GetParameter().GetNonBodyParameter().GetQueryParameterSubSchema().GetName() == "dryRun" {
-				return true, nil
-			}
-		}
-		return false, nil
-	}
-
-	return false, errors.New("couldn't find GVK in openapi")
-}

vendor/k8s.io/kubectl/pkg/util/openapi/extensions.go

@@ -1,27 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 openapi
-
-import "github.com/go-openapi/spec"
-
-// PrintColumnsKey is the key that defines which columns should be printed
-const PrintColumnsKey = "x-kubernetes-print-columns"
-
-// GetPrintColumns looks for the open API extension for the display columns.
-func GetPrintColumns(extensions spec.Extensions) (string, bool) {
-	return extensions.GetString(PrintColumnsKey)
-}

vendor/k8s.io/kubectl/pkg/util/openapi/openapi.go

@@ -1,128 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 openapi
-
-import (
-	openapi_v2 "github.com/googleapis/gnostic/OpenAPIv2"
-
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/kube-openapi/pkg/util/proto"
-)
-
-// Resources interface describe a resources provider, that can give you
-// resource based on group-version-kind.
-type Resources interface {
-	LookupResource(gvk schema.GroupVersionKind) proto.Schema
-}
-
-// groupVersionKindExtensionKey is the key used to lookup the
-// GroupVersionKind value for an object definition from the
-// definition's "extensions" map.
-const groupVersionKindExtensionKey = "x-kubernetes-group-version-kind"
-
-// document is an implementation of `Resources`. It looks for
-// resources in an openapi Schema.
-type document struct {
-	// Maps gvk to model name
-	resources map[schema.GroupVersionKind]string
-	models    proto.Models
-}
-
-var _ Resources = &document{}
-
-// NewOpenAPIData creates a new `Resources` out of the openapi document
-func NewOpenAPIData(doc *openapi_v2.Document) (Resources, error) {
-	models, err := proto.NewOpenAPIData(doc)
-	if err != nil {
-		return nil, err
-	}
-
-	resources := map[schema.GroupVersionKind]string{}
-	for _, modelName := range models.ListModels() {
-		model := models.LookupModel(modelName)
-		if model == nil {
-			panic("ListModels returns a model that can't be looked-up.")
-		}
-		gvkList := parseGroupVersionKind(model)
-		for _, gvk := range gvkList {
-			if len(gvk.Kind) > 0 {
-				resources[gvk] = modelName
-			}
-		}
-	}
-
-	return &document{
-		resources: resources,
-		models:    models,
-	}, nil
-}
-
-func (d *document) LookupResource(gvk schema.GroupVersionKind) proto.Schema {
-	modelName, found := d.resources[gvk]
-	if !found {
-		return nil
-	}
-	return d.models.LookupModel(modelName)
-}
-
-// Get and parse GroupVersionKind from the extension. Returns empty if it doesn't have one.
-func parseGroupVersionKind(s proto.Schema) []schema.GroupVersionKind {
-	extensions := s.GetExtensions()
-
-	gvkListResult := []schema.GroupVersionKind{}
-
-	// Get the extensions
-	gvkExtension, ok := extensions[groupVersionKindExtensionKey]
-	if !ok {
-		return []schema.GroupVersionKind{}
-	}
-
-	// gvk extension must be a list of at least 1 element.
-	gvkList, ok := gvkExtension.([]interface{})
-	if !ok {
-		return []schema.GroupVersionKind{}
-	}
-
-	for _, gvk := range gvkList {
-		// gvk extension list must be a map with group, version, and
-		// kind fields
-		gvkMap, ok := gvk.(map[interface{}]interface{})
-		if !ok {
-			continue
-		}
-		group, ok := gvkMap["group"].(string)
-		if !ok {
-			continue
-		}
-		version, ok := gvkMap["version"].(string)
-		if !ok {
-			continue
-		}
-		kind, ok := gvkMap["kind"].(string)
-		if !ok {
-			continue
-		}
-
-		gvkListResult = append(gvkListResult, schema.GroupVersionKind{
-			Group:   group,
-			Version: version,
-			Kind:    kind,
-		})
-	}
-
-	return gvkListResult
-}

vendor/k8s.io/kubectl/pkg/util/openapi/openapi_getter.go

@@ -1,65 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 openapi
-
-import (
-	"sync"
-
-	"k8s.io/client-go/discovery"
-)
-
-// synchronizedOpenAPIGetter fetches the openapi schema once and then caches it in memory
-type synchronizedOpenAPIGetter struct {
-	// Cached results
-	sync.Once
-	openAPISchema Resources
-	err           error
-
-	openAPIClient discovery.OpenAPISchemaInterface
-}
-
-var _ Getter = &synchronizedOpenAPIGetter{}
-
-// Getter is an interface for fetching openapi specs and parsing them into an Resources struct
-type Getter interface {
-	// OpenAPIData returns the parsed OpenAPIData
-	Get() (Resources, error)
-}
-
-// NewOpenAPIGetter returns an object to return OpenAPIDatas which reads
-// from a server, and then stores in memory for subsequent invocations
-func NewOpenAPIGetter(openAPIClient discovery.OpenAPISchemaInterface) Getter {
-	return &synchronizedOpenAPIGetter{
-		openAPIClient: openAPIClient,
-	}
-}
-
-// Resources implements Getter
-func (g *synchronizedOpenAPIGetter) Get() (Resources, error) {
-	g.Do(func() {
-		s, err := g.openAPIClient.OpenAPISchema()
-		if err != nil {
-			g.err = err
-			return
-		}
-
-		g.openAPISchema, g.err = NewOpenAPIData(s)
-	})
-
-	// Return the save result
-	return g.openAPISchema, g.err
-}

vendor/modules.txt

@@ -1368,8 +1368,6 @@ k8s.io/kube-openapi/pkg/schemaconv
 k8s.io/kube-openapi/pkg/util
 k8s.io/kube-openapi/pkg/util/proto
 k8s.io/kube-openapi/pkg/util/sets
-# k8s.io/kubectl v0.17.3 => k8s.io/kubectl v0.17.3
-k8s.io/kubectl/pkg/util/openapi
 # k8s.io/utils v0.0.0-20191114184206-e782cd3c129f => k8s.io/utils v0.0.0-20191114184206-e782cd3c129f
 k8s.io/utils/buffer
 k8s.io/utils/integer
@@ -1444,7 +1442,6 @@ sigs.k8s.io/controller-tools/pkg/webhook
 # sigs.k8s.io/kubefed v0.2.0-alpha.1 => sigs.k8s.io/kubefed v0.2.0-alpha.1
 sigs.k8s.io/kubefed/pkg/apis
 sigs.k8s.io/kubefed/pkg/apis/core/common
-sigs.k8s.io/kubefed/pkg/apis/core/typeconfig
 sigs.k8s.io/kubefed/pkg/apis/core/v1alpha1
 sigs.k8s.io/kubefed/pkg/apis/core/v1beta1
 sigs.k8s.io/kubefed/pkg/apis/multiclusterdns/v1alpha1
@@ -1452,13 +1449,8 @@ sigs.k8s.io/kubefed/pkg/apis/scheduling/v1alpha1
 sigs.k8s.io/kubefed/pkg/client/generic
 sigs.k8s.io/kubefed/pkg/client/generic/scheme
 sigs.k8s.io/kubefed/pkg/controller/util
-sigs.k8s.io/kubefed/pkg/kubefedctl
-sigs.k8s.io/kubefed/pkg/kubefedctl/enable
-sigs.k8s.io/kubefed/pkg/kubefedctl/federate
 sigs.k8s.io/kubefed/pkg/kubefedctl/options
-sigs.k8s.io/kubefed/pkg/kubefedctl/orphaning
 sigs.k8s.io/kubefed/pkg/kubefedctl/util
-sigs.k8s.io/kubefed/pkg/version
 # sigs.k8s.io/structured-merge-diff v0.0.0-20190817042607-6149e4549fca => sigs.k8s.io/structured-merge-diff v0.0.0-20190817042607-6149e4549fca
 sigs.k8s.io/structured-merge-diff/fieldpath
 sigs.k8s.io/structured-merge-diff/merge

vendor/sigs.k8s.io/kubefed/pkg/apis/core/typeconfig/interface.go

@@ -1,34 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 typeconfig
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// Interface defines how to interact with a FederatedTypeConfig
-type Interface interface {
-	GetObjectMeta() metav1.ObjectMeta
-	GetTargetType() metav1.APIResource
-	GetNamespaced() bool
-	GetPropagationEnabled() bool
-	GetFederatedType() metav1.APIResource
-	GetStatusType() *metav1.APIResource
-	GetStatusEnabled() bool
-	GetFederatedNamespaced() bool
-	IsNamespace() bool
-}

vendor/sigs.k8s.io/kubefed/pkg/apis/core/typeconfig/util.go

@@ -1,39 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 typeconfig
-
-import (
-	"fmt"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// GroupQualifiedName returns the plural name of the api resource
-// optionally qualified by its group:
-//
-//   '<target plural name>[.<target group name>]'
-//
-// This is the naming scheme for FederatedTypeConfig resources.  The
-// scheme ensures that, for a given KubeFed control plane,
-// federation of a target type will be configured by at most one
-// FederatedTypeConfig.
-func GroupQualifiedName(apiResource metav1.APIResource) string {
-	if len(apiResource.Group) == 0 {
-		return apiResource.Name
-	}
-	return fmt.Sprintf("%s.%s", apiResource.Name, apiResource.Group)
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/disable.go

@@ -1,378 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 kubefedctl
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-	"time"
-
-	"github.com/pkg/errors"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
-	apiextv1b1client "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/wait"
-	"k8s.io/client-go/rest"
-	"k8s.io/klog"
-
-	"sigs.k8s.io/kubefed/pkg/apis/core/typeconfig"
-	fedv1b1 "sigs.k8s.io/kubefed/pkg/apis/core/v1beta1"
-	genericclient "sigs.k8s.io/kubefed/pkg/client/generic"
-	ctlutil "sigs.k8s.io/kubefed/pkg/controller/util"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/enable"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/options"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/util"
-)
-
-const (
-	federatedGroupUsage = "The name of the API group to use for deleting the federated CRD type when the federated type config does not exist. Only used with --delete-crd."
-	targetVersionUsage  = "The API version of the target type to use for deletion of the federated CRD type when the federated type config does not exist. Only used with --delete-crd."
-)
-
-var (
-	disable_long = `
-		Disables propagation of a Kubernetes API type.  This command
-		can also optionally delete the API resources added by the enable
-		command.
-
-		Current context is assumed to be a Kubernetes cluster hosting
-		the kubefed control plane. Please use the
-		--host-cluster-context flag otherwise.`
-
-	disable_example = `
-		# Disable propagation of the kubernetes API type 'Deployment', named
-		in FederatedTypeConfig as 'deployments.apps'
-		kubefedctl disable deployments.apps
-
-		# Disable propagation of the kubernetes API type 'Deployment', named
-		in FederatedTypeConfig as 'deployments.apps', and delete the
-		corresponding Federated API resource
-		kubefedctl disable deployments.apps --delete-crd`
-)
-
-type disableType struct {
-	options.GlobalSubcommandOptions
-	options.CommonEnableOptions
-	disableTypeOptions
-}
-
-type disableTypeOptions struct {
-	deleteCRD           bool
-	enableTypeDirective *enable.EnableTypeDirective
-}
-
-// Bind adds the disable specific arguments to the flagset passed in as an
-// argument.
-func (o *disableTypeOptions) Bind(flags *pflag.FlagSet) {
-	flags.BoolVar(&o.deleteCRD, "delete-crd", false, "Whether to remove the API resource added by 'enable'.")
-}
-
-// NewCmdTypeDisable defines the `disable` command that
-// disables federation of a Kubernetes API type.
-func NewCmdTypeDisable(cmdOut io.Writer, config util.FedConfig) *cobra.Command {
-	opts := &disableType{}
-
-	cmd := &cobra.Command{
-		Use:     "disable NAME",
-		Short:   "Disables propagation of a Kubernetes API type",
-		Long:    disable_long,
-		Example: disable_example,
-		Run: func(cmd *cobra.Command, args []string) {
-			err := opts.Complete(args)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-
-			err = opts.Run(cmdOut, config)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-		},
-	}
-
-	flags := cmd.Flags()
-	opts.GlobalSubcommandBind(flags)
-	opts.CommonSubcommandBind(flags, federatedGroupUsage, targetVersionUsage)
-	opts.Bind(flags)
-
-	return cmd
-}
-
-// Complete ensures that options are valid and marshals them if necessary.
-func (j *disableType) Complete(args []string) error {
-	j.enableTypeDirective = enable.NewEnableTypeDirective()
-	directive := j.enableTypeDirective
-
-	if err := j.SetName(args); err != nil {
-		return err
-	}
-
-	if !j.deleteCRD {
-		if len(j.TargetVersion) > 0 {
-			return errors.New("--version flag valid only with --delete-crd")
-		} else if j.FederatedGroup != options.DefaultFederatedGroup {
-			return errors.New("--kubefed-group flag valid only with --delete-crd")
-		}
-	}
-
-	if len(j.TargetVersion) > 0 {
-		directive.Spec.TargetVersion = j.TargetVersion
-	}
-	if len(j.FederatedGroup) > 0 {
-		directive.Spec.FederatedGroup = j.FederatedGroup
-	}
-
-	return nil
-}
-
-// Run is the implementation of the `disable` command.
-func (j *disableType) Run(cmdOut io.Writer, config util.FedConfig) error {
-	hostConfig, err := config.HostConfig(j.HostClusterContext, j.Kubeconfig)
-	if err != nil {
-		return errors.Wrap(err, "Failed to get host cluster config")
-	}
-
-	// If . is specified, the target name is assumed as a group qualified name.
-	// In such case, ignore the lookup to make sure deletion of a federatedtypeconfig
-	// for which the corresponding target has been removed.
-	name := j.TargetName
-	if !strings.Contains(j.TargetName, ".") {
-		apiResource, err := enable.LookupAPIResource(hostConfig, j.TargetName, "")
-		if err != nil {
-			return err
-		}
-		name = typeconfig.GroupQualifiedName(*apiResource)
-	}
-
-	typeConfigName := ctlutil.QualifiedName{
-		Namespace: j.KubeFedNamespace,
-		Name:      name,
-	}
-	j.enableTypeDirective.Name = typeConfigName.Name
-	return DisableFederation(cmdOut, hostConfig, j.enableTypeDirective, typeConfigName, j.deleteCRD, j.DryRun, true)
-}
-
-func DisableFederation(cmdOut io.Writer, config *rest.Config, enableTypeDirective *enable.EnableTypeDirective,
-	typeConfigName ctlutil.QualifiedName, deleteCRD, dryRun, verifyStopped bool) error {
-	client, err := genericclient.New(config)
-	if err != nil {
-		return errors.Wrap(err, "Failed to get kubefed clientset")
-	}
-
-	write := func(data string) {
-		if cmdOut == nil {
-			return
-		}
-
-		if _, err := cmdOut.Write([]byte(data)); err != nil {
-			klog.Fatalf("Unexpected err: %v\n", err)
-		}
-	}
-
-	typeConfig := &fedv1b1.FederatedTypeConfig{}
-	ftcExists, err := checkFederatedTypeConfigExists(client, typeConfig, typeConfigName, write)
-	if err != nil {
-		return err
-	}
-
-	if dryRun {
-		return nil
-	}
-
-	// Disable propagation and verify it is stopped before deleting the CRD
-	// when no custom resources exist. This avoids spurious error messages in
-	// the controller manager log as watches are terminated and cannot be
-	// reestablished.
-	if ftcExists {
-		if deleteCRD {
-			err = checkFederatedTypeCustomResourcesExist(config, typeConfig, write)
-			if err != nil {
-				return err
-			}
-		}
-		if typeConfig.GetPropagationEnabled() {
-			err = disablePropagation(client, typeConfig, typeConfigName, write)
-			if err != nil {
-				return err
-			}
-		}
-		if verifyStopped {
-			err = verifyPropagationControllerStopped(client, typeConfigName, write)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	if deleteCRD {
-		if !ftcExists {
-			typeConfig, err = generatedFederatedTypeConfig(config, enableTypeDirective)
-			if err != nil {
-				return err
-			}
-		}
-		err = deleteFederatedType(config, typeConfig, write)
-		if err != nil {
-			return err
-		}
-	}
-
-	if ftcExists {
-		err = deleteFederatedTypeConfig(client, typeConfig, typeConfigName, write)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func checkFederatedTypeConfigExists(client genericclient.Client, typeConfig *fedv1b1.FederatedTypeConfig, typeConfigName ctlutil.QualifiedName, write func(string)) (bool, error) {
-	err := client.Get(context.TODO(), typeConfig, typeConfigName.Namespace, typeConfigName.Name)
-	if err == nil {
-		return true, nil
-	}
-
-	if apierrors.IsNotFound(err) {
-		write(fmt.Sprintf("FederatedTypeConfig %q does not exist\n", typeConfigName))
-		return false, nil
-	}
-
-	return false, errors.Wrapf(err, "Error retrieving FederatedTypeConfig %q", typeConfigName)
-}
-
-func disablePropagation(client genericclient.Client, typeConfig *fedv1b1.FederatedTypeConfig, typeConfigName ctlutil.QualifiedName, write func(string)) error {
-	if typeConfig.GetPropagationEnabled() {
-		typeConfig.Spec.Propagation = fedv1b1.PropagationDisabled
-		err := client.Update(context.TODO(), typeConfig)
-		if err != nil {
-			return errors.Wrapf(err, "Error disabling propagation for FederatedTypeConfig %q", typeConfigName)
-		}
-		write(fmt.Sprintf("Disabled propagation for FederatedTypeConfig %q\n", typeConfigName))
-	} else {
-		write(fmt.Sprintf("Propagation already disabled for FederatedTypeConfig %q\n", typeConfigName))
-	}
-	return nil
-}
-
-func verifyPropagationControllerStopped(client genericclient.Client, typeConfigName ctlutil.QualifiedName, write func(string)) error {
-	write(fmt.Sprintf("Verifying propagation controller is stopped for FederatedTypeConfig %q\n", typeConfigName))
-
-	var typeConfig *fedv1b1.FederatedTypeConfig
-	err := wait.PollImmediate(100*time.Millisecond, 10*time.Second, func() (bool, error) {
-		typeConfig = &fedv1b1.FederatedTypeConfig{}
-		err := client.Get(context.TODO(), typeConfig, typeConfigName.Namespace, typeConfigName.Name)
-		if err != nil {
-			klog.Errorf("Error retrieving FederatedTypeConfig %q: %v", typeConfigName, err)
-			return false, nil
-		}
-		if typeConfig.Status.PropagationController == fedv1b1.ControllerStatusNotRunning {
-			return true, nil
-		}
-		return false, nil
-	})
-
-	if err != nil {
-		return errors.Wrapf(err, "Unable to verify propagation controller for FederatedTypeConfig %q is stopped: %v", typeConfigName, err)
-	}
-
-	write(fmt.Sprintf("Propagation controller for FederatedTypeConfig %q is stopped\n", typeConfigName))
-	return nil
-}
-
-func deleteFederatedTypeConfig(client genericclient.Client, typeConfig *fedv1b1.FederatedTypeConfig, typeConfigName ctlutil.QualifiedName, write func(string)) error {
-	err := client.Delete(context.TODO(), typeConfig, typeConfig.Namespace, typeConfig.Name)
-	if err != nil {
-		return errors.Wrapf(err, "Error deleting FederatedTypeConfig %q", typeConfigName)
-	}
-	write(fmt.Sprintf("federatedtypeconfig %q deleted\n", typeConfigName))
-	return nil
-}
-
-func generatedFederatedTypeConfig(config *rest.Config, enableTypeDirective *enable.EnableTypeDirective) (*fedv1b1.FederatedTypeConfig, error) {
-	apiResource, err := enable.LookupAPIResource(config, enableTypeDirective.Name, enableTypeDirective.Spec.TargetVersion)
-	if err != nil {
-		return nil, err
-	}
-	typeConfig := enable.GenerateTypeConfigForTarget(*apiResource, enableTypeDirective).(*fedv1b1.FederatedTypeConfig)
-	return typeConfig, nil
-}
-
-func deleteFederatedType(config *rest.Config, typeConfig typeconfig.Interface, write func(string)) error {
-	err := checkFederatedTypeCustomResourcesExist(config, typeConfig, write)
-	if err != nil {
-		return err
-	}
-
-	crdName := typeconfig.GroupQualifiedName(typeConfig.GetFederatedType())
-	err = deleteFederatedCRD(config, crdName, write)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func checkFederatedTypeCustomResourcesExist(config *rest.Config, typeConfig typeconfig.Interface, write func(string)) error {
-	federatedTypeAPIResource := typeConfig.GetFederatedType()
-	crdName := typeconfig.GroupQualifiedName(federatedTypeAPIResource)
-	exists, err := customResourcesExist(config, &federatedTypeAPIResource)
-	if err != nil {
-		return err
-	} else if exists {
-		return errors.Errorf("Cannot delete CRD %q while resource instances exist. Please try kubefedctl disable again after removing the resource instances or without the '--delete-crd' option\n", crdName)
-	}
-	return nil
-}
-
-func customResourcesExist(config *rest.Config, resource *metav1.APIResource) (bool, error) {
-	client, err := ctlutil.NewResourceClient(config, resource)
-	if err != nil {
-		return false, err
-	}
-
-	options := metav1.ListOptions{}
-	objList, err := client.Resources("").List(options)
-	if apierrors.IsNotFound(err) {
-		return false, nil
-	} else if err != nil {
-		return false, err
-	}
-	return len(objList.Items) != 0, nil
-}
-
-func deleteFederatedCRD(config *rest.Config, crdName string, write func(string)) error {
-	client, err := apiextv1b1client.NewForConfig(config)
-	if err != nil {
-		return errors.Wrap(err, "Error creating crd client")
-	}
-
-	err = client.CustomResourceDefinitions().Delete(crdName, nil)
-	if apierrors.IsNotFound(err) {
-		write(fmt.Sprintf("customresourcedefinition %q does not exist\n", crdName))
-	} else if err != nil {
-		return errors.Wrapf(err, "Error deleting crd %q", crdName)
-	} else {
-		write(fmt.Sprintf("customresourcedefinition %q deleted\n", crdName))
-	}
-	return nil
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/enable/deprecatedapis.go

@@ -1,153 +0,0 @@
-/*
-Copyright 2019 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 enable
-
-import (
-	"k8s.io/apimachinery/pkg/runtime/schema"
-
-	fedv1b1 "sigs.k8s.io/kubefed/pkg/apis/core/v1beta1"
-)
-
-// Deprecated APIs removed in 1.16 will be served by current equivalent APIs
-// https://kubernetes.io/blog/2019/07/18/api-deprecations-in-1-16/
-//
-// Only allow one of the equivalent APIs for federation to avoid the possibility
-// of multiple sync controllers fighting to update the same resource
-var equivalentAPIs = map[string][]schema.GroupVersion{
-	"deployments": {
-		{
-			Group:   "apps",
-			Version: "v1",
-		},
-		{
-			Group:   "apps",
-			Version: "v1beta1",
-		},
-		{
-			Group:   "apps",
-			Version: "v1beta2",
-		},
-		{
-			Group:   "extensions",
-			Version: "v1beta1",
-		},
-	},
-	"daemonsets": {
-		{
-			Group:   "apps",
-			Version: "v1",
-		},
-		{
-			Group:   "apps",
-			Version: "v1beta1",
-		},
-		{
-			Group:   "apps",
-			Version: "v1beta2",
-		},
-		{
-			Group:   "extensions",
-			Version: "v1beta1",
-		},
-	},
-	"statefulsets": {
-		{
-			Group:   "apps",
-			Version: "v1",
-		},
-		{
-			Group:   "apps",
-			Version: "v1beta1",
-		},
-		{
-			Group:   "apps",
-			Version: "v1beta2",
-		},
-	},
-	"replicasets": {
-		{
-			Group:   "apps",
-			Version: "v1",
-		},
-		{
-			Group:   "apps",
-			Version: "v1beta1",
-		},
-		{
-			Group:   "apps",
-			Version: "v1beta2",
-		},
-		{
-			Group:   "extensions",
-			Version: "v1beta1",
-		},
-	},
-	"networkpolicies": {
-		{
-			Group:   "networking.k8s.io",
-			Version: "v1",
-		},
-		{
-			Group:   "extensions",
-			Version: "v1beta1",
-		},
-	},
-	"podsecuritypolicies": {
-		{
-			Group:   "policy",
-			Version: "v1beta1",
-		},
-		{
-			Group:   "extensions",
-			Version: "v1beta1",
-		},
-	},
-	"ingresses": {
-		{
-			Group:   "networking.k8s.io",
-			Version: "v1beta1",
-		},
-		{
-			Group:   "extensions",
-			Version: "v1beta1",
-		},
-	},
-}
-
-func IsEquivalentAPI(existingAPI, newAPI *fedv1b1.APIResource) bool {
-	if existingAPI.PluralName != newAPI.PluralName {
-		return false
-	}
-
-	apis, ok := equivalentAPIs[existingAPI.PluralName]
-	if !ok {
-		return false
-	}
-
-	for _, gv := range apis {
-		if gv.Group == existingAPI.Group && gv.Version == existingAPI.Version {
-			// skip exactly matched API from equivalent API list
-			continue
-		}
-
-		if gv.Group == newAPI.Group && gv.Version == newAPI.Version {
-			return true
-		}
-	}
-
-	return false
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/enable/directive.go

@@ -1,59 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 enable
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/options"
-)
-
-// EnableTypeDirectiveSpec defines the desired state of EnableTypeDirective.
-type EnableTypeDirectiveSpec struct {
-	// The API version of the target type.
-	// +optional
-	TargetVersion string `json:"targetVersion,omitempty"`
-
-	// The name of the API group to use for generated federated types.
-	// +optional
-	FederatedGroup string `json:"federatedGroup,omitempty"`
-
-	// The API version to use for generated federated types.
-	// +optional
-	FederatedVersion string `json:"federatedVersion,omitempty"`
-}
-
-// TODO(marun) This should become a proper API type and drive enabling
-// type federation via a controller.  For now its only purpose is to
-// enable loading of configuration from disk.
-type EnableTypeDirective struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec EnableTypeDirectiveSpec `json:"spec,omitempty"`
-}
-
-func (ft *EnableTypeDirective) SetDefaults() {
-	ft.Spec.FederatedGroup = options.DefaultFederatedGroup
-	ft.Spec.FederatedVersion = options.DefaultFederatedVersion
-}
-
-func NewEnableTypeDirective() *EnableTypeDirective {
-	ft := &EnableTypeDirective{}
-	ft.SetDefaults()
-	return ft
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/enable/enable.go

@@ -1,428 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 enable
-
-import (
-	"context"
-	"fmt"
-	"io"
-
-	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
-	apiextv1b1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
-	apiextv1b1client "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	pkgruntime "k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/client-go/rest"
-	"k8s.io/klog"
-
-	"sigs.k8s.io/kubefed/pkg/apis/core/typeconfig"
-	fedv1b1 "sigs.k8s.io/kubefed/pkg/apis/core/v1beta1"
-	genericclient "sigs.k8s.io/kubefed/pkg/client/generic"
-	ctlutil "sigs.k8s.io/kubefed/pkg/controller/util"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/options"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/util"
-)
-
-const (
-	federatedGroupUsage = "The name of the API group to use for the generated federated type."
-	targetVersionUsage  = "Optional, the API version of the target type."
-)
-
-var (
-	enable_long = `
-		Enables a Kubernetes API type (including a CRD) to be propagated
-		to clusters registered with a KubeFed control plane.  A CRD for
-		the federated type will be generated and a FederatedTypeConfig will
-		be created to configure a sync controller.
-
-		Current context is assumed to be a Kubernetes cluster hosting
-		the kubefed control plane. Please use the
-		--host-cluster-context flag otherwise.`
-
-	enable_example = `
-		# Enable federation of Deployments
-		kubefedctl enable deployments.apps --host-cluster-context=cluster1
-
-		# Enable federation of Deployments identified by name specified in
-		# deployment.yaml
-		kubefedctl enable -f deployment.yaml`
-)
-
-type enableType struct {
-	options.GlobalSubcommandOptions
-	options.CommonEnableOptions
-	enableTypeOptions
-}
-
-type enableTypeOptions struct {
-	federatedVersion    string
-	output              string
-	outputYAML          bool
-	filename            string
-	enableTypeDirective *EnableTypeDirective
-}
-
-// Bind adds the join specific arguments to the flagset passed in as an
-// argument.
-func (o *enableTypeOptions) Bind(flags *pflag.FlagSet) {
-	flags.StringVar(&o.federatedVersion, "federated-version", options.DefaultFederatedVersion, "The API version to use for the generated federated type.")
-	flags.StringVarP(&o.output, "output", "o", "", "If provided, the resources that would be created in the API by the command are instead output to stdout in the provided format.  Valid values are ['yaml'].")
-	flags.StringVarP(&o.filename, "filename", "f", "", "If provided, the command will be configured from the provided yaml file.  Only --output will be accepted from the command line")
-}
-
-// NewCmdTypeEnable defines the `enable` command that
-// enables federation of a Kubernetes API type.
-func NewCmdTypeEnable(cmdOut io.Writer, config util.FedConfig) *cobra.Command {
-	opts := &enableType{}
-
-	cmd := &cobra.Command{
-		Use:     "enable (NAME | -f FILENAME)",
-		Short:   "Enables propagation of a Kubernetes API type",
-		Long:    enable_long,
-		Example: enable_example,
-		Run: func(cmd *cobra.Command, args []string) {
-			err := opts.Complete(args)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-
-			err = opts.Run(cmdOut, config)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-		},
-	}
-
-	flags := cmd.Flags()
-	opts.GlobalSubcommandBind(flags)
-	opts.CommonSubcommandBind(flags, federatedGroupUsage, targetVersionUsage)
-	opts.Bind(flags)
-
-	return cmd
-}
-
-// Complete ensures that options are valid and marshals them if necessary.
-func (j *enableType) Complete(args []string) error {
-	j.enableTypeDirective = NewEnableTypeDirective()
-	fd := j.enableTypeDirective
-
-	if j.output == "yaml" {
-		j.outputYAML = true
-	} else if len(j.output) > 0 {
-		return errors.Errorf("Invalid value for --output: %s", j.output)
-	}
-
-	if len(j.filename) > 0 {
-		err := DecodeYAMLFromFile(j.filename, fd)
-		if err != nil {
-			return errors.Wrapf(err, "Failed to load yaml from file %q", j.filename)
-		}
-		return nil
-	}
-
-	if err := j.SetName(args); err != nil {
-		return err
-	}
-
-	fd.Name = j.TargetName
-
-	if len(j.TargetVersion) > 0 {
-		fd.Spec.TargetVersion = j.TargetVersion
-	}
-	if len(j.FederatedGroup) > 0 {
-		fd.Spec.FederatedGroup = j.FederatedGroup
-	}
-	if len(j.federatedVersion) > 0 {
-		fd.Spec.FederatedVersion = j.federatedVersion
-	}
-
-	return nil
-}
-
-// Run is the implementation of the `enable` command.
-func (j *enableType) Run(cmdOut io.Writer, config util.FedConfig) error {
-	hostConfig, err := config.HostConfig(j.HostClusterContext, j.Kubeconfig)
-	if err != nil {
-		return errors.Wrap(err, "Failed to get host cluster config")
-	}
-
-	resources, err := GetResources(hostConfig, j.enableTypeDirective)
-	if err != nil {
-		return err
-	}
-
-	if j.outputYAML {
-		concreteTypeConfig := resources.TypeConfig.(*fedv1b1.FederatedTypeConfig)
-		objects := []pkgruntime.Object{concreteTypeConfig, resources.CRD}
-		err := writeObjectsToYAML(objects, cmdOut)
-		if err != nil {
-			return errors.Wrap(err, "Failed to write objects to YAML")
-		}
-		// -o yaml implies dry run
-		return nil
-	}
-
-	return CreateResources(cmdOut, hostConfig, resources, j.KubeFedNamespace, j.DryRun)
-}
-
-type typeResources struct {
-	TypeConfig typeconfig.Interface
-	CRD        *apiextv1b1.CustomResourceDefinition
-}
-
-func GetResources(config *rest.Config, enableTypeDirective *EnableTypeDirective) (*typeResources, error) {
-	apiResource, err := LookupAPIResource(config, enableTypeDirective.Name, enableTypeDirective.Spec.TargetVersion)
-	if err != nil {
-		return nil, err
-	}
-	klog.V(2).Infof("Found type %q", resourceKey(*apiResource))
-
-	typeConfig := GenerateTypeConfigForTarget(*apiResource, enableTypeDirective)
-
-	accessor, err := newSchemaAccessor(config, *apiResource)
-	if err != nil {
-		return nil, errors.Wrap(err, "Error initializing validation schema accessor")
-	}
-
-	shortNames := []string{}
-	for _, shortName := range apiResource.ShortNames {
-		shortNames = append(shortNames, fmt.Sprintf("f%s", shortName))
-	}
-
-	crd := federatedTypeCRD(typeConfig, accessor, shortNames)
-
-	return &typeResources{
-		TypeConfig: typeConfig,
-		CRD:        crd,
-	}, nil
-}
-
-// TODO(marun) Allow updates to the configuration for a type that has
-// already been enabled for kubefed.  This would likely involve
-// updating the version of the target type and the validation of the schema.
-func CreateResources(cmdOut io.Writer, config *rest.Config, resources *typeResources, namespace string, dryRun bool) error {
-	write := func(data string) {
-		if cmdOut != nil {
-			if _, err := cmdOut.Write([]byte(data)); err != nil {
-				klog.Fatalf("Unexpected err: %v\n", err)
-			}
-		}
-	}
-
-	hostClientset, err := util.HostClientset(config)
-	if err != nil {
-		return errors.Wrap(err, "Failed to create host clientset")
-	}
-	_, err = hostClientset.CoreV1().Namespaces().Get(namespace, metav1.GetOptions{})
-	if apierrors.IsNotFound(err) {
-		return errors.Wrapf(err, "KubeFed system namespace %q does not exist", namespace)
-	} else if err != nil {
-		return errors.Wrapf(err, "Error attempting to determine whether KubeFed system namespace %q exists", namespace)
-	}
-
-	client, err := genericclient.New(config)
-	if err != nil {
-		return errors.Wrap(err, "Failed to get kubefed clientset")
-	}
-
-	concreteTypeConfig := resources.TypeConfig.(*fedv1b1.FederatedTypeConfig)
-	existingTypeConfig := &fedv1b1.FederatedTypeConfig{}
-	err = client.Get(context.TODO(), existingTypeConfig, namespace, concreteTypeConfig.Name)
-	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrapf(err, "Error retrieving FederatedTypeConfig %q", concreteTypeConfig.Name)
-	}
-	if err == nil {
-		fedType := existingTypeConfig.GetFederatedType()
-		target := existingTypeConfig.GetTargetType()
-		concreteType := concreteTypeConfig.GetFederatedType()
-		if fedType.Name != concreteType.Name || fedType.Version != concreteType.Version || fedType.Group != concreteType.Group {
-			return errors.Errorf("Federation is already enabled for %q with federated type %q. Changing the federated type to %q is not supported.",
-				qualifiedAPIResourceName(target),
-				qualifiedAPIResourceName(fedType),
-				qualifiedAPIResourceName(concreteType))
-		}
-	}
-
-	crdClient, err := apiextv1b1client.NewForConfig(config)
-	if err != nil {
-		return errors.Wrap(err, "Failed to create crd clientset")
-	}
-
-	existingCRD, err := crdClient.CustomResourceDefinitions().Get(resources.CRD.Name, metav1.GetOptions{})
-	if apierrors.IsNotFound(err) {
-		if !dryRun {
-			_, err = crdClient.CustomResourceDefinitions().Create(resources.CRD)
-			if err != nil {
-				return errors.Wrapf(err, "Error creating CRD %q", resources.CRD.Name)
-			}
-		}
-		write(fmt.Sprintf("customresourcedefinition.apiextensions.k8s.io/%s created\n", resources.CRD.Name))
-	} else if err != nil {
-		return errors.Wrapf(err, "Error getting CRD %q", resources.CRD.Name)
-	} else {
-		ftcs := &fedv1b1.FederatedTypeConfigList{}
-		err := client.List(context.TODO(), ftcs, namespace)
-		if err != nil {
-			return errors.Wrap(err, "Error getting FederatedTypeConfig list")
-		}
-
-		for _, ftc := range ftcs.Items {
-			targetAPI := concreteTypeConfig.Spec.TargetType
-			existingAPI := ftc.Spec.TargetType
-			if IsEquivalentAPI(&existingAPI, &targetAPI) {
-				existingName := qualifiedAPIResourceName(ftc.GetTargetType())
-				name := qualifiedAPIResourceName(concreteTypeConfig.GetTargetType())
-				qualifiedFTCName := ctlutil.QualifiedName{
-					Namespace: ftc.Namespace,
-					Name:      ftc.Name,
-				}
-
-				return errors.Errorf("Failed to enable %q. Federation of this type is already enabled for equivalent type %q by FederatedTypeConfig %q",
-					name, existingName, qualifiedFTCName)
-			}
-
-			if concreteTypeConfig.Name == ftc.Name {
-				continue
-			}
-
-			fedType := ftc.Spec.FederatedType
-			name := typeconfig.GroupQualifiedName(metav1.APIResource{Name: fedType.PluralName, Group: fedType.Group})
-			if name == existingCRD.Name {
-				return errors.Errorf("Failed to enable federation of %q due to the FederatedTypeConfig for %q already referencing a federated type CRD named %q. If these target types are distinct despite sharing the same kind, specifying a non-default --federated-group should allow %q to be enabled.",
-					concreteTypeConfig.Name, ftc.Name, name, concreteTypeConfig.Name)
-			}
-		}
-
-		existingCRD.Spec = resources.CRD.Spec
-		if !dryRun {
-			_, err = crdClient.CustomResourceDefinitions().Update(existingCRD)
-			if err != nil {
-				return errors.Wrapf(err, "Error updating CRD %q", resources.CRD.Name)
-			}
-		}
-		write(fmt.Sprintf("customresourcedefinition.apiextensions.k8s.io/%s updated\n", resources.CRD.Name))
-	}
-
-	concreteTypeConfig.Namespace = namespace
-	err = client.Get(context.TODO(), existingTypeConfig, namespace, concreteTypeConfig.Name)
-	createdOrUpdated := "created"
-	if err != nil {
-		if !apierrors.IsNotFound(err) {
-			return errors.Wrapf(err, "Error retrieving FederatedTypeConfig %q", concreteTypeConfig.Name)
-		}
-		if !dryRun {
-			err = client.Create(context.TODO(), concreteTypeConfig)
-			if err != nil {
-				return errors.Wrapf(err, "Error creating FederatedTypeConfig %q", concreteTypeConfig.Name)
-			}
-		}
-	} else {
-		existingTypeConfig.Spec = concreteTypeConfig.Spec
-		if !dryRun {
-			err = client.Update(context.TODO(), existingTypeConfig)
-			if err != nil {
-				return errors.Wrapf(err, "Error updating FederatedTypeConfig %q", concreteTypeConfig.Name)
-			}
-		}
-		createdOrUpdated = "updated"
-	}
-	write(fmt.Sprintf("federatedtypeconfig.core.kubefed.io/%s %s in namespace %s\n",
-		concreteTypeConfig.Name, createdOrUpdated, namespace))
-	return nil
-}
-
-func GenerateTypeConfigForTarget(apiResource metav1.APIResource, enableTypeDirective *EnableTypeDirective) typeconfig.Interface {
-	spec := enableTypeDirective.Spec
-	kind := apiResource.Kind
-	pluralName := apiResource.Name
-	typeConfig := &fedv1b1.FederatedTypeConfig{
-		// Explicitly including TypeMeta will ensure it will be
-		// serialized properly to yaml.
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "FederatedTypeConfig",
-			APIVersion: "core.kubefed.io/v1beta1",
-		},
-		ObjectMeta: metav1.ObjectMeta{
-			Name: typeconfig.GroupQualifiedName(apiResource),
-		},
-		Spec: fedv1b1.FederatedTypeConfigSpec{
-			TargetType: fedv1b1.APIResource{
-				Version: apiResource.Version,
-				Kind:    kind,
-				Scope:   NamespacedToScope(apiResource),
-			},
-			Propagation: fedv1b1.PropagationEnabled,
-			FederatedType: fedv1b1.APIResource{
-				Group:      spec.FederatedGroup,
-				Version:    spec.FederatedVersion,
-				Kind:       fmt.Sprintf("Federated%s", kind),
-				PluralName: fmt.Sprintf("federated%s", pluralName),
-				Scope:      FederatedNamespacedToScope(apiResource),
-			},
-		},
-	}
-
-	// Set defaults that would normally be set by the api
-	fedv1b1.SetFederatedTypeConfigDefaults(typeConfig)
-	return typeConfig
-}
-
-func qualifiedAPIResourceName(resource metav1.APIResource) string {
-	if resource.Group == "" {
-		return fmt.Sprintf("%s/%s", resource.Name, resource.Version)
-	}
-	return fmt.Sprintf("%s.%s/%s", resource.Name, resource.Group, resource.Version)
-}
-
-func federatedTypeCRD(typeConfig typeconfig.Interface, accessor schemaAccessor, shortNames []string) *apiextv1b1.CustomResourceDefinition {
-	templateSchema := accessor.templateSchema()
-	schema := federatedTypeValidationSchema(templateSchema)
-	return CrdForAPIResource(typeConfig.GetFederatedType(), schema, shortNames)
-}
-
-func writeObjectsToYAML(objects []pkgruntime.Object, w io.Writer) error {
-	for _, obj := range objects {
-		if _, err := w.Write([]byte("---\n")); err != nil {
-			return errors.Wrap(err, "Error encoding object to yaml")
-		}
-
-		if err := writeObjectToYAML(obj, w); err != nil {
-			return errors.Wrap(err, "Error encoding object to yaml")
-		}
-	}
-	return nil
-}
-
-func writeObjectToYAML(obj pkgruntime.Object, w io.Writer) error {
-	json, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(obj)
-	if err != nil {
-		return err
-	}
-
-	unstructuredObj := &unstructured.Unstructured{}
-	if _, _, err := unstructured.UnstructuredJSONScheme.Decode(json, nil, unstructuredObj); err != nil {
-		return err
-	}
-
-	return util.WriteUnstructuredToYaml(unstructuredObj, w)
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/enable/schema.go

@@ -1,221 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 enable
-
-import (
-	"fmt"
-
-	"github.com/pkg/errors"
-
-	apiextv1b1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
-	apiextv1b1client "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/discovery"
-	"k8s.io/client-go/rest"
-	"k8s.io/kube-openapi/pkg/util/proto"
-	"k8s.io/kubectl/pkg/util/openapi"
-)
-
-type schemaAccessor interface {
-	templateSchema() map[string]apiextv1b1.JSONSchemaProps
-}
-
-func newSchemaAccessor(config *rest.Config, apiResource metav1.APIResource) (schemaAccessor, error) {
-	// Assume the resource may be a CRD, and fall back to OpenAPI if that is not the case.
-	crdAccessor, err := newCRDSchemaAccessor(config, apiResource)
-	if err != nil {
-		return nil, err
-	}
-	if crdAccessor != nil {
-		return crdAccessor, nil
-	}
-	return newOpenAPISchemaAccessor(config, apiResource)
-}
-
-type crdSchemaAccessor struct {
-	validation *apiextv1b1.CustomResourceValidation
-}
-
-func newCRDSchemaAccessor(config *rest.Config, apiResource metav1.APIResource) (schemaAccessor, error) {
-	// CRDs must have a group
-	if len(apiResource.Group) == 0 {
-		return nil, nil
-	}
-	// Check whether the target resource is a crd
-	crdClient, err := apiextv1b1client.NewForConfig(config)
-	if err != nil {
-		return nil, errors.Wrap(err, "Failed to create crd clientset")
-	}
-	crdName := fmt.Sprintf("%s.%s", apiResource.Name, apiResource.Group)
-	crd, err := crdClient.CustomResourceDefinitions().Get(crdName, metav1.GetOptions{})
-	if apierrors.IsNotFound(err) {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, errors.Wrapf(err, "Error attempting retrieval of crd %q", crdName)
-	}
-	return &crdSchemaAccessor{validation: crd.Spec.Validation}, nil
-}
-
-func (a *crdSchemaAccessor) templateSchema() map[string]apiextv1b1.JSONSchemaProps {
-	if a.validation != nil && a.validation.OpenAPIV3Schema != nil {
-		return a.validation.OpenAPIV3Schema.Properties
-	}
-	return nil
-}
-
-type openAPISchemaAccessor struct {
-	targetResource proto.Schema
-}
-
-func newOpenAPISchemaAccessor(config *rest.Config, apiResource metav1.APIResource) (schemaAccessor, error) {
-	client, err := discovery.NewDiscoveryClientForConfig(config)
-	if err != nil {
-		return nil, errors.Wrap(err, "Error creating discovery client")
-	}
-	resources, err := openapi.NewOpenAPIGetter(client).Get()
-	if err != nil {
-		return nil, errors.Wrap(err, "Error loading openapi schema")
-	}
-	gvk := schema.GroupVersionKind{
-		Group:   apiResource.Group,
-		Version: apiResource.Version,
-		Kind:    apiResource.Kind,
-	}
-	targetResource := resources.LookupResource(gvk)
-	if targetResource == nil {
-		return nil, errors.Errorf("Unable to find openapi schema for %q", gvk)
-	}
-	return &openAPISchemaAccessor{
-		targetResource: targetResource,
-	}, nil
-}
-
-func (a *openAPISchemaAccessor) templateSchema() map[string]apiextv1b1.JSONSchemaProps {
-	var templateSchema *apiextv1b1.JSONSchemaProps
-	visitor := &jsonSchemaVistor{
-		collect: func(schema apiextv1b1.JSONSchemaProps) {
-			templateSchema = &schema
-		},
-	}
-	a.targetResource.Accept(visitor)
-
-	return templateSchema.Properties
-}
-
-// jsonSchemaVistor converts proto.Schema resources into json schema.
-// A local visitor (and associated callback) is intended to be created
-// whenever a function needs to recurse.
-//
-// TODO(marun) Generate more extensive schema if/when openapi schema
-// provides more detail as per https://github.com/ant31/crd-validation
-type jsonSchemaVistor struct {
-	collect func(schema apiextv1b1.JSONSchemaProps)
-}
-
-func (v *jsonSchemaVistor) VisitArray(a *proto.Array) {
-	arraySchema := apiextv1b1.JSONSchemaProps{
-		Type:  "array",
-		Items: &apiextv1b1.JSONSchemaPropsOrArray{},
-	}
-	localVisitor := &jsonSchemaVistor{
-		collect: func(schema apiextv1b1.JSONSchemaProps) {
-			arraySchema.Items.Schema = &schema
-		},
-	}
-	a.SubType.Accept(localVisitor)
-	v.collect(arraySchema)
-}
-
-func (v *jsonSchemaVistor) VisitMap(m *proto.Map) {
-	mapSchema := apiextv1b1.JSONSchemaProps{
-		Type: "object",
-		AdditionalProperties: &apiextv1b1.JSONSchemaPropsOrBool{
-			Allows: true,
-		},
-	}
-	localVisitor := &jsonSchemaVistor{
-		collect: func(schema apiextv1b1.JSONSchemaProps) {
-			mapSchema.AdditionalProperties.Schema = &schema
-		},
-	}
-	m.SubType.Accept(localVisitor)
-	v.collect(mapSchema)
-}
-
-func (v *jsonSchemaVistor) VisitPrimitive(p *proto.Primitive) {
-	schema := schemaForPrimitive(p)
-	v.collect(schema)
-}
-
-func (v *jsonSchemaVistor) VisitKind(k *proto.Kind) {
-	kindSchema := apiextv1b1.JSONSchemaProps{
-		Type:       "object",
-		Properties: make(map[string]apiextv1b1.JSONSchemaProps),
-		Required:   k.RequiredFields,
-	}
-	for key, fieldSchema := range k.Fields {
-		// Status cannot be defined for a template
-		if key == "status" {
-			continue
-		}
-		localVisitor := &jsonSchemaVistor{
-			collect: func(schema apiextv1b1.JSONSchemaProps) {
-				kindSchema.Properties[key] = schema
-			},
-		}
-		fieldSchema.Accept(localVisitor)
-	}
-	v.collect(kindSchema)
-}
-
-func (v *jsonSchemaVistor) VisitReference(r proto.Reference) {
-	// Short-circuit the recursive definition of JSONSchemaProps (used for CRD validation)
-	//
-	// TODO(marun) Implement proper support for recursive schema
-	if r.Reference() == "io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaProps" {
-		v.collect(apiextv1b1.JSONSchemaProps{Type: "object"})
-		return
-	}
-
-	r.SubSchema().Accept(v)
-}
-
-func schemaForPrimitive(p *proto.Primitive) apiextv1b1.JSONSchemaProps {
-	schema := apiextv1b1.JSONSchemaProps{}
-
-	if p.Format == "int-or-string" {
-		schema.AnyOf = []apiextv1b1.JSONSchemaProps{
-			{
-				Type:   "integer",
-				Format: "int32",
-			},
-			{
-				Type: "string",
-			},
-		}
-		return schema
-	}
-
-	if len(p.Format) > 0 {
-		schema.Format = p.Format
-	}
-	schema.Type = p.Type
-	return schema
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/enable/util.go

@@ -1,199 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 enable
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strings"
-
-	"github.com/pkg/errors"
-
-	apiextv1b1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/yaml"
-	"k8s.io/client-go/discovery"
-	"k8s.io/client-go/rest"
-
-	"sigs.k8s.io/kubefed/pkg/apis/core/common"
-	"sigs.k8s.io/kubefed/pkg/apis/core/typeconfig"
-)
-
-func DecodeYAMLFromFile(filename string, obj interface{}) error {
-	f, err := os.Open(filename)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	return DecodeYAML(f, obj)
-}
-
-func DecodeYAML(r io.Reader, obj interface{}) error {
-	decoder := yaml.NewYAMLToJSONDecoder(r)
-	return decoder.Decode(obj)
-}
-
-func CrdForAPIResource(apiResource metav1.APIResource, validation *apiextv1b1.CustomResourceValidation, shortNames []string) *apiextv1b1.CustomResourceDefinition {
-	scope := apiextv1b1.ClusterScoped
-	if apiResource.Namespaced {
-		scope = apiextv1b1.NamespaceScoped
-	}
-	return &apiextv1b1.CustomResourceDefinition{
-		// Explicitly including TypeMeta will ensure it will be
-		// serialized properly to yaml.
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "CustomResourceDefinition",
-			APIVersion: "apiextensions.k8s.io/v1beta1",
-		},
-		ObjectMeta: metav1.ObjectMeta{
-			Name: typeconfig.GroupQualifiedName(apiResource),
-		},
-		Spec: apiextv1b1.CustomResourceDefinitionSpec{
-			Group:   apiResource.Group,
-			Version: apiResource.Version,
-			Scope:   scope,
-			Names: apiextv1b1.CustomResourceDefinitionNames{
-				Plural:     apiResource.Name,
-				Kind:       apiResource.Kind,
-				ShortNames: shortNames,
-			},
-			Validation: validation,
-			Subresources: &apiextv1b1.CustomResourceSubresources{
-				Status: &apiextv1b1.CustomResourceSubresourceStatus{},
-			},
-		},
-	}
-}
-
-func LookupAPIResource(config *rest.Config, key, targetVersion string) (*metav1.APIResource, error) {
-	resourceLists, err := GetServerPreferredResources(config)
-	if err != nil {
-		return nil, err
-	}
-
-	var targetResource *metav1.APIResource
-	var matchedResources []string
-	for _, resourceList := range resourceLists {
-		// The list holds the GroupVersion for its list of APIResources
-		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
-		if err != nil {
-			return nil, errors.Wrap(err, "Error parsing GroupVersion")
-		}
-		if len(targetVersion) > 0 && gv.Version != targetVersion {
-			continue
-		}
-		for _, resource := range resourceList.APIResources {
-			group := gv.Group
-			if NameMatchesResource(key, resource, group) {
-				if targetResource == nil {
-					targetResource = resource.DeepCopy()
-					targetResource.Group = group
-					targetResource.Version = gv.Version
-				}
-				matchedResources = append(matchedResources, groupQualifiedName(resource.Name, gv.Group))
-			}
-		}
-
-	}
-	if len(matchedResources) > 1 {
-		return nil, errors.Errorf("Multiple resources are matched by %q: %s. A group-qualified plural name must be provided.", key, strings.Join(matchedResources, ", "))
-	}
-
-	if targetResource != nil {
-		return targetResource, nil
-	}
-
-	return nil, errors.Errorf("Unable to find api resource named %q.", key)
-}
-
-func NameMatchesResource(name string, apiResource metav1.APIResource, group string) bool {
-	lowerCaseName := strings.ToLower(name)
-	if lowerCaseName == apiResource.Name ||
-		lowerCaseName == apiResource.SingularName ||
-		lowerCaseName == strings.ToLower(apiResource.Kind) ||
-		lowerCaseName == fmt.Sprintf("%s.%s", apiResource.Name, group) {
-		return true
-	}
-	for _, shortName := range apiResource.ShortNames {
-		if lowerCaseName == strings.ToLower(shortName) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func GetServerPreferredResources(config *rest.Config) ([]*metav1.APIResourceList, error) {
-	// TODO(marun) Consider using a caching scheme ala kubectl
-	client, err := discovery.NewDiscoveryClientForConfig(config)
-	if err != nil {
-		return nil, errors.Wrap(err, "Error creating discovery client")
-	}
-
-	resourceLists, err := client.ServerPreferredResources()
-	if err != nil {
-		return nil, errors.Wrap(err, "Error listing api resources")
-	}
-	return resourceLists, nil
-}
-
-func NamespacedToScope(apiResource metav1.APIResource) apiextv1b1.ResourceScope {
-	if apiResource.Namespaced {
-		return apiextv1b1.NamespaceScoped
-	}
-	return apiextv1b1.ClusterScoped
-}
-
-func FederatedNamespacedToScope(apiResource metav1.APIResource) apiextv1b1.ResourceScope {
-	// Special-case the scope of federated namespace since it will
-	// hopefully be the only instance of the scope of a federated
-	// type differing from the scope of its target.
-	if typeconfig.GroupQualifiedName(apiResource) == common.NamespaceName {
-		// FederatedNamespace is namespaced to allow the control plane to run
-		// with only namespace-scoped permissions e.g. to determine placement.
-		return apiextv1b1.NamespaceScoped
-	}
-	return NamespacedToScope(apiResource)
-}
-
-func resourceKey(apiResource metav1.APIResource) string {
-	var group string
-	if len(apiResource.Group) == 0 {
-		group = "core"
-	} else {
-		group = apiResource.Group
-	}
-	var version string
-	if len(apiResource.Version) == 0 {
-		version = "v1"
-	} else {
-		version = apiResource.Version
-	}
-	return fmt.Sprintf("%s.%s/%s", apiResource.Name, group, version)
-}
-
-func groupQualifiedName(name, group string) string {
-	apiResource := metav1.APIResource{
-		Name:  name,
-		Group: group,
-	}
-
-	return typeconfig.GroupQualifiedName(apiResource)
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/enable/validation.go

@@ -1,260 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 enable
-
-import (
-	v1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
-
-	"sigs.k8s.io/kubefed/pkg/controller/util"
-)
-
-func federatedTypeValidationSchema(templateSchema map[string]v1beta1.JSONSchemaProps) *v1beta1.CustomResourceValidation {
-	schema := ValidationSchema(v1beta1.JSONSchemaProps{
-		Type: "object",
-		Properties: map[string]v1beta1.JSONSchemaProps{
-			"placement": {
-				Type: "object",
-				Properties: map[string]v1beta1.JSONSchemaProps{
-					// References to one or more clusters allow a
-					// scheduling mechanism to explicitly indicate
-					// placement. If one or more clusters is provided,
-					// the clusterSelector field will be ignored.
-					"clusters": {
-						Type: "array",
-						Items: &v1beta1.JSONSchemaPropsOrArray{
-							Schema: &v1beta1.JSONSchemaProps{
-								Type: "object",
-								Properties: map[string]v1beta1.JSONSchemaProps{
-									"name": {
-										Type: "string",
-									},
-								},
-								Required: []string{
-									"name",
-								},
-							},
-						},
-					},
-					"clusterSelector": {
-						Type: "object",
-						Properties: map[string]v1beta1.JSONSchemaProps{
-							"matchExpressions": {
-								Type: "array",
-								Items: &v1beta1.JSONSchemaPropsOrArray{
-									Schema: &v1beta1.JSONSchemaProps{
-										Type: "object",
-										Properties: map[string]v1beta1.JSONSchemaProps{
-											"key": {
-												Type: "string",
-											},
-											"operator": {
-												Type: "string",
-											},
-											"values": {
-												Type: "array",
-												Items: &v1beta1.JSONSchemaPropsOrArray{
-													Schema: &v1beta1.JSONSchemaProps{
-														Type: "string",
-													},
-												},
-											},
-										},
-										Required: []string{
-											"key",
-											"operator",
-										},
-									},
-								},
-							},
-							"matchLabels": {
-								Type: "object",
-								AdditionalProperties: &v1beta1.JSONSchemaPropsOrBool{
-									Schema: &v1beta1.JSONSchemaProps{
-										Type: "string",
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-			"overrides": {
-				Type: "array",
-				Items: &v1beta1.JSONSchemaPropsOrArray{
-					Schema: &v1beta1.JSONSchemaProps{
-						Type: "object",
-						Properties: map[string]v1beta1.JSONSchemaProps{
-							"clusterName": {
-								Type: "string",
-							},
-							"clusterOverrides": {
-								Type: "array",
-								Items: &v1beta1.JSONSchemaPropsOrArray{
-									Schema: &v1beta1.JSONSchemaProps{
-										Type: "object",
-										Properties: map[string]v1beta1.JSONSchemaProps{
-											"op": {
-												Type:    "string",
-												Pattern: "^(add|remove|replace)?$",
-											},
-											"path": {
-												Type: "string",
-											},
-											"value": {
-												// Supporting the override of an arbitrary field
-												// precludes up-front validation.  Errors in
-												// the definition of override values will need to
-												// be caught during propagation.
-												AnyOf: []v1beta1.JSONSchemaProps{
-													{
-														Type: "string",
-													},
-													{
-														Type: "integer",
-													},
-													{
-														Type: "boolean",
-													},
-													{
-														Type: "object",
-													},
-													{
-														Type: "array",
-													},
-												},
-											},
-										},
-										Required: []string{
-											"path",
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	})
-	if templateSchema != nil {
-		specProperties := schema.OpenAPIV3Schema.Properties["spec"].Properties
-		specProperties["template"] = v1beta1.JSONSchemaProps{
-			Type: "object",
-		}
-		// Add retainReplicas field to types that exposes a replicas
-		// field that could be targeted by HPA.
-		if templateSpec, ok := templateSchema["spec"]; ok {
-			// TODO: find a simpler way to detect that a resource is scalable than having to compute the entire schema.
-			if replicasField, ok := templateSpec.Properties["replicas"]; ok {
-				if replicasField.Type == "integer" && replicasField.Format == "int32" {
-					specProperties[util.RetainReplicasField] = v1beta1.JSONSchemaProps{
-						Type: "boolean",
-					}
-				}
-			}
-		}
-
-	}
-	return schema
-}
-
-func ValidationSchema(specProps v1beta1.JSONSchemaProps) *v1beta1.CustomResourceValidation {
-	return &v1beta1.CustomResourceValidation{
-		OpenAPIV3Schema: &v1beta1.JSONSchemaProps{
-			Properties: map[string]v1beta1.JSONSchemaProps{
-				"apiVersion": {
-					Type: "string",
-				},
-				"kind": {
-					Type: "string",
-				},
-				// TODO(marun) Add a comprehensive schema for metadata
-				"metadata": {
-					Type: "object",
-				},
-				"spec": specProps,
-				"status": {
-					Type: "object",
-					Properties: map[string]v1beta1.JSONSchemaProps{
-						"conditions": {
-							Type: "array",
-							Items: &v1beta1.JSONSchemaPropsOrArray{
-								Schema: &v1beta1.JSONSchemaProps{
-									Type: "object",
-									Properties: map[string]v1beta1.JSONSchemaProps{
-										"type": {
-											Type: "string",
-										},
-										"status": {
-											Type: "string",
-										},
-										"reason": {
-											Type: "string",
-										},
-										"lastUpdateTime": {
-											Format: "date-time",
-											Type:   "string",
-										},
-										"lastTransitionTime": {
-											Format: "date-time",
-											Type:   "string",
-										},
-									},
-									Required: []string{
-										"type",
-										"status",
-									},
-								},
-							},
-						},
-						"clusters": {
-							Type: "array",
-							Items: &v1beta1.JSONSchemaPropsOrArray{
-								Schema: &v1beta1.JSONSchemaProps{
-									Type: "object",
-									Properties: map[string]v1beta1.JSONSchemaProps{
-										"name": {
-											Type: "string",
-										},
-										"status": {
-											Type: "string",
-										},
-									},
-									Required: []string{
-										"name",
-									},
-								},
-							},
-						},
-						"observedGeneration": {
-							Format: "int64",
-							Type:   "integer",
-						},
-					},
-				},
-			},
-			// Require a spec (even if empty) as an aid to users
-			// manually creating federated configmaps or
-			// secrets. These target types do not include a spec,
-			// and the absence of the spec in a federated
-			// equivalent could indicate a malformed resource.
-			Required: []string{
-				"spec",
-			},
-		},
-	}
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/federate/federate.go

@@ -1,552 +0,0 @@
-/*
-Copyright 2019 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 federate
-
-import (
-	"context"
-	"io"
-	"time"
-
-	"github.com/pkg/errors"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	apimeta "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/util/wait"
-	"k8s.io/client-go/rest"
-	"k8s.io/klog"
-
-	"sigs.k8s.io/kubefed/pkg/apis/core/typeconfig"
-	fedv1b1 "sigs.k8s.io/kubefed/pkg/apis/core/v1beta1"
-	genericclient "sigs.k8s.io/kubefed/pkg/client/generic"
-	ctlutil "sigs.k8s.io/kubefed/pkg/controller/util"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/enable"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/options"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/util"
-)
-
-const (
-	createResourceRetryTimeout  = 10 * time.Second
-	createResourceRetryInterval = 1 * time.Second
-)
-
-var (
-	// Controller created resources should always be skipped while federating content
-	controllerCreatedAPIResourceNames = []string{
-		"endpoints",
-		"events",
-		"events.events.k8s.io",
-		"propagatedversions.core.kubefed.io",
-	}
-
-	federate_long = `
-		Federate creates a federated resource from a kubernetes resource.
-		The target resource must exist in the cluster hosting the kubefed
-		control plane. If the federated resource needs to be created in the
-		API, the control plane must have a FederatedTypeConfig for the type
-		of the kubernetes resource. If using with flag '-o yaml', it is not
-		necessary for the FederatedTypeConfig to exist (or even for the
-		kubefed API to be installed in the cluster).
-
-		Current context is assumed to be a Kubernetes cluster hosting
-		the kubefed control plane. Please use the --host-cluster-context
-		flag otherwise.`
-
-	federate_example = `
-		# Federate resource named "my-cm" in namespace "my-ns" of kubernetes type "configmaps" (identified by short name "cm")
-		kubefedctl federate cm "my-cm" -n "my-ns" --host-cluster-context=cluster1`
-)
-
-type federateResource struct {
-	options.GlobalSubcommandOptions
-	typeName             string
-	resourceName         string
-	resourceNamespace    string
-	output               string
-	outputYAML           bool
-	enableType           bool
-	federateContents     bool
-	filename             string
-	skipAPIResourceNames []string
-}
-
-func (j *federateResource) Bind(flags *pflag.FlagSet) {
-	flags.StringVarP(&j.resourceNamespace, "namespace", "n", "", "The namespace of the resource to federate.")
-	flags.StringVarP(&j.output, "output", "o", "", "If provided, the resource that would be created in the API by the command is instead output to stdout in the provided format.  Valid format is ['yaml'].")
-	flags.BoolVarP(&j.enableType, "enable-type", "t", false, "If true, attempt to enable federation of the API type of the resource before creating the federated resource.")
-	flags.BoolVarP(&j.federateContents, "contents", "c", false, "Applicable only to namespaces. If provided, the command will federate all resources within the namespace after federating the namespace.")
-	flags.StringVarP(&j.filename, "filename", "f", "", "If specified, the provided yaml file will be used as the input for target resources to federate. This mode will only emit federated resource yaml to standard output. Other flag options if provided will be ignored.")
-	flags.StringSliceVarP(&j.skipAPIResourceNames, "skip-api-resources", "s", []string{}, "Comma separated names of the api resources to skip when federating contents in a namespace. Name could be short name "+
-		"(e.g. 'deploy), kind (e.g. 'deployment'), plural name (e.g. 'deployments'), group qualified plural name (e.g. 'deployments.apps') or group name itself (e.g. 'apps') to skip the whole group.")
-}
-
-// Complete ensures that options are valid.
-func (j *federateResource) Complete(args []string) error {
-	if j.output == "yaml" {
-		j.outputYAML = true
-	} else if len(j.output) > 0 {
-		return errors.Errorf("Invalid value for --output: %s", j.output)
-	}
-
-	if len(j.filename) > 0 {
-		if len(args) > 0 {
-			return errors.Errorf("Flag '--filename' does not take any args. Got args: %v", args)
-		}
-		return nil
-	}
-
-	if len(args) == 0 {
-		return errors.New("TYPE-NAME is required")
-	}
-	j.typeName = args[0]
-
-	if len(args) == 1 {
-		return errors.New("RESOURCE-NAME is required")
-	}
-	j.resourceName = args[1]
-
-	if j.enableType && j.outputYAML {
-		return errors.New("Flag '--enable-type' cannot be used with '--output [yaml]'")
-	}
-
-	return nil
-}
-
-// NewCmdFederateResource defines the `federate` command that federates a
-// Kubernetes resource of the given kubernetes type.
-func NewCmdFederateResource(cmdOut io.Writer, config util.FedConfig) *cobra.Command {
-	opts := &federateResource{}
-
-	cmd := &cobra.Command{
-		Use:     "federate TYPE-NAME RESOURCE-NAME",
-		Short:   "Federate creates a federated resource from a kubernetes resource",
-		Long:    federate_long,
-		Example: federate_example,
-		Run: func(cmd *cobra.Command, args []string) {
-			err := opts.Complete(args)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-
-			err = opts.Run(cmdOut, config)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-		},
-	}
-
-	flags := cmd.Flags()
-	opts.GlobalSubcommandBind(flags)
-	opts.Bind(flags)
-
-	return cmd
-}
-
-// Run is the implementation of the `federate resource` command.
-func (j *federateResource) Run(cmdOut io.Writer, config util.FedConfig) error {
-
-	if len(j.resourceNamespace) == 0 {
-		var err error
-		j.resourceNamespace, err = util.GetNamespace(j.HostClusterContext, j.Kubeconfig, config)
-		if err != nil {
-			return err
-		}
-	}
-
-	hostConfig, err := config.HostConfig(j.HostClusterContext, j.Kubeconfig)
-	if err != nil {
-		return errors.Wrap(err, "Failed to get host cluster config")
-	}
-
-	if len(j.filename) > 0 {
-		resources, err := DecodeUnstructuredFromFile(j.filename)
-		if err != nil {
-			return errors.Wrapf(err, "Failed to load yaml from file %q", j.filename)
-		}
-		federatedResources, err := FederateResources(resources)
-		if err != nil {
-			return err
-		}
-
-		err = WriteUnstructuredObjsToYaml(federatedResources, cmdOut)
-		if err != nil {
-			return errors.Wrap(err, "Failed to write federated resources to YAML")
-		}
-		return nil
-
-	}
-
-	qualifiedResourceName := ctlutil.QualifiedName{
-		Namespace: j.resourceNamespace,
-		Name:      j.resourceName,
-	}
-	artifacts, err := GetFederateArtifacts(hostConfig, j.typeName, j.KubeFedNamespace, qualifiedResourceName, j.enableType, j.outputYAML)
-	if err != nil {
-		return err
-	}
-	artifactsList := []*FederateArtifacts{}
-	artifactsList = append(artifactsList, artifacts)
-
-	kind := artifacts.typeConfig.GetTargetType().Kind
-	if kind != ctlutil.NamespaceKind && j.federateContents {
-		return errors.New("Flag '--contents' can only be used with type 'namespaces'.")
-	}
-
-	if kind == ctlutil.NamespaceKind && j.federateContents {
-		containedArtifactsList, err := GetContainedArtifactsList(hostConfig, j.resourceName, j.KubeFedNamespace, j.skipAPIResourceNames, j.enableType, j.outputYAML)
-		if err != nil {
-			return err
-		}
-		artifactsList = append(artifactsList, containedArtifactsList...)
-	}
-
-	if j.outputYAML {
-		for _, artifacts := range artifactsList {
-			err := WriteUnstructuredObjsToYaml(artifacts.federatedResources, cmdOut)
-			if err != nil {
-				return errors.Wrap(err, "Failed to write federated resource to YAML")
-			}
-		}
-		return nil
-	}
-
-	return CreateResources(cmdOut, hostConfig, artifactsList, j.KubeFedNamespace, j.enableType, j.DryRun)
-}
-
-func FederateResources(resources []*unstructured.Unstructured) ([]*unstructured.Unstructured, error) {
-	var federatedResources []*unstructured.Unstructured
-	for _, targetResource := range resources {
-		// A Group, a Version and a Kind is sufficient for API Resource definition.
-		gvk := targetResource.GroupVersionKind()
-
-		// Construct an API Resource from above info.
-		// TODO(irfanurrehman) Should we depend on the lookup from the
-		// API Server instead, for some specific scenario?
-		plural, singular := apimeta.UnsafeGuessKindToResource(gvk)
-		apiResource := metav1.APIResource{
-			Name:         plural.Resource,
-			SingularName: singular.Resource,
-			Group:        gvk.Group,
-			Version:      gvk.Version,
-			Kind:         gvk.Kind,
-		}
-		apiResource.Namespaced = targetResource.GetNamespace() == ""
-
-		qualifiedName := ctlutil.NewQualifiedName(targetResource)
-		typeConfig := enable.GenerateTypeConfigForTarget(apiResource, enable.NewEnableTypeDirective())
-		federatedResource, err := FederatedResourceFromTargetResource(typeConfig, targetResource)
-		if err != nil {
-			return nil, errors.Wrapf(err, "Error getting %s from %s %q", typeConfig.GetFederatedType().Kind, typeConfig.GetTargetType().Kind, qualifiedName)
-		}
-
-		federatedResources = append(federatedResources, federatedResource)
-	}
-
-	return federatedResources, nil
-}
-
-type FederateArtifacts struct {
-	// Identifies if typeConfig for this type is installed
-	typeConfigInstalled bool
-
-	// Identifies the type
-	typeConfig typeconfig.Interface
-	// List of federated resources of this type
-	federatedResources []*unstructured.Unstructured
-}
-
-func GetFederateArtifacts(hostConfig *rest.Config, typeName, kubefedNamespace string, qualifiedName ctlutil.QualifiedName, enableType, outputYAML bool) (*FederateArtifacts, error) {
-	// Lookup kubernetes API availability
-	apiResource, err := enable.LookupAPIResource(hostConfig, typeName, "")
-	if err != nil {
-		return nil, errors.Wrapf(err, "Failed to find target API resource %s", typeName)
-	}
-	klog.V(2).Infof("API Resource for %s found", typeName)
-
-	typeConfigInstalled, typeConfig, err := getTypeConfig(hostConfig, *apiResource, kubefedNamespace, enableType, outputYAML)
-	if err != nil {
-		return nil, err
-	}
-
-	targetResource, err := getTargetResource(hostConfig, typeConfig, qualifiedName)
-	if err != nil {
-		return nil, err
-	}
-
-	federatedResource, err := FederatedResourceFromTargetResource(typeConfig, targetResource)
-	if err != nil {
-		return nil, errors.Wrapf(err, "Error getting %s from %s %q", typeConfig.GetFederatedType().Kind, typeConfig.GetTargetType().Kind, qualifiedName)
-	}
-
-	var federatedResources []*unstructured.Unstructured
-	federatedResources = append(federatedResources, federatedResource)
-	return &FederateArtifacts{
-		typeConfigInstalled: typeConfigInstalled,
-		typeConfig:          typeConfig,
-		federatedResources:  federatedResources,
-	}, nil
-}
-
-func getTypeConfig(hostConfig *rest.Config, apiResource metav1.APIResource, kubefedNamespace string, enableType, outputYAML bool) (bool, typeconfig.Interface, error) {
-	resolvedTypeName := typeconfig.GroupQualifiedName(apiResource)
-	installedTypeConfig, err := getInstalledTypeConfig(hostConfig, resolvedTypeName, kubefedNamespace)
-	if err == nil {
-		return true, installedTypeConfig, nil
-	}
-	notFound := apierrors.IsNotFound(err)
-	if notFound && !outputYAML && !enableType {
-		return false, nil, errors.Errorf("%v. Consider using '--enable-type' to optionally enable type while federating the resource", err)
-	}
-
-	generatedTypeConfig := enable.GenerateTypeConfigForTarget(apiResource, enable.NewEnableTypeDirective())
-	if notFound && enableType { // We have already generated typeConfig to additionally enable type
-		return false, generatedTypeConfig, nil
-	}
-	if outputYAML { // Output as yaml does not bother what error happened while accessing typeConfig
-		klog.V(1).Infof("Falling back to a generated type config due to lookup failure: %v", err)
-		return false, generatedTypeConfig, nil
-	}
-	return false, nil, err
-}
-
-func getInstalledTypeConfig(hostConfig *rest.Config, typeName, kubefedNamespace string) (typeconfig.Interface, error) {
-	client, err := genericclient.New(hostConfig)
-	if err != nil {
-		return nil, errors.Wrap(err, "Failed to get generic client")
-	}
-
-	concreteTypeConfig := &fedv1b1.FederatedTypeConfig{}
-	err = client.Get(context.TODO(), concreteTypeConfig, kubefedNamespace, typeName)
-	if err != nil {
-		return nil, err
-	}
-	return concreteTypeConfig, nil
-}
-
-func getTargetResource(hostConfig *rest.Config, typeConfig typeconfig.Interface, qualifiedName ctlutil.QualifiedName) (*unstructured.Unstructured, error) {
-	targetAPIResource := typeConfig.GetTargetType()
-	targetClient, err := ctlutil.NewResourceClient(hostConfig, &targetAPIResource)
-	if err != nil {
-		return nil, errors.Wrapf(err, "Error creating client for %s", targetAPIResource.Kind)
-	}
-
-	kind := targetAPIResource.Kind
-	resource, err := targetClient.Resources(qualifiedName.Namespace).Get(qualifiedName.Name, metav1.GetOptions{})
-	if err != nil {
-		return nil, errors.Wrapf(err, "Error retrieving target %s %q", kind, qualifiedName)
-	}
-
-	klog.V(2).Infof("Target %s %q found", kind, qualifiedName)
-	return resource, nil
-}
-
-func FederatedResourceFromTargetResource(typeConfig typeconfig.Interface, resource *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	fedAPIResource := typeConfig.GetFederatedType()
-	targetResource := resource.DeepCopy()
-
-	targetKind := typeConfig.GetTargetType().Kind
-
-	// Special handling is needed for some controller set fields.
-	switch targetKind {
-	case ctlutil.NamespaceKind:
-		{
-			unstructured.RemoveNestedField(targetResource.Object, "spec", "finalizers")
-		}
-	case ctlutil.ServiceAccountKind:
-		{
-			unstructured.RemoveNestedField(targetResource.Object, ctlutil.SecretsField)
-		}
-	case ctlutil.ServiceKind:
-		{
-			var targetPorts []interface{}
-			targetPorts, ok, err := unstructured.NestedSlice(targetResource.Object, "spec", "ports")
-			if err != nil {
-				return nil, err
-			}
-			if ok {
-				for index := range targetPorts {
-					port := targetPorts[index].(map[string]interface{})
-					delete(port, "nodePort")
-					targetPorts[index] = port
-				}
-				err := unstructured.SetNestedSlice(targetResource.Object, targetPorts, "spec", "ports")
-				if err != nil {
-					return nil, err
-				}
-			}
-			unstructured.RemoveNestedField(targetResource.Object, "spec", "clusterIP")
-		}
-	}
-
-	qualifiedName := ctlutil.NewQualifiedName(targetResource)
-	resourceNamespace := getNamespace(typeConfig, qualifiedName)
-	fedResource := &unstructured.Unstructured{}
-	SetBasicMetaFields(fedResource, fedAPIResource, qualifiedName.Name, resourceNamespace, "")
-
-	// Warn if annotations are present in case the intention is to
-	// define annotations in the template of the federated resource.
-	annotations, _, err := unstructured.NestedMap(targetResource.Object, "metadata", "annotations")
-	if err != nil {
-		return nil, errors.Wrap(err, "Failed to retrieve metadata.annotations")
-	}
-	if len(annotations) > 0 {
-		klog.Warningf("Annotations defined for %s %q will not appear in the template of the federated resource: %v", targetKind, qualifiedName, annotations)
-	}
-
-	if err := RemoveUnwantedFields(targetResource); err != nil {
-		return nil, err
-	}
-
-	err = unstructured.SetNestedField(fedResource.Object, targetResource.Object, ctlutil.SpecField, ctlutil.TemplateField)
-	if err != nil {
-		return nil, err
-	}
-	err = unstructured.SetNestedStringMap(fedResource.Object, map[string]string{}, ctlutil.SpecField, ctlutil.PlacementField, ctlutil.ClusterSelectorField, ctlutil.MatchLabelsField)
-	if err != nil {
-		return nil, err
-	}
-
-	return fedResource, err
-}
-
-func getNamespace(typeConfig typeconfig.Interface, qualifiedName ctlutil.QualifiedName) string {
-	if typeConfig.GetTargetType().Kind == ctlutil.NamespaceKind {
-		return qualifiedName.Name
-	}
-	return qualifiedName.Namespace
-}
-
-func CreateResources(cmdOut io.Writer, hostConfig *rest.Config, artifactsList []*FederateArtifacts, namespace string, enableType, dryRun bool) error {
-	for _, artifacts := range artifactsList {
-		if enableType && !artifacts.typeConfigInstalled {
-			enableTypeDirective := enable.NewEnableTypeDirective()
-			enableTypeDirective.Name = artifacts.typeConfig.GetObjectMeta().Name
-			typeResources, err := enable.GetResources(hostConfig, enableTypeDirective)
-			if err != nil {
-				return err
-			}
-			err = enable.CreateResources(cmdOut, hostConfig, typeResources, namespace, dryRun)
-			if err != nil {
-				return err
-			}
-		}
-
-		err := CreateFederatedResources(hostConfig, artifacts.typeConfig, artifacts.federatedResources, dryRun)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func CreateFederatedResources(hostConfig *rest.Config, typeConfig typeconfig.Interface, federatedResources []*unstructured.Unstructured, dryRun bool) error {
-	for _, federatedResource := range federatedResources {
-		err := CreateFederatedResource(hostConfig, typeConfig, federatedResource, dryRun)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func CreateFederatedResource(hostConfig *rest.Config, typeConfig typeconfig.Interface, federatedResource *unstructured.Unstructured, dryRun bool) error {
-	if typeConfig.GetTargetType().Kind == ctlutil.NamespaceKind {
-		// TODO: irfanurrehman: Can a target namespace be federated into another namespace?
-		klog.Infof("Resource to federate is a namespace. Given namespace will itself be the container for the federated namespace")
-	}
-
-	fedAPIResource := typeConfig.GetFederatedType()
-	fedKind := fedAPIResource.Kind
-	fedClient, err := ctlutil.NewResourceClient(hostConfig, &fedAPIResource)
-	if err != nil {
-		return errors.Wrapf(err, "Error creating client for %s", fedKind)
-	}
-
-	qualifiedFedName := ctlutil.NewQualifiedName(federatedResource)
-	if !dryRun {
-		// It might take a little while for the federated type to appear if the
-		// same is being enabled while or immediately before federating the resource.
-		err = wait.PollImmediate(createResourceRetryInterval, createResourceRetryTimeout, func() (bool, error) {
-			_, err := fedClient.Resources(federatedResource.GetNamespace()).Create(federatedResource, metav1.CreateOptions{})
-			if apierrors.IsNotFound(err) {
-				return false, nil
-			}
-			if err != nil {
-				return false, err
-			}
-			return true, nil
-		})
-		if err != nil {
-			return errors.Wrapf(err, "Error creating federated resource %q", qualifiedFedName)
-		}
-	}
-
-	klog.Infof("Successfully created %s %q from %s", fedKind, qualifiedFedName, typeConfig.GetTargetType().Kind)
-	return nil
-}
-
-func GetContainedArtifactsList(hostConfig *rest.Config, containerNamespace, kubefedNamespace string, skipAPIResourceNames []string, enableType, outputYAML bool) ([]*FederateArtifacts, error) {
-	targetResourcesList, err := getResourcesInNamespace(hostConfig, containerNamespace, skipAPIResourceNames)
-	if err != nil {
-		return nil, err
-	}
-
-	artifactsList := []*FederateArtifacts{}
-	for _, targetResources := range targetResourcesList {
-		apiResource := targetResources.apiResource
-		typeConfigInstalled, typeConfig, err := getTypeConfig(hostConfig, apiResource, kubefedNamespace, enableType, outputYAML)
-		if err != nil {
-			return nil, err
-		}
-		var federatedResources []*unstructured.Unstructured
-		for _, targetResource := range targetResources.resources {
-			federatedResource, err := FederatedResourceFromTargetResource(typeConfig, targetResource)
-			if err != nil {
-				return nil, err
-			}
-
-			federatedResources = append(federatedResources, federatedResource)
-		}
-		federateArtifacts := FederateArtifacts{
-			typeConfigInstalled: typeConfigInstalled,
-			typeConfig:          typeConfig,
-			federatedResources:  federatedResources,
-		}
-		artifactsList = append(artifactsList, &federateArtifacts)
-	}
-
-	return artifactsList, nil
-}
-
-func WriteUnstructuredObjsToYaml(unstructuredObjs []*unstructured.Unstructured, w io.Writer) error {
-	for _, unstructuredObj := range unstructuredObjs {
-		if _, err := w.Write([]byte("---\n")); err != nil {
-			return errors.Wrap(err, "Error encoding object to yaml")
-		}
-		err := util.WriteUnstructuredToYaml(unstructuredObj, w)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/federate/util.go

@@ -1,264 +0,0 @@
-/*
-Copyright 2019 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 federate
-
-import (
-	"bufio"
-	"io"
-	"os"
-
-	"github.com/pkg/errors"
-
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/validation"
-	utilyaml "k8s.io/apimachinery/pkg/util/yaml"
-	versionhelper "k8s.io/apimachinery/pkg/version"
-	"k8s.io/client-go/rest"
-	"k8s.io/klog"
-	"sigs.k8s.io/yaml"
-
-	"sigs.k8s.io/kubefed/pkg/apis/core/typeconfig"
-	ctlutil "sigs.k8s.io/kubefed/pkg/controller/util"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/enable"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/util"
-)
-
-func RemoveUnwantedFields(resource *unstructured.Unstructured) error {
-	unstructured.RemoveNestedField(resource.Object, "apiVersion")
-	unstructured.RemoveNestedField(resource.Object, "kind")
-	unstructured.RemoveNestedField(resource.Object, "status")
-
-	// All metadata fields save labels should be cleared. Other
-	// metadata fields will be set by the system on creation or
-	// subsequently by controllers.
-	labels, _, err := unstructured.NestedMap(resource.Object, "metadata", "labels")
-	if err != nil {
-		return errors.Wrap(err, "Failed to retrieve metadata.labels")
-	}
-	unstructured.RemoveNestedField(resource.Object, "metadata")
-	if len(labels) > 0 {
-		err := unstructured.SetNestedMap(resource.Object, labels, "metadata", "labels")
-		if err != nil {
-			return errors.Wrap(err, "Failed to set metadata.labels")
-		}
-	}
-
-	return nil
-}
-
-func SetBasicMetaFields(resource *unstructured.Unstructured, apiResource metav1.APIResource, name, namespace, generateName string) {
-	resource.SetKind(apiResource.Kind)
-	gv := schema.GroupVersion{Group: apiResource.Group, Version: apiResource.Version}
-	resource.SetAPIVersion(gv.String())
-	resource.SetName(name)
-	if generateName != "" {
-		resource.SetGenerateName(generateName)
-	}
-	if apiResource.Namespaced {
-		resource.SetNamespace(namespace)
-	}
-}
-
-func namespacedAPIResourceMap(config *rest.Config, skipAPIResourceNames []string) (map[string]metav1.APIResource, error) {
-	apiResourceLists, err := enable.GetServerPreferredResources(config)
-	if err != nil {
-		return nil, err
-	}
-
-	apiResources := make(map[string]metav1.APIResource)
-	for _, apiResourceList := range apiResourceLists {
-		if len(apiResourceList.APIResources) == 0 {
-			continue
-		}
-
-		gv, err := schema.ParseGroupVersion(apiResourceList.GroupVersion)
-		if err != nil {
-			return nil, errors.Wrap(err, "Error parsing GroupVersion")
-		}
-
-		group := gv.Group
-		if apiResourceGroupMatchesSkipName(skipAPIResourceNames, group) {
-			// A whole group is skipped by the user
-			continue
-		}
-
-		if group == "extensions" {
-			// The strategy involved to choose a Group higher in order for k8s core
-			// APIs is to consider "extensions" as the outdated group [This seems to
-			// be true for all k8s APIResources, so far]. For example if "deployments"
-			// exists in "extensions" and "apps"; "deployments.apps" will be chosen.
-			// This doesn't apply to events but events are listed in
-			// controllerCreatedAPIResourceNames and so are skipped always.
-
-			// Skipping this also assumes that "extensions" is not the only
-			// group exposed for this resource on the API Server, which probably
-			// is safe as "extensions" is deprecated.
-			// TODO(irfanurrehman): Document this.
-			continue
-		}
-
-		for _, apiResource := range apiResourceList.APIResources {
-			if !apiResource.Namespaced || util.IsFederatedAPIResource(apiResource.Kind, group) ||
-				apiResourceMatchesSkipName(apiResource, skipAPIResourceNames, group) {
-				continue
-			}
-
-			// For all other resources (say CRDs) same kinds in different groups
-			// are treated as individual types. If there happens to be an API Resource
-			// which enables conversion and allows query of the same resource across
-			// different groups, a specific group resource will have to be chosen by
-			// the user using --skip-names to skip the not chosen one(s).
-			// TODO(irfanurrehman): Document this.
-
-			// The individual apiResources do not have the group and version set
-			apiResource.Group = group
-			apiResource.Version = gv.Version
-			groupQualifiedName := typeconfig.GroupQualifiedName(apiResource)
-			if previousAPIResource, ok := apiResources[groupQualifiedName]; ok {
-				if versionhelper.CompareKubeAwareVersionStrings(gv.Version, previousAPIResource.Version) <= 0 {
-					// The newer version is not latest keep the previous.
-					continue
-				}
-			}
-
-			apiResources[groupQualifiedName] = apiResource
-		}
-	}
-
-	return apiResources, nil
-}
-
-func apiResourceGroupMatchesSkipName(skipAPIResourceNames []string, group string) bool {
-	for _, name := range skipAPIResourceNames {
-		if name == "" {
-			continue
-		}
-		if name == group {
-			return true
-		}
-	}
-	return false
-}
-
-func apiResourceMatchesSkipName(apiResource metav1.APIResource, skipAPIResourceNames []string, group string) bool {
-	names := append(controllerCreatedAPIResourceNames, skipAPIResourceNames...)
-	for _, name := range names {
-		if name == "" {
-			continue
-		}
-		if enable.NameMatchesResource(name, apiResource, group) {
-			return true
-		}
-	}
-	return false
-}
-
-// resources stores a list of resources for an api type
-type resources struct {
-	// resource type information
-	apiResource metav1.APIResource
-	// resource list
-	resources []*unstructured.Unstructured
-}
-
-func getResourcesInNamespace(config *rest.Config, namespace string, skipAPIResourceNames []string) ([]resources, error) {
-	apiResources, err := namespacedAPIResourceMap(config, skipAPIResourceNames)
-	if err != nil {
-		return nil, err
-	}
-
-	resourcesInNamespace := []resources{}
-	for _, apiResource := range apiResources {
-		client, err := ctlutil.NewResourceClient(config, &apiResource)
-		if err != nil {
-			return nil, errors.Wrapf(err, "Error creating client for %s", apiResource.Kind)
-		}
-
-		resourceList, err := client.Resources(namespace).List(metav1.ListOptions{})
-		if apierrors.IsNotFound(err) || resourceList == nil {
-			continue
-		}
-		if err != nil {
-			return nil, errors.Wrapf(err, "Error listing resources for %s", apiResource.Kind)
-		}
-
-		// It would be a waste of cycles to iterate through empty slices while federating resource
-		if len(resourceList.Items) == 0 {
-			continue
-		}
-
-		targetResources := resources{apiResource: apiResource}
-		for _, item := range resourceList.Items {
-			resource := item
-			errors := validation.IsDNS1123Subdomain(resource.GetName())
-			if len(errors) == 0 {
-				targetResources.resources = append(targetResources.resources, &resource)
-			} else {
-				klog.Warningf("Skipping resource %s of type %s because it does not conform to the DNS-1123 subdomain spec.", resource.GetName(), apiResource.Name)
-				klog.Warningf("The following error(s) were reported during DNS-1123 validation: ")
-				for _, err := range errors {
-					klog.Warningf(err)
-				}
-			}
-		}
-		resourcesInNamespace = append(resourcesInNamespace, targetResources)
-	}
-
-	return resourcesInNamespace, nil
-}
-
-// decodeUnstructuredFromFile reads a list of yamls into a slice of unstructured objects
-func DecodeUnstructuredFromFile(filename string) ([]*unstructured.Unstructured, error) {
-	var f *os.File
-	if filename == "-" {
-		f = os.Stdin
-	} else {
-		var err error
-		f, err = os.Open(filename)
-
-		if err != nil {
-			return nil, err
-		}
-	}
-	defer f.Close()
-
-	var unstructuredList []*unstructured.Unstructured
-	reader := utilyaml.NewYAMLReader(bufio.NewReader(f))
-	for {
-		unstructuedObj := &unstructured.Unstructured{}
-		// Read one YAML document at a time, until io.EOF is returned
-		buf, err := reader.Read()
-		if err == io.EOF {
-			break
-		} else if err != nil {
-			return nil, err
-		}
-		if len(buf) == 0 {
-			break
-		}
-		if err := yaml.Unmarshal(buf, unstructuedObj); err != nil {
-			return nil, err
-		}
-
-		unstructuredList = append(unstructuredList, unstructuedObj)
-	}
-
-	return unstructuredList, nil
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/join.go

@@ -1,880 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 kubefedctl
-
-import (
-	"context"
-	goerrors "errors"
-	"io"
-	"reflect"
-	"strings"
-	"time"
-
-	"github.com/pkg/errors"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-	corev1 "k8s.io/api/core/v1"
-	rbacv1 "k8s.io/api/rbac/v1"
-	apiextv1b1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/wait"
-	kubeclient "k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/rest"
-	"k8s.io/klog"
-
-	fedv1b1 "sigs.k8s.io/kubefed/pkg/apis/core/v1beta1"
-	genericclient "sigs.k8s.io/kubefed/pkg/client/generic"
-	ctlutil "sigs.k8s.io/kubefed/pkg/controller/util"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/options"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/util"
-)
-
-const (
-	serviceAccountSecretTimeout = 30 * time.Second
-)
-
-var (
-	join_long = `
-		Join registers a Kubernetes cluster with a KubeFed control
-		plane.
-
-		Current context is assumed to be a Kubernetes cluster
-		hosting a KubeFed control plane. Please use the
-		--host-cluster-context flag otherwise.`
-	join_example = `
-		# Register a cluster with a KubeFed control plane by
-		# specifying the cluster name and the context name of
-		# the control plane's host cluster. Cluster name must
-		# be a valid RFC 1123 subdomain name. Cluster context
-		# must be specified if the cluster name is different
-		# than the cluster's context in the local kubeconfig.
-		kubefedctl join foo --host-cluster-context=bar`
-
-	// Policy rules allowing full access to resources in the cluster
-	// or namespace.
-	namespacedPolicyRules = []rbacv1.PolicyRule{
-		{
-			Verbs:     []string{rbacv1.VerbAll},
-			APIGroups: []string{rbacv1.APIGroupAll},
-			Resources: []string{rbacv1.ResourceAll},
-		},
-	}
-	clusterPolicyRules = []rbacv1.PolicyRule{
-		namespacedPolicyRules[0],
-		{
-			NonResourceURLs: []string{rbacv1.NonResourceAll},
-			Verbs:           []string{"get"},
-		},
-	}
-)
-
-type joinFederation struct {
-	options.GlobalSubcommandOptions
-	options.CommonJoinOptions
-	joinFederationOptions
-}
-
-type joinFederationOptions struct {
-	secretName      string
-	scope           apiextv1b1.ResourceScope
-	errorOnExisting bool
-}
-
-// Bind adds the join specific arguments to the flagset passed in as an
-// argument.
-func (o *joinFederationOptions) Bind(flags *pflag.FlagSet) {
-	flags.StringVar(&o.secretName, "secret-name", "",
-		"Name of the secret where the cluster's credentials will be stored in the host cluster. This name should be a valid RFC 1035 label. If unspecified, defaults to a generated name containing the cluster name.")
-	flags.BoolVar(&o.errorOnExisting, "error-on-existing", true,
-		"Whether the join operation will throw an error if it encounters existing artifacts with the same name as those it's trying to create. If false, the join operation will update existing artifacts to match its own specification.")
-}
-
-// NewCmdJoin defines the `join` command that registers a cluster with
-// a KubeFed control plane.
-func NewCmdJoin(cmdOut io.Writer, config util.FedConfig) *cobra.Command {
-	opts := &joinFederation{}
-
-	cmd := &cobra.Command{
-		Use:     "join CLUSTER_NAME --host-cluster-context=HOST_CONTEXT",
-		Short:   "Register a cluster with a KubeFed control plane",
-		Long:    join_long,
-		Example: join_example,
-		Run: func(cmd *cobra.Command, args []string) {
-			err := opts.Complete(args)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-
-			err = opts.Run(cmdOut, config)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-		},
-	}
-
-	flags := cmd.Flags()
-	opts.GlobalSubcommandBind(flags)
-	opts.CommonSubcommandBind(flags)
-	opts.Bind(flags)
-
-	return cmd
-}
-
-// Complete ensures that options are valid and marshals them if necessary.
-func (j *joinFederation) Complete(args []string) error {
-	err := j.SetName(args)
-	if err != nil {
-		return err
-	}
-
-	if j.ClusterContext == "" {
-		klog.V(2).Infof("Defaulting cluster context to joining cluster name %s", j.ClusterName)
-		j.ClusterContext = j.ClusterName
-	}
-
-	if j.HostClusterName != "" && strings.ContainsAny(j.HostClusterName, ":/") {
-		return goerrors.New("host-cluster-name may not contain \"/\" or \":\"")
-	}
-
-	if j.HostClusterName == "" && strings.ContainsAny(j.HostClusterContext, ":/") {
-		klog.Fatal("host-cluster-name must be set if the name of the host cluster context contains one of \":\" or \"/\"")
-	}
-
-	klog.V(2).Infof("Args and flags: name %s, host: %s, host-system-namespace: %s, kubeconfig: %s, cluster-context: %s, secret-name: %s, dry-run: %v",
-		j.ClusterName, j.HostClusterContext, j.KubeFedNamespace, j.Kubeconfig, j.ClusterContext,
-		j.secretName, j.DryRun)
-
-	return nil
-}
-
-// Run is the implementation of the `join` command.
-func (j *joinFederation) Run(cmdOut io.Writer, config util.FedConfig) error {
-	hostClientConfig := config.GetClientConfig(j.HostClusterContext, j.Kubeconfig)
-	if err := j.SetHostClusterContextFromConfig(hostClientConfig); err != nil {
-		return err
-	}
-
-	hostConfig, err := hostClientConfig.ClientConfig()
-	if err != nil {
-		// TODO(font): Return new error with this same text so it can be output
-		// by caller.
-		klog.V(2).Infof("Failed to get host cluster config: %v", err)
-		return err
-	}
-
-	j.scope, err = options.GetScopeFromKubeFedConfig(hostConfig, j.KubeFedNamespace)
-	if err != nil {
-		return err
-	}
-
-	clusterConfig, err := config.ClusterConfig(j.ClusterContext, j.Kubeconfig)
-	if err != nil {
-		klog.V(2).Infof("Failed to get joining cluster config: %v", err)
-		return err
-	}
-
-	hostClusterName := j.HostClusterContext
-	if j.HostClusterName != "" {
-		hostClusterName = j.HostClusterName
-	}
-
-	_, err = JoinCluster(hostConfig, clusterConfig, j.KubeFedNamespace,
-		hostClusterName, j.ClusterName, j.secretName, j.scope, j.DryRun, j.errorOnExisting)
-
-	return err
-}
-
-// JoinCluster registers a cluster with a KubeFed control plane. The
-// KubeFed namespace in the joining cluster will be the same as in the
-// host cluster.
-func JoinCluster(hostConfig, clusterConfig *rest.Config, kubefedNamespace,
-	hostClusterName, joiningClusterName, secretName string,
-	scope apiextv1b1.ResourceScope, dryRun, errorOnExisting bool) (*fedv1b1.KubeFedCluster, error) {
-
-	return joinClusterForNamespace(hostConfig, clusterConfig, kubefedNamespace,
-		kubefedNamespace, hostClusterName, joiningClusterName, secretName,
-		scope, dryRun, errorOnExisting)
-}
-
-// joinClusterForNamespace registers a cluster with a KubeFed control
-// plane. The KubeFed namespace in the joining cluster is provided by
-// the joiningNamespace parameter.
-func joinClusterForNamespace(hostConfig, clusterConfig *rest.Config, kubefedNamespace,
-	joiningNamespace, hostClusterName, joiningClusterName, secretName string,
-	scope apiextv1b1.ResourceScope, dryRun, errorOnExisting bool) (*fedv1b1.KubeFedCluster, error) {
-
-	hostClientset, err := util.HostClientset(hostConfig)
-	if err != nil {
-		klog.V(2).Infof("Failed to get host cluster clientset: %v", err)
-		return nil, err
-	}
-
-	clusterClientset, err := util.ClusterClientset(clusterConfig)
-	if err != nil {
-		klog.V(2).Infof("Failed to get joining cluster clientset: %v", err)
-		return nil, err
-	}
-
-	client, err := genericclient.New(hostConfig)
-	if err != nil {
-		klog.V(2).Infof("Failed to get kubefed clientset: %v", err)
-		return nil, err
-	}
-
-	klog.V(2).Infof("Performing preflight checks.")
-	err = performPreflightChecks(clusterClientset, joiningClusterName, hostClusterName, joiningNamespace, errorOnExisting)
-	if err != nil {
-		return nil, err
-	}
-
-	klog.V(2).Infof("Creating %s namespace in joining cluster", joiningNamespace)
-	_, err = createKubeFedNamespace(clusterClientset, joiningNamespace,
-		joiningClusterName, dryRun)
-	if err != nil {
-		klog.V(2).Infof("Error creating %s namespace in joining cluster: %v",
-			joiningNamespace, err)
-		return nil, err
-	}
-	klog.V(2).Infof("Created %s namespace in joining cluster", joiningNamespace)
-
-	saName, err := createAuthorizedServiceAccount(clusterClientset,
-		joiningNamespace, joiningClusterName, hostClusterName,
-		scope, dryRun, errorOnExisting)
-	if err != nil {
-		return nil, err
-	}
-
-	secret, caBundle, err := populateSecretInHostCluster(clusterClientset, hostClientset,
-		saName, kubefedNamespace, joiningNamespace, joiningClusterName, secretName, dryRun)
-	if err != nil {
-		klog.V(2).Infof("Error creating secret in host cluster: %s due to: %v", hostClusterName, err)
-		return nil, err
-	}
-
-	var disabledTLSValidations []fedv1b1.TLSValidation
-	if clusterConfig.TLSClientConfig.Insecure {
-		disabledTLSValidations = append(disabledTLSValidations, fedv1b1.TLSAll)
-	}
-
-	kubefedCluster, err := createKubeFedCluster(client, joiningClusterName, clusterConfig.Host,
-		secret.Name, kubefedNamespace, caBundle, disabledTLSValidations, dryRun, errorOnExisting)
-	if err != nil {
-		klog.V(2).Infof("Failed to create federated cluster resource: %v", err)
-		return nil, err
-	}
-
-	klog.V(2).Info("Created federated cluster resource")
-	return kubefedCluster, nil
-}
-
-// This function is exported for testing purposes only.
-var TestOnly_JoinClusterForNamespace = joinClusterForNamespace
-
-// performPreflightChecks checks that the host and joining clusters are in
-// a consistent state.
-func performPreflightChecks(clusterClientset kubeclient.Interface, name, hostClusterName,
-	kubefedNamespace string, errorOnExisting bool) error {
-	// Make sure there is no existing service account in the joining cluster.
-	saName := util.ClusterServiceAccountName(name, hostClusterName)
-	_, err := clusterClientset.CoreV1().ServiceAccounts(kubefedNamespace).Get(saName,
-		metav1.GetOptions{})
-
-	switch {
-	case apierrors.IsNotFound(err):
-		return nil
-	case err != nil:
-		return err
-	case errorOnExisting:
-		return errors.Errorf("service account: %s already exists in joining cluster: %s", saName, name)
-	default:
-		klog.V(2).Infof("Service account %s already exists in joining cluster %s", saName, name)
-		return nil
-	}
-}
-
-// createKubeFedCluster creates a federated cluster resource that associates
-// the cluster and secret.
-func createKubeFedCluster(client genericclient.Client, joiningClusterName, apiEndpoint,
-	secretName, kubefedNamespace string, caBundle []byte, disabledTLSValidations []fedv1b1.TLSValidation,
-	dryRun, errorOnExisting bool) (*fedv1b1.KubeFedCluster, error) {
-	fedCluster := &fedv1b1.KubeFedCluster{
-		ObjectMeta: metav1.ObjectMeta{
-			Namespace: kubefedNamespace,
-			Name:      joiningClusterName,
-		},
-		Spec: fedv1b1.KubeFedClusterSpec{
-			APIEndpoint: apiEndpoint,
-			CABundle:    caBundle,
-			SecretRef: fedv1b1.LocalSecretReference{
-				Name: secretName,
-			},
-			DisabledTLSValidations: disabledTLSValidations,
-		},
-	}
-
-	if dryRun {
-		return fedCluster, nil
-	}
-
-	existingFedCluster := &fedv1b1.KubeFedCluster{}
-	err := client.Get(context.TODO(), existingFedCluster, kubefedNamespace, joiningClusterName)
-	switch {
-	case err != nil && !apierrors.IsNotFound(err):
-		klog.V(2).Infof("Could not retrieve federated cluster %s due to %v", joiningClusterName, err)
-		return nil, err
-	case err == nil && errorOnExisting:
-		return nil, errors.Errorf("federated cluster %s already exists in host cluster", joiningClusterName)
-	case err == nil:
-		existingFedCluster.Spec = fedCluster.Spec
-		err = client.Update(context.TODO(), existingFedCluster)
-		if err != nil {
-			klog.V(2).Infof("Could not update federated cluster %s due to %v", fedCluster.Name, err)
-			return nil, err
-		}
-		return existingFedCluster, nil
-	default:
-		err = client.Create(context.TODO(), fedCluster)
-		if err != nil {
-			klog.V(2).Infof("Could not create federated cluster %s due to %v", fedCluster.Name, err)
-			return nil, err
-		}
-		return fedCluster, nil
-	}
-}
-
-// createKubeFedNamespace creates the kubefed namespace in the cluster
-// associated with clusterClientset, if it doesn't already exist.
-func createKubeFedNamespace(clusterClientset kubeclient.Interface, kubefedNamespace,
-	joiningClusterName string, dryRun bool) (*corev1.Namespace, error) {
-	fedNamespace := &corev1.Namespace{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: kubefedNamespace,
-		},
-	}
-
-	if dryRun {
-		return fedNamespace, nil
-	}
-
-	_, err := clusterClientset.CoreV1().Namespaces().Get(kubefedNamespace, metav1.GetOptions{})
-	if err != nil && !apierrors.IsNotFound(err) {
-		klog.V(2).Infof("Could not get %s namespace: %v", kubefedNamespace, err)
-		return nil, err
-	}
-
-	if err == nil {
-		klog.V(2).Infof("Already existing %s namespace", kubefedNamespace)
-		return fedNamespace, nil
-	}
-
-	// Not found, so create.
-	_, err = clusterClientset.CoreV1().Namespaces().Create(fedNamespace)
-	if err != nil && !apierrors.IsAlreadyExists(err) {
-		klog.V(2).Infof("Could not create %s namespace: %v", kubefedNamespace, err)
-		return nil, err
-	}
-	return fedNamespace, nil
-}
-
-// createAuthorizedServiceAccount creates a service account and grants
-// the privileges required by the KubeFed control plane to manage
-// resources in the joining cluster.  The name of the created service
-// account is returned on success.
-func createAuthorizedServiceAccount(joiningClusterClientset kubeclient.Interface,
-	namespace, joiningClusterName, hostClusterName string,
-	scope apiextv1b1.ResourceScope, dryRun, errorOnExisting bool) (string, error) {
-
-	klog.V(2).Infof("Creating service account in joining cluster: %s", joiningClusterName)
-
-	saName, err := createServiceAccount(joiningClusterClientset, namespace,
-		joiningClusterName, hostClusterName, dryRun, errorOnExisting)
-	if err != nil {
-		klog.V(2).Infof("Error creating service account: %s in joining cluster: %s due to: %v",
-			saName, joiningClusterName, err)
-		return "", err
-	}
-
-	klog.V(2).Infof("Created service account: %s in joining cluster: %s", saName, joiningClusterName)
-
-	if scope == apiextv1b1.NamespaceScoped {
-		klog.V(2).Infof("Creating role and binding for service account: %s in joining cluster: %s", saName, joiningClusterName)
-
-		err = createRoleAndBinding(joiningClusterClientset, saName, namespace, joiningClusterName, dryRun, errorOnExisting)
-		if err != nil {
-			klog.V(2).Infof("Error creating role and binding for service account: %s in joining cluster: %s due to: %v", saName, joiningClusterName, err)
-			return "", err
-		}
-
-		klog.V(2).Infof("Created role and binding for service account: %s in joining cluster: %s",
-			saName, joiningClusterName)
-
-		klog.V(2).Infof("Creating health check cluster role and binding for service account: %s in joining cluster: %s", saName, joiningClusterName)
-
-		err = createHealthCheckClusterRoleAndBinding(joiningClusterClientset, saName, namespace, joiningClusterName,
-			dryRun, errorOnExisting)
-		if err != nil {
-			klog.V(2).Infof("Error creating health check cluster role and binding for service account: %s in joining cluster: %s due to: %v",
-				saName, joiningClusterName, err)
-			return "", err
-		}
-
-		klog.V(2).Infof("Created health check cluster role and binding for service account: %s in joining cluster: %s",
-			saName, joiningClusterName)
-
-	} else {
-		klog.V(2).Infof("Creating cluster role and binding for service account: %s in joining cluster: %s", saName, joiningClusterName)
-
-		err = createClusterRoleAndBinding(joiningClusterClientset, saName, namespace, joiningClusterName, dryRun, errorOnExisting)
-		if err != nil {
-			klog.V(2).Infof("Error creating cluster role and binding for service account: %s in joining cluster: %s due to: %v",
-				saName, joiningClusterName, err)
-			return "", err
-		}
-
-		klog.V(2).Infof("Created cluster role and binding for service account: %s in joining cluster: %s",
-			saName, joiningClusterName)
-	}
-
-	return saName, nil
-}
-
-// createServiceAccount creates a service account in the cluster associated
-// with clusterClientset with credentials that will be used by the host cluster
-// to access its API server.
-func createServiceAccount(clusterClientset kubeclient.Interface, namespace,
-	joiningClusterName, hostClusterName string, dryRun, errorOnExisting bool) (string, error) {
-	saName := util.ClusterServiceAccountName(joiningClusterName, hostClusterName)
-	sa := &corev1.ServiceAccount{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      saName,
-			Namespace: namespace,
-		},
-	}
-
-	if dryRun {
-		return saName, nil
-	}
-
-	// Create a new service account.
-	_, err := clusterClientset.CoreV1().ServiceAccounts(namespace).Create(sa)
-	switch {
-	case apierrors.IsAlreadyExists(err) && errorOnExisting:
-		klog.V(2).Infof("Service account %s/%s already exists in target cluster %s", namespace, saName, joiningClusterName)
-		return "", err
-	case err != nil && !apierrors.IsAlreadyExists(err):
-		klog.V(2).Infof("Could not create service account %s/%s in target cluster %s due to: %v", namespace, saName, joiningClusterName, err)
-		return "", err
-	default:
-		return saName, nil
-	}
-}
-
-func bindingSubjects(saName, namespace string) []rbacv1.Subject {
-	return []rbacv1.Subject{
-		{
-			Kind:      rbacv1.ServiceAccountKind,
-			Name:      saName,
-			Namespace: namespace,
-		},
-	}
-}
-
-// createClusterRoleAndBinding creates an RBAC cluster role and
-// binding that allows the service account identified by saName to
-// access all resources in all namespaces in the cluster associated
-// with clientset.
-func createClusterRoleAndBinding(clientset kubeclient.Interface, saName, namespace, clusterName string, dryRun, errorOnExisting bool) error {
-	if dryRun {
-		return nil
-	}
-
-	roleName := util.RoleName(saName)
-
-	role := &rbacv1.ClusterRole{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: roleName,
-		},
-		Rules: clusterPolicyRules,
-	}
-	existingRole, err := clientset.RbacV1().ClusterRoles().Get(roleName, metav1.GetOptions{})
-	switch {
-	case err != nil && !apierrors.IsNotFound(err):
-		klog.V(2).Infof("Could not get cluster role for service account %s in joining cluster %s due to %v",
-			saName, clusterName, err)
-		return err
-	case err == nil && errorOnExisting:
-		return errors.Errorf("cluster role for service account %s in joining cluster %s already exists", saName, clusterName)
-	case err == nil:
-		existingRole.Rules = role.Rules
-		_, err := clientset.RbacV1().ClusterRoles().Update(existingRole)
-		if err != nil {
-			klog.V(2).Infof("Could not update cluster role for service account: %s in joining cluster: %s due to: %v",
-				saName, clusterName, err)
-			return err
-		}
-	default: // role was not found
-		_, err := clientset.RbacV1().ClusterRoles().Create(role)
-		if err != nil {
-			klog.V(2).Infof("Could not create cluster role for service account: %s in joining cluster: %s due to: %v",
-				saName, clusterName, err)
-			return err
-		}
-	}
-
-	// TODO: This should limit its access to only necessary resources.
-	binding := &rbacv1.ClusterRoleBinding{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: roleName,
-		},
-		Subjects: bindingSubjects(saName, namespace),
-		RoleRef: rbacv1.RoleRef{
-			APIGroup: rbacv1.GroupName,
-			Kind:     "ClusterRole",
-			Name:     roleName,
-		},
-	}
-	existingBinding, err := clientset.RbacV1().ClusterRoleBindings().Get(binding.Name, metav1.GetOptions{})
-	switch {
-	case err != nil && !apierrors.IsNotFound(err):
-		klog.V(2).Infof("Could not get cluster role binding for service account %s in joining cluster %s due to %v",
-			saName, clusterName, err)
-		return err
-	case err == nil && errorOnExisting:
-		return errors.Errorf("cluster role binding for service account %s in joining cluster %s already exists", saName, clusterName)
-	case err == nil:
-		// The roleRef cannot be updated, therefore if the existing roleRef is different, the existing rolebinding
-		// must be deleted and recreated with the correct roleRef
-		if !reflect.DeepEqual(existingBinding.RoleRef, binding.RoleRef) {
-			err = clientset.RbacV1().ClusterRoleBindings().Delete(existingBinding.Name, &metav1.DeleteOptions{})
-			if err != nil {
-				klog.V(2).Infof("Could not delete existing cluster role binding for service account %s in joining cluster %s due to: %v",
-					saName, clusterName, err)
-				return err
-			}
-			_, err = clientset.RbacV1().ClusterRoleBindings().Create(binding)
-			if err != nil {
-				klog.V(2).Infof("Could not create cluster role binding for service account: %s in joining cluster: %s due to: %v",
-					saName, clusterName, err)
-				return err
-			}
-		} else {
-			existingBinding.Subjects = binding.Subjects
-			_, err := clientset.RbacV1().ClusterRoleBindings().Update(existingBinding)
-			if err != nil {
-				klog.V(2).Infof("Could not update cluster role binding for service account: %s in joining cluster: %s due to: %v",
-					saName, clusterName, err)
-				return err
-			}
-		}
-	default:
-		_, err = clientset.RbacV1().ClusterRoleBindings().Create(binding)
-		if err != nil {
-			klog.V(2).Infof("Could not create cluster role binding for service account: %s in joining cluster: %s due to: %v",
-				saName, clusterName, err)
-			return err
-		}
-	}
-	return nil
-}
-
-// createRoleAndBinding creates an RBAC role and binding
-// that allows the service account identified by saName to access all
-// resources in the specified namespace.
-func createRoleAndBinding(clientset kubeclient.Interface, saName, namespace, clusterName string, dryRun, errorOnExisting bool) error {
-	if dryRun {
-		return nil
-	}
-
-	roleName := util.RoleName(saName)
-
-	role := &rbacv1.Role{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: roleName,
-		},
-		Rules: namespacedPolicyRules,
-	}
-	existingRole, err := clientset.RbacV1().Roles(namespace).Get(roleName, metav1.GetOptions{})
-	switch {
-	case err != nil && !apierrors.IsNotFound(err):
-		klog.V(2).Infof("Could not retrieve role for service account %s in joining cluster %s due to %v", saName, clusterName, err)
-		return err
-	case errorOnExisting && err == nil:
-		return errors.Errorf("role for service account %s in joining cluster %s already exists", saName, clusterName)
-	case err == nil:
-		existingRole.Rules = role.Rules
-		_, err = clientset.RbacV1().Roles(namespace).Update(existingRole)
-		if err != nil {
-			klog.V(2).Infof("Could not update role for service account: %s in joining cluster: %s due to: %v",
-				saName, clusterName, err)
-			return err
-		}
-	default:
-		_, err := clientset.RbacV1().Roles(namespace).Create(role)
-		if err != nil {
-			klog.V(2).Infof("Could not create role for service account: %s in joining cluster: %s due to: %v",
-				saName, clusterName, err)
-			return err
-		}
-	}
-
-	binding := &rbacv1.RoleBinding{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: roleName,
-		},
-		Subjects: bindingSubjects(saName, namespace),
-		RoleRef: rbacv1.RoleRef{
-			APIGroup: rbacv1.GroupName,
-			Kind:     "Role",
-			Name:     roleName,
-		},
-	}
-
-	existingBinding, err := clientset.RbacV1().RoleBindings(namespace).Get(binding.Name, metav1.GetOptions{})
-	switch {
-	case err != nil && !apierrors.IsNotFound(err):
-		klog.V(2).Infof("Could not retrieve role binding for service account %s in joining cluster %s due to: %v",
-			saName, clusterName, err)
-		return err
-	case err == nil && errorOnExisting:
-		return errors.Errorf("role binding for service account %s in joining cluster %s already exists", saName, clusterName)
-	case err == nil:
-		// The roleRef cannot be updated, therefore if the existing roleRef is different, the existing rolebinding
-		// must be deleted and recreated with the correct roleRef
-		if !reflect.DeepEqual(existingBinding.RoleRef, binding.RoleRef) {
-			err = clientset.RbacV1().RoleBindings(namespace).Delete(existingBinding.Name, &metav1.DeleteOptions{})
-			if err != nil {
-				klog.V(2).Infof("Could not delete existing role binding for service account %s in joining cluster %s due to: %v",
-					saName, clusterName, err)
-				return err
-			}
-			_, err = clientset.RbacV1().RoleBindings(namespace).Create(binding)
-			if err != nil {
-				klog.V(2).Infof("Could not create role binding for service account: %s in joining cluster: %s due to: %v",
-					saName, clusterName, err)
-				return err
-			}
-		} else {
-			existingBinding.Subjects = binding.Subjects
-			_, err = clientset.RbacV1().RoleBindings(namespace).Update(existingBinding)
-			if err != nil {
-				klog.V(2).Infof("Could not update role binding for service account %s in joining cluster %s due to: %v",
-					saName, clusterName, err)
-				return err
-			}
-		}
-	default:
-		_, err = clientset.RbacV1().RoleBindings(namespace).Create(binding)
-		if err != nil {
-			klog.V(2).Infof("Could not create role binding for service account: %s in joining cluster: %s due to: %v",
-				saName, clusterName, err)
-			return err
-		}
-	}
-
-	return nil
-}
-
-// createHealthCheckClusterRoleAndBinding creates an RBAC cluster role and
-// binding that allows the service account identified by saName to
-// access the health check path of the cluster.
-func createHealthCheckClusterRoleAndBinding(clientset kubeclient.Interface, saName, namespace, clusterName string, dryRun, errorOnExisting bool) error {
-	if dryRun {
-		return nil
-	}
-
-	roleName := util.HealthCheckRoleName(saName, namespace)
-
-	role := &rbacv1.ClusterRole{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: roleName,
-		},
-		Rules: []rbacv1.PolicyRule{
-			{
-				Verbs:           []string{"Get"},
-				NonResourceURLs: []string{"/healthz"},
-			},
-			// The cluster client expects to be able to list nodes to retrieve zone and region details.
-			// TODO(marun) Consider making zone/region retrieval optional
-			{
-				Verbs:     []string{"list"},
-				APIGroups: []string{""},
-				Resources: []string{"nodes"},
-			},
-		},
-	}
-	existingRole, err := clientset.RbacV1().ClusterRoles().Get(role.Name, metav1.GetOptions{})
-	switch {
-	case err != nil && !apierrors.IsNotFound(err):
-		klog.V(2).Infof("Could not get health check cluster role for service account %s in joining cluster %s due to %v",
-			saName, clusterName, err)
-		return err
-	case err == nil && errorOnExisting:
-		return errors.Errorf("health check cluster role for service account %s in joining cluster %s already exists", saName, clusterName)
-	case err == nil:
-		existingRole.Rules = role.Rules
-		_, err := clientset.RbacV1().ClusterRoles().Update(existingRole)
-		if err != nil {
-			klog.V(2).Infof("Could not update health check cluster role for service account: %s in joining cluster: %s due to: %v",
-				saName, clusterName, err)
-			return err
-		}
-	default: // role was not found
-		_, err := clientset.RbacV1().ClusterRoles().Create(role)
-		if err != nil {
-			klog.V(2).Infof("Could not create health check cluster role for service account: %s in joining cluster: %s due to: %v",
-				saName, clusterName, err)
-			return err
-		}
-	}
-
-	binding := &rbacv1.ClusterRoleBinding{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: roleName,
-		},
-		Subjects: bindingSubjects(saName, namespace),
-		RoleRef: rbacv1.RoleRef{
-			APIGroup: rbacv1.GroupName,
-			Kind:     "ClusterRole",
-			Name:     roleName,
-		},
-	}
-	existingBinding, err := clientset.RbacV1().ClusterRoleBindings().Get(binding.Name, metav1.GetOptions{})
-	switch {
-	case err != nil && !apierrors.IsNotFound(err):
-		klog.V(2).Infof("Could not get health check cluster role binding for service account %s in joining cluster %s due to %v",
-			saName, clusterName, err)
-		return err
-	case err == nil && errorOnExisting:
-		return errors.Errorf("health check cluster role binding for service account %s in joining cluster %s already exists", saName, clusterName)
-	case err == nil:
-		// The roleRef cannot be updated, therefore if the existing roleRef is different, the existing rolebinding
-		// must be deleted and recreated with the correct roleRef
-		if !reflect.DeepEqual(existingBinding.RoleRef, binding.RoleRef) {
-			err = clientset.RbacV1().ClusterRoleBindings().Delete(existingBinding.Name, &metav1.DeleteOptions{})
-			if err != nil {
-				klog.V(2).Infof("Could not delete existing health check cluster role binding for service account %s in joining cluster %s due to: %v",
-					saName, clusterName, err)
-				return err
-			}
-			_, err = clientset.RbacV1().ClusterRoleBindings().Create(binding)
-			if err != nil {
-				klog.V(2).Infof("Could not create health check cluster role binding for service account: %s in joining cluster: %s due to: %v",
-					saName, clusterName, err)
-				return err
-			}
-		} else {
-			existingBinding.Subjects = binding.Subjects
-			_, err := clientset.RbacV1().ClusterRoleBindings().Update(existingBinding)
-			if err != nil {
-				klog.V(2).Infof("Could not update health check cluster role binding for service account: %s in joining cluster: %s due to: %v",
-					saName, clusterName, err)
-				return err
-			}
-		}
-	default:
-		_, err = clientset.RbacV1().ClusterRoleBindings().Create(binding)
-		if err != nil {
-			klog.V(2).Infof("Could not create health check cluster role binding for service account: %s in joining cluster: %s due to: %v",
-				saName, clusterName, err)
-			return err
-		}
-	}
-	return nil
-}
-
-// populateSecretInHostCluster copies the service account secret for saName
-// from the cluster referenced by clusterClientset to the client referenced by
-// hostClientset, putting it in a secret named secretName in the provided
-// namespace.
-func populateSecretInHostCluster(clusterClientset, hostClientset kubeclient.Interface,
-	saName, hostNamespace, joiningNamespace, joiningClusterName, secretName string,
-	dryRun bool) (*corev1.Secret, []byte, error) {
-
-	klog.V(2).Infof("Creating cluster credentials secret in host cluster")
-
-	if dryRun {
-		dryRunSecret := &corev1.Secret{}
-		dryRunSecret.Name = secretName
-		return dryRunSecret, nil, nil
-	}
-
-	// Get the secret from the joining cluster.
-	var secret *corev1.Secret
-	err := wait.PollImmediate(1*time.Second, serviceAccountSecretTimeout, func() (bool, error) {
-		sa, err := clusterClientset.CoreV1().ServiceAccounts(joiningNamespace).Get(saName,
-			metav1.GetOptions{})
-		if err != nil {
-			return false, nil
-		}
-
-		for _, objReference := range sa.Secrets {
-			saSecretName := objReference.Name
-			var err error
-			secret, err = clusterClientset.CoreV1().Secrets(joiningNamespace).Get(saSecretName,
-				metav1.GetOptions{})
-			if err != nil {
-				return false, nil
-			}
-			if secret.Type == corev1.SecretTypeServiceAccountToken {
-				klog.V(2).Infof("Using secret named: %s", secret.Name)
-				return true, nil
-			}
-		}
-		return false, nil
-	})
-
-	if err != nil {
-		klog.V(2).Infof("Could not get service account secret from joining cluster: %v", err)
-		return nil, nil, err
-	}
-
-	token, ok := secret.Data[ctlutil.TokenKey]
-	if !ok {
-		return nil, nil, errors.Errorf("Key %q not found in service account secret", ctlutil.TokenKey)
-	}
-
-	// Create a secret in the host cluster containing the token.
-	v1Secret := corev1.Secret{
-		ObjectMeta: metav1.ObjectMeta{
-			Namespace: hostNamespace,
-		},
-		Data: map[string][]byte{
-			ctlutil.TokenKey: token,
-		},
-	}
-
-	if secretName == "" {
-		v1Secret.GenerateName = joiningClusterName + "-"
-	} else {
-		v1Secret.Name = secretName
-	}
-
-	v1SecretResult, err := hostClientset.CoreV1().Secrets(hostNamespace).Create(&v1Secret)
-	if err != nil {
-		klog.V(2).Infof("Could not create secret in host cluster: %v", err)
-		return nil, nil, err
-	}
-
-	// caBundle is optional so no error is suggested if it is not
-	// found in the secret.
-	caBundle := secret.Data["ca.crt"]
-
-	klog.V(2).Infof("Created secret in host cluster named: %s", v1SecretResult.Name)
-	return v1SecretResult, caBundle, nil
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/kubefedctl.go

@@ -1,72 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 kubefedctl
-
-import (
-	"flag"
-	"io"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
-	"k8s.io/client-go/tools/clientcmd"
-	apiserverflag "k8s.io/component-base/cli/flag"
-
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/enable"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/federate"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/orphaning"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/util"
-)
-
-// NewKubeFedCtlCommand creates the `kubefedctl` command and its nested children.
-func NewKubeFedCtlCommand(out io.Writer) *cobra.Command {
-	// Parent command to which all subcommands are added.
-	rootCmd := &cobra.Command{
-		Use:   "kubefedctl",
-		Short: "kubefedctl controls a Kubernetes Cluster Federation",
-		Long:  "kubefedctl controls a Kubernetes Cluster Federation. Find more information at https://sigs.k8s.io/kubefed.",
-
-		RunE: runHelp,
-	}
-
-	// Add the command line flags from other dependencies (e.g., klog), but do not
-	// warn if they contain underscores.
-	pflag.CommandLine.SetNormalizeFunc(apiserverflag.WordSepNormalizeFunc)
-	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
-	rootCmd.PersistentFlags().AddFlagSet(pflag.CommandLine)
-
-	// From this point and forward we get warnings on flags that contain "_" separators
-	rootCmd.SetGlobalNormalizationFunc(apiserverflag.WarnWordSepNormalizeFunc)
-
-	// Prevent klog errors about logging before parsing.
-	_ = flag.CommandLine.Parse(nil)
-
-	fedConfig := util.NewFedConfig(clientcmd.NewDefaultPathOptions())
-	rootCmd.AddCommand(enable.NewCmdTypeEnable(out, fedConfig))
-	rootCmd.AddCommand(NewCmdTypeDisable(out, fedConfig))
-	rootCmd.AddCommand(federate.NewCmdFederateResource(out, fedConfig))
-	rootCmd.AddCommand(NewCmdJoin(out, fedConfig))
-	rootCmd.AddCommand(NewCmdUnjoin(out, fedConfig))
-	rootCmd.AddCommand(orphaning.NewCmdOrphaning(out, fedConfig))
-	rootCmd.AddCommand(NewCmdVersion(out))
-
-	return rootCmd
-}
-
-func runHelp(cmd *cobra.Command, args []string) error {
-	return cmd.Help()
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/orphaning/disable.go

@@ -1,98 +0,0 @@
-/*
-Copyright 2019 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 orphaning
-
-import (
-	"io"
-
-	"github.com/pkg/errors"
-	"github.com/spf13/cobra"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/klog"
-
-	ctlutil "sigs.k8s.io/kubefed/pkg/controller/util"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/util"
-)
-
-var (
-	orphaning_disable_long = `
-		Removes previously added "orphaning enable" ('kubefed.io/orphan: true')
-		annotation from a federated resource.  When the federated resource is subsequently marked for deletion,
-		the resources it manages in member clusters will be removed before the federated resource is removed.
-
-		Current context is assumed to be a Kubernetes cluster hosting
-		the kubefed control plane. Please use the
-		--host-cluster-context flag otherwise.`
-
-	orphaning_disable_example = `
-		# Disable the orphaning mode for a federated resource of type FederatedDeployment and named foo 
-		kubefedctl orphaning disable FederatedDeployment foo --host-cluster-context=cluster1`
-)
-
-// newCmdDisableOrphaning removes the 'kubefed.io/orphan: true' annotation from the federated resource
-func newCmdDisableOrphaning(cmdOut io.Writer, config util.FedConfig) *cobra.Command {
-	opts := &orphanResource{}
-	cmd := &cobra.Command{
-		Use:     "disable <resource type> <resource name>",
-		Short:   "Disable orphaning deletion to ensure the removal of managed resources before removing the managing federated resource",
-		Long:    orphaning_disable_long,
-		Example: orphaning_disable_example,
-		Run: func(cmd *cobra.Command, args []string) {
-			err := opts.Complete(args, config)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-
-			err = opts.RunDisable(cmdOut, config)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-		},
-	}
-
-	flags := cmd.Flags()
-	opts.GlobalSubcommandBind(flags)
-	err := opts.Bind(flags)
-	if err != nil {
-		klog.Fatalf("Error: %v", err)
-	}
-
-	return cmd
-}
-
-// RunDisable implements the `disable` command.
-func (o *orphanResource) RunDisable(cmdOut io.Writer, config util.FedConfig) error {
-	resourceClient, err := o.GetResourceClient(config, cmdOut)
-	if err != nil {
-		return err
-	}
-	fedResource, err := o.GetFederatedResource(resourceClient)
-	if err != nil {
-		return err
-	}
-	if !ctlutil.IsOrphaningEnabled(fedResource) {
-		return nil
-	}
-	ctlutil.DisableOrphaning(fedResource)
-	_, err = resourceClient.Update(fedResource, metav1.UpdateOptions{})
-	if err != nil {
-		return errors.Wrapf(err, "Failed to update resource %s %q", fedResource.GetKind(),
-			ctlutil.QualifiedName{Name: fedResource.GetName(), Namespace: fedResource.GetNamespace()})
-	}
-	return nil
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/orphaning/enable.go

@@ -1,99 +0,0 @@
-/*
-Copyright 2019 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 orphaning
-
-import (
-	"io"
-
-	"github.com/pkg/errors"
-	"github.com/spf13/cobra"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/klog"
-
-	ctlutil "sigs.k8s.io/kubefed/pkg/controller/util"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/util"
-)
-
-var (
-	orphaning_enable_long = `
-		Prevents the removal of managed resources from member clusters when their managing federated 
-		resource is removed. This is accomplished by adding 'kubefed.io/orphan: true' as an annotation to the 
-		federated resource.
-
-		Current context is assumed to be a Kubernetes cluster hosting
-		the kubefed control plane. Please use the
-		--host-cluster-context flag otherwise.`
-
-	orphan_enable_example = `
-		# Enable the orphaning mode for a federated resource of type FederatedDeployment and named foo 
-		kubefedctl orphaning enable FederatedDeployment foo --host-cluster-context=cluster1`
-)
-
-// newCmdEnableOrphaning adds 'kubefed.io/orphan: true' as an annotation to the federated resource
-func newCmdEnableOrphaning(cmdOut io.Writer, config util.FedConfig) *cobra.Command {
-	opts := &orphanResource{}
-	cmd := &cobra.Command{
-		Use:     "enable <resource type> <resource name>",
-		Short:   "Enable the orphaning (i.e. retention) of resources managed by a federated resource upon its removal.",
-		Long:    orphaning_enable_long,
-		Example: orphan_enable_example,
-		Run: func(cmd *cobra.Command, args []string) {
-			err := opts.Complete(args, config)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-
-			err = opts.RunEnable(cmdOut, config)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-		},
-	}
-
-	flags := cmd.Flags()
-	opts.GlobalSubcommandBind(flags)
-	err := opts.Bind(flags)
-	if err != nil {
-		klog.Fatalf("Error: %v", err)
-	}
-
-	return cmd
-}
-
-// RunEnable implements the `enable` command.
-func (o *orphanResource) RunEnable(cmdOut io.Writer, config util.FedConfig) error {
-	resourceClient, err := o.GetResourceClient(config, cmdOut)
-	if err != nil {
-		return err
-	}
-	fedResource, err := o.GetFederatedResource(resourceClient)
-	if err != nil {
-		return err
-	}
-	if ctlutil.IsOrphaningEnabled(fedResource) {
-		return nil
-	}
-	ctlutil.EnableOrphaning(fedResource)
-	_, err = resourceClient.Update(fedResource, metav1.UpdateOptions{})
-	if err != nil {
-		return errors.Wrapf(err, "Failed to update resource %s %q", fedResource.GetKind(),
-			ctlutil.QualifiedName{Name: fedResource.GetName(), Namespace: fedResource.GetNamespace()})
-	}
-
-	return nil
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/orphaning/orphaning.go

@@ -1,140 +0,0 @@
-/*
-Copyright 2019 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 orphaning
-
-import (
-	"fmt"
-	"io"
-
-	"github.com/pkg/errors"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/client-go/dynamic"
-	"k8s.io/klog"
-
-	"sigs.k8s.io/kubefed/pkg/apis/core/typeconfig"
-	ctlutil "sigs.k8s.io/kubefed/pkg/controller/util"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/enable"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/options"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/util"
-)
-
-type orphanResource struct {
-	options.GlobalSubcommandOptions
-	typeName          string
-	resourceName      string
-	resourceNamespace string
-}
-
-// Bind adds the join specific arguments to the flagset passed in as an argument.
-func (o *orphanResource) Bind(flags *pflag.FlagSet) error {
-	flags.StringVarP(&o.resourceNamespace, "namespace", "n", "", "If present, the namespace scope for this CLI request")
-	err := flags.MarkHidden("kubefed-namespace")
-	if err != nil {
-		return err
-	}
-	err = flags.MarkHidden("dry-run")
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// NewCmdOrphaning the head of orphaning-deletion sub commands
-func NewCmdOrphaning(cmdOut io.Writer, config util.FedConfig) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "orphaning-deletion",
-		Short: "Manage orphaning delete policy",
-		Long:  "Manage orphaning delete policy",
-		Run: func(cmd *cobra.Command, args []string) {
-			err := cmd.Help()
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-		},
-	}
-	cmd.AddCommand(newCmdEnableOrphaning(cmdOut, config))
-	cmd.AddCommand(newCmdDisableOrphaning(cmdOut, config))
-	cmd.AddCommand(newCmdStatusOrphaning(cmdOut, config))
-
-	return cmd
-}
-
-//  Complete ensures that options are valid and marshals them if necessary.
-func (o *orphanResource) Complete(args []string, config util.FedConfig) error {
-	if len(args) == 0 {
-		return errors.New("resource type is required")
-	}
-
-	o.typeName = args[0]
-
-	if len(args) == 1 {
-		return errors.New("resource name is required")
-	}
-	o.resourceName = args[1]
-
-	if len(o.resourceNamespace) == 0 {
-		var err error
-		o.resourceNamespace, err = util.GetNamespace(o.HostClusterContext, o.Kubeconfig, config)
-		return err
-	}
-	return nil
-}
-
-// Returns a Federated Resources Interface
-func (o *orphanResource) GetResourceClient(config util.FedConfig, cmdOut io.Writer) (dynamic.ResourceInterface, error) {
-	hostClientConfig := config.GetClientConfig(o.HostClusterContext, o.Kubeconfig)
-	if err := o.SetHostClusterContextFromConfig(hostClientConfig); err != nil {
-		return nil, err
-	}
-	hostConfig, err := hostClientConfig.ClientConfig()
-	if err != nil {
-		return nil, errors.Wrapf(err, "Unable to load configuration for cluster context %q in kubeconfig %q.`",
-			o.HostClusterContext, o.Kubeconfig)
-	}
-	// Lookup kubernetes API availability
-	apiResource, err := enable.LookupAPIResource(hostConfig, o.typeName, "")
-	if err != nil {
-		return nil, errors.Wrapf(err, "Failed to find targeted %s type", o.typeName)
-	}
-	klog.V(2).Infof("API Resource for %s/%s found", typeconfig.GroupQualifiedName(*apiResource), apiResource.Version)
-	if !util.IsFederatedAPIResource(apiResource.Kind, apiResource.Group) {
-		fmt.Fprintf(cmdOut, "Warning: %s/%s might not be a federated resource\n",
-			typeconfig.GroupQualifiedName(*apiResource), apiResource.Version)
-	}
-	targetClient, err := ctlutil.NewResourceClient(hostConfig, apiResource)
-
-	if err != nil {
-		return nil, errors.Wrapf(err, "Error creating client for %s", apiResource.Kind)
-	}
-
-	resourceClient := targetClient.Resources(o.resourceNamespace)
-	return resourceClient, nil
-}
-
-// Returns the Federated resource where the orphaning-deletion will be managed
-func (o *orphanResource) GetFederatedResource(resourceClient dynamic.ResourceInterface) (*unstructured.Unstructured, error) {
-	resource, err := resourceClient.Get(o.resourceName, metav1.GetOptions{})
-	if err != nil {
-		return nil, errors.Wrapf(err, "Failed to retrieve resource: %q",
-			ctlutil.QualifiedName{Name: o.resourceName, Namespace: o.resourceNamespace})
-	}
-	return resource, nil
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/orphaning/status.go

@@ -1,95 +0,0 @@
-/*
-Copyright 2019 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 orphaning
-
-import (
-	"io"
-
-	"github.com/spf13/cobra"
-
-	"k8s.io/klog"
-
-	ctlutil "sigs.k8s.io/kubefed/pkg/controller/util"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/util"
-)
-
-const (
-	Enabled  = "Enabled"
-	Disabled = "Disabled"
-)
-
-var (
-	orphaning_status_long = `
-		Checks the status of "orphaning enable" ('kubefed.io/orphan: true') annotation on a federated resource. 
-		Returns "Enabled" or "Disabled"
-
-		Current context is assumed to be a Kubernetes cluster hosting the kubefed control plane. 
-		Please use the --host-cluster-context flag otherwise.`
-
-	orphaning_status_example = `
-		# Checks the status of the orphaning mode of a federated resource of type FederatedDeployment and named foo 
-		kubefedctl orphaning status FederatedDeployment foo --host-cluster-context=cluster1`
-)
-
-// newCmdStatusOrphaning checks status of orphaning deletion of the federated resource
-func newCmdStatusOrphaning(cmdOut io.Writer, config util.FedConfig) *cobra.Command {
-	opts := &orphanResource{}
-	cmd := &cobra.Command{
-		Use:     "status <resource type> <resource name>",
-		Short:   "Get the orphaning deletion status of the federated resource",
-		Long:    orphaning_status_long,
-		Example: orphaning_status_example,
-		Run: func(cmd *cobra.Command, args []string) {
-			err := opts.Complete(args, config)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-
-			err = opts.RunStatus(cmdOut, config)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-		},
-	}
-
-	flags := cmd.Flags()
-	opts.GlobalSubcommandBind(flags)
-	err := opts.Bind(flags)
-	if err != nil {
-		klog.Fatalf("Error: %v", err)
-	}
-
-	return cmd
-}
-
-// RunStatus implements the `status` command.
-func (o *orphanResource) RunStatus(cmdOut io.Writer, config util.FedConfig) error {
-	resourceClient, err := o.GetResourceClient(config, cmdOut)
-	if err != nil {
-		return err
-	}
-	fedResource, err := o.GetFederatedResource(resourceClient)
-	if err != nil {
-		return err
-	}
-	if ctlutil.IsOrphaningEnabled(fedResource) {
-		_, err = cmdOut.Write([]byte(Enabled + "\n"))
-		return err
-	}
-	_, err = cmdOut.Write([]byte(Disabled + "\n"))
-	return err
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/unjoin.go

@@ -1,442 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 kubefedctl
-
-import (
-	"context"
-	goerrors "errors"
-	"io"
-	"strings"
-
-	"github.com/pkg/errors"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	kubeclient "k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/rest"
-	"k8s.io/klog"
-
-	fedv1b1 "sigs.k8s.io/kubefed/pkg/apis/core/v1beta1"
-	genericclient "sigs.k8s.io/kubefed/pkg/client/generic"
-	controllerutil "sigs.k8s.io/kubefed/pkg/controller/util"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/options"
-	"sigs.k8s.io/kubefed/pkg/kubefedctl/util"
-)
-
-var (
-	unjoin_long = `
-		Unjoin removes the registration of a Kubernetes cluster
-		from a KubeFed control plane. Current context is assumed
-		to be a Kubernetes cluster hosting a KubeFed control
-		plane. Please use the --host-cluster-context flag
-		otherwise.`
-	unjoin_example = `
-		# Remove the registration of a Kubernetes cluster
-		# from a KubeFed control plane by specifying the
-		# cluster name and the context name of the control
-		# plane's host cluster. Cluster name must be a
-		# valid RFC 1123 subdomain name. Cluster context
-		# must be specified if the cluster name is different
-		# than the cluster's context in the local kubeconfig.
-		kubefedctl unjoin foo --host-cluster-context=bar`
-)
-
-type unjoinFederation struct {
-	options.GlobalSubcommandOptions
-	options.CommonJoinOptions
-	unjoinFederationOptions
-}
-
-type unjoinFederationOptions struct {
-	forceDeletion bool
-}
-
-// Bind adds the unjoin specific arguments to the flagset passed in as an
-// argument.
-func (o *unjoinFederationOptions) Bind(flags *pflag.FlagSet) {
-	flags.BoolVar(&o.forceDeletion, "force", false,
-		"Delete federated cluster and secret resources even if resources in the cluster targeted for unjoin are not removed successfully.")
-}
-
-// NewCmdUnjoin defines the `unjoin` command that removes the
-// registration of a cluster from a KubeFed control plane.
-func NewCmdUnjoin(cmdOut io.Writer, config util.FedConfig) *cobra.Command {
-	opts := &unjoinFederation{}
-
-	cmd := &cobra.Command{
-		Use:     "unjoin CLUSTER_NAME --host-cluster-context=HOST_CONTEXT",
-		Short:   "Remove the registration of a cluster from a KubeFed control plane",
-		Long:    unjoin_long,
-		Example: unjoin_example,
-		Run: func(cmd *cobra.Command, args []string) {
-			err := opts.Complete(args)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-
-			err = opts.Run(cmdOut, config)
-			if err != nil {
-				klog.Fatalf("Error: %v", err)
-			}
-		},
-	}
-
-	flags := cmd.Flags()
-	opts.GlobalSubcommandBind(flags)
-	opts.CommonSubcommandBind(flags)
-	opts.Bind(flags)
-
-	return cmd
-}
-
-// Complete ensures that options are valid and marshals them if necessary.
-func (j *unjoinFederation) Complete(args []string) error {
-	err := j.SetName(args)
-	if err != nil {
-		return err
-	}
-
-	if j.ClusterContext == "" {
-		klog.V(2).Infof("Defaulting cluster context to unjoining cluster name %s", j.ClusterName)
-		j.ClusterContext = j.ClusterName
-	}
-
-	if j.HostClusterName != "" && strings.ContainsAny(j.HostClusterName, ":/") {
-		return goerrors.New("host-cluster-name may not contain \"/\" or \":\"")
-	}
-
-	if j.HostClusterName == "" && strings.ContainsAny(j.HostClusterContext, ":/") {
-		return goerrors.New("host-cluster-name must be set if the name of the host cluster context contains one of \":\" or \"/\"")
-	}
-
-	klog.V(2).Infof("Args and flags: name %s, host-cluster-context: %s, host-system-namespace: %s, kubeconfig: %s, cluster-context: %s, dry-run: %v",
-		j.ClusterName, j.HostClusterContext, j.KubeFedNamespace, j.Kubeconfig, j.ClusterContext, j.DryRun)
-
-	return nil
-}
-
-// Run is the implementation of the `unjoin` command.
-func (j *unjoinFederation) Run(cmdOut io.Writer, config util.FedConfig) error {
-	hostClientConfig := config.GetClientConfig(j.HostClusterContext, j.Kubeconfig)
-	if err := j.SetHostClusterContextFromConfig(hostClientConfig); err != nil {
-		return err
-	}
-
-	hostConfig, err := hostClientConfig.ClientConfig()
-	if err != nil {
-		// TODO(font): Return new error with this same text so it can be output
-		// by caller.
-		klog.V(2).Infof("Failed to get host cluster config: %v", err)
-		return err
-	}
-
-	clusterConfig, err := config.ClusterConfig(j.ClusterContext, j.Kubeconfig)
-	if err != nil {
-		klog.V(2).Infof("Failed to get unjoining cluster config: %v", err)
-
-		if !j.forceDeletion {
-			return err
-		}
-		// If configuration for the member cluster cannot be successfully loaded,
-		// forceDeletion indicates that resources associated with the member cluster
-		// should still be removed from the host cluster.
-	}
-
-	hostClusterName := j.HostClusterContext
-	if j.HostClusterName != "" {
-		hostClusterName = j.HostClusterName
-	}
-
-	return UnjoinCluster(hostConfig, clusterConfig, j.KubeFedNamespace,
-		hostClusterName, j.ClusterContext, j.ClusterName, j.forceDeletion, j.DryRun)
-}
-
-// UnjoinCluster performs all the necessary steps to remove the
-// registration of a cluster from a KubeFed control plane provided the
-// required set of parameters are passed in.
-func UnjoinCluster(hostConfig, clusterConfig *rest.Config, kubefedNamespace, hostClusterName,
-	unjoiningClusterContext, unjoiningClusterName string, forceDeletion, dryRun bool) error {
-
-	hostClientset, err := util.HostClientset(hostConfig)
-	if err != nil {
-		klog.V(2).Infof("Failed to get host cluster clientset: %v", err)
-		return err
-	}
-
-	var clusterClientset *kubeclient.Clientset
-	if clusterConfig != nil {
-		clusterClientset, err = util.ClusterClientset(clusterConfig)
-		if err != nil {
-			klog.V(2).Infof("Failed to get unjoining cluster clientset: %v", err)
-			if !forceDeletion {
-				return err
-			}
-		}
-	}
-
-	client, err := genericclient.New(hostConfig)
-	if err != nil {
-		klog.V(2).Infof("Failed to get kubefed clientset: %v", err)
-		return err
-	}
-
-	if clusterClientset != nil {
-		err := deleteRBACResources(clusterClientset, kubefedNamespace, unjoiningClusterName, hostClusterName, forceDeletion, dryRun)
-		if err != nil {
-			if !forceDeletion {
-				return err
-			}
-			klog.V(2).Infof("Failed to delete RBAC resources: %v", err)
-		}
-
-		err = deleteFedNSFromUnjoinCluster(hostClientset, clusterClientset, kubefedNamespace, unjoiningClusterName, dryRun)
-		if err != nil {
-			if !forceDeletion {
-				return err
-			}
-			klog.V(2).Infof("Failed to delete kubefed namespace: %v", err)
-		}
-	}
-
-	// deletionSucceeded when all operations in deleteRBACResources and deleteFedNSFromUnjoinCluster succeed.
-	return deleteFederatedClusterAndSecret(hostClientset, client, kubefedNamespace, unjoiningClusterName, forceDeletion, dryRun)
-}
-
-// deleteKubeFedClusterAndSecret deletes a federated cluster resource that associates
-// the cluster and secret.
-func deleteFederatedClusterAndSecret(hostClientset kubeclient.Interface, client genericclient.Client,
-	kubefedNamespace, unjoiningClusterName string, forceDeletion, dryRun bool) error {
-	if dryRun {
-		return nil
-	}
-
-	klog.V(2).Infof("Deleting kubefed cluster resource from namespace %q for unjoin cluster %q",
-		kubefedNamespace, unjoiningClusterName)
-
-	fedCluster := &fedv1b1.KubeFedCluster{}
-	err := client.Get(context.TODO(), fedCluster, kubefedNamespace, unjoiningClusterName)
-	if err != nil {
-		return errors.Wrapf(err, "Failed to get kubefed cluster \"%s/%s\"", kubefedNamespace, unjoiningClusterName)
-	}
-
-	err = hostClientset.CoreV1().Secrets(kubefedNamespace).Delete(fedCluster.Spec.SecretRef.Name,
-		&metav1.DeleteOptions{})
-	if apierrors.IsNotFound(err) {
-		klog.V(2).Infof("Secret \"%s/%s\" does not exist in the host cluster.", kubefedNamespace, fedCluster.Spec.SecretRef.Name)
-	} else if err != nil {
-		wrappedErr := errors.Wrapf(err, "Failed to delete secret \"%s/%s\" for unjoin cluster %q",
-			kubefedNamespace, fedCluster.Spec.SecretRef.Name, unjoiningClusterName)
-		if !forceDeletion {
-			return wrappedErr
-		}
-		klog.V(2).Infof("%v", wrappedErr)
-	} else {
-		klog.V(2).Infof("Deleted secret \"%s/%s\" for unjoin cluster %q", kubefedNamespace, fedCluster.Spec.SecretRef.Name, unjoiningClusterName)
-	}
-
-	err = client.Delete(context.TODO(), fedCluster, fedCluster.Namespace, fedCluster.Name)
-	if apierrors.IsNotFound(err) {
-		klog.V(2).Infof("KubeFed cluster \"%s/%s\" does not exist in the host cluster.", fedCluster.Namespace, fedCluster.Name)
-	} else if err != nil {
-		wrappedErr := errors.Wrapf(err, "Failed to delete kubefed cluster \"%s/%s\" for unjoin cluster %q", fedCluster.Namespace, fedCluster.Name, unjoiningClusterName)
-		if !forceDeletion {
-			return wrappedErr
-		}
-		klog.V(2).Infof("%v", wrappedErr)
-	} else {
-		klog.V(2).Infof("Deleted kubefed cluster \"%s/%s\" for unjoin cluster %q.", fedCluster.Namespace, fedCluster.Name, unjoiningClusterName)
-	}
-
-	return nil
-}
-
-// deleteRBACResources deletes the cluster role, cluster rolebindings and service account
-// from the unjoining cluster.
-func deleteRBACResources(unjoiningClusterClientset kubeclient.Interface,
-	namespace, unjoiningClusterName, hostClusterName string, forceDeletion, dryRun bool) error {
-
-	saName := util.ClusterServiceAccountName(unjoiningClusterName, hostClusterName)
-
-	err := deleteClusterRoleAndBinding(unjoiningClusterClientset, saName, namespace, unjoiningClusterName, forceDeletion, dryRun)
-	if err != nil {
-		return err
-	}
-
-	err = deleteServiceAccount(unjoiningClusterClientset, saName, namespace, unjoiningClusterName, dryRun)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// deleteFedNSFromUnjoinCluster deletes the kubefed namespace from
-// the unjoining cluster so long as the unjoining cluster is not the
-// host cluster.
-func deleteFedNSFromUnjoinCluster(hostClientset, unjoiningClusterClientset kubeclient.Interface,
-	kubefedNamespace, unjoiningClusterName string, dryRun bool) error {
-
-	if dryRun {
-		return nil
-	}
-
-	hostClusterNamespace, err := hostClientset.CoreV1().Namespaces().Get(kubefedNamespace, metav1.GetOptions{})
-	if err != nil {
-		return errors.Wrapf(err, "Error retrieving namespace %q from host cluster", kubefedNamespace)
-	}
-
-	unjoiningClusterNamespace, err := unjoiningClusterClientset.CoreV1().Namespaces().Get(kubefedNamespace, metav1.GetOptions{})
-	if err != nil {
-		return errors.Wrapf(err, "Error retrieving namespace %q from unjoining cluster %q", kubefedNamespace, unjoiningClusterName)
-	}
-
-	if controllerutil.IsPrimaryCluster(hostClusterNamespace, unjoiningClusterNamespace) {
-		klog.V(2).Infof("The kubefed namespace %q does not need to be deleted from the host cluster by unjoin.", kubefedNamespace)
-		return nil
-	}
-
-	klog.V(2).Infof("Deleting kubefed namespace %q from unjoining cluster %q.", kubefedNamespace, unjoiningClusterName)
-	err = unjoiningClusterClientset.CoreV1().Namespaces().Delete(kubefedNamespace, &metav1.DeleteOptions{})
-	if apierrors.IsNotFound(err) {
-		klog.V(2).Infof("The kubefed namespace %q no longer exists in unjoining cluster %q.", kubefedNamespace, unjoiningClusterName)
-		return nil
-	} else if err != nil {
-		return errors.Wrapf(err, "Could not delete kubefed namespace %q from unjoining cluster %q", kubefedNamespace, unjoiningClusterName)
-	} else {
-		klog.V(2).Infof("Deleted kubefed namespace %q from unjoining cluster %q.", kubefedNamespace, unjoiningClusterName)
-	}
-
-	return nil
-}
-
-// deleteServiceAccount deletes a service account in the cluster associated
-// with clusterClientset with credentials that are used by the host cluster
-// to access its API server.
-func deleteServiceAccount(clusterClientset kubeclient.Interface, saName,
-	namespace, unjoiningClusterName string, dryRun bool) error {
-	if dryRun {
-		return nil
-	}
-
-	klog.V(2).Infof("Deleting service account \"%s/%s\" in unjoining cluster %q.", namespace, saName, unjoiningClusterName)
-
-	// Delete a service account.
-	err := clusterClientset.CoreV1().ServiceAccounts(namespace).Delete(saName,
-		&metav1.DeleteOptions{})
-	if apierrors.IsNotFound(err) {
-		klog.V(2).Infof("Service account \"%s/%s\" does not exist.", namespace, saName)
-	} else if err != nil {
-		return errors.Wrapf(err, "Could not delete service account \"%s/%s\"", namespace, saName)
-	} else {
-		klog.V(2).Infof("Deleted service account \"%s/%s\" in unjoining cluster %q.", namespace, saName, unjoiningClusterName)
-	}
-
-	return nil
-}
-
-// deleteClusterRoleAndBinding deletes an RBAC cluster role and binding that
-// allows the service account identified by saName to access all resources in
-// all namespaces in the cluster associated with clusterClientset.
-func deleteClusterRoleAndBinding(clusterClientset kubeclient.Interface,
-	saName, namespace, unjoiningClusterName string, forceDeletion, dryRun bool) error {
-	if dryRun {
-		return nil
-	}
-
-	roleName := util.RoleName(saName)
-	healthCheckRoleName := util.HealthCheckRoleName(saName, namespace)
-
-	// Attempt to delete all role and role bindings created by join
-	for _, name := range []string{roleName, healthCheckRoleName} {
-		klog.V(2).Infof("Deleting cluster role binding %q for service account %q in unjoining cluster %q.",
-			name, saName, unjoiningClusterName)
-
-		err := clusterClientset.RbacV1().ClusterRoleBindings().Delete(name, &metav1.DeleteOptions{})
-		if apierrors.IsNotFound(err) {
-			klog.V(2).Infof("Cluster role binding %q for service account %q does not exist in unjoining cluster %q.",
-				name, saName, unjoiningClusterName)
-		} else if err != nil {
-			wrappedErr := errors.Wrapf(err, "Could not delete cluster role binding %q for service account %q in unjoining cluster %q",
-				name, saName, unjoiningClusterName)
-			if !forceDeletion {
-				return wrappedErr
-			}
-			klog.V(2).Infof("%v", wrappedErr)
-		} else {
-			klog.V(2).Infof("Deleted cluster role binding %q for service account %q in unjoining cluster %q.",
-				name, saName, unjoiningClusterName)
-		}
-
-		klog.V(2).Infof("Deleting cluster role %q for service account %q in unjoining cluster %q.",
-			name, saName, unjoiningClusterName)
-		err = clusterClientset.RbacV1().ClusterRoles().Delete(name, &metav1.DeleteOptions{})
-		if apierrors.IsNotFound(err) {
-			klog.V(2).Infof("Cluster role %q for service account %q does not exist in unjoining cluster %q.",
-				name, saName, unjoiningClusterName)
-		} else if err != nil {
-			wrappedErr := errors.Wrapf(err, "Could not delete cluster role %q for service account %q in unjoining cluster %q",
-				name, saName, unjoiningClusterName)
-			if !forceDeletion {
-				return wrappedErr
-			}
-			klog.V(2).Infof("%v", wrappedErr)
-		} else {
-			klog.V(2).Infof("Deleted cluster role %q for service account %q in unjoining cluster %q.",
-				name, saName, unjoiningClusterName)
-		}
-	}
-
-	klog.V(2).Infof("Deleting role binding \"%s/%s\" for service account %q in unjoining cluster %q.",
-		namespace, roleName, saName, unjoiningClusterName)
-	err := clusterClientset.RbacV1().RoleBindings(namespace).Delete(roleName, &metav1.DeleteOptions{})
-	if apierrors.IsNotFound(err) {
-		klog.V(2).Infof("Role binding \"%s/%s\" for service account %q does not exist in unjoining cluster %q.",
-			namespace, roleName, saName, unjoiningClusterName)
-	} else if err != nil {
-		wrappedErr := errors.Wrapf(err, "Could not delete role binding \"%s/%s\" for service account %q in unjoining cluster %q",
-			namespace, roleName, saName, unjoiningClusterName)
-		if !forceDeletion {
-			return wrappedErr
-		}
-		klog.V(2).Infof("%v", wrappedErr)
-	} else {
-		klog.V(2).Infof("Deleted role binding \"%s/%s\" for service account %q in unjoining cluster %q.",
-			namespace, roleName, saName, unjoiningClusterName)
-	}
-
-	klog.V(2).Infof("Deleting role \"%s/%s\" for service account %q in unjoining cluster %q.",
-		namespace, roleName, saName, unjoiningClusterName)
-	err = clusterClientset.RbacV1().Roles(namespace).Delete(roleName, &metav1.DeleteOptions{})
-	if apierrors.IsNotFound(err) {
-		klog.V(2).Infof("Role \"%s/%s\" for service account %q does not exist in unjoining cluster %q.",
-			namespace, roleName, saName, unjoiningClusterName)
-	} else if err != nil {
-		wrappedErr := errors.Wrapf(err, "Could not delete role \"%s/%s\" for service account %q in unjoining cluster %q",
-			namespace, roleName, saName, unjoiningClusterName)
-		if !forceDeletion {
-			return wrappedErr
-		}
-		klog.V(2).Infof("%v", wrappedErr)
-	} else {
-		klog.V(2).Infof("Deleting Role \"%s/%s\" for service account %q in unjoining cluster %q.",
-			namespace, roleName, saName, unjoiningClusterName)
-	}
-
-	return nil
-}

vendor/sigs.k8s.io/kubefed/pkg/kubefedctl/version.go

@@ -1,49 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 kubefedctl
-
-import (
-	"fmt"
-	"io"
-
-	"github.com/spf13/cobra"
-
-	"sigs.k8s.io/kubefed/pkg/version"
-)
-
-var (
-	version_long = `
-		Version prints the version info of this command.`
-	version_example = `
-		# Print kubefed command version
-		kubefed version`
-)
-
-// NewCmdVersion prints out the release version info for this command binary.
-func NewCmdVersion(out io.Writer) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:     "version",
-		Short:   "Print the version info",
-		Long:    version_long,
-		Example: version_example,
-		Run: func(cmd *cobra.Command, args []string) {
-			fmt.Fprintf(out, "kubefedctl version: %s\n", fmt.Sprintf("%#v", version.Get()))
-		},
-	}
-
-	return cmd
-}

vendor/sigs.k8s.io/kubefed/pkg/version/base.go

@@ -1,32 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 version
-
-// Base version information.
-//
-// This is the fallback data used when version information from git is not
-// provided via go ldflags (via Makefile).
-var (
-	version = "v0.0.1-alpha.0" // output of "git describe"
-	// the prerequisite is that the branch should be
-	// tagged using the correct versioning strategy.
-
-	gitCommit    = "unknown" // sha1 from git, output of $(git rev-parse HEAD)
-	gitTreeState = "unknown" // state of git tree, either "clean" or "dirty"
-
-	buildDate = "unknown" // build date in ISO8601 format, output of $(date -u +'%Y-%m-%dT%H:%M:%SZ')
-)

vendor/sigs.k8s.io/kubefed/pkg/version/version.go

@@ -1,48 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT 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 version
-
-import (
-	"fmt"
-	"runtime"
-)
-
-type Info struct {
-	Version      string `json:"gitVersion"`
-	GitCommit    string `json:"gitCommit"`
-	GitTreeState string `json:"gitTreeState"`
-	BuildDate    string `json:"buildDate"`
-	GoVersion    string `json:"goVersion"`
-	Compiler     string `json:"compiler"`
-	Platform     string `json:"platform"`
-}
-
-// Get returns the overall codebase version. It's for detecting
-// what code a binary was built from.
-func Get() Info {
-	// These variables typically come from -ldflags settings and in
-	// their absence fallback to the settings in pkg/version/base.go
-	return Info{
-		Version:      version,
-		GitCommit:    gitCommit,
-		GitTreeState: gitTreeState,
-		BuildDate:    buildDate,
-		GoVersion:    runtime.Version(),
-		Compiler:     runtime.Compiler,
-		Platform:     fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH),
-	}
-}