knative
/
pkg
mirror of https://github.com/knative/pkg.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Don't generate clients for apis/duck (#82) 

... they are not real types.

Fixes: https://github.com/knative/pkg/issues/75
This commit is contained in:
Matt Moore 2018-09-20 14:56:19 -07:00 committed by Knative Prow Robot
parent 70762ec49b
commit 28fe5a05de
31 changed files with 7 additions and 2402 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
client/clientset/versioned/clientset.go generated
View File

@ -20,7 +20,6 @@ package versioned
import (
authenticationv1alpha1 "github.com/knative/pkg/client/clientset/versioned/typed/authentication/v1alpha1"
duckv1alpha1 "github.com/knative/pkg/client/clientset/versioned/typed/duck/v1alpha1"
networkingv1alpha3 "github.com/knative/pkg/client/clientset/versioned/typed/istio/v1alpha3"
discovery "k8s.io/client-go/discovery"
rest "k8s.io/client-go/rest"
@ -32,9 +31,6 @@ type Interface interface {
AuthenticationV1alpha1() authenticationv1alpha1.AuthenticationV1alpha1Interface
// Deprecated: please explicitly pick a version if possible.
Authentication() authenticationv1alpha1.AuthenticationV1alpha1Interface
DuckV1alpha1() duckv1alpha1.DuckV1alpha1Interface
// Deprecated: please explicitly pick a version if possible.
Duck() duckv1alpha1.DuckV1alpha1Interface
NetworkingV1alpha3() networkingv1alpha3.NetworkingV1alpha3Interface
// Deprecated: please explicitly pick a version if possible.
Networking() networkingv1alpha3.NetworkingV1alpha3Interface
@ -45,7 +41,6 @@ type Interface interface {
type Clientset struct {
*discovery.DiscoveryClient
authenticationV1alpha1 *authenticationv1alpha1.AuthenticationV1alpha1Client
duckV1alpha1 *duckv1alpha1.DuckV1alpha1Client
networkingV1alpha3 *networkingv1alpha3.NetworkingV1alpha3Client
}
@ -60,17 +55,6 @@ func (c *Clientset) Authentication() authenticationv1alpha1.AuthenticationV1alph
return c.authenticationV1alpha1
}
// DuckV1alpha1 retrieves the DuckV1alpha1Client
func (c *Clientset) DuckV1alpha1() duckv1alpha1.DuckV1alpha1Interface {
return c.duckV1alpha1
}
// Deprecated: Duck retrieves the default version of DuckClient.
// Please explicitly pick a version.
func (c *Clientset) Duck() duckv1alpha1.DuckV1alpha1Interface {
return c.duckV1alpha1
}
// NetworkingV1alpha3 retrieves the NetworkingV1alpha3Client
func (c *Clientset) NetworkingV1alpha3() networkingv1alpha3.NetworkingV1alpha3Interface {
return c.networkingV1alpha3
@ -102,10 +86,6 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
if err != nil {
return nil, err
}
cs.duckV1alpha1, err = duckv1alpha1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.networkingV1alpha3, err = networkingv1alpha3.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
@ -123,7 +103,6 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset
cs.authenticationV1alpha1 = authenticationv1alpha1.NewForConfigOrDie(c)
cs.duckV1alpha1 = duckv1alpha1.NewForConfigOrDie(c)
cs.networkingV1alpha3 = networkingv1alpha3.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
@ -134,7 +113,6 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
func New(c rest.Interface) *Clientset {
var cs Clientset
cs.authenticationV1alpha1 = authenticationv1alpha1.New(c)
cs.duckV1alpha1 = duckv1alpha1.New(c)
cs.networkingV1alpha3 = networkingv1alpha3.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c)

12
client/clientset/versioned/fake/clientset_generated.go generated
View File

@ -22,8 +22,6 @@ import (
clientset "github.com/knative/pkg/client/clientset/versioned"
authenticationv1alpha1 "github.com/knative/pkg/client/clientset/versioned/typed/authentication/v1alpha1"
fakeauthenticationv1alpha1 "github.com/knative/pkg/client/clientset/versioned/typed/authentication/v1alpha1/fake"
duckv1alpha1 "github.com/knative/pkg/client/clientset/versioned/typed/duck/v1alpha1"
fakeduckv1alpha1 "github.com/knative/pkg/client/clientset/versioned/typed/duck/v1alpha1/fake"
networkingv1alpha3 "github.com/knative/pkg/client/clientset/versioned/typed/istio/v1alpha3"
fakenetworkingv1alpha3 "github.com/knative/pkg/client/clientset/versioned/typed/istio/v1alpha3/fake"
"k8s.io/apimachinery/pkg/runtime"
@ -85,16 +83,6 @@ func (c *Clientset) Authentication() authenticationv1alpha1.AuthenticationV1alph
return &fakeauthenticationv1alpha1.FakeAuthenticationV1alpha1{Fake: &c.Fake}
}
// DuckV1alpha1 retrieves the DuckV1alpha1Client
func (c *Clientset) DuckV1alpha1() duckv1alpha1.DuckV1alpha1Interface {
return &fakeduckv1alpha1.FakeDuckV1alpha1{Fake: &c.Fake}
}
// Duck retrieves the DuckV1alpha1Client
func (c *Clientset) Duck() duckv1alpha1.DuckV1alpha1Interface {
return &fakeduckv1alpha1.FakeDuckV1alpha1{Fake: &c.Fake}
}
// NetworkingV1alpha3 retrieves the NetworkingV1alpha3Client
func (c *Clientset) NetworkingV1alpha3() networkingv1alpha3.NetworkingV1alpha3Interface {
return &fakenetworkingv1alpha3.FakeNetworkingV1alpha3{Fake: &c.Fake}

2
client/clientset/versioned/fake/register.go generated
View File

@ -19,7 +19,6 @@ limitations under the License.
package fake
import (
duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
authenticationv1alpha1 "github.com/knative/pkg/apis/istio/authentication/v1alpha1"
networkingv1alpha3 "github.com/knative/pkg/apis/istio/v1alpha3"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@ -53,6 +52,5 @@ func init() {
// correctly.
func AddToScheme(scheme *runtime.Scheme) {
authenticationv1alpha1.AddToScheme(scheme)
duckv1alpha1.AddToScheme(scheme)
networkingv1alpha3.AddToScheme(scheme)
}

2
client/clientset/versioned/scheme/register.go generated
View File

@ -19,7 +19,6 @@ limitations under the License.
package scheme
import (
duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
authenticationv1alpha1 "github.com/knative/pkg/apis/istio/authentication/v1alpha1"
networkingv1alpha3 "github.com/knative/pkg/apis/istio/v1alpha3"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@ -53,6 +52,5 @@ func init() {
// correctly.
func AddToScheme(scheme *runtime.Scheme) {
authenticationv1alpha1.AddToScheme(scheme)
duckv1alpha1.AddToScheme(scheme)
networkingv1alpha3.AddToScheme(scheme)
}

20
client/clientset/versioned/typed/duck/v1alpha1/doc.go generated
View File

@ -1,20 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
// This package has the automatically generated typed clients.
package v1alpha1

105
client/clientset/versioned/typed/duck/v1alpha1/duck_client.go generated
View File

@ -1,105 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
package v1alpha1
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
"github.com/knative/pkg/client/clientset/versioned/scheme"
serializer "k8s.io/apimachinery/pkg/runtime/serializer"
rest "k8s.io/client-go/rest"
)
type DuckV1alpha1Interface interface {
RESTClient() rest.Interface
GenerationalsGetter
KResourcesGetter
TargetsGetter
TopicsGetter
}
// DuckV1alpha1Client is used to interact with features provided by the duck.knative.dev group.
type DuckV1alpha1Client struct {
restClient rest.Interface
}
func (c *DuckV1alpha1Client) Generationals(namespace string) GenerationalInterface {
return newGenerationals(c, namespace)
}
func (c *DuckV1alpha1Client) KResources(namespace string) KResourceInterface {
return newKResources(c, namespace)
}
func (c *DuckV1alpha1Client) Targets(namespace string) TargetInterface {
return newTargets(c, namespace)
}
func (c *DuckV1alpha1Client) Topics(namespace string) TopicInterface {
return newTopics(c, namespace)
}
// NewForConfig creates a new DuckV1alpha1Client for the given config.
func NewForConfig(c *rest.Config) (*DuckV1alpha1Client, error) {
config := *c
if err := setConfigDefaults(&config); err != nil {
return nil, err
}
client, err := rest.RESTClientFor(&config)
if err != nil {
return nil, err
}
return &DuckV1alpha1Client{client}, nil
}
// NewForConfigOrDie creates a new DuckV1alpha1Client for the given config and
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *DuckV1alpha1Client {
client, err := NewForConfig(c)
if err != nil {
panic(err)
}
return client
}
// New creates a new DuckV1alpha1Client for the given RESTClient.
func New(c rest.Interface) *DuckV1alpha1Client {
return &DuckV1alpha1Client{c}
}
func setConfigDefaults(config *rest.Config) error {
gv := v1alpha1.SchemeGroupVersion
config.GroupVersion = &gv
config.APIPath = "/apis"
config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
if config.UserAgent == "" {
config.UserAgent = rest.DefaultKubernetesUserAgent()
}
return nil
}
// RESTClient returns a RESTClient that is used to communicate
// with API server by this client implementation.
func (c *DuckV1alpha1Client) RESTClient() rest.Interface {
if c == nil {
return nil
}
return c.restClient
}

20
client/clientset/versioned/typed/duck/v1alpha1/fake/doc.go generated
View File

@ -1,20 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
// Package fake has the automatically generated clients.
package fake

52
client/clientset/versioned/typed/duck/v1alpha1/fake/fake_duck_client.go generated
View File

@ -1,52 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
package fake
import (
v1alpha1 "github.com/knative/pkg/client/clientset/versioned/typed/duck/v1alpha1"
rest "k8s.io/client-go/rest"
testing "k8s.io/client-go/testing"
)
type FakeDuckV1alpha1 struct {
*testing.Fake
}
func (c *FakeDuckV1alpha1) Generationals(namespace string) v1alpha1.GenerationalInterface {
return &FakeGenerationals{c, namespace}
}
func (c *FakeDuckV1alpha1) KResources(namespace string) v1alpha1.KResourceInterface {
return &FakeKResources{c, namespace}
}
func (c *FakeDuckV1alpha1) Targets(namespace string) v1alpha1.TargetInterface {
return &FakeTargets{c, namespace}
}
func (c *FakeDuckV1alpha1) Topics(namespace string) v1alpha1.TopicInterface {
return &FakeTopics{c, namespace}
}
// RESTClient returns a RESTClient that is used to communicate
// with API server by this client implementation.
func (c *FakeDuckV1alpha1) RESTClient() rest.Interface {
var ret *rest.RESTClient
return ret
}

128
client/clientset/versioned/typed/duck/v1alpha1/fake/fake_generational.go generated
View File

@ -1,128 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
package fake
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
labels "k8s.io/apimachinery/pkg/labels"
schema "k8s.io/apimachinery/pkg/runtime/schema"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
testing "k8s.io/client-go/testing"
)
// FakeGenerationals implements GenerationalInterface
type FakeGenerationals struct {
Fake *FakeDuckV1alpha1
ns string
}
var generationalsResource = schema.GroupVersionResource{Group: "duck.knative.dev", Version: "v1alpha1", Resource: "generationals"}
var generationalsKind = schema.GroupVersionKind{Group: "duck.knative.dev", Version: "v1alpha1", Kind: "Generational"}
// Get takes name of the generational, and returns the corresponding generational object, and an error if there is any.
func (c *FakeGenerationals) Get(name string, options v1.GetOptions) (result *v1alpha1.Generational, err error) {
obj, err := c.Fake.
Invokes(testing.NewGetAction(generationalsResource, c.ns, name), &v1alpha1.Generational{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Generational), err
}
// List takes label and field selectors, and returns the list of Generationals that match those selectors.
func (c *FakeGenerationals) List(opts v1.ListOptions) (result *v1alpha1.GenerationalList, err error) {
obj, err := c.Fake.
Invokes(testing.NewListAction(generationalsResource, generationalsKind, c.ns, opts), &v1alpha1.GenerationalList{})
if obj == nil {
return nil, err
}
label, _, _ := testing.ExtractFromListOptions(opts)
if label == nil {
label = labels.Everything()
}
list := &v1alpha1.GenerationalList{ListMeta: obj.(*v1alpha1.GenerationalList).ListMeta}
for _, item := range obj.(*v1alpha1.GenerationalList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
}
return list, err
}
// Watch returns a watch.Interface that watches the requested generationals.
func (c *FakeGenerationals) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(generationalsResource, c.ns, opts))
}
// Create takes the representation of a generational and creates it. Returns the server's representation of the generational, and an error, if there is any.
func (c *FakeGenerationals) Create(generational *v1alpha1.Generational) (result *v1alpha1.Generational, err error) {
obj, err := c.Fake.
Invokes(testing.NewCreateAction(generationalsResource, c.ns, generational), &v1alpha1.Generational{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Generational), err
}
// Update takes the representation of a generational and updates it. Returns the server's representation of the generational, and an error, if there is any.
func (c *FakeGenerationals) Update(generational *v1alpha1.Generational) (result *v1alpha1.Generational, err error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateAction(generationalsResource, c.ns, generational), &v1alpha1.Generational{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Generational), err
}
// Delete takes name of the generational and deletes it. Returns an error if one occurs.
func (c *FakeGenerationals) Delete(name string, options *v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteAction(generationalsResource, c.ns, name), &v1alpha1.Generational{})
return err
}
// DeleteCollection deletes a collection of objects.
func (c *FakeGenerationals) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
action := testing.NewDeleteCollectionAction(generationalsResource, c.ns, listOptions)
_, err := c.Fake.Invokes(action, &v1alpha1.GenerationalList{})
return err
}
// Patch applies the patch and returns the patched generational.
func (c *FakeGenerationals) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Generational, err error) {
obj, err := c.Fake.
Invokes(testing.NewPatchSubresourceAction(generationalsResource, c.ns, name, data, subresources...), &v1alpha1.Generational{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Generational), err
}

140
client/clientset/versioned/typed/duck/v1alpha1/fake/fake_kresource.go generated
View File

@ -1,140 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
package fake
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
labels "k8s.io/apimachinery/pkg/labels"
schema "k8s.io/apimachinery/pkg/runtime/schema"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
testing "k8s.io/client-go/testing"
)
// FakeKResources implements KResourceInterface
type FakeKResources struct {
Fake *FakeDuckV1alpha1
ns string
}
var kresourcesResource = schema.GroupVersionResource{Group: "duck.knative.dev", Version: "v1alpha1", Resource: "kresources"}
var kresourcesKind = schema.GroupVersionKind{Group: "duck.knative.dev", Version: "v1alpha1", Kind: "KResource"}
// Get takes name of the kResource, and returns the corresponding kResource object, and an error if there is any.
func (c *FakeKResources) Get(name string, options v1.GetOptions) (result *v1alpha1.KResource, err error) {
obj, err := c.Fake.
Invokes(testing.NewGetAction(kresourcesResource, c.ns, name), &v1alpha1.KResource{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.KResource), err
}
// List takes label and field selectors, and returns the list of KResources that match those selectors.
func (c *FakeKResources) List(opts v1.ListOptions) (result *v1alpha1.KResourceList, err error) {
obj, err := c.Fake.
Invokes(testing.NewListAction(kresourcesResource, kresourcesKind, c.ns, opts), &v1alpha1.KResourceList{})
if obj == nil {
return nil, err
}
label, _, _ := testing.ExtractFromListOptions(opts)
if label == nil {
label = labels.Everything()
}
list := &v1alpha1.KResourceList{ListMeta: obj.(*v1alpha1.KResourceList).ListMeta}
for _, item := range obj.(*v1alpha1.KResourceList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
}
return list, err
}
// Watch returns a watch.Interface that watches the requested kResources.
func (c *FakeKResources) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(kresourcesResource, c.ns, opts))
}
// Create takes the representation of a kResource and creates it. Returns the server's representation of the kResource, and an error, if there is any.
func (c *FakeKResources) Create(kResource *v1alpha1.KResource) (result *v1alpha1.KResource, err error) {
obj, err := c.Fake.
Invokes(testing.NewCreateAction(kresourcesResource, c.ns, kResource), &v1alpha1.KResource{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.KResource), err
}
// Update takes the representation of a kResource and updates it. Returns the server's representation of the kResource, and an error, if there is any.
func (c *FakeKResources) Update(kResource *v1alpha1.KResource) (result *v1alpha1.KResource, err error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateAction(kresourcesResource, c.ns, kResource), &v1alpha1.KResource{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.KResource), err
}
// UpdateStatus was generated because the type contains a Status member.
// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
func (c *FakeKResources) UpdateStatus(kResource *v1alpha1.KResource) (*v1alpha1.KResource, error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateSubresourceAction(kresourcesResource, "status", c.ns, kResource), &v1alpha1.KResource{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.KResource), err
}
// Delete takes name of the kResource and deletes it. Returns an error if one occurs.
func (c *FakeKResources) Delete(name string, options *v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteAction(kresourcesResource, c.ns, name), &v1alpha1.KResource{})
return err
}
// DeleteCollection deletes a collection of objects.
func (c *FakeKResources) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
action := testing.NewDeleteCollectionAction(kresourcesResource, c.ns, listOptions)
_, err := c.Fake.Invokes(action, &v1alpha1.KResourceList{})
return err
}
// Patch applies the patch and returns the patched kResource.
func (c *FakeKResources) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.KResource, err error) {
obj, err := c.Fake.
Invokes(testing.NewPatchSubresourceAction(kresourcesResource, c.ns, name, data, subresources...), &v1alpha1.KResource{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.KResource), err
}

140
client/clientset/versioned/typed/duck/v1alpha1/fake/fake_target.go generated
View File

@ -1,140 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
package fake
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
labels "k8s.io/apimachinery/pkg/labels"
schema "k8s.io/apimachinery/pkg/runtime/schema"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
testing "k8s.io/client-go/testing"
)
// FakeTargets implements TargetInterface
type FakeTargets struct {
Fake *FakeDuckV1alpha1
ns string
}
var targetsResource = schema.GroupVersionResource{Group: "duck.knative.dev", Version: "v1alpha1", Resource: "targets"}
var targetsKind = schema.GroupVersionKind{Group: "duck.knative.dev", Version: "v1alpha1", Kind: "Target"}
// Get takes name of the target, and returns the corresponding target object, and an error if there is any.
func (c *FakeTargets) Get(name string, options v1.GetOptions) (result *v1alpha1.Target, err error) {
obj, err := c.Fake.
Invokes(testing.NewGetAction(targetsResource, c.ns, name), &v1alpha1.Target{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Target), err
}
// List takes label and field selectors, and returns the list of Targets that match those selectors.
func (c *FakeTargets) List(opts v1.ListOptions) (result *v1alpha1.TargetList, err error) {
obj, err := c.Fake.
Invokes(testing.NewListAction(targetsResource, targetsKind, c.ns, opts), &v1alpha1.TargetList{})
if obj == nil {
return nil, err
}
label, _, _ := testing.ExtractFromListOptions(opts)
if label == nil {
label = labels.Everything()
}
list := &v1alpha1.TargetList{ListMeta: obj.(*v1alpha1.TargetList).ListMeta}
for _, item := range obj.(*v1alpha1.TargetList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
}
return list, err
}
// Watch returns a watch.Interface that watches the requested targets.
func (c *FakeTargets) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(targetsResource, c.ns, opts))
}
// Create takes the representation of a target and creates it. Returns the server's representation of the target, and an error, if there is any.
func (c *FakeTargets) Create(target *v1alpha1.Target) (result *v1alpha1.Target, err error) {
obj, err := c.Fake.
Invokes(testing.NewCreateAction(targetsResource, c.ns, target), &v1alpha1.Target{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Target), err
}
// Update takes the representation of a target and updates it. Returns the server's representation of the target, and an error, if there is any.
func (c *FakeTargets) Update(target *v1alpha1.Target) (result *v1alpha1.Target, err error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateAction(targetsResource, c.ns, target), &v1alpha1.Target{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Target), err
}
// UpdateStatus was generated because the type contains a Status member.
// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
func (c *FakeTargets) UpdateStatus(target *v1alpha1.Target) (*v1alpha1.Target, error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateSubresourceAction(targetsResource, "status", c.ns, target), &v1alpha1.Target{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Target), err
}
// Delete takes name of the target and deletes it. Returns an error if one occurs.
func (c *FakeTargets) Delete(name string, options *v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteAction(targetsResource, c.ns, name), &v1alpha1.Target{})
return err
}
// DeleteCollection deletes a collection of objects.
func (c *FakeTargets) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
action := testing.NewDeleteCollectionAction(targetsResource, c.ns, listOptions)
_, err := c.Fake.Invokes(action, &v1alpha1.TargetList{})
return err
}
// Patch applies the patch and returns the patched target.
func (c *FakeTargets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Target, err error) {
obj, err := c.Fake.
Invokes(testing.NewPatchSubresourceAction(targetsResource, c.ns, name, data, subresources...), &v1alpha1.Target{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Target), err
}

140
client/clientset/versioned/typed/duck/v1alpha1/fake/fake_topic.go generated
View File

@ -1,140 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
package fake
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
labels "k8s.io/apimachinery/pkg/labels"
schema "k8s.io/apimachinery/pkg/runtime/schema"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
testing "k8s.io/client-go/testing"
)
// FakeTopics implements TopicInterface
type FakeTopics struct {
Fake *FakeDuckV1alpha1
ns string
}
var topicsResource = schema.GroupVersionResource{Group: "duck.knative.dev", Version: "v1alpha1", Resource: "topics"}
var topicsKind = schema.GroupVersionKind{Group: "duck.knative.dev", Version: "v1alpha1", Kind: "Topic"}
// Get takes name of the topic, and returns the corresponding topic object, and an error if there is any.
func (c *FakeTopics) Get(name string, options v1.GetOptions) (result *v1alpha1.Topic, err error) {
obj, err := c.Fake.
Invokes(testing.NewGetAction(topicsResource, c.ns, name), &v1alpha1.Topic{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Topic), err
}
// List takes label and field selectors, and returns the list of Topics that match those selectors.
func (c *FakeTopics) List(opts v1.ListOptions) (result *v1alpha1.TopicList, err error) {
obj, err := c.Fake.
Invokes(testing.NewListAction(topicsResource, topicsKind, c.ns, opts), &v1alpha1.TopicList{})
if obj == nil {
return nil, err
}
label, _, _ := testing.ExtractFromListOptions(opts)
if label == nil {
label = labels.Everything()
}
list := &v1alpha1.TopicList{ListMeta: obj.(*v1alpha1.TopicList).ListMeta}
for _, item := range obj.(*v1alpha1.TopicList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
}
return list, err
}
// Watch returns a watch.Interface that watches the requested topics.
func (c *FakeTopics) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(topicsResource, c.ns, opts))
}
// Create takes the representation of a topic and creates it. Returns the server's representation of the topic, and an error, if there is any.
func (c *FakeTopics) Create(topic *v1alpha1.Topic) (result *v1alpha1.Topic, err error) {
obj, err := c.Fake.
Invokes(testing.NewCreateAction(topicsResource, c.ns, topic), &v1alpha1.Topic{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Topic), err
}
// Update takes the representation of a topic and updates it. Returns the server's representation of the topic, and an error, if there is any.
func (c *FakeTopics) Update(topic *v1alpha1.Topic) (result *v1alpha1.Topic, err error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateAction(topicsResource, c.ns, topic), &v1alpha1.Topic{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Topic), err
}
// UpdateStatus was generated because the type contains a Status member.
// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
func (c *FakeTopics) UpdateStatus(topic *v1alpha1.Topic) (*v1alpha1.Topic, error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateSubresourceAction(topicsResource, "status", c.ns, topic), &v1alpha1.Topic{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Topic), err
}
// Delete takes name of the topic and deletes it. Returns an error if one occurs.
func (c *FakeTopics) Delete(name string, options *v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteAction(topicsResource, c.ns, name), &v1alpha1.Topic{})
return err
}
// DeleteCollection deletes a collection of objects.
func (c *FakeTopics) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
action := testing.NewDeleteCollectionAction(topicsResource, c.ns, listOptions)
_, err := c.Fake.Invokes(action, &v1alpha1.TopicList{})
return err
}
// Patch applies the patch and returns the patched topic.
func (c *FakeTopics) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Topic, err error) {
obj, err := c.Fake.
Invokes(testing.NewPatchSubresourceAction(topicsResource, c.ns, name, data, subresources...), &v1alpha1.Topic{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Topic), err
}

27
client/clientset/versioned/typed/duck/v1alpha1/generated_expansion.go generated
View File

@ -1,27 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
package v1alpha1
type GenerationalExpansion interface{}
type KResourceExpansion interface{}
type TargetExpansion interface{}
type TopicExpansion interface{}

157
client/clientset/versioned/typed/duck/v1alpha1/generational.go generated
View File

@ -1,157 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
package v1alpha1
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
scheme "github.com/knative/pkg/client/clientset/versioned/scheme"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
rest "k8s.io/client-go/rest"
)
// GenerationalsGetter has a method to return a GenerationalInterface.
// A group's client should implement this interface.
type GenerationalsGetter interface {
Generationals(namespace string) GenerationalInterface
}
// GenerationalInterface has methods to work with Generational resources.
type GenerationalInterface interface {
Create(*v1alpha1.Generational) (*v1alpha1.Generational, error)
Update(*v1alpha1.Generational) (*v1alpha1.Generational, error)
Delete(name string, options *v1.DeleteOptions) error
DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
Get(name string, options v1.GetOptions) (*v1alpha1.Generational, error)
List(opts v1.ListOptions) (*v1alpha1.GenerationalList, error)
Watch(opts v1.ListOptions) (watch.Interface, error)
Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Generational, err error)
GenerationalExpansion
}
// generationals implements GenerationalInterface
type generationals struct {
client rest.Interface
ns string
}
// newGenerationals returns a Generationals
func newGenerationals(c *DuckV1alpha1Client, namespace string) *generationals {
return &generationals{
client: c.RESTClient(),
ns: namespace,
}
}
// Get takes name of the generational, and returns the corresponding generational object, and an error if there is any.
func (c *generationals) Get(name string, options v1.GetOptions) (result *v1alpha1.Generational, err error) {
result = &v1alpha1.Generational{}
err = c.client.Get().
Namespace(c.ns).
Resource("generationals").
Name(name).
VersionedParams(&options, scheme.ParameterCodec).
Do().
Into(result)
return
}
// List takes label and field selectors, and returns the list of Generationals that match those selectors.
func (c *generationals) List(opts v1.ListOptions) (result *v1alpha1.GenerationalList, err error) {
result = &v1alpha1.GenerationalList{}
err = c.client.Get().
Namespace(c.ns).
Resource("generationals").
VersionedParams(&opts, scheme.ParameterCodec).
Do().
Into(result)
return
}
// Watch returns a watch.Interface that watches the requested generationals.
func (c *generationals) Watch(opts v1.ListOptions) (watch.Interface, error) {
opts.Watch = true
return c.client.Get().
Namespace(c.ns).
Resource("generationals").
VersionedParams(&opts, scheme.ParameterCodec).
Watch()
}
// Create takes the representation of a generational and creates it. Returns the server's representation of the generational, and an error, if there is any.
func (c *generationals) Create(generational *v1alpha1.Generational) (result *v1alpha1.Generational, err error) {
result = &v1alpha1.Generational{}
err = c.client.Post().
Namespace(c.ns).
Resource("generationals").
Body(generational).
Do().
Into(result)
return
}
// Update takes the representation of a generational and updates it. Returns the server's representation of the generational, and an error, if there is any.
func (c *generationals) Update(generational *v1alpha1.Generational) (result *v1alpha1.Generational, err error) {
result = &v1alpha1.Generational{}
err = c.client.Put().
Namespace(c.ns).
Resource("generationals").
Name(generational.Name).
Body(generational).
Do().
Into(result)
return
}
// Delete takes name of the generational and deletes it. Returns an error if one occurs.
func (c *generationals) Delete(name string, options *v1.DeleteOptions) error {
return c.client.Delete().
Namespace(c.ns).
Resource("generationals").
Name(name).
Body(options).
Do().
Error()
}
// DeleteCollection deletes a collection of objects.
func (c *generationals) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
return c.client.Delete().
Namespace(c.ns).
Resource("generationals").
VersionedParams(&listOptions, scheme.ParameterCodec).
Body(options).
Do().
Error()
}
// Patch applies the patch and returns the patched generational.
func (c *generationals) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Generational, err error) {
result = &v1alpha1.Generational{}
err = c.client.Patch(pt).
Namespace(c.ns).
Resource("generationals").
SubResource(subresources...).
Name(name).
Body(data).
Do().
Into(result)
return
}

