From d0f3881a0047e8ec5d42fa73cfbac139bb9e0e71 Mon Sep 17 00:00:00 2001 From: Simon Leung Date: Mon, 5 Jun 2017 11:52:43 -0700 Subject: [PATCH 01/24] kubectl plugin create-service-broker --- .../create-service-broker.go | 56 +++++++++++++++ .../kubectl/create-service-broker/plugin.yaml | 3 + plugin/cmd/kubectl/utils/table_printer.go | 47 ++++++++++++ plugin/cmd/kubectl/utils/ui.go | 22 ++++++ plugin/cmd/kubectl/utils/utils.go | 72 +++++++++++++++++++ 5 files changed, 200 insertions(+) create mode 100644 plugin/cmd/kubectl/create-service-broker/create-service-broker.go create mode 100644 plugin/cmd/kubectl/create-service-broker/plugin.yaml create mode 100644 plugin/cmd/kubectl/utils/table_printer.go create mode 100644 plugin/cmd/kubectl/utils/ui.go create mode 100644 plugin/cmd/kubectl/utils/utils.go diff --git a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go new file mode 100644 index 00000000000..b06c72b23d9 --- /dev/null +++ b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go @@ -0,0 +1,56 @@ +package main + +import ( + "fmt" + "os" + + v1alpha1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1alpha1" + clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" + "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" + + "k8s.io/client-go/rest" +) + +const USAGE = `Usage: + kubectl plugin create-service-broker BROKER_NAME BROKER_URL` + +func main() { + svcURL := utils.SCUrlEnv() + if svcURL == "" { + svcURL = "192.168.99.100:30080" + } + + if len(os.Args) != 3 { + utils.Exit1(USAGE) + } + + broker := v1alpha1.Broker{} + broker.Kind = "Broker" + broker.Name = os.Args[1] + broker.Spec.URL = os.Args[2] + + restConfig := rest.Config{ + Host: svcURL, + APIPath: "/apis/servicecatalog.k8s.io/v1alpha1", + } + + svcClient, err := clientset.NewForConfig(&restConfig) + if err != nil { + utils.Exit1(fmt.Sprintf("Initializing client for service catalog (%s)", err)) + } + + fmt.Printf("Creating broker %s...\n", utils.Entity(broker.Name)) + resp, err := svcClient.Brokers().Create(&broker) + if err != nil { + utils.Exit1(fmt.Sprintf("Creating broker resource (%s)", err)) + } + + utils.Ok() + + table := utils.NewTable("BROKER NAME", "NAMESPACE", "URL") + table.AddRow(resp.Name, resp.Namespace, resp.Spec.URL) + err = table.Print() + if err != nil { + utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) + } +} diff --git a/plugin/cmd/kubectl/create-service-broker/plugin.yaml b/plugin/cmd/kubectl/create-service-broker/plugin.yaml new file mode 100644 index 00000000000..a8d763cc44c --- /dev/null +++ b/plugin/cmd/kubectl/create-service-broker/plugin.yaml @@ -0,0 +1,3 @@ +name: "create-service-broker" +shortDesc: "This registers a service broker with the service catalog" +command: "./create-service-broker" diff --git a/plugin/cmd/kubectl/utils/table_printer.go b/plugin/cmd/kubectl/utils/table_printer.go new file mode 100644 index 00000000000..731d7328927 --- /dev/null +++ b/plugin/cmd/kubectl/utils/table_printer.go @@ -0,0 +1,47 @@ +package utils + +import ( + "fmt" + "os" + "text/tabwriter" +) + +type table struct { + headers []string + rows [][]string +} + +func NewTable(headers ...string) *table { + return &table{ + headers: headers, + } +} + +func (t *table) AddRow(row ...string) { + t.rows = append(t.rows, row) +} + +func (t *table) Print() error { + padding := 3 + + w := tabwriter.NewWriter(os.Stdout, 0, 0, padding, ' ', 0) + + //Print header + printStr := "" + for _, h := range t.headers { + printStr = printStr + h + "\t" + } + fmt.Fprintln(w, printStr) + + //Print rows + printStr = "" + for _, rows := range t.rows { + for _, row := range rows { + printStr = printStr + row + "\t" + } + fmt.Fprintln(w, printStr) + } + fmt.Fprintln(w) + + return w.Flush() +} diff --git a/plugin/cmd/kubectl/utils/ui.go b/plugin/cmd/kubectl/utils/ui.go new file mode 100644 index 00000000000..1e6daca0e87 --- /dev/null +++ b/plugin/cmd/kubectl/utils/ui.go @@ -0,0 +1,22 @@ +package utils + +import "fmt" + +func Green(str string) string { + return fmt.Sprintf("\x1b[32;1m%s\x1b[0m", str) +} + +func Red(str string) string { + return fmt.Sprintf("\x1b[31;1m%s\x1b[0m", str) +} + +func Entity(str string) string { + return fmt.Sprintf("\x1b[36;1m%s\x1b[0m", str) +} + +func Error(msg string) { + fmt.Printf("%s\n\n%s\n\n", Red("ERROR"), msg) +} +func Ok() { + fmt.Printf("%s\n\n", Green("OK")) +} diff --git a/plugin/cmd/kubectl/utils/utils.go b/plugin/cmd/kubectl/utils/utils.go new file mode 100644 index 00000000000..7fb84ea6c7a --- /dev/null +++ b/plugin/cmd/kubectl/utils/utils.go @@ -0,0 +1,72 @@ +package utils + +import ( + "encoding/json" + "fmt" + "io/ioutil" + "net/http" + "os" + "os/exec" +) + +type namespace struct { + Metadata metadata `json:"metadata"` + Code int `json:"code"` +} + +type metadata struct { + Name string `json:"name"` +} + +func CheckNamespaceExists(name string) error { + proxyURL := "http://127.0.0.1" + proxyPort := "8881" + + kubeProxy := exec.Command("kubectl", "proxy", "-p", proxyPort) + defer func() { + if err := kubeProxy.Process.Kill(); err != nil { + Exit1(fmt.Sprintf("failed to kill kubectl proxy (%s)", err)) + } + }() + + err := kubeProxy.Start() + if err != nil { + return fmt.Errorf("Cannot start kubectl proxy (%s)", err) + } + + resp, err := http.Get(fmt.Sprintf("%s:%s/api/v1/namespaces/%s", proxyURL, proxyPort, name)) + if err != nil { + fmt.Errorf("Error looking up namespace from core api server (%s)", err) + } + + defer resp.Body.Close() + body, err := ioutil.ReadAll(resp.Body) + if err != nil { + return fmt.Errorf("Error retrieving core api server response body during namespace lookup (%s)", err) + } + + ns := namespace{} + err = json.Unmarshal(body, &ns) + if err != nil { + return fmt.Errorf("Error parsing core api server response body during namespace lookup (%s)", err) + } + + if ns.Code == 404 || ns.Metadata.Name == "" { + return fmt.Errorf("Namespace not found") + } + + return nil +} + +func SCUrlEnv() string { + url := os.Getenv("SERVICE_CATALOG_URL") + if url == "" { + return "" + } + return url +} + +func Exit1(errStr string) { + Error(errStr) + os.Exit(1) +} From 2642f9de2d3a093b5140da324abf0a335ec3a3ed Mon Sep 17 00:00:00 2001 From: Simon Leung Date: Mon, 5 Jun 2017 11:52:58 -0700 Subject: [PATCH 02/24] kubectl plugin create-service-instance --- .../create-service-instance.go | 63 +++++++++++++++++++ .../create-service-instance/plugin.yaml | 3 + 2 files changed, 66 insertions(+) create mode 100644 plugin/cmd/kubectl/create-service-instance/create-service-instance.go create mode 100644 plugin/cmd/kubectl/create-service-instance/plugin.yaml diff --git a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go new file mode 100644 index 00000000000..1f5d4e06cee --- /dev/null +++ b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go @@ -0,0 +1,63 @@ +package main + +import ( + "fmt" + "os" + + v1alpha1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1alpha1" + clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" + "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" + + "k8s.io/client-go/rest" +) + +const USAGE = `Usage: + kubectl plugin create-service-instance SERVICE_CLASS_NAME PLAN_NAME INSTANCE_NAME NAMESPACE` + +func main() { + svcURL := utils.SCUrlEnv() + if svcURL == "" { + svcURL = "192.168.99.100:30080" + } + + if len(os.Args) != 5 { + utils.Exit1(USAGE) + } + + instance := v1alpha1.Instance{} + instance.Kind = "Instance" + instance.Name = os.Args[3] + instance.Namespace = os.Args[4] + instance.Spec.PlanName = os.Args[2] + instance.Spec.ServiceClassName = os.Args[1] + + fmt.Printf("Looking up Namespace %s...\n", utils.Entity(instance.Name)) + if err := utils.CheckNamespaceExists(instance.Namespace); err != nil { + utils.Exit1(err.Error()) + } + utils.Ok() + + restConfig := rest.Config{ + Host: svcURL, + APIPath: "/apis/servicecatalog.k8s.io/v1alpha1", + } + + svcClient, err := clientset.NewForConfig(&restConfig) + if err != nil { + utils.Exit1(fmt.Sprintf("Failed to initializing client for service catalog (%s)", err)) + } + + fmt.Printf("Creating service instance %s in Namespace %s...\n", utils.Entity(instance.Name), utils.Entity(instance.Namespace)) + resp, err := svcClient.Instances(instance.Namespace).Create(&instance) + if err != nil { + utils.Exit1(fmt.Sprintf("Failed to creating service instance (%s)", err)) + } + utils.Ok() + + table := utils.NewTable("INSTANCE NAME", "NAMESPACE", "PLAN NAME", "SERVICE CLASS NAME") + table.AddRow(resp.Name, resp.Namespace, resp.Spec.PlanName, resp.Spec.ServiceClassName) + err = table.Print() + if err != nil { + utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) + } +} diff --git a/plugin/cmd/kubectl/create-service-instance/plugin.yaml b/plugin/cmd/kubectl/create-service-instance/plugin.yaml new file mode 100644 index 00000000000..f458803ddbc --- /dev/null +++ b/plugin/cmd/kubectl/create-service-instance/plugin.yaml @@ -0,0 +1,3 @@ +name: "create-service-instance" +shortDesc: "This command creates a service instance that is ready to be bound to" +command: "./create-service-instance" From 833f3797a7fff4b6c1f6aac1054420a3f79b5954 Mon Sep 17 00:00:00 2001 From: Simon Leung Date: Mon, 5 Jun 2017 11:53:06 -0700 Subject: [PATCH 03/24] kubectl plugin bind-service --- .../cmd/kubectl/bind-service/bind-service.go | 66 +++++++++++++++++++ plugin/cmd/kubectl/bind-service/plugin.yaml | 3 + 2 files changed, 69 insertions(+) create mode 100644 plugin/cmd/kubectl/bind-service/bind-service.go create mode 100644 plugin/cmd/kubectl/bind-service/plugin.yaml diff --git a/plugin/cmd/kubectl/bind-service/bind-service.go b/plugin/cmd/kubectl/bind-service/bind-service.go new file mode 100644 index 00000000000..a43c5343886 --- /dev/null +++ b/plugin/cmd/kubectl/bind-service/bind-service.go @@ -0,0 +1,66 @@ +package main + +import ( + "fmt" + "os" + + v1alpha1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1alpha1" + clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" + "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" + + "k8s.io/client-go/pkg/api/v1" + "k8s.io/client-go/rest" +) + +const USAGE = `Usage: + kubectl plugin bind-service INSTANCE_NAME BINDING_NAME NAMESPACE` + +func main() { + svcURL := utils.SCUrlEnv() + if svcURL == "" { + svcURL = "192.168.99.100:30080" + } + + if len(os.Args) != 4 { + utils.Exit1(USAGE) + } + + binding := v1alpha1.Binding{} + binding.Kind = "binding" + binding.Name = os.Args[2] + binding.Namespace = os.Args[3] + binding.Spec.InstanceRef = v1.LocalObjectReference{ + Name: os.Args[1], + } + binding.Spec.SecretName = os.Args[2] + + fmt.Printf("Looking up Namespace %s...\n", utils.Entity(binding.Name)) + if err := utils.CheckNamespaceExists(binding.Namespace); err != nil { + utils.Exit1(err.Error()) + } + utils.Ok() + + restConfig := rest.Config{ + Host: svcURL, + APIPath: "/apis/servicecatalog.k8s.io/v1alpha1", + } + + svcClient, err := clientset.NewForConfig(&restConfig) + if err != nil { + utils.Exit1(fmt.Sprintf("Error initializing client for service catalog (%s)", err)) + } + + fmt.Printf("Creating binding %s to %s in Namespace %s...\n", utils.Entity(binding.Name), utils.Entity(binding.Spec.InstanceRef.Name), utils.Entity(binding.Namespace)) + resp, err := svcClient.Bindings(binding.Namespace).Create(&binding) + if err != nil { + utils.Exit1(fmt.Sprintf("Error binding service instance (%s)", err)) + } + utils.Ok() + + table := utils.NewTable("BINDING NAME", "NAMESPACE", "INSTANCE NAME", "SECRET NAME") + table.AddRow(resp.Name, resp.Namespace, resp.Spec.InstanceRef.Name, resp.Spec.SecretName) + err = table.Print() + if err != nil { + utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) + } +} diff --git a/plugin/cmd/kubectl/bind-service/plugin.yaml b/plugin/cmd/kubectl/bind-service/plugin.yaml new file mode 100644 index 00000000000..3dfa0d6727d --- /dev/null +++ b/plugin/cmd/kubectl/bind-service/plugin.yaml @@ -0,0 +1,3 @@ +name: "bind-service" +shortDesc: "This command binds a service class to a service instance" +command: "./bind-service" From 807c7b37c9f4c607a71a6488d3187ec59aa83a82 Mon Sep 17 00:00:00 2001 From: Doug Davis Date: Tue, 11 Jul 2017 11:19:38 -0700 Subject: [PATCH 04/24] Add plugins to Makefile and fix lint issues Signed-off-by: Doug Davis --- Makefile | 40 ++++++++++++++++++++++- plugin/cmd/kubectl/utils/table_printer.go | 11 ++++--- 2 files changed, 45 insertions(+), 6 deletions(-) diff --git a/Makefile b/Makefile index 58b368ac014..823e4a43716 100644 --- a/Makefile +++ b/Makefile @@ -110,7 +110,8 @@ NON_VENDOR_DIRS = $(shell $(DOCKER_CMD) glide nv) ######################################################################### build: .init .generate_files \ $(BINDIR)/service-catalog \ - $(BINDIR)/user-broker + $(BINDIR)/user-broker \ + plugins user-broker: $(BINDIR)/user-broker $(BINDIR)/user-broker: .init contrib/cmd/user-broker \ @@ -289,6 +290,7 @@ clean: clean-bin clean-build-image clean-generated clean-coverage clean-bin: $(DOCKER_CMD) rm -rf $(BINDIR) rm -f .generate_exes + rm -f $(PLUGINS) clean-build-image: $(DOCKER_CMD) rm -rf .pkg @@ -385,3 +387,39 @@ release-push-%: $(MAKE) clean-bin $(MAKE) ARCH=$* build $(MAKE) ARCH=$* push + + +# kubectl plugin stuff +###################### +PLUGIN_EXES=bind-service create-service-broker create-service-instance + +plugins: $(BINDIR)/bind-service/bind-service \ + $(BINDIR)/create-service-broker/create-service-broker \ + $(BINDIR)/create-service-instance/create-service-instance + +$(BINDIR)/bind-service/bind-service: \ + plugin/cmd/kubectl/bind-service/bind-service.go \ + plugin/cmd/kubectl/bind-service/plugin.yaml + rm -rf $(BINDIR)/bind-service + mkdir $(BINDIR)/bind-service + $(DOCKER_CMD) go build -o $@ $< + cp plugin/cmd/kubectl/bind-service/*yaml $(BINDIR)/bind-service/ + +$(BINDIR)/create-service-broker/create-service-broker: \ + plugin/cmd/kubectl/create-service-broker/create-service-broker.go \ + plugin/cmd/kubectl/create-service-broker/plugin.yaml + rm -rf $(BINDIR)/create-service-broker + mkdir $(BINDIR)/create-service-broker + $(DOCKER_CMD) go build -o $@ $< + cp plugin/cmd/kubectl/create-service-broker/*yaml \ + $(BINDIR)/create-service-broker/ + +$(BINDIR)/create-service-instance/create-service-instance: \ + plugin/cmd/kubectl/create-service-instance/create-service-instance.go \ + plugin/cmd/kubectl/create-service-instance/plugin.yaml + rm -rf $(BINDIR)/create-service-instance + mkdir $(BINDIR)/create-service-instance + $(DOCKER_CMD) go build -o $@ $< + cp plugin/cmd/kubectl/create-service-instance/*yaml \ + $(BINDIR)/create-service-instance/ + diff --git a/plugin/cmd/kubectl/utils/table_printer.go b/plugin/cmd/kubectl/utils/table_printer.go index 731d7328927..f2cd65a274a 100644 --- a/plugin/cmd/kubectl/utils/table_printer.go +++ b/plugin/cmd/kubectl/utils/table_printer.go @@ -6,22 +6,23 @@ import ( "text/tabwriter" ) -type table struct { +type Table struct { headers []string rows [][]string } -func NewTable(headers ...string) *table { - return &table{ +// NewTable creates a new table based on the passed in header names +func NewTable(headers ...string) *Table { + return &Table{ headers: headers, } } -func (t *table) AddRow(row ...string) { +func (t *Table) AddRow(row ...string) { t.rows = append(t.rows, row) } -func (t *table) Print() error { +func (t *Table) Print() error { padding := 3 w := tabwriter.NewWriter(os.Stdout, 0, 0, padding, ' ', 0) From a7b50867e7fdfb9a9fe7c6625c8b8abbefe71fa2 Mon Sep 17 00:00:00 2001 From: Doug Davis Date: Tue, 11 Jul 2017 11:44:32 -0700 Subject: [PATCH 05/24] Fix some more "verify" issues Signed-off-by: Doug Davis --- Makefile | 11 +++---- .../cmd/kubectl/bind-service/bind-service.go | 22 ++++++++++++-- .../create-service-broker.go | 20 +++++++++++-- .../create-service-instance.go | 22 ++++++++++++-- plugin/cmd/kubectl/utils/table_printer.go | 19 ++++++++++++ plugin/cmd/kubectl/utils/ui.go | 22 ++++++++++++++ plugin/cmd/kubectl/utils/utils.go | 29 +++++++++++++++++-- 7 files changed, 128 insertions(+), 17 deletions(-) diff --git a/Makefile b/Makefile index 823e4a43716..9d8fad5e35c 100644 --- a/Makefile +++ b/Makefile @@ -290,7 +290,6 @@ clean: clean-bin clean-build-image clean-generated clean-coverage clean-bin: $(DOCKER_CMD) rm -rf $(BINDIR) rm -f .generate_exes - rm -f $(PLUGINS) clean-build-image: $(DOCKER_CMD) rm -rf .pkg @@ -401,25 +400,23 @@ $(BINDIR)/bind-service/bind-service: \ plugin/cmd/kubectl/bind-service/bind-service.go \ plugin/cmd/kubectl/bind-service/plugin.yaml rm -rf $(BINDIR)/bind-service - mkdir $(BINDIR)/bind-service $(DOCKER_CMD) go build -o $@ $< - cp plugin/cmd/kubectl/bind-service/*yaml $(BINDIR)/bind-service/ + $(DOCKER_CMD) cp plugin/cmd/kubectl/bind-service/*yaml \ + $(BINDIR)/bind-service/ $(BINDIR)/create-service-broker/create-service-broker: \ plugin/cmd/kubectl/create-service-broker/create-service-broker.go \ plugin/cmd/kubectl/create-service-broker/plugin.yaml rm -rf $(BINDIR)/create-service-broker - mkdir $(BINDIR)/create-service-broker $(DOCKER_CMD) go build -o $@ $< - cp plugin/cmd/kubectl/create-service-broker/*yaml \ + $(DOCKER_CMD) cp plugin/cmd/kubectl/create-service-broker/*yaml \ $(BINDIR)/create-service-broker/ $(BINDIR)/create-service-instance/create-service-instance: \ plugin/cmd/kubectl/create-service-instance/create-service-instance.go \ plugin/cmd/kubectl/create-service-instance/plugin.yaml rm -rf $(BINDIR)/create-service-instance - mkdir $(BINDIR)/create-service-instance $(DOCKER_CMD) go build -o $@ $< - cp plugin/cmd/kubectl/create-service-instance/*yaml \ + $(DOCKER_CMD) cp plugin/cmd/kubectl/create-service-instance/*yaml \ $(BINDIR)/create-service-instance/ diff --git a/plugin/cmd/kubectl/bind-service/bind-service.go b/plugin/cmd/kubectl/bind-service/bind-service.go index a43c5343886..77a75db94fd 100644 --- a/plugin/cmd/kubectl/bind-service/bind-service.go +++ b/plugin/cmd/kubectl/bind-service/bind-service.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + package main import ( @@ -12,7 +28,7 @@ import ( "k8s.io/client-go/rest" ) -const USAGE = `Usage: +const usage = `Usage: kubectl plugin bind-service INSTANCE_NAME BINDING_NAME NAMESPACE` func main() { @@ -22,7 +38,7 @@ func main() { } if len(os.Args) != 4 { - utils.Exit1(USAGE) + utils.Exit1(usage) } binding := v1alpha1.Binding{} @@ -34,7 +50,7 @@ func main() { } binding.Spec.SecretName = os.Args[2] - fmt.Printf("Looking up Namespace %s...\n", utils.Entity(binding.Name)) + fmt.Printf("Looking up Namespace %s...\n", utils.Entity(binding.Namespace)) if err := utils.CheckNamespaceExists(binding.Namespace); err != nil { utils.Exit1(err.Error()) } diff --git a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go index b06c72b23d9..26d20085706 100644 --- a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go +++ b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + package main import ( @@ -11,7 +27,7 @@ import ( "k8s.io/client-go/rest" ) -const USAGE = `Usage: +const usage = `Usage: kubectl plugin create-service-broker BROKER_NAME BROKER_URL` func main() { @@ -21,7 +37,7 @@ func main() { } if len(os.Args) != 3 { - utils.Exit1(USAGE) + utils.Exit1(usage) } broker := v1alpha1.Broker{} diff --git a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go index 1f5d4e06cee..5c4c622c024 100644 --- a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go +++ b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + package main import ( @@ -11,7 +27,7 @@ import ( "k8s.io/client-go/rest" ) -const USAGE = `Usage: +const usage = `Usage: kubectl plugin create-service-instance SERVICE_CLASS_NAME PLAN_NAME INSTANCE_NAME NAMESPACE` func main() { @@ -21,7 +37,7 @@ func main() { } if len(os.Args) != 5 { - utils.Exit1(USAGE) + utils.Exit1(usage) } instance := v1alpha1.Instance{} @@ -31,7 +47,7 @@ func main() { instance.Spec.PlanName = os.Args[2] instance.Spec.ServiceClassName = os.Args[1] - fmt.Printf("Looking up Namespace %s...\n", utils.Entity(instance.Name)) + fmt.Printf("Looking up Namespace %s...\n", utils.Entity(instance.Namespace)) if err := utils.CheckNamespaceExists(instance.Namespace); err != nil { utils.Exit1(err.Error()) } diff --git a/plugin/cmd/kubectl/utils/table_printer.go b/plugin/cmd/kubectl/utils/table_printer.go index f2cd65a274a..08da20aad41 100644 --- a/plugin/cmd/kubectl/utils/table_printer.go +++ b/plugin/cmd/kubectl/utils/table_printer.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + package utils import ( @@ -6,6 +22,7 @@ import ( "text/tabwriter" ) +// Table defines a tabular output - obviously in table format type Table struct { headers []string rows [][]string @@ -18,10 +35,12 @@ func NewTable(headers ...string) *Table { } } +// AddRow will append the specified row to the table func (t *Table) AddRow(row ...string) { t.rows = append(t.rows, row) } +// Print prints the table to the screen func (t *Table) Print() error { padding := 3 diff --git a/plugin/cmd/kubectl/utils/ui.go b/plugin/cmd/kubectl/utils/ui.go index 1e6daca0e87..531982ff11d 100644 --- a/plugin/cmd/kubectl/utils/ui.go +++ b/plugin/cmd/kubectl/utils/ui.go @@ -1,22 +1,44 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + package utils import "fmt" +// Green will print the specified string in green text func Green(str string) string { return fmt.Sprintf("\x1b[32;1m%s\x1b[0m", str) } +// Red will print the specified string in red text func Red(str string) string { return fmt.Sprintf("\x1b[31;1m%s\x1b[0m", str) } +// Entity will print the specified string in bold text func Entity(str string) string { return fmt.Sprintf("\x1b[36;1m%s\x1b[0m", str) } +// Error will print the specified error string in red text func Error(msg string) { fmt.Printf("%s\n\n%s\n\n", Red("ERROR"), msg) } + +// Ok will print "OK" in green func Ok() { fmt.Printf("%s\n\n", Green("OK")) } diff --git a/plugin/cmd/kubectl/utils/utils.go b/plugin/cmd/kubectl/utils/utils.go index 7fb84ea6c7a..693ce29336a 100644 --- a/plugin/cmd/kubectl/utils/utils.go +++ b/plugin/cmd/kubectl/utils/utils.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + package utils import ( @@ -18,6 +34,8 @@ type metadata struct { Name string `json:"name"` } +// CheckNamespaceExists will query our kube apiserver to see if the +// specified namespace exists - if not it returns an error func CheckNamespaceExists(name string) error { proxyURL := "http://127.0.0.1" proxyPort := "8881" @@ -36,10 +54,14 @@ func CheckNamespaceExists(name string) error { resp, err := http.Get(fmt.Sprintf("%s:%s/api/v1/namespaces/%s", proxyURL, proxyPort, name)) if err != nil { - fmt.Errorf("Error looking up namespace from core api server (%s)", err) + return fmt.Errorf("Error looking up namespace from core api server (%s)", err) } - defer resp.Body.Close() + defer func() { + if resp.Body != nil { + resp.Body.Close() + } + }() body, err := ioutil.ReadAll(resp.Body) if err != nil { return fmt.Errorf("Error retrieving core api server response body during namespace lookup (%s)", err) @@ -58,6 +80,7 @@ func CheckNamespaceExists(name string) error { return nil } +// SCUrlEnv will return the value of the SERVICE_CATALOG_URL env var func SCUrlEnv() string { url := os.Getenv("SERVICE_CATALOG_URL") if url == "" { @@ -66,6 +89,8 @@ func SCUrlEnv() string { return url } +// Exit1 will print the specified error string to the screen and +// then stop the program, with an exit code of 1 func Exit1(errStr string) { Error(errStr) os.Exit(1) From bf4dedd9a975adff0842b9c497dff07fa8529094 Mon Sep 17 00:00:00 2001 From: Morgan Bauer Date: Fri, 1 Sep 2017 16:56:22 -0700 Subject: [PATCH 06/24] rebase based on name change --- plugin/cmd/kubectl/bind-service/bind-service.go | 13 ++++++++----- .../create-service-broker/create-service-broker.go | 4 ++-- .../create-service-instance.go | 4 ++-- 3 files changed, 12 insertions(+), 9 deletions(-) diff --git a/plugin/cmd/kubectl/bind-service/bind-service.go b/plugin/cmd/kubectl/bind-service/bind-service.go index 77a75db94fd..a2bf280070f 100644 --- a/plugin/cmd/kubectl/bind-service/bind-service.go +++ b/plugin/cmd/kubectl/bind-service/bind-service.go @@ -41,11 +41,11 @@ func main() { utils.Exit1(usage) } - binding := v1alpha1.Binding{} + binding := v1alpha1.ServiceInstanceCredential{} binding.Kind = "binding" binding.Name = os.Args[2] binding.Namespace = os.Args[3] - binding.Spec.InstanceRef = v1.LocalObjectReference{ + binding.Spec.ServiceInstanceRef = v1.LocalObjectReference{ Name: os.Args[1], } binding.Spec.SecretName = os.Args[2] @@ -66,15 +66,18 @@ func main() { utils.Exit1(fmt.Sprintf("Error initializing client for service catalog (%s)", err)) } - fmt.Printf("Creating binding %s to %s in Namespace %s...\n", utils.Entity(binding.Name), utils.Entity(binding.Spec.InstanceRef.Name), utils.Entity(binding.Namespace)) - resp, err := svcClient.Bindings(binding.Namespace).Create(&binding) + fmt.Printf("Creating binding %s to %s in Namespace %s...\n", + utils.Entity(binding.Name), + utils.Entity(binding.Spec.ServiceInstanceRef.Name), + utils.Entity(binding.Namespace)) + resp, err := svcClient.ServiceInstanceCredentials(binding.Namespace).Create(&binding) if err != nil { utils.Exit1(fmt.Sprintf("Error binding service instance (%s)", err)) } utils.Ok() table := utils.NewTable("BINDING NAME", "NAMESPACE", "INSTANCE NAME", "SECRET NAME") - table.AddRow(resp.Name, resp.Namespace, resp.Spec.InstanceRef.Name, resp.Spec.SecretName) + table.AddRow(resp.Name, resp.Namespace, resp.Spec.ServiceInstanceRef.Name, resp.Spec.SecretName) err = table.Print() if err != nil { utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) diff --git a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go index 26d20085706..7a3f79073d9 100644 --- a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go +++ b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go @@ -40,7 +40,7 @@ func main() { utils.Exit1(usage) } - broker := v1alpha1.Broker{} + broker := v1alpha1.ServiceBroker{} broker.Kind = "Broker" broker.Name = os.Args[1] broker.Spec.URL = os.Args[2] @@ -56,7 +56,7 @@ func main() { } fmt.Printf("Creating broker %s...\n", utils.Entity(broker.Name)) - resp, err := svcClient.Brokers().Create(&broker) + resp, err := svcClient.ServiceBrokers().Create(&broker) if err != nil { utils.Exit1(fmt.Sprintf("Creating broker resource (%s)", err)) } diff --git a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go index 5c4c622c024..68301dc5c8c 100644 --- a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go +++ b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go @@ -40,7 +40,7 @@ func main() { utils.Exit1(usage) } - instance := v1alpha1.Instance{} + instance := v1alpha1.ServiceInstance{} instance.Kind = "Instance" instance.Name = os.Args[3] instance.Namespace = os.Args[4] @@ -64,7 +64,7 @@ func main() { } fmt.Printf("Creating service instance %s in Namespace %s...\n", utils.Entity(instance.Name), utils.Entity(instance.Namespace)) - resp, err := svcClient.Instances(instance.Namespace).Create(&instance) + resp, err := svcClient.ServiceInstances(instance.Namespace).Create(&instance) if err != nil { utils.Exit1(fmt.Sprintf("Failed to creating service instance (%s)", err)) } From 8d1cf3e28d8bbe887d4111e70f8ef4814b987320 Mon Sep 17 00:00:00 2001 From: Morgan Bauer Date: Fri, 1 Sep 2017 16:53:24 -0700 Subject: [PATCH 07/24] use standard build --- Makefile | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/Makefile b/Makefile index 9d8fad5e35c..1359421e4c3 100644 --- a/Makefile +++ b/Makefile @@ -392,15 +392,16 @@ release-push-%: ###################### PLUGIN_EXES=bind-service create-service-broker create-service-instance -plugins: $(BINDIR)/bind-service/bind-service \ - $(BINDIR)/create-service-broker/create-service-broker \ - $(BINDIR)/create-service-instance/create-service-instance +plugins: .init .generate_files \ + $(BINDIR)/bind-service/bind-service \ + $(BINDIR)/create-service-broker/create-service-broker \ + $(BINDIR)/create-service-instance/create-service-instance $(BINDIR)/bind-service/bind-service: \ plugin/cmd/kubectl/bind-service/bind-service.go \ plugin/cmd/kubectl/bind-service/plugin.yaml rm -rf $(BINDIR)/bind-service - $(DOCKER_CMD) go build -o $@ $< + $(DOCKER_CMD) $(GO_BUILD) -o $@ $< $(DOCKER_CMD) cp plugin/cmd/kubectl/bind-service/*yaml \ $(BINDIR)/bind-service/ @@ -408,7 +409,7 @@ $(BINDIR)/create-service-broker/create-service-broker: \ plugin/cmd/kubectl/create-service-broker/create-service-broker.go \ plugin/cmd/kubectl/create-service-broker/plugin.yaml rm -rf $(BINDIR)/create-service-broker - $(DOCKER_CMD) go build -o $@ $< + $(DOCKER_CMD) $(GO_BUILD) -o $@ $< $(DOCKER_CMD) cp plugin/cmd/kubectl/create-service-broker/*yaml \ $(BINDIR)/create-service-broker/ @@ -416,7 +417,7 @@ $(BINDIR)/create-service-instance/create-service-instance: \ plugin/cmd/kubectl/create-service-instance/create-service-instance.go \ plugin/cmd/kubectl/create-service-instance/plugin.yaml rm -rf $(BINDIR)/create-service-instance - $(DOCKER_CMD) go build -o $@ $< + $(DOCKER_CMD) $(GO_BUILD) -o $@ $< $(DOCKER_CMD) cp plugin/cmd/kubectl/create-service-instance/*yaml \ $(BINDIR)/create-service-instance/ From a81afa9371426a88aed98f273f725847ddceab54 Mon Sep 17 00:00:00 2001 From: Morgan Bauer Date: Fri, 1 Sep 2017 16:55:46 -0700 Subject: [PATCH 08/24] remove hard coded test url --- plugin/cmd/kubectl/bind-service/bind-service.go | 3 --- .../cmd/kubectl/create-service-broker/create-service-broker.go | 3 --- .../kubectl/create-service-instance/create-service-instance.go | 3 --- 3 files changed, 9 deletions(-) diff --git a/plugin/cmd/kubectl/bind-service/bind-service.go b/plugin/cmd/kubectl/bind-service/bind-service.go index a2bf280070f..6c9ad87182d 100644 --- a/plugin/cmd/kubectl/bind-service/bind-service.go +++ b/plugin/cmd/kubectl/bind-service/bind-service.go @@ -33,9 +33,6 @@ const usage = `Usage: func main() { svcURL := utils.SCUrlEnv() - if svcURL == "" { - svcURL = "192.168.99.100:30080" - } if len(os.Args) != 4 { utils.Exit1(usage) diff --git a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go index 7a3f79073d9..2876e87084f 100644 --- a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go +++ b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go @@ -32,9 +32,6 @@ const usage = `Usage: func main() { svcURL := utils.SCUrlEnv() - if svcURL == "" { - svcURL = "192.168.99.100:30080" - } if len(os.Args) != 3 { utils.Exit1(usage) diff --git a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go index 68301dc5c8c..f14e764f62f 100644 --- a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go +++ b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go @@ -32,9 +32,6 @@ const usage = `Usage: func main() { svcURL := utils.SCUrlEnv() - if svcURL == "" { - svcURL = "192.168.99.100:30080" - } if len(os.Args) != 5 { utils.Exit1(usage) From 811321446499cb42252d899e9b52291619aaf8f5 Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Fri, 3 Nov 2017 15:40:14 -0700 Subject: [PATCH 09/24] Update plugins to use v1beta1 Signed-off-by: Jonathan Berkhahn --- plugin/cmd/kubectl/bind-service/bind-service.go | 13 ++++++------- .../create-service-broker/create-service-broker.go | 12 ++++++------ .../create-service-instance.go | 14 +++++++------- 3 files changed, 19 insertions(+), 20 deletions(-) diff --git a/plugin/cmd/kubectl/bind-service/bind-service.go b/plugin/cmd/kubectl/bind-service/bind-service.go index 6c9ad87182d..98b56689429 100644 --- a/plugin/cmd/kubectl/bind-service/bind-service.go +++ b/plugin/cmd/kubectl/bind-service/bind-service.go @@ -20,11 +20,10 @@ import ( "fmt" "os" - v1alpha1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1alpha1" - clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" + v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" - "k8s.io/client-go/pkg/api/v1" "k8s.io/client-go/rest" ) @@ -38,11 +37,11 @@ func main() { utils.Exit1(usage) } - binding := v1alpha1.ServiceInstanceCredential{} + binding := v1beta1.ServiceBinding{} binding.Kind = "binding" binding.Name = os.Args[2] binding.Namespace = os.Args[3] - binding.Spec.ServiceInstanceRef = v1.LocalObjectReference{ + binding.Spec.ServiceInstanceRef = v1beta1.LocalObjectReference{ Name: os.Args[1], } binding.Spec.SecretName = os.Args[2] @@ -55,7 +54,7 @@ func main() { restConfig := rest.Config{ Host: svcURL, - APIPath: "/apis/servicecatalog.k8s.io/v1alpha1", + APIPath: "/apis/servicecatalog.k8s.io/v1beta1", } svcClient, err := clientset.NewForConfig(&restConfig) @@ -67,7 +66,7 @@ func main() { utils.Entity(binding.Name), utils.Entity(binding.Spec.ServiceInstanceRef.Name), utils.Entity(binding.Namespace)) - resp, err := svcClient.ServiceInstanceCredentials(binding.Namespace).Create(&binding) + resp, err := svcClient.ServiceBindings(binding.Namespace).Create(&binding) if err != nil { utils.Exit1(fmt.Sprintf("Error binding service instance (%s)", err)) } diff --git a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go index 2876e87084f..170b53e237c 100644 --- a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go +++ b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go @@ -20,8 +20,8 @@ import ( "fmt" "os" - v1alpha1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1alpha1" - clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" + v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" "k8s.io/client-go/rest" @@ -32,19 +32,19 @@ const usage = `Usage: func main() { svcURL := utils.SCUrlEnv() - + fmt.Println(os.Environ()) if len(os.Args) != 3 { utils.Exit1(usage) } - broker := v1alpha1.ServiceBroker{} + broker := v1beta1.ClusterServiceBroker{} broker.Kind = "Broker" broker.Name = os.Args[1] broker.Spec.URL = os.Args[2] restConfig := rest.Config{ Host: svcURL, - APIPath: "/apis/servicecatalog.k8s.io/v1alpha1", + APIPath: "/apis/servicecatalog.k8s.io/v1beta1", } svcClient, err := clientset.NewForConfig(&restConfig) @@ -53,7 +53,7 @@ func main() { } fmt.Printf("Creating broker %s...\n", utils.Entity(broker.Name)) - resp, err := svcClient.ServiceBrokers().Create(&broker) + resp, err := svcClient.ClusterServiceBrokers().Create(&broker) if err != nil { utils.Exit1(fmt.Sprintf("Creating broker resource (%s)", err)) } diff --git a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go index f14e764f62f..f8309e91837 100644 --- a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go +++ b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go @@ -20,8 +20,8 @@ import ( "fmt" "os" - v1alpha1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1alpha1" - clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" + v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" "k8s.io/client-go/rest" @@ -37,12 +37,12 @@ func main() { utils.Exit1(usage) } - instance := v1alpha1.ServiceInstance{} + instance := v1beta1.ServiceInstance{} instance.Kind = "Instance" instance.Name = os.Args[3] instance.Namespace = os.Args[4] - instance.Spec.PlanName = os.Args[2] - instance.Spec.ServiceClassName = os.Args[1] + instance.Spec.ClusterServicePlanRef.Name = os.Args[2] + instance.Spec.ClusterServiceClassRef.Name = os.Args[1] fmt.Printf("Looking up Namespace %s...\n", utils.Entity(instance.Namespace)) if err := utils.CheckNamespaceExists(instance.Namespace); err != nil { @@ -52,7 +52,7 @@ func main() { restConfig := rest.Config{ Host: svcURL, - APIPath: "/apis/servicecatalog.k8s.io/v1alpha1", + APIPath: "/apis/servicecatalog.k8s.io/v1beta1", } svcClient, err := clientset.NewForConfig(&restConfig) @@ -68,7 +68,7 @@ func main() { utils.Ok() table := utils.NewTable("INSTANCE NAME", "NAMESPACE", "PLAN NAME", "SERVICE CLASS NAME") - table.AddRow(resp.Name, resp.Namespace, resp.Spec.PlanName, resp.Spec.ServiceClassName) + table.AddRow(resp.Name, resp.Namespace, resp.Spec.ClusterServicePlanRef.Name, resp.Spec.ClusterServiceClassRef.Name) err = table.Print() if err != nil { utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) From 412c1b233cde078a2edce253f4c555733b5ae414 Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Fri, 3 Nov 2017 15:40:53 -0700 Subject: [PATCH 10/24] Add relist broker plugin Signed-off-by: Jonathan Berkhahn --- Makefile | 10 ++- .../kubectl/relist-service-broker/plugin.yaml | 3 + .../relist-service-broker.go | 70 +++++++++++++++++++ 3 files changed, 82 insertions(+), 1 deletion(-) create mode 100644 plugin/cmd/kubectl/relist-service-broker/plugin.yaml create mode 100644 plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go diff --git a/Makefile b/Makefile index 1359421e4c3..e7165b6e825 100644 --- a/Makefile +++ b/Makefile @@ -395,7 +395,8 @@ PLUGIN_EXES=bind-service create-service-broker create-service-instance plugins: .init .generate_files \ $(BINDIR)/bind-service/bind-service \ $(BINDIR)/create-service-broker/create-service-broker \ - $(BINDIR)/create-service-instance/create-service-instance + $(BINDIR)/create-service-instance/create-service-instance \ + $(BINDIR)/relist-service-broker/relist-service-broker $(BINDIR)/bind-service/bind-service: \ plugin/cmd/kubectl/bind-service/bind-service.go \ @@ -421,3 +422,10 @@ $(BINDIR)/create-service-instance/create-service-instance: \ $(DOCKER_CMD) cp plugin/cmd/kubectl/create-service-instance/*yaml \ $(BINDIR)/create-service-instance/ +$(BINDIR)/relist-service-broker/relist-service-broker: \ + plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go \ + plugin/cmd/kubectl/relist-service-broker/plugin.yaml + rm -rf $(BINDIR)/relist-service-broker + $(DOCKER_CMD) $(GO_BUILD) -o $@ $< + $(DOCKER_CMD) cp plugin/cmd/kubectl/relist-service-broker/*yaml \ + $(BINDIR)/relist-service-broker/ diff --git a/plugin/cmd/kubectl/relist-service-broker/plugin.yaml b/plugin/cmd/kubectl/relist-service-broker/plugin.yaml new file mode 100644 index 00000000000..dcfdb99cf3e --- /dev/null +++ b/plugin/cmd/kubectl/relist-service-broker/plugin.yaml @@ -0,0 +1,3 @@ +name: "relist-service-broker" +shortDesc: "This relists a service broker to update its offerings with the service catalog" +command: "./relist-service-broker" diff --git a/plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go b/plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go new file mode 100644 index 00000000000..58e43d925aa --- /dev/null +++ b/plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go @@ -0,0 +1,70 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main + +import ( + "fmt" + "os" + + clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" + "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "k8s.io/client-go/rest" +) + +const usage = `Usage: + kubectl plugin relist-service-broker BROKER_NAME` + +func main() { + svcURL := utils.SCUrlEnv() + + if len(os.Args) != 2 { + utils.Exit1(usage) + } + + restConfig := rest.Config{ + Host: svcURL, + APIPath: "/apis/servicecatalog.k8s.io/v1beta1", + } + + svcClient, err := clientset.NewForConfig(&restConfig) + if err != nil { + utils.Exit1(fmt.Sprintf("Initializing client for service catalog (%s)", err)) + } + brokerName := os.Args[1] + broker, err := svcClient.ClusterServiceBrokers().Get(brokerName, v1.GetOptions{}) + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to find broker %s (%s)", brokerName, err)) + } + + fmt.Printf("Relisting broker %s...\n", utils.Entity(broker.Name)) + broker.Spec.RelistRequests++ + resp, err := svcClient.ClusterServiceBrokers().Update(broker) + if err != nil { + utils.Exit1(fmt.Sprintf("Updating broker resource (%s)", err)) + } + + utils.Ok() + + table := utils.NewTable("BROKER NAME", "NAMESPACE", "URL") + table.AddRow(resp.Name, resp.Namespace, resp.Spec.URL) + err = table.Print() + if err != nil { + utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) + } +} From 74e55b491e0d48450dc984a76e7a17b366fe2532 Mon Sep 17 00:00:00 2001 From: juanvallejo Date: Mon, 13 Nov 2017 17:05:17 -0500 Subject: [PATCH 11/24] remove use of kubectl proxy for api calls --- .../create-service-broker.go | 2 +- plugin/cmd/kubectl/utils/utils.go | 54 ++++++------------- 2 files changed, 17 insertions(+), 39 deletions(-) diff --git a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go index 170b53e237c..e8636b403c0 100644 --- a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go +++ b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go @@ -20,7 +20,7 @@ import ( "fmt" "os" - v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" diff --git a/plugin/cmd/kubectl/utils/utils.go b/plugin/cmd/kubectl/utils/utils.go index 693ce29336a..a780e92892e 100644 --- a/plugin/cmd/kubectl/utils/utils.go +++ b/plugin/cmd/kubectl/utils/utils.go @@ -19,8 +19,6 @@ package utils import ( "encoding/json" "fmt" - "io/ioutil" - "net/http" "os" "os/exec" ) @@ -34,47 +32,31 @@ type metadata struct { Name string `json:"name"` } +// KubeGet makes a --raw GET call to the specified core api server endpoint. +// The "endpoint" parameter must begin without a slash and contain both a +// /: namespaces/foo +func KubeGet(endpoint string) ([]byte, error) { + caller := os.Getenv("KUBECTL_PLUGINS_CALLER") + kubeCmd := exec.Command(caller, "get", "--raw", "/api/v1/"+endpoint) + return kubeCmd.Output() +} + // CheckNamespaceExists will query our kube apiserver to see if the // specified namespace exists - if not it returns an error func CheckNamespaceExists(name string) error { - proxyURL := "http://127.0.0.1" - proxyPort := "8881" - - kubeProxy := exec.Command("kubectl", "proxy", "-p", proxyPort) - defer func() { - if err := kubeProxy.Process.Kill(); err != nil { - Exit1(fmt.Sprintf("failed to kill kubectl proxy (%s)", err)) - } - }() - - err := kubeProxy.Start() + result, err := KubeGet("namespaces/" + name) if err != nil { - return fmt.Errorf("Cannot start kubectl proxy (%s)", err) - } - - resp, err := http.Get(fmt.Sprintf("%s:%s/api/v1/namespaces/%s", proxyURL, proxyPort, name)) - if err != nil { - return fmt.Errorf("Error looking up namespace from core api server (%s)", err) - } - - defer func() { - if resp.Body != nil { - resp.Body.Close() - } - }() - body, err := ioutil.ReadAll(resp.Body) - if err != nil { - return fmt.Errorf("Error retrieving core api server response body during namespace lookup (%s)", err) + return fmt.Errorf("error: unable to perform namespace lookup: %v", err) } ns := namespace{} - err = json.Unmarshal(body, &ns) + err = json.Unmarshal(result, &ns) if err != nil { - return fmt.Errorf("Error parsing core api server response body during namespace lookup (%s)", err) + return fmt.Errorf("error: unable to parse core api server response during namespace lookup: %v", err) } - if ns.Code == 404 || ns.Metadata.Name == "" { - return fmt.Errorf("Namespace not found") + if ns.Code == 404 || len(ns.Metadata.Name) == 0 { + return fmt.Errorf("error: namespace %q does not exist", name) } return nil @@ -82,11 +64,7 @@ func CheckNamespaceExists(name string) error { // SCUrlEnv will return the value of the SERVICE_CATALOG_URL env var func SCUrlEnv() string { - url := os.Getenv("SERVICE_CATALOG_URL") - if url == "" { - return "" - } - return url + return os.Getenv("SERVICE_CATALOG_URL") } // Exit1 will print the specified error string to the screen and From a84e54f432525ffe61dafda8dbb9c19470102cf3 Mon Sep 17 00:00:00 2001 From: juanvallejo Date: Mon, 13 Nov 2017 17:11:57 -0500 Subject: [PATCH 12/24] acknowledge value of KUBECTL_PLUGINS_CURRENT_NAMESPACE --- .../cmd/kubectl/bind-service/bind-service.go | 7 ++- .../create-service-instance.go | 7 ++- plugin/cmd/kubectl/utils/utils.go | 56 +++++++++++++++++-- 3 files changed, 60 insertions(+), 10 deletions(-) diff --git a/plugin/cmd/kubectl/bind-service/bind-service.go b/plugin/cmd/kubectl/bind-service/bind-service.go index 98b56689429..43b33fb4bbe 100644 --- a/plugin/cmd/kubectl/bind-service/bind-service.go +++ b/plugin/cmd/kubectl/bind-service/bind-service.go @@ -28,19 +28,20 @@ import ( ) const usage = `Usage: - kubectl plugin bind-service INSTANCE_NAME BINDING_NAME NAMESPACE` + kubectl plugin bind-service INSTANCE_NAME BINDING_NAME [--namespace]` func main() { + namespace := utils.Namespace() svcURL := utils.SCUrlEnv() - if len(os.Args) != 4 { + if len(os.Args) != 3 { utils.Exit1(usage) } binding := v1beta1.ServiceBinding{} binding.Kind = "binding" binding.Name = os.Args[2] - binding.Namespace = os.Args[3] + binding.Namespace = namespace binding.Spec.ServiceInstanceRef = v1beta1.LocalObjectReference{ Name: os.Args[1], } diff --git a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go index f8309e91837..15181214a98 100644 --- a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go +++ b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go @@ -28,19 +28,20 @@ import ( ) const usage = `Usage: - kubectl plugin create-service-instance SERVICE_CLASS_NAME PLAN_NAME INSTANCE_NAME NAMESPACE` + kubectl plugin create-service-instance SERVICE_CLASS_NAME PLAN_NAME INSTANCE_NAME` func main() { + namespace := utils.Namespace() svcURL := utils.SCUrlEnv() - if len(os.Args) != 5 { + if len(os.Args) != 4 { utils.Exit1(usage) } instance := v1beta1.ServiceInstance{} instance.Kind = "Instance" instance.Name = os.Args[3] - instance.Namespace = os.Args[4] + instance.Namespace = namespace instance.Spec.ClusterServicePlanRef.Name = os.Args[2] instance.Spec.ClusterServiceClassRef.Name = os.Args[1] diff --git a/plugin/cmd/kubectl/utils/utils.go b/plugin/cmd/kubectl/utils/utils.go index a780e92892e..dfe135f38ff 100644 --- a/plugin/cmd/kubectl/utils/utils.go +++ b/plugin/cmd/kubectl/utils/utils.go @@ -19,6 +19,8 @@ package utils import ( "encoding/json" "fmt" + "io" + "io/ioutil" "os" "os/exec" ) @@ -35,19 +37,48 @@ type metadata struct { // KubeGet makes a --raw GET call to the specified core api server endpoint. // The "endpoint" parameter must begin without a slash and contain both a // /: namespaces/foo -func KubeGet(endpoint string) ([]byte, error) { +func KubeGet(endpoint string) (stdout, stderr io.ReadCloser, err error) { + v, logLevel := Loglevel() caller := os.Getenv("KUBECTL_PLUGINS_CALLER") - kubeCmd := exec.Command(caller, "get", "--raw", "/api/v1/"+endpoint) - return kubeCmd.Output() + kubeCmd := exec.Command(caller, "--namespace", Namespace(), v, logLevel, "get", "--raw", "/api/v1/"+endpoint) + + stdout, err = kubeCmd.StdoutPipe() + if err != nil { + return nil, nil, err + } + + stderr, err = kubeCmd.StderrPipe() + if err != nil { + return nil, nil, err + } + + err = kubeCmd.Start() + if err != nil { + return nil, nil, err + } + + return stdout, stderr, nil } // CheckNamespaceExists will query our kube apiserver to see if the // specified namespace exists - if not it returns an error func CheckNamespaceExists(name string) error { - result, err := KubeGet("namespaces/" + name) + stdout, stderr, err := KubeGet("namespaces/" + name) if err != nil { return fmt.Errorf("error: unable to perform namespace lookup: %v", err) } + defer stdout.Close() + defer stderr.Close() + + result, err := ioutil.ReadAll(stdout) + if err != nil { + return fmt.Errorf("error: unable to read standard output while performing a namespace lookup: %v", err) + } + + errOutput, err := ioutil.ReadAll(stderr) + if err == nil && len(errOutput) > 0 { + fmt.Fprintf(os.Stderr, "%v\n", string(errOutput)) + } ns := namespace{} err = json.Unmarshal(result, &ns) @@ -67,6 +98,23 @@ func SCUrlEnv() string { return os.Getenv("SERVICE_CATALOG_URL") } +// Namespace will return the value of KUBECTL_PLUGINS_CURRENT_NAMESPACE env var +func Namespace() string { + return os.Getenv("KUBECTL_PLUGINS_CURRENT_NAMESPACE") +} + +func Loglevel() (flagName, flagValue string) { + kubeLoglevel := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_V") + otherLoglevel := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_LOGLEVEL") + if len(otherLoglevel) > 0 { + return "--loglevel", otherLoglevel + } + if len(kubeLoglevel) == 0 { + kubeLoglevel = "0" + } + return "--v", kubeLoglevel +} + // Exit1 will print the specified error string to the screen and // then stop the program, with an exit code of 1 func Exit1(errStr string) { From dd3eb7d5a53b366b09ff8128823a84376c1d9133 Mon Sep 17 00:00:00 2001 From: juanvallejo Date: Mon, 13 Nov 2017 17:28:29 -0500 Subject: [PATCH 13/24] use KUBECONFIG to create clients --- .../cmd/kubectl/bind-service/bind-service.go | 29 ++--- .../create-service-broker.go | 19 +--- .../create-service-instance.go | 31 ++---- plugin/cmd/kubectl/utils/utils.go | 100 ++++++++---------- 4 files changed, 61 insertions(+), 118 deletions(-) diff --git a/plugin/cmd/kubectl/bind-service/bind-service.go b/plugin/cmd/kubectl/bind-service/bind-service.go index 43b33fb4bbe..a135831ced4 100644 --- a/plugin/cmd/kubectl/bind-service/bind-service.go +++ b/plugin/cmd/kubectl/bind-service/bind-service.go @@ -20,54 +20,37 @@ import ( "fmt" "os" - v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" - clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" - - "k8s.io/client-go/rest" ) const usage = `Usage: kubectl plugin bind-service INSTANCE_NAME BINDING_NAME [--namespace]` func main() { - namespace := utils.Namespace() - svcURL := utils.SCUrlEnv() - if len(os.Args) != 3 { utils.Exit1(usage) } + scClient, config := utils.NewClient() + binding := v1beta1.ServiceBinding{} binding.Kind = "binding" binding.Name = os.Args[2] - binding.Namespace = namespace + binding.Namespace = utils.Namespace() binding.Spec.ServiceInstanceRef = v1beta1.LocalObjectReference{ Name: os.Args[1], } binding.Spec.SecretName = os.Args[2] - fmt.Printf("Looking up Namespace %s...\n", utils.Entity(binding.Namespace)) - if err := utils.CheckNamespaceExists(binding.Namespace); err != nil { - utils.Exit1(err.Error()) - } + utils.CheckNamespaceExists(binding.Namespace, config) utils.Ok() - restConfig := rest.Config{ - Host: svcURL, - APIPath: "/apis/servicecatalog.k8s.io/v1beta1", - } - - svcClient, err := clientset.NewForConfig(&restConfig) - if err != nil { - utils.Exit1(fmt.Sprintf("Error initializing client for service catalog (%s)", err)) - } - fmt.Printf("Creating binding %s to %s in Namespace %s...\n", utils.Entity(binding.Name), utils.Entity(binding.Spec.ServiceInstanceRef.Name), utils.Entity(binding.Namespace)) - resp, err := svcClient.ServiceBindings(binding.Namespace).Create(&binding) + resp, err := scClient.ServicecatalogV1beta1().ServiceBindings(binding.Namespace).Create(&binding) if err != nil { utils.Exit1(fmt.Sprintf("Error binding service instance (%s)", err)) } diff --git a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go index e8636b403c0..0f01fdcc4ce 100644 --- a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go +++ b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go @@ -21,39 +21,26 @@ import ( "os" "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" - clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" - - "k8s.io/client-go/rest" ) const usage = `Usage: kubectl plugin create-service-broker BROKER_NAME BROKER_URL` func main() { - svcURL := utils.SCUrlEnv() - fmt.Println(os.Environ()) if len(os.Args) != 3 { utils.Exit1(usage) } + scClient, _ := utils.NewClient() + broker := v1beta1.ClusterServiceBroker{} broker.Kind = "Broker" broker.Name = os.Args[1] broker.Spec.URL = os.Args[2] - restConfig := rest.Config{ - Host: svcURL, - APIPath: "/apis/servicecatalog.k8s.io/v1beta1", - } - - svcClient, err := clientset.NewForConfig(&restConfig) - if err != nil { - utils.Exit1(fmt.Sprintf("Initializing client for service catalog (%s)", err)) - } - fmt.Printf("Creating broker %s...\n", utils.Entity(broker.Name)) - resp, err := svcClient.ClusterServiceBrokers().Create(&broker) + resp, err := scClient.ServicecatalogV1beta1().ClusterServiceBrokers().Create(&broker) if err != nil { utils.Exit1(fmt.Sprintf("Creating broker resource (%s)", err)) } diff --git a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go index 15181214a98..35de1fdc553 100644 --- a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go +++ b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go @@ -20,51 +20,34 @@ import ( "fmt" "os" - v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" - clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" - - "k8s.io/client-go/rest" ) const usage = `Usage: kubectl plugin create-service-instance SERVICE_CLASS_NAME PLAN_NAME INSTANCE_NAME` func main() { - namespace := utils.Namespace() - svcURL := utils.SCUrlEnv() - if len(os.Args) != 4 { utils.Exit1(usage) } + scClient, config := utils.NewClient() + instance := v1beta1.ServiceInstance{} instance.Kind = "Instance" instance.Name = os.Args[3] - instance.Namespace = namespace + instance.Namespace = utils.Namespace() instance.Spec.ClusterServicePlanRef.Name = os.Args[2] instance.Spec.ClusterServiceClassRef.Name = os.Args[1] - fmt.Printf("Looking up Namespace %s...\n", utils.Entity(instance.Namespace)) - if err := utils.CheckNamespaceExists(instance.Namespace); err != nil { - utils.Exit1(err.Error()) - } + utils.CheckNamespaceExists(instance.Namespace, config) utils.Ok() - restConfig := rest.Config{ - Host: svcURL, - APIPath: "/apis/servicecatalog.k8s.io/v1beta1", - } - - svcClient, err := clientset.NewForConfig(&restConfig) - if err != nil { - utils.Exit1(fmt.Sprintf("Failed to initializing client for service catalog (%s)", err)) - } - fmt.Printf("Creating service instance %s in Namespace %s...\n", utils.Entity(instance.Name), utils.Entity(instance.Namespace)) - resp, err := svcClient.ServiceInstances(instance.Namespace).Create(&instance) + resp, err := scClient.ServicecatalogV1beta1().ServiceInstances(instance.Namespace).Create(&instance) if err != nil { - utils.Exit1(fmt.Sprintf("Failed to creating service instance (%s)", err)) + utils.Exit1(fmt.Sprintf("Failed to create service instance (%s)", err)) } utils.Ok() diff --git a/plugin/cmd/kubectl/utils/utils.go b/plugin/cmd/kubectl/utils/utils.go index dfe135f38ff..8107ad4a03f 100644 --- a/plugin/cmd/kubectl/utils/utils.go +++ b/plugin/cmd/kubectl/utils/utils.go @@ -17,85 +17,63 @@ limitations under the License. package utils import ( - "encoding/json" "fmt" - "io" - "io/ioutil" "os" - "os/exec" -) -type namespace struct { - Metadata metadata `json:"metadata"` - Code int `json:"code"` -} + restclient "k8s.io/client-go/rest" + "k8s.io/client-go/tools/clientcmd" -type metadata struct { - Name string `json:"name"` -} + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + kclientset "k8s.io/client-go/kubernetes" -// KubeGet makes a --raw GET call to the specified core api server endpoint. -// The "endpoint" parameter must begin without a slash and contain both a -// /: namespaces/foo -func KubeGet(endpoint string) (stdout, stderr io.ReadCloser, err error) { - v, logLevel := Loglevel() - caller := os.Getenv("KUBECTL_PLUGINS_CALLER") - kubeCmd := exec.Command(caller, "--namespace", Namespace(), v, logLevel, "get", "--raw", "/api/v1/"+endpoint) + "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" + //clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" +) - stdout, err = kubeCmd.StdoutPipe() - if err != nil { - return nil, nil, err +// NewClient uses the KUBECONFIG environment variable to create a new client +// based on an existing configuration +func NewClient() (*clientset.Clientset, *restclient.Config) { + kubeconfig := os.Getenv("KUBECONFIG") + if len(kubeconfig) == 0 { + Exit1(fmt.Sprintf("error iniializing client. The KUBECONFIG environment variable must be defined.")) } - stderr, err = kubeCmd.StderrPipe() + clientConfig, _, err := clientFromConfig(kubeconfig) if err != nil { - return nil, nil, err + Exit1(fmt.Sprintf("error obtaining client configuration: %v", err)) } - err = kubeCmd.Start() + c, err := clientset.NewForConfig(clientConfig) if err != nil { - return nil, nil, err + Exit1(fmt.Sprintf("error obtaining a client from existing configuration: %v", err)) } - return stdout, stderr, nil + return c, clientConfig } -// CheckNamespaceExists will query our kube apiserver to see if the -// specified namespace exists - if not it returns an error -func CheckNamespaceExists(name string) error { - stdout, stderr, err := KubeGet("namespaces/" + name) - if err != nil { - return fmt.Errorf("error: unable to perform namespace lookup: %v", err) +func clientFromConfig(path string) (*restclient.Config, string, error) { + if path == "-" { + cfg, err := restclient.InClusterConfig() + if err != nil { + return nil, "", fmt.Errorf("cluster config not available: %v", err) + } + return cfg, "", nil } - defer stdout.Close() - defer stderr.Close() - result, err := ioutil.ReadAll(stdout) + rules := &clientcmd.ClientConfigLoadingRules{ExplicitPath: path} + credentials, err := rules.Load() if err != nil { - return fmt.Errorf("error: unable to read standard output while performing a namespace lookup: %v", err) - } - - errOutput, err := ioutil.ReadAll(stderr) - if err == nil && len(errOutput) > 0 { - fmt.Fprintf(os.Stderr, "%v\n", string(errOutput)) + return nil, "", fmt.Errorf("the provided credentials %q could not be loaded: %v", path, err) } - ns := namespace{} - err = json.Unmarshal(result, &ns) + cfg := clientcmd.NewDefaultClientConfig(*credentials, &clientcmd.ConfigOverrides{}) + config, err := cfg.ClientConfig() if err != nil { - return fmt.Errorf("error: unable to parse core api server response during namespace lookup: %v", err) - } - - if ns.Code == 404 || len(ns.Metadata.Name) == 0 { - return fmt.Errorf("error: namespace %q does not exist", name) + return nil, "", fmt.Errorf("the provided credentials %q could not be used: %v", path, err) } - return nil -} - -// SCUrlEnv will return the value of the SERVICE_CATALOG_URL env var -func SCUrlEnv() string { - return os.Getenv("SERVICE_CATALOG_URL") + namespace, _, _ := cfg.Namespace() + return config, namespace, nil } // Namespace will return the value of KUBECTL_PLUGINS_CURRENT_NAMESPACE env var @@ -103,6 +81,18 @@ func Namespace() string { return os.Getenv("KUBECTL_PLUGINS_CURRENT_NAMESPACE") } +func CheckNamespaceExists(ns string, config *restclient.Config) { + fmt.Printf("Looking up Namespace %s...\n", Entity(ns)) + kubeClient, err := kclientset.NewForConfig(config) + if err != nil { + Exit1(fmt.Sprintf("%v", err)) + } + + if _, err := kubeClient.Core().Namespaces().Get(ns, metav1.GetOptions{}); err != nil { + Exit1(fmt.Sprintf("%v", err)) + } +} + func Loglevel() (flagName, flagValue string) { kubeLoglevel := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_V") otherLoglevel := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_LOGLEVEL") From ffbbf61230f03f5a4577ad890848b76f66d9839d Mon Sep 17 00:00:00 2001 From: juanvallejo Date: Mon, 13 Nov 2017 17:30:51 -0500 Subject: [PATCH 14/24] handle global config flags --- plugin/cmd/kubectl/utils/utils.go | 107 +++++++++++++++++++++++++++++- 1 file changed, 105 insertions(+), 2 deletions(-) diff --git a/plugin/cmd/kubectl/utils/utils.go b/plugin/cmd/kubectl/utils/utils.go index 8107ad4a03f..3fb89533f96 100644 --- a/plugin/cmd/kubectl/utils/utils.go +++ b/plugin/cmd/kubectl/utils/utils.go @@ -17,8 +17,10 @@ limitations under the License. package utils import ( + "encoding/json" "fmt" "os" + "time" restclient "k8s.io/client-go/rest" "k8s.io/client-go/tools/clientcmd" @@ -27,13 +29,30 @@ import ( kclientset "k8s.io/client-go/kubernetes" "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" - //clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" ) // NewClient uses the KUBECONFIG environment variable to create a new client // based on an existing configuration func NewClient() (*clientset.Clientset, *restclient.Config) { - kubeconfig := os.Getenv("KUBECONFIG") + // resolve kubeconfig location, prioritizing the --config global flag, + // then the value of the KUBECONFIG env var (if any), and defaulting + // to ~/.kube/config as a last resort. + home := os.Getenv("HOME") + kubeconfig := home + "/.kube/config" + + kubeconfigEnv := os.Getenv("KUBECONFIG") + if len(kubeconfigEnv) > 0 { + kubeconfig = kubeconfigEnv + } + + configFile := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CONFIG") + kubeConfigFile := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_KUBECONFIG") + if len(configFile) > 0 { + kubeconfig = configFile + } else if len(kubeConfigFile) > 0 { + kubeconfig = kubeConfigFile + } + if len(kubeconfig) == 0 { Exit1(fmt.Sprintf("error iniializing client. The KUBECONFIG environment variable must be defined.")) } @@ -43,6 +62,8 @@ func NewClient() (*clientset.Clientset, *restclient.Config) { Exit1(fmt.Sprintf("error obtaining client configuration: %v", err)) } + applyGlobalOptionsToConfig(clientConfig) + c, err := clientset.NewForConfig(clientConfig) if err != nil { Exit1(fmt.Sprintf("error obtaining a client from existing configuration: %v", err)) @@ -51,6 +72,88 @@ func NewClient() (*clientset.Clientset, *restclient.Config) { return c, clientConfig } +func applyGlobalOptionsToConfig(config *restclient.Config) { + // impersonation config + impersonateUser := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_AS") + if len(impersonateUser) > 0 { + config.Impersonate.UserName = impersonateUser + } + + impersonateGroup := []string{} + err := json.Unmarshal([]byte(os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_AS_GROUP")), &impersonateGroup) + if err != nil { + Exit1(fmt.Sprintf("error parsing global option %q: %v", "--as-group", err)) + } + if len(impersonateGroup) > 0 { + config.Impersonate.Groups = impersonateGroup + } + + // tls config + + caFile := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CERTIFICATE_AUTHORITY") + if len(caFile) > 0 { + config.TLSClientConfig.CAFile = caFile + } + + clientCertFile := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CLIENT_CERTIFICATE") + if len(clientCertFile) > 0 { + config.TLSClientConfig.CertFile = clientCertFile + } + + clientKey := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CLIENT_KEY") + if len(clientKey) > 0 { + config.TLSClientConfig.KeyFile = clientKey + } + + // kubeconfig config + + cluster := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CLUSTER") + if len(cluster) > 0 { + // TODO(jvallejo): figure out how to override kubeconfig options + } + + context := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CONTEXT") + if len(context) > 0 { + // TODO(jvallejo): figure out how to override kubeconfig options + } + + user := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_USER") + if len(user) > 0 { + // TODO(jvallejo): figure out how to override kubeconfig options + } + + // user / misc request config + + requestTimeout := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_REQUEST_TIMEOUT") + if len(requestTimeout) > 0 { + t, err := time.ParseDuration(requestTimeout) + if err != nil { + Exit1(fmt.Sprintf("%v", err)) + } + config.Timeout = t + } + + server := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_SERVER") + if len(server) > 0 { + config.ServerName = server + } + + token := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_TOKEN") + if len(token) > 0 { + config.BearerToken = token + } + + username := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_USERNAME") + if len(username) > 0 { + config.Username = username + } + + password := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_PASSWORD") + if len(password) > 0 { + config.Username = password + } +} + func clientFromConfig(path string) (*restclient.Config, string, error) { if path == "-" { cfg, err := restclient.InClusterConfig() From 2a41027ec32aa8887a2bafcf4efc774c3d78fec1 Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Tue, 14 Nov 2017 16:55:09 -0800 Subject: [PATCH 15/24] Refactor relist-service-broker to work with changes --- .../relist-service-broker.go | 19 +++---------------- 1 file changed, 3 insertions(+), 16 deletions(-) diff --git a/plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go b/plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go index 58e43d925aa..333028c1b45 100644 --- a/plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go +++ b/plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go @@ -20,41 +20,28 @@ import ( "fmt" "os" - clientset "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - - "k8s.io/client-go/rest" ) const usage = `Usage: kubectl plugin relist-service-broker BROKER_NAME` func main() { - svcURL := utils.SCUrlEnv() - if len(os.Args) != 2 { utils.Exit1(usage) } - restConfig := rest.Config{ - Host: svcURL, - APIPath: "/apis/servicecatalog.k8s.io/v1beta1", - } - - svcClient, err := clientset.NewForConfig(&restConfig) - if err != nil { - utils.Exit1(fmt.Sprintf("Initializing client for service catalog (%s)", err)) - } + scClient, _ := utils.NewClient() brokerName := os.Args[1] - broker, err := svcClient.ClusterServiceBrokers().Get(brokerName, v1.GetOptions{}) + broker, err := scClient.ServicecatalogV1beta1().ClusterServiceBrokers().Get(brokerName, v1.GetOptions{}) if err != nil { utils.Exit1(fmt.Sprintf("Unable to find broker %s (%s)", brokerName, err)) } fmt.Printf("Relisting broker %s...\n", utils.Entity(broker.Name)) broker.Spec.RelistRequests++ - resp, err := svcClient.ClusterServiceBrokers().Update(broker) + resp, err := scClient.ServicecatalogV1beta1().ClusterServiceBrokers().Update(broker) if err != nil { utils.Exit1(fmt.Sprintf("Updating broker resource (%s)", err)) } From 9d3e5bd4da029de5f5e9009b96f393e229a23c11 Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Wed, 15 Nov 2017 16:35:53 -0800 Subject: [PATCH 16/24] Fix bugs in plugin output --- .../cmd/kubectl/create-service-broker/create-service-broker.go | 2 +- plugin/cmd/kubectl/utils/table_printer.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go index 0f01fdcc4ce..640ec7c566a 100644 --- a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go +++ b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go @@ -42,7 +42,7 @@ func main() { fmt.Printf("Creating broker %s...\n", utils.Entity(broker.Name)) resp, err := scClient.ServicecatalogV1beta1().ClusterServiceBrokers().Create(&broker) if err != nil { - utils.Exit1(fmt.Sprintf("Creating broker resource (%s)", err)) + utils.Exit1(fmt.Sprintf("Error creating broker resource (%s)", err)) } utils.Ok() diff --git a/plugin/cmd/kubectl/utils/table_printer.go b/plugin/cmd/kubectl/utils/table_printer.go index 08da20aad41..4f08c3583dd 100644 --- a/plugin/cmd/kubectl/utils/table_printer.go +++ b/plugin/cmd/kubectl/utils/table_printer.go @@ -54,8 +54,8 @@ func (t *Table) Print() error { fmt.Fprintln(w, printStr) //Print rows - printStr = "" for _, rows := range t.rows { + printStr = "" for _, row := range rows { printStr = printStr + row + "\t" } From 0586082211b33dafa60499afc7c1b9f5237be3b8 Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Wed, 15 Nov 2017 16:36:23 -0800 Subject: [PATCH 17/24] Add plugin for clusterservicebroker interaction --- Makefile | 11 +++- plugin/cmd/kubectl/broker/broker.go | 73 +++++++++++++++++++++++++++ plugin/cmd/kubectl/broker/plugin.yaml | 7 +++ 3 files changed, 90 insertions(+), 1 deletion(-) create mode 100644 plugin/cmd/kubectl/broker/broker.go create mode 100644 plugin/cmd/kubectl/broker/plugin.yaml diff --git a/Makefile b/Makefile index e7165b6e825..29f79cd6716 100644 --- a/Makefile +++ b/Makefile @@ -396,7 +396,8 @@ plugins: .init .generate_files \ $(BINDIR)/bind-service/bind-service \ $(BINDIR)/create-service-broker/create-service-broker \ $(BINDIR)/create-service-instance/create-service-instance \ - $(BINDIR)/relist-service-broker/relist-service-broker + $(BINDIR)/relist-service-broker/relist-service-broker \ + $(BINDIR)/broker/broker $(BINDIR)/bind-service/bind-service: \ plugin/cmd/kubectl/bind-service/bind-service.go \ @@ -429,3 +430,11 @@ $(BINDIR)/relist-service-broker/relist-service-broker: \ $(DOCKER_CMD) $(GO_BUILD) -o $@ $< $(DOCKER_CMD) cp plugin/cmd/kubectl/relist-service-broker/*yaml \ $(BINDIR)/relist-service-broker/ + +$(BINDIR)/broker/broker: \ + plugin/cmd/kubectl/broker/broker.go \ + plugin/cmd/kubectl/broker/plugin.yaml + rm -rf $(BINDIR)/broker + $(DOCKER_CMD) $(GO_BUILD) -o $@ $< + $(DOCKER_CMD) cp plugin/cmd/kubectl/broker/*yaml \ + $(BINDIR)/broker/ diff --git a/plugin/cmd/kubectl/broker/broker.go b/plugin/cmd/kubectl/broker/broker.go new file mode 100644 index 00000000000..18979e37649 --- /dev/null +++ b/plugin/cmd/kubectl/broker/broker.go @@ -0,0 +1,73 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main + +import ( + "fmt" + "os" + + "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +const usage = `Usage: + kubectl plugin broker SUBCOMMAND + +Available subcommands: + list +` + +const getUsage = `Usage: + kubectl plugin broker get BROKERNAME +` + +func main() { + if len(os.Args) < 2 { + utils.Exit1(usage) + } + + scClient, _ := utils.NewClient() + if os.Args[1] == "list" { + brokers, err := scClient.ServicecatalogV1beta1().ClusterServiceBrokers().List(v1.ListOptions{}) + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to list brokers (%s)", err)) + } + + table := utils.NewTable("BROKER NAME", "NAMESPACE", "URL") + for _, v := range brokers.Items { + table.AddRow(v.Name, v.Namespace, v.Spec.URL) + err = table.Print() + } + if err != nil { + utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) + } + } else if os.Args[1] == "get" { + if len(os.Args) != 3 { + utils.Exit1(getUsage) + } + brokerName := os.Args[2] + broker, err := scClient.ServicecatalogV1beta1().ClusterServiceBrokers().Get(brokerName, v1.GetOptions{}) + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to find broker %s (%s)", brokerName, err)) + } + table := utils.NewTable("BROKER NAME", "NAMESPACE", "URL") + table.AddRow(broker.Name, broker.Namespace, broker.Spec.URL) + err = table.Print() + } else { + utils.Exit1(usage) + } +} diff --git a/plugin/cmd/kubectl/broker/plugin.yaml b/plugin/cmd/kubectl/broker/plugin.yaml new file mode 100644 index 00000000000..dd3f6ce0c02 --- /dev/null +++ b/plugin/cmd/kubectl/broker/plugin.yaml @@ -0,0 +1,7 @@ +name: "broker" +shortDesc: "This command interacts with Cluster Service Brokers" +command: "./broker" +tree: + - name: "list" + shortDesc: "Lists all Cluster Service Brokers" + command: "./broker list" From fe0b140707e468a66198b50472b729451f1f700c Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Fri, 15 Dec 2017 14:01:47 -0800 Subject: [PATCH 18/24] MVP plugins for service-catalog interaction --- Makefile | 74 +- .../cmd/kubectl/bind-service/bind-service.go | 65 -- plugin/cmd/kubectl/bind-service/plugin.yaml | 3 - plugin/cmd/kubectl/binding/binding.go | 86 +++ plugin/cmd/kubectl/binding/plugin.yaml | 10 + plugin/cmd/kubectl/broker/broker.go | 14 +- plugin/cmd/kubectl/broker/plugin.yaml | 3 + plugin/cmd/kubectl/class/class.go | 77 ++ plugin/cmd/kubectl/class/plugin.yaml | 10 + .../create-service-broker.go | 56 -- .../kubectl/create-service-broker/plugin.yaml | 3 - .../create-service-instance.go | 60 -- .../create-service-instance/plugin.yaml | 3 - plugin/cmd/kubectl/instance/instance.go | 86 +++ plugin/cmd/kubectl/instance/plugin.yaml | 10 + plugin/cmd/kubectl/plan/plan.go | 77 ++ plugin/cmd/kubectl/plan/plugin.yaml | 10 + .../kubectl/relist-service-broker/plugin.yaml | 3 - .../relist-service-broker.go | 57 -- .../pkg/kubectl/plugin_client/assets/config | 20 + plugin/pkg/kubectl/plugin_client/binding.go | 32 + .../pkg/kubectl/plugin_client/binding_test.go | 80 ++ plugin/pkg/kubectl/plugin_client/broker.go | 32 + .../pkg/kubectl/plugin_client/broker_test.go | 73 ++ plugin/pkg/kubectl/plugin_client/class.go | 32 + .../pkg/kubectl/plugin_client/class_test.go | 73 ++ .../fake_clusterservicebroker_interface.go | 642 ++++++++++++++++ .../fake_clusterserviceclass_interface.go | 642 ++++++++++++++++ .../fake_clusterserviceplan_interface.go | 642 ++++++++++++++++ .../plugin_client/fakes/fake_interface.go | 192 +++++ .../fakes/fake_servicebinding_interface.go | 642 ++++++++++++++++ .../fake_servicecatalogv1beta1_interface.go | 364 +++++++++ .../fakes/fake_serviceinstance_interface.go | 708 ++++++++++++++++++ plugin/pkg/kubectl/plugin_client/instance.go | 32 + .../kubectl/plugin_client/instance_test.go | 80 ++ plugin/pkg/kubectl/plugin_client/plan.go | 32 + plugin/pkg/kubectl/plugin_client/plan_test.go | 73 ++ .../kubectl/plugin_client/plugin_client.go | 191 +++++ .../plugin_client/plugin_client_suite_test.go | 19 + .../kubectl/utils/table_printer.go | 0 plugin/{cmd => pkg}/kubectl/utils/ui.go | 0 plugin/{cmd => pkg}/kubectl/utils/utils.go | 0 42 files changed, 5016 insertions(+), 292 deletions(-) delete mode 100644 plugin/cmd/kubectl/bind-service/bind-service.go delete mode 100644 plugin/cmd/kubectl/bind-service/plugin.yaml create mode 100644 plugin/cmd/kubectl/binding/binding.go create mode 100644 plugin/cmd/kubectl/binding/plugin.yaml create mode 100644 plugin/cmd/kubectl/class/class.go create mode 100644 plugin/cmd/kubectl/class/plugin.yaml delete mode 100644 plugin/cmd/kubectl/create-service-broker/create-service-broker.go delete mode 100644 plugin/cmd/kubectl/create-service-broker/plugin.yaml delete mode 100644 plugin/cmd/kubectl/create-service-instance/create-service-instance.go delete mode 100644 plugin/cmd/kubectl/create-service-instance/plugin.yaml create mode 100644 plugin/cmd/kubectl/instance/instance.go create mode 100644 plugin/cmd/kubectl/instance/plugin.yaml create mode 100644 plugin/cmd/kubectl/plan/plan.go create mode 100644 plugin/cmd/kubectl/plan/plugin.yaml delete mode 100644 plugin/cmd/kubectl/relist-service-broker/plugin.yaml delete mode 100644 plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go create mode 100755 plugin/pkg/kubectl/plugin_client/assets/config create mode 100644 plugin/pkg/kubectl/plugin_client/binding.go create mode 100644 plugin/pkg/kubectl/plugin_client/binding_test.go create mode 100644 plugin/pkg/kubectl/plugin_client/broker.go create mode 100644 plugin/pkg/kubectl/plugin_client/broker_test.go create mode 100644 plugin/pkg/kubectl/plugin_client/class.go create mode 100644 plugin/pkg/kubectl/plugin_client/class_test.go create mode 100644 plugin/pkg/kubectl/plugin_client/fakes/fake_clusterservicebroker_interface.go create mode 100644 plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceclass_interface.go create mode 100644 plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceplan_interface.go create mode 100644 plugin/pkg/kubectl/plugin_client/fakes/fake_interface.go create mode 100644 plugin/pkg/kubectl/plugin_client/fakes/fake_servicebinding_interface.go create mode 100644 plugin/pkg/kubectl/plugin_client/fakes/fake_servicecatalogv1beta1_interface.go create mode 100644 plugin/pkg/kubectl/plugin_client/fakes/fake_serviceinstance_interface.go create mode 100644 plugin/pkg/kubectl/plugin_client/instance.go create mode 100644 plugin/pkg/kubectl/plugin_client/instance_test.go create mode 100644 plugin/pkg/kubectl/plugin_client/plan.go create mode 100644 plugin/pkg/kubectl/plugin_client/plan_test.go create mode 100644 plugin/pkg/kubectl/plugin_client/plugin_client.go create mode 100644 plugin/pkg/kubectl/plugin_client/plugin_client_suite_test.go rename plugin/{cmd => pkg}/kubectl/utils/table_printer.go (100%) rename plugin/{cmd => pkg}/kubectl/utils/ui.go (100%) rename plugin/{cmd => pkg}/kubectl/utils/utils.go (100%) diff --git a/Makefile b/Makefile index 29f79cd6716..060475a495f 100644 --- a/Makefile +++ b/Makefile @@ -390,46 +390,22 @@ release-push-%: # kubectl plugin stuff ###################### -PLUGIN_EXES=bind-service create-service-broker create-service-instance +PLUGIN_EXES=binding broker class instance plan plugins: .init .generate_files \ - $(BINDIR)/bind-service/bind-service \ - $(BINDIR)/create-service-broker/create-service-broker \ - $(BINDIR)/create-service-instance/create-service-instance \ - $(BINDIR)/relist-service-broker/relist-service-broker \ - $(BINDIR)/broker/broker - -$(BINDIR)/bind-service/bind-service: \ - plugin/cmd/kubectl/bind-service/bind-service.go \ - plugin/cmd/kubectl/bind-service/plugin.yaml - rm -rf $(BINDIR)/bind-service + $(BINDIR)/binding/binding \ + $(BINDIR)/broker/broker \ + $(BINDIR)/class/class \ + $(BINDIR)/instance/instance \ + $(BINDIR)/plan/plan + +$(BINDIR)/binding/binding: \ + plugin/cmd/kubectl/binding/binding.go \ + plugin/cmd/kubectl/binding/plugin.yaml + rm -rf $(BINDIR)/binding $(DOCKER_CMD) $(GO_BUILD) -o $@ $< - $(DOCKER_CMD) cp plugin/cmd/kubectl/bind-service/*yaml \ - $(BINDIR)/bind-service/ - -$(BINDIR)/create-service-broker/create-service-broker: \ - plugin/cmd/kubectl/create-service-broker/create-service-broker.go \ - plugin/cmd/kubectl/create-service-broker/plugin.yaml - rm -rf $(BINDIR)/create-service-broker - $(DOCKER_CMD) $(GO_BUILD) -o $@ $< - $(DOCKER_CMD) cp plugin/cmd/kubectl/create-service-broker/*yaml \ - $(BINDIR)/create-service-broker/ - -$(BINDIR)/create-service-instance/create-service-instance: \ - plugin/cmd/kubectl/create-service-instance/create-service-instance.go \ - plugin/cmd/kubectl/create-service-instance/plugin.yaml - rm -rf $(BINDIR)/create-service-instance - $(DOCKER_CMD) $(GO_BUILD) -o $@ $< - $(DOCKER_CMD) cp plugin/cmd/kubectl/create-service-instance/*yaml \ - $(BINDIR)/create-service-instance/ - -$(BINDIR)/relist-service-broker/relist-service-broker: \ - plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go \ - plugin/cmd/kubectl/relist-service-broker/plugin.yaml - rm -rf $(BINDIR)/relist-service-broker - $(DOCKER_CMD) $(GO_BUILD) -o $@ $< - $(DOCKER_CMD) cp plugin/cmd/kubectl/relist-service-broker/*yaml \ - $(BINDIR)/relist-service-broker/ + $(DOCKER_CMD) cp plugin/cmd/kubectl/binding/*yaml \ + $(BINDIR)/binding/ $(BINDIR)/broker/broker: \ plugin/cmd/kubectl/broker/broker.go \ @@ -438,3 +414,27 @@ $(BINDIR)/broker/broker: \ $(DOCKER_CMD) $(GO_BUILD) -o $@ $< $(DOCKER_CMD) cp plugin/cmd/kubectl/broker/*yaml \ $(BINDIR)/broker/ + +$(BINDIR)/class/class: \ + plugin/cmd/kubectl/class/class.go \ + plugin/cmd/kubectl/class/plugin.yaml + rm -rf $(BINDIR)/class + $(DOCKER_CMD) $(GO_BUILD) -o $@ $< + $(DOCKER_CMD) cp plugin/cmd/kubectl/class/*yaml \ + $(BINDIR)/class/ + +$(BINDIR)/instance/instance: \ + plugin/cmd/kubectl/instance/instance.go \ + plugin/cmd/kubectl/instance/plugin.yaml + rm -rf $(BINDIR)/instance + $(DOCKER_CMD) $(GO_BUILD) -o $@ $< + $(DOCKER_CMD) cp plugin/cmd/kubectl/instance/*yaml \ + $(BINDIR)/instance/ + +$(BINDIR)/plan/plan: \ + plugin/cmd/kubectl/plan/plan.go \ + plugin/cmd/kubectl/plan/plugin.yaml + rm -rf $(BINDIR)/plan + $(DOCKER_CMD) $(GO_BUILD) -o $@ $< + $(DOCKER_CMD) cp plugin/cmd/kubectl/plan/*yaml \ + $(BINDIR)/plan/ diff --git a/plugin/cmd/kubectl/bind-service/bind-service.go b/plugin/cmd/kubectl/bind-service/bind-service.go deleted file mode 100644 index a135831ced4..00000000000 --- a/plugin/cmd/kubectl/bind-service/bind-service.go +++ /dev/null @@ -1,65 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package main - -import ( - "fmt" - "os" - - "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" - "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" -) - -const usage = `Usage: - kubectl plugin bind-service INSTANCE_NAME BINDING_NAME [--namespace]` - -func main() { - if len(os.Args) != 3 { - utils.Exit1(usage) - } - - scClient, config := utils.NewClient() - - binding := v1beta1.ServiceBinding{} - binding.Kind = "binding" - binding.Name = os.Args[2] - binding.Namespace = utils.Namespace() - binding.Spec.ServiceInstanceRef = v1beta1.LocalObjectReference{ - Name: os.Args[1], - } - binding.Spec.SecretName = os.Args[2] - - utils.CheckNamespaceExists(binding.Namespace, config) - utils.Ok() - - fmt.Printf("Creating binding %s to %s in Namespace %s...\n", - utils.Entity(binding.Name), - utils.Entity(binding.Spec.ServiceInstanceRef.Name), - utils.Entity(binding.Namespace)) - resp, err := scClient.ServicecatalogV1beta1().ServiceBindings(binding.Namespace).Create(&binding) - if err != nil { - utils.Exit1(fmt.Sprintf("Error binding service instance (%s)", err)) - } - utils.Ok() - - table := utils.NewTable("BINDING NAME", "NAMESPACE", "INSTANCE NAME", "SECRET NAME") - table.AddRow(resp.Name, resp.Namespace, resp.Spec.ServiceInstanceRef.Name, resp.Spec.SecretName) - err = table.Print() - if err != nil { - utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) - } -} diff --git a/plugin/cmd/kubectl/bind-service/plugin.yaml b/plugin/cmd/kubectl/bind-service/plugin.yaml deleted file mode 100644 index 3dfa0d6727d..00000000000 --- a/plugin/cmd/kubectl/bind-service/plugin.yaml +++ /dev/null @@ -1,3 +0,0 @@ -name: "bind-service" -shortDesc: "This command binds a service class to a service instance" -command: "./bind-service" diff --git a/plugin/cmd/kubectl/binding/binding.go b/plugin/cmd/kubectl/binding/binding.go new file mode 100644 index 00000000000..38e1a2ae82b --- /dev/null +++ b/plugin/cmd/kubectl/binding/binding.go @@ -0,0 +1,86 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main + +import ( + "fmt" + "os" + + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/utils" +) + +const usage = `Usage: + kubectl plugin binding SUBCOMMAND + +Available subcommands: + list + get +` + +const listUsage = `Usage: + kubectl plugin binding list NAMESPACE +` + +const getUsage = `Usage: + kubectl plugin binding get NAMESPACE INSTANCENAME +` + +func main() { + if len(os.Args) < 2 { + utils.Exit1(usage) + } + + client, err := plugin_client.NewClient() + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to initialize service catalog client (%s)", err)) + } + if os.Args[1] == "list" { + if len(os.Args) != 3 { + utils.Exit1(listUsage) + } + namespace := os.Args[2] + bindings, err := client.ListBindings(namespace) + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to list bindings in namespace %s (%s)", namespace, err)) + } + + table := utils.NewTable("BINDING NAME", "NAMESPACE", "INSTANCE NAME") + for _, v := range bindings.Items { + table.AddRow(v.Name, v.Namespace, v.Spec.ServiceInstanceRef.Name) + err = table.Print() + } + if err != nil { + utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) + } + } else if os.Args[1] == "get" { + if len(os.Args) != 4 { + utils.Exit1(getUsage) + } + namespace := os.Args[2] + bindingName := os.Args[3] + binding, err := client.GetBinding(bindingName, namespace) + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to find binding %s in namespae %s (%s)", bindingName, namespace, err)) + } + table := utils.NewTable("BINDINGNAME", "NAMESPACE", "INSTANCE NAME") + table.AddRow(binding.Name, binding.Namespace, binding.Spec.ServiceInstanceRef.Name) + err = table.Print() + } else { + utils.Exit1(usage) + } +} diff --git a/plugin/cmd/kubectl/binding/plugin.yaml b/plugin/cmd/kubectl/binding/plugin.yaml new file mode 100644 index 00000000000..7f206082aa9 --- /dev/null +++ b/plugin/cmd/kubectl/binding/plugin.yaml @@ -0,0 +1,10 @@ +name: "binding" +shortDesc: "This command interacts with Service Bindings" +command: "./binding" +tree: + - name: "list" + shortDesc: "Lists all Service Bindings in a particular namespace" + command: "./binding list" + - name: "get" + shortDesc: "Gets a particular Service Bindings in a particular namespace" + command: "./binding get" diff --git a/plugin/cmd/kubectl/broker/broker.go b/plugin/cmd/kubectl/broker/broker.go index 18979e37649..7c0289877aa 100644 --- a/plugin/cmd/kubectl/broker/broker.go +++ b/plugin/cmd/kubectl/broker/broker.go @@ -20,8 +20,8 @@ import ( "fmt" "os" - "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" - v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/utils" ) const usage = `Usage: @@ -29,6 +29,7 @@ const usage = `Usage: Available subcommands: list + get ` const getUsage = `Usage: @@ -40,9 +41,12 @@ func main() { utils.Exit1(usage) } - scClient, _ := utils.NewClient() + client, err := plugin_client.NewClient() + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to initialize service catalog client (%s)", err)) + } if os.Args[1] == "list" { - brokers, err := scClient.ServicecatalogV1beta1().ClusterServiceBrokers().List(v1.ListOptions{}) + brokers, err := client.ListBrokers() if err != nil { utils.Exit1(fmt.Sprintf("Unable to list brokers (%s)", err)) } @@ -60,7 +64,7 @@ func main() { utils.Exit1(getUsage) } brokerName := os.Args[2] - broker, err := scClient.ServicecatalogV1beta1().ClusterServiceBrokers().Get(brokerName, v1.GetOptions{}) + broker, err := client.GetBroker(brokerName) if err != nil { utils.Exit1(fmt.Sprintf("Unable to find broker %s (%s)", brokerName, err)) } diff --git a/plugin/cmd/kubectl/broker/plugin.yaml b/plugin/cmd/kubectl/broker/plugin.yaml index dd3f6ce0c02..96bb0d78aa4 100644 --- a/plugin/cmd/kubectl/broker/plugin.yaml +++ b/plugin/cmd/kubectl/broker/plugin.yaml @@ -5,3 +5,6 @@ tree: - name: "list" shortDesc: "Lists all Cluster Service Brokers" command: "./broker list" + - name: "get" + shortDesc: "Gets a particular Cluster Service Broker" + command: "./broker get" diff --git a/plugin/cmd/kubectl/class/class.go b/plugin/cmd/kubectl/class/class.go new file mode 100644 index 00000000000..cdbe0e74a84 --- /dev/null +++ b/plugin/cmd/kubectl/class/class.go @@ -0,0 +1,77 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main + +import ( + "fmt" + "os" + + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/utils" +) + +const usage = `Usage: + kubectl plugin class SUBCOMMAND + +Available subcommands: + list + get +` + +const getUsage = `Usage: + kubectl plugin class get CLASSNAME +` + +func main() { + if len(os.Args) < 2 { + utils.Exit1(usage) + } + + client, err := plugin_client.NewClient() + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to initialize service catalog client (%s)", err)) + } + if os.Args[1] == "list" { + classes, err := client.ListClasses() + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to list classes (%s)", err)) + } + + table := utils.NewTable("CLASS NAME", "NAMESPACE", "BROKER NAME") + for _, v := range classes.Items { + table.AddRow(v.Name, v.Namespace, v.Spec.ClusterServiceBrokerName) + err = table.Print() + } + if err != nil { + utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) + } + } else if os.Args[1] == "get" { + if len(os.Args) != 3 { + utils.Exit1(getUsage) + } + className := os.Args[2] + class, err := client.GetClass(className) + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to find class %s (%s)", className, err)) + } + table := utils.NewTable("CLASS NAME", "NAMESPACE", "BROKER NAME") + table.AddRow(class.Name, class.Namespace, class.Spec.ClusterServiceBrokerName) + err = table.Print() + } else { + utils.Exit1(usage) + } +} diff --git a/plugin/cmd/kubectl/class/plugin.yaml b/plugin/cmd/kubectl/class/plugin.yaml new file mode 100644 index 00000000000..fa77c0d5c45 --- /dev/null +++ b/plugin/cmd/kubectl/class/plugin.yaml @@ -0,0 +1,10 @@ +name: "class" +shortDesc: "This command interacts with Cluster Service Classes" +command: "./class" +tree: + - name: "list" + shortDesc: "Lists all Cluster Service Classes" + command: "./class list" + - name: "get" + shortDesc: "Gets a particular Cluster Service Class" + command: "./class get" diff --git a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go b/plugin/cmd/kubectl/create-service-broker/create-service-broker.go deleted file mode 100644 index 640ec7c566a..00000000000 --- a/plugin/cmd/kubectl/create-service-broker/create-service-broker.go +++ /dev/null @@ -1,56 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package main - -import ( - "fmt" - "os" - - "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" - "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" -) - -const usage = `Usage: - kubectl plugin create-service-broker BROKER_NAME BROKER_URL` - -func main() { - if len(os.Args) != 3 { - utils.Exit1(usage) - } - - scClient, _ := utils.NewClient() - - broker := v1beta1.ClusterServiceBroker{} - broker.Kind = "Broker" - broker.Name = os.Args[1] - broker.Spec.URL = os.Args[2] - - fmt.Printf("Creating broker %s...\n", utils.Entity(broker.Name)) - resp, err := scClient.ServicecatalogV1beta1().ClusterServiceBrokers().Create(&broker) - if err != nil { - utils.Exit1(fmt.Sprintf("Error creating broker resource (%s)", err)) - } - - utils.Ok() - - table := utils.NewTable("BROKER NAME", "NAMESPACE", "URL") - table.AddRow(resp.Name, resp.Namespace, resp.Spec.URL) - err = table.Print() - if err != nil { - utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) - } -} diff --git a/plugin/cmd/kubectl/create-service-broker/plugin.yaml b/plugin/cmd/kubectl/create-service-broker/plugin.yaml deleted file mode 100644 index a8d763cc44c..00000000000 --- a/plugin/cmd/kubectl/create-service-broker/plugin.yaml +++ /dev/null @@ -1,3 +0,0 @@ -name: "create-service-broker" -shortDesc: "This registers a service broker with the service catalog" -command: "./create-service-broker" diff --git a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go b/plugin/cmd/kubectl/create-service-instance/create-service-instance.go deleted file mode 100644 index 35de1fdc553..00000000000 --- a/plugin/cmd/kubectl/create-service-instance/create-service-instance.go +++ /dev/null @@ -1,60 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package main - -import ( - "fmt" - "os" - - "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" - "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" -) - -const usage = `Usage: - kubectl plugin create-service-instance SERVICE_CLASS_NAME PLAN_NAME INSTANCE_NAME` - -func main() { - if len(os.Args) != 4 { - utils.Exit1(usage) - } - - scClient, config := utils.NewClient() - - instance := v1beta1.ServiceInstance{} - instance.Kind = "Instance" - instance.Name = os.Args[3] - instance.Namespace = utils.Namespace() - instance.Spec.ClusterServicePlanRef.Name = os.Args[2] - instance.Spec.ClusterServiceClassRef.Name = os.Args[1] - - utils.CheckNamespaceExists(instance.Namespace, config) - utils.Ok() - - fmt.Printf("Creating service instance %s in Namespace %s...\n", utils.Entity(instance.Name), utils.Entity(instance.Namespace)) - resp, err := scClient.ServicecatalogV1beta1().ServiceInstances(instance.Namespace).Create(&instance) - if err != nil { - utils.Exit1(fmt.Sprintf("Failed to create service instance (%s)", err)) - } - utils.Ok() - - table := utils.NewTable("INSTANCE NAME", "NAMESPACE", "PLAN NAME", "SERVICE CLASS NAME") - table.AddRow(resp.Name, resp.Namespace, resp.Spec.ClusterServicePlanRef.Name, resp.Spec.ClusterServiceClassRef.Name) - err = table.Print() - if err != nil { - utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) - } -} diff --git a/plugin/cmd/kubectl/create-service-instance/plugin.yaml b/plugin/cmd/kubectl/create-service-instance/plugin.yaml deleted file mode 100644 index f458803ddbc..00000000000 --- a/plugin/cmd/kubectl/create-service-instance/plugin.yaml +++ /dev/null @@ -1,3 +0,0 @@ -name: "create-service-instance" -shortDesc: "This command creates a service instance that is ready to be bound to" -command: "./create-service-instance" diff --git a/plugin/cmd/kubectl/instance/instance.go b/plugin/cmd/kubectl/instance/instance.go new file mode 100644 index 00000000000..46f03664c31 --- /dev/null +++ b/plugin/cmd/kubectl/instance/instance.go @@ -0,0 +1,86 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main + +import ( + "fmt" + "os" + + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/utils" +) + +const usage = `Usage: + kubectl plugin instance SUBCOMMAND + +Available subcommands: + list + get +` + +const listUsage = `Usage: + kubectl plugin instance list NAMESPACE +` + +const getUsage = `Usage: + kubectl plugin instance get NAMESPACE INSTANCENAME +` + +func main() { + if len(os.Args) < 2 { + utils.Exit1(usage) + } + + client, err := plugin_client.NewClient() + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to initialize service catalog client (%s)", err)) + } + if os.Args[1] == "list" { + if len(os.Args) != 3 { + utils.Exit1(listUsage) + } + namespace := os.Args[2] + instances, err := client.ListInstances(namespace) + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to list instances in namespace %s (%s)", namespace, err)) + } + + table := utils.NewTable("INSTANCE NAME", "NAMESPACE", "CLASS NAME", "PLAN NAME") + for _, v := range instances.Items { + table.AddRow(v.Name, v.Namespace, v.Spec.ClusterServiceClassRef.Name, v.Spec.ClusterServicePlanRef.Name) + err = table.Print() + } + if err != nil { + utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) + } + } else if os.Args[1] == "get" { + if len(os.Args) != 4 { + utils.Exit1(getUsage) + } + namespace := os.Args[2] + instanceName := os.Args[3] + instance, err := client.GetInstance(instanceName, namespace) + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to find instance %s in namespace %s (%s)", instanceName, namespace, err)) + } + table := utils.NewTable("INSTANCE NAME", "NAMESPACE", "CLASS NAME", "PLAN NAME") + table.AddRow(instance.Name, instance.Namespace, instance.Spec.ClusterServiceClassRef.Name, instance.Spec.ClusterServicePlanRef.Name) + err = table.Print() + } else { + utils.Exit1(usage) + } +} diff --git a/plugin/cmd/kubectl/instance/plugin.yaml b/plugin/cmd/kubectl/instance/plugin.yaml new file mode 100644 index 00000000000..8aab807e705 --- /dev/null +++ b/plugin/cmd/kubectl/instance/plugin.yaml @@ -0,0 +1,10 @@ +name: "instance" +shortDesc: "This command interacts with Service Instances" +command: "./instance" +tree: + - name: "list" + shortDesc: "Lists all Service Instances in a particular namespace" + command: "./instance list" + - name: "get" + shortDesc: "Gets a particular Service Instance in a particular namespace" + command: "./instance get" diff --git a/plugin/cmd/kubectl/plan/plan.go b/plugin/cmd/kubectl/plan/plan.go new file mode 100644 index 00000000000..55925a2249b --- /dev/null +++ b/plugin/cmd/kubectl/plan/plan.go @@ -0,0 +1,77 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main + +import ( + "fmt" + "os" + + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/utils" +) + +const usage = `Usage: + kubectl plugin plan SUBCOMMAND + +Available subcommands: + list + get +` + +const getUsage = `Usage: + kubectl plugin plan get PLANNAME +` + +func main() { + if len(os.Args) < 2 { + utils.Exit1(usage) + } + + client, err := plugin_client.NewClient() + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to initialize service catalog client (%s)", err)) + } + if os.Args[1] == "list" { + plans, err := client.ListPlans() + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to list plans (%s)", err)) + } + + table := utils.NewTable("PLAN NAME", "DESCRIPTION", "BROKER NAME") + for _, v := range plans.Items { + table.AddRow(v.Name, v.Spec.Description, v.Spec.ClusterServiceBrokerName) + err = table.Print() + } + if err != nil { + utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) + } + } else if os.Args[1] == "get" { + if len(os.Args) != 3 { + utils.Exit1(getUsage) + } + planName := os.Args[2] + plan, err := client.GetPlan(planName) + if err != nil { + utils.Exit1(fmt.Sprintf("Unable to find plan %s (%s)", planName, err)) + } + table := utils.NewTable("PLAN NAME", "DESCRIPTIONS", "BROKER NAME") + table.AddRow(plan.Name, plan.Spec.Description, plan.Spec.ClusterServiceBrokerName) + err = table.Print() + } else { + utils.Exit1(usage) + } +} diff --git a/plugin/cmd/kubectl/plan/plugin.yaml b/plugin/cmd/kubectl/plan/plugin.yaml new file mode 100644 index 00000000000..2c67c04ea36 --- /dev/null +++ b/plugin/cmd/kubectl/plan/plugin.yaml @@ -0,0 +1,10 @@ +name: "plan" +shortDesc: "This command interacts with Cluster Service Plans" +command: "./plan" +tree: + - name: "list" + shortDesc: "Lists all Cluster Service Plans" + command: "./plan list" + - name: "get" + shortDesc: "Gets a particular Cluster Service Plan" + command: "./plan get" diff --git a/plugin/cmd/kubectl/relist-service-broker/plugin.yaml b/plugin/cmd/kubectl/relist-service-broker/plugin.yaml deleted file mode 100644 index dcfdb99cf3e..00000000000 --- a/plugin/cmd/kubectl/relist-service-broker/plugin.yaml +++ /dev/null @@ -1,3 +0,0 @@ -name: "relist-service-broker" -shortDesc: "This relists a service broker to update its offerings with the service catalog" -command: "./relist-service-broker" diff --git a/plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go b/plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go deleted file mode 100644 index 333028c1b45..00000000000 --- a/plugin/cmd/kubectl/relist-service-broker/relist-service-broker.go +++ /dev/null @@ -1,57 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package main - -import ( - "fmt" - "os" - - "github.com/kubernetes-incubator/service-catalog/plugin/cmd/kubectl/utils" - v1 "k8s.io/apimachinery/pkg/apis/meta/v1" -) - -const usage = `Usage: - kubectl plugin relist-service-broker BROKER_NAME` - -func main() { - if len(os.Args) != 2 { - utils.Exit1(usage) - } - - scClient, _ := utils.NewClient() - brokerName := os.Args[1] - broker, err := scClient.ServicecatalogV1beta1().ClusterServiceBrokers().Get(brokerName, v1.GetOptions{}) - if err != nil { - utils.Exit1(fmt.Sprintf("Unable to find broker %s (%s)", brokerName, err)) - } - - fmt.Printf("Relisting broker %s...\n", utils.Entity(broker.Name)) - broker.Spec.RelistRequests++ - resp, err := scClient.ServicecatalogV1beta1().ClusterServiceBrokers().Update(broker) - if err != nil { - utils.Exit1(fmt.Sprintf("Updating broker resource (%s)", err)) - } - - utils.Ok() - - table := utils.NewTable("BROKER NAME", "NAMESPACE", "URL") - table.AddRow(resp.Name, resp.Namespace, resp.Spec.URL) - err = table.Print() - if err != nil { - utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) - } -} diff --git a/plugin/pkg/kubectl/plugin_client/assets/config b/plugin/pkg/kubectl/plugin_client/assets/config new file mode 100755 index 00000000000..b19682e031a --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/assets/config @@ -0,0 +1,20 @@ +apiVersion: v1 +clusters: +- cluster: + certificate-authority: + server: https://notreal.com:1234 + name: local +contexts: +- context: + cluster: local + user: myself + name: local +current-context: local +kind: Config +preferences: {} +users: +- name: myself + user: + as-user-extra: {} + username: foo + password: bar diff --git a/plugin/pkg/kubectl/plugin_client/binding.go b/plugin/pkg/kubectl/plugin_client/binding.go new file mode 100644 index 00000000000..1fa82be467a --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/binding.go @@ -0,0 +1,32 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package plugin_client + +import ( + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +func (c *PluginClient) GetBinding(bindingName, namespace string) (*v1beta1.ServiceBinding, error) { + binding, err := c.ScClient.ServicecatalogV1beta1().ServiceBindings(namespace).Get(bindingName, v1.GetOptions{}) + return binding, err +} + +func (c *PluginClient) ListBindings(namespace string) (*v1beta1.ServiceBindingList, error) { + bindings, err := c.ScClient.ServicecatalogV1beta1().ServiceBindings(namespace).List(v1.ListOptions{}) + return bindings, err +} diff --git a/plugin/pkg/kubectl/plugin_client/binding_test.go b/plugin/pkg/kubectl/plugin_client/binding_test.go new file mode 100644 index 00000000000..50495f9e104 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/binding_test.go @@ -0,0 +1,80 @@ +package plugin_client_test + +import ( + "errors" + + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client/fakes" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("Binding", func() { + var ( + client *plugin_client.PluginClient + err error + FakeScClient *fakes.FakeInterface + ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface + ServiceBindings *fakes.FakeServiceBindingInterface + ) + + BeforeEach(func() { + client, err = plugin_client.NewClient() + Expect(err).NotTo(HaveOccurred()) + FakeScClient = &fakes.FakeInterface{} + ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} + ServiceBindings = &fakes.FakeServiceBindingInterface{} + + client.ScClient = FakeScClient + FakeScClient.ServicecatalogV1beta1Returns(ServicecatalogV1beta1) + ServicecatalogV1beta1.ServiceBindingsReturns(ServiceBindings) + }) + + Describe("Get", func() { + It("Calls the generated v1beta1 List method with the passed in binding and namespace", func() { + namespace := "foobar_namespace" + bindingName := "potato_binding" + + _, err := client.GetBinding(bindingName, namespace) + Expect(err).NotTo(HaveOccurred()) + Expect(ServicecatalogV1beta1.ServiceBindingsArgsForCall(0)).To(Equal(namespace)) + returnedName, _ := ServiceBindings.GetArgsForCall(0) + Expect(returnedName).To(Equal(bindingName)) + Expect(ServiceBindings.GetCallCount()).To(Equal(1)) + }) + It("Bubbles up errors", func() { + namespace := "foobar_namespace" + bindingName := "potato_binding" + errorMessage := "binding not found" + + ServiceBindings.GetReturns(nil, errors.New(errorMessage)) + _, err := client.GetBinding(bindingName, namespace) + Expect(err).To(HaveOccurred()) + Expect(ServiceBindings.GetCallCount()).To(Equal(1)) + }) + }) + + Describe("List", func() { + It("Calls the generated v1beta1 List method with the specified namespace", func() { + namespace := "foobar_namespace" + + _, err := client.ListBindings(namespace) + + Expect(err).NotTo(HaveOccurred()) + Expect(ServicecatalogV1beta1.ServiceBindingsArgsForCall(0)).To(Equal(namespace)) + Expect(ServiceBindings.ListCallCount()).To(Equal(1)) + }) + It("Bubbles up errors", func() { + ServiceBindings.ListReturns(nil, errors.New("foobar")) + namespace := "foobar_namespace" + + _, err := client.ListBindings(namespace) + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).Should(ContainSubstring("foobar")) + Expect(ServicecatalogV1beta1.ServiceBindingsArgsForCall(0)).To(Equal(namespace)) + Expect(ServiceBindings.ListCallCount()).To(Equal(1)) + }) + }) +}) diff --git a/plugin/pkg/kubectl/plugin_client/broker.go b/plugin/pkg/kubectl/plugin_client/broker.go new file mode 100644 index 00000000000..922c94f0938 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/broker.go @@ -0,0 +1,32 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package plugin_client + +import ( + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +func (c *PluginClient) GetBroker(brokerName string) (*v1beta1.ClusterServiceBroker, error) { + broker, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceBrokers().Get(brokerName, v1.GetOptions{}) + return broker, err +} + +func (c *PluginClient) ListBrokers() (*v1beta1.ClusterServiceBrokerList, error) { + brokers, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceBrokers().List(v1.ListOptions{}) + return brokers, err +} diff --git a/plugin/pkg/kubectl/plugin_client/broker_test.go b/plugin/pkg/kubectl/plugin_client/broker_test.go new file mode 100644 index 00000000000..3af3ee04f35 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/broker_test.go @@ -0,0 +1,73 @@ +package plugin_client_test + +import ( + "errors" + + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client/fakes" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("Broker", func() { + var ( + client *plugin_client.PluginClient + err error + FakeScClient *fakes.FakeInterface + ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface + ClusterServiceBrokers *fakes.FakeClusterServiceBrokerInterface + ) + + BeforeEach(func() { + client, err = plugin_client.NewClient() + Expect(err).NotTo(HaveOccurred()) + FakeScClient = &fakes.FakeInterface{} + ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} + ClusterServiceBrokers = &fakes.FakeClusterServiceBrokerInterface{} + + client.ScClient = FakeScClient + FakeScClient.ServicecatalogV1beta1Returns(ServicecatalogV1beta1) + ServicecatalogV1beta1.ClusterServiceBrokersReturns(ClusterServiceBrokers) + }) + + Describe("Get", func() { + It("Calls the generated v1beta1 List method with the passed in broker", func() { + brokerName := "foobar" + _, err = client.GetBroker(brokerName) + + Expect(ClusterServiceBrokers.GetCallCount()).To(Equal(1)) + name, _ := ClusterServiceBrokers.GetArgsForCall(0) + Expect(name).To(Equal(brokerName)) + }) + It("Bubbles up errors", func() { + errorMessage := "broker not found" + ClusterServiceBrokers.GetReturns(nil, errors.New(errorMessage)) + + _, err := client.GetBroker("banana") + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).Should(ContainSubstring(errorMessage)) + Expect(ClusterServiceBrokers.GetCallCount()).To(Equal(1)) + }) + }) + + Describe("List", func() { + It("Calls the generated v1beta1 List method", func() { + _, err := client.ListBrokers() + + Expect(err).NotTo(HaveOccurred()) + Expect(ClusterServiceBrokers.ListCallCount()).To(Equal(1)) + }) + It("Bubbles up errors", func() { + errorMessage := "foobar" + ClusterServiceBrokers.ListReturns(nil, errors.New(errorMessage)) + + _, err := client.ListBrokers() + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).Should(ContainSubstring(errorMessage)) + Expect(ClusterServiceBrokers.ListCallCount()).To(Equal(1)) + }) + }) +}) diff --git a/plugin/pkg/kubectl/plugin_client/class.go b/plugin/pkg/kubectl/plugin_client/class.go new file mode 100644 index 00000000000..8b229d2294f --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/class.go @@ -0,0 +1,32 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package plugin_client + +import ( + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +func (c *PluginClient) GetClass(className string) (*v1beta1.ClusterServiceClass, error) { + class, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceClasses().Get(className, v1.GetOptions{}) + return class, err +} + +func (c *PluginClient) ListClasses() (*v1beta1.ClusterServiceClassList, error) { + classes, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceClasses().List(v1.ListOptions{}) + return classes, err +} diff --git a/plugin/pkg/kubectl/plugin_client/class_test.go b/plugin/pkg/kubectl/plugin_client/class_test.go new file mode 100644 index 00000000000..87e1aa04075 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/class_test.go @@ -0,0 +1,73 @@ +package plugin_client_test + +import ( + "errors" + + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client/fakes" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("Class", func() { + var ( + client *plugin_client.PluginClient + err error + FakeScClient *fakes.FakeInterface + ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface + ClusterServiceClasses *fakes.FakeClusterServiceClassInterface + ) + + BeforeEach(func() { + client, err = plugin_client.NewClient() + Expect(err).NotTo(HaveOccurred()) + FakeScClient = &fakes.FakeInterface{} + ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} + ClusterServiceClasses = &fakes.FakeClusterServiceClassInterface{} + + client.ScClient = FakeScClient + FakeScClient.ServicecatalogV1beta1Returns(ServicecatalogV1beta1) + ServicecatalogV1beta1.ClusterServiceClassesReturns(ClusterServiceClasses) + }) + + Describe("Get", func() { + It("Calls the generated v1beta1 List method with the passed in class", func() { + className := "foobar" + _, err = client.GetClass(className) + + Expect(ClusterServiceClasses.GetCallCount()).To(Equal(1)) + name, _ := ClusterServiceClasses.GetArgsForCall(0) + Expect(name).To(Equal(className)) + }) + It("Bubbles up errors", func() { + errorMessage := "class not found" + ClusterServiceClasses.GetReturns(nil, errors.New(errorMessage)) + + _, err := client.GetClass("banana") + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).Should(ContainSubstring(errorMessage)) + Expect(ClusterServiceClasses.GetCallCount()).To(Equal(1)) + }) + }) + + Describe("List", func() { + It("Calls the generated v1beta1 List method", func() { + _, err := client.ListClasses() + + Expect(err).NotTo(HaveOccurred()) + Expect(ClusterServiceClasses.ListCallCount()).To(Equal(1)) + }) + It("Bubbles up errors", func() { + errorMessage := "foobar" + ClusterServiceClasses.ListReturns(nil, errors.New(errorMessage)) + + _, err := client.ListClasses() + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).Should(ContainSubstring(errorMessage)) + Expect(ClusterServiceClasses.ListCallCount()).To(Equal(1)) + }) + }) +}) diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterservicebroker_interface.go b/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterservicebroker_interface.go new file mode 100644 index 00000000000..25b9bf782b0 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterservicebroker_interface.go @@ -0,0 +1,642 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package fakes + +import ( + "sync" + + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + generated_v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" + "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/watch" +) + +type FakeClusterServiceBrokerInterface struct { + CreateStub func(*v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) + createMutex sync.RWMutex + createArgsForCall []struct { + arg1 *v1beta1.ClusterServiceBroker + } + createReturns struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + } + createReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + } + UpdateStub func(*v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) + updateMutex sync.RWMutex + updateArgsForCall []struct { + arg1 *v1beta1.ClusterServiceBroker + } + updateReturns struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + } + updateReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + } + UpdateStatusStub func(*v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) + updateStatusMutex sync.RWMutex + updateStatusArgsForCall []struct { + arg1 *v1beta1.ClusterServiceBroker + } + updateStatusReturns struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + } + updateStatusReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + } + DeleteStub func(name string, options *v1.DeleteOptions) error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + name string + options *v1.DeleteOptions + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + DeleteCollectionStub func(options *v1.DeleteOptions, listOptions v1.ListOptions) error + deleteCollectionMutex sync.RWMutex + deleteCollectionArgsForCall []struct { + options *v1.DeleteOptions + listOptions v1.ListOptions + } + deleteCollectionReturns struct { + result1 error + } + deleteCollectionReturnsOnCall map[int]struct { + result1 error + } + GetStub func(name string, options v1.GetOptions) (*v1beta1.ClusterServiceBroker, error) + getMutex sync.RWMutex + getArgsForCall []struct { + name string + options v1.GetOptions + } + getReturns struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + } + getReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + } + ListStub func(opts v1.ListOptions) (*v1beta1.ClusterServiceBrokerList, error) + listMutex sync.RWMutex + listArgsForCall []struct { + opts v1.ListOptions + } + listReturns struct { + result1 *v1beta1.ClusterServiceBrokerList + result2 error + } + listReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceBrokerList + result2 error + } + WatchStub func(opts v1.ListOptions) (watch.Interface, error) + watchMutex sync.RWMutex + watchArgsForCall []struct { + opts v1.ListOptions + } + watchReturns struct { + result1 watch.Interface + result2 error + } + watchReturnsOnCall map[int]struct { + result1 watch.Interface + result2 error + } + PatchStub func(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServiceBroker, err error) + patchMutex sync.RWMutex + patchArgsForCall []struct { + name string + pt types.PatchType + data []byte + subresources []string + } + patchReturns struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + } + patchReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeClusterServiceBrokerInterface) Create(arg1 *v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) { + fake.createMutex.Lock() + ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] + fake.createArgsForCall = append(fake.createArgsForCall, struct { + arg1 *v1beta1.ClusterServiceBroker + }{arg1}) + fake.recordInvocation("Create", []interface{}{arg1}) + fake.createMutex.Unlock() + if fake.CreateStub != nil { + return fake.CreateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.createReturns.result1, fake.createReturns.result2 +} + +func (fake *FakeClusterServiceBrokerInterface) CreateCallCount() int { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return len(fake.createArgsForCall) +} + +func (fake *FakeClusterServiceBrokerInterface) CreateArgsForCall(i int) *v1beta1.ClusterServiceBroker { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return fake.createArgsForCall[i].arg1 +} + +func (fake *FakeClusterServiceBrokerInterface) CreateReturns(result1 *v1beta1.ClusterServiceBroker, result2 error) { + fake.CreateStub = nil + fake.createReturns = struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) CreateReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBroker, result2 error) { + fake.CreateStub = nil + if fake.createReturnsOnCall == nil { + fake.createReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }) + } + fake.createReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) Update(arg1 *v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) { + fake.updateMutex.Lock() + ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] + fake.updateArgsForCall = append(fake.updateArgsForCall, struct { + arg1 *v1beta1.ClusterServiceBroker + }{arg1}) + fake.recordInvocation("Update", []interface{}{arg1}) + fake.updateMutex.Unlock() + if fake.UpdateStub != nil { + return fake.UpdateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.updateReturns.result1, fake.updateReturns.result2 +} + +func (fake *FakeClusterServiceBrokerInterface) UpdateCallCount() int { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + return len(fake.updateArgsForCall) +} + +func (fake *FakeClusterServiceBrokerInterface) UpdateArgsForCall(i int) *v1beta1.ClusterServiceBroker { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + return fake.updateArgsForCall[i].arg1 +} + +func (fake *FakeClusterServiceBrokerInterface) UpdateReturns(result1 *v1beta1.ClusterServiceBroker, result2 error) { + fake.UpdateStub = nil + fake.updateReturns = struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) UpdateReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBroker, result2 error) { + fake.UpdateStub = nil + if fake.updateReturnsOnCall == nil { + fake.updateReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }) + } + fake.updateReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) UpdateStatus(arg1 *v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) { + fake.updateStatusMutex.Lock() + ret, specificReturn := fake.updateStatusReturnsOnCall[len(fake.updateStatusArgsForCall)] + fake.updateStatusArgsForCall = append(fake.updateStatusArgsForCall, struct { + arg1 *v1beta1.ClusterServiceBroker + }{arg1}) + fake.recordInvocation("UpdateStatus", []interface{}{arg1}) + fake.updateStatusMutex.Unlock() + if fake.UpdateStatusStub != nil { + return fake.UpdateStatusStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.updateStatusReturns.result1, fake.updateStatusReturns.result2 +} + +func (fake *FakeClusterServiceBrokerInterface) UpdateStatusCallCount() int { + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + return len(fake.updateStatusArgsForCall) +} + +func (fake *FakeClusterServiceBrokerInterface) UpdateStatusArgsForCall(i int) *v1beta1.ClusterServiceBroker { + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + return fake.updateStatusArgsForCall[i].arg1 +} + +func (fake *FakeClusterServiceBrokerInterface) UpdateStatusReturns(result1 *v1beta1.ClusterServiceBroker, result2 error) { + fake.UpdateStatusStub = nil + fake.updateStatusReturns = struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) UpdateStatusReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBroker, result2 error) { + fake.UpdateStatusStub = nil + if fake.updateStatusReturnsOnCall == nil { + fake.updateStatusReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }) + } + fake.updateStatusReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) Delete(name string, options *v1.DeleteOptions) error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + name string + options *v1.DeleteOptions + }{name, options}) + fake.recordInvocation("Delete", []interface{}{name, options}) + fake.deleteMutex.Unlock() + if fake.DeleteStub != nil { + return fake.DeleteStub(name, options) + } + if specificReturn { + return ret.result1 + } + return fake.deleteReturns.result1 +} + +func (fake *FakeClusterServiceBrokerInterface) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeClusterServiceBrokerInterface) DeleteArgsForCall(i int) (string, *v1.DeleteOptions) { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return fake.deleteArgsForCall[i].name, fake.deleteArgsForCall[i].options +} + +func (fake *FakeClusterServiceBrokerInterface) DeleteReturns(result1 error) { + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServiceBrokerInterface) DeleteReturnsOnCall(i int, result1 error) { + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServiceBrokerInterface) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { + fake.deleteCollectionMutex.Lock() + ret, specificReturn := fake.deleteCollectionReturnsOnCall[len(fake.deleteCollectionArgsForCall)] + fake.deleteCollectionArgsForCall = append(fake.deleteCollectionArgsForCall, struct { + options *v1.DeleteOptions + listOptions v1.ListOptions + }{options, listOptions}) + fake.recordInvocation("DeleteCollection", []interface{}{options, listOptions}) + fake.deleteCollectionMutex.Unlock() + if fake.DeleteCollectionStub != nil { + return fake.DeleteCollectionStub(options, listOptions) + } + if specificReturn { + return ret.result1 + } + return fake.deleteCollectionReturns.result1 +} + +func (fake *FakeClusterServiceBrokerInterface) DeleteCollectionCallCount() int { + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + return len(fake.deleteCollectionArgsForCall) +} + +func (fake *FakeClusterServiceBrokerInterface) DeleteCollectionArgsForCall(i int) (*v1.DeleteOptions, v1.ListOptions) { + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + return fake.deleteCollectionArgsForCall[i].options, fake.deleteCollectionArgsForCall[i].listOptions +} + +func (fake *FakeClusterServiceBrokerInterface) DeleteCollectionReturns(result1 error) { + fake.DeleteCollectionStub = nil + fake.deleteCollectionReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServiceBrokerInterface) DeleteCollectionReturnsOnCall(i int, result1 error) { + fake.DeleteCollectionStub = nil + if fake.deleteCollectionReturnsOnCall == nil { + fake.deleteCollectionReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteCollectionReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServiceBrokerInterface) Get(name string, options v1.GetOptions) (*v1beta1.ClusterServiceBroker, error) { + fake.getMutex.Lock() + ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] + fake.getArgsForCall = append(fake.getArgsForCall, struct { + name string + options v1.GetOptions + }{name, options}) + fake.recordInvocation("Get", []interface{}{name, options}) + fake.getMutex.Unlock() + if fake.GetStub != nil { + return fake.GetStub(name, options) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getReturns.result1, fake.getReturns.result2 +} + +func (fake *FakeClusterServiceBrokerInterface) GetCallCount() int { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return len(fake.getArgsForCall) +} + +func (fake *FakeClusterServiceBrokerInterface) GetArgsForCall(i int) (string, v1.GetOptions) { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return fake.getArgsForCall[i].name, fake.getArgsForCall[i].options +} + +func (fake *FakeClusterServiceBrokerInterface) GetReturns(result1 *v1beta1.ClusterServiceBroker, result2 error) { + fake.GetStub = nil + fake.getReturns = struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) GetReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBroker, result2 error) { + fake.GetStub = nil + if fake.getReturnsOnCall == nil { + fake.getReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }) + } + fake.getReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) List(opts v1.ListOptions) (*v1beta1.ClusterServiceBrokerList, error) { + fake.listMutex.Lock() + ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] + fake.listArgsForCall = append(fake.listArgsForCall, struct { + opts v1.ListOptions + }{opts}) + fake.recordInvocation("List", []interface{}{opts}) + fake.listMutex.Unlock() + if fake.ListStub != nil { + return fake.ListStub(opts) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listReturns.result1, fake.listReturns.result2 +} + +func (fake *FakeClusterServiceBrokerInterface) ListCallCount() int { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return len(fake.listArgsForCall) +} + +func (fake *FakeClusterServiceBrokerInterface) ListArgsForCall(i int) v1.ListOptions { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return fake.listArgsForCall[i].opts +} + +func (fake *FakeClusterServiceBrokerInterface) ListReturns(result1 *v1beta1.ClusterServiceBrokerList, result2 error) { + fake.ListStub = nil + fake.listReturns = struct { + result1 *v1beta1.ClusterServiceBrokerList + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) ListReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBrokerList, result2 error) { + fake.ListStub = nil + if fake.listReturnsOnCall == nil { + fake.listReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceBrokerList + result2 error + }) + } + fake.listReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceBrokerList + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) Watch(opts v1.ListOptions) (watch.Interface, error) { + fake.watchMutex.Lock() + ret, specificReturn := fake.watchReturnsOnCall[len(fake.watchArgsForCall)] + fake.watchArgsForCall = append(fake.watchArgsForCall, struct { + opts v1.ListOptions + }{opts}) + fake.recordInvocation("Watch", []interface{}{opts}) + fake.watchMutex.Unlock() + if fake.WatchStub != nil { + return fake.WatchStub(opts) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.watchReturns.result1, fake.watchReturns.result2 +} + +func (fake *FakeClusterServiceBrokerInterface) WatchCallCount() int { + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + return len(fake.watchArgsForCall) +} + +func (fake *FakeClusterServiceBrokerInterface) WatchArgsForCall(i int) v1.ListOptions { + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + return fake.watchArgsForCall[i].opts +} + +func (fake *FakeClusterServiceBrokerInterface) WatchReturns(result1 watch.Interface, result2 error) { + fake.WatchStub = nil + fake.watchReturns = struct { + result1 watch.Interface + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) WatchReturnsOnCall(i int, result1 watch.Interface, result2 error) { + fake.WatchStub = nil + if fake.watchReturnsOnCall == nil { + fake.watchReturnsOnCall = make(map[int]struct { + result1 watch.Interface + result2 error + }) + } + fake.watchReturnsOnCall[i] = struct { + result1 watch.Interface + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServiceBroker, err error) { + var dataCopy []byte + if data != nil { + dataCopy = make([]byte, len(data)) + copy(dataCopy, data) + } + fake.patchMutex.Lock() + ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)] + fake.patchArgsForCall = append(fake.patchArgsForCall, struct { + name string + pt types.PatchType + data []byte + subresources []string + }{name, pt, dataCopy, subresources}) + fake.recordInvocation("Patch", []interface{}{name, pt, dataCopy, subresources}) + fake.patchMutex.Unlock() + if fake.PatchStub != nil { + return fake.PatchStub(name, pt, data, subresources...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.patchReturns.result1, fake.patchReturns.result2 +} + +func (fake *FakeClusterServiceBrokerInterface) PatchCallCount() int { + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + return len(fake.patchArgsForCall) +} + +func (fake *FakeClusterServiceBrokerInterface) PatchArgsForCall(i int) (string, types.PatchType, []byte, []string) { + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + return fake.patchArgsForCall[i].name, fake.patchArgsForCall[i].pt, fake.patchArgsForCall[i].data, fake.patchArgsForCall[i].subresources +} + +func (fake *FakeClusterServiceBrokerInterface) PatchReturns(result1 *v1beta1.ClusterServiceBroker, result2 error) { + fake.PatchStub = nil + fake.patchReturns = struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) PatchReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBroker, result2 error) { + fake.PatchStub = nil + if fake.patchReturnsOnCall == nil { + fake.patchReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }) + } + fake.patchReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceBroker + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceBrokerInterface) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeClusterServiceBrokerInterface) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ generated_v1beta1.ClusterServiceBrokerInterface = new(FakeClusterServiceBrokerInterface) diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceclass_interface.go b/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceclass_interface.go new file mode 100644 index 00000000000..608c065f25e --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceclass_interface.go @@ -0,0 +1,642 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package fakes + +import ( + "sync" + + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + generated_v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" + "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/watch" +) + +type FakeClusterServiceClassInterface struct { + CreateStub func(*v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) + createMutex sync.RWMutex + createArgsForCall []struct { + arg1 *v1beta1.ClusterServiceClass + } + createReturns struct { + result1 *v1beta1.ClusterServiceClass + result2 error + } + createReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceClass + result2 error + } + UpdateStub func(*v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) + updateMutex sync.RWMutex + updateArgsForCall []struct { + arg1 *v1beta1.ClusterServiceClass + } + updateReturns struct { + result1 *v1beta1.ClusterServiceClass + result2 error + } + updateReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceClass + result2 error + } + UpdateStatusStub func(*v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) + updateStatusMutex sync.RWMutex + updateStatusArgsForCall []struct { + arg1 *v1beta1.ClusterServiceClass + } + updateStatusReturns struct { + result1 *v1beta1.ClusterServiceClass + result2 error + } + updateStatusReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceClass + result2 error + } + DeleteStub func(name string, options *v1.DeleteOptions) error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + name string + options *v1.DeleteOptions + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + DeleteCollectionStub func(options *v1.DeleteOptions, listOptions v1.ListOptions) error + deleteCollectionMutex sync.RWMutex + deleteCollectionArgsForCall []struct { + options *v1.DeleteOptions + listOptions v1.ListOptions + } + deleteCollectionReturns struct { + result1 error + } + deleteCollectionReturnsOnCall map[int]struct { + result1 error + } + GetStub func(name string, options v1.GetOptions) (*v1beta1.ClusterServiceClass, error) + getMutex sync.RWMutex + getArgsForCall []struct { + name string + options v1.GetOptions + } + getReturns struct { + result1 *v1beta1.ClusterServiceClass + result2 error + } + getReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceClass + result2 error + } + ListStub func(opts v1.ListOptions) (*v1beta1.ClusterServiceClassList, error) + listMutex sync.RWMutex + listArgsForCall []struct { + opts v1.ListOptions + } + listReturns struct { + result1 *v1beta1.ClusterServiceClassList + result2 error + } + listReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceClassList + result2 error + } + WatchStub func(opts v1.ListOptions) (watch.Interface, error) + watchMutex sync.RWMutex + watchArgsForCall []struct { + opts v1.ListOptions + } + watchReturns struct { + result1 watch.Interface + result2 error + } + watchReturnsOnCall map[int]struct { + result1 watch.Interface + result2 error + } + PatchStub func(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServiceClass, err error) + patchMutex sync.RWMutex + patchArgsForCall []struct { + name string + pt types.PatchType + data []byte + subresources []string + } + patchReturns struct { + result1 *v1beta1.ClusterServiceClass + result2 error + } + patchReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServiceClass + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeClusterServiceClassInterface) Create(arg1 *v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) { + fake.createMutex.Lock() + ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] + fake.createArgsForCall = append(fake.createArgsForCall, struct { + arg1 *v1beta1.ClusterServiceClass + }{arg1}) + fake.recordInvocation("Create", []interface{}{arg1}) + fake.createMutex.Unlock() + if fake.CreateStub != nil { + return fake.CreateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.createReturns.result1, fake.createReturns.result2 +} + +func (fake *FakeClusterServiceClassInterface) CreateCallCount() int { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return len(fake.createArgsForCall) +} + +func (fake *FakeClusterServiceClassInterface) CreateArgsForCall(i int) *v1beta1.ClusterServiceClass { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return fake.createArgsForCall[i].arg1 +} + +func (fake *FakeClusterServiceClassInterface) CreateReturns(result1 *v1beta1.ClusterServiceClass, result2 error) { + fake.CreateStub = nil + fake.createReturns = struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) CreateReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClass, result2 error) { + fake.CreateStub = nil + if fake.createReturnsOnCall == nil { + fake.createReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }) + } + fake.createReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) Update(arg1 *v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) { + fake.updateMutex.Lock() + ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] + fake.updateArgsForCall = append(fake.updateArgsForCall, struct { + arg1 *v1beta1.ClusterServiceClass + }{arg1}) + fake.recordInvocation("Update", []interface{}{arg1}) + fake.updateMutex.Unlock() + if fake.UpdateStub != nil { + return fake.UpdateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.updateReturns.result1, fake.updateReturns.result2 +} + +func (fake *FakeClusterServiceClassInterface) UpdateCallCount() int { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + return len(fake.updateArgsForCall) +} + +func (fake *FakeClusterServiceClassInterface) UpdateArgsForCall(i int) *v1beta1.ClusterServiceClass { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + return fake.updateArgsForCall[i].arg1 +} + +func (fake *FakeClusterServiceClassInterface) UpdateReturns(result1 *v1beta1.ClusterServiceClass, result2 error) { + fake.UpdateStub = nil + fake.updateReturns = struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) UpdateReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClass, result2 error) { + fake.UpdateStub = nil + if fake.updateReturnsOnCall == nil { + fake.updateReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }) + } + fake.updateReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) UpdateStatus(arg1 *v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) { + fake.updateStatusMutex.Lock() + ret, specificReturn := fake.updateStatusReturnsOnCall[len(fake.updateStatusArgsForCall)] + fake.updateStatusArgsForCall = append(fake.updateStatusArgsForCall, struct { + arg1 *v1beta1.ClusterServiceClass + }{arg1}) + fake.recordInvocation("UpdateStatus", []interface{}{arg1}) + fake.updateStatusMutex.Unlock() + if fake.UpdateStatusStub != nil { + return fake.UpdateStatusStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.updateStatusReturns.result1, fake.updateStatusReturns.result2 +} + +func (fake *FakeClusterServiceClassInterface) UpdateStatusCallCount() int { + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + return len(fake.updateStatusArgsForCall) +} + +func (fake *FakeClusterServiceClassInterface) UpdateStatusArgsForCall(i int) *v1beta1.ClusterServiceClass { + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + return fake.updateStatusArgsForCall[i].arg1 +} + +func (fake *FakeClusterServiceClassInterface) UpdateStatusReturns(result1 *v1beta1.ClusterServiceClass, result2 error) { + fake.UpdateStatusStub = nil + fake.updateStatusReturns = struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) UpdateStatusReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClass, result2 error) { + fake.UpdateStatusStub = nil + if fake.updateStatusReturnsOnCall == nil { + fake.updateStatusReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }) + } + fake.updateStatusReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) Delete(name string, options *v1.DeleteOptions) error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + name string + options *v1.DeleteOptions + }{name, options}) + fake.recordInvocation("Delete", []interface{}{name, options}) + fake.deleteMutex.Unlock() + if fake.DeleteStub != nil { + return fake.DeleteStub(name, options) + } + if specificReturn { + return ret.result1 + } + return fake.deleteReturns.result1 +} + +func (fake *FakeClusterServiceClassInterface) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeClusterServiceClassInterface) DeleteArgsForCall(i int) (string, *v1.DeleteOptions) { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return fake.deleteArgsForCall[i].name, fake.deleteArgsForCall[i].options +} + +func (fake *FakeClusterServiceClassInterface) DeleteReturns(result1 error) { + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServiceClassInterface) DeleteReturnsOnCall(i int, result1 error) { + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServiceClassInterface) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { + fake.deleteCollectionMutex.Lock() + ret, specificReturn := fake.deleteCollectionReturnsOnCall[len(fake.deleteCollectionArgsForCall)] + fake.deleteCollectionArgsForCall = append(fake.deleteCollectionArgsForCall, struct { + options *v1.DeleteOptions + listOptions v1.ListOptions + }{options, listOptions}) + fake.recordInvocation("DeleteCollection", []interface{}{options, listOptions}) + fake.deleteCollectionMutex.Unlock() + if fake.DeleteCollectionStub != nil { + return fake.DeleteCollectionStub(options, listOptions) + } + if specificReturn { + return ret.result1 + } + return fake.deleteCollectionReturns.result1 +} + +func (fake *FakeClusterServiceClassInterface) DeleteCollectionCallCount() int { + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + return len(fake.deleteCollectionArgsForCall) +} + +func (fake *FakeClusterServiceClassInterface) DeleteCollectionArgsForCall(i int) (*v1.DeleteOptions, v1.ListOptions) { + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + return fake.deleteCollectionArgsForCall[i].options, fake.deleteCollectionArgsForCall[i].listOptions +} + +func (fake *FakeClusterServiceClassInterface) DeleteCollectionReturns(result1 error) { + fake.DeleteCollectionStub = nil + fake.deleteCollectionReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServiceClassInterface) DeleteCollectionReturnsOnCall(i int, result1 error) { + fake.DeleteCollectionStub = nil + if fake.deleteCollectionReturnsOnCall == nil { + fake.deleteCollectionReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteCollectionReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServiceClassInterface) Get(name string, options v1.GetOptions) (*v1beta1.ClusterServiceClass, error) { + fake.getMutex.Lock() + ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] + fake.getArgsForCall = append(fake.getArgsForCall, struct { + name string + options v1.GetOptions + }{name, options}) + fake.recordInvocation("Get", []interface{}{name, options}) + fake.getMutex.Unlock() + if fake.GetStub != nil { + return fake.GetStub(name, options) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getReturns.result1, fake.getReturns.result2 +} + +func (fake *FakeClusterServiceClassInterface) GetCallCount() int { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return len(fake.getArgsForCall) +} + +func (fake *FakeClusterServiceClassInterface) GetArgsForCall(i int) (string, v1.GetOptions) { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return fake.getArgsForCall[i].name, fake.getArgsForCall[i].options +} + +func (fake *FakeClusterServiceClassInterface) GetReturns(result1 *v1beta1.ClusterServiceClass, result2 error) { + fake.GetStub = nil + fake.getReturns = struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) GetReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClass, result2 error) { + fake.GetStub = nil + if fake.getReturnsOnCall == nil { + fake.getReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }) + } + fake.getReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) List(opts v1.ListOptions) (*v1beta1.ClusterServiceClassList, error) { + fake.listMutex.Lock() + ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] + fake.listArgsForCall = append(fake.listArgsForCall, struct { + opts v1.ListOptions + }{opts}) + fake.recordInvocation("List", []interface{}{opts}) + fake.listMutex.Unlock() + if fake.ListStub != nil { + return fake.ListStub(opts) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listReturns.result1, fake.listReturns.result2 +} + +func (fake *FakeClusterServiceClassInterface) ListCallCount() int { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return len(fake.listArgsForCall) +} + +func (fake *FakeClusterServiceClassInterface) ListArgsForCall(i int) v1.ListOptions { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return fake.listArgsForCall[i].opts +} + +func (fake *FakeClusterServiceClassInterface) ListReturns(result1 *v1beta1.ClusterServiceClassList, result2 error) { + fake.ListStub = nil + fake.listReturns = struct { + result1 *v1beta1.ClusterServiceClassList + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) ListReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClassList, result2 error) { + fake.ListStub = nil + if fake.listReturnsOnCall == nil { + fake.listReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceClassList + result2 error + }) + } + fake.listReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceClassList + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) Watch(opts v1.ListOptions) (watch.Interface, error) { + fake.watchMutex.Lock() + ret, specificReturn := fake.watchReturnsOnCall[len(fake.watchArgsForCall)] + fake.watchArgsForCall = append(fake.watchArgsForCall, struct { + opts v1.ListOptions + }{opts}) + fake.recordInvocation("Watch", []interface{}{opts}) + fake.watchMutex.Unlock() + if fake.WatchStub != nil { + return fake.WatchStub(opts) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.watchReturns.result1, fake.watchReturns.result2 +} + +func (fake *FakeClusterServiceClassInterface) WatchCallCount() int { + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + return len(fake.watchArgsForCall) +} + +func (fake *FakeClusterServiceClassInterface) WatchArgsForCall(i int) v1.ListOptions { + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + return fake.watchArgsForCall[i].opts +} + +func (fake *FakeClusterServiceClassInterface) WatchReturns(result1 watch.Interface, result2 error) { + fake.WatchStub = nil + fake.watchReturns = struct { + result1 watch.Interface + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) WatchReturnsOnCall(i int, result1 watch.Interface, result2 error) { + fake.WatchStub = nil + if fake.watchReturnsOnCall == nil { + fake.watchReturnsOnCall = make(map[int]struct { + result1 watch.Interface + result2 error + }) + } + fake.watchReturnsOnCall[i] = struct { + result1 watch.Interface + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServiceClass, err error) { + var dataCopy []byte + if data != nil { + dataCopy = make([]byte, len(data)) + copy(dataCopy, data) + } + fake.patchMutex.Lock() + ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)] + fake.patchArgsForCall = append(fake.patchArgsForCall, struct { + name string + pt types.PatchType + data []byte + subresources []string + }{name, pt, dataCopy, subresources}) + fake.recordInvocation("Patch", []interface{}{name, pt, dataCopy, subresources}) + fake.patchMutex.Unlock() + if fake.PatchStub != nil { + return fake.PatchStub(name, pt, data, subresources...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.patchReturns.result1, fake.patchReturns.result2 +} + +func (fake *FakeClusterServiceClassInterface) PatchCallCount() int { + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + return len(fake.patchArgsForCall) +} + +func (fake *FakeClusterServiceClassInterface) PatchArgsForCall(i int) (string, types.PatchType, []byte, []string) { + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + return fake.patchArgsForCall[i].name, fake.patchArgsForCall[i].pt, fake.patchArgsForCall[i].data, fake.patchArgsForCall[i].subresources +} + +func (fake *FakeClusterServiceClassInterface) PatchReturns(result1 *v1beta1.ClusterServiceClass, result2 error) { + fake.PatchStub = nil + fake.patchReturns = struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) PatchReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClass, result2 error) { + fake.PatchStub = nil + if fake.patchReturnsOnCall == nil { + fake.patchReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }) + } + fake.patchReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServiceClass + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServiceClassInterface) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeClusterServiceClassInterface) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ generated_v1beta1.ClusterServiceClassInterface = new(FakeClusterServiceClassInterface) diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceplan_interface.go b/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceplan_interface.go new file mode 100644 index 00000000000..8bd999be7a6 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceplan_interface.go @@ -0,0 +1,642 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package fakes + +import ( + "sync" + + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + generated_v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" + "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/watch" +) + +type FakeClusterServicePlanInterface struct { + CreateStub func(*v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) + createMutex sync.RWMutex + createArgsForCall []struct { + arg1 *v1beta1.ClusterServicePlan + } + createReturns struct { + result1 *v1beta1.ClusterServicePlan + result2 error + } + createReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServicePlan + result2 error + } + UpdateStub func(*v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) + updateMutex sync.RWMutex + updateArgsForCall []struct { + arg1 *v1beta1.ClusterServicePlan + } + updateReturns struct { + result1 *v1beta1.ClusterServicePlan + result2 error + } + updateReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServicePlan + result2 error + } + UpdateStatusStub func(*v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) + updateStatusMutex sync.RWMutex + updateStatusArgsForCall []struct { + arg1 *v1beta1.ClusterServicePlan + } + updateStatusReturns struct { + result1 *v1beta1.ClusterServicePlan + result2 error + } + updateStatusReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServicePlan + result2 error + } + DeleteStub func(name string, options *v1.DeleteOptions) error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + name string + options *v1.DeleteOptions + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + DeleteCollectionStub func(options *v1.DeleteOptions, listOptions v1.ListOptions) error + deleteCollectionMutex sync.RWMutex + deleteCollectionArgsForCall []struct { + options *v1.DeleteOptions + listOptions v1.ListOptions + } + deleteCollectionReturns struct { + result1 error + } + deleteCollectionReturnsOnCall map[int]struct { + result1 error + } + GetStub func(name string, options v1.GetOptions) (*v1beta1.ClusterServicePlan, error) + getMutex sync.RWMutex + getArgsForCall []struct { + name string + options v1.GetOptions + } + getReturns struct { + result1 *v1beta1.ClusterServicePlan + result2 error + } + getReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServicePlan + result2 error + } + ListStub func(opts v1.ListOptions) (*v1beta1.ClusterServicePlanList, error) + listMutex sync.RWMutex + listArgsForCall []struct { + opts v1.ListOptions + } + listReturns struct { + result1 *v1beta1.ClusterServicePlanList + result2 error + } + listReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServicePlanList + result2 error + } + WatchStub func(opts v1.ListOptions) (watch.Interface, error) + watchMutex sync.RWMutex + watchArgsForCall []struct { + opts v1.ListOptions + } + watchReturns struct { + result1 watch.Interface + result2 error + } + watchReturnsOnCall map[int]struct { + result1 watch.Interface + result2 error + } + PatchStub func(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServicePlan, err error) + patchMutex sync.RWMutex + patchArgsForCall []struct { + name string + pt types.PatchType + data []byte + subresources []string + } + patchReturns struct { + result1 *v1beta1.ClusterServicePlan + result2 error + } + patchReturnsOnCall map[int]struct { + result1 *v1beta1.ClusterServicePlan + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeClusterServicePlanInterface) Create(arg1 *v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) { + fake.createMutex.Lock() + ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] + fake.createArgsForCall = append(fake.createArgsForCall, struct { + arg1 *v1beta1.ClusterServicePlan + }{arg1}) + fake.recordInvocation("Create", []interface{}{arg1}) + fake.createMutex.Unlock() + if fake.CreateStub != nil { + return fake.CreateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.createReturns.result1, fake.createReturns.result2 +} + +func (fake *FakeClusterServicePlanInterface) CreateCallCount() int { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return len(fake.createArgsForCall) +} + +func (fake *FakeClusterServicePlanInterface) CreateArgsForCall(i int) *v1beta1.ClusterServicePlan { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return fake.createArgsForCall[i].arg1 +} + +func (fake *FakeClusterServicePlanInterface) CreateReturns(result1 *v1beta1.ClusterServicePlan, result2 error) { + fake.CreateStub = nil + fake.createReturns = struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) CreateReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlan, result2 error) { + fake.CreateStub = nil + if fake.createReturnsOnCall == nil { + fake.createReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }) + } + fake.createReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) Update(arg1 *v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) { + fake.updateMutex.Lock() + ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] + fake.updateArgsForCall = append(fake.updateArgsForCall, struct { + arg1 *v1beta1.ClusterServicePlan + }{arg1}) + fake.recordInvocation("Update", []interface{}{arg1}) + fake.updateMutex.Unlock() + if fake.UpdateStub != nil { + return fake.UpdateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.updateReturns.result1, fake.updateReturns.result2 +} + +func (fake *FakeClusterServicePlanInterface) UpdateCallCount() int { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + return len(fake.updateArgsForCall) +} + +func (fake *FakeClusterServicePlanInterface) UpdateArgsForCall(i int) *v1beta1.ClusterServicePlan { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + return fake.updateArgsForCall[i].arg1 +} + +func (fake *FakeClusterServicePlanInterface) UpdateReturns(result1 *v1beta1.ClusterServicePlan, result2 error) { + fake.UpdateStub = nil + fake.updateReturns = struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) UpdateReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlan, result2 error) { + fake.UpdateStub = nil + if fake.updateReturnsOnCall == nil { + fake.updateReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }) + } + fake.updateReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) UpdateStatus(arg1 *v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) { + fake.updateStatusMutex.Lock() + ret, specificReturn := fake.updateStatusReturnsOnCall[len(fake.updateStatusArgsForCall)] + fake.updateStatusArgsForCall = append(fake.updateStatusArgsForCall, struct { + arg1 *v1beta1.ClusterServicePlan + }{arg1}) + fake.recordInvocation("UpdateStatus", []interface{}{arg1}) + fake.updateStatusMutex.Unlock() + if fake.UpdateStatusStub != nil { + return fake.UpdateStatusStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.updateStatusReturns.result1, fake.updateStatusReturns.result2 +} + +func (fake *FakeClusterServicePlanInterface) UpdateStatusCallCount() int { + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + return len(fake.updateStatusArgsForCall) +} + +func (fake *FakeClusterServicePlanInterface) UpdateStatusArgsForCall(i int) *v1beta1.ClusterServicePlan { + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + return fake.updateStatusArgsForCall[i].arg1 +} + +func (fake *FakeClusterServicePlanInterface) UpdateStatusReturns(result1 *v1beta1.ClusterServicePlan, result2 error) { + fake.UpdateStatusStub = nil + fake.updateStatusReturns = struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) UpdateStatusReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlan, result2 error) { + fake.UpdateStatusStub = nil + if fake.updateStatusReturnsOnCall == nil { + fake.updateStatusReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }) + } + fake.updateStatusReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) Delete(name string, options *v1.DeleteOptions) error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + name string + options *v1.DeleteOptions + }{name, options}) + fake.recordInvocation("Delete", []interface{}{name, options}) + fake.deleteMutex.Unlock() + if fake.DeleteStub != nil { + return fake.DeleteStub(name, options) + } + if specificReturn { + return ret.result1 + } + return fake.deleteReturns.result1 +} + +func (fake *FakeClusterServicePlanInterface) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeClusterServicePlanInterface) DeleteArgsForCall(i int) (string, *v1.DeleteOptions) { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return fake.deleteArgsForCall[i].name, fake.deleteArgsForCall[i].options +} + +func (fake *FakeClusterServicePlanInterface) DeleteReturns(result1 error) { + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServicePlanInterface) DeleteReturnsOnCall(i int, result1 error) { + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServicePlanInterface) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { + fake.deleteCollectionMutex.Lock() + ret, specificReturn := fake.deleteCollectionReturnsOnCall[len(fake.deleteCollectionArgsForCall)] + fake.deleteCollectionArgsForCall = append(fake.deleteCollectionArgsForCall, struct { + options *v1.DeleteOptions + listOptions v1.ListOptions + }{options, listOptions}) + fake.recordInvocation("DeleteCollection", []interface{}{options, listOptions}) + fake.deleteCollectionMutex.Unlock() + if fake.DeleteCollectionStub != nil { + return fake.DeleteCollectionStub(options, listOptions) + } + if specificReturn { + return ret.result1 + } + return fake.deleteCollectionReturns.result1 +} + +func (fake *FakeClusterServicePlanInterface) DeleteCollectionCallCount() int { + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + return len(fake.deleteCollectionArgsForCall) +} + +func (fake *FakeClusterServicePlanInterface) DeleteCollectionArgsForCall(i int) (*v1.DeleteOptions, v1.ListOptions) { + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + return fake.deleteCollectionArgsForCall[i].options, fake.deleteCollectionArgsForCall[i].listOptions +} + +func (fake *FakeClusterServicePlanInterface) DeleteCollectionReturns(result1 error) { + fake.DeleteCollectionStub = nil + fake.deleteCollectionReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServicePlanInterface) DeleteCollectionReturnsOnCall(i int, result1 error) { + fake.DeleteCollectionStub = nil + if fake.deleteCollectionReturnsOnCall == nil { + fake.deleteCollectionReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteCollectionReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeClusterServicePlanInterface) Get(name string, options v1.GetOptions) (*v1beta1.ClusterServicePlan, error) { + fake.getMutex.Lock() + ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] + fake.getArgsForCall = append(fake.getArgsForCall, struct { + name string + options v1.GetOptions + }{name, options}) + fake.recordInvocation("Get", []interface{}{name, options}) + fake.getMutex.Unlock() + if fake.GetStub != nil { + return fake.GetStub(name, options) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getReturns.result1, fake.getReturns.result2 +} + +func (fake *FakeClusterServicePlanInterface) GetCallCount() int { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return len(fake.getArgsForCall) +} + +func (fake *FakeClusterServicePlanInterface) GetArgsForCall(i int) (string, v1.GetOptions) { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return fake.getArgsForCall[i].name, fake.getArgsForCall[i].options +} + +func (fake *FakeClusterServicePlanInterface) GetReturns(result1 *v1beta1.ClusterServicePlan, result2 error) { + fake.GetStub = nil + fake.getReturns = struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) GetReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlan, result2 error) { + fake.GetStub = nil + if fake.getReturnsOnCall == nil { + fake.getReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }) + } + fake.getReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) List(opts v1.ListOptions) (*v1beta1.ClusterServicePlanList, error) { + fake.listMutex.Lock() + ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] + fake.listArgsForCall = append(fake.listArgsForCall, struct { + opts v1.ListOptions + }{opts}) + fake.recordInvocation("List", []interface{}{opts}) + fake.listMutex.Unlock() + if fake.ListStub != nil { + return fake.ListStub(opts) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listReturns.result1, fake.listReturns.result2 +} + +func (fake *FakeClusterServicePlanInterface) ListCallCount() int { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return len(fake.listArgsForCall) +} + +func (fake *FakeClusterServicePlanInterface) ListArgsForCall(i int) v1.ListOptions { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return fake.listArgsForCall[i].opts +} + +func (fake *FakeClusterServicePlanInterface) ListReturns(result1 *v1beta1.ClusterServicePlanList, result2 error) { + fake.ListStub = nil + fake.listReturns = struct { + result1 *v1beta1.ClusterServicePlanList + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) ListReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlanList, result2 error) { + fake.ListStub = nil + if fake.listReturnsOnCall == nil { + fake.listReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServicePlanList + result2 error + }) + } + fake.listReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServicePlanList + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) Watch(opts v1.ListOptions) (watch.Interface, error) { + fake.watchMutex.Lock() + ret, specificReturn := fake.watchReturnsOnCall[len(fake.watchArgsForCall)] + fake.watchArgsForCall = append(fake.watchArgsForCall, struct { + opts v1.ListOptions + }{opts}) + fake.recordInvocation("Watch", []interface{}{opts}) + fake.watchMutex.Unlock() + if fake.WatchStub != nil { + return fake.WatchStub(opts) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.watchReturns.result1, fake.watchReturns.result2 +} + +func (fake *FakeClusterServicePlanInterface) WatchCallCount() int { + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + return len(fake.watchArgsForCall) +} + +func (fake *FakeClusterServicePlanInterface) WatchArgsForCall(i int) v1.ListOptions { + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + return fake.watchArgsForCall[i].opts +} + +func (fake *FakeClusterServicePlanInterface) WatchReturns(result1 watch.Interface, result2 error) { + fake.WatchStub = nil + fake.watchReturns = struct { + result1 watch.Interface + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) WatchReturnsOnCall(i int, result1 watch.Interface, result2 error) { + fake.WatchStub = nil + if fake.watchReturnsOnCall == nil { + fake.watchReturnsOnCall = make(map[int]struct { + result1 watch.Interface + result2 error + }) + } + fake.watchReturnsOnCall[i] = struct { + result1 watch.Interface + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServicePlan, err error) { + var dataCopy []byte + if data != nil { + dataCopy = make([]byte, len(data)) + copy(dataCopy, data) + } + fake.patchMutex.Lock() + ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)] + fake.patchArgsForCall = append(fake.patchArgsForCall, struct { + name string + pt types.PatchType + data []byte + subresources []string + }{name, pt, dataCopy, subresources}) + fake.recordInvocation("Patch", []interface{}{name, pt, dataCopy, subresources}) + fake.patchMutex.Unlock() + if fake.PatchStub != nil { + return fake.PatchStub(name, pt, data, subresources...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.patchReturns.result1, fake.patchReturns.result2 +} + +func (fake *FakeClusterServicePlanInterface) PatchCallCount() int { + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + return len(fake.patchArgsForCall) +} + +func (fake *FakeClusterServicePlanInterface) PatchArgsForCall(i int) (string, types.PatchType, []byte, []string) { + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + return fake.patchArgsForCall[i].name, fake.patchArgsForCall[i].pt, fake.patchArgsForCall[i].data, fake.patchArgsForCall[i].subresources +} + +func (fake *FakeClusterServicePlanInterface) PatchReturns(result1 *v1beta1.ClusterServicePlan, result2 error) { + fake.PatchStub = nil + fake.patchReturns = struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) PatchReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlan, result2 error) { + fake.PatchStub = nil + if fake.patchReturnsOnCall == nil { + fake.patchReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }) + } + fake.patchReturnsOnCall[i] = struct { + result1 *v1beta1.ClusterServicePlan + result2 error + }{result1, result2} +} + +func (fake *FakeClusterServicePlanInterface) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeClusterServicePlanInterface) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ generated_v1beta1.ClusterServicePlanInterface = new(FakeClusterServicePlanInterface) diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_interface.go b/plugin/pkg/kubectl/plugin_client/fakes/fake_interface.go new file mode 100644 index 00000000000..67ae0469cf9 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/fakes/fake_interface.go @@ -0,0 +1,192 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package fakes + +import ( + "sync" + + "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" + servicecatalogv1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" + "k8s.io/client-go/discovery" +) + +type FakeInterface struct { + DiscoveryStub func() discovery.DiscoveryInterface + discoveryMutex sync.RWMutex + discoveryArgsForCall []struct{} + discoveryReturns struct { + result1 discovery.DiscoveryInterface + } + discoveryReturnsOnCall map[int]struct { + result1 discovery.DiscoveryInterface + } + ServicecatalogV1beta1Stub func() servicecatalogv1beta1.ServicecatalogV1beta1Interface + servicecatalogV1beta1Mutex sync.RWMutex + servicecatalogV1beta1ArgsForCall []struct{} + servicecatalogV1beta1Returns struct { + result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface + } + servicecatalogV1beta1ReturnsOnCall map[int]struct { + result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface + } + ServicecatalogStub func() servicecatalogv1beta1.ServicecatalogV1beta1Interface + servicecatalogMutex sync.RWMutex + servicecatalogArgsForCall []struct{} + servicecatalogReturns struct { + result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface + } + servicecatalogReturnsOnCall map[int]struct { + result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeInterface) Discovery() discovery.DiscoveryInterface { + fake.discoveryMutex.Lock() + ret, specificReturn := fake.discoveryReturnsOnCall[len(fake.discoveryArgsForCall)] + fake.discoveryArgsForCall = append(fake.discoveryArgsForCall, struct{}{}) + fake.recordInvocation("Discovery", []interface{}{}) + fake.discoveryMutex.Unlock() + if fake.DiscoveryStub != nil { + return fake.DiscoveryStub() + } + if specificReturn { + return ret.result1 + } + return fake.discoveryReturns.result1 +} + +func (fake *FakeInterface) DiscoveryCallCount() int { + fake.discoveryMutex.RLock() + defer fake.discoveryMutex.RUnlock() + return len(fake.discoveryArgsForCall) +} + +func (fake *FakeInterface) DiscoveryReturns(result1 discovery.DiscoveryInterface) { + fake.DiscoveryStub = nil + fake.discoveryReturns = struct { + result1 discovery.DiscoveryInterface + }{result1} +} + +func (fake *FakeInterface) DiscoveryReturnsOnCall(i int, result1 discovery.DiscoveryInterface) { + fake.DiscoveryStub = nil + if fake.discoveryReturnsOnCall == nil { + fake.discoveryReturnsOnCall = make(map[int]struct { + result1 discovery.DiscoveryInterface + }) + } + fake.discoveryReturnsOnCall[i] = struct { + result1 discovery.DiscoveryInterface + }{result1} +} + +func (fake *FakeInterface) ServicecatalogV1beta1() servicecatalogv1beta1.ServicecatalogV1beta1Interface { + fake.servicecatalogV1beta1Mutex.Lock() + ret, specificReturn := fake.servicecatalogV1beta1ReturnsOnCall[len(fake.servicecatalogV1beta1ArgsForCall)] + fake.servicecatalogV1beta1ArgsForCall = append(fake.servicecatalogV1beta1ArgsForCall, struct{}{}) + fake.recordInvocation("ServicecatalogV1beta1", []interface{}{}) + fake.servicecatalogV1beta1Mutex.Unlock() + if fake.ServicecatalogV1beta1Stub != nil { + return fake.ServicecatalogV1beta1Stub() + } + if specificReturn { + return ret.result1 + } + return fake.servicecatalogV1beta1Returns.result1 +} + +func (fake *FakeInterface) ServicecatalogV1beta1CallCount() int { + fake.servicecatalogV1beta1Mutex.RLock() + defer fake.servicecatalogV1beta1Mutex.RUnlock() + return len(fake.servicecatalogV1beta1ArgsForCall) +} + +func (fake *FakeInterface) ServicecatalogV1beta1Returns(result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface) { + fake.ServicecatalogV1beta1Stub = nil + fake.servicecatalogV1beta1Returns = struct { + result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface + }{result1} +} + +func (fake *FakeInterface) ServicecatalogV1beta1ReturnsOnCall(i int, result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface) { + fake.ServicecatalogV1beta1Stub = nil + if fake.servicecatalogV1beta1ReturnsOnCall == nil { + fake.servicecatalogV1beta1ReturnsOnCall = make(map[int]struct { + result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface + }) + } + fake.servicecatalogV1beta1ReturnsOnCall[i] = struct { + result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface + }{result1} +} + +func (fake *FakeInterface) Servicecatalog() servicecatalogv1beta1.ServicecatalogV1beta1Interface { + fake.servicecatalogMutex.Lock() + ret, specificReturn := fake.servicecatalogReturnsOnCall[len(fake.servicecatalogArgsForCall)] + fake.servicecatalogArgsForCall = append(fake.servicecatalogArgsForCall, struct{}{}) + fake.recordInvocation("Servicecatalog", []interface{}{}) + fake.servicecatalogMutex.Unlock() + if fake.ServicecatalogStub != nil { + return fake.ServicecatalogStub() + } + if specificReturn { + return ret.result1 + } + return fake.servicecatalogReturns.result1 +} + +func (fake *FakeInterface) ServicecatalogCallCount() int { + fake.servicecatalogMutex.RLock() + defer fake.servicecatalogMutex.RUnlock() + return len(fake.servicecatalogArgsForCall) +} + +func (fake *FakeInterface) ServicecatalogReturns(result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface) { + fake.ServicecatalogStub = nil + fake.servicecatalogReturns = struct { + result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface + }{result1} +} + +func (fake *FakeInterface) ServicecatalogReturnsOnCall(i int, result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface) { + fake.ServicecatalogStub = nil + if fake.servicecatalogReturnsOnCall == nil { + fake.servicecatalogReturnsOnCall = make(map[int]struct { + result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface + }) + } + fake.servicecatalogReturnsOnCall[i] = struct { + result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface + }{result1} +} + +func (fake *FakeInterface) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.discoveryMutex.RLock() + defer fake.discoveryMutex.RUnlock() + fake.servicecatalogV1beta1Mutex.RLock() + defer fake.servicecatalogV1beta1Mutex.RUnlock() + fake.servicecatalogMutex.RLock() + defer fake.servicecatalogMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeInterface) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ clientset.Interface = new(FakeInterface) diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_servicebinding_interface.go b/plugin/pkg/kubectl/plugin_client/fakes/fake_servicebinding_interface.go new file mode 100644 index 00000000000..d0e41987177 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/fakes/fake_servicebinding_interface.go @@ -0,0 +1,642 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package fakes + +import ( + "sync" + + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + generated_v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" + "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/watch" +) + +type FakeServiceBindingInterface struct { + CreateStub func(*v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) + createMutex sync.RWMutex + createArgsForCall []struct { + arg1 *v1beta1.ServiceBinding + } + createReturns struct { + result1 *v1beta1.ServiceBinding + result2 error + } + createReturnsOnCall map[int]struct { + result1 *v1beta1.ServiceBinding + result2 error + } + UpdateStub func(*v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) + updateMutex sync.RWMutex + updateArgsForCall []struct { + arg1 *v1beta1.ServiceBinding + } + updateReturns struct { + result1 *v1beta1.ServiceBinding + result2 error + } + updateReturnsOnCall map[int]struct { + result1 *v1beta1.ServiceBinding + result2 error + } + UpdateStatusStub func(*v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) + updateStatusMutex sync.RWMutex + updateStatusArgsForCall []struct { + arg1 *v1beta1.ServiceBinding + } + updateStatusReturns struct { + result1 *v1beta1.ServiceBinding + result2 error + } + updateStatusReturnsOnCall map[int]struct { + result1 *v1beta1.ServiceBinding + result2 error + } + DeleteStub func(name string, options *v1.DeleteOptions) error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + name string + options *v1.DeleteOptions + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + DeleteCollectionStub func(options *v1.DeleteOptions, listOptions v1.ListOptions) error + deleteCollectionMutex sync.RWMutex + deleteCollectionArgsForCall []struct { + options *v1.DeleteOptions + listOptions v1.ListOptions + } + deleteCollectionReturns struct { + result1 error + } + deleteCollectionReturnsOnCall map[int]struct { + result1 error + } + GetStub func(name string, options v1.GetOptions) (*v1beta1.ServiceBinding, error) + getMutex sync.RWMutex + getArgsForCall []struct { + name string + options v1.GetOptions + } + getReturns struct { + result1 *v1beta1.ServiceBinding + result2 error + } + getReturnsOnCall map[int]struct { + result1 *v1beta1.ServiceBinding + result2 error + } + ListStub func(opts v1.ListOptions) (*v1beta1.ServiceBindingList, error) + listMutex sync.RWMutex + listArgsForCall []struct { + opts v1.ListOptions + } + listReturns struct { + result1 *v1beta1.ServiceBindingList + result2 error + } + listReturnsOnCall map[int]struct { + result1 *v1beta1.ServiceBindingList + result2 error + } + WatchStub func(opts v1.ListOptions) (watch.Interface, error) + watchMutex sync.RWMutex + watchArgsForCall []struct { + opts v1.ListOptions + } + watchReturns struct { + result1 watch.Interface + result2 error + } + watchReturnsOnCall map[int]struct { + result1 watch.Interface + result2 error + } + PatchStub func(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ServiceBinding, err error) + patchMutex sync.RWMutex + patchArgsForCall []struct { + name string + pt types.PatchType + data []byte + subresources []string + } + patchReturns struct { + result1 *v1beta1.ServiceBinding + result2 error + } + patchReturnsOnCall map[int]struct { + result1 *v1beta1.ServiceBinding + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeServiceBindingInterface) Create(arg1 *v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) { + fake.createMutex.Lock() + ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] + fake.createArgsForCall = append(fake.createArgsForCall, struct { + arg1 *v1beta1.ServiceBinding + }{arg1}) + fake.recordInvocation("Create", []interface{}{arg1}) + fake.createMutex.Unlock() + if fake.CreateStub != nil { + return fake.CreateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.createReturns.result1, fake.createReturns.result2 +} + +func (fake *FakeServiceBindingInterface) CreateCallCount() int { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return len(fake.createArgsForCall) +} + +func (fake *FakeServiceBindingInterface) CreateArgsForCall(i int) *v1beta1.ServiceBinding { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return fake.createArgsForCall[i].arg1 +} + +func (fake *FakeServiceBindingInterface) CreateReturns(result1 *v1beta1.ServiceBinding, result2 error) { + fake.CreateStub = nil + fake.createReturns = struct { + result1 *v1beta1.ServiceBinding + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) CreateReturnsOnCall(i int, result1 *v1beta1.ServiceBinding, result2 error) { + fake.CreateStub = nil + if fake.createReturnsOnCall == nil { + fake.createReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ServiceBinding + result2 error + }) + } + fake.createReturnsOnCall[i] = struct { + result1 *v1beta1.ServiceBinding + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) Update(arg1 *v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) { + fake.updateMutex.Lock() + ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] + fake.updateArgsForCall = append(fake.updateArgsForCall, struct { + arg1 *v1beta1.ServiceBinding + }{arg1}) + fake.recordInvocation("Update", []interface{}{arg1}) + fake.updateMutex.Unlock() + if fake.UpdateStub != nil { + return fake.UpdateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.updateReturns.result1, fake.updateReturns.result2 +} + +func (fake *FakeServiceBindingInterface) UpdateCallCount() int { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + return len(fake.updateArgsForCall) +} + +func (fake *FakeServiceBindingInterface) UpdateArgsForCall(i int) *v1beta1.ServiceBinding { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + return fake.updateArgsForCall[i].arg1 +} + +func (fake *FakeServiceBindingInterface) UpdateReturns(result1 *v1beta1.ServiceBinding, result2 error) { + fake.UpdateStub = nil + fake.updateReturns = struct { + result1 *v1beta1.ServiceBinding + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) UpdateReturnsOnCall(i int, result1 *v1beta1.ServiceBinding, result2 error) { + fake.UpdateStub = nil + if fake.updateReturnsOnCall == nil { + fake.updateReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ServiceBinding + result2 error + }) + } + fake.updateReturnsOnCall[i] = struct { + result1 *v1beta1.ServiceBinding + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) UpdateStatus(arg1 *v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) { + fake.updateStatusMutex.Lock() + ret, specificReturn := fake.updateStatusReturnsOnCall[len(fake.updateStatusArgsForCall)] + fake.updateStatusArgsForCall = append(fake.updateStatusArgsForCall, struct { + arg1 *v1beta1.ServiceBinding + }{arg1}) + fake.recordInvocation("UpdateStatus", []interface{}{arg1}) + fake.updateStatusMutex.Unlock() + if fake.UpdateStatusStub != nil { + return fake.UpdateStatusStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.updateStatusReturns.result1, fake.updateStatusReturns.result2 +} + +func (fake *FakeServiceBindingInterface) UpdateStatusCallCount() int { + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + return len(fake.updateStatusArgsForCall) +} + +func (fake *FakeServiceBindingInterface) UpdateStatusArgsForCall(i int) *v1beta1.ServiceBinding { + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + return fake.updateStatusArgsForCall[i].arg1 +} + +func (fake *FakeServiceBindingInterface) UpdateStatusReturns(result1 *v1beta1.ServiceBinding, result2 error) { + fake.UpdateStatusStub = nil + fake.updateStatusReturns = struct { + result1 *v1beta1.ServiceBinding + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) UpdateStatusReturnsOnCall(i int, result1 *v1beta1.ServiceBinding, result2 error) { + fake.UpdateStatusStub = nil + if fake.updateStatusReturnsOnCall == nil { + fake.updateStatusReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ServiceBinding + result2 error + }) + } + fake.updateStatusReturnsOnCall[i] = struct { + result1 *v1beta1.ServiceBinding + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) Delete(name string, options *v1.DeleteOptions) error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + name string + options *v1.DeleteOptions + }{name, options}) + fake.recordInvocation("Delete", []interface{}{name, options}) + fake.deleteMutex.Unlock() + if fake.DeleteStub != nil { + return fake.DeleteStub(name, options) + } + if specificReturn { + return ret.result1 + } + return fake.deleteReturns.result1 +} + +func (fake *FakeServiceBindingInterface) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeServiceBindingInterface) DeleteArgsForCall(i int) (string, *v1.DeleteOptions) { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return fake.deleteArgsForCall[i].name, fake.deleteArgsForCall[i].options +} + +func (fake *FakeServiceBindingInterface) DeleteReturns(result1 error) { + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeServiceBindingInterface) DeleteReturnsOnCall(i int, result1 error) { + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeServiceBindingInterface) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { + fake.deleteCollectionMutex.Lock() + ret, specificReturn := fake.deleteCollectionReturnsOnCall[len(fake.deleteCollectionArgsForCall)] + fake.deleteCollectionArgsForCall = append(fake.deleteCollectionArgsForCall, struct { + options *v1.DeleteOptions + listOptions v1.ListOptions + }{options, listOptions}) + fake.recordInvocation("DeleteCollection", []interface{}{options, listOptions}) + fake.deleteCollectionMutex.Unlock() + if fake.DeleteCollectionStub != nil { + return fake.DeleteCollectionStub(options, listOptions) + } + if specificReturn { + return ret.result1 + } + return fake.deleteCollectionReturns.result1 +} + +func (fake *FakeServiceBindingInterface) DeleteCollectionCallCount() int { + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + return len(fake.deleteCollectionArgsForCall) +} + +func (fake *FakeServiceBindingInterface) DeleteCollectionArgsForCall(i int) (*v1.DeleteOptions, v1.ListOptions) { + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + return fake.deleteCollectionArgsForCall[i].options, fake.deleteCollectionArgsForCall[i].listOptions +} + +func (fake *FakeServiceBindingInterface) DeleteCollectionReturns(result1 error) { + fake.DeleteCollectionStub = nil + fake.deleteCollectionReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeServiceBindingInterface) DeleteCollectionReturnsOnCall(i int, result1 error) { + fake.DeleteCollectionStub = nil + if fake.deleteCollectionReturnsOnCall == nil { + fake.deleteCollectionReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteCollectionReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeServiceBindingInterface) Get(name string, options v1.GetOptions) (*v1beta1.ServiceBinding, error) { + fake.getMutex.Lock() + ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] + fake.getArgsForCall = append(fake.getArgsForCall, struct { + name string + options v1.GetOptions + }{name, options}) + fake.recordInvocation("Get", []interface{}{name, options}) + fake.getMutex.Unlock() + if fake.GetStub != nil { + return fake.GetStub(name, options) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getReturns.result1, fake.getReturns.result2 +} + +func (fake *FakeServiceBindingInterface) GetCallCount() int { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return len(fake.getArgsForCall) +} + +func (fake *FakeServiceBindingInterface) GetArgsForCall(i int) (string, v1.GetOptions) { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return fake.getArgsForCall[i].name, fake.getArgsForCall[i].options +} + +func (fake *FakeServiceBindingInterface) GetReturns(result1 *v1beta1.ServiceBinding, result2 error) { + fake.GetStub = nil + fake.getReturns = struct { + result1 *v1beta1.ServiceBinding + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) GetReturnsOnCall(i int, result1 *v1beta1.ServiceBinding, result2 error) { + fake.GetStub = nil + if fake.getReturnsOnCall == nil { + fake.getReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ServiceBinding + result2 error + }) + } + fake.getReturnsOnCall[i] = struct { + result1 *v1beta1.ServiceBinding + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) List(opts v1.ListOptions) (*v1beta1.ServiceBindingList, error) { + fake.listMutex.Lock() + ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] + fake.listArgsForCall = append(fake.listArgsForCall, struct { + opts v1.ListOptions + }{opts}) + fake.recordInvocation("List", []interface{}{opts}) + fake.listMutex.Unlock() + if fake.ListStub != nil { + return fake.ListStub(opts) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listReturns.result1, fake.listReturns.result2 +} + +func (fake *FakeServiceBindingInterface) ListCallCount() int { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return len(fake.listArgsForCall) +} + +func (fake *FakeServiceBindingInterface) ListArgsForCall(i int) v1.ListOptions { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return fake.listArgsForCall[i].opts +} + +func (fake *FakeServiceBindingInterface) ListReturns(result1 *v1beta1.ServiceBindingList, result2 error) { + fake.ListStub = nil + fake.listReturns = struct { + result1 *v1beta1.ServiceBindingList + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) ListReturnsOnCall(i int, result1 *v1beta1.ServiceBindingList, result2 error) { + fake.ListStub = nil + if fake.listReturnsOnCall == nil { + fake.listReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ServiceBindingList + result2 error + }) + } + fake.listReturnsOnCall[i] = struct { + result1 *v1beta1.ServiceBindingList + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) Watch(opts v1.ListOptions) (watch.Interface, error) { + fake.watchMutex.Lock() + ret, specificReturn := fake.watchReturnsOnCall[len(fake.watchArgsForCall)] + fake.watchArgsForCall = append(fake.watchArgsForCall, struct { + opts v1.ListOptions + }{opts}) + fake.recordInvocation("Watch", []interface{}{opts}) + fake.watchMutex.Unlock() + if fake.WatchStub != nil { + return fake.WatchStub(opts) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.watchReturns.result1, fake.watchReturns.result2 +} + +func (fake *FakeServiceBindingInterface) WatchCallCount() int { + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + return len(fake.watchArgsForCall) +} + +func (fake *FakeServiceBindingInterface) WatchArgsForCall(i int) v1.ListOptions { + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + return fake.watchArgsForCall[i].opts +} + +func (fake *FakeServiceBindingInterface) WatchReturns(result1 watch.Interface, result2 error) { + fake.WatchStub = nil + fake.watchReturns = struct { + result1 watch.Interface + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) WatchReturnsOnCall(i int, result1 watch.Interface, result2 error) { + fake.WatchStub = nil + if fake.watchReturnsOnCall == nil { + fake.watchReturnsOnCall = make(map[int]struct { + result1 watch.Interface + result2 error + }) + } + fake.watchReturnsOnCall[i] = struct { + result1 watch.Interface + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ServiceBinding, err error) { + var dataCopy []byte + if data != nil { + dataCopy = make([]byte, len(data)) + copy(dataCopy, data) + } + fake.patchMutex.Lock() + ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)] + fake.patchArgsForCall = append(fake.patchArgsForCall, struct { + name string + pt types.PatchType + data []byte + subresources []string + }{name, pt, dataCopy, subresources}) + fake.recordInvocation("Patch", []interface{}{name, pt, dataCopy, subresources}) + fake.patchMutex.Unlock() + if fake.PatchStub != nil { + return fake.PatchStub(name, pt, data, subresources...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.patchReturns.result1, fake.patchReturns.result2 +} + +func (fake *FakeServiceBindingInterface) PatchCallCount() int { + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + return len(fake.patchArgsForCall) +} + +func (fake *FakeServiceBindingInterface) PatchArgsForCall(i int) (string, types.PatchType, []byte, []string) { + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + return fake.patchArgsForCall[i].name, fake.patchArgsForCall[i].pt, fake.patchArgsForCall[i].data, fake.patchArgsForCall[i].subresources +} + +func (fake *FakeServiceBindingInterface) PatchReturns(result1 *v1beta1.ServiceBinding, result2 error) { + fake.PatchStub = nil + fake.patchReturns = struct { + result1 *v1beta1.ServiceBinding + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) PatchReturnsOnCall(i int, result1 *v1beta1.ServiceBinding, result2 error) { + fake.PatchStub = nil + if fake.patchReturnsOnCall == nil { + fake.patchReturnsOnCall = make(map[int]struct { + result1 *v1beta1.ServiceBinding + result2 error + }) + } + fake.patchReturnsOnCall[i] = struct { + result1 *v1beta1.ServiceBinding + result2 error + }{result1, result2} +} + +func (fake *FakeServiceBindingInterface) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeServiceBindingInterface) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ generated_v1beta1.ServiceBindingInterface = new(FakeServiceBindingInterface) diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_servicecatalogv1beta1_interface.go b/plugin/pkg/kubectl/plugin_client/fakes/fake_servicecatalogv1beta1_interface.go new file mode 100644 index 00000000000..d5fda56e4ab --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/fakes/fake_servicecatalogv1beta1_interface.go @@ -0,0 +1,364 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package fakes + +import ( + "sync" + + "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" + "k8s.io/client-go/rest" +) + +type FakeServicecatalogV1beta1Interface struct { + RESTClientStub func() rest.Interface + rESTClientMutex sync.RWMutex + rESTClientArgsForCall []struct{} + rESTClientReturns struct { + result1 rest.Interface + } + rESTClientReturnsOnCall map[int]struct { + result1 rest.Interface + } + ClusterServiceBrokersStub func() v1beta1.ClusterServiceBrokerInterface + clusterServiceBrokersMutex sync.RWMutex + clusterServiceBrokersArgsForCall []struct{} + clusterServiceBrokersReturns struct { + result1 v1beta1.ClusterServiceBrokerInterface + } + clusterServiceBrokersReturnsOnCall map[int]struct { + result1 v1beta1.ClusterServiceBrokerInterface + } + ClusterServiceClassesStub func() v1beta1.ClusterServiceClassInterface + clusterServiceClassesMutex sync.RWMutex + clusterServiceClassesArgsForCall []struct{} + clusterServiceClassesReturns struct { + result1 v1beta1.ClusterServiceClassInterface + } + clusterServiceClassesReturnsOnCall map[int]struct { + result1 v1beta1.ClusterServiceClassInterface + } + ClusterServicePlansStub func() v1beta1.ClusterServicePlanInterface + clusterServicePlansMutex sync.RWMutex + clusterServicePlansArgsForCall []struct{} + clusterServicePlansReturns struct { + result1 v1beta1.ClusterServicePlanInterface + } + clusterServicePlansReturnsOnCall map[int]struct { + result1 v1beta1.ClusterServicePlanInterface + } + ServiceBindingsStub func(namespace string) v1beta1.ServiceBindingInterface + serviceBindingsMutex sync.RWMutex + serviceBindingsArgsForCall []struct { + namespace string + } + serviceBindingsReturns struct { + result1 v1beta1.ServiceBindingInterface + } + serviceBindingsReturnsOnCall map[int]struct { + result1 v1beta1.ServiceBindingInterface + } + ServiceInstancesStub func(namespace string) v1beta1.ServiceInstanceInterface + serviceInstancesMutex sync.RWMutex + serviceInstancesArgsForCall []struct { + namespace string + } + serviceInstancesReturns struct { + result1 v1beta1.ServiceInstanceInterface + } + serviceInstancesReturnsOnCall map[int]struct { + result1 v1beta1.ServiceInstanceInterface + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeServicecatalogV1beta1Interface) RESTClient() rest.Interface { + fake.rESTClientMutex.Lock() + ret, specificReturn := fake.rESTClientReturnsOnCall[len(fake.rESTClientArgsForCall)] + fake.rESTClientArgsForCall = append(fake.rESTClientArgsForCall, struct{}{}) + fake.recordInvocation("RESTClient", []interface{}{}) + fake.rESTClientMutex.Unlock() + if fake.RESTClientStub != nil { + return fake.RESTClientStub() + } + if specificReturn { + return ret.result1 + } + return fake.rESTClientReturns.result1 +} + +func (fake *FakeServicecatalogV1beta1Interface) RESTClientCallCount() int { + fake.rESTClientMutex.RLock() + defer fake.rESTClientMutex.RUnlock() + return len(fake.rESTClientArgsForCall) +} + +func (fake *FakeServicecatalogV1beta1Interface) RESTClientReturns(result1 rest.Interface) { + fake.RESTClientStub = nil + fake.rESTClientReturns = struct { + result1 rest.Interface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) RESTClientReturnsOnCall(i int, result1 rest.Interface) { + fake.RESTClientStub = nil + if fake.rESTClientReturnsOnCall == nil { + fake.rESTClientReturnsOnCall = make(map[int]struct { + result1 rest.Interface + }) + } + fake.rESTClientReturnsOnCall[i] = struct { + result1 rest.Interface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceBrokers() v1beta1.ClusterServiceBrokerInterface { + fake.clusterServiceBrokersMutex.Lock() + ret, specificReturn := fake.clusterServiceBrokersReturnsOnCall[len(fake.clusterServiceBrokersArgsForCall)] + fake.clusterServiceBrokersArgsForCall = append(fake.clusterServiceBrokersArgsForCall, struct{}{}) + fake.recordInvocation("ClusterServiceBrokers", []interface{}{}) + fake.clusterServiceBrokersMutex.Unlock() + if fake.ClusterServiceBrokersStub != nil { + return fake.ClusterServiceBrokersStub() + } + if specificReturn { + return ret.result1 + } + return fake.clusterServiceBrokersReturns.result1 +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceBrokersCallCount() int { + fake.clusterServiceBrokersMutex.RLock() + defer fake.clusterServiceBrokersMutex.RUnlock() + return len(fake.clusterServiceBrokersArgsForCall) +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceBrokersReturns(result1 v1beta1.ClusterServiceBrokerInterface) { + fake.ClusterServiceBrokersStub = nil + fake.clusterServiceBrokersReturns = struct { + result1 v1beta1.ClusterServiceBrokerInterface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceBrokersReturnsOnCall(i int, result1 v1beta1.ClusterServiceBrokerInterface) { + fake.ClusterServiceBrokersStub = nil + if fake.clusterServiceBrokersReturnsOnCall == nil { + fake.clusterServiceBrokersReturnsOnCall = make(map[int]struct { + result1 v1beta1.ClusterServiceBrokerInterface + }) + } + fake.clusterServiceBrokersReturnsOnCall[i] = struct { + result1 v1beta1.ClusterServiceBrokerInterface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceClasses() v1beta1.ClusterServiceClassInterface { + fake.clusterServiceClassesMutex.Lock() + ret, specificReturn := fake.clusterServiceClassesReturnsOnCall[len(fake.clusterServiceClassesArgsForCall)] + fake.clusterServiceClassesArgsForCall = append(fake.clusterServiceClassesArgsForCall, struct{}{}) + fake.recordInvocation("ClusterServiceClasses", []interface{}{}) + fake.clusterServiceClassesMutex.Unlock() + if fake.ClusterServiceClassesStub != nil { + return fake.ClusterServiceClassesStub() + } + if specificReturn { + return ret.result1 + } + return fake.clusterServiceClassesReturns.result1 +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceClassesCallCount() int { + fake.clusterServiceClassesMutex.RLock() + defer fake.clusterServiceClassesMutex.RUnlock() + return len(fake.clusterServiceClassesArgsForCall) +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceClassesReturns(result1 v1beta1.ClusterServiceClassInterface) { + fake.ClusterServiceClassesStub = nil + fake.clusterServiceClassesReturns = struct { + result1 v1beta1.ClusterServiceClassInterface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceClassesReturnsOnCall(i int, result1 v1beta1.ClusterServiceClassInterface) { + fake.ClusterServiceClassesStub = nil + if fake.clusterServiceClassesReturnsOnCall == nil { + fake.clusterServiceClassesReturnsOnCall = make(map[int]struct { + result1 v1beta1.ClusterServiceClassInterface + }) + } + fake.clusterServiceClassesReturnsOnCall[i] = struct { + result1 v1beta1.ClusterServiceClassInterface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServicePlans() v1beta1.ClusterServicePlanInterface { + fake.clusterServicePlansMutex.Lock() + ret, specificReturn := fake.clusterServicePlansReturnsOnCall[len(fake.clusterServicePlansArgsForCall)] + fake.clusterServicePlansArgsForCall = append(fake.clusterServicePlansArgsForCall, struct{}{}) + fake.recordInvocation("ClusterServicePlans", []interface{}{}) + fake.clusterServicePlansMutex.Unlock() + if fake.ClusterServicePlansStub != nil { + return fake.ClusterServicePlansStub() + } + if specificReturn { + return ret.result1 + } + return fake.clusterServicePlansReturns.result1 +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServicePlansCallCount() int { + fake.clusterServicePlansMutex.RLock() + defer fake.clusterServicePlansMutex.RUnlock() + return len(fake.clusterServicePlansArgsForCall) +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServicePlansReturns(result1 v1beta1.ClusterServicePlanInterface) { + fake.ClusterServicePlansStub = nil + fake.clusterServicePlansReturns = struct { + result1 v1beta1.ClusterServicePlanInterface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) ClusterServicePlansReturnsOnCall(i int, result1 v1beta1.ClusterServicePlanInterface) { + fake.ClusterServicePlansStub = nil + if fake.clusterServicePlansReturnsOnCall == nil { + fake.clusterServicePlansReturnsOnCall = make(map[int]struct { + result1 v1beta1.ClusterServicePlanInterface + }) + } + fake.clusterServicePlansReturnsOnCall[i] = struct { + result1 v1beta1.ClusterServicePlanInterface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) ServiceBindings(namespace string) v1beta1.ServiceBindingInterface { + fake.serviceBindingsMutex.Lock() + ret, specificReturn := fake.serviceBindingsReturnsOnCall[len(fake.serviceBindingsArgsForCall)] + fake.serviceBindingsArgsForCall = append(fake.serviceBindingsArgsForCall, struct { + namespace string + }{namespace}) + fake.recordInvocation("ServiceBindings", []interface{}{namespace}) + fake.serviceBindingsMutex.Unlock() + if fake.ServiceBindingsStub != nil { + return fake.ServiceBindingsStub(namespace) + } + if specificReturn { + return ret.result1 + } + return fake.serviceBindingsReturns.result1 +} + +func (fake *FakeServicecatalogV1beta1Interface) ServiceBindingsCallCount() int { + fake.serviceBindingsMutex.RLock() + defer fake.serviceBindingsMutex.RUnlock() + return len(fake.serviceBindingsArgsForCall) +} + +func (fake *FakeServicecatalogV1beta1Interface) ServiceBindingsArgsForCall(i int) string { + fake.serviceBindingsMutex.RLock() + defer fake.serviceBindingsMutex.RUnlock() + return fake.serviceBindingsArgsForCall[i].namespace +} + +func (fake *FakeServicecatalogV1beta1Interface) ServiceBindingsReturns(result1 v1beta1.ServiceBindingInterface) { + fake.ServiceBindingsStub = nil + fake.serviceBindingsReturns = struct { + result1 v1beta1.ServiceBindingInterface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) ServiceBindingsReturnsOnCall(i int, result1 v1beta1.ServiceBindingInterface) { + fake.ServiceBindingsStub = nil + if fake.serviceBindingsReturnsOnCall == nil { + fake.serviceBindingsReturnsOnCall = make(map[int]struct { + result1 v1beta1.ServiceBindingInterface + }) + } + fake.serviceBindingsReturnsOnCall[i] = struct { + result1 v1beta1.ServiceBindingInterface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) ServiceInstances(namespace string) v1beta1.ServiceInstanceInterface { + fake.serviceInstancesMutex.Lock() + ret, specificReturn := fake.serviceInstancesReturnsOnCall[len(fake.serviceInstancesArgsForCall)] + fake.serviceInstancesArgsForCall = append(fake.serviceInstancesArgsForCall, struct { + namespace string + }{namespace}) + fake.recordInvocation("ServiceInstances", []interface{}{namespace}) + fake.serviceInstancesMutex.Unlock() + if fake.ServiceInstancesStub != nil { + return fake.ServiceInstancesStub(namespace) + } + if specificReturn { + return ret.result1 + } + return fake.serviceInstancesReturns.result1 +} + +func (fake *FakeServicecatalogV1beta1Interface) ServiceInstancesCallCount() int { + fake.serviceInstancesMutex.RLock() + defer fake.serviceInstancesMutex.RUnlock() + return len(fake.serviceInstancesArgsForCall) +} + +func (fake *FakeServicecatalogV1beta1Interface) ServiceInstancesArgsForCall(i int) string { + fake.serviceInstancesMutex.RLock() + defer fake.serviceInstancesMutex.RUnlock() + return fake.serviceInstancesArgsForCall[i].namespace +} + +func (fake *FakeServicecatalogV1beta1Interface) ServiceInstancesReturns(result1 v1beta1.ServiceInstanceInterface) { + fake.ServiceInstancesStub = nil + fake.serviceInstancesReturns = struct { + result1 v1beta1.ServiceInstanceInterface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) ServiceInstancesReturnsOnCall(i int, result1 v1beta1.ServiceInstanceInterface) { + fake.ServiceInstancesStub = nil + if fake.serviceInstancesReturnsOnCall == nil { + fake.serviceInstancesReturnsOnCall = make(map[int]struct { + result1 v1beta1.ServiceInstanceInterface + }) + } + fake.serviceInstancesReturnsOnCall[i] = struct { + result1 v1beta1.ServiceInstanceInterface + }{result1} +} + +func (fake *FakeServicecatalogV1beta1Interface) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.rESTClientMutex.RLock() + defer fake.rESTClientMutex.RUnlock() + fake.clusterServiceBrokersMutex.RLock() + defer fake.clusterServiceBrokersMutex.RUnlock() + fake.clusterServiceClassesMutex.RLock() + defer fake.clusterServiceClassesMutex.RUnlock() + fake.clusterServicePlansMutex.RLock() + defer fake.clusterServicePlansMutex.RUnlock() + fake.serviceBindingsMutex.RLock() + defer fake.serviceBindingsMutex.RUnlock() + fake.serviceInstancesMutex.RLock() + defer fake.serviceInstancesMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeServicecatalogV1beta1Interface) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ v1beta1.ServicecatalogV1beta1Interface = new(FakeServicecatalogV1beta1Interface) diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_serviceinstance_interface.go b/plugin/pkg/kubectl/plugin_client/fakes/fake_serviceinstance_interface.go new file mode 100644 index 00000000000..7f7a7e5cad2 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/fakes/fake_serviceinstance_interface.go @@ -0,0 +1,708 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package fakes + +import ( + "sync" + + v1beta1servicecatalog "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + generated_v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" + "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/watch" +) + +type FakeServiceInstanceInterface struct { + CreateStub func(*v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) + createMutex sync.RWMutex + createArgsForCall []struct { + arg1 *v1beta1servicecatalog.ServiceInstance + } + createReturns struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + createReturnsOnCall map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + UpdateStub func(*v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) + updateMutex sync.RWMutex + updateArgsForCall []struct { + arg1 *v1beta1servicecatalog.ServiceInstance + } + updateReturns struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + updateReturnsOnCall map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + UpdateStatusStub func(*v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) + updateStatusMutex sync.RWMutex + updateStatusArgsForCall []struct { + arg1 *v1beta1servicecatalog.ServiceInstance + } + updateStatusReturns struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + updateStatusReturnsOnCall map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + DeleteStub func(name string, options *v1.DeleteOptions) error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + name string + options *v1.DeleteOptions + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + DeleteCollectionStub func(options *v1.DeleteOptions, listOptions v1.ListOptions) error + deleteCollectionMutex sync.RWMutex + deleteCollectionArgsForCall []struct { + options *v1.DeleteOptions + listOptions v1.ListOptions + } + deleteCollectionReturns struct { + result1 error + } + deleteCollectionReturnsOnCall map[int]struct { + result1 error + } + GetStub func(name string, options v1.GetOptions) (*v1beta1servicecatalog.ServiceInstance, error) + getMutex sync.RWMutex + getArgsForCall []struct { + name string + options v1.GetOptions + } + getReturns struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + getReturnsOnCall map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + ListStub func(opts v1.ListOptions) (*v1beta1servicecatalog.ServiceInstanceList, error) + listMutex sync.RWMutex + listArgsForCall []struct { + opts v1.ListOptions + } + listReturns struct { + result1 *v1beta1servicecatalog.ServiceInstanceList + result2 error + } + listReturnsOnCall map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstanceList + result2 error + } + WatchStub func(opts v1.ListOptions) (watch.Interface, error) + watchMutex sync.RWMutex + watchArgsForCall []struct { + opts v1.ListOptions + } + watchReturns struct { + result1 watch.Interface + result2 error + } + watchReturnsOnCall map[int]struct { + result1 watch.Interface + result2 error + } + PatchStub func(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1servicecatalog.ServiceInstance, err error) + patchMutex sync.RWMutex + patchArgsForCall []struct { + name string + pt types.PatchType + data []byte + subresources []string + } + patchReturns struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + patchReturnsOnCall map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + UpdateReferencesStub func(serviceInstance *v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) + updateReferencesMutex sync.RWMutex + updateReferencesArgsForCall []struct { + serviceInstance *v1beta1servicecatalog.ServiceInstance + } + updateReferencesReturns struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + updateReferencesReturnsOnCall map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeServiceInstanceInterface) Create(arg1 *v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) { + fake.createMutex.Lock() + ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] + fake.createArgsForCall = append(fake.createArgsForCall, struct { + arg1 *v1beta1servicecatalog.ServiceInstance + }{arg1}) + fake.recordInvocation("Create", []interface{}{arg1}) + fake.createMutex.Unlock() + if fake.CreateStub != nil { + return fake.CreateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.createReturns.result1, fake.createReturns.result2 +} + +func (fake *FakeServiceInstanceInterface) CreateCallCount() int { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return len(fake.createArgsForCall) +} + +func (fake *FakeServiceInstanceInterface) CreateArgsForCall(i int) *v1beta1servicecatalog.ServiceInstance { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return fake.createArgsForCall[i].arg1 +} + +func (fake *FakeServiceInstanceInterface) CreateReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.CreateStub = nil + fake.createReturns = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) CreateReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.CreateStub = nil + if fake.createReturnsOnCall == nil { + fake.createReturnsOnCall = make(map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }) + } + fake.createReturnsOnCall[i] = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) Update(arg1 *v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) { + fake.updateMutex.Lock() + ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] + fake.updateArgsForCall = append(fake.updateArgsForCall, struct { + arg1 *v1beta1servicecatalog.ServiceInstance + }{arg1}) + fake.recordInvocation("Update", []interface{}{arg1}) + fake.updateMutex.Unlock() + if fake.UpdateStub != nil { + return fake.UpdateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.updateReturns.result1, fake.updateReturns.result2 +} + +func (fake *FakeServiceInstanceInterface) UpdateCallCount() int { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + return len(fake.updateArgsForCall) +} + +func (fake *FakeServiceInstanceInterface) UpdateArgsForCall(i int) *v1beta1servicecatalog.ServiceInstance { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + return fake.updateArgsForCall[i].arg1 +} + +func (fake *FakeServiceInstanceInterface) UpdateReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.UpdateStub = nil + fake.updateReturns = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) UpdateReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.UpdateStub = nil + if fake.updateReturnsOnCall == nil { + fake.updateReturnsOnCall = make(map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }) + } + fake.updateReturnsOnCall[i] = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) UpdateStatus(arg1 *v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) { + fake.updateStatusMutex.Lock() + ret, specificReturn := fake.updateStatusReturnsOnCall[len(fake.updateStatusArgsForCall)] + fake.updateStatusArgsForCall = append(fake.updateStatusArgsForCall, struct { + arg1 *v1beta1servicecatalog.ServiceInstance + }{arg1}) + fake.recordInvocation("UpdateStatus", []interface{}{arg1}) + fake.updateStatusMutex.Unlock() + if fake.UpdateStatusStub != nil { + return fake.UpdateStatusStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.updateStatusReturns.result1, fake.updateStatusReturns.result2 +} + +func (fake *FakeServiceInstanceInterface) UpdateStatusCallCount() int { + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + return len(fake.updateStatusArgsForCall) +} + +func (fake *FakeServiceInstanceInterface) UpdateStatusArgsForCall(i int) *v1beta1servicecatalog.ServiceInstance { + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + return fake.updateStatusArgsForCall[i].arg1 +} + +func (fake *FakeServiceInstanceInterface) UpdateStatusReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.UpdateStatusStub = nil + fake.updateStatusReturns = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) UpdateStatusReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.UpdateStatusStub = nil + if fake.updateStatusReturnsOnCall == nil { + fake.updateStatusReturnsOnCall = make(map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }) + } + fake.updateStatusReturnsOnCall[i] = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) Delete(name string, options *v1.DeleteOptions) error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + name string + options *v1.DeleteOptions + }{name, options}) + fake.recordInvocation("Delete", []interface{}{name, options}) + fake.deleteMutex.Unlock() + if fake.DeleteStub != nil { + return fake.DeleteStub(name, options) + } + if specificReturn { + return ret.result1 + } + return fake.deleteReturns.result1 +} + +func (fake *FakeServiceInstanceInterface) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeServiceInstanceInterface) DeleteArgsForCall(i int) (string, *v1.DeleteOptions) { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return fake.deleteArgsForCall[i].name, fake.deleteArgsForCall[i].options +} + +func (fake *FakeServiceInstanceInterface) DeleteReturns(result1 error) { + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeServiceInstanceInterface) DeleteReturnsOnCall(i int, result1 error) { + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeServiceInstanceInterface) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { + fake.deleteCollectionMutex.Lock() + ret, specificReturn := fake.deleteCollectionReturnsOnCall[len(fake.deleteCollectionArgsForCall)] + fake.deleteCollectionArgsForCall = append(fake.deleteCollectionArgsForCall, struct { + options *v1.DeleteOptions + listOptions v1.ListOptions + }{options, listOptions}) + fake.recordInvocation("DeleteCollection", []interface{}{options, listOptions}) + fake.deleteCollectionMutex.Unlock() + if fake.DeleteCollectionStub != nil { + return fake.DeleteCollectionStub(options, listOptions) + } + if specificReturn { + return ret.result1 + } + return fake.deleteCollectionReturns.result1 +} + +func (fake *FakeServiceInstanceInterface) DeleteCollectionCallCount() int { + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + return len(fake.deleteCollectionArgsForCall) +} + +func (fake *FakeServiceInstanceInterface) DeleteCollectionArgsForCall(i int) (*v1.DeleteOptions, v1.ListOptions) { + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + return fake.deleteCollectionArgsForCall[i].options, fake.deleteCollectionArgsForCall[i].listOptions +} + +func (fake *FakeServiceInstanceInterface) DeleteCollectionReturns(result1 error) { + fake.DeleteCollectionStub = nil + fake.deleteCollectionReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeServiceInstanceInterface) DeleteCollectionReturnsOnCall(i int, result1 error) { + fake.DeleteCollectionStub = nil + if fake.deleteCollectionReturnsOnCall == nil { + fake.deleteCollectionReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteCollectionReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeServiceInstanceInterface) Get(name string, options v1.GetOptions) (*v1beta1servicecatalog.ServiceInstance, error) { + fake.getMutex.Lock() + ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] + fake.getArgsForCall = append(fake.getArgsForCall, struct { + name string + options v1.GetOptions + }{name, options}) + fake.recordInvocation("Get", []interface{}{name, options}) + fake.getMutex.Unlock() + if fake.GetStub != nil { + return fake.GetStub(name, options) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.getReturns.result1, fake.getReturns.result2 +} + +func (fake *FakeServiceInstanceInterface) GetCallCount() int { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return len(fake.getArgsForCall) +} + +func (fake *FakeServiceInstanceInterface) GetArgsForCall(i int) (string, v1.GetOptions) { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return fake.getArgsForCall[i].name, fake.getArgsForCall[i].options +} + +func (fake *FakeServiceInstanceInterface) GetReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.GetStub = nil + fake.getReturns = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) GetReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.GetStub = nil + if fake.getReturnsOnCall == nil { + fake.getReturnsOnCall = make(map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }) + } + fake.getReturnsOnCall[i] = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) List(opts v1.ListOptions) (*v1beta1servicecatalog.ServiceInstanceList, error) { + fake.listMutex.Lock() + ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] + fake.listArgsForCall = append(fake.listArgsForCall, struct { + opts v1.ListOptions + }{opts}) + fake.recordInvocation("List", []interface{}{opts}) + fake.listMutex.Unlock() + if fake.ListStub != nil { + return fake.ListStub(opts) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.listReturns.result1, fake.listReturns.result2 +} + +func (fake *FakeServiceInstanceInterface) ListCallCount() int { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return len(fake.listArgsForCall) +} + +func (fake *FakeServiceInstanceInterface) ListArgsForCall(i int) v1.ListOptions { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return fake.listArgsForCall[i].opts +} + +func (fake *FakeServiceInstanceInterface) ListReturns(result1 *v1beta1servicecatalog.ServiceInstanceList, result2 error) { + fake.ListStub = nil + fake.listReturns = struct { + result1 *v1beta1servicecatalog.ServiceInstanceList + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) ListReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstanceList, result2 error) { + fake.ListStub = nil + if fake.listReturnsOnCall == nil { + fake.listReturnsOnCall = make(map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstanceList + result2 error + }) + } + fake.listReturnsOnCall[i] = struct { + result1 *v1beta1servicecatalog.ServiceInstanceList + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) Watch(opts v1.ListOptions) (watch.Interface, error) { + fake.watchMutex.Lock() + ret, specificReturn := fake.watchReturnsOnCall[len(fake.watchArgsForCall)] + fake.watchArgsForCall = append(fake.watchArgsForCall, struct { + opts v1.ListOptions + }{opts}) + fake.recordInvocation("Watch", []interface{}{opts}) + fake.watchMutex.Unlock() + if fake.WatchStub != nil { + return fake.WatchStub(opts) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.watchReturns.result1, fake.watchReturns.result2 +} + +func (fake *FakeServiceInstanceInterface) WatchCallCount() int { + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + return len(fake.watchArgsForCall) +} + +func (fake *FakeServiceInstanceInterface) WatchArgsForCall(i int) v1.ListOptions { + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + return fake.watchArgsForCall[i].opts +} + +func (fake *FakeServiceInstanceInterface) WatchReturns(result1 watch.Interface, result2 error) { + fake.WatchStub = nil + fake.watchReturns = struct { + result1 watch.Interface + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) WatchReturnsOnCall(i int, result1 watch.Interface, result2 error) { + fake.WatchStub = nil + if fake.watchReturnsOnCall == nil { + fake.watchReturnsOnCall = make(map[int]struct { + result1 watch.Interface + result2 error + }) + } + fake.watchReturnsOnCall[i] = struct { + result1 watch.Interface + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1servicecatalog.ServiceInstance, err error) { + var dataCopy []byte + if data != nil { + dataCopy = make([]byte, len(data)) + copy(dataCopy, data) + } + fake.patchMutex.Lock() + ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)] + fake.patchArgsForCall = append(fake.patchArgsForCall, struct { + name string + pt types.PatchType + data []byte + subresources []string + }{name, pt, dataCopy, subresources}) + fake.recordInvocation("Patch", []interface{}{name, pt, dataCopy, subresources}) + fake.patchMutex.Unlock() + if fake.PatchStub != nil { + return fake.PatchStub(name, pt, data, subresources...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.patchReturns.result1, fake.patchReturns.result2 +} + +func (fake *FakeServiceInstanceInterface) PatchCallCount() int { + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + return len(fake.patchArgsForCall) +} + +func (fake *FakeServiceInstanceInterface) PatchArgsForCall(i int) (string, types.PatchType, []byte, []string) { + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + return fake.patchArgsForCall[i].name, fake.patchArgsForCall[i].pt, fake.patchArgsForCall[i].data, fake.patchArgsForCall[i].subresources +} + +func (fake *FakeServiceInstanceInterface) PatchReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.PatchStub = nil + fake.patchReturns = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) PatchReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.PatchStub = nil + if fake.patchReturnsOnCall == nil { + fake.patchReturnsOnCall = make(map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }) + } + fake.patchReturnsOnCall[i] = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) UpdateReferences(serviceInstance *v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) { + fake.updateReferencesMutex.Lock() + ret, specificReturn := fake.updateReferencesReturnsOnCall[len(fake.updateReferencesArgsForCall)] + fake.updateReferencesArgsForCall = append(fake.updateReferencesArgsForCall, struct { + serviceInstance *v1beta1servicecatalog.ServiceInstance + }{serviceInstance}) + fake.recordInvocation("UpdateReferences", []interface{}{serviceInstance}) + fake.updateReferencesMutex.Unlock() + if fake.UpdateReferencesStub != nil { + return fake.UpdateReferencesStub(serviceInstance) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fake.updateReferencesReturns.result1, fake.updateReferencesReturns.result2 +} + +func (fake *FakeServiceInstanceInterface) UpdateReferencesCallCount() int { + fake.updateReferencesMutex.RLock() + defer fake.updateReferencesMutex.RUnlock() + return len(fake.updateReferencesArgsForCall) +} + +func (fake *FakeServiceInstanceInterface) UpdateReferencesArgsForCall(i int) *v1beta1servicecatalog.ServiceInstance { + fake.updateReferencesMutex.RLock() + defer fake.updateReferencesMutex.RUnlock() + return fake.updateReferencesArgsForCall[i].serviceInstance +} + +func (fake *FakeServiceInstanceInterface) UpdateReferencesReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.UpdateReferencesStub = nil + fake.updateReferencesReturns = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) UpdateReferencesReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { + fake.UpdateReferencesStub = nil + if fake.updateReferencesReturnsOnCall == nil { + fake.updateReferencesReturnsOnCall = make(map[int]struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }) + } + fake.updateReferencesReturnsOnCall[i] = struct { + result1 *v1beta1servicecatalog.ServiceInstance + result2 error + }{result1, result2} +} + +func (fake *FakeServiceInstanceInterface) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + fake.updateStatusMutex.RLock() + defer fake.updateStatusMutex.RUnlock() + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + fake.deleteCollectionMutex.RLock() + defer fake.deleteCollectionMutex.RUnlock() + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + fake.watchMutex.RLock() + defer fake.watchMutex.RUnlock() + fake.patchMutex.RLock() + defer fake.patchMutex.RUnlock() + fake.updateReferencesMutex.RLock() + defer fake.updateReferencesMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeServiceInstanceInterface) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ generated_v1beta1.ServiceInstanceInterface = new(FakeServiceInstanceInterface) diff --git a/plugin/pkg/kubectl/plugin_client/instance.go b/plugin/pkg/kubectl/plugin_client/instance.go new file mode 100644 index 00000000000..fecc0a2a93a --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/instance.go @@ -0,0 +1,32 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package plugin_client + +import ( + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +func (c *PluginClient) GetInstance(instanceName, namespace string) (*v1beta1.ServiceInstance, error) { + instance, err := c.ScClient.ServicecatalogV1beta1().ServiceInstances(namespace).Get(instanceName, v1.GetOptions{}) + return instance, err +} + +func (c *PluginClient) ListInstances(namespace string) (*v1beta1.ServiceInstanceList, error) { + instances, err := c.ScClient.ServicecatalogV1beta1().ServiceInstances(namespace).List(v1.ListOptions{}) + return instances, err +} diff --git a/plugin/pkg/kubectl/plugin_client/instance_test.go b/plugin/pkg/kubectl/plugin_client/instance_test.go new file mode 100644 index 00000000000..1c3b58263d5 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/instance_test.go @@ -0,0 +1,80 @@ +package plugin_client_test + +import ( + "errors" + + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client/fakes" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("Instances", func() { + var ( + client *plugin_client.PluginClient + err error + FakeScClient *fakes.FakeInterface + ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface + ServiceInstances *fakes.FakeServiceInstanceInterface + ) + + BeforeEach(func() { + client, err = plugin_client.NewClient() + Expect(err).NotTo(HaveOccurred()) + FakeScClient = &fakes.FakeInterface{} + ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} + ServiceInstances = &fakes.FakeServiceInstanceInterface{} + + client.ScClient = FakeScClient + FakeScClient.ServicecatalogV1beta1Returns(ServicecatalogV1beta1) + ServicecatalogV1beta1.ServiceInstancesReturns(ServiceInstances) + }) + + Describe("Get", func() { + It("Calls the generated v1beta1 List method with the passed in instance and namespace", func() { + namespace := "foobar_namespace" + instanceName := "potato_instance" + + _, err := client.GetInstance(instanceName, namespace) + Expect(err).NotTo(HaveOccurred()) + Expect(ServicecatalogV1beta1.ServiceInstancesArgsForCall(0)).To(Equal(namespace)) + returnedName, _ := ServiceInstances.GetArgsForCall(0) + Expect(returnedName).To(Equal(instanceName)) + Expect(ServiceInstances.GetCallCount()).To(Equal(1)) + }) + It("Bubbles up errors", func() { + namespace := "foobar_namespace" + instanceName := "potato_instance" + errorMessage := "instance not found" + + ServiceInstances.GetReturns(nil, errors.New(errorMessage)) + _, err := client.GetInstance(instanceName, namespace) + Expect(err).To(HaveOccurred()) + Expect(ServiceInstances.GetCallCount()).To(Equal(1)) + }) + }) + + Describe("List", func() { + It("Calls the generated v1beta1 List method with the specified namespace", func() { + namespace := "foobar_namespace" + + _, err := client.ListInstances(namespace) + + Expect(err).NotTo(HaveOccurred()) + Expect(ServicecatalogV1beta1.ServiceInstancesArgsForCall(0)).To(Equal(namespace)) + Expect(ServiceInstances.ListCallCount()).To(Equal(1)) + }) + It("Bubbles up errors", func() { + ServiceInstances.ListReturns(nil, errors.New("foobar")) + namespace := "foobar_namespace" + + _, err := client.ListInstances(namespace) + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).Should(ContainSubstring("foobar")) + Expect(ServicecatalogV1beta1.ServiceInstancesArgsForCall(0)).To(Equal(namespace)) + Expect(ServiceInstances.ListCallCount()).To(Equal(1)) + }) + }) +}) diff --git a/plugin/pkg/kubectl/plugin_client/plan.go b/plugin/pkg/kubectl/plugin_client/plan.go new file mode 100644 index 00000000000..c60e4565ed1 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/plan.go @@ -0,0 +1,32 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package plugin_client + +import ( + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +func (c *PluginClient) GetPlan(planName string) (*v1beta1.ClusterServicePlan, error) { + plan, err := c.ScClient.ServicecatalogV1beta1().ClusterServicePlans().Get(planName, v1.GetOptions{}) + return plan, err +} + +func (c *PluginClient) ListPlans() (*v1beta1.ClusterServicePlanList, error) { + plans, err := c.ScClient.ServicecatalogV1beta1().ClusterServicePlans().List(v1.ListOptions{}) + return plans, err +} diff --git a/plugin/pkg/kubectl/plugin_client/plan_test.go b/plugin/pkg/kubectl/plugin_client/plan_test.go new file mode 100644 index 00000000000..205eddf7853 --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/plan_test.go @@ -0,0 +1,73 @@ +package plugin_client_test + +import ( + "errors" + + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client/fakes" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("Plan", func() { + var ( + client *plugin_client.PluginClient + err error + FakeScClient *fakes.FakeInterface + ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface + ClusterServicePlans *fakes.FakeClusterServicePlanInterface + ) + + BeforeEach(func() { + client, err = plugin_client.NewClient() + Expect(err).NotTo(HaveOccurred()) + FakeScClient = &fakes.FakeInterface{} + ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} + ClusterServicePlans = &fakes.FakeClusterServicePlanInterface{} + + client.ScClient = FakeScClient + FakeScClient.ServicecatalogV1beta1Returns(ServicecatalogV1beta1) + ServicecatalogV1beta1.ClusterServicePlansReturns(ClusterServicePlans) + }) + + Describe("Get", func() { + It("Calls the generated v1beta1 List method with the passed in plan", func() { + planName := "foobar" + _, err = client.GetPlan(planName) + + Expect(ClusterServicePlans.GetCallCount()).To(Equal(1)) + name, _ := ClusterServicePlans.GetArgsForCall(0) + Expect(name).To(Equal(planName)) + }) + It("Bubbles up errors", func() { + errorMessage := "plan not found" + ClusterServicePlans.GetReturns(nil, errors.New(errorMessage)) + + _, err := client.GetPlan("banana") + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).Should(ContainSubstring(errorMessage)) + Expect(ClusterServicePlans.GetCallCount()).To(Equal(1)) + }) + }) + + Describe("List", func() { + It("Calls the generated v1beta1 List method", func() { + _, err := client.ListPlans() + + Expect(err).NotTo(HaveOccurred()) + Expect(ClusterServicePlans.ListCallCount()).To(Equal(1)) + }) + It("Bubbles up errors", func() { + errorMessage := "foobar" + ClusterServicePlans.ListReturns(nil, errors.New(errorMessage)) + + _, err := client.ListPlans() + + Expect(err).To(HaveOccurred()) + Expect(err.Error()).Should(ContainSubstring(errorMessage)) + Expect(ClusterServicePlans.ListCallCount()).To(Equal(1)) + }) + }) +}) diff --git a/plugin/pkg/kubectl/plugin_client/plugin_client.go b/plugin/pkg/kubectl/plugin_client/plugin_client.go new file mode 100644 index 00000000000..b76bb80f6ca --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/plugin_client.go @@ -0,0 +1,191 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package plugin_client + +import ( + "encoding/json" + "errors" + "fmt" + "os" + "time" + + restclient "k8s.io/client-go/rest" + "k8s.io/client-go/tools/clientcmd" + + "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" +) + +type PluginClient struct { + ScClient clientset.Interface + Config *restclient.Config +} + +// NewClient uses the KUBECONFIG environment variable to create a new client +// based on an existing configuration +func NewClient() (*PluginClient, error) { + // resolve kubeconfig location, prioritizing the --config global flag, + // then the value of the KUBECONFIG env var (if any), and defaulting + // to ~/.kube/config as a last resort. + home := os.Getenv("HOME") + kubeconfig := home + "/.kube/config" + + kubeconfigEnv := os.Getenv("KUBECONFIG") + if len(kubeconfigEnv) > 0 { + kubeconfig = kubeconfigEnv + } + + configFile := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CONFIG") + kubeConfigFile := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_KUBECONFIG") + if len(configFile) > 0 { + kubeconfig = configFile + } else if len(kubeConfigFile) > 0 { + kubeconfig = kubeConfigFile + } + + if len(kubeconfig) == 0 { + return nil, errors.New(fmt.Sprintf("error iniializing client. The KUBECONFIG environment variable must be defined.")) + } + + clientConfig, _, err := clientFromConfig(kubeconfig) + if err != nil { + return nil, errors.New(fmt.Sprintf("error obtaining client configuration: %v", err)) + } + + err = applyGlobalOptionsToConfig(clientConfig) + if err != nil { + return nil, errors.New(fmt.Sprintf("error processing global plugin options: %v", err)) + } + + c, err := clientset.NewForConfig(clientConfig) + if err != nil { + return nil, errors.New(fmt.Sprintf("error obtaining a client from existing configuration: %v", err)) + } + + pluginClient := PluginClient{c, clientConfig} + return &pluginClient, nil +} + +func clientFromConfig(path string) (*restclient.Config, string, error) { + if path == "-" { + cfg, err := restclient.InClusterConfig() + if err != nil { + return nil, "", fmt.Errorf("cluster config not available: %v", err) + } + return cfg, "", nil + } + + rules := &clientcmd.ClientConfigLoadingRules{ExplicitPath: path} + credentials, err := rules.Load() + if err != nil { + return nil, "", fmt.Errorf("the provided credentials %q could not be loaded: %v", path, err) + } + + cfg := clientcmd.NewDefaultClientConfig(*credentials, &clientcmd.ConfigOverrides{}) + config, err := cfg.ClientConfig() + if err != nil { + return nil, "", fmt.Errorf("the provided credentials %q could not be used: %v", path, err) + } + + namespace, _, _ := cfg.Namespace() + return config, namespace, nil +} + +func applyGlobalOptionsToConfig(config *restclient.Config) error { + // impersonation config + impersonateUser := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_AS") + if len(impersonateUser) > 0 { + config.Impersonate.UserName = impersonateUser + } + + impersonateGroupRaw := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_AS_GROUP") + if len(impersonateGroupRaw) > 0 { + impersonateGroup := []string{} + err := json.Unmarshal([]byte(impersonateGroupRaw), &impersonateGroup) + if err != nil { + return errors.New(fmt.Sprintf("error parsing global option %q: %v", "--as-group", err)) + } + if len(impersonateGroup) > 0 { + config.Impersonate.Groups = impersonateGroup + } + } + // tls config + + caFile := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CERTIFICATE_AUTHORITY") + if len(caFile) > 0 { + config.TLSClientConfig.CAFile = caFile + } + + clientCertFile := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CLIENT_CERTIFICATE") + if len(clientCertFile) > 0 { + config.TLSClientConfig.CertFile = clientCertFile + } + + clientKey := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CLIENT_KEY") + if len(clientKey) > 0 { + config.TLSClientConfig.KeyFile = clientKey + } + + // kubeconfig config + + cluster := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CLUSTER") + if len(cluster) > 0 { + // TODO(jvallejo): figure out how to override kubeconfig options + } + + context := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_CONTEXT") + if len(context) > 0 { + // TODO(jvallejo): figure out how to override kubeconfig options + } + + user := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_USER") + if len(user) > 0 { + // TODO(jvallejo): figure out how to override kubeconfig options + } + + // user / misc request config + + requestTimeout := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_REQUEST_TIMEOUT") + if len(requestTimeout) > 0 { + t, err := time.ParseDuration(requestTimeout) + if err != nil { + return errors.New(fmt.Sprintf("%v", err)) + } + config.Timeout = t + } + + server := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_SERVER") + if len(server) > 0 { + config.ServerName = server + } + + token := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_TOKEN") + if len(token) > 0 { + config.BearerToken = token + } + + username := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_USERNAME") + if len(username) > 0 { + config.Username = username + } + + password := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_PASSWORD") + if len(password) > 0 { + config.Username = password + } + + return nil +} diff --git a/plugin/pkg/kubectl/plugin_client/plugin_client_suite_test.go b/plugin/pkg/kubectl/plugin_client/plugin_client_suite_test.go new file mode 100644 index 00000000000..f2419c35a3f --- /dev/null +++ b/plugin/pkg/kubectl/plugin_client/plugin_client_suite_test.go @@ -0,0 +1,19 @@ +package plugin_client_test + +import ( + "os" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "testing" +) + +func TestPluginClient(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "PluginClient Suite") +} + +var _ = BeforeEach(func() { + os.Setenv("KUBECTL_PLUGINS_GLOBAL_FLAG_KUBECONFIG", "assets/config") +}) diff --git a/plugin/cmd/kubectl/utils/table_printer.go b/plugin/pkg/kubectl/utils/table_printer.go similarity index 100% rename from plugin/cmd/kubectl/utils/table_printer.go rename to plugin/pkg/kubectl/utils/table_printer.go diff --git a/plugin/cmd/kubectl/utils/ui.go b/plugin/pkg/kubectl/utils/ui.go similarity index 100% rename from plugin/cmd/kubectl/utils/ui.go rename to plugin/pkg/kubectl/utils/ui.go diff --git a/plugin/cmd/kubectl/utils/utils.go b/plugin/pkg/kubectl/utils/utils.go similarity index 100% rename from plugin/cmd/kubectl/utils/utils.go rename to plugin/pkg/kubectl/utils/utils.go From f8e9aa0f16b83ada7b17c074b10961ab99b29c3a Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Fri, 15 Dec 2017 15:42:29 -0800 Subject: [PATCH 19/24] Appease golinter --- plugin/cmd/kubectl/binding/binding.go | 4 +-- plugin/cmd/kubectl/broker/broker.go | 4 +-- plugin/cmd/kubectl/class/class.go | 4 +-- plugin/cmd/kubectl/instance/instance.go | 4 +-- plugin/cmd/kubectl/plan/plan.go | 4 +-- .../{plugin_client => client}/assets/config | 0 .../{plugin_client => client}/binding.go | 4 ++- .../{plugin_client => client}/binding_test.go | 26 +++++++++++--- .../{plugin_client => client}/broker.go | 4 ++- .../{plugin_client => client}/broker_test.go | 26 +++++++++++--- .../{plugin_client => client}/class.go | 4 ++- .../{plugin_client => client}/class_test.go | 26 +++++++++++--- .../fake_clusterservicebroker_interface.go | 16 +++++++++ .../fake_clusterserviceclass_interface.go | 16 +++++++++ .../fake_clusterserviceplan_interface.go | 16 +++++++++ .../fakes/fake_interface.go | 16 +++++++++ .../fakes/fake_servicebinding_interface.go | 16 +++++++++ .../fake_servicecatalogv1beta1_interface.go | 16 +++++++++ .../fakes/fake_serviceinstance_interface.go | 16 +++++++++ .../{plugin_client => client}/instance.go | 4 ++- .../instance_test.go | 26 +++++++++++--- .../kubectl/{plugin_client => client}/plan.go | 4 ++- .../{plugin_client => client}/plan_test.go | 26 +++++++++++--- .../plugin_client.go | 17 ++++----- .../client/plugin_client_suite_test.go | 35 +++++++++++++++++++ .../plugin_client/plugin_client_suite_test.go | 19 ---------- plugin/pkg/kubectl/utils/utils.go | 4 +++ 27 files changed, 290 insertions(+), 67 deletions(-) rename plugin/pkg/kubectl/{plugin_client => client}/assets/config (100%) rename plugin/pkg/kubectl/{plugin_client => client}/binding.go (88%) rename plugin/pkg/kubectl/{plugin_client => client}/binding_test.go (76%) rename plugin/pkg/kubectl/{plugin_client => client}/broker.go (91%) rename plugin/pkg/kubectl/{plugin_client => client}/broker_test.go (73%) rename plugin/pkg/kubectl/{plugin_client => client}/class.go (90%) rename plugin/pkg/kubectl/{plugin_client => client}/class_test.go (73%) rename plugin/pkg/kubectl/{plugin_client => client}/fakes/fake_clusterservicebroker_interface.go (97%) rename plugin/pkg/kubectl/{plugin_client => client}/fakes/fake_clusterserviceclass_interface.go (97%) rename plugin/pkg/kubectl/{plugin_client => client}/fakes/fake_clusterserviceplan_interface.go (97%) rename plugin/pkg/kubectl/{plugin_client => client}/fakes/fake_interface.go (92%) rename plugin/pkg/kubectl/{plugin_client => client}/fakes/fake_servicebinding_interface.go (97%) rename plugin/pkg/kubectl/{plugin_client => client}/fakes/fake_servicecatalogv1beta1_interface.go (95%) rename plugin/pkg/kubectl/{plugin_client => client}/fakes/fake_serviceinstance_interface.go (97%) rename plugin/pkg/kubectl/{plugin_client => client}/instance.go (87%) rename plugin/pkg/kubectl/{plugin_client => client}/instance_test.go (76%) rename plugin/pkg/kubectl/{plugin_client => client}/plan.go (92%) rename plugin/pkg/kubectl/{plugin_client => client}/plan_test.go (72%) rename plugin/pkg/kubectl/{plugin_client => client}/plugin_client.go (89%) create mode 100644 plugin/pkg/kubectl/client/plugin_client_suite_test.go delete mode 100644 plugin/pkg/kubectl/plugin_client/plugin_client_suite_test.go diff --git a/plugin/cmd/kubectl/binding/binding.go b/plugin/cmd/kubectl/binding/binding.go index 38e1a2ae82b..ea07f777bc9 100644 --- a/plugin/cmd/kubectl/binding/binding.go +++ b/plugin/cmd/kubectl/binding/binding.go @@ -20,7 +20,7 @@ import ( "fmt" "os" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/utils" ) @@ -45,7 +45,7 @@ func main() { utils.Exit1(usage) } - client, err := plugin_client.NewClient() + client, err := client.NewClient() if err != nil { utils.Exit1(fmt.Sprintf("Unable to initialize service catalog client (%s)", err)) } diff --git a/plugin/cmd/kubectl/broker/broker.go b/plugin/cmd/kubectl/broker/broker.go index 7c0289877aa..eea6395c3f6 100644 --- a/plugin/cmd/kubectl/broker/broker.go +++ b/plugin/cmd/kubectl/broker/broker.go @@ -20,7 +20,7 @@ import ( "fmt" "os" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/utils" ) @@ -41,7 +41,7 @@ func main() { utils.Exit1(usage) } - client, err := plugin_client.NewClient() + client, err := client.NewClient() if err != nil { utils.Exit1(fmt.Sprintf("Unable to initialize service catalog client (%s)", err)) } diff --git a/plugin/cmd/kubectl/class/class.go b/plugin/cmd/kubectl/class/class.go index cdbe0e74a84..083d932050b 100644 --- a/plugin/cmd/kubectl/class/class.go +++ b/plugin/cmd/kubectl/class/class.go @@ -20,7 +20,7 @@ import ( "fmt" "os" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/utils" ) @@ -41,7 +41,7 @@ func main() { utils.Exit1(usage) } - client, err := plugin_client.NewClient() + client, err := client.NewClient() if err != nil { utils.Exit1(fmt.Sprintf("Unable to initialize service catalog client (%s)", err)) } diff --git a/plugin/cmd/kubectl/instance/instance.go b/plugin/cmd/kubectl/instance/instance.go index 46f03664c31..0b4ee5dca31 100644 --- a/plugin/cmd/kubectl/instance/instance.go +++ b/plugin/cmd/kubectl/instance/instance.go @@ -20,7 +20,7 @@ import ( "fmt" "os" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/utils" ) @@ -45,7 +45,7 @@ func main() { utils.Exit1(usage) } - client, err := plugin_client.NewClient() + client, err := client.NewClient() if err != nil { utils.Exit1(fmt.Sprintf("Unable to initialize service catalog client (%s)", err)) } diff --git a/plugin/cmd/kubectl/plan/plan.go b/plugin/cmd/kubectl/plan/plan.go index 55925a2249b..3218996c737 100644 --- a/plugin/cmd/kubectl/plan/plan.go +++ b/plugin/cmd/kubectl/plan/plan.go @@ -20,7 +20,7 @@ import ( "fmt" "os" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/utils" ) @@ -41,7 +41,7 @@ func main() { utils.Exit1(usage) } - client, err := plugin_client.NewClient() + client, err := client.NewClient() if err != nil { utils.Exit1(fmt.Sprintf("Unable to initialize service catalog client (%s)", err)) } diff --git a/plugin/pkg/kubectl/plugin_client/assets/config b/plugin/pkg/kubectl/client/assets/config similarity index 100% rename from plugin/pkg/kubectl/plugin_client/assets/config rename to plugin/pkg/kubectl/client/assets/config diff --git a/plugin/pkg/kubectl/plugin_client/binding.go b/plugin/pkg/kubectl/client/binding.go similarity index 88% rename from plugin/pkg/kubectl/plugin_client/binding.go rename to plugin/pkg/kubectl/client/binding.go index 1fa82be467a..27f82dac7bb 100644 --- a/plugin/pkg/kubectl/plugin_client/binding.go +++ b/plugin/pkg/kubectl/client/binding.go @@ -14,18 +14,20 @@ See the License for the specific language governing permissions and limitations under the License. */ -package plugin_client +package client import ( "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) +//GetBinding retrieves a binding by external name in a given namespace func (c *PluginClient) GetBinding(bindingName, namespace string) (*v1beta1.ServiceBinding, error) { binding, err := c.ScClient.ServicecatalogV1beta1().ServiceBindings(namespace).Get(bindingName, v1.GetOptions{}) return binding, err } +//ListBindings returns a list of all bindings in a namespace func (c *PluginClient) ListBindings(namespace string) (*v1beta1.ServiceBindingList, error) { bindings, err := c.ScClient.ServicecatalogV1beta1().ServiceBindings(namespace).List(v1.ListOptions{}) return bindings, err diff --git a/plugin/pkg/kubectl/plugin_client/binding_test.go b/plugin/pkg/kubectl/client/binding_test.go similarity index 76% rename from plugin/pkg/kubectl/plugin_client/binding_test.go rename to plugin/pkg/kubectl/client/binding_test.go index 50495f9e104..cf15f381560 100644 --- a/plugin/pkg/kubectl/plugin_client/binding_test.go +++ b/plugin/pkg/kubectl/client/binding_test.go @@ -1,10 +1,26 @@ -package plugin_client_test +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package client_test import ( "errors" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client/fakes" + . "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client/fakes" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" @@ -12,7 +28,7 @@ import ( var _ = Describe("Binding", func() { var ( - client *plugin_client.PluginClient + client *PluginClient err error FakeScClient *fakes.FakeInterface ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface @@ -20,7 +36,7 @@ var _ = Describe("Binding", func() { ) BeforeEach(func() { - client, err = plugin_client.NewClient() + client, err = NewClient() Expect(err).NotTo(HaveOccurred()) FakeScClient = &fakes.FakeInterface{} ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} diff --git a/plugin/pkg/kubectl/plugin_client/broker.go b/plugin/pkg/kubectl/client/broker.go similarity index 91% rename from plugin/pkg/kubectl/plugin_client/broker.go rename to plugin/pkg/kubectl/client/broker.go index 922c94f0938..4c64723fd12 100644 --- a/plugin/pkg/kubectl/plugin_client/broker.go +++ b/plugin/pkg/kubectl/client/broker.go @@ -14,18 +14,20 @@ See the License for the specific language governing permissions and limitations under the License. */ -package plugin_client +package client import ( "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) +//GetBroker retrieves a broker by external name func (c *PluginClient) GetBroker(brokerName string) (*v1beta1.ClusterServiceBroker, error) { broker, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceBrokers().Get(brokerName, v1.GetOptions{}) return broker, err } +//ListBrokers returns a list of all brokers func (c *PluginClient) ListBrokers() (*v1beta1.ClusterServiceBrokerList, error) { brokers, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceBrokers().List(v1.ListOptions{}) return brokers, err diff --git a/plugin/pkg/kubectl/plugin_client/broker_test.go b/plugin/pkg/kubectl/client/broker_test.go similarity index 73% rename from plugin/pkg/kubectl/plugin_client/broker_test.go rename to plugin/pkg/kubectl/client/broker_test.go index 3af3ee04f35..8d44e69ec93 100644 --- a/plugin/pkg/kubectl/plugin_client/broker_test.go +++ b/plugin/pkg/kubectl/client/broker_test.go @@ -1,10 +1,26 @@ -package plugin_client_test +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package client_test import ( "errors" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client/fakes" + . "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client/fakes" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" @@ -12,7 +28,7 @@ import ( var _ = Describe("Broker", func() { var ( - client *plugin_client.PluginClient + client *PluginClient err error FakeScClient *fakes.FakeInterface ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface @@ -20,7 +36,7 @@ var _ = Describe("Broker", func() { ) BeforeEach(func() { - client, err = plugin_client.NewClient() + client, err = NewClient() Expect(err).NotTo(HaveOccurred()) FakeScClient = &fakes.FakeInterface{} ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} diff --git a/plugin/pkg/kubectl/plugin_client/class.go b/plugin/pkg/kubectl/client/class.go similarity index 90% rename from plugin/pkg/kubectl/plugin_client/class.go rename to plugin/pkg/kubectl/client/class.go index 8b229d2294f..13ec0e4e227 100644 --- a/plugin/pkg/kubectl/plugin_client/class.go +++ b/plugin/pkg/kubectl/client/class.go @@ -14,18 +14,20 @@ See the License for the specific language governing permissions and limitations under the License. */ -package plugin_client +package client import ( "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) +//GetClass retrieves a class by external name func (c *PluginClient) GetClass(className string) (*v1beta1.ClusterServiceClass, error) { class, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceClasses().Get(className, v1.GetOptions{}) return class, err } +//ListClasses returns a list of all service classes func (c *PluginClient) ListClasses() (*v1beta1.ClusterServiceClassList, error) { classes, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceClasses().List(v1.ListOptions{}) return classes, err diff --git a/plugin/pkg/kubectl/plugin_client/class_test.go b/plugin/pkg/kubectl/client/class_test.go similarity index 73% rename from plugin/pkg/kubectl/plugin_client/class_test.go rename to plugin/pkg/kubectl/client/class_test.go index 87e1aa04075..984ea08c953 100644 --- a/plugin/pkg/kubectl/plugin_client/class_test.go +++ b/plugin/pkg/kubectl/client/class_test.go @@ -1,10 +1,26 @@ -package plugin_client_test +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package client_test import ( "errors" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client/fakes" + . "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client/fakes" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" @@ -12,7 +28,7 @@ import ( var _ = Describe("Class", func() { var ( - client *plugin_client.PluginClient + client *PluginClient err error FakeScClient *fakes.FakeInterface ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface @@ -20,7 +36,7 @@ var _ = Describe("Class", func() { ) BeforeEach(func() { - client, err = plugin_client.NewClient() + client, err = NewClient() Expect(err).NotTo(HaveOccurred()) FakeScClient = &fakes.FakeInterface{} ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterservicebroker_interface.go b/plugin/pkg/kubectl/client/fakes/fake_clusterservicebroker_interface.go similarity index 97% rename from plugin/pkg/kubectl/plugin_client/fakes/fake_clusterservicebroker_interface.go rename to plugin/pkg/kubectl/client/fakes/fake_clusterservicebroker_interface.go index 25b9bf782b0..1fdda52d5e6 100644 --- a/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterservicebroker_interface.go +++ b/plugin/pkg/kubectl/client/fakes/fake_clusterservicebroker_interface.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + // Code generated by counterfeiter. DO NOT EDIT. package fakes diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceclass_interface.go b/plugin/pkg/kubectl/client/fakes/fake_clusterserviceclass_interface.go similarity index 97% rename from plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceclass_interface.go rename to plugin/pkg/kubectl/client/fakes/fake_clusterserviceclass_interface.go index 608c065f25e..b3df37f4623 100644 --- a/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceclass_interface.go +++ b/plugin/pkg/kubectl/client/fakes/fake_clusterserviceclass_interface.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + // Code generated by counterfeiter. DO NOT EDIT. package fakes diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceplan_interface.go b/plugin/pkg/kubectl/client/fakes/fake_clusterserviceplan_interface.go similarity index 97% rename from plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceplan_interface.go rename to plugin/pkg/kubectl/client/fakes/fake_clusterserviceplan_interface.go index 8bd999be7a6..2347fd00040 100644 --- a/plugin/pkg/kubectl/plugin_client/fakes/fake_clusterserviceplan_interface.go +++ b/plugin/pkg/kubectl/client/fakes/fake_clusterserviceplan_interface.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + // Code generated by counterfeiter. DO NOT EDIT. package fakes diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_interface.go b/plugin/pkg/kubectl/client/fakes/fake_interface.go similarity index 92% rename from plugin/pkg/kubectl/plugin_client/fakes/fake_interface.go rename to plugin/pkg/kubectl/client/fakes/fake_interface.go index 67ae0469cf9..f7bba48c59a 100644 --- a/plugin/pkg/kubectl/plugin_client/fakes/fake_interface.go +++ b/plugin/pkg/kubectl/client/fakes/fake_interface.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + // Code generated by counterfeiter. DO NOT EDIT. package fakes diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_servicebinding_interface.go b/plugin/pkg/kubectl/client/fakes/fake_servicebinding_interface.go similarity index 97% rename from plugin/pkg/kubectl/plugin_client/fakes/fake_servicebinding_interface.go rename to plugin/pkg/kubectl/client/fakes/fake_servicebinding_interface.go index d0e41987177..88cf2249ad2 100644 --- a/plugin/pkg/kubectl/plugin_client/fakes/fake_servicebinding_interface.go +++ b/plugin/pkg/kubectl/client/fakes/fake_servicebinding_interface.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + // Code generated by counterfeiter. DO NOT EDIT. package fakes diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_servicecatalogv1beta1_interface.go b/plugin/pkg/kubectl/client/fakes/fake_servicecatalogv1beta1_interface.go similarity index 95% rename from plugin/pkg/kubectl/plugin_client/fakes/fake_servicecatalogv1beta1_interface.go rename to plugin/pkg/kubectl/client/fakes/fake_servicecatalogv1beta1_interface.go index d5fda56e4ab..687b8ae6368 100644 --- a/plugin/pkg/kubectl/plugin_client/fakes/fake_servicecatalogv1beta1_interface.go +++ b/plugin/pkg/kubectl/client/fakes/fake_servicecatalogv1beta1_interface.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + // Code generated by counterfeiter. DO NOT EDIT. package fakes diff --git a/plugin/pkg/kubectl/plugin_client/fakes/fake_serviceinstance_interface.go b/plugin/pkg/kubectl/client/fakes/fake_serviceinstance_interface.go similarity index 97% rename from plugin/pkg/kubectl/plugin_client/fakes/fake_serviceinstance_interface.go rename to plugin/pkg/kubectl/client/fakes/fake_serviceinstance_interface.go index 7f7a7e5cad2..e6254dbb175 100644 --- a/plugin/pkg/kubectl/plugin_client/fakes/fake_serviceinstance_interface.go +++ b/plugin/pkg/kubectl/client/fakes/fake_serviceinstance_interface.go @@ -1,3 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + // Code generated by counterfeiter. DO NOT EDIT. package fakes diff --git a/plugin/pkg/kubectl/plugin_client/instance.go b/plugin/pkg/kubectl/client/instance.go similarity index 87% rename from plugin/pkg/kubectl/plugin_client/instance.go rename to plugin/pkg/kubectl/client/instance.go index fecc0a2a93a..6288f83898e 100644 --- a/plugin/pkg/kubectl/plugin_client/instance.go +++ b/plugin/pkg/kubectl/client/instance.go @@ -14,18 +14,20 @@ See the License for the specific language governing permissions and limitations under the License. */ -package plugin_client +package client import ( "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) +//GetInstance retrieves a service instance by external name in a given namespace func (c *PluginClient) GetInstance(instanceName, namespace string) (*v1beta1.ServiceInstance, error) { instance, err := c.ScClient.ServicecatalogV1beta1().ServiceInstances(namespace).Get(instanceName, v1.GetOptions{}) return instance, err } +//ListInstances returns all service instances in a given namespace func (c *PluginClient) ListInstances(namespace string) (*v1beta1.ServiceInstanceList, error) { instances, err := c.ScClient.ServicecatalogV1beta1().ServiceInstances(namespace).List(v1.ListOptions{}) return instances, err diff --git a/plugin/pkg/kubectl/plugin_client/instance_test.go b/plugin/pkg/kubectl/client/instance_test.go similarity index 76% rename from plugin/pkg/kubectl/plugin_client/instance_test.go rename to plugin/pkg/kubectl/client/instance_test.go index 1c3b58263d5..5b2bb13a6ee 100644 --- a/plugin/pkg/kubectl/plugin_client/instance_test.go +++ b/plugin/pkg/kubectl/client/instance_test.go @@ -1,10 +1,26 @@ -package plugin_client_test +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package client_test import ( "errors" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client/fakes" + . "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client/fakes" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" @@ -12,7 +28,7 @@ import ( var _ = Describe("Instances", func() { var ( - client *plugin_client.PluginClient + client *PluginClient err error FakeScClient *fakes.FakeInterface ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface @@ -20,7 +36,7 @@ var _ = Describe("Instances", func() { ) BeforeEach(func() { - client, err = plugin_client.NewClient() + client, err = NewClient() Expect(err).NotTo(HaveOccurred()) FakeScClient = &fakes.FakeInterface{} ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} diff --git a/plugin/pkg/kubectl/plugin_client/plan.go b/plugin/pkg/kubectl/client/plan.go similarity index 92% rename from plugin/pkg/kubectl/plugin_client/plan.go rename to plugin/pkg/kubectl/client/plan.go index c60e4565ed1..1d7e0478a44 100644 --- a/plugin/pkg/kubectl/plugin_client/plan.go +++ b/plugin/pkg/kubectl/client/plan.go @@ -14,18 +14,20 @@ See the License for the specific language governing permissions and limitations under the License. */ -package plugin_client +package client import ( "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) +//GetPlan retrieves a plan by external name func (c *PluginClient) GetPlan(planName string) (*v1beta1.ClusterServicePlan, error) { plan, err := c.ScClient.ServicecatalogV1beta1().ClusterServicePlans().Get(planName, v1.GetOptions{}) return plan, err } +//ListPlans lists all service plans func (c *PluginClient) ListPlans() (*v1beta1.ClusterServicePlanList, error) { plans, err := c.ScClient.ServicecatalogV1beta1().ClusterServicePlans().List(v1.ListOptions{}) return plans, err diff --git a/plugin/pkg/kubectl/plugin_client/plan_test.go b/plugin/pkg/kubectl/client/plan_test.go similarity index 72% rename from plugin/pkg/kubectl/plugin_client/plan_test.go rename to plugin/pkg/kubectl/client/plan_test.go index 205eddf7853..a84586a1cef 100644 --- a/plugin/pkg/kubectl/plugin_client/plan_test.go +++ b/plugin/pkg/kubectl/client/plan_test.go @@ -1,10 +1,26 @@ -package plugin_client_test +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package client_test import ( "errors" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/plugin_client/fakes" + . "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" + "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client/fakes" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" @@ -12,7 +28,7 @@ import ( var _ = Describe("Plan", func() { var ( - client *plugin_client.PluginClient + client *PluginClient err error FakeScClient *fakes.FakeInterface ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface @@ -20,7 +36,7 @@ var _ = Describe("Plan", func() { ) BeforeEach(func() { - client, err = plugin_client.NewClient() + client, err = NewClient() Expect(err).NotTo(HaveOccurred()) FakeScClient = &fakes.FakeInterface{} ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} diff --git a/plugin/pkg/kubectl/plugin_client/plugin_client.go b/plugin/pkg/kubectl/client/plugin_client.go similarity index 89% rename from plugin/pkg/kubectl/plugin_client/plugin_client.go rename to plugin/pkg/kubectl/client/plugin_client.go index b76bb80f6ca..ef2d49e3010 100644 --- a/plugin/pkg/kubectl/plugin_client/plugin_client.go +++ b/plugin/pkg/kubectl/client/plugin_client.go @@ -14,11 +14,10 @@ See the License for the specific language governing permissions and limitations under the License. */ -package plugin_client +package client import ( "encoding/json" - "errors" "fmt" "os" "time" @@ -29,6 +28,8 @@ import ( "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" ) +//PluginClient is a client for interacting with the service catalog +//via generated clientset interface type PluginClient struct { ScClient clientset.Interface Config *restclient.Config @@ -57,22 +58,22 @@ func NewClient() (*PluginClient, error) { } if len(kubeconfig) == 0 { - return nil, errors.New(fmt.Sprintf("error iniializing client. The KUBECONFIG environment variable must be defined.")) + return nil, fmt.Errorf("error iniializing client. The KUBECONFIG environment variable must be defined") } clientConfig, _, err := clientFromConfig(kubeconfig) if err != nil { - return nil, errors.New(fmt.Sprintf("error obtaining client configuration: %v", err)) + return nil, fmt.Errorf("error obtaining client configuration: %v", err) } err = applyGlobalOptionsToConfig(clientConfig) if err != nil { - return nil, errors.New(fmt.Sprintf("error processing global plugin options: %v", err)) + return nil, fmt.Errorf("error processing global plugin options: %v", err) } c, err := clientset.NewForConfig(clientConfig) if err != nil { - return nil, errors.New(fmt.Sprintf("error obtaining a client from existing configuration: %v", err)) + return nil, fmt.Errorf("error obtaining a client from existing configuration: %v", err) } pluginClient := PluginClient{c, clientConfig} @@ -116,7 +117,7 @@ func applyGlobalOptionsToConfig(config *restclient.Config) error { impersonateGroup := []string{} err := json.Unmarshal([]byte(impersonateGroupRaw), &impersonateGroup) if err != nil { - return errors.New(fmt.Sprintf("error parsing global option %q: %v", "--as-group", err)) + return fmt.Errorf("error parsing global option %q: %v", "--as-group", err) } if len(impersonateGroup) > 0 { config.Impersonate.Groups = impersonateGroup @@ -162,7 +163,7 @@ func applyGlobalOptionsToConfig(config *restclient.Config) error { if len(requestTimeout) > 0 { t, err := time.ParseDuration(requestTimeout) if err != nil { - return errors.New(fmt.Sprintf("%v", err)) + return fmt.Errorf("%v", err) } config.Timeout = t } diff --git a/plugin/pkg/kubectl/client/plugin_client_suite_test.go b/plugin/pkg/kubectl/client/plugin_client_suite_test.go new file mode 100644 index 00000000000..442bbd8f2f6 --- /dev/null +++ b/plugin/pkg/kubectl/client/plugin_client_suite_test.go @@ -0,0 +1,35 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package client_test + +import ( + "os" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" + + "testing" +) + +func TestPluginClient(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "PluginClient Suite") +} + +var _ = BeforeEach(func() { + os.Setenv("KUBECTL_PLUGINS_GLOBAL_FLAG_KUBECONFIG", "assets/config") +}) diff --git a/plugin/pkg/kubectl/plugin_client/plugin_client_suite_test.go b/plugin/pkg/kubectl/plugin_client/plugin_client_suite_test.go deleted file mode 100644 index f2419c35a3f..00000000000 --- a/plugin/pkg/kubectl/plugin_client/plugin_client_suite_test.go +++ /dev/null @@ -1,19 +0,0 @@ -package plugin_client_test - -import ( - "os" - - . "github.com/onsi/ginkgo" - . "github.com/onsi/gomega" - - "testing" -) - -func TestPluginClient(t *testing.T) { - RegisterFailHandler(Fail) - RunSpecs(t, "PluginClient Suite") -} - -var _ = BeforeEach(func() { - os.Setenv("KUBECTL_PLUGINS_GLOBAL_FLAG_KUBECONFIG", "assets/config") -}) diff --git a/plugin/pkg/kubectl/utils/utils.go b/plugin/pkg/kubectl/utils/utils.go index 3fb89533f96..e97204df5e1 100644 --- a/plugin/pkg/kubectl/utils/utils.go +++ b/plugin/pkg/kubectl/utils/utils.go @@ -184,6 +184,8 @@ func Namespace() string { return os.Getenv("KUBECTL_PLUGINS_CURRENT_NAMESPACE") } +//CheckNamespaceExists checks if a specified namespace exists +//the targeted cluster func CheckNamespaceExists(ns string, config *restclient.Config) { fmt.Printf("Looking up Namespace %s...\n", Entity(ns)) kubeClient, err := kclientset.NewForConfig(config) @@ -196,6 +198,8 @@ func CheckNamespaceExists(ns string, config *restclient.Config) { } } +//Loglevel returns the loglevel value set by the calling +//kubectl plugin framework func Loglevel() (flagName, flagValue string) { kubeLoglevel := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_V") otherLoglevel := os.Getenv("KUBECTL_PLUGINS_GLOBAL_FLAG_LOGLEVEL") From 3ca40a843814675dc7cb59024fb4c3809fce7457 Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Mon, 18 Dec 2017 15:18:16 -0800 Subject: [PATCH 20/24] Formatting changes --- plugin/cmd/kubectl/binding/binding.go | 8 ++++---- plugin/cmd/kubectl/broker/broker.go | 6 +++--- plugin/cmd/kubectl/class/class.go | 6 +++--- plugin/cmd/kubectl/instance/instance.go | 6 +++--- plugin/cmd/kubectl/plan/plan.go | 8 ++++---- plugin/pkg/kubectl/client/binding.go | 6 +++--- plugin/pkg/kubectl/client/broker.go | 6 +++--- plugin/pkg/kubectl/client/broker_test.go | 2 +- plugin/pkg/kubectl/client/class.go | 6 +++--- plugin/pkg/kubectl/client/class_test.go | 2 +- plugin/pkg/kubectl/client/instance.go | 4 ++-- plugin/pkg/kubectl/client/instance_test.go | 2 +- plugin/pkg/kubectl/client/plan.go | 6 +++--- plugin/pkg/kubectl/client/plan_test.go | 2 +- plugin/pkg/kubectl/client/plugin_client.go | 6 +++--- plugin/pkg/kubectl/utils/table_printer.go | 2 +- plugin/pkg/kubectl/utils/ui.go | 2 +- plugin/pkg/kubectl/utils/utils.go | 2 +- 18 files changed, 41 insertions(+), 41 deletions(-) diff --git a/plugin/cmd/kubectl/binding/binding.go b/plugin/cmd/kubectl/binding/binding.go index ea07f777bc9..35e08a45f6b 100644 --- a/plugin/cmd/kubectl/binding/binding.go +++ b/plugin/cmd/kubectl/binding/binding.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. @@ -37,7 +37,7 @@ const listUsage = `Usage: ` const getUsage = `Usage: - kubectl plugin binding get NAMESPACE INSTANCENAME + kubectl plugin binding get NAMESPACE INSTANCE_NAME ` func main() { @@ -62,8 +62,8 @@ func main() { table := utils.NewTable("BINDING NAME", "NAMESPACE", "INSTANCE NAME") for _, v := range bindings.Items { table.AddRow(v.Name, v.Namespace, v.Spec.ServiceInstanceRef.Name) - err = table.Print() } + err = table.Print() if err != nil { utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) } @@ -77,7 +77,7 @@ func main() { if err != nil { utils.Exit1(fmt.Sprintf("Unable to find binding %s in namespae %s (%s)", bindingName, namespace, err)) } - table := utils.NewTable("BINDINGNAME", "NAMESPACE", "INSTANCE NAME") + table := utils.NewTable("BINDING NAME", "NAMESPACE", "INSTANCE NAME") table.AddRow(binding.Name, binding.Namespace, binding.Spec.ServiceInstanceRef.Name) err = table.Print() } else { diff --git a/plugin/cmd/kubectl/broker/broker.go b/plugin/cmd/kubectl/broker/broker.go index eea6395c3f6..1659ecd8bd7 100644 --- a/plugin/cmd/kubectl/broker/broker.go +++ b/plugin/cmd/kubectl/broker/broker.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. @@ -33,7 +33,7 @@ Available subcommands: ` const getUsage = `Usage: - kubectl plugin broker get BROKERNAME + kubectl plugin broker get BROKER_NAME ` func main() { @@ -54,8 +54,8 @@ func main() { table := utils.NewTable("BROKER NAME", "NAMESPACE", "URL") for _, v := range brokers.Items { table.AddRow(v.Name, v.Namespace, v.Spec.URL) - err = table.Print() } + err = table.Print() if err != nil { utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) } diff --git a/plugin/cmd/kubectl/class/class.go b/plugin/cmd/kubectl/class/class.go index 083d932050b..47b393961f6 100644 --- a/plugin/cmd/kubectl/class/class.go +++ b/plugin/cmd/kubectl/class/class.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. @@ -33,7 +33,7 @@ Available subcommands: ` const getUsage = `Usage: - kubectl plugin class get CLASSNAME + kubectl plugin class get CLASS_NAME ` func main() { @@ -54,8 +54,8 @@ func main() { table := utils.NewTable("CLASS NAME", "NAMESPACE", "BROKER NAME") for _, v := range classes.Items { table.AddRow(v.Name, v.Namespace, v.Spec.ClusterServiceBrokerName) - err = table.Print() } + err = table.Print() if err != nil { utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) } diff --git a/plugin/cmd/kubectl/instance/instance.go b/plugin/cmd/kubectl/instance/instance.go index 0b4ee5dca31..e10dca70f83 100644 --- a/plugin/cmd/kubectl/instance/instance.go +++ b/plugin/cmd/kubectl/instance/instance.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. @@ -37,7 +37,7 @@ const listUsage = `Usage: ` const getUsage = `Usage: - kubectl plugin instance get NAMESPACE INSTANCENAME + kubectl plugin instance get NAMESPACE INSTANCE_NAME ` func main() { @@ -62,8 +62,8 @@ func main() { table := utils.NewTable("INSTANCE NAME", "NAMESPACE", "CLASS NAME", "PLAN NAME") for _, v := range instances.Items { table.AddRow(v.Name, v.Namespace, v.Spec.ClusterServiceClassRef.Name, v.Spec.ClusterServicePlanRef.Name) - err = table.Print() } + err = table.Print() if err != nil { utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) } diff --git a/plugin/cmd/kubectl/plan/plan.go b/plugin/cmd/kubectl/plan/plan.go index 3218996c737..8fd890af4a3 100644 --- a/plugin/cmd/kubectl/plan/plan.go +++ b/plugin/cmd/kubectl/plan/plan.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. @@ -33,7 +33,7 @@ Available subcommands: ` const getUsage = `Usage: - kubectl plugin plan get PLANNAME + kubectl plugin plan get PLAN_NAME ` func main() { @@ -53,9 +53,9 @@ func main() { table := utils.NewTable("PLAN NAME", "DESCRIPTION", "BROKER NAME") for _, v := range plans.Items { - table.AddRow(v.Name, v.Spec.Description, v.Spec.ClusterServiceBrokerName) - err = table.Print() + table.AddRow(v.Spec.ExternalName, v.Spec.Description, v.Spec.ClusterServiceBrokerName) } + err = table.Print() if err != nil { utils.Exit1(fmt.Sprintf("Error printing result (%s)", err)) } diff --git a/plugin/pkg/kubectl/client/binding.go b/plugin/pkg/kubectl/client/binding.go index 27f82dac7bb..1cbbe3f0f6a 100644 --- a/plugin/pkg/kubectl/client/binding.go +++ b/plugin/pkg/kubectl/client/binding.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. @@ -21,13 +21,13 @@ import ( v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) -//GetBinding retrieves a binding by external name in a given namespace +// GetBinding retrieves a binding by external name in a given namespace func (c *PluginClient) GetBinding(bindingName, namespace string) (*v1beta1.ServiceBinding, error) { binding, err := c.ScClient.ServicecatalogV1beta1().ServiceBindings(namespace).Get(bindingName, v1.GetOptions{}) return binding, err } -//ListBindings returns a list of all bindings in a namespace +// ListBindings returns a list of all bindings in a namespace func (c *PluginClient) ListBindings(namespace string) (*v1beta1.ServiceBindingList, error) { bindings, err := c.ScClient.ServicecatalogV1beta1().ServiceBindings(namespace).List(v1.ListOptions{}) return bindings, err diff --git a/plugin/pkg/kubectl/client/broker.go b/plugin/pkg/kubectl/client/broker.go index 4c64723fd12..81dca517a3f 100644 --- a/plugin/pkg/kubectl/client/broker.go +++ b/plugin/pkg/kubectl/client/broker.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. @@ -21,13 +21,13 @@ import ( v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) -//GetBroker retrieves a broker by external name +// GetBroker retrieves a broker by external name func (c *PluginClient) GetBroker(brokerName string) (*v1beta1.ClusterServiceBroker, error) { broker, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceBrokers().Get(brokerName, v1.GetOptions{}) return broker, err } -//ListBrokers returns a list of all brokers +// ListBrokers returns a list of all brokers func (c *PluginClient) ListBrokers() (*v1beta1.ClusterServiceBrokerList, error) { brokers, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceBrokers().List(v1.ListOptions{}) return brokers, err diff --git a/plugin/pkg/kubectl/client/broker_test.go b/plugin/pkg/kubectl/client/broker_test.go index 8d44e69ec93..62613af53be 100644 --- a/plugin/pkg/kubectl/client/broker_test.go +++ b/plugin/pkg/kubectl/client/broker_test.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. diff --git a/plugin/pkg/kubectl/client/class.go b/plugin/pkg/kubectl/client/class.go index 13ec0e4e227..ec948072148 100644 --- a/plugin/pkg/kubectl/client/class.go +++ b/plugin/pkg/kubectl/client/class.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. @@ -21,13 +21,13 @@ import ( v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) -//GetClass retrieves a class by external name +// GetClass retrieves a class by external name func (c *PluginClient) GetClass(className string) (*v1beta1.ClusterServiceClass, error) { class, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceClasses().Get(className, v1.GetOptions{}) return class, err } -//ListClasses returns a list of all service classes +// ListClasses returns a list of all service classes func (c *PluginClient) ListClasses() (*v1beta1.ClusterServiceClassList, error) { classes, err := c.ScClient.ServicecatalogV1beta1().ClusterServiceClasses().List(v1.ListOptions{}) return classes, err diff --git a/plugin/pkg/kubectl/client/class_test.go b/plugin/pkg/kubectl/client/class_test.go index 984ea08c953..f51bd24a881 100644 --- a/plugin/pkg/kubectl/client/class_test.go +++ b/plugin/pkg/kubectl/client/class_test.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. diff --git a/plugin/pkg/kubectl/client/instance.go b/plugin/pkg/kubectl/client/instance.go index 6288f83898e..d5a89361fc3 100644 --- a/plugin/pkg/kubectl/client/instance.go +++ b/plugin/pkg/kubectl/client/instance.go @@ -21,13 +21,13 @@ import ( v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) -//GetInstance retrieves a service instance by external name in a given namespace +// GetInstance retrieves a service instance by external name in a given namespace func (c *PluginClient) GetInstance(instanceName, namespace string) (*v1beta1.ServiceInstance, error) { instance, err := c.ScClient.ServicecatalogV1beta1().ServiceInstances(namespace).Get(instanceName, v1.GetOptions{}) return instance, err } -//ListInstances returns all service instances in a given namespace +// ListInstances returns all service instances in a given namespace func (c *PluginClient) ListInstances(namespace string) (*v1beta1.ServiceInstanceList, error) { instances, err := c.ScClient.ServicecatalogV1beta1().ServiceInstances(namespace).List(v1.ListOptions{}) return instances, err diff --git a/plugin/pkg/kubectl/client/instance_test.go b/plugin/pkg/kubectl/client/instance_test.go index 5b2bb13a6ee..9b590e1aa78 100644 --- a/plugin/pkg/kubectl/client/instance_test.go +++ b/plugin/pkg/kubectl/client/instance_test.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. diff --git a/plugin/pkg/kubectl/client/plan.go b/plugin/pkg/kubectl/client/plan.go index 1d7e0478a44..1441d3af417 100644 --- a/plugin/pkg/kubectl/client/plan.go +++ b/plugin/pkg/kubectl/client/plan.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. @@ -21,13 +21,13 @@ import ( v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) -//GetPlan retrieves a plan by external name +// GetPlan retrieves a plan by external name func (c *PluginClient) GetPlan(planName string) (*v1beta1.ClusterServicePlan, error) { plan, err := c.ScClient.ServicecatalogV1beta1().ClusterServicePlans().Get(planName, v1.GetOptions{}) return plan, err } -//ListPlans lists all service plans +// ListPlans lists all service plans func (c *PluginClient) ListPlans() (*v1beta1.ClusterServicePlanList, error) { plans, err := c.ScClient.ServicecatalogV1beta1().ClusterServicePlans().List(v1.ListOptions{}) return plans, err diff --git a/plugin/pkg/kubectl/client/plan_test.go b/plugin/pkg/kubectl/client/plan_test.go index a84586a1cef..7af6af3ada0 100644 --- a/plugin/pkg/kubectl/client/plan_test.go +++ b/plugin/pkg/kubectl/client/plan_test.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. diff --git a/plugin/pkg/kubectl/client/plugin_client.go b/plugin/pkg/kubectl/client/plugin_client.go index ef2d49e3010..da341860dcb 100644 --- a/plugin/pkg/kubectl/client/plugin_client.go +++ b/plugin/pkg/kubectl/client/plugin_client.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. @@ -28,8 +28,8 @@ import ( "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" ) -//PluginClient is a client for interacting with the service catalog -//via generated clientset interface +// PluginClient is a client for interacting with the service catalog +// via generated clientset interface type PluginClient struct { ScClient clientset.Interface Config *restclient.Config diff --git a/plugin/pkg/kubectl/utils/table_printer.go b/plugin/pkg/kubectl/utils/table_printer.go index 4f08c3583dd..69492e99ce3 100644 --- a/plugin/pkg/kubectl/utils/table_printer.go +++ b/plugin/pkg/kubectl/utils/table_printer.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. diff --git a/plugin/pkg/kubectl/utils/ui.go b/plugin/pkg/kubectl/utils/ui.go index 531982ff11d..56b9abbc3a2 100644 --- a/plugin/pkg/kubectl/utils/ui.go +++ b/plugin/pkg/kubectl/utils/ui.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. diff --git a/plugin/pkg/kubectl/utils/utils.go b/plugin/pkg/kubectl/utils/utils.go index e97204df5e1..4372cdb2496 100644 --- a/plugin/pkg/kubectl/utils/utils.go +++ b/plugin/pkg/kubectl/utils/utils.go @@ -1,5 +1,5 @@ /* -Copyright 2016 The Kubernetes Authors. +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. From 59c3bc4be4209848368d411cb266ac7054e626fd Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Mon, 15 Jan 2018 17:02:38 -0800 Subject: [PATCH 21/24] update color utils to be platform independent --- plugin/pkg/kubectl/utils/ui.go | 44 ---------------------------- plugin/pkg/kubectl/utils/utils.go | 5 ++-- vendor/github.com/fatih/color | 1 + vendor/github.com/mattn/go-colorable | 1 + vendor/github.com/mattn/go-isatty | 1 + 5 files changed, 6 insertions(+), 46 deletions(-) delete mode 100644 plugin/pkg/kubectl/utils/ui.go create mode 160000 vendor/github.com/fatih/color create mode 160000 vendor/github.com/mattn/go-colorable create mode 160000 vendor/github.com/mattn/go-isatty diff --git a/plugin/pkg/kubectl/utils/ui.go b/plugin/pkg/kubectl/utils/ui.go deleted file mode 100644 index 56b9abbc3a2..00000000000 --- a/plugin/pkg/kubectl/utils/ui.go +++ /dev/null @@ -1,44 +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 utils - -import "fmt" - -// Green will print the specified string in green text -func Green(str string) string { - return fmt.Sprintf("\x1b[32;1m%s\x1b[0m", str) -} - -// Red will print the specified string in red text -func Red(str string) string { - return fmt.Sprintf("\x1b[31;1m%s\x1b[0m", str) -} - -// Entity will print the specified string in bold text -func Entity(str string) string { - return fmt.Sprintf("\x1b[36;1m%s\x1b[0m", str) -} - -// Error will print the specified error string in red text -func Error(msg string) { - fmt.Printf("%s\n\n%s\n\n", Red("ERROR"), msg) -} - -// Ok will print "OK" in green -func Ok() { - fmt.Printf("%s\n\n", Green("OK")) -} diff --git a/plugin/pkg/kubectl/utils/utils.go b/plugin/pkg/kubectl/utils/utils.go index 4372cdb2496..ed5b6b791bf 100644 --- a/plugin/pkg/kubectl/utils/utils.go +++ b/plugin/pkg/kubectl/utils/utils.go @@ -28,6 +28,7 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" kclientset "k8s.io/client-go/kubernetes" + "github.com/fatih/color" "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" ) @@ -187,7 +188,7 @@ func Namespace() string { //CheckNamespaceExists checks if a specified namespace exists //the targeted cluster func CheckNamespaceExists(ns string, config *restclient.Config) { - fmt.Printf("Looking up Namespace %s...\n", Entity(ns)) + fmt.Printf("Looking up Namespace '%s'...\n", ns) kubeClient, err := kclientset.NewForConfig(config) if err != nil { Exit1(fmt.Sprintf("%v", err)) @@ -215,6 +216,6 @@ func Loglevel() (flagName, flagValue string) { // Exit1 will print the specified error string to the screen and // then stop the program, with an exit code of 1 func Exit1(errStr string) { - Error(errStr) + color.Red("Error\n\n%s\n", errStr) os.Exit(1) } diff --git a/vendor/github.com/fatih/color b/vendor/github.com/fatih/color new file mode 160000 index 00000000000..87d4004f2ab --- /dev/null +++ b/vendor/github.com/fatih/color @@ -0,0 +1 @@ +Subproject commit 87d4004f2ab62d0d255e0a38f1680aa534549fe3 diff --git a/vendor/github.com/mattn/go-colorable b/vendor/github.com/mattn/go-colorable new file mode 160000 index 00000000000..ed8eb9e318d --- /dev/null +++ b/vendor/github.com/mattn/go-colorable @@ -0,0 +1 @@ +Subproject commit ed8eb9e318d7a84ce5915b495b7d35e0cfe7b5a8 diff --git a/vendor/github.com/mattn/go-isatty b/vendor/github.com/mattn/go-isatty new file mode 160000 index 00000000000..66b8e73f3f5 --- /dev/null +++ b/vendor/github.com/mattn/go-isatty @@ -0,0 +1 @@ +Subproject commit 66b8e73f3f5cda9f96b69efd03dd3d7fc4a5cdb8 From fa9fbce83ab9a26b1e595d2836e1f2c2a1f88b92 Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Mon, 15 Jan 2018 17:03:09 -0800 Subject: [PATCH 22/24] refactor plugin tests to use generated fakes --- plugin/pkg/kubectl/client/binding_test.go | 71 +- plugin/pkg/kubectl/client/broker_test.go | 68 +- plugin/pkg/kubectl/client/class_test.go | 66 +- .../fake_clusterservicebroker_interface.go | 658 ---------------- .../fake_clusterserviceclass_interface.go | 658 ---------------- .../fake_clusterserviceplan_interface.go | 658 ---------------- .../kubectl/client/fakes/fake_interface.go | 208 ----- .../fakes/fake_servicebinding_interface.go | 658 ---------------- .../fake_servicecatalogv1beta1_interface.go | 380 --------- .../fakes/fake_serviceinstance_interface.go | 724 ------------------ plugin/pkg/kubectl/client/instance_test.go | 72 +- plugin/pkg/kubectl/client/plan_test.go | 69 +- 12 files changed, 202 insertions(+), 4088 deletions(-) delete mode 100644 plugin/pkg/kubectl/client/fakes/fake_clusterservicebroker_interface.go delete mode 100644 plugin/pkg/kubectl/client/fakes/fake_clusterserviceclass_interface.go delete mode 100644 plugin/pkg/kubectl/client/fakes/fake_clusterserviceplan_interface.go delete mode 100644 plugin/pkg/kubectl/client/fakes/fake_interface.go delete mode 100644 plugin/pkg/kubectl/client/fakes/fake_servicebinding_interface.go delete mode 100644 plugin/pkg/kubectl/client/fakes/fake_servicecatalogv1beta1_interface.go delete mode 100644 plugin/pkg/kubectl/client/fakes/fake_serviceinstance_interface.go diff --git a/plugin/pkg/kubectl/client/binding_test.go b/plugin/pkg/kubectl/client/binding_test.go index cf15f381560..f25e1c19db1 100644 --- a/plugin/pkg/kubectl/client/binding_test.go +++ b/plugin/pkg/kubectl/client/binding_test.go @@ -17,10 +17,15 @@ limitations under the License. package client_test import ( - "errors" + "fmt" + + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/fake" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/testing" . "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client/fakes" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" @@ -28,46 +33,48 @@ import ( var _ = Describe("Binding", func() { var ( - client *PluginClient - err error - FakeScClient *fakes.FakeInterface - ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface - ServiceBindings *fakes.FakeServiceBindingInterface + client *PluginClient + err error + svcCatClient *fake.Clientset + sb *v1beta1.ServiceBinding + sb2 *v1beta1.ServiceBinding ) BeforeEach(func() { client, err = NewClient() Expect(err).NotTo(HaveOccurred()) - FakeScClient = &fakes.FakeInterface{} - ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} - ServiceBindings = &fakes.FakeServiceBindingInterface{} - client.ScClient = FakeScClient - FakeScClient.ServicecatalogV1beta1Returns(ServicecatalogV1beta1) - ServicecatalogV1beta1.ServiceBindingsReturns(ServiceBindings) + sb = &v1beta1.ServiceBinding{ObjectMeta: metav1.ObjectMeta{Name: "foobar", Namespace: "foobar_namespace"}} + sb2 = &v1beta1.ServiceBinding{ObjectMeta: metav1.ObjectMeta{Name: "barbaz", Namespace: "foobar_namespace"}} + svcCatClient = fake.NewSimpleClientset(sb, sb2) + client.ScClient = svcCatClient }) Describe("Get", func() { It("Calls the generated v1beta1 List method with the passed in binding and namespace", func() { + bindingName := "foobar" namespace := "foobar_namespace" - bindingName := "potato_binding" - _, err := client.GetBinding(bindingName, namespace) + binding, err := client.GetBinding(bindingName, namespace) Expect(err).NotTo(HaveOccurred()) - Expect(ServicecatalogV1beta1.ServiceBindingsArgsForCall(0)).To(Equal(namespace)) - returnedName, _ := ServiceBindings.GetArgsForCall(0) - Expect(returnedName).To(Equal(bindingName)) - Expect(ServiceBindings.GetCallCount()).To(Equal(1)) + Expect(binding.Name).To(Equal(bindingName)) + + actions := svcCatClient.Actions() + Expect(actions[0].Matches("get", "servicebindings")).To(BeTrue()) + Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(bindingName)) + Expect(actions[0].(testing.GetActionImpl).Namespace).To(Equal(namespace)) }) It("Bubbles up errors", func() { + bindingName := "not_a_real_binding" namespace := "foobar_namespace" - bindingName := "potato_binding" - errorMessage := "binding not found" - ServiceBindings.GetReturns(nil, errors.New(errorMessage)) _, err := client.GetBinding(bindingName, namespace) Expect(err).To(HaveOccurred()) - Expect(ServiceBindings.GetCallCount()).To(Equal(1)) + Expect(err.Error()).Should(ContainSubstring("not found")) + actions := svcCatClient.Actions() + Expect(actions[0].Matches("get", "servicebindings")).To(BeTrue()) + Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(bindingName)) + Expect(actions[0].(testing.GetActionImpl).Namespace).To(Equal(namespace)) }) }) @@ -75,22 +82,26 @@ var _ = Describe("Binding", func() { It("Calls the generated v1beta1 List method with the specified namespace", func() { namespace := "foobar_namespace" - _, err := client.ListBindings(namespace) + bindings, err := client.ListBindings(namespace) Expect(err).NotTo(HaveOccurred()) - Expect(ServicecatalogV1beta1.ServiceBindingsArgsForCall(0)).To(Equal(namespace)) - Expect(ServiceBindings.ListCallCount()).To(Equal(1)) + Expect(bindings.Items).Should(ConsistOf(*sb, *sb2)) + Expect(svcCatClient.Actions()[0].Matches("list", "servicebindings")).To(BeTrue()) }) It("Bubbles up errors", func() { - ServiceBindings.ListReturns(nil, errors.New("foobar")) + badClient := &fake.Clientset{} + errorMessage := "error retrieving list" + badClient.AddReactor("list", "servicebindings", func(action testing.Action) (bool, runtime.Object, error) { + return true, nil, fmt.Errorf(errorMessage) + }) + client.ScClient = badClient namespace := "foobar_namespace" _, err := client.ListBindings(namespace) Expect(err).To(HaveOccurred()) - Expect(err.Error()).Should(ContainSubstring("foobar")) - Expect(ServicecatalogV1beta1.ServiceBindingsArgsForCall(0)).To(Equal(namespace)) - Expect(ServiceBindings.ListCallCount()).To(Equal(1)) + Expect(err.Error()).Should(ContainSubstring(errorMessage)) + Expect(badClient.Actions()[0].Matches("list", "servicebindings")).To(BeTrue()) }) }) }) diff --git a/plugin/pkg/kubectl/client/broker_test.go b/plugin/pkg/kubectl/client/broker_test.go index 62613af53be..6400071bf16 100644 --- a/plugin/pkg/kubectl/client/broker_test.go +++ b/plugin/pkg/kubectl/client/broker_test.go @@ -17,10 +17,15 @@ limitations under the License. package client_test import ( - "errors" + "fmt" + + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/fake" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/testing" . "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client/fakes" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" @@ -28,62 +33,69 @@ import ( var _ = Describe("Broker", func() { var ( - client *PluginClient - err error - FakeScClient *fakes.FakeInterface - ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface - ClusterServiceBrokers *fakes.FakeClusterServiceBrokerInterface + client *PluginClient + err error + svcCatClient *fake.Clientset + sb *v1beta1.ClusterServiceBroker + sb2 *v1beta1.ClusterServiceBroker ) BeforeEach(func() { client, err = NewClient() Expect(err).NotTo(HaveOccurred()) - FakeScClient = &fakes.FakeInterface{} - ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} - ClusterServiceBrokers = &fakes.FakeClusterServiceBrokerInterface{} - client.ScClient = FakeScClient - FakeScClient.ServicecatalogV1beta1Returns(ServicecatalogV1beta1) - ServicecatalogV1beta1.ClusterServiceBrokersReturns(ClusterServiceBrokers) + sb = &v1beta1.ClusterServiceBroker{ObjectMeta: metav1.ObjectMeta{Name: "foobar"}} + sb2 = &v1beta1.ClusterServiceBroker{ObjectMeta: metav1.ObjectMeta{Name: "barbaz"}} + svcCatClient = fake.NewSimpleClientset(sb, sb2) + client.ScClient = svcCatClient }) Describe("Get", func() { It("Calls the generated v1beta1 List method with the passed in broker", func() { brokerName := "foobar" - _, err = client.GetBroker(brokerName) - Expect(ClusterServiceBrokers.GetCallCount()).To(Equal(1)) - name, _ := ClusterServiceBrokers.GetArgsForCall(0) - Expect(name).To(Equal(brokerName)) + broker, err := client.GetBroker(brokerName) + + Expect(err).NotTo(HaveOccurred()) + Expect(broker.Name).To(Equal(brokerName)) + actions := svcCatClient.Actions() + Expect(actions[0].Matches("get", "clusterservicebrokers")).To(BeTrue()) + Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(brokerName)) }) It("Bubbles up errors", func() { - errorMessage := "broker not found" - ClusterServiceBrokers.GetReturns(nil, errors.New(errorMessage)) + brokerName := "banana" - _, err := client.GetBroker("banana") + broker, err := client.GetBroker(brokerName) + Expect(broker).To(BeNil()) Expect(err).To(HaveOccurred()) - Expect(err.Error()).Should(ContainSubstring(errorMessage)) - Expect(ClusterServiceBrokers.GetCallCount()).To(Equal(1)) + Expect(err.Error()).Should(ContainSubstring("not found")) + actions := svcCatClient.Actions() + Expect(actions[0].Matches("get", "clusterservicebrokers")).To(BeTrue()) + Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(brokerName)) }) }) Describe("List", func() { It("Calls the generated v1beta1 List method", func() { - _, err := client.ListBrokers() + brokers, err := client.ListBrokers() Expect(err).NotTo(HaveOccurred()) - Expect(ClusterServiceBrokers.ListCallCount()).To(Equal(1)) + Expect(brokers.Items).Should(ConsistOf(*sb, *sb2)) + Expect(svcCatClient.Actions()[0].Matches("list", "clusterservicebrokers")).To(BeTrue()) }) It("Bubbles up errors", func() { - errorMessage := "foobar" - ClusterServiceBrokers.ListReturns(nil, errors.New(errorMessage)) - + badClient := &fake.Clientset{} + errorMessage := "error retrieving list" + badClient.AddReactor("list", "clusterservicebrokers", func(action testing.Action) (bool, runtime.Object, error) { + return true, nil, fmt.Errorf(errorMessage) + }) + client.ScClient = badClient _, err := client.ListBrokers() Expect(err).To(HaveOccurred()) Expect(err.Error()).Should(ContainSubstring(errorMessage)) - Expect(ClusterServiceBrokers.ListCallCount()).To(Equal(1)) + Expect(badClient.Actions()[0].Matches("list", "clusterservicebrokers")).To(BeTrue()) }) }) }) diff --git a/plugin/pkg/kubectl/client/class_test.go b/plugin/pkg/kubectl/client/class_test.go index f51bd24a881..798b45704ce 100644 --- a/plugin/pkg/kubectl/client/class_test.go +++ b/plugin/pkg/kubectl/client/class_test.go @@ -17,10 +17,15 @@ limitations under the License. package client_test import ( - "errors" + "fmt" + + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/fake" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/testing" . "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client/fakes" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" @@ -28,62 +33,69 @@ import ( var _ = Describe("Class", func() { var ( - client *PluginClient - err error - FakeScClient *fakes.FakeInterface - ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface - ClusterServiceClasses *fakes.FakeClusterServiceClassInterface + client *PluginClient + err error + svcCatClient *fake.Clientset + sc *v1beta1.ClusterServiceClass + sc2 *v1beta1.ClusterServiceClass ) BeforeEach(func() { client, err = NewClient() Expect(err).NotTo(HaveOccurred()) - FakeScClient = &fakes.FakeInterface{} - ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} - ClusterServiceClasses = &fakes.FakeClusterServiceClassInterface{} - client.ScClient = FakeScClient - FakeScClient.ServicecatalogV1beta1Returns(ServicecatalogV1beta1) - ServicecatalogV1beta1.ClusterServiceClassesReturns(ClusterServiceClasses) + sc = &v1beta1.ClusterServiceClass{ObjectMeta: metav1.ObjectMeta{Name: "foobar"}} + sc2 = &v1beta1.ClusterServiceClass{ObjectMeta: metav1.ObjectMeta{Name: "barbaz"}} + svcCatClient = fake.NewSimpleClientset(sc, sc2) + client.ScClient = svcCatClient }) Describe("Get", func() { It("Calls the generated v1beta1 List method with the passed in class", func() { className := "foobar" - _, err = client.GetClass(className) + class, err := client.GetClass(className) - Expect(ClusterServiceClasses.GetCallCount()).To(Equal(1)) - name, _ := ClusterServiceClasses.GetArgsForCall(0) - Expect(name).To(Equal(className)) + Expect(err).NotTo(HaveOccurred()) + Expect(class.Name).To(Equal(className)) + actions := svcCatClient.Actions() + Expect(actions[0].Matches("get", "clusterserviceclasses")).To(BeTrue()) + Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(className)) }) It("Bubbles up errors", func() { - errorMessage := "class not found" - ClusterServiceClasses.GetReturns(nil, errors.New(errorMessage)) + className := "banana" - _, err := client.GetClass("banana") + class, err := client.GetClass(className) + Expect(class).To(BeNil()) Expect(err).To(HaveOccurred()) - Expect(err.Error()).Should(ContainSubstring(errorMessage)) - Expect(ClusterServiceClasses.GetCallCount()).To(Equal(1)) + Expect(err.Error()).Should(ContainSubstring("not found")) + actions := svcCatClient.Actions() + Expect(actions[0].Matches("get", "clusterserviceclasses")).To(BeTrue()) + Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(className)) }) }) Describe("List", func() { It("Calls the generated v1beta1 List method", func() { - _, err := client.ListClasses() + classes, err := client.ListClasses() Expect(err).NotTo(HaveOccurred()) - Expect(ClusterServiceClasses.ListCallCount()).To(Equal(1)) + Expect(classes.Items).Should(ConsistOf(*sc, *sc2)) + Expect(svcCatClient.Actions()[0].Matches("list", "clusterserviceclasses")).To(BeTrue()) }) It("Bubbles up errors", func() { - errorMessage := "foobar" - ClusterServiceClasses.ListReturns(nil, errors.New(errorMessage)) + badClient := &fake.Clientset{} + errorMessage := "error retrieving list" + badClient.AddReactor("list", "clusterserviceclasses", func(action testing.Action) (bool, runtime.Object, error) { + return true, nil, fmt.Errorf(errorMessage) + }) + client.ScClient = badClient _, err := client.ListClasses() Expect(err).To(HaveOccurred()) Expect(err.Error()).Should(ContainSubstring(errorMessage)) - Expect(ClusterServiceClasses.ListCallCount()).To(Equal(1)) + Expect(badClient.Actions()[0].Matches("list", "clusterserviceclasses")).To(BeTrue()) }) }) }) diff --git a/plugin/pkg/kubectl/client/fakes/fake_clusterservicebroker_interface.go b/plugin/pkg/kubectl/client/fakes/fake_clusterservicebroker_interface.go deleted file mode 100644 index 1fdda52d5e6..00000000000 --- a/plugin/pkg/kubectl/client/fakes/fake_clusterservicebroker_interface.go +++ /dev/null @@ -1,658 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -// Code generated by counterfeiter. DO NOT EDIT. -package fakes - -import ( - "sync" - - "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" - generated_v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" - "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/watch" -) - -type FakeClusterServiceBrokerInterface struct { - CreateStub func(*v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) - createMutex sync.RWMutex - createArgsForCall []struct { - arg1 *v1beta1.ClusterServiceBroker - } - createReturns struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - } - createReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - } - UpdateStub func(*v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) - updateMutex sync.RWMutex - updateArgsForCall []struct { - arg1 *v1beta1.ClusterServiceBroker - } - updateReturns struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - } - updateReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - } - UpdateStatusStub func(*v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) - updateStatusMutex sync.RWMutex - updateStatusArgsForCall []struct { - arg1 *v1beta1.ClusterServiceBroker - } - updateStatusReturns struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - } - updateStatusReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - } - DeleteStub func(name string, options *v1.DeleteOptions) error - deleteMutex sync.RWMutex - deleteArgsForCall []struct { - name string - options *v1.DeleteOptions - } - deleteReturns struct { - result1 error - } - deleteReturnsOnCall map[int]struct { - result1 error - } - DeleteCollectionStub func(options *v1.DeleteOptions, listOptions v1.ListOptions) error - deleteCollectionMutex sync.RWMutex - deleteCollectionArgsForCall []struct { - options *v1.DeleteOptions - listOptions v1.ListOptions - } - deleteCollectionReturns struct { - result1 error - } - deleteCollectionReturnsOnCall map[int]struct { - result1 error - } - GetStub func(name string, options v1.GetOptions) (*v1beta1.ClusterServiceBroker, error) - getMutex sync.RWMutex - getArgsForCall []struct { - name string - options v1.GetOptions - } - getReturns struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - } - getReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - } - ListStub func(opts v1.ListOptions) (*v1beta1.ClusterServiceBrokerList, error) - listMutex sync.RWMutex - listArgsForCall []struct { - opts v1.ListOptions - } - listReturns struct { - result1 *v1beta1.ClusterServiceBrokerList - result2 error - } - listReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceBrokerList - result2 error - } - WatchStub func(opts v1.ListOptions) (watch.Interface, error) - watchMutex sync.RWMutex - watchArgsForCall []struct { - opts v1.ListOptions - } - watchReturns struct { - result1 watch.Interface - result2 error - } - watchReturnsOnCall map[int]struct { - result1 watch.Interface - result2 error - } - PatchStub func(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServiceBroker, err error) - patchMutex sync.RWMutex - patchArgsForCall []struct { - name string - pt types.PatchType - data []byte - subresources []string - } - patchReturns struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - } - patchReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeClusterServiceBrokerInterface) Create(arg1 *v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) { - fake.createMutex.Lock() - ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] - fake.createArgsForCall = append(fake.createArgsForCall, struct { - arg1 *v1beta1.ClusterServiceBroker - }{arg1}) - fake.recordInvocation("Create", []interface{}{arg1}) - fake.createMutex.Unlock() - if fake.CreateStub != nil { - return fake.CreateStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.createReturns.result1, fake.createReturns.result2 -} - -func (fake *FakeClusterServiceBrokerInterface) CreateCallCount() int { - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - return len(fake.createArgsForCall) -} - -func (fake *FakeClusterServiceBrokerInterface) CreateArgsForCall(i int) *v1beta1.ClusterServiceBroker { - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - return fake.createArgsForCall[i].arg1 -} - -func (fake *FakeClusterServiceBrokerInterface) CreateReturns(result1 *v1beta1.ClusterServiceBroker, result2 error) { - fake.CreateStub = nil - fake.createReturns = struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) CreateReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBroker, result2 error) { - fake.CreateStub = nil - if fake.createReturnsOnCall == nil { - fake.createReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }) - } - fake.createReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) Update(arg1 *v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) { - fake.updateMutex.Lock() - ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] - fake.updateArgsForCall = append(fake.updateArgsForCall, struct { - arg1 *v1beta1.ClusterServiceBroker - }{arg1}) - fake.recordInvocation("Update", []interface{}{arg1}) - fake.updateMutex.Unlock() - if fake.UpdateStub != nil { - return fake.UpdateStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.updateReturns.result1, fake.updateReturns.result2 -} - -func (fake *FakeClusterServiceBrokerInterface) UpdateCallCount() int { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return len(fake.updateArgsForCall) -} - -func (fake *FakeClusterServiceBrokerInterface) UpdateArgsForCall(i int) *v1beta1.ClusterServiceBroker { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return fake.updateArgsForCall[i].arg1 -} - -func (fake *FakeClusterServiceBrokerInterface) UpdateReturns(result1 *v1beta1.ClusterServiceBroker, result2 error) { - fake.UpdateStub = nil - fake.updateReturns = struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) UpdateReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBroker, result2 error) { - fake.UpdateStub = nil - if fake.updateReturnsOnCall == nil { - fake.updateReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }) - } - fake.updateReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) UpdateStatus(arg1 *v1beta1.ClusterServiceBroker) (*v1beta1.ClusterServiceBroker, error) { - fake.updateStatusMutex.Lock() - ret, specificReturn := fake.updateStatusReturnsOnCall[len(fake.updateStatusArgsForCall)] - fake.updateStatusArgsForCall = append(fake.updateStatusArgsForCall, struct { - arg1 *v1beta1.ClusterServiceBroker - }{arg1}) - fake.recordInvocation("UpdateStatus", []interface{}{arg1}) - fake.updateStatusMutex.Unlock() - if fake.UpdateStatusStub != nil { - return fake.UpdateStatusStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.updateStatusReturns.result1, fake.updateStatusReturns.result2 -} - -func (fake *FakeClusterServiceBrokerInterface) UpdateStatusCallCount() int { - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - return len(fake.updateStatusArgsForCall) -} - -func (fake *FakeClusterServiceBrokerInterface) UpdateStatusArgsForCall(i int) *v1beta1.ClusterServiceBroker { - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - return fake.updateStatusArgsForCall[i].arg1 -} - -func (fake *FakeClusterServiceBrokerInterface) UpdateStatusReturns(result1 *v1beta1.ClusterServiceBroker, result2 error) { - fake.UpdateStatusStub = nil - fake.updateStatusReturns = struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) UpdateStatusReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBroker, result2 error) { - fake.UpdateStatusStub = nil - if fake.updateStatusReturnsOnCall == nil { - fake.updateStatusReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }) - } - fake.updateStatusReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) Delete(name string, options *v1.DeleteOptions) error { - fake.deleteMutex.Lock() - ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] - fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { - name string - options *v1.DeleteOptions - }{name, options}) - fake.recordInvocation("Delete", []interface{}{name, options}) - fake.deleteMutex.Unlock() - if fake.DeleteStub != nil { - return fake.DeleteStub(name, options) - } - if specificReturn { - return ret.result1 - } - return fake.deleteReturns.result1 -} - -func (fake *FakeClusterServiceBrokerInterface) DeleteCallCount() int { - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - return len(fake.deleteArgsForCall) -} - -func (fake *FakeClusterServiceBrokerInterface) DeleteArgsForCall(i int) (string, *v1.DeleteOptions) { - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - return fake.deleteArgsForCall[i].name, fake.deleteArgsForCall[i].options -} - -func (fake *FakeClusterServiceBrokerInterface) DeleteReturns(result1 error) { - fake.DeleteStub = nil - fake.deleteReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServiceBrokerInterface) DeleteReturnsOnCall(i int, result1 error) { - fake.DeleteStub = nil - if fake.deleteReturnsOnCall == nil { - fake.deleteReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServiceBrokerInterface) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { - fake.deleteCollectionMutex.Lock() - ret, specificReturn := fake.deleteCollectionReturnsOnCall[len(fake.deleteCollectionArgsForCall)] - fake.deleteCollectionArgsForCall = append(fake.deleteCollectionArgsForCall, struct { - options *v1.DeleteOptions - listOptions v1.ListOptions - }{options, listOptions}) - fake.recordInvocation("DeleteCollection", []interface{}{options, listOptions}) - fake.deleteCollectionMutex.Unlock() - if fake.DeleteCollectionStub != nil { - return fake.DeleteCollectionStub(options, listOptions) - } - if specificReturn { - return ret.result1 - } - return fake.deleteCollectionReturns.result1 -} - -func (fake *FakeClusterServiceBrokerInterface) DeleteCollectionCallCount() int { - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - return len(fake.deleteCollectionArgsForCall) -} - -func (fake *FakeClusterServiceBrokerInterface) DeleteCollectionArgsForCall(i int) (*v1.DeleteOptions, v1.ListOptions) { - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - return fake.deleteCollectionArgsForCall[i].options, fake.deleteCollectionArgsForCall[i].listOptions -} - -func (fake *FakeClusterServiceBrokerInterface) DeleteCollectionReturns(result1 error) { - fake.DeleteCollectionStub = nil - fake.deleteCollectionReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServiceBrokerInterface) DeleteCollectionReturnsOnCall(i int, result1 error) { - fake.DeleteCollectionStub = nil - if fake.deleteCollectionReturnsOnCall == nil { - fake.deleteCollectionReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteCollectionReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServiceBrokerInterface) Get(name string, options v1.GetOptions) (*v1beta1.ClusterServiceBroker, error) { - fake.getMutex.Lock() - ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] - fake.getArgsForCall = append(fake.getArgsForCall, struct { - name string - options v1.GetOptions - }{name, options}) - fake.recordInvocation("Get", []interface{}{name, options}) - fake.getMutex.Unlock() - if fake.GetStub != nil { - return fake.GetStub(name, options) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.getReturns.result1, fake.getReturns.result2 -} - -func (fake *FakeClusterServiceBrokerInterface) GetCallCount() int { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - return len(fake.getArgsForCall) -} - -func (fake *FakeClusterServiceBrokerInterface) GetArgsForCall(i int) (string, v1.GetOptions) { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - return fake.getArgsForCall[i].name, fake.getArgsForCall[i].options -} - -func (fake *FakeClusterServiceBrokerInterface) GetReturns(result1 *v1beta1.ClusterServiceBroker, result2 error) { - fake.GetStub = nil - fake.getReturns = struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) GetReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBroker, result2 error) { - fake.GetStub = nil - if fake.getReturnsOnCall == nil { - fake.getReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }) - } - fake.getReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) List(opts v1.ListOptions) (*v1beta1.ClusterServiceBrokerList, error) { - fake.listMutex.Lock() - ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] - fake.listArgsForCall = append(fake.listArgsForCall, struct { - opts v1.ListOptions - }{opts}) - fake.recordInvocation("List", []interface{}{opts}) - fake.listMutex.Unlock() - if fake.ListStub != nil { - return fake.ListStub(opts) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.listReturns.result1, fake.listReturns.result2 -} - -func (fake *FakeClusterServiceBrokerInterface) ListCallCount() int { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return len(fake.listArgsForCall) -} - -func (fake *FakeClusterServiceBrokerInterface) ListArgsForCall(i int) v1.ListOptions { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return fake.listArgsForCall[i].opts -} - -func (fake *FakeClusterServiceBrokerInterface) ListReturns(result1 *v1beta1.ClusterServiceBrokerList, result2 error) { - fake.ListStub = nil - fake.listReturns = struct { - result1 *v1beta1.ClusterServiceBrokerList - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) ListReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBrokerList, result2 error) { - fake.ListStub = nil - if fake.listReturnsOnCall == nil { - fake.listReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceBrokerList - result2 error - }) - } - fake.listReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceBrokerList - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) Watch(opts v1.ListOptions) (watch.Interface, error) { - fake.watchMutex.Lock() - ret, specificReturn := fake.watchReturnsOnCall[len(fake.watchArgsForCall)] - fake.watchArgsForCall = append(fake.watchArgsForCall, struct { - opts v1.ListOptions - }{opts}) - fake.recordInvocation("Watch", []interface{}{opts}) - fake.watchMutex.Unlock() - if fake.WatchStub != nil { - return fake.WatchStub(opts) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.watchReturns.result1, fake.watchReturns.result2 -} - -func (fake *FakeClusterServiceBrokerInterface) WatchCallCount() int { - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - return len(fake.watchArgsForCall) -} - -func (fake *FakeClusterServiceBrokerInterface) WatchArgsForCall(i int) v1.ListOptions { - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - return fake.watchArgsForCall[i].opts -} - -func (fake *FakeClusterServiceBrokerInterface) WatchReturns(result1 watch.Interface, result2 error) { - fake.WatchStub = nil - fake.watchReturns = struct { - result1 watch.Interface - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) WatchReturnsOnCall(i int, result1 watch.Interface, result2 error) { - fake.WatchStub = nil - if fake.watchReturnsOnCall == nil { - fake.watchReturnsOnCall = make(map[int]struct { - result1 watch.Interface - result2 error - }) - } - fake.watchReturnsOnCall[i] = struct { - result1 watch.Interface - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServiceBroker, err error) { - var dataCopy []byte - if data != nil { - dataCopy = make([]byte, len(data)) - copy(dataCopy, data) - } - fake.patchMutex.Lock() - ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)] - fake.patchArgsForCall = append(fake.patchArgsForCall, struct { - name string - pt types.PatchType - data []byte - subresources []string - }{name, pt, dataCopy, subresources}) - fake.recordInvocation("Patch", []interface{}{name, pt, dataCopy, subresources}) - fake.patchMutex.Unlock() - if fake.PatchStub != nil { - return fake.PatchStub(name, pt, data, subresources...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.patchReturns.result1, fake.patchReturns.result2 -} - -func (fake *FakeClusterServiceBrokerInterface) PatchCallCount() int { - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - return len(fake.patchArgsForCall) -} - -func (fake *FakeClusterServiceBrokerInterface) PatchArgsForCall(i int) (string, types.PatchType, []byte, []string) { - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - return fake.patchArgsForCall[i].name, fake.patchArgsForCall[i].pt, fake.patchArgsForCall[i].data, fake.patchArgsForCall[i].subresources -} - -func (fake *FakeClusterServiceBrokerInterface) PatchReturns(result1 *v1beta1.ClusterServiceBroker, result2 error) { - fake.PatchStub = nil - fake.patchReturns = struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) PatchReturnsOnCall(i int, result1 *v1beta1.ClusterServiceBroker, result2 error) { - fake.PatchStub = nil - if fake.patchReturnsOnCall == nil { - fake.patchReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }) - } - fake.patchReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceBroker - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceBrokerInterface) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeClusterServiceBrokerInterface) recordInvocation(key string, args []interface{}) { - fake.invocationsMutex.Lock() - defer fake.invocationsMutex.Unlock() - if fake.invocations == nil { - fake.invocations = map[string][][]interface{}{} - } - if fake.invocations[key] == nil { - fake.invocations[key] = [][]interface{}{} - } - fake.invocations[key] = append(fake.invocations[key], args) -} - -var _ generated_v1beta1.ClusterServiceBrokerInterface = new(FakeClusterServiceBrokerInterface) diff --git a/plugin/pkg/kubectl/client/fakes/fake_clusterserviceclass_interface.go b/plugin/pkg/kubectl/client/fakes/fake_clusterserviceclass_interface.go deleted file mode 100644 index b3df37f4623..00000000000 --- a/plugin/pkg/kubectl/client/fakes/fake_clusterserviceclass_interface.go +++ /dev/null @@ -1,658 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -// Code generated by counterfeiter. DO NOT EDIT. -package fakes - -import ( - "sync" - - "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" - generated_v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" - "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/watch" -) - -type FakeClusterServiceClassInterface struct { - CreateStub func(*v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) - createMutex sync.RWMutex - createArgsForCall []struct { - arg1 *v1beta1.ClusterServiceClass - } - createReturns struct { - result1 *v1beta1.ClusterServiceClass - result2 error - } - createReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceClass - result2 error - } - UpdateStub func(*v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) - updateMutex sync.RWMutex - updateArgsForCall []struct { - arg1 *v1beta1.ClusterServiceClass - } - updateReturns struct { - result1 *v1beta1.ClusterServiceClass - result2 error - } - updateReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceClass - result2 error - } - UpdateStatusStub func(*v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) - updateStatusMutex sync.RWMutex - updateStatusArgsForCall []struct { - arg1 *v1beta1.ClusterServiceClass - } - updateStatusReturns struct { - result1 *v1beta1.ClusterServiceClass - result2 error - } - updateStatusReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceClass - result2 error - } - DeleteStub func(name string, options *v1.DeleteOptions) error - deleteMutex sync.RWMutex - deleteArgsForCall []struct { - name string - options *v1.DeleteOptions - } - deleteReturns struct { - result1 error - } - deleteReturnsOnCall map[int]struct { - result1 error - } - DeleteCollectionStub func(options *v1.DeleteOptions, listOptions v1.ListOptions) error - deleteCollectionMutex sync.RWMutex - deleteCollectionArgsForCall []struct { - options *v1.DeleteOptions - listOptions v1.ListOptions - } - deleteCollectionReturns struct { - result1 error - } - deleteCollectionReturnsOnCall map[int]struct { - result1 error - } - GetStub func(name string, options v1.GetOptions) (*v1beta1.ClusterServiceClass, error) - getMutex sync.RWMutex - getArgsForCall []struct { - name string - options v1.GetOptions - } - getReturns struct { - result1 *v1beta1.ClusterServiceClass - result2 error - } - getReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceClass - result2 error - } - ListStub func(opts v1.ListOptions) (*v1beta1.ClusterServiceClassList, error) - listMutex sync.RWMutex - listArgsForCall []struct { - opts v1.ListOptions - } - listReturns struct { - result1 *v1beta1.ClusterServiceClassList - result2 error - } - listReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceClassList - result2 error - } - WatchStub func(opts v1.ListOptions) (watch.Interface, error) - watchMutex sync.RWMutex - watchArgsForCall []struct { - opts v1.ListOptions - } - watchReturns struct { - result1 watch.Interface - result2 error - } - watchReturnsOnCall map[int]struct { - result1 watch.Interface - result2 error - } - PatchStub func(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServiceClass, err error) - patchMutex sync.RWMutex - patchArgsForCall []struct { - name string - pt types.PatchType - data []byte - subresources []string - } - patchReturns struct { - result1 *v1beta1.ClusterServiceClass - result2 error - } - patchReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServiceClass - result2 error - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeClusterServiceClassInterface) Create(arg1 *v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) { - fake.createMutex.Lock() - ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] - fake.createArgsForCall = append(fake.createArgsForCall, struct { - arg1 *v1beta1.ClusterServiceClass - }{arg1}) - fake.recordInvocation("Create", []interface{}{arg1}) - fake.createMutex.Unlock() - if fake.CreateStub != nil { - return fake.CreateStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.createReturns.result1, fake.createReturns.result2 -} - -func (fake *FakeClusterServiceClassInterface) CreateCallCount() int { - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - return len(fake.createArgsForCall) -} - -func (fake *FakeClusterServiceClassInterface) CreateArgsForCall(i int) *v1beta1.ClusterServiceClass { - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - return fake.createArgsForCall[i].arg1 -} - -func (fake *FakeClusterServiceClassInterface) CreateReturns(result1 *v1beta1.ClusterServiceClass, result2 error) { - fake.CreateStub = nil - fake.createReturns = struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) CreateReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClass, result2 error) { - fake.CreateStub = nil - if fake.createReturnsOnCall == nil { - fake.createReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }) - } - fake.createReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) Update(arg1 *v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) { - fake.updateMutex.Lock() - ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] - fake.updateArgsForCall = append(fake.updateArgsForCall, struct { - arg1 *v1beta1.ClusterServiceClass - }{arg1}) - fake.recordInvocation("Update", []interface{}{arg1}) - fake.updateMutex.Unlock() - if fake.UpdateStub != nil { - return fake.UpdateStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.updateReturns.result1, fake.updateReturns.result2 -} - -func (fake *FakeClusterServiceClassInterface) UpdateCallCount() int { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return len(fake.updateArgsForCall) -} - -func (fake *FakeClusterServiceClassInterface) UpdateArgsForCall(i int) *v1beta1.ClusterServiceClass { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return fake.updateArgsForCall[i].arg1 -} - -func (fake *FakeClusterServiceClassInterface) UpdateReturns(result1 *v1beta1.ClusterServiceClass, result2 error) { - fake.UpdateStub = nil - fake.updateReturns = struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) UpdateReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClass, result2 error) { - fake.UpdateStub = nil - if fake.updateReturnsOnCall == nil { - fake.updateReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }) - } - fake.updateReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) UpdateStatus(arg1 *v1beta1.ClusterServiceClass) (*v1beta1.ClusterServiceClass, error) { - fake.updateStatusMutex.Lock() - ret, specificReturn := fake.updateStatusReturnsOnCall[len(fake.updateStatusArgsForCall)] - fake.updateStatusArgsForCall = append(fake.updateStatusArgsForCall, struct { - arg1 *v1beta1.ClusterServiceClass - }{arg1}) - fake.recordInvocation("UpdateStatus", []interface{}{arg1}) - fake.updateStatusMutex.Unlock() - if fake.UpdateStatusStub != nil { - return fake.UpdateStatusStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.updateStatusReturns.result1, fake.updateStatusReturns.result2 -} - -func (fake *FakeClusterServiceClassInterface) UpdateStatusCallCount() int { - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - return len(fake.updateStatusArgsForCall) -} - -func (fake *FakeClusterServiceClassInterface) UpdateStatusArgsForCall(i int) *v1beta1.ClusterServiceClass { - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - return fake.updateStatusArgsForCall[i].arg1 -} - -func (fake *FakeClusterServiceClassInterface) UpdateStatusReturns(result1 *v1beta1.ClusterServiceClass, result2 error) { - fake.UpdateStatusStub = nil - fake.updateStatusReturns = struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) UpdateStatusReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClass, result2 error) { - fake.UpdateStatusStub = nil - if fake.updateStatusReturnsOnCall == nil { - fake.updateStatusReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }) - } - fake.updateStatusReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) Delete(name string, options *v1.DeleteOptions) error { - fake.deleteMutex.Lock() - ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] - fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { - name string - options *v1.DeleteOptions - }{name, options}) - fake.recordInvocation("Delete", []interface{}{name, options}) - fake.deleteMutex.Unlock() - if fake.DeleteStub != nil { - return fake.DeleteStub(name, options) - } - if specificReturn { - return ret.result1 - } - return fake.deleteReturns.result1 -} - -func (fake *FakeClusterServiceClassInterface) DeleteCallCount() int { - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - return len(fake.deleteArgsForCall) -} - -func (fake *FakeClusterServiceClassInterface) DeleteArgsForCall(i int) (string, *v1.DeleteOptions) { - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - return fake.deleteArgsForCall[i].name, fake.deleteArgsForCall[i].options -} - -func (fake *FakeClusterServiceClassInterface) DeleteReturns(result1 error) { - fake.DeleteStub = nil - fake.deleteReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServiceClassInterface) DeleteReturnsOnCall(i int, result1 error) { - fake.DeleteStub = nil - if fake.deleteReturnsOnCall == nil { - fake.deleteReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServiceClassInterface) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { - fake.deleteCollectionMutex.Lock() - ret, specificReturn := fake.deleteCollectionReturnsOnCall[len(fake.deleteCollectionArgsForCall)] - fake.deleteCollectionArgsForCall = append(fake.deleteCollectionArgsForCall, struct { - options *v1.DeleteOptions - listOptions v1.ListOptions - }{options, listOptions}) - fake.recordInvocation("DeleteCollection", []interface{}{options, listOptions}) - fake.deleteCollectionMutex.Unlock() - if fake.DeleteCollectionStub != nil { - return fake.DeleteCollectionStub(options, listOptions) - } - if specificReturn { - return ret.result1 - } - return fake.deleteCollectionReturns.result1 -} - -func (fake *FakeClusterServiceClassInterface) DeleteCollectionCallCount() int { - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - return len(fake.deleteCollectionArgsForCall) -} - -func (fake *FakeClusterServiceClassInterface) DeleteCollectionArgsForCall(i int) (*v1.DeleteOptions, v1.ListOptions) { - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - return fake.deleteCollectionArgsForCall[i].options, fake.deleteCollectionArgsForCall[i].listOptions -} - -func (fake *FakeClusterServiceClassInterface) DeleteCollectionReturns(result1 error) { - fake.DeleteCollectionStub = nil - fake.deleteCollectionReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServiceClassInterface) DeleteCollectionReturnsOnCall(i int, result1 error) { - fake.DeleteCollectionStub = nil - if fake.deleteCollectionReturnsOnCall == nil { - fake.deleteCollectionReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteCollectionReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServiceClassInterface) Get(name string, options v1.GetOptions) (*v1beta1.ClusterServiceClass, error) { - fake.getMutex.Lock() - ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] - fake.getArgsForCall = append(fake.getArgsForCall, struct { - name string - options v1.GetOptions - }{name, options}) - fake.recordInvocation("Get", []interface{}{name, options}) - fake.getMutex.Unlock() - if fake.GetStub != nil { - return fake.GetStub(name, options) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.getReturns.result1, fake.getReturns.result2 -} - -func (fake *FakeClusterServiceClassInterface) GetCallCount() int { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - return len(fake.getArgsForCall) -} - -func (fake *FakeClusterServiceClassInterface) GetArgsForCall(i int) (string, v1.GetOptions) { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - return fake.getArgsForCall[i].name, fake.getArgsForCall[i].options -} - -func (fake *FakeClusterServiceClassInterface) GetReturns(result1 *v1beta1.ClusterServiceClass, result2 error) { - fake.GetStub = nil - fake.getReturns = struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) GetReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClass, result2 error) { - fake.GetStub = nil - if fake.getReturnsOnCall == nil { - fake.getReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }) - } - fake.getReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) List(opts v1.ListOptions) (*v1beta1.ClusterServiceClassList, error) { - fake.listMutex.Lock() - ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] - fake.listArgsForCall = append(fake.listArgsForCall, struct { - opts v1.ListOptions - }{opts}) - fake.recordInvocation("List", []interface{}{opts}) - fake.listMutex.Unlock() - if fake.ListStub != nil { - return fake.ListStub(opts) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.listReturns.result1, fake.listReturns.result2 -} - -func (fake *FakeClusterServiceClassInterface) ListCallCount() int { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return len(fake.listArgsForCall) -} - -func (fake *FakeClusterServiceClassInterface) ListArgsForCall(i int) v1.ListOptions { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return fake.listArgsForCall[i].opts -} - -func (fake *FakeClusterServiceClassInterface) ListReturns(result1 *v1beta1.ClusterServiceClassList, result2 error) { - fake.ListStub = nil - fake.listReturns = struct { - result1 *v1beta1.ClusterServiceClassList - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) ListReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClassList, result2 error) { - fake.ListStub = nil - if fake.listReturnsOnCall == nil { - fake.listReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceClassList - result2 error - }) - } - fake.listReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceClassList - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) Watch(opts v1.ListOptions) (watch.Interface, error) { - fake.watchMutex.Lock() - ret, specificReturn := fake.watchReturnsOnCall[len(fake.watchArgsForCall)] - fake.watchArgsForCall = append(fake.watchArgsForCall, struct { - opts v1.ListOptions - }{opts}) - fake.recordInvocation("Watch", []interface{}{opts}) - fake.watchMutex.Unlock() - if fake.WatchStub != nil { - return fake.WatchStub(opts) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.watchReturns.result1, fake.watchReturns.result2 -} - -func (fake *FakeClusterServiceClassInterface) WatchCallCount() int { - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - return len(fake.watchArgsForCall) -} - -func (fake *FakeClusterServiceClassInterface) WatchArgsForCall(i int) v1.ListOptions { - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - return fake.watchArgsForCall[i].opts -} - -func (fake *FakeClusterServiceClassInterface) WatchReturns(result1 watch.Interface, result2 error) { - fake.WatchStub = nil - fake.watchReturns = struct { - result1 watch.Interface - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) WatchReturnsOnCall(i int, result1 watch.Interface, result2 error) { - fake.WatchStub = nil - if fake.watchReturnsOnCall == nil { - fake.watchReturnsOnCall = make(map[int]struct { - result1 watch.Interface - result2 error - }) - } - fake.watchReturnsOnCall[i] = struct { - result1 watch.Interface - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServiceClass, err error) { - var dataCopy []byte - if data != nil { - dataCopy = make([]byte, len(data)) - copy(dataCopy, data) - } - fake.patchMutex.Lock() - ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)] - fake.patchArgsForCall = append(fake.patchArgsForCall, struct { - name string - pt types.PatchType - data []byte - subresources []string - }{name, pt, dataCopy, subresources}) - fake.recordInvocation("Patch", []interface{}{name, pt, dataCopy, subresources}) - fake.patchMutex.Unlock() - if fake.PatchStub != nil { - return fake.PatchStub(name, pt, data, subresources...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.patchReturns.result1, fake.patchReturns.result2 -} - -func (fake *FakeClusterServiceClassInterface) PatchCallCount() int { - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - return len(fake.patchArgsForCall) -} - -func (fake *FakeClusterServiceClassInterface) PatchArgsForCall(i int) (string, types.PatchType, []byte, []string) { - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - return fake.patchArgsForCall[i].name, fake.patchArgsForCall[i].pt, fake.patchArgsForCall[i].data, fake.patchArgsForCall[i].subresources -} - -func (fake *FakeClusterServiceClassInterface) PatchReturns(result1 *v1beta1.ClusterServiceClass, result2 error) { - fake.PatchStub = nil - fake.patchReturns = struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) PatchReturnsOnCall(i int, result1 *v1beta1.ClusterServiceClass, result2 error) { - fake.PatchStub = nil - if fake.patchReturnsOnCall == nil { - fake.patchReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }) - } - fake.patchReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServiceClass - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServiceClassInterface) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeClusterServiceClassInterface) recordInvocation(key string, args []interface{}) { - fake.invocationsMutex.Lock() - defer fake.invocationsMutex.Unlock() - if fake.invocations == nil { - fake.invocations = map[string][][]interface{}{} - } - if fake.invocations[key] == nil { - fake.invocations[key] = [][]interface{}{} - } - fake.invocations[key] = append(fake.invocations[key], args) -} - -var _ generated_v1beta1.ClusterServiceClassInterface = new(FakeClusterServiceClassInterface) diff --git a/plugin/pkg/kubectl/client/fakes/fake_clusterserviceplan_interface.go b/plugin/pkg/kubectl/client/fakes/fake_clusterserviceplan_interface.go deleted file mode 100644 index 2347fd00040..00000000000 --- a/plugin/pkg/kubectl/client/fakes/fake_clusterserviceplan_interface.go +++ /dev/null @@ -1,658 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -// Code generated by counterfeiter. DO NOT EDIT. -package fakes - -import ( - "sync" - - "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" - generated_v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" - "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/watch" -) - -type FakeClusterServicePlanInterface struct { - CreateStub func(*v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) - createMutex sync.RWMutex - createArgsForCall []struct { - arg1 *v1beta1.ClusterServicePlan - } - createReturns struct { - result1 *v1beta1.ClusterServicePlan - result2 error - } - createReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServicePlan - result2 error - } - UpdateStub func(*v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) - updateMutex sync.RWMutex - updateArgsForCall []struct { - arg1 *v1beta1.ClusterServicePlan - } - updateReturns struct { - result1 *v1beta1.ClusterServicePlan - result2 error - } - updateReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServicePlan - result2 error - } - UpdateStatusStub func(*v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) - updateStatusMutex sync.RWMutex - updateStatusArgsForCall []struct { - arg1 *v1beta1.ClusterServicePlan - } - updateStatusReturns struct { - result1 *v1beta1.ClusterServicePlan - result2 error - } - updateStatusReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServicePlan - result2 error - } - DeleteStub func(name string, options *v1.DeleteOptions) error - deleteMutex sync.RWMutex - deleteArgsForCall []struct { - name string - options *v1.DeleteOptions - } - deleteReturns struct { - result1 error - } - deleteReturnsOnCall map[int]struct { - result1 error - } - DeleteCollectionStub func(options *v1.DeleteOptions, listOptions v1.ListOptions) error - deleteCollectionMutex sync.RWMutex - deleteCollectionArgsForCall []struct { - options *v1.DeleteOptions - listOptions v1.ListOptions - } - deleteCollectionReturns struct { - result1 error - } - deleteCollectionReturnsOnCall map[int]struct { - result1 error - } - GetStub func(name string, options v1.GetOptions) (*v1beta1.ClusterServicePlan, error) - getMutex sync.RWMutex - getArgsForCall []struct { - name string - options v1.GetOptions - } - getReturns struct { - result1 *v1beta1.ClusterServicePlan - result2 error - } - getReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServicePlan - result2 error - } - ListStub func(opts v1.ListOptions) (*v1beta1.ClusterServicePlanList, error) - listMutex sync.RWMutex - listArgsForCall []struct { - opts v1.ListOptions - } - listReturns struct { - result1 *v1beta1.ClusterServicePlanList - result2 error - } - listReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServicePlanList - result2 error - } - WatchStub func(opts v1.ListOptions) (watch.Interface, error) - watchMutex sync.RWMutex - watchArgsForCall []struct { - opts v1.ListOptions - } - watchReturns struct { - result1 watch.Interface - result2 error - } - watchReturnsOnCall map[int]struct { - result1 watch.Interface - result2 error - } - PatchStub func(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServicePlan, err error) - patchMutex sync.RWMutex - patchArgsForCall []struct { - name string - pt types.PatchType - data []byte - subresources []string - } - patchReturns struct { - result1 *v1beta1.ClusterServicePlan - result2 error - } - patchReturnsOnCall map[int]struct { - result1 *v1beta1.ClusterServicePlan - result2 error - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeClusterServicePlanInterface) Create(arg1 *v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) { - fake.createMutex.Lock() - ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] - fake.createArgsForCall = append(fake.createArgsForCall, struct { - arg1 *v1beta1.ClusterServicePlan - }{arg1}) - fake.recordInvocation("Create", []interface{}{arg1}) - fake.createMutex.Unlock() - if fake.CreateStub != nil { - return fake.CreateStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.createReturns.result1, fake.createReturns.result2 -} - -func (fake *FakeClusterServicePlanInterface) CreateCallCount() int { - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - return len(fake.createArgsForCall) -} - -func (fake *FakeClusterServicePlanInterface) CreateArgsForCall(i int) *v1beta1.ClusterServicePlan { - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - return fake.createArgsForCall[i].arg1 -} - -func (fake *FakeClusterServicePlanInterface) CreateReturns(result1 *v1beta1.ClusterServicePlan, result2 error) { - fake.CreateStub = nil - fake.createReturns = struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) CreateReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlan, result2 error) { - fake.CreateStub = nil - if fake.createReturnsOnCall == nil { - fake.createReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }) - } - fake.createReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) Update(arg1 *v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) { - fake.updateMutex.Lock() - ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] - fake.updateArgsForCall = append(fake.updateArgsForCall, struct { - arg1 *v1beta1.ClusterServicePlan - }{arg1}) - fake.recordInvocation("Update", []interface{}{arg1}) - fake.updateMutex.Unlock() - if fake.UpdateStub != nil { - return fake.UpdateStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.updateReturns.result1, fake.updateReturns.result2 -} - -func (fake *FakeClusterServicePlanInterface) UpdateCallCount() int { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return len(fake.updateArgsForCall) -} - -func (fake *FakeClusterServicePlanInterface) UpdateArgsForCall(i int) *v1beta1.ClusterServicePlan { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return fake.updateArgsForCall[i].arg1 -} - -func (fake *FakeClusterServicePlanInterface) UpdateReturns(result1 *v1beta1.ClusterServicePlan, result2 error) { - fake.UpdateStub = nil - fake.updateReturns = struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) UpdateReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlan, result2 error) { - fake.UpdateStub = nil - if fake.updateReturnsOnCall == nil { - fake.updateReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }) - } - fake.updateReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) UpdateStatus(arg1 *v1beta1.ClusterServicePlan) (*v1beta1.ClusterServicePlan, error) { - fake.updateStatusMutex.Lock() - ret, specificReturn := fake.updateStatusReturnsOnCall[len(fake.updateStatusArgsForCall)] - fake.updateStatusArgsForCall = append(fake.updateStatusArgsForCall, struct { - arg1 *v1beta1.ClusterServicePlan - }{arg1}) - fake.recordInvocation("UpdateStatus", []interface{}{arg1}) - fake.updateStatusMutex.Unlock() - if fake.UpdateStatusStub != nil { - return fake.UpdateStatusStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.updateStatusReturns.result1, fake.updateStatusReturns.result2 -} - -func (fake *FakeClusterServicePlanInterface) UpdateStatusCallCount() int { - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - return len(fake.updateStatusArgsForCall) -} - -func (fake *FakeClusterServicePlanInterface) UpdateStatusArgsForCall(i int) *v1beta1.ClusterServicePlan { - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - return fake.updateStatusArgsForCall[i].arg1 -} - -func (fake *FakeClusterServicePlanInterface) UpdateStatusReturns(result1 *v1beta1.ClusterServicePlan, result2 error) { - fake.UpdateStatusStub = nil - fake.updateStatusReturns = struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) UpdateStatusReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlan, result2 error) { - fake.UpdateStatusStub = nil - if fake.updateStatusReturnsOnCall == nil { - fake.updateStatusReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }) - } - fake.updateStatusReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) Delete(name string, options *v1.DeleteOptions) error { - fake.deleteMutex.Lock() - ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] - fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { - name string - options *v1.DeleteOptions - }{name, options}) - fake.recordInvocation("Delete", []interface{}{name, options}) - fake.deleteMutex.Unlock() - if fake.DeleteStub != nil { - return fake.DeleteStub(name, options) - } - if specificReturn { - return ret.result1 - } - return fake.deleteReturns.result1 -} - -func (fake *FakeClusterServicePlanInterface) DeleteCallCount() int { - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - return len(fake.deleteArgsForCall) -} - -func (fake *FakeClusterServicePlanInterface) DeleteArgsForCall(i int) (string, *v1.DeleteOptions) { - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - return fake.deleteArgsForCall[i].name, fake.deleteArgsForCall[i].options -} - -func (fake *FakeClusterServicePlanInterface) DeleteReturns(result1 error) { - fake.DeleteStub = nil - fake.deleteReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServicePlanInterface) DeleteReturnsOnCall(i int, result1 error) { - fake.DeleteStub = nil - if fake.deleteReturnsOnCall == nil { - fake.deleteReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServicePlanInterface) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { - fake.deleteCollectionMutex.Lock() - ret, specificReturn := fake.deleteCollectionReturnsOnCall[len(fake.deleteCollectionArgsForCall)] - fake.deleteCollectionArgsForCall = append(fake.deleteCollectionArgsForCall, struct { - options *v1.DeleteOptions - listOptions v1.ListOptions - }{options, listOptions}) - fake.recordInvocation("DeleteCollection", []interface{}{options, listOptions}) - fake.deleteCollectionMutex.Unlock() - if fake.DeleteCollectionStub != nil { - return fake.DeleteCollectionStub(options, listOptions) - } - if specificReturn { - return ret.result1 - } - return fake.deleteCollectionReturns.result1 -} - -func (fake *FakeClusterServicePlanInterface) DeleteCollectionCallCount() int { - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - return len(fake.deleteCollectionArgsForCall) -} - -func (fake *FakeClusterServicePlanInterface) DeleteCollectionArgsForCall(i int) (*v1.DeleteOptions, v1.ListOptions) { - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - return fake.deleteCollectionArgsForCall[i].options, fake.deleteCollectionArgsForCall[i].listOptions -} - -func (fake *FakeClusterServicePlanInterface) DeleteCollectionReturns(result1 error) { - fake.DeleteCollectionStub = nil - fake.deleteCollectionReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServicePlanInterface) DeleteCollectionReturnsOnCall(i int, result1 error) { - fake.DeleteCollectionStub = nil - if fake.deleteCollectionReturnsOnCall == nil { - fake.deleteCollectionReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteCollectionReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeClusterServicePlanInterface) Get(name string, options v1.GetOptions) (*v1beta1.ClusterServicePlan, error) { - fake.getMutex.Lock() - ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] - fake.getArgsForCall = append(fake.getArgsForCall, struct { - name string - options v1.GetOptions - }{name, options}) - fake.recordInvocation("Get", []interface{}{name, options}) - fake.getMutex.Unlock() - if fake.GetStub != nil { - return fake.GetStub(name, options) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.getReturns.result1, fake.getReturns.result2 -} - -func (fake *FakeClusterServicePlanInterface) GetCallCount() int { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - return len(fake.getArgsForCall) -} - -func (fake *FakeClusterServicePlanInterface) GetArgsForCall(i int) (string, v1.GetOptions) { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - return fake.getArgsForCall[i].name, fake.getArgsForCall[i].options -} - -func (fake *FakeClusterServicePlanInterface) GetReturns(result1 *v1beta1.ClusterServicePlan, result2 error) { - fake.GetStub = nil - fake.getReturns = struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) GetReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlan, result2 error) { - fake.GetStub = nil - if fake.getReturnsOnCall == nil { - fake.getReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }) - } - fake.getReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) List(opts v1.ListOptions) (*v1beta1.ClusterServicePlanList, error) { - fake.listMutex.Lock() - ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] - fake.listArgsForCall = append(fake.listArgsForCall, struct { - opts v1.ListOptions - }{opts}) - fake.recordInvocation("List", []interface{}{opts}) - fake.listMutex.Unlock() - if fake.ListStub != nil { - return fake.ListStub(opts) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.listReturns.result1, fake.listReturns.result2 -} - -func (fake *FakeClusterServicePlanInterface) ListCallCount() int { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return len(fake.listArgsForCall) -} - -func (fake *FakeClusterServicePlanInterface) ListArgsForCall(i int) v1.ListOptions { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return fake.listArgsForCall[i].opts -} - -func (fake *FakeClusterServicePlanInterface) ListReturns(result1 *v1beta1.ClusterServicePlanList, result2 error) { - fake.ListStub = nil - fake.listReturns = struct { - result1 *v1beta1.ClusterServicePlanList - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) ListReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlanList, result2 error) { - fake.ListStub = nil - if fake.listReturnsOnCall == nil { - fake.listReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServicePlanList - result2 error - }) - } - fake.listReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServicePlanList - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) Watch(opts v1.ListOptions) (watch.Interface, error) { - fake.watchMutex.Lock() - ret, specificReturn := fake.watchReturnsOnCall[len(fake.watchArgsForCall)] - fake.watchArgsForCall = append(fake.watchArgsForCall, struct { - opts v1.ListOptions - }{opts}) - fake.recordInvocation("Watch", []interface{}{opts}) - fake.watchMutex.Unlock() - if fake.WatchStub != nil { - return fake.WatchStub(opts) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.watchReturns.result1, fake.watchReturns.result2 -} - -func (fake *FakeClusterServicePlanInterface) WatchCallCount() int { - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - return len(fake.watchArgsForCall) -} - -func (fake *FakeClusterServicePlanInterface) WatchArgsForCall(i int) v1.ListOptions { - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - return fake.watchArgsForCall[i].opts -} - -func (fake *FakeClusterServicePlanInterface) WatchReturns(result1 watch.Interface, result2 error) { - fake.WatchStub = nil - fake.watchReturns = struct { - result1 watch.Interface - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) WatchReturnsOnCall(i int, result1 watch.Interface, result2 error) { - fake.WatchStub = nil - if fake.watchReturnsOnCall == nil { - fake.watchReturnsOnCall = make(map[int]struct { - result1 watch.Interface - result2 error - }) - } - fake.watchReturnsOnCall[i] = struct { - result1 watch.Interface - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterServicePlan, err error) { - var dataCopy []byte - if data != nil { - dataCopy = make([]byte, len(data)) - copy(dataCopy, data) - } - fake.patchMutex.Lock() - ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)] - fake.patchArgsForCall = append(fake.patchArgsForCall, struct { - name string - pt types.PatchType - data []byte - subresources []string - }{name, pt, dataCopy, subresources}) - fake.recordInvocation("Patch", []interface{}{name, pt, dataCopy, subresources}) - fake.patchMutex.Unlock() - if fake.PatchStub != nil { - return fake.PatchStub(name, pt, data, subresources...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.patchReturns.result1, fake.patchReturns.result2 -} - -func (fake *FakeClusterServicePlanInterface) PatchCallCount() int { - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - return len(fake.patchArgsForCall) -} - -func (fake *FakeClusterServicePlanInterface) PatchArgsForCall(i int) (string, types.PatchType, []byte, []string) { - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - return fake.patchArgsForCall[i].name, fake.patchArgsForCall[i].pt, fake.patchArgsForCall[i].data, fake.patchArgsForCall[i].subresources -} - -func (fake *FakeClusterServicePlanInterface) PatchReturns(result1 *v1beta1.ClusterServicePlan, result2 error) { - fake.PatchStub = nil - fake.patchReturns = struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) PatchReturnsOnCall(i int, result1 *v1beta1.ClusterServicePlan, result2 error) { - fake.PatchStub = nil - if fake.patchReturnsOnCall == nil { - fake.patchReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }) - } - fake.patchReturnsOnCall[i] = struct { - result1 *v1beta1.ClusterServicePlan - result2 error - }{result1, result2} -} - -func (fake *FakeClusterServicePlanInterface) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeClusterServicePlanInterface) recordInvocation(key string, args []interface{}) { - fake.invocationsMutex.Lock() - defer fake.invocationsMutex.Unlock() - if fake.invocations == nil { - fake.invocations = map[string][][]interface{}{} - } - if fake.invocations[key] == nil { - fake.invocations[key] = [][]interface{}{} - } - fake.invocations[key] = append(fake.invocations[key], args) -} - -var _ generated_v1beta1.ClusterServicePlanInterface = new(FakeClusterServicePlanInterface) diff --git a/plugin/pkg/kubectl/client/fakes/fake_interface.go b/plugin/pkg/kubectl/client/fakes/fake_interface.go deleted file mode 100644 index f7bba48c59a..00000000000 --- a/plugin/pkg/kubectl/client/fakes/fake_interface.go +++ /dev/null @@ -1,208 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -// Code generated by counterfeiter. DO NOT EDIT. -package fakes - -import ( - "sync" - - "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset" - servicecatalogv1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" - "k8s.io/client-go/discovery" -) - -type FakeInterface struct { - DiscoveryStub func() discovery.DiscoveryInterface - discoveryMutex sync.RWMutex - discoveryArgsForCall []struct{} - discoveryReturns struct { - result1 discovery.DiscoveryInterface - } - discoveryReturnsOnCall map[int]struct { - result1 discovery.DiscoveryInterface - } - ServicecatalogV1beta1Stub func() servicecatalogv1beta1.ServicecatalogV1beta1Interface - servicecatalogV1beta1Mutex sync.RWMutex - servicecatalogV1beta1ArgsForCall []struct{} - servicecatalogV1beta1Returns struct { - result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface - } - servicecatalogV1beta1ReturnsOnCall map[int]struct { - result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface - } - ServicecatalogStub func() servicecatalogv1beta1.ServicecatalogV1beta1Interface - servicecatalogMutex sync.RWMutex - servicecatalogArgsForCall []struct{} - servicecatalogReturns struct { - result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface - } - servicecatalogReturnsOnCall map[int]struct { - result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeInterface) Discovery() discovery.DiscoveryInterface { - fake.discoveryMutex.Lock() - ret, specificReturn := fake.discoveryReturnsOnCall[len(fake.discoveryArgsForCall)] - fake.discoveryArgsForCall = append(fake.discoveryArgsForCall, struct{}{}) - fake.recordInvocation("Discovery", []interface{}{}) - fake.discoveryMutex.Unlock() - if fake.DiscoveryStub != nil { - return fake.DiscoveryStub() - } - if specificReturn { - return ret.result1 - } - return fake.discoveryReturns.result1 -} - -func (fake *FakeInterface) DiscoveryCallCount() int { - fake.discoveryMutex.RLock() - defer fake.discoveryMutex.RUnlock() - return len(fake.discoveryArgsForCall) -} - -func (fake *FakeInterface) DiscoveryReturns(result1 discovery.DiscoveryInterface) { - fake.DiscoveryStub = nil - fake.discoveryReturns = struct { - result1 discovery.DiscoveryInterface - }{result1} -} - -func (fake *FakeInterface) DiscoveryReturnsOnCall(i int, result1 discovery.DiscoveryInterface) { - fake.DiscoveryStub = nil - if fake.discoveryReturnsOnCall == nil { - fake.discoveryReturnsOnCall = make(map[int]struct { - result1 discovery.DiscoveryInterface - }) - } - fake.discoveryReturnsOnCall[i] = struct { - result1 discovery.DiscoveryInterface - }{result1} -} - -func (fake *FakeInterface) ServicecatalogV1beta1() servicecatalogv1beta1.ServicecatalogV1beta1Interface { - fake.servicecatalogV1beta1Mutex.Lock() - ret, specificReturn := fake.servicecatalogV1beta1ReturnsOnCall[len(fake.servicecatalogV1beta1ArgsForCall)] - fake.servicecatalogV1beta1ArgsForCall = append(fake.servicecatalogV1beta1ArgsForCall, struct{}{}) - fake.recordInvocation("ServicecatalogV1beta1", []interface{}{}) - fake.servicecatalogV1beta1Mutex.Unlock() - if fake.ServicecatalogV1beta1Stub != nil { - return fake.ServicecatalogV1beta1Stub() - } - if specificReturn { - return ret.result1 - } - return fake.servicecatalogV1beta1Returns.result1 -} - -func (fake *FakeInterface) ServicecatalogV1beta1CallCount() int { - fake.servicecatalogV1beta1Mutex.RLock() - defer fake.servicecatalogV1beta1Mutex.RUnlock() - return len(fake.servicecatalogV1beta1ArgsForCall) -} - -func (fake *FakeInterface) ServicecatalogV1beta1Returns(result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface) { - fake.ServicecatalogV1beta1Stub = nil - fake.servicecatalogV1beta1Returns = struct { - result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface - }{result1} -} - -func (fake *FakeInterface) ServicecatalogV1beta1ReturnsOnCall(i int, result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface) { - fake.ServicecatalogV1beta1Stub = nil - if fake.servicecatalogV1beta1ReturnsOnCall == nil { - fake.servicecatalogV1beta1ReturnsOnCall = make(map[int]struct { - result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface - }) - } - fake.servicecatalogV1beta1ReturnsOnCall[i] = struct { - result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface - }{result1} -} - -func (fake *FakeInterface) Servicecatalog() servicecatalogv1beta1.ServicecatalogV1beta1Interface { - fake.servicecatalogMutex.Lock() - ret, specificReturn := fake.servicecatalogReturnsOnCall[len(fake.servicecatalogArgsForCall)] - fake.servicecatalogArgsForCall = append(fake.servicecatalogArgsForCall, struct{}{}) - fake.recordInvocation("Servicecatalog", []interface{}{}) - fake.servicecatalogMutex.Unlock() - if fake.ServicecatalogStub != nil { - return fake.ServicecatalogStub() - } - if specificReturn { - return ret.result1 - } - return fake.servicecatalogReturns.result1 -} - -func (fake *FakeInterface) ServicecatalogCallCount() int { - fake.servicecatalogMutex.RLock() - defer fake.servicecatalogMutex.RUnlock() - return len(fake.servicecatalogArgsForCall) -} - -func (fake *FakeInterface) ServicecatalogReturns(result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface) { - fake.ServicecatalogStub = nil - fake.servicecatalogReturns = struct { - result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface - }{result1} -} - -func (fake *FakeInterface) ServicecatalogReturnsOnCall(i int, result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface) { - fake.ServicecatalogStub = nil - if fake.servicecatalogReturnsOnCall == nil { - fake.servicecatalogReturnsOnCall = make(map[int]struct { - result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface - }) - } - fake.servicecatalogReturnsOnCall[i] = struct { - result1 servicecatalogv1beta1.ServicecatalogV1beta1Interface - }{result1} -} - -func (fake *FakeInterface) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.discoveryMutex.RLock() - defer fake.discoveryMutex.RUnlock() - fake.servicecatalogV1beta1Mutex.RLock() - defer fake.servicecatalogV1beta1Mutex.RUnlock() - fake.servicecatalogMutex.RLock() - defer fake.servicecatalogMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeInterface) recordInvocation(key string, args []interface{}) { - fake.invocationsMutex.Lock() - defer fake.invocationsMutex.Unlock() - if fake.invocations == nil { - fake.invocations = map[string][][]interface{}{} - } - if fake.invocations[key] == nil { - fake.invocations[key] = [][]interface{}{} - } - fake.invocations[key] = append(fake.invocations[key], args) -} - -var _ clientset.Interface = new(FakeInterface) diff --git a/plugin/pkg/kubectl/client/fakes/fake_servicebinding_interface.go b/plugin/pkg/kubectl/client/fakes/fake_servicebinding_interface.go deleted file mode 100644 index 88cf2249ad2..00000000000 --- a/plugin/pkg/kubectl/client/fakes/fake_servicebinding_interface.go +++ /dev/null @@ -1,658 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -// Code generated by counterfeiter. DO NOT EDIT. -package fakes - -import ( - "sync" - - "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" - generated_v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" - "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/watch" -) - -type FakeServiceBindingInterface struct { - CreateStub func(*v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) - createMutex sync.RWMutex - createArgsForCall []struct { - arg1 *v1beta1.ServiceBinding - } - createReturns struct { - result1 *v1beta1.ServiceBinding - result2 error - } - createReturnsOnCall map[int]struct { - result1 *v1beta1.ServiceBinding - result2 error - } - UpdateStub func(*v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) - updateMutex sync.RWMutex - updateArgsForCall []struct { - arg1 *v1beta1.ServiceBinding - } - updateReturns struct { - result1 *v1beta1.ServiceBinding - result2 error - } - updateReturnsOnCall map[int]struct { - result1 *v1beta1.ServiceBinding - result2 error - } - UpdateStatusStub func(*v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) - updateStatusMutex sync.RWMutex - updateStatusArgsForCall []struct { - arg1 *v1beta1.ServiceBinding - } - updateStatusReturns struct { - result1 *v1beta1.ServiceBinding - result2 error - } - updateStatusReturnsOnCall map[int]struct { - result1 *v1beta1.ServiceBinding - result2 error - } - DeleteStub func(name string, options *v1.DeleteOptions) error - deleteMutex sync.RWMutex - deleteArgsForCall []struct { - name string - options *v1.DeleteOptions - } - deleteReturns struct { - result1 error - } - deleteReturnsOnCall map[int]struct { - result1 error - } - DeleteCollectionStub func(options *v1.DeleteOptions, listOptions v1.ListOptions) error - deleteCollectionMutex sync.RWMutex - deleteCollectionArgsForCall []struct { - options *v1.DeleteOptions - listOptions v1.ListOptions - } - deleteCollectionReturns struct { - result1 error - } - deleteCollectionReturnsOnCall map[int]struct { - result1 error - } - GetStub func(name string, options v1.GetOptions) (*v1beta1.ServiceBinding, error) - getMutex sync.RWMutex - getArgsForCall []struct { - name string - options v1.GetOptions - } - getReturns struct { - result1 *v1beta1.ServiceBinding - result2 error - } - getReturnsOnCall map[int]struct { - result1 *v1beta1.ServiceBinding - result2 error - } - ListStub func(opts v1.ListOptions) (*v1beta1.ServiceBindingList, error) - listMutex sync.RWMutex - listArgsForCall []struct { - opts v1.ListOptions - } - listReturns struct { - result1 *v1beta1.ServiceBindingList - result2 error - } - listReturnsOnCall map[int]struct { - result1 *v1beta1.ServiceBindingList - result2 error - } - WatchStub func(opts v1.ListOptions) (watch.Interface, error) - watchMutex sync.RWMutex - watchArgsForCall []struct { - opts v1.ListOptions - } - watchReturns struct { - result1 watch.Interface - result2 error - } - watchReturnsOnCall map[int]struct { - result1 watch.Interface - result2 error - } - PatchStub func(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ServiceBinding, err error) - patchMutex sync.RWMutex - patchArgsForCall []struct { - name string - pt types.PatchType - data []byte - subresources []string - } - patchReturns struct { - result1 *v1beta1.ServiceBinding - result2 error - } - patchReturnsOnCall map[int]struct { - result1 *v1beta1.ServiceBinding - result2 error - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeServiceBindingInterface) Create(arg1 *v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) { - fake.createMutex.Lock() - ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] - fake.createArgsForCall = append(fake.createArgsForCall, struct { - arg1 *v1beta1.ServiceBinding - }{arg1}) - fake.recordInvocation("Create", []interface{}{arg1}) - fake.createMutex.Unlock() - if fake.CreateStub != nil { - return fake.CreateStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.createReturns.result1, fake.createReturns.result2 -} - -func (fake *FakeServiceBindingInterface) CreateCallCount() int { - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - return len(fake.createArgsForCall) -} - -func (fake *FakeServiceBindingInterface) CreateArgsForCall(i int) *v1beta1.ServiceBinding { - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - return fake.createArgsForCall[i].arg1 -} - -func (fake *FakeServiceBindingInterface) CreateReturns(result1 *v1beta1.ServiceBinding, result2 error) { - fake.CreateStub = nil - fake.createReturns = struct { - result1 *v1beta1.ServiceBinding - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) CreateReturnsOnCall(i int, result1 *v1beta1.ServiceBinding, result2 error) { - fake.CreateStub = nil - if fake.createReturnsOnCall == nil { - fake.createReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ServiceBinding - result2 error - }) - } - fake.createReturnsOnCall[i] = struct { - result1 *v1beta1.ServiceBinding - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) Update(arg1 *v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) { - fake.updateMutex.Lock() - ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] - fake.updateArgsForCall = append(fake.updateArgsForCall, struct { - arg1 *v1beta1.ServiceBinding - }{arg1}) - fake.recordInvocation("Update", []interface{}{arg1}) - fake.updateMutex.Unlock() - if fake.UpdateStub != nil { - return fake.UpdateStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.updateReturns.result1, fake.updateReturns.result2 -} - -func (fake *FakeServiceBindingInterface) UpdateCallCount() int { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return len(fake.updateArgsForCall) -} - -func (fake *FakeServiceBindingInterface) UpdateArgsForCall(i int) *v1beta1.ServiceBinding { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return fake.updateArgsForCall[i].arg1 -} - -func (fake *FakeServiceBindingInterface) UpdateReturns(result1 *v1beta1.ServiceBinding, result2 error) { - fake.UpdateStub = nil - fake.updateReturns = struct { - result1 *v1beta1.ServiceBinding - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) UpdateReturnsOnCall(i int, result1 *v1beta1.ServiceBinding, result2 error) { - fake.UpdateStub = nil - if fake.updateReturnsOnCall == nil { - fake.updateReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ServiceBinding - result2 error - }) - } - fake.updateReturnsOnCall[i] = struct { - result1 *v1beta1.ServiceBinding - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) UpdateStatus(arg1 *v1beta1.ServiceBinding) (*v1beta1.ServiceBinding, error) { - fake.updateStatusMutex.Lock() - ret, specificReturn := fake.updateStatusReturnsOnCall[len(fake.updateStatusArgsForCall)] - fake.updateStatusArgsForCall = append(fake.updateStatusArgsForCall, struct { - arg1 *v1beta1.ServiceBinding - }{arg1}) - fake.recordInvocation("UpdateStatus", []interface{}{arg1}) - fake.updateStatusMutex.Unlock() - if fake.UpdateStatusStub != nil { - return fake.UpdateStatusStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.updateStatusReturns.result1, fake.updateStatusReturns.result2 -} - -func (fake *FakeServiceBindingInterface) UpdateStatusCallCount() int { - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - return len(fake.updateStatusArgsForCall) -} - -func (fake *FakeServiceBindingInterface) UpdateStatusArgsForCall(i int) *v1beta1.ServiceBinding { - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - return fake.updateStatusArgsForCall[i].arg1 -} - -func (fake *FakeServiceBindingInterface) UpdateStatusReturns(result1 *v1beta1.ServiceBinding, result2 error) { - fake.UpdateStatusStub = nil - fake.updateStatusReturns = struct { - result1 *v1beta1.ServiceBinding - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) UpdateStatusReturnsOnCall(i int, result1 *v1beta1.ServiceBinding, result2 error) { - fake.UpdateStatusStub = nil - if fake.updateStatusReturnsOnCall == nil { - fake.updateStatusReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ServiceBinding - result2 error - }) - } - fake.updateStatusReturnsOnCall[i] = struct { - result1 *v1beta1.ServiceBinding - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) Delete(name string, options *v1.DeleteOptions) error { - fake.deleteMutex.Lock() - ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] - fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { - name string - options *v1.DeleteOptions - }{name, options}) - fake.recordInvocation("Delete", []interface{}{name, options}) - fake.deleteMutex.Unlock() - if fake.DeleteStub != nil { - return fake.DeleteStub(name, options) - } - if specificReturn { - return ret.result1 - } - return fake.deleteReturns.result1 -} - -func (fake *FakeServiceBindingInterface) DeleteCallCount() int { - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - return len(fake.deleteArgsForCall) -} - -func (fake *FakeServiceBindingInterface) DeleteArgsForCall(i int) (string, *v1.DeleteOptions) { - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - return fake.deleteArgsForCall[i].name, fake.deleteArgsForCall[i].options -} - -func (fake *FakeServiceBindingInterface) DeleteReturns(result1 error) { - fake.DeleteStub = nil - fake.deleteReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceBindingInterface) DeleteReturnsOnCall(i int, result1 error) { - fake.DeleteStub = nil - if fake.deleteReturnsOnCall == nil { - fake.deleteReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceBindingInterface) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { - fake.deleteCollectionMutex.Lock() - ret, specificReturn := fake.deleteCollectionReturnsOnCall[len(fake.deleteCollectionArgsForCall)] - fake.deleteCollectionArgsForCall = append(fake.deleteCollectionArgsForCall, struct { - options *v1.DeleteOptions - listOptions v1.ListOptions - }{options, listOptions}) - fake.recordInvocation("DeleteCollection", []interface{}{options, listOptions}) - fake.deleteCollectionMutex.Unlock() - if fake.DeleteCollectionStub != nil { - return fake.DeleteCollectionStub(options, listOptions) - } - if specificReturn { - return ret.result1 - } - return fake.deleteCollectionReturns.result1 -} - -func (fake *FakeServiceBindingInterface) DeleteCollectionCallCount() int { - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - return len(fake.deleteCollectionArgsForCall) -} - -func (fake *FakeServiceBindingInterface) DeleteCollectionArgsForCall(i int) (*v1.DeleteOptions, v1.ListOptions) { - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - return fake.deleteCollectionArgsForCall[i].options, fake.deleteCollectionArgsForCall[i].listOptions -} - -func (fake *FakeServiceBindingInterface) DeleteCollectionReturns(result1 error) { - fake.DeleteCollectionStub = nil - fake.deleteCollectionReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceBindingInterface) DeleteCollectionReturnsOnCall(i int, result1 error) { - fake.DeleteCollectionStub = nil - if fake.deleteCollectionReturnsOnCall == nil { - fake.deleteCollectionReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteCollectionReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceBindingInterface) Get(name string, options v1.GetOptions) (*v1beta1.ServiceBinding, error) { - fake.getMutex.Lock() - ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] - fake.getArgsForCall = append(fake.getArgsForCall, struct { - name string - options v1.GetOptions - }{name, options}) - fake.recordInvocation("Get", []interface{}{name, options}) - fake.getMutex.Unlock() - if fake.GetStub != nil { - return fake.GetStub(name, options) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.getReturns.result1, fake.getReturns.result2 -} - -func (fake *FakeServiceBindingInterface) GetCallCount() int { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - return len(fake.getArgsForCall) -} - -func (fake *FakeServiceBindingInterface) GetArgsForCall(i int) (string, v1.GetOptions) { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - return fake.getArgsForCall[i].name, fake.getArgsForCall[i].options -} - -func (fake *FakeServiceBindingInterface) GetReturns(result1 *v1beta1.ServiceBinding, result2 error) { - fake.GetStub = nil - fake.getReturns = struct { - result1 *v1beta1.ServiceBinding - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) GetReturnsOnCall(i int, result1 *v1beta1.ServiceBinding, result2 error) { - fake.GetStub = nil - if fake.getReturnsOnCall == nil { - fake.getReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ServiceBinding - result2 error - }) - } - fake.getReturnsOnCall[i] = struct { - result1 *v1beta1.ServiceBinding - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) List(opts v1.ListOptions) (*v1beta1.ServiceBindingList, error) { - fake.listMutex.Lock() - ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] - fake.listArgsForCall = append(fake.listArgsForCall, struct { - opts v1.ListOptions - }{opts}) - fake.recordInvocation("List", []interface{}{opts}) - fake.listMutex.Unlock() - if fake.ListStub != nil { - return fake.ListStub(opts) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.listReturns.result1, fake.listReturns.result2 -} - -func (fake *FakeServiceBindingInterface) ListCallCount() int { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return len(fake.listArgsForCall) -} - -func (fake *FakeServiceBindingInterface) ListArgsForCall(i int) v1.ListOptions { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return fake.listArgsForCall[i].opts -} - -func (fake *FakeServiceBindingInterface) ListReturns(result1 *v1beta1.ServiceBindingList, result2 error) { - fake.ListStub = nil - fake.listReturns = struct { - result1 *v1beta1.ServiceBindingList - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) ListReturnsOnCall(i int, result1 *v1beta1.ServiceBindingList, result2 error) { - fake.ListStub = nil - if fake.listReturnsOnCall == nil { - fake.listReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ServiceBindingList - result2 error - }) - } - fake.listReturnsOnCall[i] = struct { - result1 *v1beta1.ServiceBindingList - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) Watch(opts v1.ListOptions) (watch.Interface, error) { - fake.watchMutex.Lock() - ret, specificReturn := fake.watchReturnsOnCall[len(fake.watchArgsForCall)] - fake.watchArgsForCall = append(fake.watchArgsForCall, struct { - opts v1.ListOptions - }{opts}) - fake.recordInvocation("Watch", []interface{}{opts}) - fake.watchMutex.Unlock() - if fake.WatchStub != nil { - return fake.WatchStub(opts) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.watchReturns.result1, fake.watchReturns.result2 -} - -func (fake *FakeServiceBindingInterface) WatchCallCount() int { - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - return len(fake.watchArgsForCall) -} - -func (fake *FakeServiceBindingInterface) WatchArgsForCall(i int) v1.ListOptions { - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - return fake.watchArgsForCall[i].opts -} - -func (fake *FakeServiceBindingInterface) WatchReturns(result1 watch.Interface, result2 error) { - fake.WatchStub = nil - fake.watchReturns = struct { - result1 watch.Interface - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) WatchReturnsOnCall(i int, result1 watch.Interface, result2 error) { - fake.WatchStub = nil - if fake.watchReturnsOnCall == nil { - fake.watchReturnsOnCall = make(map[int]struct { - result1 watch.Interface - result2 error - }) - } - fake.watchReturnsOnCall[i] = struct { - result1 watch.Interface - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ServiceBinding, err error) { - var dataCopy []byte - if data != nil { - dataCopy = make([]byte, len(data)) - copy(dataCopy, data) - } - fake.patchMutex.Lock() - ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)] - fake.patchArgsForCall = append(fake.patchArgsForCall, struct { - name string - pt types.PatchType - data []byte - subresources []string - }{name, pt, dataCopy, subresources}) - fake.recordInvocation("Patch", []interface{}{name, pt, dataCopy, subresources}) - fake.patchMutex.Unlock() - if fake.PatchStub != nil { - return fake.PatchStub(name, pt, data, subresources...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.patchReturns.result1, fake.patchReturns.result2 -} - -func (fake *FakeServiceBindingInterface) PatchCallCount() int { - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - return len(fake.patchArgsForCall) -} - -func (fake *FakeServiceBindingInterface) PatchArgsForCall(i int) (string, types.PatchType, []byte, []string) { - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - return fake.patchArgsForCall[i].name, fake.patchArgsForCall[i].pt, fake.patchArgsForCall[i].data, fake.patchArgsForCall[i].subresources -} - -func (fake *FakeServiceBindingInterface) PatchReturns(result1 *v1beta1.ServiceBinding, result2 error) { - fake.PatchStub = nil - fake.patchReturns = struct { - result1 *v1beta1.ServiceBinding - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) PatchReturnsOnCall(i int, result1 *v1beta1.ServiceBinding, result2 error) { - fake.PatchStub = nil - if fake.patchReturnsOnCall == nil { - fake.patchReturnsOnCall = make(map[int]struct { - result1 *v1beta1.ServiceBinding - result2 error - }) - } - fake.patchReturnsOnCall[i] = struct { - result1 *v1beta1.ServiceBinding - result2 error - }{result1, result2} -} - -func (fake *FakeServiceBindingInterface) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeServiceBindingInterface) recordInvocation(key string, args []interface{}) { - fake.invocationsMutex.Lock() - defer fake.invocationsMutex.Unlock() - if fake.invocations == nil { - fake.invocations = map[string][][]interface{}{} - } - if fake.invocations[key] == nil { - fake.invocations[key] = [][]interface{}{} - } - fake.invocations[key] = append(fake.invocations[key], args) -} - -var _ generated_v1beta1.ServiceBindingInterface = new(FakeServiceBindingInterface) diff --git a/plugin/pkg/kubectl/client/fakes/fake_servicecatalogv1beta1_interface.go b/plugin/pkg/kubectl/client/fakes/fake_servicecatalogv1beta1_interface.go deleted file mode 100644 index 687b8ae6368..00000000000 --- a/plugin/pkg/kubectl/client/fakes/fake_servicecatalogv1beta1_interface.go +++ /dev/null @@ -1,380 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -// Code generated by counterfeiter. DO NOT EDIT. -package fakes - -import ( - "sync" - - "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" - "k8s.io/client-go/rest" -) - -type FakeServicecatalogV1beta1Interface struct { - RESTClientStub func() rest.Interface - rESTClientMutex sync.RWMutex - rESTClientArgsForCall []struct{} - rESTClientReturns struct { - result1 rest.Interface - } - rESTClientReturnsOnCall map[int]struct { - result1 rest.Interface - } - ClusterServiceBrokersStub func() v1beta1.ClusterServiceBrokerInterface - clusterServiceBrokersMutex sync.RWMutex - clusterServiceBrokersArgsForCall []struct{} - clusterServiceBrokersReturns struct { - result1 v1beta1.ClusterServiceBrokerInterface - } - clusterServiceBrokersReturnsOnCall map[int]struct { - result1 v1beta1.ClusterServiceBrokerInterface - } - ClusterServiceClassesStub func() v1beta1.ClusterServiceClassInterface - clusterServiceClassesMutex sync.RWMutex - clusterServiceClassesArgsForCall []struct{} - clusterServiceClassesReturns struct { - result1 v1beta1.ClusterServiceClassInterface - } - clusterServiceClassesReturnsOnCall map[int]struct { - result1 v1beta1.ClusterServiceClassInterface - } - ClusterServicePlansStub func() v1beta1.ClusterServicePlanInterface - clusterServicePlansMutex sync.RWMutex - clusterServicePlansArgsForCall []struct{} - clusterServicePlansReturns struct { - result1 v1beta1.ClusterServicePlanInterface - } - clusterServicePlansReturnsOnCall map[int]struct { - result1 v1beta1.ClusterServicePlanInterface - } - ServiceBindingsStub func(namespace string) v1beta1.ServiceBindingInterface - serviceBindingsMutex sync.RWMutex - serviceBindingsArgsForCall []struct { - namespace string - } - serviceBindingsReturns struct { - result1 v1beta1.ServiceBindingInterface - } - serviceBindingsReturnsOnCall map[int]struct { - result1 v1beta1.ServiceBindingInterface - } - ServiceInstancesStub func(namespace string) v1beta1.ServiceInstanceInterface - serviceInstancesMutex sync.RWMutex - serviceInstancesArgsForCall []struct { - namespace string - } - serviceInstancesReturns struct { - result1 v1beta1.ServiceInstanceInterface - } - serviceInstancesReturnsOnCall map[int]struct { - result1 v1beta1.ServiceInstanceInterface - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeServicecatalogV1beta1Interface) RESTClient() rest.Interface { - fake.rESTClientMutex.Lock() - ret, specificReturn := fake.rESTClientReturnsOnCall[len(fake.rESTClientArgsForCall)] - fake.rESTClientArgsForCall = append(fake.rESTClientArgsForCall, struct{}{}) - fake.recordInvocation("RESTClient", []interface{}{}) - fake.rESTClientMutex.Unlock() - if fake.RESTClientStub != nil { - return fake.RESTClientStub() - } - if specificReturn { - return ret.result1 - } - return fake.rESTClientReturns.result1 -} - -func (fake *FakeServicecatalogV1beta1Interface) RESTClientCallCount() int { - fake.rESTClientMutex.RLock() - defer fake.rESTClientMutex.RUnlock() - return len(fake.rESTClientArgsForCall) -} - -func (fake *FakeServicecatalogV1beta1Interface) RESTClientReturns(result1 rest.Interface) { - fake.RESTClientStub = nil - fake.rESTClientReturns = struct { - result1 rest.Interface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) RESTClientReturnsOnCall(i int, result1 rest.Interface) { - fake.RESTClientStub = nil - if fake.rESTClientReturnsOnCall == nil { - fake.rESTClientReturnsOnCall = make(map[int]struct { - result1 rest.Interface - }) - } - fake.rESTClientReturnsOnCall[i] = struct { - result1 rest.Interface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceBrokers() v1beta1.ClusterServiceBrokerInterface { - fake.clusterServiceBrokersMutex.Lock() - ret, specificReturn := fake.clusterServiceBrokersReturnsOnCall[len(fake.clusterServiceBrokersArgsForCall)] - fake.clusterServiceBrokersArgsForCall = append(fake.clusterServiceBrokersArgsForCall, struct{}{}) - fake.recordInvocation("ClusterServiceBrokers", []interface{}{}) - fake.clusterServiceBrokersMutex.Unlock() - if fake.ClusterServiceBrokersStub != nil { - return fake.ClusterServiceBrokersStub() - } - if specificReturn { - return ret.result1 - } - return fake.clusterServiceBrokersReturns.result1 -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceBrokersCallCount() int { - fake.clusterServiceBrokersMutex.RLock() - defer fake.clusterServiceBrokersMutex.RUnlock() - return len(fake.clusterServiceBrokersArgsForCall) -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceBrokersReturns(result1 v1beta1.ClusterServiceBrokerInterface) { - fake.ClusterServiceBrokersStub = nil - fake.clusterServiceBrokersReturns = struct { - result1 v1beta1.ClusterServiceBrokerInterface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceBrokersReturnsOnCall(i int, result1 v1beta1.ClusterServiceBrokerInterface) { - fake.ClusterServiceBrokersStub = nil - if fake.clusterServiceBrokersReturnsOnCall == nil { - fake.clusterServiceBrokersReturnsOnCall = make(map[int]struct { - result1 v1beta1.ClusterServiceBrokerInterface - }) - } - fake.clusterServiceBrokersReturnsOnCall[i] = struct { - result1 v1beta1.ClusterServiceBrokerInterface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceClasses() v1beta1.ClusterServiceClassInterface { - fake.clusterServiceClassesMutex.Lock() - ret, specificReturn := fake.clusterServiceClassesReturnsOnCall[len(fake.clusterServiceClassesArgsForCall)] - fake.clusterServiceClassesArgsForCall = append(fake.clusterServiceClassesArgsForCall, struct{}{}) - fake.recordInvocation("ClusterServiceClasses", []interface{}{}) - fake.clusterServiceClassesMutex.Unlock() - if fake.ClusterServiceClassesStub != nil { - return fake.ClusterServiceClassesStub() - } - if specificReturn { - return ret.result1 - } - return fake.clusterServiceClassesReturns.result1 -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceClassesCallCount() int { - fake.clusterServiceClassesMutex.RLock() - defer fake.clusterServiceClassesMutex.RUnlock() - return len(fake.clusterServiceClassesArgsForCall) -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceClassesReturns(result1 v1beta1.ClusterServiceClassInterface) { - fake.ClusterServiceClassesStub = nil - fake.clusterServiceClassesReturns = struct { - result1 v1beta1.ClusterServiceClassInterface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServiceClassesReturnsOnCall(i int, result1 v1beta1.ClusterServiceClassInterface) { - fake.ClusterServiceClassesStub = nil - if fake.clusterServiceClassesReturnsOnCall == nil { - fake.clusterServiceClassesReturnsOnCall = make(map[int]struct { - result1 v1beta1.ClusterServiceClassInterface - }) - } - fake.clusterServiceClassesReturnsOnCall[i] = struct { - result1 v1beta1.ClusterServiceClassInterface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServicePlans() v1beta1.ClusterServicePlanInterface { - fake.clusterServicePlansMutex.Lock() - ret, specificReturn := fake.clusterServicePlansReturnsOnCall[len(fake.clusterServicePlansArgsForCall)] - fake.clusterServicePlansArgsForCall = append(fake.clusterServicePlansArgsForCall, struct{}{}) - fake.recordInvocation("ClusterServicePlans", []interface{}{}) - fake.clusterServicePlansMutex.Unlock() - if fake.ClusterServicePlansStub != nil { - return fake.ClusterServicePlansStub() - } - if specificReturn { - return ret.result1 - } - return fake.clusterServicePlansReturns.result1 -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServicePlansCallCount() int { - fake.clusterServicePlansMutex.RLock() - defer fake.clusterServicePlansMutex.RUnlock() - return len(fake.clusterServicePlansArgsForCall) -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServicePlansReturns(result1 v1beta1.ClusterServicePlanInterface) { - fake.ClusterServicePlansStub = nil - fake.clusterServicePlansReturns = struct { - result1 v1beta1.ClusterServicePlanInterface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) ClusterServicePlansReturnsOnCall(i int, result1 v1beta1.ClusterServicePlanInterface) { - fake.ClusterServicePlansStub = nil - if fake.clusterServicePlansReturnsOnCall == nil { - fake.clusterServicePlansReturnsOnCall = make(map[int]struct { - result1 v1beta1.ClusterServicePlanInterface - }) - } - fake.clusterServicePlansReturnsOnCall[i] = struct { - result1 v1beta1.ClusterServicePlanInterface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) ServiceBindings(namespace string) v1beta1.ServiceBindingInterface { - fake.serviceBindingsMutex.Lock() - ret, specificReturn := fake.serviceBindingsReturnsOnCall[len(fake.serviceBindingsArgsForCall)] - fake.serviceBindingsArgsForCall = append(fake.serviceBindingsArgsForCall, struct { - namespace string - }{namespace}) - fake.recordInvocation("ServiceBindings", []interface{}{namespace}) - fake.serviceBindingsMutex.Unlock() - if fake.ServiceBindingsStub != nil { - return fake.ServiceBindingsStub(namespace) - } - if specificReturn { - return ret.result1 - } - return fake.serviceBindingsReturns.result1 -} - -func (fake *FakeServicecatalogV1beta1Interface) ServiceBindingsCallCount() int { - fake.serviceBindingsMutex.RLock() - defer fake.serviceBindingsMutex.RUnlock() - return len(fake.serviceBindingsArgsForCall) -} - -func (fake *FakeServicecatalogV1beta1Interface) ServiceBindingsArgsForCall(i int) string { - fake.serviceBindingsMutex.RLock() - defer fake.serviceBindingsMutex.RUnlock() - return fake.serviceBindingsArgsForCall[i].namespace -} - -func (fake *FakeServicecatalogV1beta1Interface) ServiceBindingsReturns(result1 v1beta1.ServiceBindingInterface) { - fake.ServiceBindingsStub = nil - fake.serviceBindingsReturns = struct { - result1 v1beta1.ServiceBindingInterface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) ServiceBindingsReturnsOnCall(i int, result1 v1beta1.ServiceBindingInterface) { - fake.ServiceBindingsStub = nil - if fake.serviceBindingsReturnsOnCall == nil { - fake.serviceBindingsReturnsOnCall = make(map[int]struct { - result1 v1beta1.ServiceBindingInterface - }) - } - fake.serviceBindingsReturnsOnCall[i] = struct { - result1 v1beta1.ServiceBindingInterface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) ServiceInstances(namespace string) v1beta1.ServiceInstanceInterface { - fake.serviceInstancesMutex.Lock() - ret, specificReturn := fake.serviceInstancesReturnsOnCall[len(fake.serviceInstancesArgsForCall)] - fake.serviceInstancesArgsForCall = append(fake.serviceInstancesArgsForCall, struct { - namespace string - }{namespace}) - fake.recordInvocation("ServiceInstances", []interface{}{namespace}) - fake.serviceInstancesMutex.Unlock() - if fake.ServiceInstancesStub != nil { - return fake.ServiceInstancesStub(namespace) - } - if specificReturn { - return ret.result1 - } - return fake.serviceInstancesReturns.result1 -} - -func (fake *FakeServicecatalogV1beta1Interface) ServiceInstancesCallCount() int { - fake.serviceInstancesMutex.RLock() - defer fake.serviceInstancesMutex.RUnlock() - return len(fake.serviceInstancesArgsForCall) -} - -func (fake *FakeServicecatalogV1beta1Interface) ServiceInstancesArgsForCall(i int) string { - fake.serviceInstancesMutex.RLock() - defer fake.serviceInstancesMutex.RUnlock() - return fake.serviceInstancesArgsForCall[i].namespace -} - -func (fake *FakeServicecatalogV1beta1Interface) ServiceInstancesReturns(result1 v1beta1.ServiceInstanceInterface) { - fake.ServiceInstancesStub = nil - fake.serviceInstancesReturns = struct { - result1 v1beta1.ServiceInstanceInterface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) ServiceInstancesReturnsOnCall(i int, result1 v1beta1.ServiceInstanceInterface) { - fake.ServiceInstancesStub = nil - if fake.serviceInstancesReturnsOnCall == nil { - fake.serviceInstancesReturnsOnCall = make(map[int]struct { - result1 v1beta1.ServiceInstanceInterface - }) - } - fake.serviceInstancesReturnsOnCall[i] = struct { - result1 v1beta1.ServiceInstanceInterface - }{result1} -} - -func (fake *FakeServicecatalogV1beta1Interface) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.rESTClientMutex.RLock() - defer fake.rESTClientMutex.RUnlock() - fake.clusterServiceBrokersMutex.RLock() - defer fake.clusterServiceBrokersMutex.RUnlock() - fake.clusterServiceClassesMutex.RLock() - defer fake.clusterServiceClassesMutex.RUnlock() - fake.clusterServicePlansMutex.RLock() - defer fake.clusterServicePlansMutex.RUnlock() - fake.serviceBindingsMutex.RLock() - defer fake.serviceBindingsMutex.RUnlock() - fake.serviceInstancesMutex.RLock() - defer fake.serviceInstancesMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeServicecatalogV1beta1Interface) recordInvocation(key string, args []interface{}) { - fake.invocationsMutex.Lock() - defer fake.invocationsMutex.Unlock() - if fake.invocations == nil { - fake.invocations = map[string][][]interface{}{} - } - if fake.invocations[key] == nil { - fake.invocations[key] = [][]interface{}{} - } - fake.invocations[key] = append(fake.invocations[key], args) -} - -var _ v1beta1.ServicecatalogV1beta1Interface = new(FakeServicecatalogV1beta1Interface) diff --git a/plugin/pkg/kubectl/client/fakes/fake_serviceinstance_interface.go b/plugin/pkg/kubectl/client/fakes/fake_serviceinstance_interface.go deleted file mode 100644 index e6254dbb175..00000000000 --- a/plugin/pkg/kubectl/client/fakes/fake_serviceinstance_interface.go +++ /dev/null @@ -1,724 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -// Code generated by counterfeiter. DO NOT EDIT. -package fakes - -import ( - "sync" - - v1beta1servicecatalog "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" - generated_v1beta1 "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/typed/servicecatalog/v1beta1" - "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/watch" -) - -type FakeServiceInstanceInterface struct { - CreateStub func(*v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) - createMutex sync.RWMutex - createArgsForCall []struct { - arg1 *v1beta1servicecatalog.ServiceInstance - } - createReturns struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - createReturnsOnCall map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - UpdateStub func(*v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) - updateMutex sync.RWMutex - updateArgsForCall []struct { - arg1 *v1beta1servicecatalog.ServiceInstance - } - updateReturns struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - updateReturnsOnCall map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - UpdateStatusStub func(*v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) - updateStatusMutex sync.RWMutex - updateStatusArgsForCall []struct { - arg1 *v1beta1servicecatalog.ServiceInstance - } - updateStatusReturns struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - updateStatusReturnsOnCall map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - DeleteStub func(name string, options *v1.DeleteOptions) error - deleteMutex sync.RWMutex - deleteArgsForCall []struct { - name string - options *v1.DeleteOptions - } - deleteReturns struct { - result1 error - } - deleteReturnsOnCall map[int]struct { - result1 error - } - DeleteCollectionStub func(options *v1.DeleteOptions, listOptions v1.ListOptions) error - deleteCollectionMutex sync.RWMutex - deleteCollectionArgsForCall []struct { - options *v1.DeleteOptions - listOptions v1.ListOptions - } - deleteCollectionReturns struct { - result1 error - } - deleteCollectionReturnsOnCall map[int]struct { - result1 error - } - GetStub func(name string, options v1.GetOptions) (*v1beta1servicecatalog.ServiceInstance, error) - getMutex sync.RWMutex - getArgsForCall []struct { - name string - options v1.GetOptions - } - getReturns struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - getReturnsOnCall map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - ListStub func(opts v1.ListOptions) (*v1beta1servicecatalog.ServiceInstanceList, error) - listMutex sync.RWMutex - listArgsForCall []struct { - opts v1.ListOptions - } - listReturns struct { - result1 *v1beta1servicecatalog.ServiceInstanceList - result2 error - } - listReturnsOnCall map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstanceList - result2 error - } - WatchStub func(opts v1.ListOptions) (watch.Interface, error) - watchMutex sync.RWMutex - watchArgsForCall []struct { - opts v1.ListOptions - } - watchReturns struct { - result1 watch.Interface - result2 error - } - watchReturnsOnCall map[int]struct { - result1 watch.Interface - result2 error - } - PatchStub func(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1servicecatalog.ServiceInstance, err error) - patchMutex sync.RWMutex - patchArgsForCall []struct { - name string - pt types.PatchType - data []byte - subresources []string - } - patchReturns struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - patchReturnsOnCall map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - UpdateReferencesStub func(serviceInstance *v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) - updateReferencesMutex sync.RWMutex - updateReferencesArgsForCall []struct { - serviceInstance *v1beta1servicecatalog.ServiceInstance - } - updateReferencesReturns struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - updateReferencesReturnsOnCall map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeServiceInstanceInterface) Create(arg1 *v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) { - fake.createMutex.Lock() - ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] - fake.createArgsForCall = append(fake.createArgsForCall, struct { - arg1 *v1beta1servicecatalog.ServiceInstance - }{arg1}) - fake.recordInvocation("Create", []interface{}{arg1}) - fake.createMutex.Unlock() - if fake.CreateStub != nil { - return fake.CreateStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.createReturns.result1, fake.createReturns.result2 -} - -func (fake *FakeServiceInstanceInterface) CreateCallCount() int { - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - return len(fake.createArgsForCall) -} - -func (fake *FakeServiceInstanceInterface) CreateArgsForCall(i int) *v1beta1servicecatalog.ServiceInstance { - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - return fake.createArgsForCall[i].arg1 -} - -func (fake *FakeServiceInstanceInterface) CreateReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.CreateStub = nil - fake.createReturns = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) CreateReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.CreateStub = nil - if fake.createReturnsOnCall == nil { - fake.createReturnsOnCall = make(map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }) - } - fake.createReturnsOnCall[i] = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) Update(arg1 *v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) { - fake.updateMutex.Lock() - ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] - fake.updateArgsForCall = append(fake.updateArgsForCall, struct { - arg1 *v1beta1servicecatalog.ServiceInstance - }{arg1}) - fake.recordInvocation("Update", []interface{}{arg1}) - fake.updateMutex.Unlock() - if fake.UpdateStub != nil { - return fake.UpdateStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.updateReturns.result1, fake.updateReturns.result2 -} - -func (fake *FakeServiceInstanceInterface) UpdateCallCount() int { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return len(fake.updateArgsForCall) -} - -func (fake *FakeServiceInstanceInterface) UpdateArgsForCall(i int) *v1beta1servicecatalog.ServiceInstance { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return fake.updateArgsForCall[i].arg1 -} - -func (fake *FakeServiceInstanceInterface) UpdateReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.UpdateStub = nil - fake.updateReturns = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) UpdateReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.UpdateStub = nil - if fake.updateReturnsOnCall == nil { - fake.updateReturnsOnCall = make(map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }) - } - fake.updateReturnsOnCall[i] = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) UpdateStatus(arg1 *v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) { - fake.updateStatusMutex.Lock() - ret, specificReturn := fake.updateStatusReturnsOnCall[len(fake.updateStatusArgsForCall)] - fake.updateStatusArgsForCall = append(fake.updateStatusArgsForCall, struct { - arg1 *v1beta1servicecatalog.ServiceInstance - }{arg1}) - fake.recordInvocation("UpdateStatus", []interface{}{arg1}) - fake.updateStatusMutex.Unlock() - if fake.UpdateStatusStub != nil { - return fake.UpdateStatusStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.updateStatusReturns.result1, fake.updateStatusReturns.result2 -} - -func (fake *FakeServiceInstanceInterface) UpdateStatusCallCount() int { - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - return len(fake.updateStatusArgsForCall) -} - -func (fake *FakeServiceInstanceInterface) UpdateStatusArgsForCall(i int) *v1beta1servicecatalog.ServiceInstance { - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - return fake.updateStatusArgsForCall[i].arg1 -} - -func (fake *FakeServiceInstanceInterface) UpdateStatusReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.UpdateStatusStub = nil - fake.updateStatusReturns = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) UpdateStatusReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.UpdateStatusStub = nil - if fake.updateStatusReturnsOnCall == nil { - fake.updateStatusReturnsOnCall = make(map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }) - } - fake.updateStatusReturnsOnCall[i] = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) Delete(name string, options *v1.DeleteOptions) error { - fake.deleteMutex.Lock() - ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] - fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { - name string - options *v1.DeleteOptions - }{name, options}) - fake.recordInvocation("Delete", []interface{}{name, options}) - fake.deleteMutex.Unlock() - if fake.DeleteStub != nil { - return fake.DeleteStub(name, options) - } - if specificReturn { - return ret.result1 - } - return fake.deleteReturns.result1 -} - -func (fake *FakeServiceInstanceInterface) DeleteCallCount() int { - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - return len(fake.deleteArgsForCall) -} - -func (fake *FakeServiceInstanceInterface) DeleteArgsForCall(i int) (string, *v1.DeleteOptions) { - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - return fake.deleteArgsForCall[i].name, fake.deleteArgsForCall[i].options -} - -func (fake *FakeServiceInstanceInterface) DeleteReturns(result1 error) { - fake.DeleteStub = nil - fake.deleteReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceInstanceInterface) DeleteReturnsOnCall(i int, result1 error) { - fake.DeleteStub = nil - if fake.deleteReturnsOnCall == nil { - fake.deleteReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceInstanceInterface) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { - fake.deleteCollectionMutex.Lock() - ret, specificReturn := fake.deleteCollectionReturnsOnCall[len(fake.deleteCollectionArgsForCall)] - fake.deleteCollectionArgsForCall = append(fake.deleteCollectionArgsForCall, struct { - options *v1.DeleteOptions - listOptions v1.ListOptions - }{options, listOptions}) - fake.recordInvocation("DeleteCollection", []interface{}{options, listOptions}) - fake.deleteCollectionMutex.Unlock() - if fake.DeleteCollectionStub != nil { - return fake.DeleteCollectionStub(options, listOptions) - } - if specificReturn { - return ret.result1 - } - return fake.deleteCollectionReturns.result1 -} - -func (fake *FakeServiceInstanceInterface) DeleteCollectionCallCount() int { - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - return len(fake.deleteCollectionArgsForCall) -} - -func (fake *FakeServiceInstanceInterface) DeleteCollectionArgsForCall(i int) (*v1.DeleteOptions, v1.ListOptions) { - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - return fake.deleteCollectionArgsForCall[i].options, fake.deleteCollectionArgsForCall[i].listOptions -} - -func (fake *FakeServiceInstanceInterface) DeleteCollectionReturns(result1 error) { - fake.DeleteCollectionStub = nil - fake.deleteCollectionReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceInstanceInterface) DeleteCollectionReturnsOnCall(i int, result1 error) { - fake.DeleteCollectionStub = nil - if fake.deleteCollectionReturnsOnCall == nil { - fake.deleteCollectionReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteCollectionReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeServiceInstanceInterface) Get(name string, options v1.GetOptions) (*v1beta1servicecatalog.ServiceInstance, error) { - fake.getMutex.Lock() - ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] - fake.getArgsForCall = append(fake.getArgsForCall, struct { - name string - options v1.GetOptions - }{name, options}) - fake.recordInvocation("Get", []interface{}{name, options}) - fake.getMutex.Unlock() - if fake.GetStub != nil { - return fake.GetStub(name, options) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.getReturns.result1, fake.getReturns.result2 -} - -func (fake *FakeServiceInstanceInterface) GetCallCount() int { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - return len(fake.getArgsForCall) -} - -func (fake *FakeServiceInstanceInterface) GetArgsForCall(i int) (string, v1.GetOptions) { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - return fake.getArgsForCall[i].name, fake.getArgsForCall[i].options -} - -func (fake *FakeServiceInstanceInterface) GetReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.GetStub = nil - fake.getReturns = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) GetReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.GetStub = nil - if fake.getReturnsOnCall == nil { - fake.getReturnsOnCall = make(map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }) - } - fake.getReturnsOnCall[i] = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) List(opts v1.ListOptions) (*v1beta1servicecatalog.ServiceInstanceList, error) { - fake.listMutex.Lock() - ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] - fake.listArgsForCall = append(fake.listArgsForCall, struct { - opts v1.ListOptions - }{opts}) - fake.recordInvocation("List", []interface{}{opts}) - fake.listMutex.Unlock() - if fake.ListStub != nil { - return fake.ListStub(opts) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.listReturns.result1, fake.listReturns.result2 -} - -func (fake *FakeServiceInstanceInterface) ListCallCount() int { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return len(fake.listArgsForCall) -} - -func (fake *FakeServiceInstanceInterface) ListArgsForCall(i int) v1.ListOptions { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return fake.listArgsForCall[i].opts -} - -func (fake *FakeServiceInstanceInterface) ListReturns(result1 *v1beta1servicecatalog.ServiceInstanceList, result2 error) { - fake.ListStub = nil - fake.listReturns = struct { - result1 *v1beta1servicecatalog.ServiceInstanceList - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) ListReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstanceList, result2 error) { - fake.ListStub = nil - if fake.listReturnsOnCall == nil { - fake.listReturnsOnCall = make(map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstanceList - result2 error - }) - } - fake.listReturnsOnCall[i] = struct { - result1 *v1beta1servicecatalog.ServiceInstanceList - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) Watch(opts v1.ListOptions) (watch.Interface, error) { - fake.watchMutex.Lock() - ret, specificReturn := fake.watchReturnsOnCall[len(fake.watchArgsForCall)] - fake.watchArgsForCall = append(fake.watchArgsForCall, struct { - opts v1.ListOptions - }{opts}) - fake.recordInvocation("Watch", []interface{}{opts}) - fake.watchMutex.Unlock() - if fake.WatchStub != nil { - return fake.WatchStub(opts) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.watchReturns.result1, fake.watchReturns.result2 -} - -func (fake *FakeServiceInstanceInterface) WatchCallCount() int { - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - return len(fake.watchArgsForCall) -} - -func (fake *FakeServiceInstanceInterface) WatchArgsForCall(i int) v1.ListOptions { - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - return fake.watchArgsForCall[i].opts -} - -func (fake *FakeServiceInstanceInterface) WatchReturns(result1 watch.Interface, result2 error) { - fake.WatchStub = nil - fake.watchReturns = struct { - result1 watch.Interface - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) WatchReturnsOnCall(i int, result1 watch.Interface, result2 error) { - fake.WatchStub = nil - if fake.watchReturnsOnCall == nil { - fake.watchReturnsOnCall = make(map[int]struct { - result1 watch.Interface - result2 error - }) - } - fake.watchReturnsOnCall[i] = struct { - result1 watch.Interface - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1servicecatalog.ServiceInstance, err error) { - var dataCopy []byte - if data != nil { - dataCopy = make([]byte, len(data)) - copy(dataCopy, data) - } - fake.patchMutex.Lock() - ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)] - fake.patchArgsForCall = append(fake.patchArgsForCall, struct { - name string - pt types.PatchType - data []byte - subresources []string - }{name, pt, dataCopy, subresources}) - fake.recordInvocation("Patch", []interface{}{name, pt, dataCopy, subresources}) - fake.patchMutex.Unlock() - if fake.PatchStub != nil { - return fake.PatchStub(name, pt, data, subresources...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.patchReturns.result1, fake.patchReturns.result2 -} - -func (fake *FakeServiceInstanceInterface) PatchCallCount() int { - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - return len(fake.patchArgsForCall) -} - -func (fake *FakeServiceInstanceInterface) PatchArgsForCall(i int) (string, types.PatchType, []byte, []string) { - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - return fake.patchArgsForCall[i].name, fake.patchArgsForCall[i].pt, fake.patchArgsForCall[i].data, fake.patchArgsForCall[i].subresources -} - -func (fake *FakeServiceInstanceInterface) PatchReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.PatchStub = nil - fake.patchReturns = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) PatchReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.PatchStub = nil - if fake.patchReturnsOnCall == nil { - fake.patchReturnsOnCall = make(map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }) - } - fake.patchReturnsOnCall[i] = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) UpdateReferences(serviceInstance *v1beta1servicecatalog.ServiceInstance) (*v1beta1servicecatalog.ServiceInstance, error) { - fake.updateReferencesMutex.Lock() - ret, specificReturn := fake.updateReferencesReturnsOnCall[len(fake.updateReferencesArgsForCall)] - fake.updateReferencesArgsForCall = append(fake.updateReferencesArgsForCall, struct { - serviceInstance *v1beta1servicecatalog.ServiceInstance - }{serviceInstance}) - fake.recordInvocation("UpdateReferences", []interface{}{serviceInstance}) - fake.updateReferencesMutex.Unlock() - if fake.UpdateReferencesStub != nil { - return fake.UpdateReferencesStub(serviceInstance) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fake.updateReferencesReturns.result1, fake.updateReferencesReturns.result2 -} - -func (fake *FakeServiceInstanceInterface) UpdateReferencesCallCount() int { - fake.updateReferencesMutex.RLock() - defer fake.updateReferencesMutex.RUnlock() - return len(fake.updateReferencesArgsForCall) -} - -func (fake *FakeServiceInstanceInterface) UpdateReferencesArgsForCall(i int) *v1beta1servicecatalog.ServiceInstance { - fake.updateReferencesMutex.RLock() - defer fake.updateReferencesMutex.RUnlock() - return fake.updateReferencesArgsForCall[i].serviceInstance -} - -func (fake *FakeServiceInstanceInterface) UpdateReferencesReturns(result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.UpdateReferencesStub = nil - fake.updateReferencesReturns = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) UpdateReferencesReturnsOnCall(i int, result1 *v1beta1servicecatalog.ServiceInstance, result2 error) { - fake.UpdateReferencesStub = nil - if fake.updateReferencesReturnsOnCall == nil { - fake.updateReferencesReturnsOnCall = make(map[int]struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }) - } - fake.updateReferencesReturnsOnCall[i] = struct { - result1 *v1beta1servicecatalog.ServiceInstance - result2 error - }{result1, result2} -} - -func (fake *FakeServiceInstanceInterface) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.createMutex.RLock() - defer fake.createMutex.RUnlock() - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - fake.updateStatusMutex.RLock() - defer fake.updateStatusMutex.RUnlock() - fake.deleteMutex.RLock() - defer fake.deleteMutex.RUnlock() - fake.deleteCollectionMutex.RLock() - defer fake.deleteCollectionMutex.RUnlock() - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - fake.watchMutex.RLock() - defer fake.watchMutex.RUnlock() - fake.patchMutex.RLock() - defer fake.patchMutex.RUnlock() - fake.updateReferencesMutex.RLock() - defer fake.updateReferencesMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeServiceInstanceInterface) recordInvocation(key string, args []interface{}) { - fake.invocationsMutex.Lock() - defer fake.invocationsMutex.Unlock() - if fake.invocations == nil { - fake.invocations = map[string][][]interface{}{} - } - if fake.invocations[key] == nil { - fake.invocations[key] = [][]interface{}{} - } - fake.invocations[key] = append(fake.invocations[key], args) -} - -var _ generated_v1beta1.ServiceInstanceInterface = new(FakeServiceInstanceInterface) diff --git a/plugin/pkg/kubectl/client/instance_test.go b/plugin/pkg/kubectl/client/instance_test.go index 9b590e1aa78..19ad17a1909 100644 --- a/plugin/pkg/kubectl/client/instance_test.go +++ b/plugin/pkg/kubectl/client/instance_test.go @@ -17,10 +17,15 @@ limitations under the License. package client_test import ( - "errors" + "fmt" + + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/fake" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/testing" . "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client/fakes" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" @@ -28,46 +33,47 @@ import ( var _ = Describe("Instances", func() { var ( - client *PluginClient - err error - FakeScClient *fakes.FakeInterface - ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface - ServiceInstances *fakes.FakeServiceInstanceInterface + client *PluginClient + err error + svcCatClient *fake.Clientset + si *v1beta1.ServiceInstance + si2 *v1beta1.ServiceInstance ) BeforeEach(func() { client, err = NewClient() Expect(err).NotTo(HaveOccurred()) - FakeScClient = &fakes.FakeInterface{} - ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} - ServiceInstances = &fakes.FakeServiceInstanceInterface{} - - client.ScClient = FakeScClient - FakeScClient.ServicecatalogV1beta1Returns(ServicecatalogV1beta1) - ServicecatalogV1beta1.ServiceInstancesReturns(ServiceInstances) + si = &v1beta1.ServiceInstance{ObjectMeta: metav1.ObjectMeta{Name: "foobar", Namespace: "foobar_namespace"}} + si2 = &v1beta1.ServiceInstance{ObjectMeta: metav1.ObjectMeta{Name: "barbaz", Namespace: "foobar_namespace"}} + svcCatClient = fake.NewSimpleClientset(si, si2) + client.ScClient = svcCatClient }) Describe("Get", func() { It("Calls the generated v1beta1 List method with the passed in instance and namespace", func() { + instanceName := "foobar" namespace := "foobar_namespace" - instanceName := "potato_instance" - _, err := client.GetInstance(instanceName, namespace) + instance, err := client.GetInstance(instanceName, namespace) Expect(err).NotTo(HaveOccurred()) - Expect(ServicecatalogV1beta1.ServiceInstancesArgsForCall(0)).To(Equal(namespace)) - returnedName, _ := ServiceInstances.GetArgsForCall(0) - Expect(returnedName).To(Equal(instanceName)) - Expect(ServiceInstances.GetCallCount()).To(Equal(1)) + Expect(instance.Name).To(Equal(instanceName)) + + actions := svcCatClient.Actions() + Expect(actions[0].Matches("get", "serviceinstances")).To(BeTrue()) + Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(instanceName)) + Expect(actions[0].(testing.GetActionImpl).Namespace).To(Equal(namespace)) }) It("Bubbles up errors", func() { + instanceName := "not_real" namespace := "foobar_namespace" - instanceName := "potato_instance" - errorMessage := "instance not found" - ServiceInstances.GetReturns(nil, errors.New(errorMessage)) _, err := client.GetInstance(instanceName, namespace) Expect(err).To(HaveOccurred()) - Expect(ServiceInstances.GetCallCount()).To(Equal(1)) + Expect(err.Error()).Should(ContainSubstring("not found")) + actions := svcCatClient.Actions() + Expect(actions[0].Matches("get", "serviceinstances")).To(BeTrue()) + Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(instanceName)) + Expect(actions[0].(testing.GetActionImpl).Namespace).To(Equal(namespace)) }) }) @@ -75,22 +81,26 @@ var _ = Describe("Instances", func() { It("Calls the generated v1beta1 List method with the specified namespace", func() { namespace := "foobar_namespace" - _, err := client.ListInstances(namespace) + instances, err := client.ListInstances(namespace) Expect(err).NotTo(HaveOccurred()) - Expect(ServicecatalogV1beta1.ServiceInstancesArgsForCall(0)).To(Equal(namespace)) - Expect(ServiceInstances.ListCallCount()).To(Equal(1)) + Expect(instances.Items).Should(ConsistOf(*si, *si2)) + Expect(svcCatClient.Actions()[0].Matches("list", "serviceinstances")).To(BeTrue()) }) It("Bubbles up errors", func() { - ServiceInstances.ListReturns(nil, errors.New("foobar")) + badClient := &fake.Clientset{} + errorMessage := "error retrieving list" + badClient.AddReactor("list", "serviceinstances", func(action testing.Action) (bool, runtime.Object, error) { + return true, nil, fmt.Errorf(errorMessage) + }) + client.ScClient = badClient namespace := "foobar_namespace" _, err := client.ListInstances(namespace) Expect(err).To(HaveOccurred()) - Expect(err.Error()).Should(ContainSubstring("foobar")) - Expect(ServicecatalogV1beta1.ServiceInstancesArgsForCall(0)).To(Equal(namespace)) - Expect(ServiceInstances.ListCallCount()).To(Equal(1)) + Expect(err.Error()).Should(ContainSubstring(errorMessage)) + Expect(badClient.Actions()[0].Matches("list", "serviceinstances")).To(BeTrue()) }) }) }) diff --git a/plugin/pkg/kubectl/client/plan_test.go b/plugin/pkg/kubectl/client/plan_test.go index 7af6af3ada0..e615a5cbe46 100644 --- a/plugin/pkg/kubectl/client/plan_test.go +++ b/plugin/pkg/kubectl/client/plan_test.go @@ -17,10 +17,15 @@ limitations under the License. package client_test import ( - "errors" + "fmt" + + "github.com/kubernetes-incubator/service-catalog/pkg/apis/servicecatalog/v1beta1" + "github.com/kubernetes-incubator/service-catalog/pkg/client/clientset_generated/clientset/fake" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/client-go/testing" . "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client" - "github.com/kubernetes-incubator/service-catalog/plugin/pkg/kubectl/client/fakes" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" @@ -28,62 +33,70 @@ import ( var _ = Describe("Plan", func() { var ( - client *PluginClient - err error - FakeScClient *fakes.FakeInterface - ServicecatalogV1beta1 *fakes.FakeServicecatalogV1beta1Interface - ClusterServicePlans *fakes.FakeClusterServicePlanInterface + client *PluginClient + err error + svcCatClient *fake.Clientset + sp *v1beta1.ClusterServicePlan + sp2 *v1beta1.ClusterServicePlan ) BeforeEach(func() { client, err = NewClient() Expect(err).NotTo(HaveOccurred()) - FakeScClient = &fakes.FakeInterface{} - ServicecatalogV1beta1 = &fakes.FakeServicecatalogV1beta1Interface{} - ClusterServicePlans = &fakes.FakeClusterServicePlanInterface{} - client.ScClient = FakeScClient - FakeScClient.ServicecatalogV1beta1Returns(ServicecatalogV1beta1) - ServicecatalogV1beta1.ClusterServicePlansReturns(ClusterServicePlans) + sp = &v1beta1.ClusterServicePlan{ObjectMeta: metav1.ObjectMeta{Name: "foobar"}} + sp2 = &v1beta1.ClusterServicePlan{ObjectMeta: metav1.ObjectMeta{Name: "barbaz"}} + svcCatClient = fake.NewSimpleClientset(sp, sp2) + client.ScClient = svcCatClient }) Describe("Get", func() { It("Calls the generated v1beta1 List method with the passed in plan", func() { planName := "foobar" - _, err = client.GetPlan(planName) - Expect(ClusterServicePlans.GetCallCount()).To(Equal(1)) - name, _ := ClusterServicePlans.GetArgsForCall(0) - Expect(name).To(Equal(planName)) + plan, err := client.GetPlan(planName) + + Expect(err).NotTo(HaveOccurred()) + Expect(plan.Name).To(Equal(planName)) + actions := svcCatClient.Actions() + Expect(actions[0].Matches("get", "clusterserviceplans")).To(BeTrue()) + Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(planName)) + }) It("Bubbles up errors", func() { - errorMessage := "plan not found" - ClusterServicePlans.GetReturns(nil, errors.New(errorMessage)) + planName := "not_real" - _, err := client.GetPlan("banana") + plan, err := client.GetPlan(planName) + Expect(plan).To(BeNil()) Expect(err).To(HaveOccurred()) - Expect(err.Error()).Should(ContainSubstring(errorMessage)) - Expect(ClusterServicePlans.GetCallCount()).To(Equal(1)) + Expect(err.Error()).Should(ContainSubstring("not found")) + actions := svcCatClient.Actions() + Expect(actions[0].Matches("get", "clusterserviceplans")).To(BeTrue()) + Expect(actions[0].(testing.GetActionImpl).Name).To(Equal(planName)) }) }) Describe("List", func() { It("Calls the generated v1beta1 List method", func() { - _, err := client.ListPlans() + plans, err := client.ListPlans() Expect(err).NotTo(HaveOccurred()) - Expect(ClusterServicePlans.ListCallCount()).To(Equal(1)) + Expect(plans.Items).Should(ConsistOf(*sp, *sp2)) + Expect(svcCatClient.Actions()[0].Matches("list", "clusterserviceplans")).To(BeTrue()) }) It("Bubbles up errors", func() { - errorMessage := "foobar" - ClusterServicePlans.ListReturns(nil, errors.New(errorMessage)) - + badClient := &fake.Clientset{} + errorMessage := "error retrieving list" + badClient.AddReactor("list", "clusterserviceplans", func(action testing.Action) (bool, runtime.Object, error) { + return true, nil, fmt.Errorf(errorMessage) + }) + client.ScClient = badClient _, err := client.ListPlans() Expect(err).To(HaveOccurred()) Expect(err.Error()).Should(ContainSubstring(errorMessage)) - Expect(ClusterServicePlans.ListCallCount()).To(Equal(1)) + Expect(badClient.Actions()[0].Matches("list", "clusterserviceplans")).To(BeTrue()) }) }) }) From fba2ea0509d1f0f80d566d180529791a98df4960 Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Tue, 16 Jan 2018 14:42:57 -0800 Subject: [PATCH 23/24] fix dependencies for color change --- vendor/github.com/fatih/color | 1 - vendor/github.com/fatih/color/LICENSE.md | 20 + vendor/github.com/fatih/color/README.md | 154 ++++ vendor/github.com/fatih/color/color.go | 402 +++++++++ vendor/github.com/fatih/color/color_test.go | 226 +++++ vendor/github.com/fatih/color/doc.go | 114 +++ vendor/github.com/mattn/go-colorable | 1 - vendor/github.com/mattn/go-colorable/LICENSE | 21 + .../github.com/mattn/go-colorable/README.md | 43 + .../mattn/go-colorable/colorable_others.go | 24 + .../mattn/go-colorable/colorable_windows.go | 809 ++++++++++++++++++ .../mattn/go-colorable/noncolorable.go | 57 ++ vendor/github.com/mattn/go-isatty | 1 - vendor/github.com/mattn/go-isatty/LICENSE | 9 + vendor/github.com/mattn/go-isatty/README.md | 37 + vendor/github.com/mattn/go-isatty/doc.go | 2 + .../mattn/go-isatty/isatty_appengine.go | 9 + .../github.com/mattn/go-isatty/isatty_bsd.go | 18 + .../mattn/go-isatty/isatty_linux.go | 18 + .../mattn/go-isatty/isatty_solaris.go | 16 + .../mattn/go-isatty/isatty_windows.go | 19 + 21 files changed, 1998 insertions(+), 3 deletions(-) delete mode 160000 vendor/github.com/fatih/color create mode 100644 vendor/github.com/fatih/color/LICENSE.md create mode 100644 vendor/github.com/fatih/color/README.md create mode 100644 vendor/github.com/fatih/color/color.go create mode 100644 vendor/github.com/fatih/color/color_test.go create mode 100644 vendor/github.com/fatih/color/doc.go delete mode 160000 vendor/github.com/mattn/go-colorable create mode 100644 vendor/github.com/mattn/go-colorable/LICENSE create mode 100644 vendor/github.com/mattn/go-colorable/README.md create mode 100644 vendor/github.com/mattn/go-colorable/colorable_others.go create mode 100644 vendor/github.com/mattn/go-colorable/colorable_windows.go create mode 100644 vendor/github.com/mattn/go-colorable/noncolorable.go delete mode 160000 vendor/github.com/mattn/go-isatty create mode 100644 vendor/github.com/mattn/go-isatty/LICENSE create mode 100644 vendor/github.com/mattn/go-isatty/README.md create mode 100644 vendor/github.com/mattn/go-isatty/doc.go create mode 100644 vendor/github.com/mattn/go-isatty/isatty_appengine.go create mode 100644 vendor/github.com/mattn/go-isatty/isatty_bsd.go create mode 100644 vendor/github.com/mattn/go-isatty/isatty_linux.go create mode 100644 vendor/github.com/mattn/go-isatty/isatty_solaris.go create mode 100644 vendor/github.com/mattn/go-isatty/isatty_windows.go diff --git a/vendor/github.com/fatih/color b/vendor/github.com/fatih/color deleted file mode 160000 index 87d4004f2ab..00000000000 --- a/vendor/github.com/fatih/color +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 87d4004f2ab62d0d255e0a38f1680aa534549fe3 diff --git a/vendor/github.com/fatih/color/LICENSE.md b/vendor/github.com/fatih/color/LICENSE.md new file mode 100644 index 00000000000..25fdaf639df --- /dev/null +++ b/vendor/github.com/fatih/color/LICENSE.md @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright (c) 2013 Fatih Arslan + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/github.com/fatih/color/README.md b/vendor/github.com/fatih/color/README.md new file mode 100644 index 00000000000..0921f98a5f3 --- /dev/null +++ b/vendor/github.com/fatih/color/README.md @@ -0,0 +1,154 @@ +# Color [![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/fatih/color) [![Build Status](http://img.shields.io/travis/fatih/color.svg?style=flat-square)](https://travis-ci.org/fatih/color) + + + +Color lets you use colorized outputs in terms of [ANSI Escape +Codes](http://en.wikipedia.org/wiki/ANSI_escape_code#Colors) in Go (Golang). It +has support for Windows too! The API can be used in several ways, pick one that +suits you. + + + +![Color](http://i.imgur.com/c1JI0lA.png) + + +## Install + +```bash +go get github.com/fatih/color +``` + +## Examples + +### Standard colors + +```go +// Print with default helper functions +color.Cyan("Prints text in cyan.") + +// A newline will be appended automatically +color.Blue("Prints %s in blue.", "text") + +// These are using the default foreground colors +color.Red("We have red") +color.Magenta("And many others ..") + +``` + +### Mix and reuse colors + +```go +// Create a new color object +c := color.New(color.FgCyan).Add(color.Underline) +c.Println("Prints cyan text with an underline.") + +// Or just add them to New() +d := color.New(color.FgCyan, color.Bold) +d.Printf("This prints bold cyan %s\n", "too!.") + +// Mix up foreground and background colors, create new mixes! +red := color.New(color.FgRed) + +boldRed := red.Add(color.Bold) +boldRed.Println("This will print text in bold red.") + +whiteBackground := red.Add(color.BgWhite) +whiteBackground.Println("Red text with white background.") +``` + +### Custom print functions (PrintFunc) + +```go +// Create a custom print function for convenience +red := color.New(color.FgRed).PrintfFunc() +red("Warning") +red("Error: %s", err) + +// Mix up multiple attributes +notice := color.New(color.Bold, color.FgGreen).PrintlnFunc() +notice("Don't forget this...") +``` + +### Insert into noncolor strings (SprintFunc) + +```go +// Create SprintXxx functions to mix strings with other non-colorized strings: +yellow := color.New(color.FgYellow).SprintFunc() +red := color.New(color.FgRed).SprintFunc() +fmt.Printf("This is a %s and this is %s.\n", yellow("warning"), red("error")) + +info := color.New(color.FgWhite, color.BgGreen).SprintFunc() +fmt.Printf("This %s rocks!\n", info("package")) + +// Use helper functions +fmt.Printf("This", color.RedString("warning"), "should be not neglected.") +fmt.Printf(color.GreenString("Info:"), "an important message." ) + +// Windows supported too! Just don't forget to change the output to color.Output +fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS")) +``` + +### Plug into existing code + +```go +// Use handy standard colors +color.Set(color.FgYellow) + +fmt.Println("Existing text will now be in yellow") +fmt.Printf("This one %s\n", "too") + +color.Unset() // Don't forget to unset + +// You can mix up parameters +color.Set(color.FgMagenta, color.Bold) +defer color.Unset() // Use it in your function + +fmt.Println("All text will now be bold magenta.") +``` + +### Disable color + +There might be a case where you want to disable color output (for example to +pipe the standard output of your app to somewhere else). `Color` has support to +disable colors both globally and for single color definition. For example +suppose you have a CLI app and a `--no-color` bool flag. You can easily disable +the color output with: + +```go + +var flagNoColor = flag.Bool("no-color", false, "Disable color output") + +if *flagNoColor { + color.NoColor = true // disables colorized output +} +``` + +It also has support for single color definitions (local). You can +disable/enable color output on the fly: + +```go +c := color.New(color.FgCyan) +c.Println("Prints cyan text") + +c.DisableColor() +c.Println("This is printed without any color") + +c.EnableColor() +c.Println("This prints again cyan...") +``` + +## Todo + +* Save/Return previous values +* Evaluate fmt.Formatter interface + + +## Credits + + * [Fatih Arslan](https://github.com/fatih) + * Windows support via @mattn: [colorable](https://github.com/mattn/go-colorable) + +## License + +The MIT License (MIT) - see [`LICENSE.md`](https://github.com/fatih/color/blob/master/LICENSE.md) for more details + diff --git a/vendor/github.com/fatih/color/color.go b/vendor/github.com/fatih/color/color.go new file mode 100644 index 00000000000..e3e997284d0 --- /dev/null +++ b/vendor/github.com/fatih/color/color.go @@ -0,0 +1,402 @@ +package color + +import ( + "fmt" + "os" + "strconv" + "strings" + + "github.com/mattn/go-colorable" + "github.com/mattn/go-isatty" +) + +// NoColor defines if the output is colorized or not. It's dynamically set to +// false or true based on the stdout's file descriptor referring to a terminal +// or not. This is a global option and affects all colors. For more control +// over each color block use the methods DisableColor() individually. +var NoColor = !isatty.IsTerminal(os.Stdout.Fd()) + +// Color defines a custom color object which is defined by SGR parameters. +type Color struct { + params []Attribute + noColor *bool +} + +// Attribute defines a single SGR Code +type Attribute int + +const escape = "\x1b" + +// Base attributes +const ( + Reset Attribute = iota + Bold + Faint + Italic + Underline + BlinkSlow + BlinkRapid + ReverseVideo + Concealed + CrossedOut +) + +// Foreground text colors +const ( + FgBlack Attribute = iota + 30 + FgRed + FgGreen + FgYellow + FgBlue + FgMagenta + FgCyan + FgWhite +) + +// Foreground Hi-Intensity text colors +const ( + FgHiBlack Attribute = iota + 90 + FgHiRed + FgHiGreen + FgHiYellow + FgHiBlue + FgHiMagenta + FgHiCyan + FgHiWhite +) + +// Background text colors +const ( + BgBlack Attribute = iota + 40 + BgRed + BgGreen + BgYellow + BgBlue + BgMagenta + BgCyan + BgWhite +) + +// Background Hi-Intensity text colors +const ( + BgHiBlack Attribute = iota + 100 + BgHiRed + BgHiGreen + BgHiYellow + BgHiBlue + BgHiMagenta + BgHiCyan + BgHiWhite +) + +// New returns a newly created color object. +func New(value ...Attribute) *Color { + c := &Color{params: make([]Attribute, 0)} + c.Add(value...) + return c +} + +// Set sets the given parameters immediately. It will change the color of +// output with the given SGR parameters until color.Unset() is called. +func Set(p ...Attribute) *Color { + c := New(p...) + c.Set() + return c +} + +// Unset resets all escape attributes and clears the output. Usually should +// be called after Set(). +func Unset() { + if NoColor { + return + } + + fmt.Fprintf(Output, "%s[%dm", escape, Reset) +} + +// Set sets the SGR sequence. +func (c *Color) Set() *Color { + if c.isNoColorSet() { + return c + } + + fmt.Fprintf(Output, c.format()) + return c +} + +func (c *Color) unset() { + if c.isNoColorSet() { + return + } + + Unset() +} + +// Add is used to chain SGR parameters. Use as many as parameters to combine +// and create custom color objects. Example: Add(color.FgRed, color.Underline). +func (c *Color) Add(value ...Attribute) *Color { + c.params = append(c.params, value...) + return c +} + +func (c *Color) prepend(value Attribute) { + c.params = append(c.params, 0) + copy(c.params[1:], c.params[0:]) + c.params[0] = value +} + +// Output defines the standard output of the print functions. By default +// os.Stdout is used. +var Output = colorable.NewColorableStdout() + +// Print formats using the default formats for its operands and writes to +// standard output. Spaces are added between operands when neither is a +// string. It returns the number of bytes written and any write error +// encountered. This is the standard fmt.Print() method wrapped with the given +// color. +func (c *Color) Print(a ...interface{}) (n int, err error) { + c.Set() + defer c.unset() + + return fmt.Fprint(Output, a...) +} + +// Printf formats according to a format specifier and writes to standard output. +// It returns the number of bytes written and any write error encountered. +// This is the standard fmt.Printf() method wrapped with the given color. +func (c *Color) Printf(format string, a ...interface{}) (n int, err error) { + c.Set() + defer c.unset() + + return fmt.Fprintf(Output, format, a...) +} + +// Println formats using the default formats for its operands and writes to +// standard output. Spaces are always added between operands and a newline is +// appended. It returns the number of bytes written and any write error +// encountered. This is the standard fmt.Print() method wrapped with the given +// color. +func (c *Color) Println(a ...interface{}) (n int, err error) { + c.Set() + defer c.unset() + + return fmt.Fprintln(Output, a...) +} + +// PrintFunc returns a new function that prints the passed arguments as +// colorized with color.Print(). +func (c *Color) PrintFunc() func(a ...interface{}) { + return func(a ...interface{}) { c.Print(a...) } +} + +// PrintfFunc returns a new function that prints the passed arguments as +// colorized with color.Printf(). +func (c *Color) PrintfFunc() func(format string, a ...interface{}) { + return func(format string, a ...interface{}) { c.Printf(format, a...) } +} + +// PrintlnFunc returns a new function that prints the passed arguments as +// colorized with color.Println(). +func (c *Color) PrintlnFunc() func(a ...interface{}) { + return func(a ...interface{}) { c.Println(a...) } +} + +// SprintFunc returns a new function that returns colorized strings for the +// given arguments with fmt.Sprint(). Useful to put into or mix into other +// string. Windows users should use this in conjuction with color.Output, example: +// +// put := New(FgYellow).SprintFunc() +// fmt.Fprintf(color.Output, "This is a %s", put("warning")) +func (c *Color) SprintFunc() func(a ...interface{}) string { + return func(a ...interface{}) string { + return c.wrap(fmt.Sprint(a...)) + } +} + +// SprintfFunc returns a new function that returns colorized strings for the +// given arguments with fmt.Sprintf(). Useful to put into or mix into other +// string. Windows users should use this in conjuction with color.Output. +func (c *Color) SprintfFunc() func(format string, a ...interface{}) string { + return func(format string, a ...interface{}) string { + return c.wrap(fmt.Sprintf(format, a...)) + } +} + +// SprintlnFunc returns a new function that returns colorized strings for the +// given arguments with fmt.Sprintln(). Useful to put into or mix into other +// string. Windows users should use this in conjuction with color.Output. +func (c *Color) SprintlnFunc() func(a ...interface{}) string { + return func(a ...interface{}) string { + return c.wrap(fmt.Sprintln(a...)) + } +} + +// sequence returns a formated SGR sequence to be plugged into a "\x1b[...m" +// an example output might be: "1;36" -> bold cyan +func (c *Color) sequence() string { + format := make([]string, len(c.params)) + for i, v := range c.params { + format[i] = strconv.Itoa(int(v)) + } + + return strings.Join(format, ";") +} + +// wrap wraps the s string with the colors attributes. The string is ready to +// be printed. +func (c *Color) wrap(s string) string { + if c.isNoColorSet() { + return s + } + + return c.format() + s + c.unformat() +} + +func (c *Color) format() string { + return fmt.Sprintf("%s[%sm", escape, c.sequence()) +} + +func (c *Color) unformat() string { + return fmt.Sprintf("%s[%dm", escape, Reset) +} + +// DisableColor disables the color output. Useful to not change any existing +// code and still being able to output. Can be used for flags like +// "--no-color". To enable back use EnableColor() method. +func (c *Color) DisableColor() { + c.noColor = boolPtr(true) +} + +// EnableColor enables the color output. Use it in conjuction with +// DisableColor(). Otherwise this method has no side effects. +func (c *Color) EnableColor() { + c.noColor = boolPtr(false) +} + +func (c *Color) isNoColorSet() bool { + // check first if we have user setted action + if c.noColor != nil { + return *c.noColor + } + + // if not return the global option, which is disabled by default + return NoColor +} + +// Equals returns a boolean value indicating whether two colors are equal. +func (c *Color) Equals(c2 *Color) bool { + if len(c.params) != len(c2.params) { + return false + } + + for _, attr := range c.params { + if !c2.attrExists(attr) { + return false + } + } + + return true +} + +func (c *Color) attrExists(a Attribute) bool { + for _, attr := range c.params { + if attr == a { + return true + } + } + + return false +} + +func boolPtr(v bool) *bool { + return &v +} + +// Black is an convenient helper function to print with black foreground. A +// newline is appended to format by default. +func Black(format string, a ...interface{}) { printColor(format, FgBlack, a...) } + +// Red is an convenient helper function to print with red foreground. A +// newline is appended to format by default. +func Red(format string, a ...interface{}) { printColor(format, FgRed, a...) } + +// Green is an convenient helper function to print with green foreground. A +// newline is appended to format by default. +func Green(format string, a ...interface{}) { printColor(format, FgGreen, a...) } + +// Yellow is an convenient helper function to print with yellow foreground. +// A newline is appended to format by default. +func Yellow(format string, a ...interface{}) { printColor(format, FgYellow, a...) } + +// Blue is an convenient helper function to print with blue foreground. A +// newline is appended to format by default. +func Blue(format string, a ...interface{}) { printColor(format, FgBlue, a...) } + +// Magenta is an convenient helper function to print with magenta foreground. +// A newline is appended to format by default. +func Magenta(format string, a ...interface{}) { printColor(format, FgMagenta, a...) } + +// Cyan is an convenient helper function to print with cyan foreground. A +// newline is appended to format by default. +func Cyan(format string, a ...interface{}) { printColor(format, FgCyan, a...) } + +// White is an convenient helper function to print with white foreground. A +// newline is appended to format by default. +func White(format string, a ...interface{}) { printColor(format, FgWhite, a...) } + +func printColor(format string, p Attribute, a ...interface{}) { + if !strings.HasSuffix(format, "\n") { + format += "\n" + } + + c := &Color{params: []Attribute{p}} + c.Printf(format, a...) +} + +// BlackString is an convenient helper function to return a string with black +// foreground. +func BlackString(format string, a ...interface{}) string { + return New(FgBlack).SprintfFunc()(format, a...) +} + +// RedString is an convenient helper function to return a string with red +// foreground. +func RedString(format string, a ...interface{}) string { + return New(FgRed).SprintfFunc()(format, a...) +} + +// GreenString is an convenient helper function to return a string with green +// foreground. +func GreenString(format string, a ...interface{}) string { + return New(FgGreen).SprintfFunc()(format, a...) +} + +// YellowString is an convenient helper function to return a string with yellow +// foreground. +func YellowString(format string, a ...interface{}) string { + return New(FgYellow).SprintfFunc()(format, a...) +} + +// BlueString is an convenient helper function to return a string with blue +// foreground. +func BlueString(format string, a ...interface{}) string { + return New(FgBlue).SprintfFunc()(format, a...) +} + +// MagentaString is an convenient helper function to return a string with magenta +// foreground. +func MagentaString(format string, a ...interface{}) string { + return New(FgMagenta).SprintfFunc()(format, a...) +} + +// CyanString is an convenient helper function to return a string with cyan +// foreground. +func CyanString(format string, a ...interface{}) string { + return New(FgCyan).SprintfFunc()(format, a...) +} + +// WhiteString is an convenient helper function to return a string with white +// foreground. +func WhiteString(format string, a ...interface{}) string { + return New(FgWhite).SprintfFunc()(format, a...) +} diff --git a/vendor/github.com/fatih/color/color_test.go b/vendor/github.com/fatih/color/color_test.go new file mode 100644 index 00000000000..8028535841d --- /dev/null +++ b/vendor/github.com/fatih/color/color_test.go @@ -0,0 +1,226 @@ +package color + +import ( + "bytes" + "fmt" + "testing" + + "github.com/mattn/go-colorable" +) + +// Testing colors is kinda different. First we test for given colors and their +// escaped formatted results. Next we create some visual tests to be tested. +// Each visual test includes the color name to be compared. +func TestColor(t *testing.T) { + rb := new(bytes.Buffer) + Output = rb + + NoColor = false + + testColors := []struct { + text string + code Attribute + }{ + {text: "black", code: FgBlack}, + {text: "red", code: FgRed}, + {text: "green", code: FgGreen}, + {text: "yellow", code: FgYellow}, + {text: "blue", code: FgBlue}, + {text: "magent", code: FgMagenta}, + {text: "cyan", code: FgCyan}, + {text: "white", code: FgWhite}, + {text: "hblack", code: FgHiBlack}, + {text: "hred", code: FgHiRed}, + {text: "hgreen", code: FgHiGreen}, + {text: "hyellow", code: FgHiYellow}, + {text: "hblue", code: FgHiBlue}, + {text: "hmagent", code: FgHiMagenta}, + {text: "hcyan", code: FgHiCyan}, + {text: "hwhite", code: FgHiWhite}, + } + + for _, c := range testColors { + New(c.code).Print(c.text) + + line, _ := rb.ReadString('\n') + scannedLine := fmt.Sprintf("%q", line) + colored := fmt.Sprintf("\x1b[%dm%s\x1b[0m", c.code, c.text) + escapedForm := fmt.Sprintf("%q", colored) + + fmt.Printf("%s\t: %s\n", c.text, line) + + if scannedLine != escapedForm { + t.Errorf("Expecting %s, got '%s'\n", escapedForm, scannedLine) + } + } +} + +func TestColorEquals(t *testing.T) { + fgblack1 := New(FgBlack) + fgblack2 := New(FgBlack) + bgblack := New(BgBlack) + fgbgblack := New(FgBlack, BgBlack) + fgblackbgred := New(FgBlack, BgRed) + fgred := New(FgRed) + bgred := New(BgRed) + + if !fgblack1.Equals(fgblack2) { + t.Error("Two black colors are not equal") + } + + if fgblack1.Equals(bgblack) { + t.Error("Fg and bg black colors are equal") + } + + if fgblack1.Equals(fgbgblack) { + t.Error("Fg black equals fg/bg black color") + } + + if fgblack1.Equals(fgred) { + t.Error("Fg black equals Fg red") + } + + if fgblack1.Equals(bgred) { + t.Error("Fg black equals Bg red") + } + + if fgblack1.Equals(fgblackbgred) { + t.Error("Fg black equals fg black bg red") + } +} + +func TestNoColor(t *testing.T) { + rb := new(bytes.Buffer) + Output = rb + + testColors := []struct { + text string + code Attribute + }{ + {text: "black", code: FgBlack}, + {text: "red", code: FgRed}, + {text: "green", code: FgGreen}, + {text: "yellow", code: FgYellow}, + {text: "blue", code: FgBlue}, + {text: "magent", code: FgMagenta}, + {text: "cyan", code: FgCyan}, + {text: "white", code: FgWhite}, + {text: "hblack", code: FgHiBlack}, + {text: "hred", code: FgHiRed}, + {text: "hgreen", code: FgHiGreen}, + {text: "hyellow", code: FgHiYellow}, + {text: "hblue", code: FgHiBlue}, + {text: "hmagent", code: FgHiMagenta}, + {text: "hcyan", code: FgHiCyan}, + {text: "hwhite", code: FgHiWhite}, + } + + for _, c := range testColors { + p := New(c.code) + p.DisableColor() + p.Print(c.text) + + line, _ := rb.ReadString('\n') + if line != c.text { + t.Errorf("Expecting %s, got '%s'\n", c.text, line) + } + } + + // global check + NoColor = true + defer func() { + NoColor = false + }() + for _, c := range testColors { + p := New(c.code) + p.Print(c.text) + + line, _ := rb.ReadString('\n') + if line != c.text { + t.Errorf("Expecting %s, got '%s'\n", c.text, line) + } + } + +} + +func TestColorVisual(t *testing.T) { + // First Visual Test + Output = colorable.NewColorableStdout() + + New(FgRed).Printf("red\t") + New(BgRed).Print(" ") + New(FgRed, Bold).Println(" red") + + New(FgGreen).Printf("green\t") + New(BgGreen).Print(" ") + New(FgGreen, Bold).Println(" green") + + New(FgYellow).Printf("yellow\t") + New(BgYellow).Print(" ") + New(FgYellow, Bold).Println(" yellow") + + New(FgBlue).Printf("blue\t") + New(BgBlue).Print(" ") + New(FgBlue, Bold).Println(" blue") + + New(FgMagenta).Printf("magenta\t") + New(BgMagenta).Print(" ") + New(FgMagenta, Bold).Println(" magenta") + + New(FgCyan).Printf("cyan\t") + New(BgCyan).Print(" ") + New(FgCyan, Bold).Println(" cyan") + + New(FgWhite).Printf("white\t") + New(BgWhite).Print(" ") + New(FgWhite, Bold).Println(" white") + fmt.Println("") + + // Second Visual test + Black("black") + Red("red") + Green("green") + Yellow("yellow") + Blue("blue") + Magenta("magenta") + Cyan("cyan") + White("white") + + // Third visual test + fmt.Println() + Set(FgBlue) + fmt.Println("is this blue?") + Unset() + + Set(FgMagenta) + fmt.Println("and this magenta?") + Unset() + + // Fourth Visual test + fmt.Println() + blue := New(FgBlue).PrintlnFunc() + blue("blue text with custom print func") + + red := New(FgRed).PrintfFunc() + red("red text with a printf func: %d\n", 123) + + put := New(FgYellow).SprintFunc() + warn := New(FgRed).SprintFunc() + + fmt.Fprintf(Output, "this is a %s and this is %s.\n", put("warning"), warn("error")) + + info := New(FgWhite, BgGreen).SprintFunc() + fmt.Fprintf(Output, "this %s rocks!\n", info("package")) + + // Fifth Visual Test + fmt.Println() + + fmt.Fprintln(Output, BlackString("black")) + fmt.Fprintln(Output, RedString("red")) + fmt.Fprintln(Output, GreenString("green")) + fmt.Fprintln(Output, YellowString("yellow")) + fmt.Fprintln(Output, BlueString("blue")) + fmt.Fprintln(Output, MagentaString("magenta")) + fmt.Fprintln(Output, CyanString("cyan")) + fmt.Fprintln(Output, WhiteString("white")) +} diff --git a/vendor/github.com/fatih/color/doc.go b/vendor/github.com/fatih/color/doc.go new file mode 100644 index 00000000000..17908787c99 --- /dev/null +++ b/vendor/github.com/fatih/color/doc.go @@ -0,0 +1,114 @@ +/* +Package color is an ANSI color package to output colorized or SGR defined +output to the standard output. The API can be used in several way, pick one +that suits you. + +Use simple and default helper functions with predefined foreground colors: + + color.Cyan("Prints text in cyan.") + + // a newline will be appended automatically + color.Blue("Prints %s in blue.", "text") + + // More default foreground colors.. + color.Red("We have red") + color.Yellow("Yellow color too!") + color.Magenta("And many others ..") + +However there are times where custom color mixes are required. Below are some +examples to create custom color objects and use the print functions of each +separate color object. + + // Create a new color object + c := color.New(color.FgCyan).Add(color.Underline) + c.Println("Prints cyan text with an underline.") + + // Or just add them to New() + d := color.New(color.FgCyan, color.Bold) + d.Printf("This prints bold cyan %s\n", "too!.") + + + // Mix up foreground and background colors, create new mixes! + red := color.New(color.FgRed) + + boldRed := red.Add(color.Bold) + boldRed.Println("This will print text in bold red.") + + whiteBackground := red.Add(color.BgWhite) + whiteBackground.Println("Red text with White background.") + + +You can create PrintXxx functions to simplify even more: + + // Create a custom print function for convenient + red := color.New(color.FgRed).PrintfFunc() + red("warning") + red("error: %s", err) + + // Mix up multiple attributes + notice := color.New(color.Bold, color.FgGreen).PrintlnFunc() + notice("don't forget this...") + + +Or create SprintXxx functions to mix strings with other non-colorized strings: + + yellow := New(FgYellow).SprintFunc() + red := New(FgRed).SprintFunc() + + fmt.Printf("this is a %s and this is %s.\n", yellow("warning"), red("error")) + + info := New(FgWhite, BgGreen).SprintFunc() + fmt.Printf("this %s rocks!\n", info("package")) + +Windows support is enabled by default. All Print functions works as intended. +However only for color.SprintXXX functions, user should use fmt.FprintXXX and +set the output to color.Output: + + fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS")) + + info := New(FgWhite, BgGreen).SprintFunc() + fmt.Fprintf(color.Output, "this %s rocks!\n", info("package")) + +Using with existing code is possible. Just use the Set() method to set the +standard output to the given parameters. That way a rewrite of an existing +code is not required. + + // Use handy standard colors. + color.Set(color.FgYellow) + + fmt.Println("Existing text will be now in Yellow") + fmt.Printf("This one %s\n", "too") + + color.Unset() // don't forget to unset + + // You can mix up parameters + color.Set(color.FgMagenta, color.Bold) + defer color.Unset() // use it in your function + + fmt.Println("All text will be now bold magenta.") + +There might be a case where you want to disable color output (for example to +pipe the standard output of your app to somewhere else). `Color` has support to +disable colors both globally and for single color definition. For example +suppose you have a CLI app and a `--no-color` bool flag. You can easily disable +the color output with: + + var flagNoColor = flag.Bool("no-color", false, "Disable color output") + + if *flagNoColor { + color.NoColor = true // disables colorized output + } + +It also has support for single color definitions (local). You can +disable/enable color output on the fly: + + c := color.New(color.FgCyan) + c.Println("Prints cyan text") + + c.DisableColor() + c.Println("This is printed without any color") + + c.EnableColor() + c.Println("This prints again cyan...") +*/ +package color diff --git a/vendor/github.com/mattn/go-colorable b/vendor/github.com/mattn/go-colorable deleted file mode 160000 index ed8eb9e318d..00000000000 --- a/vendor/github.com/mattn/go-colorable +++ /dev/null @@ -1 +0,0 @@ -Subproject commit ed8eb9e318d7a84ce5915b495b7d35e0cfe7b5a8 diff --git a/vendor/github.com/mattn/go-colorable/LICENSE b/vendor/github.com/mattn/go-colorable/LICENSE new file mode 100644 index 00000000000..91b5cef30eb --- /dev/null +++ b/vendor/github.com/mattn/go-colorable/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2016 Yasuhiro Matsumoto + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/github.com/mattn/go-colorable/README.md b/vendor/github.com/mattn/go-colorable/README.md new file mode 100644 index 00000000000..e84226a7358 --- /dev/null +++ b/vendor/github.com/mattn/go-colorable/README.md @@ -0,0 +1,43 @@ +# go-colorable + +Colorable writer for windows. + +For example, most of logger packages doesn't show colors on windows. (I know we can do it with ansicon. But I don't want.) +This package is possible to handle escape sequence for ansi color on windows. + +## Too Bad! + +![](https://raw.githubusercontent.com/mattn/go-colorable/gh-pages/bad.png) + + +## So Good! + +![](https://raw.githubusercontent.com/mattn/go-colorable/gh-pages/good.png) + +## Usage + +```go +logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true}) +logrus.SetOutput(colorable.NewColorableStdout()) + +logrus.Info("succeeded") +logrus.Warn("not correct") +logrus.Error("something error") +logrus.Fatal("panic") +``` + +You can compile above code on non-windows OSs. + +## Installation + +``` +$ go get github.com/mattn/go-colorable +``` + +# License + +MIT + +# Author + +Yasuhiro Matsumoto (a.k.a mattn) diff --git a/vendor/github.com/mattn/go-colorable/colorable_others.go b/vendor/github.com/mattn/go-colorable/colorable_others.go new file mode 100644 index 00000000000..52d6653b34b --- /dev/null +++ b/vendor/github.com/mattn/go-colorable/colorable_others.go @@ -0,0 +1,24 @@ +// +build !windows + +package colorable + +import ( + "io" + "os" +) + +func NewColorable(file *os.File) io.Writer { + if file == nil { + panic("nil passed instead of *os.File to NewColorable()") + } + + return file +} + +func NewColorableStdout() io.Writer { + return os.Stdout +} + +func NewColorableStderr() io.Writer { + return os.Stderr +} diff --git a/vendor/github.com/mattn/go-colorable/colorable_windows.go b/vendor/github.com/mattn/go-colorable/colorable_windows.go new file mode 100644 index 00000000000..22f075fd088 --- /dev/null +++ b/vendor/github.com/mattn/go-colorable/colorable_windows.go @@ -0,0 +1,809 @@ +package colorable + +import ( + "bytes" + "fmt" + "io" + "math" + "os" + "strconv" + "strings" + "syscall" + "unsafe" + + "github.com/mattn/go-isatty" +) + +const ( + foregroundBlue = 0x1 + foregroundGreen = 0x2 + foregroundRed = 0x4 + foregroundIntensity = 0x8 + foregroundMask = (foregroundRed | foregroundBlue | foregroundGreen | foregroundIntensity) + backgroundBlue = 0x10 + backgroundGreen = 0x20 + backgroundRed = 0x40 + backgroundIntensity = 0x80 + backgroundMask = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity) +) + +type wchar uint16 +type short int16 +type dword uint32 +type word uint16 + +type coord struct { + x short + y short +} + +type smallRect struct { + left short + top short + right short + bottom short +} + +type consoleScreenBufferInfo struct { + size coord + cursorPosition coord + attributes word + window smallRect + maximumWindowSize coord +} + +type consoleCursorInfo struct { + size dword + visible int32 +} + +var ( + kernel32 = syscall.NewLazyDLL("kernel32.dll") + procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo") + procSetConsoleTextAttribute = kernel32.NewProc("SetConsoleTextAttribute") + procSetConsoleCursorPosition = kernel32.NewProc("SetConsoleCursorPosition") + procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW") + procFillConsoleOutputAttribute = kernel32.NewProc("FillConsoleOutputAttribute") + procGetConsoleCursorInfo = kernel32.NewProc("GetConsoleCursorInfo") + procSetConsoleCursorInfo = kernel32.NewProc("SetConsoleCursorInfo") +) + +type Writer struct { + out io.Writer + handle syscall.Handle + lastbuf bytes.Buffer + oldattr word +} + +func NewColorable(file *os.File) io.Writer { + if file == nil { + panic("nil passed instead of *os.File to NewColorable()") + } + + if isatty.IsTerminal(file.Fd()) { + var csbi consoleScreenBufferInfo + handle := syscall.Handle(file.Fd()) + procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi))) + return &Writer{out: file, handle: handle, oldattr: csbi.attributes} + } else { + return file + } +} + +func NewColorableStdout() io.Writer { + return NewColorable(os.Stdout) +} + +func NewColorableStderr() io.Writer { + return NewColorable(os.Stderr) +} + +var color256 = map[int]int{ + 0: 0x000000, + 1: 0x800000, + 2: 0x008000, + 3: 0x808000, + 4: 0x000080, + 5: 0x800080, + 6: 0x008080, + 7: 0xc0c0c0, + 8: 0x808080, + 9: 0xff0000, + 10: 0x00ff00, + 11: 0xffff00, + 12: 0x0000ff, + 13: 0xff00ff, + 14: 0x00ffff, + 15: 0xffffff, + 16: 0x000000, + 17: 0x00005f, + 18: 0x000087, + 19: 0x0000af, + 20: 0x0000d7, + 21: 0x0000ff, + 22: 0x005f00, + 23: 0x005f5f, + 24: 0x005f87, + 25: 0x005faf, + 26: 0x005fd7, + 27: 0x005fff, + 28: 0x008700, + 29: 0x00875f, + 30: 0x008787, + 31: 0x0087af, + 32: 0x0087d7, + 33: 0x0087ff, + 34: 0x00af00, + 35: 0x00af5f, + 36: 0x00af87, + 37: 0x00afaf, + 38: 0x00afd7, + 39: 0x00afff, + 40: 0x00d700, + 41: 0x00d75f, + 42: 0x00d787, + 43: 0x00d7af, + 44: 0x00d7d7, + 45: 0x00d7ff, + 46: 0x00ff00, + 47: 0x00ff5f, + 48: 0x00ff87, + 49: 0x00ffaf, + 50: 0x00ffd7, + 51: 0x00ffff, + 52: 0x5f0000, + 53: 0x5f005f, + 54: 0x5f0087, + 55: 0x5f00af, + 56: 0x5f00d7, + 57: 0x5f00ff, + 58: 0x5f5f00, + 59: 0x5f5f5f, + 60: 0x5f5f87, + 61: 0x5f5faf, + 62: 0x5f5fd7, + 63: 0x5f5fff, + 64: 0x5f8700, + 65: 0x5f875f, + 66: 0x5f8787, + 67: 0x5f87af, + 68: 0x5f87d7, + 69: 0x5f87ff, + 70: 0x5faf00, + 71: 0x5faf5f, + 72: 0x5faf87, + 73: 0x5fafaf, + 74: 0x5fafd7, + 75: 0x5fafff, + 76: 0x5fd700, + 77: 0x5fd75f, + 78: 0x5fd787, + 79: 0x5fd7af, + 80: 0x5fd7d7, + 81: 0x5fd7ff, + 82: 0x5fff00, + 83: 0x5fff5f, + 84: 0x5fff87, + 85: 0x5fffaf, + 86: 0x5fffd7, + 87: 0x5fffff, + 88: 0x870000, + 89: 0x87005f, + 90: 0x870087, + 91: 0x8700af, + 92: 0x8700d7, + 93: 0x8700ff, + 94: 0x875f00, + 95: 0x875f5f, + 96: 0x875f87, + 97: 0x875faf, + 98: 0x875fd7, + 99: 0x875fff, + 100: 0x878700, + 101: 0x87875f, + 102: 0x878787, + 103: 0x8787af, + 104: 0x8787d7, + 105: 0x8787ff, + 106: 0x87af00, + 107: 0x87af5f, + 108: 0x87af87, + 109: 0x87afaf, + 110: 0x87afd7, + 111: 0x87afff, + 112: 0x87d700, + 113: 0x87d75f, + 114: 0x87d787, + 115: 0x87d7af, + 116: 0x87d7d7, + 117: 0x87d7ff, + 118: 0x87ff00, + 119: 0x87ff5f, + 120: 0x87ff87, + 121: 0x87ffaf, + 122: 0x87ffd7, + 123: 0x87ffff, + 124: 0xaf0000, + 125: 0xaf005f, + 126: 0xaf0087, + 127: 0xaf00af, + 128: 0xaf00d7, + 129: 0xaf00ff, + 130: 0xaf5f00, + 131: 0xaf5f5f, + 132: 0xaf5f87, + 133: 0xaf5faf, + 134: 0xaf5fd7, + 135: 0xaf5fff, + 136: 0xaf8700, + 137: 0xaf875f, + 138: 0xaf8787, + 139: 0xaf87af, + 140: 0xaf87d7, + 141: 0xaf87ff, + 142: 0xafaf00, + 143: 0xafaf5f, + 144: 0xafaf87, + 145: 0xafafaf, + 146: 0xafafd7, + 147: 0xafafff, + 148: 0xafd700, + 149: 0xafd75f, + 150: 0xafd787, + 151: 0xafd7af, + 152: 0xafd7d7, + 153: 0xafd7ff, + 154: 0xafff00, + 155: 0xafff5f, + 156: 0xafff87, + 157: 0xafffaf, + 158: 0xafffd7, + 159: 0xafffff, + 160: 0xd70000, + 161: 0xd7005f, + 162: 0xd70087, + 163: 0xd700af, + 164: 0xd700d7, + 165: 0xd700ff, + 166: 0xd75f00, + 167: 0xd75f5f, + 168: 0xd75f87, + 169: 0xd75faf, + 170: 0xd75fd7, + 171: 0xd75fff, + 172: 0xd78700, + 173: 0xd7875f, + 174: 0xd78787, + 175: 0xd787af, + 176: 0xd787d7, + 177: 0xd787ff, + 178: 0xd7af00, + 179: 0xd7af5f, + 180: 0xd7af87, + 181: 0xd7afaf, + 182: 0xd7afd7, + 183: 0xd7afff, + 184: 0xd7d700, + 185: 0xd7d75f, + 186: 0xd7d787, + 187: 0xd7d7af, + 188: 0xd7d7d7, + 189: 0xd7d7ff, + 190: 0xd7ff00, + 191: 0xd7ff5f, + 192: 0xd7ff87, + 193: 0xd7ffaf, + 194: 0xd7ffd7, + 195: 0xd7ffff, + 196: 0xff0000, + 197: 0xff005f, + 198: 0xff0087, + 199: 0xff00af, + 200: 0xff00d7, + 201: 0xff00ff, + 202: 0xff5f00, + 203: 0xff5f5f, + 204: 0xff5f87, + 205: 0xff5faf, + 206: 0xff5fd7, + 207: 0xff5fff, + 208: 0xff8700, + 209: 0xff875f, + 210: 0xff8787, + 211: 0xff87af, + 212: 0xff87d7, + 213: 0xff87ff, + 214: 0xffaf00, + 215: 0xffaf5f, + 216: 0xffaf87, + 217: 0xffafaf, + 218: 0xffafd7, + 219: 0xffafff, + 220: 0xffd700, + 221: 0xffd75f, + 222: 0xffd787, + 223: 0xffd7af, + 224: 0xffd7d7, + 225: 0xffd7ff, + 226: 0xffff00, + 227: 0xffff5f, + 228: 0xffff87, + 229: 0xffffaf, + 230: 0xffffd7, + 231: 0xffffff, + 232: 0x080808, + 233: 0x121212, + 234: 0x1c1c1c, + 235: 0x262626, + 236: 0x303030, + 237: 0x3a3a3a, + 238: 0x444444, + 239: 0x4e4e4e, + 240: 0x585858, + 241: 0x626262, + 242: 0x6c6c6c, + 243: 0x767676, + 244: 0x808080, + 245: 0x8a8a8a, + 246: 0x949494, + 247: 0x9e9e9e, + 248: 0xa8a8a8, + 249: 0xb2b2b2, + 250: 0xbcbcbc, + 251: 0xc6c6c6, + 252: 0xd0d0d0, + 253: 0xdadada, + 254: 0xe4e4e4, + 255: 0xeeeeee, +} + +func (w *Writer) Write(data []byte) (n int, err error) { + var csbi consoleScreenBufferInfo + procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + + er := bytes.NewBuffer(data) +loop: + for { + r1, _, err := procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + if r1 == 0 { + break loop + } + + c1, _, err := er.ReadRune() + if err != nil { + break loop + } + if c1 != 0x1b { + fmt.Fprint(w.out, string(c1)) + continue + } + c2, _, err := er.ReadRune() + if err != nil { + w.lastbuf.WriteRune(c1) + break loop + } + if c2 != 0x5b { + w.lastbuf.WriteRune(c1) + w.lastbuf.WriteRune(c2) + continue + } + + var buf bytes.Buffer + var m rune + for { + c, _, err := er.ReadRune() + if err != nil { + w.lastbuf.WriteRune(c1) + w.lastbuf.WriteRune(c2) + w.lastbuf.Write(buf.Bytes()) + break loop + } + if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' { + m = c + break + } + buf.Write([]byte(string(c))) + } + + var csbi consoleScreenBufferInfo + switch m { + case 'A': + n, err = strconv.Atoi(buf.String()) + if err != nil { + continue + } + procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + csbi.cursorPosition.y -= short(n) + procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) + case 'B': + n, err = strconv.Atoi(buf.String()) + if err != nil { + continue + } + procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + csbi.cursorPosition.y += short(n) + procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) + case 'C': + n, err = strconv.Atoi(buf.String()) + if err != nil { + continue + } + procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + csbi.cursorPosition.x -= short(n) + procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) + case 'D': + n, err = strconv.Atoi(buf.String()) + if err != nil { + continue + } + if n, err = strconv.Atoi(buf.String()); err == nil { + var csbi consoleScreenBufferInfo + procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + csbi.cursorPosition.x += short(n) + procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) + } + case 'E': + n, err = strconv.Atoi(buf.String()) + if err != nil { + continue + } + procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + csbi.cursorPosition.x = 0 + csbi.cursorPosition.y += short(n) + procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) + case 'F': + n, err = strconv.Atoi(buf.String()) + if err != nil { + continue + } + procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + csbi.cursorPosition.x = 0 + csbi.cursorPosition.y -= short(n) + procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) + case 'G': + n, err = strconv.Atoi(buf.String()) + if err != nil { + continue + } + procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + csbi.cursorPosition.x = short(n-1) + procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) + case 'H': + token := strings.Split(buf.String(), ";") + if len(token) != 2 { + continue + } + n1, err := strconv.Atoi(token[0]) + if err != nil { + continue + } + n2, err := strconv.Atoi(token[1]) + if err != nil { + continue + } + csbi.cursorPosition.x = short(n2-1) + csbi.cursorPosition.y = short(n1-1) + procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) + case 'J': + n, err := strconv.Atoi(buf.String()) + if err != nil { + continue + } + procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + var cursor coord + switch n { + case 0: + cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y} + case 1: + cursor = coord{x: csbi.window.left, y: csbi.window.top} + case 2: + cursor = coord{x: csbi.window.left, y: csbi.window.top} + } + var count, written dword + count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x) + procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written))) + procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written))) + case 'K': + n, err := strconv.Atoi(buf.String()) + if err != nil { + continue + } + procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + var cursor coord + switch n { + case 0: + cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y} + case 1: + cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y} + case 2: + cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y} + } + var count, written dword + count = dword(csbi.size.x - csbi.cursorPosition.x) + procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written))) + procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written))) + case 'm': + procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) + attr := csbi.attributes + cs := buf.String() + if cs == "" { + procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(w.oldattr)) + continue + } + token := strings.Split(cs, ";") + for i := 0; i < len(token); i++ { + ns := token[i] + if n, err = strconv.Atoi(ns); err == nil { + switch { + case n == 0 || n == 100: + attr = w.oldattr + case 1 <= n && n <= 5: + attr |= foregroundIntensity + case n == 7: + attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4) + case 22 == n || n == 25 || n == 25: + attr |= foregroundIntensity + case n == 27: + attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4) + case 30 <= n && n <= 37: + attr &= backgroundMask + if (n-30)&1 != 0 { + attr |= foregroundRed + } + if (n-30)&2 != 0 { + attr |= foregroundGreen + } + if (n-30)&4 != 0 { + attr |= foregroundBlue + } + case n == 38: // set foreground color. + if i < len(token)-2 && (token[i+1] == "5" || token[i+1] == "05") { + if n256, err := strconv.Atoi(token[i+2]); err == nil { + if n256foreAttr == nil { + n256setup() + } + attr &= backgroundMask + attr |= n256foreAttr[n256] + i += 2 + } + } else { + attr = attr & (w.oldattr & backgroundMask) + } + case n == 39: // reset foreground color. + attr &= backgroundMask + attr |= w.oldattr & foregroundMask + case 40 <= n && n <= 47: + attr &= foregroundMask + if (n-40)&1 != 0 { + attr |= backgroundRed + } + if (n-40)&2 != 0 { + attr |= backgroundGreen + } + if (n-40)&4 != 0 { + attr |= backgroundBlue + } + case n == 48: // set background color. + if i < len(token)-2 && token[i+1] == "5" { + if n256, err := strconv.Atoi(token[i+2]); err == nil { + if n256backAttr == nil { + n256setup() + } + attr &= foregroundMask + attr |= n256backAttr[n256] + i += 2 + } + } else { + attr = attr & (w.oldattr & foregroundMask) + } + case n == 49: // reset foreground color. + attr &= foregroundMask + attr |= w.oldattr & backgroundMask + case 90 <= n && n <= 97: + attr = (attr & backgroundMask) + attr |= foregroundIntensity + if (n-90)&1 != 0 { + attr |= foregroundRed + } + if (n-90)&2 != 0 { + attr |= foregroundGreen + } + if (n-90)&4 != 0 { + attr |= foregroundBlue + } + case 100 <= n && n <= 107: + attr = (attr & foregroundMask) + attr |= backgroundIntensity + if (n-100)&1 != 0 { + attr |= backgroundRed + } + if (n-100)&2 != 0 { + attr |= backgroundGreen + } + if (n-100)&4 != 0 { + attr |= backgroundBlue + } + } + procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(attr)) + } + } + case 'h': + cs := buf.String() + if cs == "?25" { + var ci consoleCursorInfo + procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci))) + ci.visible = 1 + procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci))) + } + case 'l': + cs := buf.String() + if cs == "?25" { + var ci consoleCursorInfo + procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci))) + ci.visible = 0 + procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci))) + } + } + } + return len(data) - w.lastbuf.Len(), nil +} + +type consoleColor struct { + rgb int + red bool + green bool + blue bool + intensity bool +} + +func (c consoleColor) foregroundAttr() (attr word) { + if c.red { + attr |= foregroundRed + } + if c.green { + attr |= foregroundGreen + } + if c.blue { + attr |= foregroundBlue + } + if c.intensity { + attr |= foregroundIntensity + } + return +} + +func (c consoleColor) backgroundAttr() (attr word) { + if c.red { + attr |= backgroundRed + } + if c.green { + attr |= backgroundGreen + } + if c.blue { + attr |= backgroundBlue + } + if c.intensity { + attr |= backgroundIntensity + } + return +} + +var color16 = []consoleColor{ + consoleColor{0x000000, false, false, false, false}, + consoleColor{0x000080, false, false, true, false}, + consoleColor{0x008000, false, true, false, false}, + consoleColor{0x008080, false, true, true, false}, + consoleColor{0x800000, true, false, false, false}, + consoleColor{0x800080, true, false, true, false}, + consoleColor{0x808000, true, true, false, false}, + consoleColor{0xc0c0c0, true, true, true, false}, + consoleColor{0x808080, false, false, false, true}, + consoleColor{0x0000ff, false, false, true, true}, + consoleColor{0x00ff00, false, true, false, true}, + consoleColor{0x00ffff, false, true, true, true}, + consoleColor{0xff0000, true, false, false, true}, + consoleColor{0xff00ff, true, false, true, true}, + consoleColor{0xffff00, true, true, false, true}, + consoleColor{0xffffff, true, true, true, true}, +} + +type hsv struct { + h, s, v float32 +} + +func (a hsv) dist(b hsv) float32 { + dh := a.h - b.h + switch { + case dh > 0.5: + dh = 1 - dh + case dh < -0.5: + dh = -1 - dh + } + ds := a.s - b.s + dv := a.v - b.v + return float32(math.Sqrt(float64(dh*dh + ds*ds + dv*dv))) +} + +func toHSV(rgb int) hsv { + r, g, b := float32((rgb&0xFF0000)>>16)/256.0, + float32((rgb&0x00FF00)>>8)/256.0, + float32(rgb&0x0000FF)/256.0 + min, max := minmax3f(r, g, b) + h := max - min + if h > 0 { + if max == r { + h = (g - b) / h + if h < 0 { + h += 6 + } + } else if max == g { + h = 2 + (b-r)/h + } else { + h = 4 + (r-g)/h + } + } + h /= 6.0 + s := max - min + if max != 0 { + s /= max + } + v := max + return hsv{h: h, s: s, v: v} +} + +type hsvTable []hsv + +func toHSVTable(rgbTable []consoleColor) hsvTable { + t := make(hsvTable, len(rgbTable)) + for i, c := range rgbTable { + t[i] = toHSV(c.rgb) + } + return t +} + +func (t hsvTable) find(rgb int) consoleColor { + hsv := toHSV(rgb) + n := 7 + l := float32(5.0) + for i, p := range t { + d := hsv.dist(p) + if d < l { + l, n = d, i + } + } + return color16[n] +} + +func minmax3f(a, b, c float32) (min, max float32) { + if a < b { + if b < c { + return a, c + } else if a < c { + return a, b + } else { + return c, b + } + } else { + if a < c { + return b, c + } else if b < c { + return b, a + } else { + return c, a + } + } +} + +var n256foreAttr []word +var n256backAttr []word + +func n256setup() { + n256foreAttr = make([]word, 256) + n256backAttr = make([]word, 256) + t := toHSVTable(color16) + for i, rgb := range color256 { + c := t.find(rgb) + n256foreAttr[i] = c.foregroundAttr() + n256backAttr[i] = c.backgroundAttr() + } +} diff --git a/vendor/github.com/mattn/go-colorable/noncolorable.go b/vendor/github.com/mattn/go-colorable/noncolorable.go new file mode 100644 index 00000000000..fb976dbd8b7 --- /dev/null +++ b/vendor/github.com/mattn/go-colorable/noncolorable.go @@ -0,0 +1,57 @@ +package colorable + +import ( + "bytes" + "fmt" + "io" +) + +type NonColorable struct { + out io.Writer + lastbuf bytes.Buffer +} + +func NewNonColorable(w io.Writer) io.Writer { + return &NonColorable{out: w} +} + +func (w *NonColorable) Write(data []byte) (n int, err error) { + er := bytes.NewBuffer(data) +loop: + for { + c1, _, err := er.ReadRune() + if err != nil { + break loop + } + if c1 != 0x1b { + fmt.Fprint(w.out, string(c1)) + continue + } + c2, _, err := er.ReadRune() + if err != nil { + w.lastbuf.WriteRune(c1) + break loop + } + if c2 != 0x5b { + w.lastbuf.WriteRune(c1) + w.lastbuf.WriteRune(c2) + continue + } + + var buf bytes.Buffer + for { + c, _, err := er.ReadRune() + if err != nil { + w.lastbuf.WriteRune(c1) + w.lastbuf.WriteRune(c2) + w.lastbuf.Write(buf.Bytes()) + break loop + } + if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' { + break + } + buf.Write([]byte(string(c))) + } + } + return len(data) - w.lastbuf.Len(), nil +} diff --git a/vendor/github.com/mattn/go-isatty b/vendor/github.com/mattn/go-isatty deleted file mode 160000 index 66b8e73f3f5..00000000000 --- a/vendor/github.com/mattn/go-isatty +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 66b8e73f3f5cda9f96b69efd03dd3d7fc4a5cdb8 diff --git a/vendor/github.com/mattn/go-isatty/LICENSE b/vendor/github.com/mattn/go-isatty/LICENSE new file mode 100644 index 00000000000..65dc692b6b1 --- /dev/null +++ b/vendor/github.com/mattn/go-isatty/LICENSE @@ -0,0 +1,9 @@ +Copyright (c) Yasuhiro MATSUMOTO + +MIT License (Expat) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/github.com/mattn/go-isatty/README.md b/vendor/github.com/mattn/go-isatty/README.md new file mode 100644 index 00000000000..74845de4a24 --- /dev/null +++ b/vendor/github.com/mattn/go-isatty/README.md @@ -0,0 +1,37 @@ +# go-isatty + +isatty for golang + +## Usage + +```go +package main + +import ( + "fmt" + "github.com/mattn/go-isatty" + "os" +) + +func main() { + if isatty.IsTerminal(os.Stdout.Fd()) { + fmt.Println("Is Terminal") + } else { + fmt.Println("Is Not Terminal") + } +} +``` + +## Installation + +``` +$ go get github.com/mattn/go-isatty +``` + +# License + +MIT + +# Author + +Yasuhiro Matsumoto (a.k.a mattn) diff --git a/vendor/github.com/mattn/go-isatty/doc.go b/vendor/github.com/mattn/go-isatty/doc.go new file mode 100644 index 00000000000..17d4f90ebcc --- /dev/null +++ b/vendor/github.com/mattn/go-isatty/doc.go @@ -0,0 +1,2 @@ +// Package isatty implements interface to isatty +package isatty diff --git a/vendor/github.com/mattn/go-isatty/isatty_appengine.go b/vendor/github.com/mattn/go-isatty/isatty_appengine.go new file mode 100644 index 00000000000..83c588773cf --- /dev/null +++ b/vendor/github.com/mattn/go-isatty/isatty_appengine.go @@ -0,0 +1,9 @@ +// +build appengine + +package isatty + +// IsTerminal returns true if the file descriptor is terminal which +// is always false on on appengine classic which is a sandboxed PaaS. +func IsTerminal(fd uintptr) bool { + return false +} diff --git a/vendor/github.com/mattn/go-isatty/isatty_bsd.go b/vendor/github.com/mattn/go-isatty/isatty_bsd.go new file mode 100644 index 00000000000..42f2514d133 --- /dev/null +++ b/vendor/github.com/mattn/go-isatty/isatty_bsd.go @@ -0,0 +1,18 @@ +// +build darwin freebsd openbsd netbsd dragonfly +// +build !appengine + +package isatty + +import ( + "syscall" + "unsafe" +) + +const ioctlReadTermios = syscall.TIOCGETA + +// IsTerminal return true if the file descriptor is terminal. +func IsTerminal(fd uintptr) bool { + var termios syscall.Termios + _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0) + return err == 0 +} diff --git a/vendor/github.com/mattn/go-isatty/isatty_linux.go b/vendor/github.com/mattn/go-isatty/isatty_linux.go new file mode 100644 index 00000000000..9d24bac1db3 --- /dev/null +++ b/vendor/github.com/mattn/go-isatty/isatty_linux.go @@ -0,0 +1,18 @@ +// +build linux +// +build !appengine + +package isatty + +import ( + "syscall" + "unsafe" +) + +const ioctlReadTermios = syscall.TCGETS + +// IsTerminal return true if the file descriptor is terminal. +func IsTerminal(fd uintptr) bool { + var termios syscall.Termios + _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0) + return err == 0 +} diff --git a/vendor/github.com/mattn/go-isatty/isatty_solaris.go b/vendor/github.com/mattn/go-isatty/isatty_solaris.go new file mode 100644 index 00000000000..1f0c6bf53dc --- /dev/null +++ b/vendor/github.com/mattn/go-isatty/isatty_solaris.go @@ -0,0 +1,16 @@ +// +build solaris +// +build !appengine + +package isatty + +import ( + "golang.org/x/sys/unix" +) + +// IsTerminal returns true if the given file descriptor is a terminal. +// see: http://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libbc/libc/gen/common/isatty.c +func IsTerminal(fd uintptr) bool { + var termio unix.Termio + err := unix.IoctlSetTermio(int(fd), unix.TCGETA, &termio) + return err == nil +} diff --git a/vendor/github.com/mattn/go-isatty/isatty_windows.go b/vendor/github.com/mattn/go-isatty/isatty_windows.go new file mode 100644 index 00000000000..83c398b16db --- /dev/null +++ b/vendor/github.com/mattn/go-isatty/isatty_windows.go @@ -0,0 +1,19 @@ +// +build windows +// +build !appengine + +package isatty + +import ( + "syscall" + "unsafe" +) + +var kernel32 = syscall.NewLazyDLL("kernel32.dll") +var procGetConsoleMode = kernel32.NewProc("GetConsoleMode") + +// IsTerminal return true if the file descriptor is terminal. +func IsTerminal(fd uintptr) bool { + var st uint32 + r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, fd, uintptr(unsafe.Pointer(&st)), 0) + return r != 0 && e == 0 +} From 961883ca84c05262d39920769ecccc710de8eef9 Mon Sep 17 00:00:00 2001 From: Jonathan Berkhahn Date: Wed, 17 Jan 2018 13:38:39 -0800 Subject: [PATCH 24/24] Find home dir in a cross-platform compatible way --- plugin/pkg/kubectl/utils/utils.go | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/plugin/pkg/kubectl/utils/utils.go b/plugin/pkg/kubectl/utils/utils.go index ed5b6b791bf..cc5538eb6b9 100644 --- a/plugin/pkg/kubectl/utils/utils.go +++ b/plugin/pkg/kubectl/utils/utils.go @@ -20,6 +20,8 @@ import ( "encoding/json" "fmt" "os" + "path/filepath" + "runtime" "time" restclient "k8s.io/client-go/rest" @@ -39,7 +41,13 @@ func NewClient() (*clientset.Clientset, *restclient.Config) { // then the value of the KUBECONFIG env var (if any), and defaulting // to ~/.kube/config as a last resort. home := os.Getenv("HOME") - kubeconfig := home + "/.kube/config" + if runtime.GOOS == "windows" { + home = os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH") + if home == "" { + home = os.Getenv("USERPROFILE") + } + } + kubeconfig := filepath.Join(home, ".kube", "config") kubeconfigEnv := os.Getenv("KUBECONFIG") if len(kubeconfigEnv) > 0 {