From 0b720dc187b8ef05d711be3af9f8f6e4219de4df Mon Sep 17 00:00:00 2001 From: Jack Yu Date: Fri, 24 May 2024 19:29:53 +0800 Subject: [PATCH] test: add usbdevice and usbdevice controller test case Signed-off-by: Jack Yu --- pkg/codegen/main.go | 8 + pkg/config/factory_magement.go | 28 +- pkg/controller/nodes/node_controller.go | 2 +- pkg/controller/setup.go | 6 + pkg/controller/usbdevice/label.go | 2 +- pkg/controller/usbdevice/register.go | 6 +- .../usbdevice/usbdevice_claim_controller.go | 18 +- .../usbdevice_claim_controller_test.go | 93 +++++ .../usbdevice/usbdevice_controller.go | 13 +- .../usbdevice/usbdevice_controller_test.go | 69 ++++ pkg/deviceplugins/local_usb_device.go | 31 ++ pkg/deviceplugins/usb_device_plugin.go | 26 -- .../clientset/versioned/clientset.go | 13 + .../versioned/fake/clientset_generated.go | 7 + .../clientset/versioned/fake/register.go | 2 + .../clientset/versioned/scheme/register.go | 2 + .../versioned/typed/kubevirt.io/v1/doc.go | 20 + .../typed/kubevirt.io/v1/fake/doc.go | 20 + .../kubevirt.io/v1/fake/fake_kubevirt.go | 142 +++++++ .../v1/fake/fake_kubevirt.io_client.go | 60 +++ .../v1/fake/fake_virtualmachine.go | 142 +++++++ .../v1/fake/fake_virtualmachineinstance.go | 142 +++++++ .../fake_virtualmachineinstancemigration.go | 142 +++++++ .../fake/fake_virtualmachineinstancepreset.go | 130 ++++++ .../fake_virtualmachineinstancereplicaset.go | 142 +++++++ .../kubevirt.io/v1/generated_expansion.go | 31 ++ .../typed/kubevirt.io/v1/kubevirt.go | 195 +++++++++ .../kubevirt.io/v1/kubevirt.io_client.go | 132 ++++++ .../typed/kubevirt.io/v1/virtualmachine.go | 195 +++++++++ .../kubevirt.io/v1/virtualmachineinstance.go | 195 +++++++++ .../v1/virtualmachineinstancemigration.go | 195 +++++++++ .../v1/virtualmachineinstancepreset.go | 178 +++++++++ .../v1/virtualmachineinstancereplicaset.go | 195 +++++++++ .../controllers/kubevirt.io/factory.go | 72 ++++ .../controllers/kubevirt.io/interface.go | 43 ++ .../controllers/kubevirt.io/v1/interface.go | 48 +++ .../controllers/kubevirt.io/v1/kubevirt.go | 376 ++++++++++++++++++ pkg/util/fakeclients/kubevirt.go | 46 +++ pkg/util/gousb/usbid/load_data.go | 4 +- tests/integration/suite_test.go | 2 +- 40 files changed, 3113 insertions(+), 60 deletions(-) create mode 100644 pkg/controller/usbdevice/usbdevice_claim_controller_test.go create mode 100644 pkg/controller/usbdevice/usbdevice_controller_test.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/doc.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/doc.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_kubevirt.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_kubevirt.io_client.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachine.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstance.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancemigration.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancepreset.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancereplicaset.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/generated_expansion.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/kubevirt.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/kubevirt.io_client.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachine.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstance.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancemigration.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancepreset.go create mode 100644 pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancereplicaset.go create mode 100644 pkg/generated/controllers/kubevirt.io/factory.go create mode 100644 pkg/generated/controllers/kubevirt.io/interface.go create mode 100644 pkg/generated/controllers/kubevirt.io/v1/interface.go create mode 100644 pkg/generated/controllers/kubevirt.io/v1/kubevirt.go create mode 100644 pkg/util/fakeclients/kubevirt.go diff --git a/pkg/codegen/main.go b/pkg/codegen/main.go index aa7c1645..29190e46 100644 --- a/pkg/codegen/main.go +++ b/pkg/codegen/main.go @@ -7,6 +7,7 @@ import ( controllergen "github.com/rancher/wrangler/pkg/controller-gen" "github.com/rancher/wrangler/pkg/controller-gen/args" _ "github.com/rancher/wrangler/pkg/generated/controllers/apiextensions.k8s.io/v1" + kubevirtv1 "kubevirt.io/api/core/v1" "github.com/harvester/pcidevices/pkg/crd" ) @@ -33,6 +34,13 @@ func main() { GenerateTypes: true, GenerateClients: true, }, + kubevirtv1.SchemeGroupVersion.Group: { + Types: []interface{}{ + kubevirtv1.KubeVirt{}, + }, + GenerateTypes: false, + GenerateClients: true, + }, }, }) } diff --git a/pkg/config/factory_magement.go b/pkg/config/factory_magement.go index 7523b2f8..16c218bb 100644 --- a/pkg/config/factory_magement.go +++ b/pkg/config/factory_magement.go @@ -7,23 +7,33 @@ import ( "kubevirt.io/client-go/kubecli" ctldevices "github.com/harvester/pcidevices/pkg/generated/controllers/devices.harvesterhci.io" + ctlkubevirt "github.com/harvester/pcidevices/pkg/generated/controllers/kubevirt.io" ) type FactoryManager struct { - DeviceFactory *ctldevices.Factory - CoreFactory *ctlcore.Factory - NetworkFactory *ctlnetwork.Factory + DeviceFactory *ctldevices.Factory + CoreFactory *ctlcore.Factory + NetworkFactory *ctlnetwork.Factory + KubevirtFactory *ctlkubevirt.Factory KubevirtClient kubecli.KubevirtClient Cfg *rest.Config } -func NewFactoryManager(deviceFactory *ctldevices.Factory, coreFactory *ctlcore.Factory, networkFactory *ctlnetwork.Factory, kubevirtClient kubecli.KubevirtClient, cfg *rest.Config) *FactoryManager { +func NewFactoryManager( + deviceFactory *ctldevices.Factory, + coreFactory *ctlcore.Factory, + networkFactory *ctlnetwork.Factory, + kubevirtFactory *ctlkubevirt.Factory, + kubevirtClient kubecli.KubevirtClient, + cfg *rest.Config, +) *FactoryManager { return &FactoryManager{ - DeviceFactory: deviceFactory, - CoreFactory: coreFactory, - NetworkFactory: networkFactory, - KubevirtClient: kubevirtClient, - Cfg: cfg, + DeviceFactory: deviceFactory, + CoreFactory: coreFactory, + NetworkFactory: networkFactory, + KubevirtFactory: kubevirtFactory, + KubevirtClient: kubevirtClient, + Cfg: cfg, } } diff --git a/pkg/controller/nodes/node_controller.go b/pkg/controller/nodes/node_controller.go index db026fd6..094ac4c1 100644 --- a/pkg/controller/nodes/node_controller.go +++ b/pkg/controller/nodes/node_controller.go @@ -117,7 +117,7 @@ func (h *handler) reconcileNodeDevices(name string, node *v1beta1.Node) (*v1beta return nil, fmt.Errorf("error reconciling pcidevices for node %s: %v", h.nodeName, err) } - usbHandler := usbdevice.NewHandler(h.usbCtl, h.usbClaimCtl, h.virtClient) + usbHandler := usbdevice.NewHandler(h.usbCtl, h.usbClaimCtl) if err := usbHandler.ReconcileUSBDevices(); err != nil { return nil, fmt.Errorf("error reconciling usb devices for node %s: %v", h.nodeName, err) } diff --git a/pkg/controller/setup.go b/pkg/controller/setup.go index 8d0c9782..a75964c5 100644 --- a/pkg/controller/setup.go +++ b/pkg/controller/setup.go @@ -27,6 +27,7 @@ import ( "github.com/harvester/pcidevices/pkg/controller/usbdevice" "github.com/harvester/pcidevices/pkg/crd" ctldevices "github.com/harvester/pcidevices/pkg/generated/controllers/devices.harvesterhci.io" + ctlkubevirt "github.com/harvester/pcidevices/pkg/generated/controllers/kubevirt.io" "github.com/harvester/pcidevices/pkg/webhook" ) @@ -75,6 +76,10 @@ func Setup(ctx context.Context, cfg *rest.Config, _ *runtime.Scheme) error { return fmt.Errorf("error building network controllers: %v", err) } + kubevirtFactory, err := ctlkubevirt.NewFactoryFromConfigWithOptions(cfg, &ctlkubevirt.FactoryOptions{ + SharedControllerFactory: factory, + }) + clientConfig := kubecli.DefaultClientConfig(&pflag.FlagSet{}) virtClient, err := kubecli.GetKubevirtClientFromClientConfig(clientConfig) @@ -82,6 +87,7 @@ func Setup(ctx context.Context, cfg *rest.Config, _ *runtime.Scheme) error { deviceFactory, coreFactory, networkFactory, + kubevirtFactory, virtClient, cfg, ) diff --git a/pkg/controller/usbdevice/label.go b/pkg/controller/usbdevice/label.go index 99c2ef7c..4c3c036f 100644 --- a/pkg/controller/usbdevice/label.go +++ b/pkg/controller/usbdevice/label.go @@ -13,7 +13,7 @@ type commonLabel struct { var cl *commonLabel -func setupCommonLabels() { +func init() { cl = &commonLabel{ nodeName: os.Getenv(v1beta1.NodeEnvVarName), } diff --git a/pkg/controller/usbdevice/register.go b/pkg/controller/usbdevice/register.go index e269f884..1139d1d6 100644 --- a/pkg/controller/usbdevice/register.go +++ b/pkg/controller/usbdevice/register.go @@ -17,11 +17,9 @@ const ( func Register(ctx context.Context, management *config.FactoryManager) error { usbDeviceCtrl := management.DeviceFactory.Devices().V1beta1().USBDevice() usbDeviceClaimCtrl := management.DeviceFactory.Devices().V1beta1().USBDeviceClaim() - virtClient := management.KubevirtClient + virtClient := management.KubevirtFactory.Kubevirt().V1().KubeVirt() - setupCommonLabels() - - handler := NewHandler(usbDeviceCtrl, usbDeviceClaimCtrl, virtClient) + handler := NewHandler(usbDeviceCtrl, usbDeviceClaimCtrl) usbDeviceClaimController := NewClaimHandler(usbDeviceCtrl.Cache(), usbDeviceClaimCtrl, usbDeviceCtrl, virtClient) usbDeviceClaimCtrl.OnChange(ctx, "usbClaimClient-device-claim", usbDeviceClaimController.OnUSBDeviceClaimChanged) diff --git a/pkg/controller/usbdevice/usbdevice_claim_controller.go b/pkg/controller/usbdevice/usbdevice_claim_controller.go index 8d4c81a7..3cce0b90 100644 --- a/pkg/controller/usbdevice/usbdevice_claim_controller.go +++ b/pkg/controller/usbdevice/usbdevice_claim_controller.go @@ -9,23 +9,23 @@ import ( apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" kubevirtv1 "kubevirt.io/api/core/v1" - "kubevirt.io/client-go/kubecli" "github.com/harvester/pcidevices/pkg/apis/devices.harvesterhci.io/v1beta1" "github.com/harvester/pcidevices/pkg/deviceplugins" ctldevicerv1beta1 "github.com/harvester/pcidevices/pkg/generated/controllers/devices.harvesterhci.io/v1beta1" + ctlkubevirtv1 "github.com/harvester/pcidevices/pkg/generated/controllers/kubevirt.io/v1" ) type ClaimHandler struct { - usbClaimClient ctldevicerv1beta1.USBDeviceClaimController - usbClient ctldevicerv1beta1.USBDeviceController - virtClient kubecli.KubevirtClient + usbClaimClient ctldevicerv1beta1.USBDeviceClaimClient + usbClient ctldevicerv1beta1.USBDeviceClient + virtClient ctlkubevirtv1.KubeVirtClient lock *sync.Mutex usbDeviceCache ctldevicerv1beta1.USBDeviceCache devicePlugin map[string]*deviceplugins.USBDevicePlugin } -func NewClaimHandler(usbDeviceCache ctldevicerv1beta1.USBDeviceCache, usbClaimClient ctldevicerv1beta1.USBDeviceClaimController, usbClient ctldevicerv1beta1.USBDeviceController, virtClient kubecli.KubevirtClient) *ClaimHandler { +func NewClaimHandler(usbDeviceCache ctldevicerv1beta1.USBDeviceCache, usbClaimClient ctldevicerv1beta1.USBDeviceClaimClient, usbClient ctldevicerv1beta1.USBDeviceClient, virtClient ctlkubevirtv1.KubeVirtClient) *ClaimHandler { return &ClaimHandler{ usbDeviceCache: usbDeviceCache, usbClaimClient: usbClaimClient, @@ -59,7 +59,7 @@ func (h *ClaimHandler) OnUSBDeviceClaimChanged(_ string, usbDeviceClaim *v1beta1 h.lock.Lock() defer h.lock.Unlock() - virt, err := h.virtClient.KubeVirt(KubeVirtNamespace).Get(KubeVirtResource, &metav1.GetOptions{}) + virt, err := h.virtClient.Get(KubeVirtNamespace, KubeVirtResource, metav1.GetOptions{}) if err != nil { logrus.Errorf("failed to get kubevirt: %v", err) return usbDeviceClaim, err @@ -142,7 +142,7 @@ func (h *ClaimHandler) OnRemove(_ string, claim *v1beta1.USBDeviceClaim) (*v1bet h.lock.Lock() defer h.lock.Unlock() - virt, err := h.virtClient.KubeVirt(KubeVirtNamespace).Get(KubeVirtResource, &metav1.GetOptions{}) + virt, err := h.virtClient.Get(KubeVirtNamespace, KubeVirtResource, metav1.GetOptions{}) if err != nil { fmt.Println(err) return nil, err @@ -168,7 +168,7 @@ func (h *ClaimHandler) OnRemove(_ string, claim *v1beta1.USBDeviceClaim) (*v1bet virtDp.Spec.Configuration.PermittedHostDevices.USB = usbs if !reflect.DeepEqual(virt.Spec.Configuration.PermittedHostDevices.USB, virtDp.Spec.Configuration.PermittedHostDevices.USB) { - if _, err := h.virtClient.KubeVirt(KubeVirtNamespace).Update(virtDp); err != nil { + if _, err := h.virtClient.Update(virtDp); err != nil { return claim, nil } } @@ -222,7 +222,7 @@ func (h *ClaimHandler) updateKubeVirt(virt *kubevirtv1.KubeVirt, usbDevice *v1be }) if virt.Spec.Configuration.PermittedHostDevices == nil || !reflect.DeepEqual(virt.Spec.Configuration.PermittedHostDevices.USB, virtDp.Spec.Configuration.PermittedHostDevices.USB) { - newVirt, err := h.virtClient.KubeVirt(KubeVirtNamespace).Update(virtDp) + newVirt, err := h.virtClient.Update(virtDp) if err != nil { logrus.Errorf("failed to update kubevirt: %v", err) return virt, err diff --git a/pkg/controller/usbdevice/usbdevice_claim_controller_test.go b/pkg/controller/usbdevice/usbdevice_claim_controller_test.go new file mode 100644 index 00000000..b3329675 --- /dev/null +++ b/pkg/controller/usbdevice/usbdevice_claim_controller_test.go @@ -0,0 +1,93 @@ +package usbdevice + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + kubevirtv1 "kubevirt.io/api/core/v1" + + "github.com/harvester/pcidevices/pkg/apis/devices.harvesterhci.io/v1beta1" + "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/fake" + "github.com/harvester/pcidevices/pkg/util/fakeclients" +) + +var ( + mockUsbDevice1 = &v1beta1.USBDevice{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-node-0951-1666-001002", + Labels: map[string]string{ + "nodename": "test-node", + }, + }, + Status: v1beta1.USBDeviceStatus{ + VendorID: "0951", + ProductID: "1666", + ResourceName: "kubevirt.io/test-node-0951-1666-001002", + DevicePath: "/dev/bus/usb/001/002", + NodeName: "test-node", + Description: "DataTraveler 100 G3/G4/SE9 G2/50 Kyson (Kingston Technology)", + }, + } + + mockKubeVirt = &kubevirtv1.KubeVirt{ + ObjectMeta: metav1.ObjectMeta{ + Name: "kubevirt", + Namespace: KubeVirtNamespace, + }, + Spec: kubevirtv1.KubeVirtSpec{}, + } + + mockUsbDeviceClaim1 = &v1beta1.USBDeviceClaim{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-node-0951-1666-001002", + OwnerReferences: []metav1.OwnerReference{ + { + APIVersion: "devices.harvesterhci.io/v1beta1", + Kind: "USBDevice", + Name: "test-node-0951-1666-001002", + UID: "test-uid", + }, + }, + }, + Status: v1beta1.USBDeviceClaimStatus{ + NodeName: "test-node", + }, + } +) + +func Test_OnUSBDeviceClaimChanged(t *testing.T) { + client := fake.NewSimpleClientset(mockUsbDevice1, mockUsbDeviceClaim1, mockKubeVirt) + + handler := NewClaimHandler( + fakeclients.USBDeviceCache(client.DevicesV1beta1().USBDevices), + fakeclients.USBDeviceClaimsClient(client.DevicesV1beta1().USBDeviceClaims), + fakeclients.USBDevicesClient(client.DevicesV1beta1().USBDevices), + fakeclients.KubeVirtClient(client.KubevirtV1().KubeVirts), + ) + + _, err := handler.OnUSBDeviceClaimChanged("", mockUsbDeviceClaim1) + assert.NoError(t, err) + + kubevirt, err := client.KubevirtV1().KubeVirts(mockKubeVirt.Namespace).Get(context.Background(), mockKubeVirt.Name, metav1.GetOptions{}) + assert.NoError(t, err) + assert.Equal(t, kubevirtv1.KubeVirtSpec{ + Configuration: kubevirtv1.KubeVirtConfiguration{ + PermittedHostDevices: &kubevirtv1.PermittedHostDevices{ + USB: []kubevirtv1.USBHostDevice{ + { + ResourceName: "kubevirt.io/test-node-0951-1666-001002", + ExternalResourceProvider: true, + Selectors: []kubevirtv1.USBSelector{ + { + Vendor: "0951", + Product: "1666", + }, + }, + }, + }, + }, + }, + }, kubevirt.Spec) +} diff --git a/pkg/controller/usbdevice/usbdevice_controller.go b/pkg/controller/usbdevice/usbdevice_controller.go index ed7b5177..991102ae 100644 --- a/pkg/controller/usbdevice/usbdevice_controller.go +++ b/pkg/controller/usbdevice/usbdevice_controller.go @@ -8,7 +8,6 @@ import ( "github.com/sirupsen/logrus" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" - "kubevirt.io/client-go/kubecli" "github.com/harvester/pcidevices/pkg/apis/devices.harvesterhci.io/v1beta1" "github.com/harvester/pcidevices/pkg/deviceplugins" @@ -18,11 +17,12 @@ import ( ) type Handler struct { - usbClient ctldevicerv1vbeta1.USBDeviceController - usbClaimClient ctldevicerv1vbeta1.USBDeviceClaimController - virtClient kubecli.KubevirtClient + usbClient ctldevicerv1vbeta1.USBDeviceClient + usbClaimClient ctldevicerv1vbeta1.USBDeviceClaimClient } +var walkUSBDevices = deviceplugins.WalkUSBDevices + type USBDevice struct { Name string Manufacturer string @@ -39,11 +39,10 @@ func (dev *USBDevice) GetID() string { return fmt.Sprintf("%04x:%04x-%02d:%02d", dev.Vendor, dev.Product, dev.Bus, dev.DeviceNumber) } -func NewHandler(usbClient ctldevicerv1vbeta1.USBDeviceController, usbClaimClient ctldevicerv1vbeta1.USBDeviceClaimController, virtClient kubecli.KubevirtClient) *Handler { +func NewHandler(usbClient ctldevicerv1vbeta1.USBDeviceClient, usbClaimClient ctldevicerv1vbeta1.USBDeviceClaimClient) *Handler { return &Handler{ usbClient: usbClient, usbClaimClient: usbClaimClient, - virtClient: virtClient, } } @@ -79,7 +78,7 @@ func (h *Handler) OnDeviceChange(_ string, _ string, obj runtime.Object) ([]rela func (h *Handler) ReconcileUSBDevices() error { nodeName := cl.nodeName - localUSBDevices, err := deviceplugins.WalkUSBDevices() + localUSBDevices, err := walkUSBDevices() if err != nil { logrus.Errorf("failed to walk USB devices: %v\n", err) return err diff --git a/pkg/controller/usbdevice/usbdevice_controller_test.go b/pkg/controller/usbdevice/usbdevice_controller_test.go new file mode 100644 index 00000000..2a090e8b --- /dev/null +++ b/pkg/controller/usbdevice/usbdevice_controller_test.go @@ -0,0 +1,69 @@ +package usbdevice + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/harvester/pcidevices/pkg/deviceplugins" + "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/fake" + "github.com/harvester/pcidevices/pkg/util/fakeclients" +) + +var mockWalkUSBDevices = func() (map[int][]*deviceplugins.USBDevice, error) { + return map[int][]*deviceplugins.USBDevice{ + 0: { + { + Name: "test", + Manufacturer: "test", + Vendor: 2385, + Product: 5734, + DevicePath: "/dev/bus/usb/001/002", + PCIAddress: "0000:02:01.0", + }, + }, + }, nil +} + +var mockCommonLabel = &commonLabel{ + nodeName: "test-node", +} + +func Test_ReconcileUSBDevices(t *testing.T) { + // detect one usb device, create a USBDevice CR + walkUSBDevices = mockWalkUSBDevices + cl = mockCommonLabel + client := fake.NewSimpleClientset() + + usbHandler := NewHandler( + fakeclients.USBDevicesClient(client.DevicesV1beta1().USBDevices), + fakeclients.USBDeviceClaimsClient(client.DevicesV1beta1().USBDeviceClaims), + ) + + err := usbHandler.ReconcileUSBDevices() + assert.NoError(t, err) + + list, err := client.DevicesV1beta1().USBDevices().List(context.Background(), metav1.ListOptions{}) + assert.NoError(t, err) + + assert.Equal(t, 1, len(list.Items)) + assert.Equal(t, "test-node-0951-1666-001002", list.Items[0].Name) + assert.Equal(t, "0951", list.Items[0].Status.VendorID) + assert.Equal(t, "1666", list.Items[0].Status.ProductID) + assert.Equal(t, "kubevirt.io/test-node-0951-1666-001002", list.Items[0].Status.ResourceName) + assert.Equal(t, "/dev/bus/usb/001/002", list.Items[0].Status.DevicePath) + assert.Equal(t, cl.nodeName, list.Items[0].Status.NodeName) + assert.Equal(t, "DataTraveler 100 G3/G4/SE9 G2/50 Kyson (Kingston Technology)", list.Items[0].Status.Description) + + // detect no usb device after few minutes, delete existing USBDevice CR + walkUSBDevices = func() (map[int][]*deviceplugins.USBDevice, error) { return map[int][]*deviceplugins.USBDevice{}, nil } + + err = usbHandler.ReconcileUSBDevices() + assert.NoError(t, err) + + list, err = client.DevicesV1beta1().USBDevices().List(context.Background(), metav1.ListOptions{}) + assert.NoError(t, err) + assert.Equal(t, 0, len(list.Items)) +} diff --git a/pkg/deviceplugins/local_usb_device.go b/pkg/deviceplugins/local_usb_device.go index c7c0869a..46259c72 100644 --- a/pkg/deviceplugins/local_usb_device.go +++ b/pkg/deviceplugins/local_usb_device.go @@ -1,5 +1,10 @@ package deviceplugins +import ( + "github.com/sirupsen/logrus" + v1 "kubevirt.io/api/core/v1" +) + type LocalDevices struct { // For quicker indexing, map devices based on vendor string devices map[int][]*USBDevice @@ -38,3 +43,29 @@ func (l *LocalDevices) remove(usbdevs []*USBDevice) { } } } + +// return a list of USBDevices while removing it from the list of local devices +func (l *LocalDevices) fetch(selectors []v1.USBSelector) ([]*USBDevice, bool) { + usbdevs := make([]*USBDevice, 0, len(selectors)) + + // we have to find all devices under this resource name + for _, selector := range selectors { + selector := selector + vendor, product, err := parseSelector(&selector) + if err != nil { + logrus.Warningf("Failed to convert selector: %+v", selector) + return nil, false + } + + local := l.find(vendor, product) + if local == nil { + return nil, false + } + + usbdevs = append(usbdevs, local) + } + + // To avoid mapping the same usb device to different k8s plugins + l.remove(usbdevs) + return usbdevs, true +} diff --git a/pkg/deviceplugins/usb_device_plugin.go b/pkg/deviceplugins/usb_device_plugin.go index fd4b2948..79c6f652 100644 --- a/pkg/deviceplugins/usb_device_plugin.go +++ b/pkg/deviceplugins/usb_device_plugin.go @@ -447,32 +447,6 @@ func (plugin *USBDevicePlugin) PreStartContainer(context.Context, *pluginapi.Pre return &pluginapi.PreStartContainerResponse{}, nil } -// return a list of USBDevices while removing it from the list of local devices -func (l *LocalDevices) fetch(selectors []v1.USBSelector) ([]*USBDevice, bool) { - usbdevs := make([]*USBDevice, len(selectors)) - - // we have to find all devices under this resource name - for _, selector := range selectors { - selector := selector - vendor, product, err := parseSelector(&selector) - if err != nil { - log.Log.Reason(err).Warningf("Failed to convert selector: %+v", selector) - return nil, false - } - - local := l.find(vendor, product) - if local == nil { - return nil, false - } - - usbdevs = append(usbdevs, local) - } - - // To avoid mapping the same usb device to different k8s plugins - l.remove(usbdevs) - return usbdevs, true -} - func NewUSBDevicePlugin(resourceName string, pluginDevices []*PluginDevices) *USBDevicePlugin { s := strings.Split(resourceName, "/") resourceID := s[0] diff --git a/pkg/generated/clientset/versioned/clientset.go b/pkg/generated/clientset/versioned/clientset.go index 2f8a00b5..e4d16bc5 100644 --- a/pkg/generated/clientset/versioned/clientset.go +++ b/pkg/generated/clientset/versioned/clientset.go @@ -23,6 +23,7 @@ import ( "net/http" devicesv1beta1 "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/typed/devices.harvesterhci.io/v1beta1" + kubevirtv1 "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/typed/kubevirt.io/v1" discovery "k8s.io/client-go/discovery" rest "k8s.io/client-go/rest" flowcontrol "k8s.io/client-go/util/flowcontrol" @@ -31,12 +32,14 @@ import ( type Interface interface { Discovery() discovery.DiscoveryInterface DevicesV1beta1() devicesv1beta1.DevicesV1beta1Interface + KubevirtV1() kubevirtv1.KubevirtV1Interface } // Clientset contains the clients for groups. type Clientset struct { *discovery.DiscoveryClient devicesV1beta1 *devicesv1beta1.DevicesV1beta1Client + kubevirtV1 *kubevirtv1.KubevirtV1Client } // DevicesV1beta1 retrieves the DevicesV1beta1Client @@ -44,6 +47,11 @@ func (c *Clientset) DevicesV1beta1() devicesv1beta1.DevicesV1beta1Interface { return c.devicesV1beta1 } +// KubevirtV1 retrieves the KubevirtV1Client +func (c *Clientset) KubevirtV1() kubevirtv1.KubevirtV1Interface { + return c.kubevirtV1 +} + // Discovery retrieves the DiscoveryClient func (c *Clientset) Discovery() discovery.DiscoveryInterface { if c == nil { @@ -92,6 +100,10 @@ func NewForConfigAndClient(c *rest.Config, httpClient *http.Client) (*Clientset, if err != nil { return nil, err } + cs.kubevirtV1, err = kubevirtv1.NewForConfigAndClient(&configShallowCopy, httpClient) + if err != nil { + return nil, err + } cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfigAndClient(&configShallowCopy, httpClient) if err != nil { @@ -114,6 +126,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset { func New(c rest.Interface) *Clientset { var cs Clientset cs.devicesV1beta1 = devicesv1beta1.New(c) + cs.kubevirtV1 = kubevirtv1.New(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c) return &cs diff --git a/pkg/generated/clientset/versioned/fake/clientset_generated.go b/pkg/generated/clientset/versioned/fake/clientset_generated.go index 5031f6b2..4a4a26d9 100644 --- a/pkg/generated/clientset/versioned/fake/clientset_generated.go +++ b/pkg/generated/clientset/versioned/fake/clientset_generated.go @@ -22,6 +22,8 @@ import ( clientset "github.com/harvester/pcidevices/pkg/generated/clientset/versioned" devicesv1beta1 "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/typed/devices.harvesterhci.io/v1beta1" fakedevicesv1beta1 "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/typed/devices.harvesterhci.io/v1beta1/fake" + kubevirtv1 "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/typed/kubevirt.io/v1" + fakekubevirtv1 "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/watch" "k8s.io/client-go/discovery" @@ -83,3 +85,8 @@ var ( func (c *Clientset) DevicesV1beta1() devicesv1beta1.DevicesV1beta1Interface { return &fakedevicesv1beta1.FakeDevicesV1beta1{Fake: &c.Fake} } + +// KubevirtV1 retrieves the KubevirtV1Client +func (c *Clientset) KubevirtV1() kubevirtv1.KubevirtV1Interface { + return &fakekubevirtv1.FakeKubevirtV1{Fake: &c.Fake} +} diff --git a/pkg/generated/clientset/versioned/fake/register.go b/pkg/generated/clientset/versioned/fake/register.go index 6f5f3b16..3b6f6b5e 100644 --- a/pkg/generated/clientset/versioned/fake/register.go +++ b/pkg/generated/clientset/versioned/fake/register.go @@ -25,6 +25,7 @@ import ( schema "k8s.io/apimachinery/pkg/runtime/schema" serializer "k8s.io/apimachinery/pkg/runtime/serializer" utilruntime "k8s.io/apimachinery/pkg/util/runtime" + kubevirtv1 "kubevirt.io/api/core/v1" ) var scheme = runtime.NewScheme() @@ -32,6 +33,7 @@ var codecs = serializer.NewCodecFactory(scheme) var localSchemeBuilder = runtime.SchemeBuilder{ devicesv1beta1.AddToScheme, + kubevirtv1.AddToScheme, } // AddToScheme adds all types of this clientset into the given scheme. This allows composition diff --git a/pkg/generated/clientset/versioned/scheme/register.go b/pkg/generated/clientset/versioned/scheme/register.go index 6501b6f4..f931f202 100644 --- a/pkg/generated/clientset/versioned/scheme/register.go +++ b/pkg/generated/clientset/versioned/scheme/register.go @@ -25,6 +25,7 @@ import ( schema "k8s.io/apimachinery/pkg/runtime/schema" serializer "k8s.io/apimachinery/pkg/runtime/serializer" utilruntime "k8s.io/apimachinery/pkg/util/runtime" + kubevirtv1 "kubevirt.io/api/core/v1" ) var Scheme = runtime.NewScheme() @@ -32,6 +33,7 @@ var Codecs = serializer.NewCodecFactory(Scheme) var ParameterCodec = runtime.NewParameterCodec(Scheme) var localSchemeBuilder = runtime.SchemeBuilder{ devicesv1beta1.AddToScheme, + kubevirtv1.AddToScheme, } // AddToScheme adds all types of this clientset into the given scheme. This allows composition diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/doc.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/doc.go new file mode 100644 index 00000000..14176aa3 --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/doc.go @@ -0,0 +1,20 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +// This package has the automatically generated typed clients. +package v1 diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/doc.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/doc.go new file mode 100644 index 00000000..b8105736 --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/doc.go @@ -0,0 +1,20 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +// Package fake has the automatically generated clients. +package fake diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_kubevirt.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_kubevirt.go new file mode 100644 index 00000000..2841179a --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_kubevirt.go @@ -0,0 +1,142 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package fake + +import ( + "context" + + 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" + corev1 "kubevirt.io/api/core/v1" +) + +// FakeKubeVirts implements KubeVirtInterface +type FakeKubeVirts struct { + Fake *FakeKubevirtV1 + ns string +} + +var kubevirtsResource = schema.GroupVersionResource{Group: "kubevirt.io", Version: "v1", Resource: "kubevirts"} + +var kubevirtsKind = schema.GroupVersionKind{Group: "kubevirt.io", Version: "v1", Kind: "KubeVirt"} + +// Get takes name of the kubeVirt, and returns the corresponding kubeVirt object, and an error if there is any. +func (c *FakeKubeVirts) Get(ctx context.Context, name string, options v1.GetOptions) (result *corev1.KubeVirt, err error) { + obj, err := c.Fake. + Invokes(testing.NewGetAction(kubevirtsResource, c.ns, name), &corev1.KubeVirt{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.KubeVirt), err +} + +// List takes label and field selectors, and returns the list of KubeVirts that match those selectors. +func (c *FakeKubeVirts) List(ctx context.Context, opts v1.ListOptions) (result *corev1.KubeVirtList, err error) { + obj, err := c.Fake. + Invokes(testing.NewListAction(kubevirtsResource, kubevirtsKind, c.ns, opts), &corev1.KubeVirtList{}) + + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &corev1.KubeVirtList{ListMeta: obj.(*corev1.KubeVirtList).ListMeta} + for _, item := range obj.(*corev1.KubeVirtList).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 kubeVirts. +func (c *FakeKubeVirts) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewWatchAction(kubevirtsResource, c.ns, opts)) + +} + +// Create takes the representation of a kubeVirt and creates it. Returns the server's representation of the kubeVirt, and an error, if there is any. +func (c *FakeKubeVirts) Create(ctx context.Context, kubeVirt *corev1.KubeVirt, opts v1.CreateOptions) (result *corev1.KubeVirt, err error) { + obj, err := c.Fake. + Invokes(testing.NewCreateAction(kubevirtsResource, c.ns, kubeVirt), &corev1.KubeVirt{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.KubeVirt), err +} + +// Update takes the representation of a kubeVirt and updates it. Returns the server's representation of the kubeVirt, and an error, if there is any. +func (c *FakeKubeVirts) Update(ctx context.Context, kubeVirt *corev1.KubeVirt, opts v1.UpdateOptions) (result *corev1.KubeVirt, err error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateAction(kubevirtsResource, c.ns, kubeVirt), &corev1.KubeVirt{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.KubeVirt), 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 *FakeKubeVirts) UpdateStatus(ctx context.Context, kubeVirt *corev1.KubeVirt, opts v1.UpdateOptions) (*corev1.KubeVirt, error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateSubresourceAction(kubevirtsResource, "status", c.ns, kubeVirt), &corev1.KubeVirt{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.KubeVirt), err +} + +// Delete takes name of the kubeVirt and deletes it. Returns an error if one occurs. +func (c *FakeKubeVirts) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewDeleteActionWithOptions(kubevirtsResource, c.ns, name, opts), &corev1.KubeVirt{}) + + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeKubeVirts) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewDeleteCollectionAction(kubevirtsResource, c.ns, listOpts) + + _, err := c.Fake.Invokes(action, &corev1.KubeVirtList{}) + return err +} + +// Patch applies the patch and returns the patched kubeVirt. +func (c *FakeKubeVirts) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *corev1.KubeVirt, err error) { + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(kubevirtsResource, c.ns, name, pt, data, subresources...), &corev1.KubeVirt{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.KubeVirt), err +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_kubevirt.io_client.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_kubevirt.io_client.go new file mode 100644 index 00000000..b09eca4c --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_kubevirt.io_client.go @@ -0,0 +1,60 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package fake + +import ( + v1 "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/typed/kubevirt.io/v1" + rest "k8s.io/client-go/rest" + testing "k8s.io/client-go/testing" +) + +type FakeKubevirtV1 struct { + *testing.Fake +} + +func (c *FakeKubevirtV1) KubeVirts(namespace string) v1.KubeVirtInterface { + return &FakeKubeVirts{c, namespace} +} + +func (c *FakeKubevirtV1) VirtualMachines(namespace string) v1.VirtualMachineInterface { + return &FakeVirtualMachines{c, namespace} +} + +func (c *FakeKubevirtV1) VirtualMachineInstances(namespace string) v1.VirtualMachineInstanceInterface { + return &FakeVirtualMachineInstances{c, namespace} +} + +func (c *FakeKubevirtV1) VirtualMachineInstanceMigrations(namespace string) v1.VirtualMachineInstanceMigrationInterface { + return &FakeVirtualMachineInstanceMigrations{c, namespace} +} + +func (c *FakeKubevirtV1) VirtualMachineInstancePresets(namespace string) v1.VirtualMachineInstancePresetInterface { + return &FakeVirtualMachineInstancePresets{c, namespace} +} + +func (c *FakeKubevirtV1) VirtualMachineInstanceReplicaSets(namespace string) v1.VirtualMachineInstanceReplicaSetInterface { + return &FakeVirtualMachineInstanceReplicaSets{c, namespace} +} + +// RESTClient returns a RESTClient that is used to communicate +// with API server by this client implementation. +func (c *FakeKubevirtV1) RESTClient() rest.Interface { + var ret *rest.RESTClient + return ret +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachine.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachine.go new file mode 100644 index 00000000..ee7a5c89 --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachine.go @@ -0,0 +1,142 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package fake + +import ( + "context" + + 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" + corev1 "kubevirt.io/api/core/v1" +) + +// FakeVirtualMachines implements VirtualMachineInterface +type FakeVirtualMachines struct { + Fake *FakeKubevirtV1 + ns string +} + +var virtualmachinesResource = schema.GroupVersionResource{Group: "kubevirt.io", Version: "v1", Resource: "virtualmachines"} + +var virtualmachinesKind = schema.GroupVersionKind{Group: "kubevirt.io", Version: "v1", Kind: "VirtualMachine"} + +// Get takes name of the virtualMachine, and returns the corresponding virtualMachine object, and an error if there is any. +func (c *FakeVirtualMachines) Get(ctx context.Context, name string, options v1.GetOptions) (result *corev1.VirtualMachine, err error) { + obj, err := c.Fake. + Invokes(testing.NewGetAction(virtualmachinesResource, c.ns, name), &corev1.VirtualMachine{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachine), err +} + +// List takes label and field selectors, and returns the list of VirtualMachines that match those selectors. +func (c *FakeVirtualMachines) List(ctx context.Context, opts v1.ListOptions) (result *corev1.VirtualMachineList, err error) { + obj, err := c.Fake. + Invokes(testing.NewListAction(virtualmachinesResource, virtualmachinesKind, c.ns, opts), &corev1.VirtualMachineList{}) + + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &corev1.VirtualMachineList{ListMeta: obj.(*corev1.VirtualMachineList).ListMeta} + for _, item := range obj.(*corev1.VirtualMachineList).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 virtualMachines. +func (c *FakeVirtualMachines) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewWatchAction(virtualmachinesResource, c.ns, opts)) + +} + +// Create takes the representation of a virtualMachine and creates it. Returns the server's representation of the virtualMachine, and an error, if there is any. +func (c *FakeVirtualMachines) Create(ctx context.Context, virtualMachine *corev1.VirtualMachine, opts v1.CreateOptions) (result *corev1.VirtualMachine, err error) { + obj, err := c.Fake. + Invokes(testing.NewCreateAction(virtualmachinesResource, c.ns, virtualMachine), &corev1.VirtualMachine{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachine), err +} + +// Update takes the representation of a virtualMachine and updates it. Returns the server's representation of the virtualMachine, and an error, if there is any. +func (c *FakeVirtualMachines) Update(ctx context.Context, virtualMachine *corev1.VirtualMachine, opts v1.UpdateOptions) (result *corev1.VirtualMachine, err error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateAction(virtualmachinesResource, c.ns, virtualMachine), &corev1.VirtualMachine{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachine), 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 *FakeVirtualMachines) UpdateStatus(ctx context.Context, virtualMachine *corev1.VirtualMachine, opts v1.UpdateOptions) (*corev1.VirtualMachine, error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateSubresourceAction(virtualmachinesResource, "status", c.ns, virtualMachine), &corev1.VirtualMachine{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachine), err +} + +// Delete takes name of the virtualMachine and deletes it. Returns an error if one occurs. +func (c *FakeVirtualMachines) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewDeleteActionWithOptions(virtualmachinesResource, c.ns, name, opts), &corev1.VirtualMachine{}) + + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeVirtualMachines) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewDeleteCollectionAction(virtualmachinesResource, c.ns, listOpts) + + _, err := c.Fake.Invokes(action, &corev1.VirtualMachineList{}) + return err +} + +// Patch applies the patch and returns the patched virtualMachine. +func (c *FakeVirtualMachines) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *corev1.VirtualMachine, err error) { + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(virtualmachinesResource, c.ns, name, pt, data, subresources...), &corev1.VirtualMachine{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachine), err +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstance.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstance.go new file mode 100644 index 00000000..43dc9f54 --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstance.go @@ -0,0 +1,142 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package fake + +import ( + "context" + + 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" + corev1 "kubevirt.io/api/core/v1" +) + +// FakeVirtualMachineInstances implements VirtualMachineInstanceInterface +type FakeVirtualMachineInstances struct { + Fake *FakeKubevirtV1 + ns string +} + +var virtualmachineinstancesResource = schema.GroupVersionResource{Group: "kubevirt.io", Version: "v1", Resource: "virtualmachineinstances"} + +var virtualmachineinstancesKind = schema.GroupVersionKind{Group: "kubevirt.io", Version: "v1", Kind: "VirtualMachineInstance"} + +// Get takes name of the virtualMachineInstance, and returns the corresponding virtualMachineInstance object, and an error if there is any. +func (c *FakeVirtualMachineInstances) Get(ctx context.Context, name string, options v1.GetOptions) (result *corev1.VirtualMachineInstance, err error) { + obj, err := c.Fake. + Invokes(testing.NewGetAction(virtualmachineinstancesResource, c.ns, name), &corev1.VirtualMachineInstance{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstance), err +} + +// List takes label and field selectors, and returns the list of VirtualMachineInstances that match those selectors. +func (c *FakeVirtualMachineInstances) List(ctx context.Context, opts v1.ListOptions) (result *corev1.VirtualMachineInstanceList, err error) { + obj, err := c.Fake. + Invokes(testing.NewListAction(virtualmachineinstancesResource, virtualmachineinstancesKind, c.ns, opts), &corev1.VirtualMachineInstanceList{}) + + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &corev1.VirtualMachineInstanceList{ListMeta: obj.(*corev1.VirtualMachineInstanceList).ListMeta} + for _, item := range obj.(*corev1.VirtualMachineInstanceList).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 virtualMachineInstances. +func (c *FakeVirtualMachineInstances) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewWatchAction(virtualmachineinstancesResource, c.ns, opts)) + +} + +// Create takes the representation of a virtualMachineInstance and creates it. Returns the server's representation of the virtualMachineInstance, and an error, if there is any. +func (c *FakeVirtualMachineInstances) Create(ctx context.Context, virtualMachineInstance *corev1.VirtualMachineInstance, opts v1.CreateOptions) (result *corev1.VirtualMachineInstance, err error) { + obj, err := c.Fake. + Invokes(testing.NewCreateAction(virtualmachineinstancesResource, c.ns, virtualMachineInstance), &corev1.VirtualMachineInstance{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstance), err +} + +// Update takes the representation of a virtualMachineInstance and updates it. Returns the server's representation of the virtualMachineInstance, and an error, if there is any. +func (c *FakeVirtualMachineInstances) Update(ctx context.Context, virtualMachineInstance *corev1.VirtualMachineInstance, opts v1.UpdateOptions) (result *corev1.VirtualMachineInstance, err error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateAction(virtualmachineinstancesResource, c.ns, virtualMachineInstance), &corev1.VirtualMachineInstance{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstance), 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 *FakeVirtualMachineInstances) UpdateStatus(ctx context.Context, virtualMachineInstance *corev1.VirtualMachineInstance, opts v1.UpdateOptions) (*corev1.VirtualMachineInstance, error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateSubresourceAction(virtualmachineinstancesResource, "status", c.ns, virtualMachineInstance), &corev1.VirtualMachineInstance{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstance), err +} + +// Delete takes name of the virtualMachineInstance and deletes it. Returns an error if one occurs. +func (c *FakeVirtualMachineInstances) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewDeleteActionWithOptions(virtualmachineinstancesResource, c.ns, name, opts), &corev1.VirtualMachineInstance{}) + + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeVirtualMachineInstances) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewDeleteCollectionAction(virtualmachineinstancesResource, c.ns, listOpts) + + _, err := c.Fake.Invokes(action, &corev1.VirtualMachineInstanceList{}) + return err +} + +// Patch applies the patch and returns the patched virtualMachineInstance. +func (c *FakeVirtualMachineInstances) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *corev1.VirtualMachineInstance, err error) { + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(virtualmachineinstancesResource, c.ns, name, pt, data, subresources...), &corev1.VirtualMachineInstance{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstance), err +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancemigration.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancemigration.go new file mode 100644 index 00000000..cc09c6fa --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancemigration.go @@ -0,0 +1,142 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package fake + +import ( + "context" + + 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" + corev1 "kubevirt.io/api/core/v1" +) + +// FakeVirtualMachineInstanceMigrations implements VirtualMachineInstanceMigrationInterface +type FakeVirtualMachineInstanceMigrations struct { + Fake *FakeKubevirtV1 + ns string +} + +var virtualmachineinstancemigrationsResource = schema.GroupVersionResource{Group: "kubevirt.io", Version: "v1", Resource: "virtualmachineinstancemigrations"} + +var virtualmachineinstancemigrationsKind = schema.GroupVersionKind{Group: "kubevirt.io", Version: "v1", Kind: "VirtualMachineInstanceMigration"} + +// Get takes name of the virtualMachineInstanceMigration, and returns the corresponding virtualMachineInstanceMigration object, and an error if there is any. +func (c *FakeVirtualMachineInstanceMigrations) Get(ctx context.Context, name string, options v1.GetOptions) (result *corev1.VirtualMachineInstanceMigration, err error) { + obj, err := c.Fake. + Invokes(testing.NewGetAction(virtualmachineinstancemigrationsResource, c.ns, name), &corev1.VirtualMachineInstanceMigration{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstanceMigration), err +} + +// List takes label and field selectors, and returns the list of VirtualMachineInstanceMigrations that match those selectors. +func (c *FakeVirtualMachineInstanceMigrations) List(ctx context.Context, opts v1.ListOptions) (result *corev1.VirtualMachineInstanceMigrationList, err error) { + obj, err := c.Fake. + Invokes(testing.NewListAction(virtualmachineinstancemigrationsResource, virtualmachineinstancemigrationsKind, c.ns, opts), &corev1.VirtualMachineInstanceMigrationList{}) + + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &corev1.VirtualMachineInstanceMigrationList{ListMeta: obj.(*corev1.VirtualMachineInstanceMigrationList).ListMeta} + for _, item := range obj.(*corev1.VirtualMachineInstanceMigrationList).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 virtualMachineInstanceMigrations. +func (c *FakeVirtualMachineInstanceMigrations) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewWatchAction(virtualmachineinstancemigrationsResource, c.ns, opts)) + +} + +// Create takes the representation of a virtualMachineInstanceMigration and creates it. Returns the server's representation of the virtualMachineInstanceMigration, and an error, if there is any. +func (c *FakeVirtualMachineInstanceMigrations) Create(ctx context.Context, virtualMachineInstanceMigration *corev1.VirtualMachineInstanceMigration, opts v1.CreateOptions) (result *corev1.VirtualMachineInstanceMigration, err error) { + obj, err := c.Fake. + Invokes(testing.NewCreateAction(virtualmachineinstancemigrationsResource, c.ns, virtualMachineInstanceMigration), &corev1.VirtualMachineInstanceMigration{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstanceMigration), err +} + +// Update takes the representation of a virtualMachineInstanceMigration and updates it. Returns the server's representation of the virtualMachineInstanceMigration, and an error, if there is any. +func (c *FakeVirtualMachineInstanceMigrations) Update(ctx context.Context, virtualMachineInstanceMigration *corev1.VirtualMachineInstanceMigration, opts v1.UpdateOptions) (result *corev1.VirtualMachineInstanceMigration, err error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateAction(virtualmachineinstancemigrationsResource, c.ns, virtualMachineInstanceMigration), &corev1.VirtualMachineInstanceMigration{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstanceMigration), 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 *FakeVirtualMachineInstanceMigrations) UpdateStatus(ctx context.Context, virtualMachineInstanceMigration *corev1.VirtualMachineInstanceMigration, opts v1.UpdateOptions) (*corev1.VirtualMachineInstanceMigration, error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateSubresourceAction(virtualmachineinstancemigrationsResource, "status", c.ns, virtualMachineInstanceMigration), &corev1.VirtualMachineInstanceMigration{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstanceMigration), err +} + +// Delete takes name of the virtualMachineInstanceMigration and deletes it. Returns an error if one occurs. +func (c *FakeVirtualMachineInstanceMigrations) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewDeleteActionWithOptions(virtualmachineinstancemigrationsResource, c.ns, name, opts), &corev1.VirtualMachineInstanceMigration{}) + + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeVirtualMachineInstanceMigrations) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewDeleteCollectionAction(virtualmachineinstancemigrationsResource, c.ns, listOpts) + + _, err := c.Fake.Invokes(action, &corev1.VirtualMachineInstanceMigrationList{}) + return err +} + +// Patch applies the patch and returns the patched virtualMachineInstanceMigration. +func (c *FakeVirtualMachineInstanceMigrations) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *corev1.VirtualMachineInstanceMigration, err error) { + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(virtualmachineinstancemigrationsResource, c.ns, name, pt, data, subresources...), &corev1.VirtualMachineInstanceMigration{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstanceMigration), err +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancepreset.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancepreset.go new file mode 100644 index 00000000..3d0e7f76 --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancepreset.go @@ -0,0 +1,130 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package fake + +import ( + "context" + + 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" + corev1 "kubevirt.io/api/core/v1" +) + +// FakeVirtualMachineInstancePresets implements VirtualMachineInstancePresetInterface +type FakeVirtualMachineInstancePresets struct { + Fake *FakeKubevirtV1 + ns string +} + +var virtualmachineinstancepresetsResource = schema.GroupVersionResource{Group: "kubevirt.io", Version: "v1", Resource: "virtualmachineinstancepresets"} + +var virtualmachineinstancepresetsKind = schema.GroupVersionKind{Group: "kubevirt.io", Version: "v1", Kind: "VirtualMachineInstancePreset"} + +// Get takes name of the virtualMachineInstancePreset, and returns the corresponding virtualMachineInstancePreset object, and an error if there is any. +func (c *FakeVirtualMachineInstancePresets) Get(ctx context.Context, name string, options v1.GetOptions) (result *corev1.VirtualMachineInstancePreset, err error) { + obj, err := c.Fake. + Invokes(testing.NewGetAction(virtualmachineinstancepresetsResource, c.ns, name), &corev1.VirtualMachineInstancePreset{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstancePreset), err +} + +// List takes label and field selectors, and returns the list of VirtualMachineInstancePresets that match those selectors. +func (c *FakeVirtualMachineInstancePresets) List(ctx context.Context, opts v1.ListOptions) (result *corev1.VirtualMachineInstancePresetList, err error) { + obj, err := c.Fake. + Invokes(testing.NewListAction(virtualmachineinstancepresetsResource, virtualmachineinstancepresetsKind, c.ns, opts), &corev1.VirtualMachineInstancePresetList{}) + + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &corev1.VirtualMachineInstancePresetList{ListMeta: obj.(*corev1.VirtualMachineInstancePresetList).ListMeta} + for _, item := range obj.(*corev1.VirtualMachineInstancePresetList).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 virtualMachineInstancePresets. +func (c *FakeVirtualMachineInstancePresets) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewWatchAction(virtualmachineinstancepresetsResource, c.ns, opts)) + +} + +// Create takes the representation of a virtualMachineInstancePreset and creates it. Returns the server's representation of the virtualMachineInstancePreset, and an error, if there is any. +func (c *FakeVirtualMachineInstancePresets) Create(ctx context.Context, virtualMachineInstancePreset *corev1.VirtualMachineInstancePreset, opts v1.CreateOptions) (result *corev1.VirtualMachineInstancePreset, err error) { + obj, err := c.Fake. + Invokes(testing.NewCreateAction(virtualmachineinstancepresetsResource, c.ns, virtualMachineInstancePreset), &corev1.VirtualMachineInstancePreset{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstancePreset), err +} + +// Update takes the representation of a virtualMachineInstancePreset and updates it. Returns the server's representation of the virtualMachineInstancePreset, and an error, if there is any. +func (c *FakeVirtualMachineInstancePresets) Update(ctx context.Context, virtualMachineInstancePreset *corev1.VirtualMachineInstancePreset, opts v1.UpdateOptions) (result *corev1.VirtualMachineInstancePreset, err error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateAction(virtualmachineinstancepresetsResource, c.ns, virtualMachineInstancePreset), &corev1.VirtualMachineInstancePreset{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstancePreset), err +} + +// Delete takes name of the virtualMachineInstancePreset and deletes it. Returns an error if one occurs. +func (c *FakeVirtualMachineInstancePresets) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewDeleteActionWithOptions(virtualmachineinstancepresetsResource, c.ns, name, opts), &corev1.VirtualMachineInstancePreset{}) + + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeVirtualMachineInstancePresets) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewDeleteCollectionAction(virtualmachineinstancepresetsResource, c.ns, listOpts) + + _, err := c.Fake.Invokes(action, &corev1.VirtualMachineInstancePresetList{}) + return err +} + +// Patch applies the patch and returns the patched virtualMachineInstancePreset. +func (c *FakeVirtualMachineInstancePresets) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *corev1.VirtualMachineInstancePreset, err error) { + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(virtualmachineinstancepresetsResource, c.ns, name, pt, data, subresources...), &corev1.VirtualMachineInstancePreset{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstancePreset), err +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancereplicaset.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancereplicaset.go new file mode 100644 index 00000000..9a921f4a --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/fake/fake_virtualmachineinstancereplicaset.go @@ -0,0 +1,142 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package fake + +import ( + "context" + + 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" + corev1 "kubevirt.io/api/core/v1" +) + +// FakeVirtualMachineInstanceReplicaSets implements VirtualMachineInstanceReplicaSetInterface +type FakeVirtualMachineInstanceReplicaSets struct { + Fake *FakeKubevirtV1 + ns string +} + +var virtualmachineinstancereplicasetsResource = schema.GroupVersionResource{Group: "kubevirt.io", Version: "v1", Resource: "virtualmachineinstancereplicasets"} + +var virtualmachineinstancereplicasetsKind = schema.GroupVersionKind{Group: "kubevirt.io", Version: "v1", Kind: "VirtualMachineInstanceReplicaSet"} + +// Get takes name of the virtualMachineInstanceReplicaSet, and returns the corresponding virtualMachineInstanceReplicaSet object, and an error if there is any. +func (c *FakeVirtualMachineInstanceReplicaSets) Get(ctx context.Context, name string, options v1.GetOptions) (result *corev1.VirtualMachineInstanceReplicaSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewGetAction(virtualmachineinstancereplicasetsResource, c.ns, name), &corev1.VirtualMachineInstanceReplicaSet{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstanceReplicaSet), err +} + +// List takes label and field selectors, and returns the list of VirtualMachineInstanceReplicaSets that match those selectors. +func (c *FakeVirtualMachineInstanceReplicaSets) List(ctx context.Context, opts v1.ListOptions) (result *corev1.VirtualMachineInstanceReplicaSetList, err error) { + obj, err := c.Fake. + Invokes(testing.NewListAction(virtualmachineinstancereplicasetsResource, virtualmachineinstancereplicasetsKind, c.ns, opts), &corev1.VirtualMachineInstanceReplicaSetList{}) + + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &corev1.VirtualMachineInstanceReplicaSetList{ListMeta: obj.(*corev1.VirtualMachineInstanceReplicaSetList).ListMeta} + for _, item := range obj.(*corev1.VirtualMachineInstanceReplicaSetList).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 virtualMachineInstanceReplicaSets. +func (c *FakeVirtualMachineInstanceReplicaSets) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewWatchAction(virtualmachineinstancereplicasetsResource, c.ns, opts)) + +} + +// Create takes the representation of a virtualMachineInstanceReplicaSet and creates it. Returns the server's representation of the virtualMachineInstanceReplicaSet, and an error, if there is any. +func (c *FakeVirtualMachineInstanceReplicaSets) Create(ctx context.Context, virtualMachineInstanceReplicaSet *corev1.VirtualMachineInstanceReplicaSet, opts v1.CreateOptions) (result *corev1.VirtualMachineInstanceReplicaSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewCreateAction(virtualmachineinstancereplicasetsResource, c.ns, virtualMachineInstanceReplicaSet), &corev1.VirtualMachineInstanceReplicaSet{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstanceReplicaSet), err +} + +// Update takes the representation of a virtualMachineInstanceReplicaSet and updates it. Returns the server's representation of the virtualMachineInstanceReplicaSet, and an error, if there is any. +func (c *FakeVirtualMachineInstanceReplicaSets) Update(ctx context.Context, virtualMachineInstanceReplicaSet *corev1.VirtualMachineInstanceReplicaSet, opts v1.UpdateOptions) (result *corev1.VirtualMachineInstanceReplicaSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateAction(virtualmachineinstancereplicasetsResource, c.ns, virtualMachineInstanceReplicaSet), &corev1.VirtualMachineInstanceReplicaSet{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstanceReplicaSet), 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 *FakeVirtualMachineInstanceReplicaSets) UpdateStatus(ctx context.Context, virtualMachineInstanceReplicaSet *corev1.VirtualMachineInstanceReplicaSet, opts v1.UpdateOptions) (*corev1.VirtualMachineInstanceReplicaSet, error) { + obj, err := c.Fake. + Invokes(testing.NewUpdateSubresourceAction(virtualmachineinstancereplicasetsResource, "status", c.ns, virtualMachineInstanceReplicaSet), &corev1.VirtualMachineInstanceReplicaSet{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstanceReplicaSet), err +} + +// Delete takes name of the virtualMachineInstanceReplicaSet and deletes it. Returns an error if one occurs. +func (c *FakeVirtualMachineInstanceReplicaSets) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewDeleteActionWithOptions(virtualmachineinstancereplicasetsResource, c.ns, name, opts), &corev1.VirtualMachineInstanceReplicaSet{}) + + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeVirtualMachineInstanceReplicaSets) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewDeleteCollectionAction(virtualmachineinstancereplicasetsResource, c.ns, listOpts) + + _, err := c.Fake.Invokes(action, &corev1.VirtualMachineInstanceReplicaSetList{}) + return err +} + +// Patch applies the patch and returns the patched virtualMachineInstanceReplicaSet. +func (c *FakeVirtualMachineInstanceReplicaSets) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *corev1.VirtualMachineInstanceReplicaSet, err error) { + obj, err := c.Fake. + Invokes(testing.NewPatchSubresourceAction(virtualmachineinstancereplicasetsResource, c.ns, name, pt, data, subresources...), &corev1.VirtualMachineInstanceReplicaSet{}) + + if obj == nil { + return nil, err + } + return obj.(*corev1.VirtualMachineInstanceReplicaSet), err +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/generated_expansion.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/generated_expansion.go new file mode 100644 index 00000000..e41e11ed --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/generated_expansion.go @@ -0,0 +1,31 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package v1 + +type KubeVirtExpansion interface{} + +type VirtualMachineExpansion interface{} + +type VirtualMachineInstanceExpansion interface{} + +type VirtualMachineInstanceMigrationExpansion interface{} + +type VirtualMachineInstancePresetExpansion interface{} + +type VirtualMachineInstanceReplicaSetExpansion interface{} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/kubevirt.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/kubevirt.go new file mode 100644 index 00000000..fb2cdad0 --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/kubevirt.go @@ -0,0 +1,195 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package v1 + +import ( + "context" + "time" + + scheme "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/scheme" + metav1 "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" + v1 "kubevirt.io/api/core/v1" +) + +// KubeVirtsGetter has a method to return a KubeVirtInterface. +// A group's client should implement this interface. +type KubeVirtsGetter interface { + KubeVirts(namespace string) KubeVirtInterface +} + +// KubeVirtInterface has methods to work with KubeVirt resources. +type KubeVirtInterface interface { + Create(ctx context.Context, kubeVirt *v1.KubeVirt, opts metav1.CreateOptions) (*v1.KubeVirt, error) + Update(ctx context.Context, kubeVirt *v1.KubeVirt, opts metav1.UpdateOptions) (*v1.KubeVirt, error) + UpdateStatus(ctx context.Context, kubeVirt *v1.KubeVirt, opts metav1.UpdateOptions) (*v1.KubeVirt, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.KubeVirt, error) + List(ctx context.Context, opts metav1.ListOptions) (*v1.KubeVirtList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.KubeVirt, err error) + KubeVirtExpansion +} + +// kubeVirts implements KubeVirtInterface +type kubeVirts struct { + client rest.Interface + ns string +} + +// newKubeVirts returns a KubeVirts +func newKubeVirts(c *KubevirtV1Client, namespace string) *kubeVirts { + return &kubeVirts{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the kubeVirt, and returns the corresponding kubeVirt object, and an error if there is any. +func (c *kubeVirts) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.KubeVirt, err error) { + result = &v1.KubeVirt{} + err = c.client.Get(). + Namespace(c.ns). + Resource("kubevirts"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of KubeVirts that match those selectors. +func (c *kubeVirts) List(ctx context.Context, opts metav1.ListOptions) (result *v1.KubeVirtList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1.KubeVirtList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("kubevirts"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested kubeVirts. +func (c *kubeVirts) Watch(ctx context.Context, opts metav1.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("kubevirts"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a kubeVirt and creates it. Returns the server's representation of the kubeVirt, and an error, if there is any. +func (c *kubeVirts) Create(ctx context.Context, kubeVirt *v1.KubeVirt, opts metav1.CreateOptions) (result *v1.KubeVirt, err error) { + result = &v1.KubeVirt{} + err = c.client.Post(). + Namespace(c.ns). + Resource("kubevirts"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(kubeVirt). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a kubeVirt and updates it. Returns the server's representation of the kubeVirt, and an error, if there is any. +func (c *kubeVirts) Update(ctx context.Context, kubeVirt *v1.KubeVirt, opts metav1.UpdateOptions) (result *v1.KubeVirt, err error) { + result = &v1.KubeVirt{} + err = c.client.Put(). + Namespace(c.ns). + Resource("kubevirts"). + Name(kubeVirt.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(kubeVirt). + Do(ctx). + 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 *kubeVirts) UpdateStatus(ctx context.Context, kubeVirt *v1.KubeVirt, opts metav1.UpdateOptions) (result *v1.KubeVirt, err error) { + result = &v1.KubeVirt{} + err = c.client.Put(). + Namespace(c.ns). + Resource("kubevirts"). + Name(kubeVirt.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(kubeVirt). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the kubeVirt and deletes it. Returns an error if one occurs. +func (c *kubeVirts) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("kubevirts"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *kubeVirts) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("kubevirts"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched kubeVirt. +func (c *kubeVirts) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.KubeVirt, err error) { + result = &v1.KubeVirt{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("kubevirts"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/kubevirt.io_client.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/kubevirt.io_client.go new file mode 100644 index 00000000..484cdc48 --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/kubevirt.io_client.go @@ -0,0 +1,132 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package v1 + +import ( + "net/http" + + "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/scheme" + rest "k8s.io/client-go/rest" + v1 "kubevirt.io/api/core/v1" +) + +type KubevirtV1Interface interface { + RESTClient() rest.Interface + KubeVirtsGetter + VirtualMachinesGetter + VirtualMachineInstancesGetter + VirtualMachineInstanceMigrationsGetter + VirtualMachineInstancePresetsGetter + VirtualMachineInstanceReplicaSetsGetter +} + +// KubevirtV1Client is used to interact with features provided by the kubevirt.io group. +type KubevirtV1Client struct { + restClient rest.Interface +} + +func (c *KubevirtV1Client) KubeVirts(namespace string) KubeVirtInterface { + return newKubeVirts(c, namespace) +} + +func (c *KubevirtV1Client) VirtualMachines(namespace string) VirtualMachineInterface { + return newVirtualMachines(c, namespace) +} + +func (c *KubevirtV1Client) VirtualMachineInstances(namespace string) VirtualMachineInstanceInterface { + return newVirtualMachineInstances(c, namespace) +} + +func (c *KubevirtV1Client) VirtualMachineInstanceMigrations(namespace string) VirtualMachineInstanceMigrationInterface { + return newVirtualMachineInstanceMigrations(c, namespace) +} + +func (c *KubevirtV1Client) VirtualMachineInstancePresets(namespace string) VirtualMachineInstancePresetInterface { + return newVirtualMachineInstancePresets(c, namespace) +} + +func (c *KubevirtV1Client) VirtualMachineInstanceReplicaSets(namespace string) VirtualMachineInstanceReplicaSetInterface { + return newVirtualMachineInstanceReplicaSets(c, namespace) +} + +// NewForConfig creates a new KubevirtV1Client for the given config. +// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient), +// where httpClient was generated with rest.HTTPClientFor(c). +func NewForConfig(c *rest.Config) (*KubevirtV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + httpClient, err := rest.HTTPClientFor(&config) + if err != nil { + return nil, err + } + return NewForConfigAndClient(&config, httpClient) +} + +// NewForConfigAndClient creates a new KubevirtV1Client for the given config and http client. +// Note the http client provided takes precedence over the configured transport values. +func NewForConfigAndClient(c *rest.Config, h *http.Client) (*KubevirtV1Client, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := rest.RESTClientForConfigAndClient(&config, h) + if err != nil { + return nil, err + } + return &KubevirtV1Client{client}, nil +} + +// NewForConfigOrDie creates a new KubevirtV1Client for the given config and +// panics if there is an error in the config. +func NewForConfigOrDie(c *rest.Config) *KubevirtV1Client { + client, err := NewForConfig(c) + if err != nil { + panic(err) + } + return client +} + +// New creates a new KubevirtV1Client for the given RESTClient. +func New(c rest.Interface) *KubevirtV1Client { + return &KubevirtV1Client{c} +} + +func setConfigDefaults(config *rest.Config) error { + gv := v1.SchemeGroupVersion + config.GroupVersion = &gv + config.APIPath = "/apis" + config.NegotiatedSerializer = scheme.Codecs.WithoutConversion() + + 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 *KubevirtV1Client) RESTClient() rest.Interface { + if c == nil { + return nil + } + return c.restClient +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachine.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachine.go new file mode 100644 index 00000000..792a0d36 --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachine.go @@ -0,0 +1,195 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package v1 + +import ( + "context" + "time" + + scheme "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/scheme" + metav1 "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" + v1 "kubevirt.io/api/core/v1" +) + +// VirtualMachinesGetter has a method to return a VirtualMachineInterface. +// A group's client should implement this interface. +type VirtualMachinesGetter interface { + VirtualMachines(namespace string) VirtualMachineInterface +} + +// VirtualMachineInterface has methods to work with VirtualMachine resources. +type VirtualMachineInterface interface { + Create(ctx context.Context, virtualMachine *v1.VirtualMachine, opts metav1.CreateOptions) (*v1.VirtualMachine, error) + Update(ctx context.Context, virtualMachine *v1.VirtualMachine, opts metav1.UpdateOptions) (*v1.VirtualMachine, error) + UpdateStatus(ctx context.Context, virtualMachine *v1.VirtualMachine, opts metav1.UpdateOptions) (*v1.VirtualMachine, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.VirtualMachine, error) + List(ctx context.Context, opts metav1.ListOptions) (*v1.VirtualMachineList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.VirtualMachine, err error) + VirtualMachineExpansion +} + +// virtualMachines implements VirtualMachineInterface +type virtualMachines struct { + client rest.Interface + ns string +} + +// newVirtualMachines returns a VirtualMachines +func newVirtualMachines(c *KubevirtV1Client, namespace string) *virtualMachines { + return &virtualMachines{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the virtualMachine, and returns the corresponding virtualMachine object, and an error if there is any. +func (c *virtualMachines) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.VirtualMachine, err error) { + result = &v1.VirtualMachine{} + err = c.client.Get(). + Namespace(c.ns). + Resource("virtualmachines"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of VirtualMachines that match those selectors. +func (c *virtualMachines) List(ctx context.Context, opts metav1.ListOptions) (result *v1.VirtualMachineList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1.VirtualMachineList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("virtualmachines"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested virtualMachines. +func (c *virtualMachines) Watch(ctx context.Context, opts metav1.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("virtualmachines"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a virtualMachine and creates it. Returns the server's representation of the virtualMachine, and an error, if there is any. +func (c *virtualMachines) Create(ctx context.Context, virtualMachine *v1.VirtualMachine, opts metav1.CreateOptions) (result *v1.VirtualMachine, err error) { + result = &v1.VirtualMachine{} + err = c.client.Post(). + Namespace(c.ns). + Resource("virtualmachines"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachine). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a virtualMachine and updates it. Returns the server's representation of the virtualMachine, and an error, if there is any. +func (c *virtualMachines) Update(ctx context.Context, virtualMachine *v1.VirtualMachine, opts metav1.UpdateOptions) (result *v1.VirtualMachine, err error) { + result = &v1.VirtualMachine{} + err = c.client.Put(). + Namespace(c.ns). + Resource("virtualmachines"). + Name(virtualMachine.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachine). + Do(ctx). + 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 *virtualMachines) UpdateStatus(ctx context.Context, virtualMachine *v1.VirtualMachine, opts metav1.UpdateOptions) (result *v1.VirtualMachine, err error) { + result = &v1.VirtualMachine{} + err = c.client.Put(). + Namespace(c.ns). + Resource("virtualmachines"). + Name(virtualMachine.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachine). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the virtualMachine and deletes it. Returns an error if one occurs. +func (c *virtualMachines) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("virtualmachines"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *virtualMachines) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("virtualmachines"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched virtualMachine. +func (c *virtualMachines) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.VirtualMachine, err error) { + result = &v1.VirtualMachine{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("virtualmachines"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstance.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstance.go new file mode 100644 index 00000000..8f11527b --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstance.go @@ -0,0 +1,195 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package v1 + +import ( + "context" + "time" + + scheme "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/scheme" + metav1 "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" + v1 "kubevirt.io/api/core/v1" +) + +// VirtualMachineInstancesGetter has a method to return a VirtualMachineInstanceInterface. +// A group's client should implement this interface. +type VirtualMachineInstancesGetter interface { + VirtualMachineInstances(namespace string) VirtualMachineInstanceInterface +} + +// VirtualMachineInstanceInterface has methods to work with VirtualMachineInstance resources. +type VirtualMachineInstanceInterface interface { + Create(ctx context.Context, virtualMachineInstance *v1.VirtualMachineInstance, opts metav1.CreateOptions) (*v1.VirtualMachineInstance, error) + Update(ctx context.Context, virtualMachineInstance *v1.VirtualMachineInstance, opts metav1.UpdateOptions) (*v1.VirtualMachineInstance, error) + UpdateStatus(ctx context.Context, virtualMachineInstance *v1.VirtualMachineInstance, opts metav1.UpdateOptions) (*v1.VirtualMachineInstance, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.VirtualMachineInstance, error) + List(ctx context.Context, opts metav1.ListOptions) (*v1.VirtualMachineInstanceList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.VirtualMachineInstance, err error) + VirtualMachineInstanceExpansion +} + +// virtualMachineInstances implements VirtualMachineInstanceInterface +type virtualMachineInstances struct { + client rest.Interface + ns string +} + +// newVirtualMachineInstances returns a VirtualMachineInstances +func newVirtualMachineInstances(c *KubevirtV1Client, namespace string) *virtualMachineInstances { + return &virtualMachineInstances{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the virtualMachineInstance, and returns the corresponding virtualMachineInstance object, and an error if there is any. +func (c *virtualMachineInstances) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.VirtualMachineInstance, err error) { + result = &v1.VirtualMachineInstance{} + err = c.client.Get(). + Namespace(c.ns). + Resource("virtualmachineinstances"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of VirtualMachineInstances that match those selectors. +func (c *virtualMachineInstances) List(ctx context.Context, opts metav1.ListOptions) (result *v1.VirtualMachineInstanceList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1.VirtualMachineInstanceList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("virtualmachineinstances"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested virtualMachineInstances. +func (c *virtualMachineInstances) Watch(ctx context.Context, opts metav1.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("virtualmachineinstances"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a virtualMachineInstance and creates it. Returns the server's representation of the virtualMachineInstance, and an error, if there is any. +func (c *virtualMachineInstances) Create(ctx context.Context, virtualMachineInstance *v1.VirtualMachineInstance, opts metav1.CreateOptions) (result *v1.VirtualMachineInstance, err error) { + result = &v1.VirtualMachineInstance{} + err = c.client.Post(). + Namespace(c.ns). + Resource("virtualmachineinstances"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachineInstance). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a virtualMachineInstance and updates it. Returns the server's representation of the virtualMachineInstance, and an error, if there is any. +func (c *virtualMachineInstances) Update(ctx context.Context, virtualMachineInstance *v1.VirtualMachineInstance, opts metav1.UpdateOptions) (result *v1.VirtualMachineInstance, err error) { + result = &v1.VirtualMachineInstance{} + err = c.client.Put(). + Namespace(c.ns). + Resource("virtualmachineinstances"). + Name(virtualMachineInstance.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachineInstance). + Do(ctx). + 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 *virtualMachineInstances) UpdateStatus(ctx context.Context, virtualMachineInstance *v1.VirtualMachineInstance, opts metav1.UpdateOptions) (result *v1.VirtualMachineInstance, err error) { + result = &v1.VirtualMachineInstance{} + err = c.client.Put(). + Namespace(c.ns). + Resource("virtualmachineinstances"). + Name(virtualMachineInstance.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachineInstance). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the virtualMachineInstance and deletes it. Returns an error if one occurs. +func (c *virtualMachineInstances) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("virtualmachineinstances"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *virtualMachineInstances) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("virtualmachineinstances"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched virtualMachineInstance. +func (c *virtualMachineInstances) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.VirtualMachineInstance, err error) { + result = &v1.VirtualMachineInstance{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("virtualmachineinstances"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancemigration.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancemigration.go new file mode 100644 index 00000000..5f1aee6a --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancemigration.go @@ -0,0 +1,195 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package v1 + +import ( + "context" + "time" + + scheme "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/scheme" + metav1 "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" + v1 "kubevirt.io/api/core/v1" +) + +// VirtualMachineInstanceMigrationsGetter has a method to return a VirtualMachineInstanceMigrationInterface. +// A group's client should implement this interface. +type VirtualMachineInstanceMigrationsGetter interface { + VirtualMachineInstanceMigrations(namespace string) VirtualMachineInstanceMigrationInterface +} + +// VirtualMachineInstanceMigrationInterface has methods to work with VirtualMachineInstanceMigration resources. +type VirtualMachineInstanceMigrationInterface interface { + Create(ctx context.Context, virtualMachineInstanceMigration *v1.VirtualMachineInstanceMigration, opts metav1.CreateOptions) (*v1.VirtualMachineInstanceMigration, error) + Update(ctx context.Context, virtualMachineInstanceMigration *v1.VirtualMachineInstanceMigration, opts metav1.UpdateOptions) (*v1.VirtualMachineInstanceMigration, error) + UpdateStatus(ctx context.Context, virtualMachineInstanceMigration *v1.VirtualMachineInstanceMigration, opts metav1.UpdateOptions) (*v1.VirtualMachineInstanceMigration, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.VirtualMachineInstanceMigration, error) + List(ctx context.Context, opts metav1.ListOptions) (*v1.VirtualMachineInstanceMigrationList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.VirtualMachineInstanceMigration, err error) + VirtualMachineInstanceMigrationExpansion +} + +// virtualMachineInstanceMigrations implements VirtualMachineInstanceMigrationInterface +type virtualMachineInstanceMigrations struct { + client rest.Interface + ns string +} + +// newVirtualMachineInstanceMigrations returns a VirtualMachineInstanceMigrations +func newVirtualMachineInstanceMigrations(c *KubevirtV1Client, namespace string) *virtualMachineInstanceMigrations { + return &virtualMachineInstanceMigrations{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the virtualMachineInstanceMigration, and returns the corresponding virtualMachineInstanceMigration object, and an error if there is any. +func (c *virtualMachineInstanceMigrations) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.VirtualMachineInstanceMigration, err error) { + result = &v1.VirtualMachineInstanceMigration{} + err = c.client.Get(). + Namespace(c.ns). + Resource("virtualmachineinstancemigrations"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of VirtualMachineInstanceMigrations that match those selectors. +func (c *virtualMachineInstanceMigrations) List(ctx context.Context, opts metav1.ListOptions) (result *v1.VirtualMachineInstanceMigrationList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1.VirtualMachineInstanceMigrationList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("virtualmachineinstancemigrations"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested virtualMachineInstanceMigrations. +func (c *virtualMachineInstanceMigrations) Watch(ctx context.Context, opts metav1.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("virtualmachineinstancemigrations"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a virtualMachineInstanceMigration and creates it. Returns the server's representation of the virtualMachineInstanceMigration, and an error, if there is any. +func (c *virtualMachineInstanceMigrations) Create(ctx context.Context, virtualMachineInstanceMigration *v1.VirtualMachineInstanceMigration, opts metav1.CreateOptions) (result *v1.VirtualMachineInstanceMigration, err error) { + result = &v1.VirtualMachineInstanceMigration{} + err = c.client.Post(). + Namespace(c.ns). + Resource("virtualmachineinstancemigrations"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachineInstanceMigration). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a virtualMachineInstanceMigration and updates it. Returns the server's representation of the virtualMachineInstanceMigration, and an error, if there is any. +func (c *virtualMachineInstanceMigrations) Update(ctx context.Context, virtualMachineInstanceMigration *v1.VirtualMachineInstanceMigration, opts metav1.UpdateOptions) (result *v1.VirtualMachineInstanceMigration, err error) { + result = &v1.VirtualMachineInstanceMigration{} + err = c.client.Put(). + Namespace(c.ns). + Resource("virtualmachineinstancemigrations"). + Name(virtualMachineInstanceMigration.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachineInstanceMigration). + Do(ctx). + 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 *virtualMachineInstanceMigrations) UpdateStatus(ctx context.Context, virtualMachineInstanceMigration *v1.VirtualMachineInstanceMigration, opts metav1.UpdateOptions) (result *v1.VirtualMachineInstanceMigration, err error) { + result = &v1.VirtualMachineInstanceMigration{} + err = c.client.Put(). + Namespace(c.ns). + Resource("virtualmachineinstancemigrations"). + Name(virtualMachineInstanceMigration.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachineInstanceMigration). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the virtualMachineInstanceMigration and deletes it. Returns an error if one occurs. +func (c *virtualMachineInstanceMigrations) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("virtualmachineinstancemigrations"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *virtualMachineInstanceMigrations) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("virtualmachineinstancemigrations"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched virtualMachineInstanceMigration. +func (c *virtualMachineInstanceMigrations) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.VirtualMachineInstanceMigration, err error) { + result = &v1.VirtualMachineInstanceMigration{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("virtualmachineinstancemigrations"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancepreset.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancepreset.go new file mode 100644 index 00000000..972a6f6d --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancepreset.go @@ -0,0 +1,178 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package v1 + +import ( + "context" + "time" + + scheme "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/scheme" + metav1 "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" + v1 "kubevirt.io/api/core/v1" +) + +// VirtualMachineInstancePresetsGetter has a method to return a VirtualMachineInstancePresetInterface. +// A group's client should implement this interface. +type VirtualMachineInstancePresetsGetter interface { + VirtualMachineInstancePresets(namespace string) VirtualMachineInstancePresetInterface +} + +// VirtualMachineInstancePresetInterface has methods to work with VirtualMachineInstancePreset resources. +type VirtualMachineInstancePresetInterface interface { + Create(ctx context.Context, virtualMachineInstancePreset *v1.VirtualMachineInstancePreset, opts metav1.CreateOptions) (*v1.VirtualMachineInstancePreset, error) + Update(ctx context.Context, virtualMachineInstancePreset *v1.VirtualMachineInstancePreset, opts metav1.UpdateOptions) (*v1.VirtualMachineInstancePreset, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.VirtualMachineInstancePreset, error) + List(ctx context.Context, opts metav1.ListOptions) (*v1.VirtualMachineInstancePresetList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.VirtualMachineInstancePreset, err error) + VirtualMachineInstancePresetExpansion +} + +// virtualMachineInstancePresets implements VirtualMachineInstancePresetInterface +type virtualMachineInstancePresets struct { + client rest.Interface + ns string +} + +// newVirtualMachineInstancePresets returns a VirtualMachineInstancePresets +func newVirtualMachineInstancePresets(c *KubevirtV1Client, namespace string) *virtualMachineInstancePresets { + return &virtualMachineInstancePresets{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the virtualMachineInstancePreset, and returns the corresponding virtualMachineInstancePreset object, and an error if there is any. +func (c *virtualMachineInstancePresets) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.VirtualMachineInstancePreset, err error) { + result = &v1.VirtualMachineInstancePreset{} + err = c.client.Get(). + Namespace(c.ns). + Resource("virtualmachineinstancepresets"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of VirtualMachineInstancePresets that match those selectors. +func (c *virtualMachineInstancePresets) List(ctx context.Context, opts metav1.ListOptions) (result *v1.VirtualMachineInstancePresetList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1.VirtualMachineInstancePresetList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("virtualmachineinstancepresets"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested virtualMachineInstancePresets. +func (c *virtualMachineInstancePresets) Watch(ctx context.Context, opts metav1.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("virtualmachineinstancepresets"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a virtualMachineInstancePreset and creates it. Returns the server's representation of the virtualMachineInstancePreset, and an error, if there is any. +func (c *virtualMachineInstancePresets) Create(ctx context.Context, virtualMachineInstancePreset *v1.VirtualMachineInstancePreset, opts metav1.CreateOptions) (result *v1.VirtualMachineInstancePreset, err error) { + result = &v1.VirtualMachineInstancePreset{} + err = c.client.Post(). + Namespace(c.ns). + Resource("virtualmachineinstancepresets"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachineInstancePreset). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a virtualMachineInstancePreset and updates it. Returns the server's representation of the virtualMachineInstancePreset, and an error, if there is any. +func (c *virtualMachineInstancePresets) Update(ctx context.Context, virtualMachineInstancePreset *v1.VirtualMachineInstancePreset, opts metav1.UpdateOptions) (result *v1.VirtualMachineInstancePreset, err error) { + result = &v1.VirtualMachineInstancePreset{} + err = c.client.Put(). + Namespace(c.ns). + Resource("virtualmachineinstancepresets"). + Name(virtualMachineInstancePreset.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachineInstancePreset). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the virtualMachineInstancePreset and deletes it. Returns an error if one occurs. +func (c *virtualMachineInstancePresets) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("virtualmachineinstancepresets"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *virtualMachineInstancePresets) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("virtualmachineinstancepresets"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched virtualMachineInstancePreset. +func (c *virtualMachineInstancePresets) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.VirtualMachineInstancePreset, err error) { + result = &v1.VirtualMachineInstancePreset{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("virtualmachineinstancepresets"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancereplicaset.go b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancereplicaset.go new file mode 100644 index 00000000..f2a274e0 --- /dev/null +++ b/pkg/generated/clientset/versioned/typed/kubevirt.io/v1/virtualmachineinstancereplicaset.go @@ -0,0 +1,195 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package v1 + +import ( + "context" + "time" + + scheme "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/scheme" + metav1 "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" + v1 "kubevirt.io/api/core/v1" +) + +// VirtualMachineInstanceReplicaSetsGetter has a method to return a VirtualMachineInstanceReplicaSetInterface. +// A group's client should implement this interface. +type VirtualMachineInstanceReplicaSetsGetter interface { + VirtualMachineInstanceReplicaSets(namespace string) VirtualMachineInstanceReplicaSetInterface +} + +// VirtualMachineInstanceReplicaSetInterface has methods to work with VirtualMachineInstanceReplicaSet resources. +type VirtualMachineInstanceReplicaSetInterface interface { + Create(ctx context.Context, virtualMachineInstanceReplicaSet *v1.VirtualMachineInstanceReplicaSet, opts metav1.CreateOptions) (*v1.VirtualMachineInstanceReplicaSet, error) + Update(ctx context.Context, virtualMachineInstanceReplicaSet *v1.VirtualMachineInstanceReplicaSet, opts metav1.UpdateOptions) (*v1.VirtualMachineInstanceReplicaSet, error) + UpdateStatus(ctx context.Context, virtualMachineInstanceReplicaSet *v1.VirtualMachineInstanceReplicaSet, opts metav1.UpdateOptions) (*v1.VirtualMachineInstanceReplicaSet, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.VirtualMachineInstanceReplicaSet, error) + List(ctx context.Context, opts metav1.ListOptions) (*v1.VirtualMachineInstanceReplicaSetList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.VirtualMachineInstanceReplicaSet, err error) + VirtualMachineInstanceReplicaSetExpansion +} + +// virtualMachineInstanceReplicaSets implements VirtualMachineInstanceReplicaSetInterface +type virtualMachineInstanceReplicaSets struct { + client rest.Interface + ns string +} + +// newVirtualMachineInstanceReplicaSets returns a VirtualMachineInstanceReplicaSets +func newVirtualMachineInstanceReplicaSets(c *KubevirtV1Client, namespace string) *virtualMachineInstanceReplicaSets { + return &virtualMachineInstanceReplicaSets{ + client: c.RESTClient(), + ns: namespace, + } +} + +// Get takes name of the virtualMachineInstanceReplicaSet, and returns the corresponding virtualMachineInstanceReplicaSet object, and an error if there is any. +func (c *virtualMachineInstanceReplicaSets) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.VirtualMachineInstanceReplicaSet, err error) { + result = &v1.VirtualMachineInstanceReplicaSet{} + err = c.client.Get(). + Namespace(c.ns). + Resource("virtualmachineinstancereplicasets"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of VirtualMachineInstanceReplicaSets that match those selectors. +func (c *virtualMachineInstanceReplicaSets) List(ctx context.Context, opts metav1.ListOptions) (result *v1.VirtualMachineInstanceReplicaSetList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1.VirtualMachineInstanceReplicaSetList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("virtualmachineinstancereplicasets"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested virtualMachineInstanceReplicaSets. +func (c *virtualMachineInstanceReplicaSets) Watch(ctx context.Context, opts metav1.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("virtualmachineinstancereplicasets"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a virtualMachineInstanceReplicaSet and creates it. Returns the server's representation of the virtualMachineInstanceReplicaSet, and an error, if there is any. +func (c *virtualMachineInstanceReplicaSets) Create(ctx context.Context, virtualMachineInstanceReplicaSet *v1.VirtualMachineInstanceReplicaSet, opts metav1.CreateOptions) (result *v1.VirtualMachineInstanceReplicaSet, err error) { + result = &v1.VirtualMachineInstanceReplicaSet{} + err = c.client.Post(). + Namespace(c.ns). + Resource("virtualmachineinstancereplicasets"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachineInstanceReplicaSet). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a virtualMachineInstanceReplicaSet and updates it. Returns the server's representation of the virtualMachineInstanceReplicaSet, and an error, if there is any. +func (c *virtualMachineInstanceReplicaSets) Update(ctx context.Context, virtualMachineInstanceReplicaSet *v1.VirtualMachineInstanceReplicaSet, opts metav1.UpdateOptions) (result *v1.VirtualMachineInstanceReplicaSet, err error) { + result = &v1.VirtualMachineInstanceReplicaSet{} + err = c.client.Put(). + Namespace(c.ns). + Resource("virtualmachineinstancereplicasets"). + Name(virtualMachineInstanceReplicaSet.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachineInstanceReplicaSet). + Do(ctx). + 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 *virtualMachineInstanceReplicaSets) UpdateStatus(ctx context.Context, virtualMachineInstanceReplicaSet *v1.VirtualMachineInstanceReplicaSet, opts metav1.UpdateOptions) (result *v1.VirtualMachineInstanceReplicaSet, err error) { + result = &v1.VirtualMachineInstanceReplicaSet{} + err = c.client.Put(). + Namespace(c.ns). + Resource("virtualmachineinstancereplicasets"). + Name(virtualMachineInstanceReplicaSet.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(virtualMachineInstanceReplicaSet). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the virtualMachineInstanceReplicaSet and deletes it. Returns an error if one occurs. +func (c *virtualMachineInstanceReplicaSets) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("virtualmachineinstancereplicasets"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *virtualMachineInstanceReplicaSets) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Namespace(c.ns). + Resource("virtualmachineinstancereplicasets"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched virtualMachineInstanceReplicaSet. +func (c *virtualMachineInstanceReplicaSets) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.VirtualMachineInstanceReplicaSet, err error) { + result = &v1.VirtualMachineInstanceReplicaSet{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("virtualmachineinstancereplicasets"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/pkg/generated/controllers/kubevirt.io/factory.go b/pkg/generated/controllers/kubevirt.io/factory.go new file mode 100644 index 00000000..6a7a00f2 --- /dev/null +++ b/pkg/generated/controllers/kubevirt.io/factory.go @@ -0,0 +1,72 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package kubevirt + +import ( + "github.com/rancher/lasso/pkg/controller" + "github.com/rancher/wrangler/pkg/generic" + "k8s.io/client-go/rest" +) + +type Factory struct { + *generic.Factory +} + +func NewFactoryFromConfigOrDie(config *rest.Config) *Factory { + f, err := NewFactoryFromConfig(config) + if err != nil { + panic(err) + } + return f +} + +func NewFactoryFromConfig(config *rest.Config) (*Factory, error) { + return NewFactoryFromConfigWithOptions(config, nil) +} + +func NewFactoryFromConfigWithNamespace(config *rest.Config, namespace string) (*Factory, error) { + return NewFactoryFromConfigWithOptions(config, &FactoryOptions{ + Namespace: namespace, + }) +} + +type FactoryOptions = generic.FactoryOptions + +func NewFactoryFromConfigWithOptions(config *rest.Config, opts *FactoryOptions) (*Factory, error) { + f, err := generic.NewFactoryFromConfigWithOptions(config, opts) + return &Factory{ + Factory: f, + }, err +} + +func NewFactoryFromConfigWithOptionsOrDie(config *rest.Config, opts *FactoryOptions) *Factory { + f, err := NewFactoryFromConfigWithOptions(config, opts) + if err != nil { + panic(err) + } + return f +} + +func (c *Factory) Kubevirt() Interface { + return New(c.ControllerFactory()) +} + +func (c *Factory) WithAgent(userAgent string) Interface { + return New(controller.NewSharedControllerFactoryWithAgent(userAgent, c.ControllerFactory())) +} diff --git a/pkg/generated/controllers/kubevirt.io/interface.go b/pkg/generated/controllers/kubevirt.io/interface.go new file mode 100644 index 00000000..36b9db4a --- /dev/null +++ b/pkg/generated/controllers/kubevirt.io/interface.go @@ -0,0 +1,43 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package kubevirt + +import ( + v1 "github.com/harvester/pcidevices/pkg/generated/controllers/kubevirt.io/v1" + "github.com/rancher/lasso/pkg/controller" +) + +type Interface interface { + V1() v1.Interface +} + +type group struct { + controllerFactory controller.SharedControllerFactory +} + +// New returns a new Interface. +func New(controllerFactory controller.SharedControllerFactory) Interface { + return &group{ + controllerFactory: controllerFactory, + } +} + +func (g *group) V1() v1.Interface { + return v1.New(g.controllerFactory) +} diff --git a/pkg/generated/controllers/kubevirt.io/v1/interface.go b/pkg/generated/controllers/kubevirt.io/v1/interface.go new file mode 100644 index 00000000..6563cf40 --- /dev/null +++ b/pkg/generated/controllers/kubevirt.io/v1/interface.go @@ -0,0 +1,48 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package v1 + +import ( + "github.com/rancher/lasso/pkg/controller" + "github.com/rancher/wrangler/pkg/schemes" + "k8s.io/apimachinery/pkg/runtime/schema" + v1 "kubevirt.io/api/core/v1" +) + +func init() { + schemes.Register(v1.AddToScheme) +} + +type Interface interface { + KubeVirt() KubeVirtController +} + +func New(controllerFactory controller.SharedControllerFactory) Interface { + return &version{ + controllerFactory: controllerFactory, + } +} + +type version struct { + controllerFactory controller.SharedControllerFactory +} + +func (c *version) KubeVirt() KubeVirtController { + return NewKubeVirtController(schema.GroupVersionKind{Group: "kubevirt.io", Version: "v1", Kind: "KubeVirt"}, "kubevirts", true, c.controllerFactory) +} diff --git a/pkg/generated/controllers/kubevirt.io/v1/kubevirt.go b/pkg/generated/controllers/kubevirt.io/v1/kubevirt.go new file mode 100644 index 00000000..2969c912 --- /dev/null +++ b/pkg/generated/controllers/kubevirt.io/v1/kubevirt.go @@ -0,0 +1,376 @@ +/* +Copyright 2022 Rancher Labs, Inc. + +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 main. DO NOT EDIT. + +package v1 + +import ( + "context" + "time" + + "github.com/rancher/lasso/pkg/client" + "github.com/rancher/lasso/pkg/controller" + "github.com/rancher/wrangler/pkg/apply" + "github.com/rancher/wrangler/pkg/condition" + "github.com/rancher/wrangler/pkg/generic" + "github.com/rancher/wrangler/pkg/kv" + "k8s.io/apimachinery/pkg/api/equality" + "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/types" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" + "k8s.io/apimachinery/pkg/watch" + "k8s.io/client-go/tools/cache" + v1 "kubevirt.io/api/core/v1" +) + +type KubeVirtHandler func(string, *v1.KubeVirt) (*v1.KubeVirt, error) + +type KubeVirtController interface { + generic.ControllerMeta + KubeVirtClient + + OnChange(ctx context.Context, name string, sync KubeVirtHandler) + OnRemove(ctx context.Context, name string, sync KubeVirtHandler) + Enqueue(namespace, name string) + EnqueueAfter(namespace, name string, duration time.Duration) + + Cache() KubeVirtCache +} + +type KubeVirtClient interface { + Create(*v1.KubeVirt) (*v1.KubeVirt, error) + Update(*v1.KubeVirt) (*v1.KubeVirt, error) + UpdateStatus(*v1.KubeVirt) (*v1.KubeVirt, error) + Delete(namespace, name string, options *metav1.DeleteOptions) error + Get(namespace, name string, options metav1.GetOptions) (*v1.KubeVirt, error) + List(namespace string, opts metav1.ListOptions) (*v1.KubeVirtList, error) + Watch(namespace string, opts metav1.ListOptions) (watch.Interface, error) + Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.KubeVirt, err error) +} + +type KubeVirtCache interface { + Get(namespace, name string) (*v1.KubeVirt, error) + List(namespace string, selector labels.Selector) ([]*v1.KubeVirt, error) + + AddIndexer(indexName string, indexer KubeVirtIndexer) + GetByIndex(indexName, key string) ([]*v1.KubeVirt, error) +} + +type KubeVirtIndexer func(obj *v1.KubeVirt) ([]string, error) + +type kubeVirtController struct { + controller controller.SharedController + client *client.Client + gvk schema.GroupVersionKind + groupResource schema.GroupResource +} + +func NewKubeVirtController(gvk schema.GroupVersionKind, resource string, namespaced bool, controller controller.SharedControllerFactory) KubeVirtController { + c := controller.ForResourceKind(gvk.GroupVersion().WithResource(resource), gvk.Kind, namespaced) + return &kubeVirtController{ + controller: c, + client: c.Client(), + gvk: gvk, + groupResource: schema.GroupResource{ + Group: gvk.Group, + Resource: resource, + }, + } +} + +func FromKubeVirtHandlerToHandler(sync KubeVirtHandler) generic.Handler { + return func(key string, obj runtime.Object) (ret runtime.Object, err error) { + var v *v1.KubeVirt + if obj == nil { + v, err = sync(key, nil) + } else { + v, err = sync(key, obj.(*v1.KubeVirt)) + } + if v == nil { + return nil, err + } + return v, err + } +} + +func (c *kubeVirtController) Updater() generic.Updater { + return func(obj runtime.Object) (runtime.Object, error) { + newObj, err := c.Update(obj.(*v1.KubeVirt)) + if newObj == nil { + return nil, err + } + return newObj, err + } +} + +func UpdateKubeVirtDeepCopyOnChange(client KubeVirtClient, obj *v1.KubeVirt, handler func(obj *v1.KubeVirt) (*v1.KubeVirt, error)) (*v1.KubeVirt, error) { + if obj == nil { + return obj, nil + } + + copyObj := obj.DeepCopy() + newObj, err := handler(copyObj) + if newObj != nil { + copyObj = newObj + } + if obj.ResourceVersion == copyObj.ResourceVersion && !equality.Semantic.DeepEqual(obj, copyObj) { + return client.Update(copyObj) + } + + return copyObj, err +} + +func (c *kubeVirtController) AddGenericHandler(ctx context.Context, name string, handler generic.Handler) { + c.controller.RegisterHandler(ctx, name, controller.SharedControllerHandlerFunc(handler)) +} + +func (c *kubeVirtController) AddGenericRemoveHandler(ctx context.Context, name string, handler generic.Handler) { + c.AddGenericHandler(ctx, name, generic.NewRemoveHandler(name, c.Updater(), handler)) +} + +func (c *kubeVirtController) OnChange(ctx context.Context, name string, sync KubeVirtHandler) { + c.AddGenericHandler(ctx, name, FromKubeVirtHandlerToHandler(sync)) +} + +func (c *kubeVirtController) OnRemove(ctx context.Context, name string, sync KubeVirtHandler) { + c.AddGenericHandler(ctx, name, generic.NewRemoveHandler(name, c.Updater(), FromKubeVirtHandlerToHandler(sync))) +} + +func (c *kubeVirtController) Enqueue(namespace, name string) { + c.controller.Enqueue(namespace, name) +} + +func (c *kubeVirtController) EnqueueAfter(namespace, name string, duration time.Duration) { + c.controller.EnqueueAfter(namespace, name, duration) +} + +func (c *kubeVirtController) Informer() cache.SharedIndexInformer { + return c.controller.Informer() +} + +func (c *kubeVirtController) GroupVersionKind() schema.GroupVersionKind { + return c.gvk +} + +func (c *kubeVirtController) Cache() KubeVirtCache { + return &kubeVirtCache{ + indexer: c.Informer().GetIndexer(), + resource: c.groupResource, + } +} + +func (c *kubeVirtController) Create(obj *v1.KubeVirt) (*v1.KubeVirt, error) { + result := &v1.KubeVirt{} + return result, c.client.Create(context.TODO(), obj.Namespace, obj, result, metav1.CreateOptions{}) +} + +func (c *kubeVirtController) Update(obj *v1.KubeVirt) (*v1.KubeVirt, error) { + result := &v1.KubeVirt{} + return result, c.client.Update(context.TODO(), obj.Namespace, obj, result, metav1.UpdateOptions{}) +} + +func (c *kubeVirtController) UpdateStatus(obj *v1.KubeVirt) (*v1.KubeVirt, error) { + result := &v1.KubeVirt{} + return result, c.client.UpdateStatus(context.TODO(), obj.Namespace, obj, result, metav1.UpdateOptions{}) +} + +func (c *kubeVirtController) Delete(namespace, name string, options *metav1.DeleteOptions) error { + if options == nil { + options = &metav1.DeleteOptions{} + } + return c.client.Delete(context.TODO(), namespace, name, *options) +} + +func (c *kubeVirtController) Get(namespace, name string, options metav1.GetOptions) (*v1.KubeVirt, error) { + result := &v1.KubeVirt{} + return result, c.client.Get(context.TODO(), namespace, name, result, options) +} + +func (c *kubeVirtController) List(namespace string, opts metav1.ListOptions) (*v1.KubeVirtList, error) { + result := &v1.KubeVirtList{} + return result, c.client.List(context.TODO(), namespace, result, opts) +} + +func (c *kubeVirtController) Watch(namespace string, opts metav1.ListOptions) (watch.Interface, error) { + return c.client.Watch(context.TODO(), namespace, opts) +} + +func (c *kubeVirtController) Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (*v1.KubeVirt, error) { + result := &v1.KubeVirt{} + return result, c.client.Patch(context.TODO(), namespace, name, pt, data, result, metav1.PatchOptions{}, subresources...) +} + +type kubeVirtCache struct { + indexer cache.Indexer + resource schema.GroupResource +} + +func (c *kubeVirtCache) Get(namespace, name string) (*v1.KubeVirt, error) { + obj, exists, err := c.indexer.GetByKey(namespace + "/" + name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(c.resource, name) + } + return obj.(*v1.KubeVirt), nil +} + +func (c *kubeVirtCache) List(namespace string, selector labels.Selector) (ret []*v1.KubeVirt, err error) { + + err = cache.ListAllByNamespace(c.indexer, namespace, selector, func(m interface{}) { + ret = append(ret, m.(*v1.KubeVirt)) + }) + + return ret, err +} + +func (c *kubeVirtCache) AddIndexer(indexName string, indexer KubeVirtIndexer) { + utilruntime.Must(c.indexer.AddIndexers(map[string]cache.IndexFunc{ + indexName: func(obj interface{}) (strings []string, e error) { + return indexer(obj.(*v1.KubeVirt)) + }, + })) +} + +func (c *kubeVirtCache) GetByIndex(indexName, key string) (result []*v1.KubeVirt, err error) { + objs, err := c.indexer.ByIndex(indexName, key) + if err != nil { + return nil, err + } + result = make([]*v1.KubeVirt, 0, len(objs)) + for _, obj := range objs { + result = append(result, obj.(*v1.KubeVirt)) + } + return result, nil +} + +type KubeVirtStatusHandler func(obj *v1.KubeVirt, status v1.KubeVirtStatus) (v1.KubeVirtStatus, error) + +type KubeVirtGeneratingHandler func(obj *v1.KubeVirt, status v1.KubeVirtStatus) ([]runtime.Object, v1.KubeVirtStatus, error) + +func RegisterKubeVirtStatusHandler(ctx context.Context, controller KubeVirtController, condition condition.Cond, name string, handler KubeVirtStatusHandler) { + statusHandler := &kubeVirtStatusHandler{ + client: controller, + condition: condition, + handler: handler, + } + controller.AddGenericHandler(ctx, name, FromKubeVirtHandlerToHandler(statusHandler.sync)) +} + +func RegisterKubeVirtGeneratingHandler(ctx context.Context, controller KubeVirtController, apply apply.Apply, + condition condition.Cond, name string, handler KubeVirtGeneratingHandler, opts *generic.GeneratingHandlerOptions) { + statusHandler := &kubeVirtGeneratingHandler{ + KubeVirtGeneratingHandler: handler, + apply: apply, + name: name, + gvk: controller.GroupVersionKind(), + } + if opts != nil { + statusHandler.opts = *opts + } + controller.OnChange(ctx, name, statusHandler.Remove) + RegisterKubeVirtStatusHandler(ctx, controller, condition, name, statusHandler.Handle) +} + +type kubeVirtStatusHandler struct { + client KubeVirtClient + condition condition.Cond + handler KubeVirtStatusHandler +} + +func (a *kubeVirtStatusHandler) sync(key string, obj *v1.KubeVirt) (*v1.KubeVirt, error) { + if obj == nil { + return obj, nil + } + + origStatus := obj.Status.DeepCopy() + obj = obj.DeepCopy() + newStatus, err := a.handler(obj, obj.Status) + if err != nil { + // Revert to old status on error + newStatus = *origStatus.DeepCopy() + } + + if a.condition != "" { + if errors.IsConflict(err) { + a.condition.SetError(&newStatus, "", nil) + } else { + a.condition.SetError(&newStatus, "", err) + } + } + if !equality.Semantic.DeepEqual(origStatus, &newStatus) { + if a.condition != "" { + // Since status has changed, update the lastUpdatedTime + a.condition.LastUpdated(&newStatus, time.Now().UTC().Format(time.RFC3339)) + } + + var newErr error + obj.Status = newStatus + newObj, newErr := a.client.UpdateStatus(obj) + if err == nil { + err = newErr + } + if newErr == nil { + obj = newObj + } + } + return obj, err +} + +type kubeVirtGeneratingHandler struct { + KubeVirtGeneratingHandler + apply apply.Apply + opts generic.GeneratingHandlerOptions + gvk schema.GroupVersionKind + name string +} + +func (a *kubeVirtGeneratingHandler) Remove(key string, obj *v1.KubeVirt) (*v1.KubeVirt, error) { + if obj != nil { + return obj, nil + } + + obj = &v1.KubeVirt{} + obj.Namespace, obj.Name = kv.RSplit(key, "/") + obj.SetGroupVersionKind(a.gvk) + + return nil, generic.ConfigureApplyForObject(a.apply, obj, &a.opts). + WithOwner(obj). + WithSetID(a.name). + ApplyObjects() +} + +func (a *kubeVirtGeneratingHandler) Handle(obj *v1.KubeVirt, status v1.KubeVirtStatus) (v1.KubeVirtStatus, error) { + if !obj.DeletionTimestamp.IsZero() { + return status, nil + } + + objs, newStatus, err := a.KubeVirtGeneratingHandler(obj, status) + if err != nil { + return newStatus, err + } + + return newStatus, generic.ConfigureApplyForObject(a.apply, obj, &a.opts). + WithOwner(obj). + WithSetID(a.name). + ApplyObjects(objs...) +} diff --git a/pkg/util/fakeclients/kubevirt.go b/pkg/util/fakeclients/kubevirt.go new file mode 100644 index 00000000..28bc33aa --- /dev/null +++ b/pkg/util/fakeclients/kubevirt.go @@ -0,0 +1,46 @@ +package fakeclients + +import ( + "context" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/watch" + kubevirtapiv1 "kubevirt.io/api/core/v1" + + kubevirtv1 "github.com/harvester/pcidevices/pkg/generated/clientset/versioned/typed/kubevirt.io/v1" +) + +type KubeVirtClient func(namespace string) kubevirtv1.KubeVirtInterface + +func (k KubeVirtClient) Update(d *kubevirtapiv1.KubeVirt) (*kubevirtapiv1.KubeVirt, error) { + return k(d.Namespace).Update(context.TODO(), d, metav1.UpdateOptions{}) +} + +func (k KubeVirtClient) Get(namespace, name string, options metav1.GetOptions) (*kubevirtapiv1.KubeVirt, error) { + return k(namespace).Get(context.TODO(), name, options) +} + +func (k KubeVirtClient) Create(d *kubevirtapiv1.KubeVirt) (*kubevirtapiv1.KubeVirt, error) { + return k(d.Namespace).Create(context.TODO(), d, metav1.CreateOptions{}) +} + +func (k KubeVirtClient) Delete(namespace, name string, options *metav1.DeleteOptions) error { + return k(namespace).Delete(context.TODO(), name, *options) +} + +func (k KubeVirtClient) List(namespace string, opts metav1.ListOptions) (*kubevirtapiv1.KubeVirtList, error) { + return k(namespace).List(context.TODO(), opts) +} + +func (k KubeVirtClient) Watch(_ string, _ metav1.ListOptions) (watch.Interface, error) { + panic("implement me") +} + +func (k KubeVirtClient) Patch(_, _ string, _ types.PatchType, _ []byte, _ ...string) (result *kubevirtapiv1.KubeVirt, err error) { + panic("implement me") +} + +func (k KubeVirtClient) UpdateStatus(d *kubevirtapiv1.KubeVirt) (*kubevirtapiv1.KubeVirt, error) { + return k(d.Namespace).Update(context.TODO(), d, metav1.UpdateOptions{}) +} diff --git a/pkg/util/gousb/usbid/load_data.go b/pkg/util/gousb/usbid/load_data.go index 15d4dea1..66800116 100644 --- a/pkg/util/gousb/usbid/load_data.go +++ b/pkg/util/gousb/usbid/load_data.go @@ -27,8 +27,8 @@ import "time" // // The baked-in data was last generated: // -// 2024-05-23 11:25:41.3854 +0800 CST m=+1.155482168 -var LastUpdate = time.Unix(0, 1716434741385400000) +// 2024-05-24 18:06:00.452809 +0800 CST m=+1.712571876 +var LastUpdate = time.Unix(0, 1716545160452809000) const usbIDListData = `# # List of USB ID's diff --git a/tests/integration/suite_test.go b/tests/integration/suite_test.go index 9a3137d6..37981761 100644 --- a/tests/integration/suite_test.go +++ b/tests/integration/suite_test.go @@ -135,7 +135,7 @@ var _ = BeforeSuite(func() { Expect(err).NotTo(HaveOccurred()) - management := config.NewFactoryManager(factory, coreFactory, nil, nil, nil) + management := config.NewFactoryManager(factory, coreFactory, nil, nil, nil, nil) err = nodecleanup.Register(ctx, management) Expect(err).NotTo(HaveOccurred())