174
client/clientset/versioned/typed/duck/v1alpha1/kresource.go generated
View File

@ -1,174 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
package v1alpha1
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
scheme "github.com/knative/pkg/client/clientset/versioned/scheme"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
rest "k8s.io/client-go/rest"
)
// KResourcesGetter has a method to return a KResourceInterface.
// A group's client should implement this interface.
type KResourcesGetter interface {
KResources(namespace string) KResourceInterface
}
// KResourceInterface has methods to work with KResource resources.
type KResourceInterface interface {
Create(*v1alpha1.KResource) (*v1alpha1.KResource, error)
Update(*v1alpha1.KResource) (*v1alpha1.KResource, error)
UpdateStatus(*v1alpha1.KResource) (*v1alpha1.KResource, error)
Delete(name string, options *v1.DeleteOptions) error
DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
Get(name string, options v1.GetOptions) (*v1alpha1.KResource, error)
List(opts v1.ListOptions) (*v1alpha1.KResourceList, error)
Watch(opts v1.ListOptions) (watch.Interface, error)
Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.KResource, err error)
KResourceExpansion
}
// kResources implements KResourceInterface
type kResources struct {
client rest.Interface
ns string
}
// newKResources returns a KResources
func newKResources(c *DuckV1alpha1Client, namespace string) *kResources {
return &kResources{
client: c.RESTClient(),
ns: namespace,
}
}
// Get takes name of the kResource, and returns the corresponding kResource object, and an error if there is any.
func (c *kResources) Get(name string, options v1.GetOptions) (result *v1alpha1.KResource, err error) {
result = &v1alpha1.KResource{}
err = c.client.Get().
Namespace(c.ns).
Resource("kresources").
Name(name).
VersionedParams(&options, scheme.ParameterCodec).
Do().
Into(result)
return
}
// List takes label and field selectors, and returns the list of KResources that match those selectors.
func (c *kResources) List(opts v1.ListOptions) (result *v1alpha1.KResourceList, err error) {
result = &v1alpha1.KResourceList{}
err = c.client.Get().
Namespace(c.ns).
Resource("kresources").
VersionedParams(&opts, scheme.ParameterCodec).
Do().
Into(result)
return
}
// Watch returns a watch.Interface that watches the requested kResources.
func (c *kResources) Watch(opts v1.ListOptions) (watch.Interface, error) {
opts.Watch = true
return c.client.Get().
Namespace(c.ns).
Resource("kresources").
VersionedParams(&opts, scheme.ParameterCodec).
Watch()
}
// Create takes the representation of a kResource and creates it. Returns the server's representation of the kResource, and an error, if there is any.
func (c *kResources) Create(kResource *v1alpha1.KResource) (result *v1alpha1.KResource, err error) {
result = &v1alpha1.KResource{}
err = c.client.Post().
Namespace(c.ns).
Resource("kresources").
Body(kResource).
Do().
Into(result)
return
}
// Update takes the representation of a kResource and updates it. Returns the server's representation of the kResource, and an error, if there is any.
func (c *kResources) Update(kResource *v1alpha1.KResource) (result *v1alpha1.KResource, err error) {
result = &v1alpha1.KResource{}
err = c.client.Put().
Namespace(c.ns).
Resource("kresources").
Name(kResource.Name).
Body(kResource).
Do().
Into(result)
return
}
// UpdateStatus was generated because the type contains a Status member.
// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
func (c *kResources) UpdateStatus(kResource *v1alpha1.KResource) (result *v1alpha1.KResource, err error) {
result = &v1alpha1.KResource{}
err = c.client.Put().
Namespace(c.ns).
Resource("kresources").
Name(kResource.Name).
SubResource("status").
Body(kResource).
Do().
Into(result)
return
}
// Delete takes name of the kResource and deletes it. Returns an error if one occurs.
func (c *kResources) Delete(name string, options *v1.DeleteOptions) error {
return c.client.Delete().
Namespace(c.ns).
Resource("kresources").
Name(name).
Body(options).
Do().
Error()
}
// DeleteCollection deletes a collection of objects.
func (c *kResources) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
return c.client.Delete().
Namespace(c.ns).
Resource("kresources").
VersionedParams(&listOptions, scheme.ParameterCodec).
Body(options).
Do().
Error()
}
// Patch applies the patch and returns the patched kResource.
func (c *kResources) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.KResource, err error) {
result = &v1alpha1.KResource{}
err = c.client.Patch(pt).
Namespace(c.ns).
Resource("kresources").
SubResource(subresources...).
Name(name).
Body(data).
Do().
Into(result)
return
}

