technofab/zfs-localpv
1
0
Fork 0
mirror of https://github.com/TECHNOFAB11/zfs-localpv.git synced 2025-12-12 06:20:11 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

feat(zfspv): adding snapshot and clone support for ZFSPV (#39)

Browse source 
This commits support snapshot and clone commands via CSI driver. User can create snap and clone using the following steps. 

Note:
- Snapshot is created via reconciliation CR
- Cloned volume will be on the same zpool where the snapshot is taken
- Cloned volume will have same properties as source volume. 

-----------------------------------
Create a Snapshotclass
```
kind: VolumeSnapshotClass
apiVersion: snapshot.storage.k8s.io/v1beta1
metadata:
  name: zfspv-snapclass
  annotations:
    snapshot.storage.kubernetes.io/is-default-class: "true"
driver: zfs.csi.openebs.io
deletionPolicy: Delete
```
Once snapshotclass is created, we can use this class to create a Snapshot 
```
apiVersion: snapshot.storage.k8s.io/v1beta1
kind: VolumeSnapshot
metadata:
  name: zfspv-snap
spec:
  volumeSnapshotClassName: zfspv-snapclass
  source:
    persistentVolumeClaimName: csi-zfspv
```
```
$ kubectl get volumesnapshot
NAME          AGE
zfspv-snap    7m52s
```
```
$ kubectl get volumesnapshot -o yaml
apiVersion: v1
items:
- apiVersion: snapshot.storage.k8s.io/v1beta1
  kind: VolumeSnapshot
  metadata:
    annotations:
      kubectl.kubernetes.io/last-applied-configuration: |
        {"apiVersion":"snapshot.storage.k8s.io/v1beta1","kind":"VolumeSnapshot","metadata":{"annotations":{},"name":"zfspv-snap","namespace":"default"},"spec":{"source":{"persistentVolumeClaimName":"csi-zfspv"},"volumeSnapshotClassName":"zfspv-snapclass"}}
    creationTimestamp: "2020-01-30T10:31:24Z"
    finalizers:
    - snapshot.storage.kubernetes.io/volumesnapshot-as-source-protection
    - snapshot.storage.kubernetes.io/volumesnapshot-bound-protection
    generation: 1
    name: zfspv-snap
    namespace: default
    resourceVersion: "30040"
    selfLink: /apis/snapshot.storage.k8s.io/v1beta1/namespaces/default/volumesnapshots/zfspv-snap
    uid: 1a5cf166-c599-4f58-9f3c-f1148be47fca
  spec:
    source:
      persistentVolumeClaimName: csi-zfspv
    volumeSnapshotClassName: zfspv-snapclass
  status:
    boundVolumeSnapshotContentName: snapcontent-1a5cf166-c599-4f58-9f3c-f1148be47fca
    creationTime: "2020-01-30T10:31:24Z"
    readyToUse: true
    restoreSize: "0"
kind: List
metadata:
  resourceVersion: ""
  selfLink: ""
```


Openebs resource for the created snapshot 
```
$ kubectl get snap -n openebs -o yaml
apiVersion: v1
items:
- apiVersion: openebs.io/v1alpha1
  kind: ZFSSnapshot
  metadata:
    creationTimestamp: "2020-01-30T10:31:24Z"
    finalizers:
    - zfs.openebs.io/finalizer
    generation: 2
    labels:
      kubernetes.io/nodename: pawan-2
      openebs.io/persistent-volume: pvc-18cab7c3-ec5e-4264-8507-e6f7df4c789a
    name: snapshot-1a5cf166-c599-4f58-9f3c-f1148be47fca
    namespace: openebs
    resourceVersion: "30035"
    selfLink: /apis/openebs.io/v1alpha1/namespaces/openebs/zfssnapshots/snapshot-1a5cf166-c599-4f58-9f3c-f1148be47fca
    uid: e29d571c-42b5-4fb7-9110-e1cfc9b96641
  spec:
    capacity: "4294967296"
    fsType: zfs
    ownerNodeID: pawan-2
    poolName: zfspv-pool
    status: Ready
    volumeType: DATASET
kind: List
metadata:
  resourceVersion: ""
  selfLink: ""
```

Create a clone volume
    
 We can provide a datasource as snapshot name to create a clone volume
    
```yaml
    kind: PersistentVolumeClaim
    apiVersion: v1
    metadata:
      name: zfspv-clone
    spec:
      storageClassName: openebs-zfspv
      dataSource:
        name: zfspv-snap
        kind: VolumeSnapshot
        apiGroup: snapshot.storage.k8s.io
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 4Gi
```
It will create a ZFS clone volume from the mentioned snapshot and create the PV on the same node where original volume is there.
    
Here, As resize is not supported yet, the clone PVC size should match the size of the snapshot.
Also, all the properties from the storageclass will not be considered for the clone case, it will take the properties from the snapshot and create the clone volume. One thing to note here is that, the storageclass in clone PVC should have the same poolname as that of the original volume as across the pool, clone is not supported.


Signed-off-by: Pawan <pawan@mayadata.io>
This commit is contained in:
Pawan Prakash Sharma 2020-02-13 13:31:17 +05:30 • committed by GitHub
parent b0434bb537
commit 287606b78a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
40 changed files with 2995 additions and 123 deletions
Download patch file Download diff file Expand all files Collapse all files

5
pkg/generated/clientset/internalclientset/typed/core/v1alpha1/core_client.go
View file

@ -27,6 +27,7 @@ import (
type OpenebsV1alpha1Interface interface {
RESTClient() rest.Interface
ZFSSnapshotsGetter
ZFSVolumesGetter
}
@ -35,6 +36,10 @@ type OpenebsV1alpha1Client struct {
restClient rest.Interface
}
func (c *OpenebsV1alpha1Client) ZFSSnapshots(namespace string) ZFSSnapshotInterface {
return newZFSSnapshots(c, namespace)
}
func (c *OpenebsV1alpha1Client) ZFSVolumes(namespace string) ZFSVolumeInterface {
return newZFSVolumes(c, namespace)
}

4
pkg/generated/clientset/internalclientset/typed/core/v1alpha1/fake/fake_core_client.go
View file

@ -28,6 +28,10 @@ type FakeOpenebsV1alpha1 struct {
*testing.Fake
}
func (c *FakeOpenebsV1alpha1) ZFSSnapshots(namespace string) v1alpha1.ZFSSnapshotInterface {
return &FakeZFSSnapshots{c, namespace}
}
func (c *FakeOpenebsV1alpha1) ZFSVolumes(namespace string) v1alpha1.ZFSVolumeInterface {
return &FakeZFSVolumes{c, namespace}
}

140
pkg/generated/clientset/internalclientset/typed/core/v1alpha1/fake/fake_zfssnapshot.go Normal file
View file

@ -0,0 +1,140 @@
/*
Copyright 2019 The OpenEBS 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/openebs/zfs-localpv/pkg/apis/openebs.io/core/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"
)
// FakeZFSSnapshots implements ZFSSnapshotInterface
type FakeZFSSnapshots struct {
Fake *FakeOpenebsV1alpha1
ns string
}
var zfssnapshotsResource = schema.GroupVersionResource{Group: "openebs.io", Version: "v1alpha1", Resource: "zfssnapshots"}
var zfssnapshotsKind = schema.GroupVersionKind{Group: "openebs.io", Version: "v1alpha1", Kind: "ZFSSnapshot"}
// Get takes name of the zFSSnapshot, and returns the corresponding zFSSnapshot object, and an error if there is any.
func (c *FakeZFSSnapshots) Get(name string, options v1.GetOptions) (result *v1alpha1.ZFSSnapshot, err error) {
obj, err := c.Fake.
Invokes(testing.NewGetAction(zfssnapshotsResource, c.ns, name), &v1alpha1.ZFSSnapshot{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.ZFSSnapshot), err
}
// List takes label and field selectors, and returns the list of ZFSSnapshots that match those selectors.
func (c *FakeZFSSnapshots) List(opts v1.ListOptions) (result *v1alpha1.ZFSSnapshotList, err error) {
obj, err := c.Fake.
Invokes(testing.NewListAction(zfssnapshotsResource, zfssnapshotsKind, c.ns, opts), &v1alpha1.ZFSSnapshotList{})
if obj == nil {
return nil, err
}
label, _, _ := testing.ExtractFromListOptions(opts)
if label == nil {
label = labels.Everything()
}
list := &v1alpha1.ZFSSnapshotList{ListMeta: obj.(*v1alpha1.ZFSSnapshotList).ListMeta}
for _, item := range obj.(*v1alpha1.ZFSSnapshotList).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 zFSSnapshots.
func (c *FakeZFSSnapshots) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(zfssnapshotsResource, c.ns, opts))
}
// Create takes the representation of a zFSSnapshot and creates it. Returns the server's representation of the zFSSnapshot, and an error, if there is any.
func (c *FakeZFSSnapshots) Create(zFSSnapshot *v1alpha1.ZFSSnapshot) (result *v1alpha1.ZFSSnapshot, err error) {
obj, err := c.Fake.
Invokes(testing.NewCreateAction(zfssnapshotsResource, c.ns, zFSSnapshot), &v1alpha1.ZFSSnapshot{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.ZFSSnapshot), err
}
// Update takes the representation of a zFSSnapshot and updates it. Returns the server's representation of the zFSSnapshot, and an error, if there is any.
func (c *FakeZFSSnapshots) Update(zFSSnapshot *v1alpha1.ZFSSnapshot) (result *v1alpha1.ZFSSnapshot, err error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateAction(zfssnapshotsResource, c.ns, zFSSnapshot), &v1alpha1.ZFSSnapshot{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.ZFSSnapshot), 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 *FakeZFSSnapshots) UpdateStatus(zFSSnapshot *v1alpha1.ZFSSnapshot) (*v1alpha1.ZFSSnapshot, error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateSubresourceAction(zfssnapshotsResource, "status", c.ns, zFSSnapshot), &v1alpha1.ZFSSnapshot{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.ZFSSnapshot), err
}
// Delete takes name of the zFSSnapshot and deletes it. Returns an error if one occurs.
func (c *FakeZFSSnapshots) Delete(name string, options *v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteAction(zfssnapshotsResource, c.ns, name), &v1alpha1.ZFSSnapshot{})
return err
}
// DeleteCollection deletes a collection of objects.
func (c *FakeZFSSnapshots) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
action := testing.NewDeleteCollectionAction(zfssnapshotsResource, c.ns, listOptions)
_, err := c.Fake.Invokes(action, &v1alpha1.ZFSSnapshotList{})
return err
}
// Patch applies the patch and returns the patched zFSSnapshot.
func (c *FakeZFSSnapshots) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.ZFSSnapshot, err error) {
obj, err := c.Fake.
Invokes(testing.NewPatchSubresourceAction(zfssnapshotsResource, c.ns, name, pt, data, subresources...), &v1alpha1.ZFSSnapshot{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.ZFSSnapshot), err
}

2
pkg/generated/clientset/internalclientset/typed/core/v1alpha1/generated_expansion.go
View file

@ -18,4 +18,6 @@ limitations under the License.
package v1alpha1
type ZFSSnapshotExpansion interface{}
type ZFSVolumeExpansion interface{}

191
pkg/generated/clientset/internalclientset/typed/core/v1alpha1/zfssnapshot.go Normal file
View file

@ -0,0 +1,191 @@
/*
Copyright 2019 The OpenEBS 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 (
"time"
v1alpha1 "github.com/openebs/zfs-localpv/pkg/apis/openebs.io/core/v1alpha1"
scheme "github.com/openebs/zfs-localpv/pkg/generated/clientset/internalclientset/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"
)
// ZFSSnapshotsGetter has a method to return a ZFSSnapshotInterface.
// A group's client should implement this interface.
type ZFSSnapshotsGetter interface {
ZFSSnapshots(namespace string) ZFSSnapshotInterface
}
// ZFSSnapshotInterface has methods to work with ZFSSnapshot resources.
type ZFSSnapshotInterface interface {
Create(*v1alpha1.ZFSSnapshot) (*v1alpha1.ZFSSnapshot, error)
Update(*v1alpha1.ZFSSnapshot) (*v1alpha1.ZFSSnapshot, error)
UpdateStatus(*v1alpha1.ZFSSnapshot) (*v1alpha1.ZFSSnapshot, error)
Delete(name string, options *v1.DeleteOptions) error
DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
Get(name string, options v1.GetOptions) (*v1alpha1.ZFSSnapshot, error)
List(opts v1.ListOptions) (*v1alpha1.ZFSSnapshotList, error)
Watch(opts v1.ListOptions) (watch.Interface, error)
Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.ZFSSnapshot, err error)
ZFSSnapshotExpansion
}
// zFSSnapshots implements ZFSSnapshotInterface
type zFSSnapshots struct {
client rest.Interface
ns string
}
// newZFSSnapshots returns a ZFSSnapshots
func newZFSSnapshots(c *OpenebsV1alpha1Client, namespace string) *zFSSnapshots {
return &zFSSnapshots{
client: c.RESTClient(),
ns: namespace,
}
}
// Get takes name of the zFSSnapshot, and returns the corresponding zFSSnapshot object, and an error if there is any.
func (c *zFSSnapshots) Get(name string, options v1.GetOptions) (result *v1alpha1.ZFSSnapshot, err error) {
result = &v1alpha1.ZFSSnapshot{}
err = c.client.Get().
Namespace(c.ns).
Resource("zfssnapshots").
Name(name).
VersionedParams(&options, scheme.ParameterCodec).
Do().
Into(result)
return
}
// List takes label and field selectors, and returns the list of ZFSSnapshots that match those selectors.
func (c *zFSSnapshots) List(opts v1.ListOptions) (result *v1alpha1.ZFSSnapshotList, err error) {
var timeout time.Duration
if opts.TimeoutSeconds != nil {
timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
}
result = &v1alpha1.ZFSSnapshotList{}
err = c.client.Get().
Namespace(c.ns).
Resource("zfssnapshots").
VersionedParams(&opts, scheme.ParameterCodec).
Timeout(timeout).
Do().
Into(result)
return
}
// Watch returns a watch.Interface that watches the requested zFSSnapshots.
func (c *zFSSnapshots) Watch(opts v1.ListOptions) (watch.Interface, error) {
var timeout time.Duration
if opts.TimeoutSeconds != nil {
timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
}
opts.Watch = true
return c.client.Get().
Namespace(c.ns).
Resource("zfssnapshots").
VersionedParams(&opts, scheme.ParameterCodec).
Timeout(timeout).
Watch()
}
// Create takes the representation of a zFSSnapshot and creates it. Returns the server's representation of the zFSSnapshot, and an error, if there is any.
func (c *zFSSnapshots) Create(zFSSnapshot *v1alpha1.ZFSSnapshot) (result *v1alpha1.ZFSSnapshot, err error) {
result = &v1alpha1.ZFSSnapshot{}
err = c.client.Post().
Namespace(c.ns).
Resource("zfssnapshots").
Body(zFSSnapshot).
Do().
Into(result)
return
}
// Update takes the representation of a zFSSnapshot and updates it. Returns the server's representation of the zFSSnapshot, and an error, if there is any.
func (c *zFSSnapshots) Update(zFSSnapshot *v1alpha1.ZFSSnapshot) (result *v1alpha1.ZFSSnapshot, err error) {
result = &v1alpha1.ZFSSnapshot{}
err = c.client.Put().
Namespace(c.ns).
Resource("zfssnapshots").
Name(zFSSnapshot.Name).
Body(zFSSnapshot).
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 *zFSSnapshots) UpdateStatus(zFSSnapshot *v1alpha1.ZFSSnapshot) (result *v1alpha1.ZFSSnapshot, err error) {
result = &v1alpha1.ZFSSnapshot{}
err = c.client.Put().
Namespace(c.ns).
Resource("zfssnapshots").
Name(zFSSnapshot.Name).
SubResource("status").
Body(zFSSnapshot).
Do().
Into(result)
return
}
// Delete takes name of the zFSSnapshot and deletes it. Returns an error if one occurs.
func (c *zFSSnapshots) Delete(name string, options *v1.DeleteOptions) error {
return c.client.Delete().
Namespace(c.ns).
Resource("zfssnapshots").
Name(name).
Body(options).
Do().
Error()
}
// DeleteCollection deletes a collection of objects.
func (c *zFSSnapshots) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
var timeout time.Duration
if listOptions.TimeoutSeconds != nil {
timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second
}
return c.client.Delete().
Namespace(c.ns).
Resource("zfssnapshots").
VersionedParams(&listOptions, scheme.ParameterCodec).
Timeout(timeout).
Body(options).
Do().
Error()
}
// Patch applies the patch and returns the patched zFSSnapshot.
func (c *zFSSnapshots) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.ZFSSnapshot, err error) {
result = &v1alpha1.ZFSSnapshot{}
err = c.client.Patch(pt).
Namespace(c.ns).
Resource("zfssnapshots").
SubResource(subresources...).
Name(name).
Body(data).
Do().
Into(result)
return
}

7
pkg/generated/informer/externalversions/core/v1alpha1/interface.go
View file

@ -24,6 +24,8 @@ import (
// Interface provides access to all the informers in this group version.
type Interface interface {
// ZFSSnapshots returns a ZFSSnapshotInformer.
ZFSSnapshots() ZFSSnapshotInformer
// ZFSVolumes returns a ZFSVolumeInformer.
ZFSVolumes() ZFSVolumeInformer
}
@ -39,6 +41,11 @@ func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakList
return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
}
// ZFSSnapshots returns a ZFSSnapshotInformer.
func (v *version) ZFSSnapshots() ZFSSnapshotInformer {
return &zFSSnapshotInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
}
// ZFSVolumes returns a ZFSVolumeInformer.
func (v *version) ZFSVolumes() ZFSVolumeInformer {
return &zFSVolumeInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}

89
pkg/generated/informer/externalversions/core/v1alpha1/zfssnapshot.go Normal file
View file

@ -0,0 +1,89 @@
/*
Copyright 2019 The OpenEBS 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"
corev1alpha1 "github.com/openebs/zfs-localpv/pkg/apis/openebs.io/core/v1alpha1"
internalclientset "github.com/openebs/zfs-localpv/pkg/generated/clientset/internalclientset"
internalinterfaces "github.com/openebs/zfs-localpv/pkg/generated/informer/externalversions/internalinterfaces"
v1alpha1 "github.com/openebs/zfs-localpv/pkg/generated/lister/core/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"
)
// ZFSSnapshotInformer provides access to a shared informer and lister for
// ZFSSnapshots.
type ZFSSnapshotInformer interface {
Informer() cache.SharedIndexInformer
Lister() v1alpha1.ZFSSnapshotLister
}
type zFSSnapshotInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
namespace string
}
// NewZFSSnapshotInformer constructs a new informer for ZFSSnapshot 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 NewZFSSnapshotInformer(client internalclientset.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredZFSSnapshotInformer(client, namespace, resyncPeriod, indexers, nil)
}
// NewFilteredZFSSnapshotInformer constructs a new informer for ZFSSnapshot 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 NewFilteredZFSSnapshotInformer(client internalclientset.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.OpenebsV1alpha1().ZFSSnapshots(namespace).List(options)
},
WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.OpenebsV1alpha1().ZFSSnapshots(namespace).Watch(options)
},
},
&corev1alpha1.ZFSSnapshot{},
resyncPeriod,
indexers,
)
}
func (f *zFSSnapshotInformer) defaultInformer(client internalclientset.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredZFSSnapshotInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *zFSSnapshotInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&corev1alpha1.ZFSSnapshot{}, f.defaultInformer)
}
func (f *zFSSnapshotInformer) Lister() v1alpha1.ZFSSnapshotLister {
return v1alpha1.NewZFSSnapshotLister(f.Informer().GetIndexer())
}

2
pkg/generated/informer/externalversions/generic.go
View file

@ -53,6 +53,8 @@ func (f *genericInformer) Lister() cache.GenericLister {
func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) {
switch resource {
// Group=openebs.io, Version=v1alpha1
case v1alpha1.SchemeGroupVersion.WithResource("zfssnapshots"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Openebs().V1alpha1().ZFSSnapshots().Informer()}, nil
case v1alpha1.SchemeGroupVersion.WithResource("zfsvolumes"):
return &genericInformer{resource: resource.GroupResource(), informer: f.Openebs().V1alpha1().ZFSVolumes().Informer()}, nil

8
pkg/generated/lister/core/v1alpha1/expansion_generated.go
View file

@ -18,6 +18,14 @@ limitations under the License.
package v1alpha1
// ZFSSnapshotListerExpansion allows custom methods to be added to
// ZFSSnapshotLister.
type ZFSSnapshotListerExpansion interface{}
// ZFSSnapshotNamespaceListerExpansion allows custom methods to be added to
// ZFSSnapshotNamespaceLister.
type ZFSSnapshotNamespaceListerExpansion interface{}
// ZFSVolumeListerExpansion allows custom methods to be added to
// ZFSVolumeLister.
type ZFSVolumeListerExpansion interface{}

94
pkg/generated/lister/core/v1alpha1/zfssnapshot.go Normal file
View file

@ -0,0 +1,94 @@
/*
Copyright 2019 The OpenEBS 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/openebs/zfs-localpv/pkg/apis/openebs.io/core/v1alpha1"
"k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/tools/cache"
)
// ZFSSnapshotLister helps list ZFSSnapshots.
type ZFSSnapshotLister interface {
// List lists all ZFSSnapshots in the indexer.
List(selector labels.Selector) (ret []*v1alpha1.ZFSSnapshot, err error)
// ZFSSnapshots returns an object that can list and get ZFSSnapshots.
ZFSSnapshots(namespace string) ZFSSnapshotNamespaceLister
ZFSSnapshotListerExpansion
}
// zFSSnapshotLister implements the ZFSSnapshotLister interface.
type zFSSnapshotLister struct {
indexer cache.Indexer
}
// NewZFSSnapshotLister returns a new ZFSSnapshotLister.
func NewZFSSnapshotLister(indexer cache.Indexer) ZFSSnapshotLister {
return &zFSSnapshotLister{indexer: indexer}
}
// List lists all ZFSSnapshots in the indexer.
func (s *zFSSnapshotLister) List(selector labels.Selector) (ret []*v1alpha1.ZFSSnapshot, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.ZFSSnapshot))
})
return ret, err
}
// ZFSSnapshots returns an object that can list and get ZFSSnapshots.
func (s *zFSSnapshotLister) ZFSSnapshots(namespace string) ZFSSnapshotNamespaceLister {
return zFSSnapshotNamespaceLister{indexer: s.indexer, namespace: namespace}
}
// ZFSSnapshotNamespaceLister helps list and get ZFSSnapshots.
type ZFSSnapshotNamespaceLister interface {
// List lists all ZFSSnapshots in the indexer for a given namespace.
List(selector labels.Selector) (ret []*v1alpha1.ZFSSnapshot, err error)
// Get retrieves the ZFSSnapshot from the indexer for a given namespace and name.
Get(name string) (*v1alpha1.ZFSSnapshot, error)
ZFSSnapshotNamespaceListerExpansion
}
// zFSSnapshotNamespaceLister implements the ZFSSnapshotNamespaceLister
// interface.
type zFSSnapshotNamespaceLister struct {
indexer cache.Indexer
namespace string
}
// List lists all ZFSSnapshots in the indexer for a given namespace.
func (s zFSSnapshotNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.ZFSSnapshot, err error) {
err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.ZFSSnapshot))
})
return ret, err
}
// Get retrieves the ZFSSnapshot from the indexer for a given namespace and name.
func (s zFSSnapshotNamespaceLister) Get(name string) (*v1alpha1.ZFSSnapshot, error) {
obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
if err != nil {
return nil, err
}
if !exists {
return nil, errors.NewNotFound(v1alpha1.Resource("zfssnapshot"), name)
}
return obj.(*v1alpha1.ZFSSnapshot), nil
}