174
client/clientset/versioned/typed/duck/v1alpha1/target.go generated
View File

@ -1,174 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
package v1alpha1
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
scheme "github.com/knative/pkg/client/clientset/versioned/scheme"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
rest "k8s.io/client-go/rest"
)
// TargetsGetter has a method to return a TargetInterface.
// A group's client should implement this interface.
type TargetsGetter interface {
Targets(namespace string) TargetInterface
}
// TargetInterface has methods to work with Target resources.
type TargetInterface interface {
Create(*v1alpha1.Target) (*v1alpha1.Target, error)
Update(*v1alpha1.Target) (*v1alpha1.Target, error)
UpdateStatus(*v1alpha1.Target) (*v1alpha1.Target, error)
Delete(name string, options *v1.DeleteOptions) error
DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
Get(name string, options v1.GetOptions) (*v1alpha1.Target, error)
List(opts v1.ListOptions) (*v1alpha1.TargetList, error)
Watch(opts v1.ListOptions) (watch.Interface, error)
Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Target, err error)
TargetExpansion
}
// targets implements TargetInterface
type targets struct {
client rest.Interface
ns string
}
// newTargets returns a Targets
func newTargets(c *DuckV1alpha1Client, namespace string) *targets {
return &targets{
client: c.RESTClient(),
ns: namespace,
}
}
// Get takes name of the target, and returns the corresponding target object, and an error if there is any.
func (c *targets) Get(name string, options v1.GetOptions) (result *v1alpha1.Target, err error) {
result = &v1alpha1.Target{}
err = c.client.Get().
Namespace(c.ns).
Resource("targets").
Name(name).
VersionedParams(&options, scheme.ParameterCodec).
Do().
Into(result)
return
}
// List takes label and field selectors, and returns the list of Targets that match those selectors.
func (c *targets) List(opts v1.ListOptions) (result *v1alpha1.TargetList, err error) {
result = &v1alpha1.TargetList{}
err = c.client.Get().
Namespace(c.ns).
Resource("targets").
VersionedParams(&opts, scheme.ParameterCodec).
Do().
Into(result)
return
}
// Watch returns a watch.Interface that watches the requested targets.
func (c *targets) Watch(opts v1.ListOptions) (watch.Interface, error) {
opts.Watch = true
return c.client.Get().
Namespace(c.ns).
Resource("targets").
VersionedParams(&opts, scheme.ParameterCodec).
Watch()
}
// Create takes the representation of a target and creates it. Returns the server's representation of the target, and an error, if there is any.
func (c *targets) Create(target *v1alpha1.Target) (result *v1alpha1.Target, err error) {
result = &v1alpha1.Target{}
err = c.client.Post().
Namespace(c.ns).
Resource("targets").
Body(target).
Do().
Into(result)
return
}
// Update takes the representation of a target and updates it. Returns the server's representation of the target, and an error, if there is any.
func (c *targets) Update(target *v1alpha1.Target) (result *v1alpha1.Target, err error) {
result = &v1alpha1.Target{}
err = c.client.Put().
Namespace(c.ns).
Resource("targets").
Name(target.Name).
Body(target).
Do().
Into(result)
return
}
// UpdateStatus was generated because the type contains a Status member.
// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
func (c *targets) UpdateStatus(target *v1alpha1.Target) (result *v1alpha1.Target, err error) {
result = &v1alpha1.Target{}
err = c.client.Put().
Namespace(c.ns).
Resource("targets").
Name(target.Name).
SubResource("status").
Body(target).
Do().
Into(result)
return
}
// Delete takes name of the target and deletes it. Returns an error if one occurs.
func (c *targets) Delete(name string, options *v1.DeleteOptions) error {
return c.client.Delete().
Namespace(c.ns).
Resource("targets").
Name(name).
Body(options).
Do().
Error()
}
// DeleteCollection deletes a collection of objects.
func (c *targets) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
return c.client.Delete().
Namespace(c.ns).
Resource("targets").
VersionedParams(&listOptions, scheme.ParameterCodec).
Body(options).
Do().
Error()
}
// Patch applies the patch and returns the patched target.
func (c *targets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Target, err error) {
result = &v1alpha1.Target{}
err = c.client.Patch(pt).
Namespace(c.ns).
Resource("targets").
SubResource(subresources...).
Name(name).
Body(data).
Do().
Into(result)
return
}

174
client/clientset/versioned/typed/duck/v1alpha1/topic.go generated
View File

@ -1,174 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 client-gen. DO NOT EDIT.
package v1alpha1
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
scheme "github.com/knative/pkg/client/clientset/versioned/scheme"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
rest "k8s.io/client-go/rest"
)
// TopicsGetter has a method to return a TopicInterface.
// A group's client should implement this interface.
type TopicsGetter interface {
Topics(namespace string) TopicInterface
}
// TopicInterface has methods to work with Topic resources.
type TopicInterface interface {
Create(*v1alpha1.Topic) (*v1alpha1.Topic, error)
Update(*v1alpha1.Topic) (*v1alpha1.Topic, error)
UpdateStatus(*v1alpha1.Topic) (*v1alpha1.Topic, error)
Delete(name string, options *v1.DeleteOptions) error
DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
Get(name string, options v1.GetOptions) (*v1alpha1.Topic, error)
List(opts v1.ListOptions) (*v1alpha1.TopicList, error)
Watch(opts v1.ListOptions) (watch.Interface, error)
Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Topic, err error)
TopicExpansion
}
// topics implements TopicInterface
type topics struct {
client rest.Interface
ns string
}
// newTopics returns a Topics
func newTopics(c *DuckV1alpha1Client, namespace string) *topics {
return &topics{
client: c.RESTClient(),
ns: namespace,
}
}
// Get takes name of the topic, and returns the corresponding topic object, and an error if there is any.
func (c *topics) Get(name string, options v1.GetOptions) (result *v1alpha1.Topic, err error) {
result = &v1alpha1.Topic{}
err = c.client.Get().
Namespace(c.ns).
Resource("topics").
Name(name).
VersionedParams(&options, scheme.ParameterCodec).
Do().
Into(result)
return
}
// List takes label and field selectors, and returns the list of Topics that match those selectors.
func (c *topics) List(opts v1.ListOptions) (result *v1alpha1.TopicList, err error) {
result = &v1alpha1.TopicList{}
err = c.client.Get().
Namespace(c.ns).
Resource("topics").
VersionedParams(&opts, scheme.ParameterCodec).
Do().
Into(result)
return
}
// Watch returns a watch.Interface that watches the requested topics.
func (c *topics) Watch(opts v1.ListOptions) (watch.Interface, error) {
opts.Watch = true
return c.client.Get().
Namespace(c.ns).
Resource("topics").
VersionedParams(&opts, scheme.ParameterCodec).
Watch()
}
// Create takes the representation of a topic and creates it. Returns the server's representation of the topic, and an error, if there is any.
func (c *topics) Create(topic *v1alpha1.Topic) (result *v1alpha1.Topic, err error) {
result = &v1alpha1.Topic{}
err = c.client.Post().
Namespace(c.ns).
Resource("topics").
Body(topic).
Do().
Into(result)
return
}
// Update takes the representation of a topic and updates it. Returns the server's representation of the topic, and an error, if there is any.
func (c *topics) Update(topic *v1alpha1.Topic) (result *v1alpha1.Topic, err error) {
result = &v1alpha1.Topic{}
err = c.client.Put().
Namespace(c.ns).
Resource("topics").
Name(topic.Name).
Body(topic).
Do().
Into(result)
return
}
// UpdateStatus was generated because the type contains a Status member.
// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
func (c *topics) UpdateStatus(topic *v1alpha1.Topic) (result *v1alpha1.Topic, err error) {
result = &v1alpha1.Topic{}
err = c.client.Put().
Namespace(c.ns).
Resource("topics").
Name(topic.Name).
SubResource("status").
Body(topic).
Do().
Into(result)
return
}
// Delete takes name of the topic and deletes it. Returns an error if one occurs.
func (c *topics) Delete(name string, options *v1.DeleteOptions) error {
return c.client.Delete().
Namespace(c.ns).
Resource("topics").
Name(name).
Body(options).
Do().
Error()
}
// DeleteCollection deletes a collection of objects.
func (c *topics) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
return c.client.Delete().
Namespace(c.ns).
Resource("topics").
VersionedParams(&listOptions, scheme.ParameterCodec).
Body(options).
Do().
Error()
}
// Patch applies the patch and returns the patched topic.
func (c *topics) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Topic, err error) {
result = &v1alpha1.Topic{}
err = c.client.Patch(pt).
Namespace(c.ns).
Resource("topics").
SubResource(subresources...).
Name(name).
Body(data).
Do().
Into(result)
return
}

46
client/informers/externalversions/duck/interface.go generated
View File

@ -1,46 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 informer-gen. DO NOT EDIT.
package duck
import (
v1alpha1 "github.com/knative/pkg/client/informers/externalversions/duck/v1alpha1"
internalinterfaces "github.com/knative/pkg/client/informers/externalversions/internalinterfaces"
)
// Interface provides access to each of this group's versions.
type Interface interface {
// V1alpha1 provides access to shared informers for resources in V1alpha1.
V1alpha1() v1alpha1.Interface
}
type group struct {
factory internalinterfaces.SharedInformerFactory
namespace string
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// New returns a new Interface.
func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
}
// V1alpha1 returns a new v1alpha1.Interface.
func (g *group) V1alpha1() v1alpha1.Interface {
return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)
}

89
client/informers/externalversions/duck/v1alpha1/generational.go generated
View File

@ -1,89 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 informer-gen. DO NOT EDIT.
package v1alpha1
import (
time "time"
duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
versioned "github.com/knative/pkg/client/clientset/versioned"
internalinterfaces "github.com/knative/pkg/client/informers/externalversions/internalinterfaces"
v1alpha1 "github.com/knative/pkg/client/listers/duck/v1alpha1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
)
// GenerationalInformer provides access to a shared informer and lister for
// Generationals.
type GenerationalInformer interface {
Informer() cache.SharedIndexInformer
Lister() v1alpha1.GenerationalLister
}
type generationalInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
namespace string
}
// NewGenerationalInformer constructs a new informer for Generational type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewGenerationalInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredGenerationalInformer(client, namespace, resyncPeriod, indexers, nil)
}
// NewFilteredGenerationalInformer constructs a new informer for Generational type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredGenerationalInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.DuckV1alpha1().Generationals(namespace).List(options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.DuckV1alpha1().Generationals(namespace).Watch(options)
},
},
&duckv1alpha1.Generational{},
resyncPeriod,
indexers,
)
}
func (f *generationalInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredGenerationalInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *generationalInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&duckv1alpha1.Generational{}, f.defaultInformer)
}
func (f *generationalInformer) Lister() v1alpha1.GenerationalLister {
return v1alpha1.NewGenerationalLister(f.Informer().GetIndexer())
}

66
client/informers/externalversions/duck/v1alpha1/interface.go generated
View File

@ -1,66 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 informer-gen. DO NOT EDIT.
package v1alpha1
import (
internalinterfaces "github.com/knative/pkg/client/informers/externalversions/internalinterfaces"
)
// Interface provides access to all the informers in this group version.
type Interface interface {
// Generationals returns a GenerationalInformer.
Generationals() GenerationalInformer
// KResources returns a KResourceInformer.
KResources() KResourceInformer
// Targets returns a TargetInformer.
Targets() TargetInformer
// Topics returns a TopicInformer.
Topics() TopicInformer
}
type version struct {
factory internalinterfaces.SharedInformerFactory
namespace string
tweakListOptions internalinterfaces.TweakListOptionsFunc
}
// New returns a new Interface.
func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
}
// Generationals returns a GenerationalInformer.
func (v *version) Generationals() GenerationalInformer {
return &generationalInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
}
// KResources returns a KResourceInformer.
func (v *version) KResources() KResourceInformer {
return &kResourceInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
}
// Targets returns a TargetInformer.
func (v *version) Targets() TargetInformer {
return &targetInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
}
// Topics returns a TopicInformer.
func (v *version) Topics() TopicInformer {
return &topicInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
}

89
client/informers/externalversions/duck/v1alpha1/kresource.go generated
View File

@ -1,89 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 informer-gen. DO NOT EDIT.
package v1alpha1
import (
time "time"
duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
versioned "github.com/knative/pkg/client/clientset/versioned"
internalinterfaces "github.com/knative/pkg/client/informers/externalversions/internalinterfaces"
v1alpha1 "github.com/knative/pkg/client/listers/duck/v1alpha1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
)
// KResourceInformer provides access to a shared informer and lister for
// KResources.
type KResourceInformer interface {
Informer() cache.SharedIndexInformer
Lister() v1alpha1.KResourceLister
}
type kResourceInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
namespace string
}
// NewKResourceInformer constructs a new informer for KResource type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewKResourceInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredKResourceInformer(client, namespace, resyncPeriod, indexers, nil)
}
// NewFilteredKResourceInformer constructs a new informer for KResource type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredKResourceInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.DuckV1alpha1().KResources(namespace).List(options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.DuckV1alpha1().KResources(namespace).Watch(options)
},
},
&duckv1alpha1.KResource{},
resyncPeriod,
indexers,
)
}
func (f *kResourceInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredKResourceInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *kResourceInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&duckv1alpha1.KResource{}, f.defaultInformer)
}
func (f *kResourceInformer) Lister() v1alpha1.KResourceLister {
return v1alpha1.NewKResourceLister(f.Informer().GetIndexer())
}

89
client/informers/externalversions/duck/v1alpha1/target.go generated
View File

@ -1,89 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 informer-gen. DO NOT EDIT.
package v1alpha1
import (
time "time"
duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
versioned "github.com/knative/pkg/client/clientset/versioned"
internalinterfaces "github.com/knative/pkg/client/informers/externalversions/internalinterfaces"
v1alpha1 "github.com/knative/pkg/client/listers/duck/v1alpha1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
)
// TargetInformer provides access to a shared informer and lister for
// Targets.
type TargetInformer interface {
Informer() cache.SharedIndexInformer
Lister() v1alpha1.TargetLister
}
type targetInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
namespace string
}
// NewTargetInformer constructs a new informer for Target type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewTargetInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredTargetInformer(client, namespace, resyncPeriod, indexers, nil)
}
// NewFilteredTargetInformer constructs a new informer for Target type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredTargetInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.DuckV1alpha1().Targets(namespace).List(options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.DuckV1alpha1().Targets(namespace).Watch(options)
},
},
&duckv1alpha1.Target{},
resyncPeriod,
indexers,
)
}
func (f *targetInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredTargetInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *targetInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&duckv1alpha1.Target{}, f.defaultInformer)
}
func (f *targetInformer) Lister() v1alpha1.TargetLister {
return v1alpha1.NewTargetLister(f.Informer().GetIndexer())
}

89
client/informers/externalversions/duck/v1alpha1/topic.go generated
View File

@ -1,89 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 informer-gen. DO NOT EDIT.
package v1alpha1
import (
time "time"
duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
versioned "github.com/knative/pkg/client/clientset/versioned"
internalinterfaces "github.com/knative/pkg/client/informers/externalversions/internalinterfaces"
v1alpha1 "github.com/knative/pkg/client/listers/duck/v1alpha1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
)
// TopicInformer provides access to a shared informer and lister for
// Topics.
type TopicInformer interface {
Informer() cache.SharedIndexInformer
Lister() v1alpha1.TopicLister
}
type topicInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
namespace string
}
// NewTopicInformer constructs a new informer for Topic type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewTopicInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredTopicInformer(client, namespace, resyncPeriod, indexers, nil)
}
// NewFilteredTopicInformer constructs a new informer for Topic type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredTopicInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.DuckV1alpha1().Topics(namespace).List(options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.DuckV1alpha1().Topics(namespace).Watch(options)
},
},
&duckv1alpha1.Topic{},
resyncPeriod,
indexers,
)
}
func (f *topicInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredTopicInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *topicInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&duckv1alpha1.Topic{}, f.defaultInformer)
}
func (f *topicInformer) Lister() v1alpha1.TopicLister {
return v1alpha1.NewTopicLister(f.Informer().GetIndexer())
}

6
client/informers/externalversions/factory.go generated
View File

@ -25,7 +25,6 @@ import (
versioned "github.com/knative/pkg/client/clientset/versioned"
authentication "github.com/knative/pkg/client/informers/externalversions/authentication"
duck "github.com/knative/pkg/client/informers/externalversions/duck"
internalinterfaces "github.com/knative/pkg/client/informers/externalversions/internalinterfaces"
istio "github.com/knative/pkg/client/informers/externalversions/istio"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@ -175,7 +174,6 @@ type SharedInformerFactory interface {
WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool
Authentication() authentication.Interface
Duck() duck.Interface
Networking() istio.Interface
}
@ -183,10 +181,6 @@ func (f *sharedInformerFactory) Authentication() authentication.Interface {
return authentication.New(f, f.namespace, f.tweakListOptions)
}
func (f *sharedInformerFactory) Duck() duck.Interface {
return duck.New(f, f.namespace, f.tweakListOptions)
}
func (f *sharedInformerFactory) Networking() istio.Interface {
return istio.New(f, f.namespace, f.tweakListOptions)
}

11
client/informers/externalversions/generic.go generated
View File

@ -21,7 +21,6 @@ package externalversions
import (
"fmt"
duckv1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
v1alpha1 "github.com/knative/pkg/apis/istio/authentication/v1alpha1"
v1alpha3 "github.com/knative/pkg/apis/istio/v1alpha3"
schema "k8s.io/apimachinery/pkg/runtime/schema"
@ -58,16 +57,6 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource
case v1alpha1.SchemeGroupVersion.WithResource("policies"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Authentication().V1alpha1().Policies().Informer()}, nil
// Group=duck.knative.dev, Version=v1alpha1
case duckv1alpha1.SchemeGroupVersion.WithResource("generationals"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Duck().V1alpha1().Generationals().Informer()}, nil
case duckv1alpha1.SchemeGroupVersion.WithResource("kresources"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Duck().V1alpha1().KResources().Informer()}, nil
case duckv1alpha1.SchemeGroupVersion.WithResource("targets"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Duck().V1alpha1().Targets().Informer()}, nil
case duckv1alpha1.SchemeGroupVersion.WithResource("topics"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Duck().V1alpha1().Topics().Informer()}, nil
// Group=networking.istio.io, Version=v1alpha3
case v1alpha3.SchemeGroupVersion.WithResource("destinationrules"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Networking().V1alpha3().DestinationRules().Informer()}, nil

51
client/listers/duck/v1alpha1/expansion_generated.go generated
View File

@ -1,51 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 lister-gen. DO NOT EDIT.
package v1alpha1
// GenerationalListerExpansion allows custom methods to be added to
// GenerationalLister.
type GenerationalListerExpansion interface{}
// GenerationalNamespaceListerExpansion allows custom methods to be added to
// GenerationalNamespaceLister.
type GenerationalNamespaceListerExpansion interface{}
// KResourceListerExpansion allows custom methods to be added to
// KResourceLister.
type KResourceListerExpansion interface{}
// KResourceNamespaceListerExpansion allows custom methods to be added to
// KResourceNamespaceLister.
type KResourceNamespaceListerExpansion interface{}
// TargetListerExpansion allows custom methods to be added to
// TargetLister.
type TargetListerExpansion interface{}
// TargetNamespaceListerExpansion allows custom methods to be added to
// TargetNamespaceLister.
type TargetNamespaceListerExpansion interface{}
// TopicListerExpansion allows custom methods to be added to
// TopicLister.
type TopicListerExpansion interface{}
// TopicNamespaceListerExpansion allows custom methods to be added to
// TopicNamespaceLister.
type TopicNamespaceListerExpansion interface{}

94
client/listers/duck/v1alpha1/generational.go generated
View File

@ -1,94 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 lister-gen. DO NOT EDIT.
package v1alpha1
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
"k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/tools/cache"
)
// GenerationalLister helps list Generationals.
type GenerationalLister interface {
// List lists all Generationals in the indexer.
List(selector labels.Selector) (ret []*v1alpha1.Generational, err error)
// Generationals returns an object that can list and get Generationals.
Generationals(namespace string) GenerationalNamespaceLister
GenerationalListerExpansion
}
// generationalLister implements the GenerationalLister interface.
type generationalLister struct {
indexer cache.Indexer
}
// NewGenerationalLister returns a new GenerationalLister.
func NewGenerationalLister(indexer cache.Indexer) GenerationalLister {
return &generationalLister{indexer: indexer}
}
// List lists all Generationals in the indexer.
func (s *generationalLister) List(selector labels.Selector) (ret []*v1alpha1.Generational, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.Generational))
})
return ret, err
}
// Generationals returns an object that can list and get Generationals.
func (s *generationalLister) Generationals(namespace string) GenerationalNamespaceLister {
return generationalNamespaceLister{indexer: s.indexer, namespace: namespace}
}
// GenerationalNamespaceLister helps list and get Generationals.
type GenerationalNamespaceLister interface {
// List lists all Generationals in the indexer for a given namespace.
List(selector labels.Selector) (ret []*v1alpha1.Generational, err error)
// Get retrieves the Generational from the indexer for a given namespace and name.
Get(name string) (*v1alpha1.Generational, error)
GenerationalNamespaceListerExpansion
}
// generationalNamespaceLister implements the GenerationalNamespaceLister
// interface.
type generationalNamespaceLister struct {
indexer cache.Indexer
namespace string
}
// List lists all Generationals in the indexer for a given namespace.
func (s generationalNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.Generational, err error) {
err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.Generational))
})
return ret, err
}
// Get retrieves the Generational from the indexer for a given namespace and name.
func (s generationalNamespaceLister) Get(name string) (*v1alpha1.Generational, error) {
obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
if err != nil {
return nil, err
}
if !exists {
return nil, errors.NewNotFound(v1alpha1.Resource("generational"), name)
}
return obj.(*v1alpha1.Generational), nil
}

94
client/listers/duck/v1alpha1/kresource.go generated
View File

@ -1,94 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 lister-gen. DO NOT EDIT.
package v1alpha1
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
"k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/tools/cache"
)
// KResourceLister helps list KResources.
type KResourceLister interface {
// List lists all KResources in the indexer.
List(selector labels.Selector) (ret []*v1alpha1.KResource, err error)
// KResources returns an object that can list and get KResources.
KResources(namespace string) KResourceNamespaceLister
KResourceListerExpansion
}
// kResourceLister implements the KResourceLister interface.
type kResourceLister struct {
indexer cache.Indexer
}
// NewKResourceLister returns a new KResourceLister.
func NewKResourceLister(indexer cache.Indexer) KResourceLister {
return &kResourceLister{indexer: indexer}
}
// List lists all KResources in the indexer.
func (s *kResourceLister) List(selector labels.Selector) (ret []*v1alpha1.KResource, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.KResource))
})
return ret, err
}
// KResources returns an object that can list and get KResources.
func (s *kResourceLister) KResources(namespace string) KResourceNamespaceLister {
return kResourceNamespaceLister{indexer: s.indexer, namespace: namespace}
}
// KResourceNamespaceLister helps list and get KResources.
type KResourceNamespaceLister interface {
// List lists all KResources in the indexer for a given namespace.
List(selector labels.Selector) (ret []*v1alpha1.KResource, err error)
// Get retrieves the KResource from the indexer for a given namespace and name.
Get(name string) (*v1alpha1.KResource, error)
KResourceNamespaceListerExpansion
}
// kResourceNamespaceLister implements the KResourceNamespaceLister
// interface.
type kResourceNamespaceLister struct {
indexer cache.Indexer
namespace string
}
// List lists all KResources in the indexer for a given namespace.
func (s kResourceNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.KResource, err error) {
err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.KResource))
})
return ret, err
}
// Get retrieves the KResource from the indexer for a given namespace and name.
func (s kResourceNamespaceLister) Get(name string) (*v1alpha1.KResource, error) {
obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
if err != nil {
return nil, err
}
if !exists {
return nil, errors.NewNotFound(v1alpha1.Resource("kresource"), name)
}
return obj.(*v1alpha1.KResource), nil
}

94
client/listers/duck/v1alpha1/target.go generated
View File

@ -1,94 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 lister-gen. DO NOT EDIT.
package v1alpha1
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
"k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/tools/cache"
)
// TargetLister helps list Targets.
type TargetLister interface {
// List lists all Targets in the indexer.
List(selector labels.Selector) (ret []*v1alpha1.Target, err error)
// Targets returns an object that can list and get Targets.
Targets(namespace string) TargetNamespaceLister
TargetListerExpansion
}
// targetLister implements the TargetLister interface.
type targetLister struct {
indexer cache.Indexer
}
// NewTargetLister returns a new TargetLister.
func NewTargetLister(indexer cache.Indexer) TargetLister {
return &targetLister{indexer: indexer}
}
// List lists all Targets in the indexer.
func (s *targetLister) List(selector labels.Selector) (ret []*v1alpha1.Target, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.Target))
})
return ret, err
}
// Targets returns an object that can list and get Targets.
func (s *targetLister) Targets(namespace string) TargetNamespaceLister {
return targetNamespaceLister{indexer: s.indexer, namespace: namespace}
}
// TargetNamespaceLister helps list and get Targets.
type TargetNamespaceLister interface {
// List lists all Targets in the indexer for a given namespace.
List(selector labels.Selector) (ret []*v1alpha1.Target, err error)
// Get retrieves the Target from the indexer for a given namespace and name.
Get(name string) (*v1alpha1.Target, error)
TargetNamespaceListerExpansion
}
// targetNamespaceLister implements the TargetNamespaceLister
// interface.
type targetNamespaceLister struct {
indexer cache.Indexer
namespace string
}
// List lists all Targets in the indexer for a given namespace.
func (s targetNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.Target, err error) {
err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.Target))
})
return ret, err
}
// Get retrieves the Target from the indexer for a given namespace and name.
func (s targetNamespaceLister) Get(name string) (*v1alpha1.Target, error) {
obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
if err != nil {
return nil, err
}
if !exists {
return nil, errors.NewNotFound(v1alpha1.Resource("target"), name)
}
return obj.(*v1alpha1.Target), nil
}

94
client/listers/duck/v1alpha1/topic.go generated
View File

@ -1,94 +0,0 @@
/*
Copyright 2018 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT 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 lister-gen. DO NOT EDIT.
package v1alpha1
import (
v1alpha1 "github.com/knative/pkg/apis/duck/v1alpha1"
"k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/tools/cache"
)
// TopicLister helps list Topics.
type TopicLister interface {
// List lists all Topics in the indexer.
List(selector labels.Selector) (ret []*v1alpha1.Topic, err error)
// Topics returns an object that can list and get Topics.
Topics(namespace string) TopicNamespaceLister
TopicListerExpansion
}
// topicLister implements the TopicLister interface.
type topicLister struct {
indexer cache.Indexer
}
// NewTopicLister returns a new TopicLister.
func NewTopicLister(indexer cache.Indexer) TopicLister {
return &topicLister{indexer: indexer}
}
// List lists all Topics in the indexer.
func (s *topicLister) List(selector labels.Selector) (ret []*v1alpha1.Topic, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.Topic))
})
return ret, err
}
// Topics returns an object that can list and get Topics.
func (s *topicLister) Topics(namespace string) TopicNamespaceLister {
return topicNamespaceLister{indexer: s.indexer, namespace: namespace}
}
// TopicNamespaceLister helps list and get Topics.
type TopicNamespaceLister interface {
// List lists all Topics in the indexer for a given namespace.
List(selector labels.Selector) (ret []*v1alpha1.Topic, err error)
// Get retrieves the Topic from the indexer for a given namespace and name.
Get(name string) (*v1alpha1.Topic, error)
TopicNamespaceListerExpansion
}
// topicNamespaceLister implements the TopicNamespaceLister
// interface.
type topicNamespaceLister struct {
indexer cache.Indexer
namespace string
}
// List lists all Topics in the indexer for a given namespace.
func (s topicNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.Topic, err error) {
err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.Topic))
})
return ret, err
}
// Get retrieves the Topic from the indexer for a given namespace and name.
func (s topicNamespaceLister) Get(name string) (*v1alpha1.Topic, error) {
obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
if err != nil {
return nil, err
}
if !exists {
return nil, errors.NewNotFound(v1alpha1.Resource("topic"), name)
}
return obj.(*v1alpha1.Topic), nil
}

8
hack/update-codegen.sh
View File

@ -30,7 +30,13 @@ go install ./vendor/k8s.io/code-generator/cmd/deepcopy-gen
# instead of the $GOPATH directly. For normal projects this can be dropped.
${CODEGEN_PKG}/generate-groups.sh "deepcopy,client,informer,lister" \
github.com/knative/pkg/client github.com/knative/pkg/apis \
"istio:v1alpha3 istio/authentication:v1alpha1 duck:v1alpha1" \
"istio:v1alpha3 istio/authentication:v1alpha1" \
--go-header-file ${REPO_ROOT_DIR}/hack/boilerplate/boilerplate.go.txt
# Only deepcopy the Duck types, as they are not real resources.
${CODEGEN_PKG}/generate-groups.sh "deepcopy" \
github.com/knative/pkg/client github.com/knative/pkg/apis \
"duck:v1alpha1" \
--go-header-file ${REPO_ROOT_DIR}/hack/boilerplate/boilerplate.go.txt
# Depends on generate-groups.sh to install bin/deepcopy-gen