class Fog::Kubevirt::Compute::Mock

Attributes

namespace[RW]

Public Class Methods

new(options={}) click to toggle source
# File lib/fog/kubevirt/compute/compute.rb, line 498
def initialize(options={})
  @namespace = options[:namespace]
end

Public Instance Methods

client() click to toggle source
# File lib/fog/kubevirt/compute/compute.rb, line 502
def client
  return @client if defined?(@client)
end
create_networkattachmentdef(_net_att_def) click to toggle source
# File lib/fog/kubevirt/compute/requests/create_networkattachmentdef.rb, line 29
def create_networkattachmentdef(_net_att_def)
end
create_persistentvolume(volume) click to toggle source
# File lib/fog/kubevirt/compute/requests/create_persistentvolume.rb, line 11
def create_persistentvolume(volume)
end
create_pvc(attrs) click to toggle source
# File lib/fog/kubevirt/compute/requests/create_pvc.rb, line 11
def create_pvc(attrs)
  attrs_set_1g = {:apiVersion=>"v1",
                  :kind=>"PersistentVolumeClaim",
                  :metadata=>{:name=>"robin-rykert-example-com-claim-1",
                              :namespace=>"default"},
                              :spec=>{:storageClassName=>"local-storage",
                                      :resources=>{:requests=>{:storage=>"1G"}},
                                      :selector=>{},
                                      :accessModes=>["ReadWriteOnce"]}}
  if attrs == attrs_set_1g
    result = Kubeclient::Resource.new
    result.kind = "PersistentVolumeClaim"
    result.apiVersion="v1"
    result.metadata = {:name=>"robin-rykert-example-com-claim-1",
                       :namespace=>"default",
                       :selfLink=>"/api/v1/namespaces/default/persistentvolumeclaims/robin-rykert-example-com-claim-1",
                       :uid=>"00a7e1d7-5875-11e9-9132-525400c5a686",
                       :resourceVersion=>"1020273",
                       :creationTimestamp=>"2019-04-06T14:05:15Z"}
    result.spec = {:accessModes=>["ReadWriteOnce"],
                   :selector=>{},
                   :resources=>{:requests=>{:storage=>"1G"}},
                   :storageClassName=>"local-storage",
                   :volumeMode=>"Filesystem",
                   :dataSource=>nil}
    result.status = {:phase=>"Pending"}
    return result
  end

  attrs_set_2g = {:apiVersion=>"v1",
                  :kind=>"PersistentVolumeClaim",
                  :metadata=>{:name=>"robin-rykert-example-com-claim-2",
                              :namespace=>"default"},
                              :spec=>{:storageClassName=>"local-storage",
                                      :resources=>{:requests=>{:storage=>"2G"}},
                                      :selector=>{},
                                      :accessModes=>["ReadWriteOnce"]}}
  if attrs == attrs_set_2g
    result = Kubeclient::Resource.new
    result.kind="PersistentVolumeClaim"
    result.apiVersion="v1"
    result.metadata = {:name=>"robin-rykert-example-com-claim-2",
                       :namespace=>"default",
                       :selfLink=>"/api/v1/namespaces/default/persistentvolumeclaims/robin-rykert-example-com-claim-2",
                       :uid=>"00aa08ba-5875-11e9-9132-525400c5a686",
                       :resourceVersion=>"1020274",
                       :creationTimestamp=>"2019-04-06T14:05:15Z"}
    result.spec = {:accessModes=>["ReadWriteOnce"],
                   :selector=>{},
                   :resources=>{:requests=>{:storage=>"2G"}},
                   :storageClassName=>"local-storage",
                   :volumeMode=>"Filesystem",
                   :dataSource=>nil}
    result.status = {:phase=>"Pending"}
    return result
  end

  attrs_set_1g_image = {:apiVersion=>"v1",
                        :kind=>"PersistentVolumeClaim",
                        :metadata=>{:name=>"olive-kempter-example-com-claim-1",
                                    :namespace=>"default"},
                                    :spec=>{:storageClassName=>"local-storage",
                                            :resources=>{:requests=>{:storage=>"1G"}},
                                            :selector=>{},
                                            :accessModes=>["ReadWriteOnce"]}}

  if attrs == attrs_set_1g_image
    result = Kubeclient::Resource.new
    result.kind="PersistentVolumeClaim"
    result.apiVersion="v1"
    result.metadata={:name=>"olive-kempter-example-com-claim-1",
                     :namespace=>"default",
                     :selfLink=>"/api/v1/namespaces/default/persistentvolumeclaims/olive-kempter-example-com-claim-1",
                     :uid=>"d4d63298-5945-11e9-9132-525400c5a686",
                     :resourceVersion=>"1075554",
                     :creationTimestamp=>"2019-04-07T15:00:06Z"}
    result.spec={:accessModes=>["ReadWriteOnce"],
                 :selector=>{},
                 :resources=>{:requests=>{:storage=>"1G"}},
                 :storageClassName=>"local-storage",
                 :volumeMode=>"Filesystem",
                 :dataSource=>nil}
    result.status={:phase=>"Pending"}
    result
  end
end
create_service(srv) click to toggle source
# File lib/fog/kubevirt/compute/requests/create_service.rb, line 11
def create_service(srv); end
create_storage_class(attrs) click to toggle source
# File lib/fog/kubevirt/compute/requests/create_storageclass.rb, line 11
def create_storage_class(attrs); end
create_vm(vm) click to toggle source
# File lib/fog/kubevirt/compute/requests/create_vm.rb, line 13
def create_vm(vm)
  args_network_based ={:kind=>"VirtualMachine",
                       :metadata=>{:labels=>{:"kubevirt.io/vm"=>"robin-rykert.example.com"},
                                   :name=>"robin-rykert.example.com",
                                   :namespace=>"default"},
                                   :spec=>{:running=>false,
                                           :template=>{:metadata=>{:creationTimestamp=>nil,
                                                                   :labels=>{:"kubevirt.io/vm"=>"robin-rykert.example.com"}},
  :spec=>{:domain=>{:devices=>{:disks=>[{:name=>"robin-rykert-example-com-disk-00",
                                         :disk=>{:bus=>"virtio"}},
  {:name=>"robin-rykert-example-com-disk-01",
   :disk=>{:bus=>"virtio"}}],
  :interfaces=>[{:bridge=>{},
                 :name=>"ovs-foreman",
                 :bootOrder=>1,
                 :macAddress=>"a2:b4:a2:b6:a2:a8"}]},
                 :machine=>{:type=>""},
                 :resources=>{:requests=>{:memory=>"1024M"}},
                 :cpu=>{:cores=>1}},
  :terminationGracePeriodSeconds=>0,
  :volumes=>[{:name=>"robin-rykert-example-com-disk-00",
              :persistentVolumeClaim=>{:claimName=>"robin-rykert-example-com-claim-1"}},
  {:name=>"robin-rykert-example-com-disk-01",
   :persistentVolumeClaim=>{:claimName=>"robin-rykert-example-com-claim-2"}}],
  :networks=>[{:name=>"ovs-foreman",
               :multus=>{:networkName=>"ovs-foreman"}}]}}}}
  if vm == args_network_based
    result = Kubeclient::Resource.new
    result.apiVersion="kubevirt.io/v1alpha3"
    result.kind="VirtualMachine"
    result.metadata={:creationTimestamp=>"2019-04-06T14:05:15Z",
                     :generation=>1,
                     :labels=>{:"kubevirt.io/vm"=>"robin-rykert.example.com"},
                     :name=>"robin-rykert.example.com",
                     :namespace=>"default",
                     :resourceVersion=>"1020275",
                     :selfLink=>"/apis/kubevirt.io/v1alpha3/namespaces/default/virtualmachines/robin-rykert.example.com",
                     :uid=>"00ae63ee-5875-11e9-9132-525400c5a686"}
    result.spec={:running=>false,
                 :template=>{:metadata=>{:creationTimestamp=>nil,
                                         :labels=>{:"kubevirt.io/vm"=>"robin-rykert.example.com"}},
    :spec=>{:domain=>{:cpu=>{:cores=>1},
                      :devices=>{:disks=>[{:disk=>{:bus=>"virtio"},
                                           :name=>"robin-rykert-example-com-disk-00"},
                                           {:disk=>{:bus=>"virtio"},
                                            :name=>"robin-rykert-example-com-disk-01"}],
                                            :interfaces=>[{:bootOrder=>1,
                                                           :bridge=>{},
                                                           :macAddress=>"a2:b4:a2:b6:a2:a8",
                                                           :name=>"ovs-foreman"}]},
                                                           :machine=>{:type=>""},
                                                           :resources=>{:requests=>{:memory=>"1024M"}}},
    :networks=>[{:multus=>{:networkName=>"ovs-foreman"},
                 :name=>"ovs-foreman"}],
                 :terminationGracePeriodSeconds=>0,
                 :volumes=>[{:name=>"robin-rykert-example-com-disk-00",
                             :persistentVolumeClaim=>{:claimName=>"robin-rykert-example-com-claim-1"}},
    {:name=>"robin-rykert-example-com-disk-01",
     :persistentVolumeClaim=>{:claimName=>"robin-rykert-example-com-claim-2"}}]}}}
    return result
  end

  args_image_based = {:kind=>"VirtualMachine",
                      :metadata=>{:labels=>{:"kubevirt.io/vm"=>"olive-kempter.example.com"},
                                  :name=>"olive-kempter.example.com",
                                  :namespace=>"default"},
                                  :spec=>{:running=>false,
                                          :template=>{:metadata=>{:creationTimestamp=>nil,
                                                                  :labels=>{:"kubevirt.io/vm"=>"olive-kempter.example.com"}},
  :spec=>{:domain=>{:devices=>{:disks=>[{:name=>"olive-kempter-example-com-disk-00",
                                         :disk=>{:bus=>"virtio"},
                                         :bootOrder=>1},
                                         {:name=>"olive-kempter-example-com-disk-01",
                                          :disk=>{:bus=>"virtio"}}],
  :interfaces=>[{:bridge=>{},
                 :name=>"ovs-foreman",
                 :macAddress=>"a2:a4:a2:b2:a2:b6"}]},
                 :machine=>{:type=>""},
                 :resources=>{:requests=>{:memory=>"1024M"}},
                 :cpu=>{:cores=>1}},
  :terminationGracePeriodSeconds=>0,
  :volumes=>[{:name=>"olive-kempter-example-com-disk-00",
              :containerDisk=>{:image=>"kubevirt/fedora-cloud-registry-disk-demo"}},
  {:name=>"olive-kempter-example-com-disk-01",
   :persistentVolumeClaim=>{:claimName=>"olive-kempter-example-com-claim-1"}}],
  :networks=>[{:name=>"ovs-foreman",
               :multus=>{:networkName=>"ovs-foreman"}}]}}}}
  if vm == args_image_based
    result = Kubeclient::Resource.new
    result.apiVersion="kubevirt.io/v1alpha3"
    result.kind = "VirtualMachine"
    result.metadata={:creationTimestamp=>"2019-04-07T15:00:07Z",
                     :generation=>1,
                     :labels=>{:"kubevirt.io/vm"=>"olive-kempter.example.com"},
                     :name=>"olive-kempter.example.com",
                     :namespace=>"default",
                     :resourceVersion=>"1075555",
                     :selfLink=>"/apis/kubevirt.io/v1alpha3/namespaces/default/virtualmachines/olive-kempter.example.com",
                     :uid=>"d4dba9e4-5945-11e9-9132-525400c5a686"},
                     result.spec={:running=>false,
                                  :template=>{:metadata=>{:creationTimestamp=>nil,
                                                          :labels=>{:"kubevirt.io/vm"=>"olive-kempter.example.com"}},
    :spec=>{:domain=>{:cpu=>{:cores=>1},
                      :devices=>{:disks=>[{:bootOrder=>1,
                                           :disk=>{:bus=>"virtio"},
                                           :name=>"olive-kempter-example-com-disk-00"},
                                           {:disk=>{:bus=>"virtio"},
                                            :name=>"olive-kempter-example-com-disk-01"}],
                                            :interfaces=>[{:bridge=>{},
                                                           :macAddress=>"a2:a4:a2:b2:a2:b6",
                                                           :name=>"ovs-foreman"}]},
                                                           :machine=>{:type=>""},
                                                           :resources=>{:requests=>{:memory=>"1024M"}}},
    :networks=>[{:multus=>{:networkName=>"ovs-foreman"},
                 :name=>"ovs-foreman"}],
                 :terminationGracePeriodSeconds=>0,
                 :volumes=>[{:containerDisk=>{:image=>"kubevirt/fedora-cloud-registry-disk-demo"},
                             :name=>"olive-kempter-example-com-disk-00"},
                             {:name=>"olive-kempter-example-com-disk-01",
                              :persistentVolumeClaim=>{:claimName=>"olive-kempter-example-com-claim-1"}}]}}}
  end
end
create_vminstance(vm) click to toggle source
# File lib/fog/kubevirt/compute/requests/create_vminstance.rb, line 12
def create_vminstance(vm)
end
delete_networkattachmentdef(_name, _namespace) click to toggle source
# File lib/fog/kubevirt/compute/requests/delete_networkattachmentdef.rb, line 11
def delete_networkattachmentdef(_name, _namespace)
end
delete_persistentvolume(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/delete_persistentvolume.rb, line 11
def delete_persistentvolume(name)
end
delete_pvc(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/delete_pvc.rb, line 11
def delete_pvc(name)
end
delete_service(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/delete_service.rb, line 11
def delete_service(name)
end
delete_storage_class(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/delete_storageclass.rb, line 11
def delete_storage_class(name)
end
delete_virtual_machine_instance(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/delete_vminstance.rb, line 11
def delete_virtual_machine_instance(name)
end
delete_vm(name, namespace) click to toggle source
# File lib/fog/kubevirt/compute/requests/delete_vm.rb, line 11
def delete_vm(name, namespace)
end
disk(name: "", boot_order: nil, type: "disk", bus: "virtio", readonly: nil) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_server.rb, line 62
def disk(name: "", boot_order: nil, type: "disk", bus: "virtio", readonly: nil)
  disk = Fog::Kubevirt::Compute::VmData::VmDisk.new
  disk.name = name
  disk.boot_order = boot_order
  disk.type = type
  disk.bus = bus
  disk.readonly = readonly
  disk
end
get_networkattachmentdef(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_networkattachmentdef.rb, line 14
def get_networkattachmentdef(name)
end
get_node(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_node.rb, line 13
def get_node(name)
  node = {:apiVersion => "v1",
          :kind => "Node",
          :metadata => {
            :annotations => {
              :volumes.kubernetes.io/controller-managed-attach-detach => "true"
            },
            :creationTimestamp => "2018-04-09T15:34:26Z",
            :labels => {
              :beta.kubernetes.io/arch => "amd64", :beta.kubernetes.io/os => "linux",
              :kubernetes.io/hostname => "master", :node-role.kubernetes.io/master => "true",
              :openshift-infra => "apiserver", :region => "infra", :zone => "default"
            },
            :name => "master",
            :resourceVersion => "1514501",
            :selfLink => "/api/v1/nodes/master",
            :uid => "7c4102a6-3c0b-11e8-ad43-525400a36119"
          },
          :spec => {
            :externalID => "master"
          },
          :status => {
            :addresses => [
              {:address => "192.168.200.2", :type => "InternalIP"},
              {:address => "master", :type => "Hostname"}
            ],
            :allocatable => {:cpu => "2", :memory => "2739328Ki", :pods => "20"},
            :capacity => {:cpu => "2", :memory => "2841728Ki", :pods => "20"},
            :conditions => [
              {
                :lastHeartbeatTime => "2018-04-20T09:37:45Z", :lastTransitionTime => "2018-04-09T15:34:26Z",
                :message => "kubelet has sufficient disk space available", :reason => "KubeletHasSufficientDisk",
                :status => "False", :type => "OutOfDisk"
              },
              {
                :lastHeartbeatTime => "2018-04-20T09:37:45Z", :lastTransitionTime => "2018-04-09T15:34:26Z",
                :message => "kubelet has sufficient memory available", :reason => "KubeletHasSufficientMemory",
                :status => "False", :type => "MemoryPressure"
              },
              {
                :lastHeartbeatTime => "2018-04-20T09:37:45Z", :lastTransitionTime => "2018-04-19T12:56:17Z",
                :message => "kubelet has disk pressure", :reason => "KubeletHasDiskPressure",
                :status => "True", :type => "DiskPressure"
              },
              {
                :lastHeartbeatTime => "2018-04-20T09:37:45Z", :lastTransitionTime => "2018-04-20T07:08:18Z",
                :message => "kubelet is posting ready status", :reason => "KubeletReady",
                :status => "True", :type => "Ready"
              }
            ],
            :daemonEndpoints => {
              :kubeletEndpoint => {
                :Port => 10250
              }
            },
            :images => [
              {
                :names => ["docker.io/openshift/openvswitch@sha256:2783e9bc552ea8c4ea725a9f88e353330243b010925c274561ba045974ce4000",
                           "docker.io/openshift/openvswitch:v3.9.0-alpha.4"], :sizeBytes => 1474465582
              },
              {
                :names => ["docker.io/openshift/node@sha256:e092f1267535714070761844a62cdd38ce05e63a836ee55196953b8ac69527ba",
                           "docker.io/openshift/node:v3.9.0-alpha.4"], :sizeBytes => 1472685816
              },
              {
                :names => ["docker.io/openshift/origin@sha256:4a3d8819499307c57dbb7d244b719c0e45068ca54727ef30b53a361cbe7d9430",
                           "docker.io/openshift/origin:v3.9.0-alpha.4"], :sizeBytes => 1257103966
              },
              {
                :names => ["docker.io/ansibleplaybookbundle/apb-base@sha256:639d623b8185dd1471d38d2cc554efe7e2440a69d9a44cefa6b5565e8cc0d89c",
                           "docker.io/ansibleplaybookbundle/apb-base:latest"], :sizeBytes => 658504560
              },
              {
                :names => ["registry.fedoraproject.org/latest/etcd@sha256:0656877d3888ca8b385bfc720fede845de185f0b5d29a0bbc7a2fb8c6fc8137a",
                           "registry.fedoraproject.org/latest/etcd:latest"], :sizeBytes => 308700638
              },
              {
                :names => ["docker.io/fedora@sha256:7e2fc11763119c0cc0781400bb571bf2033c45469ebe286f1f090ba0dcffc32e",
                           "docker.io/fedora:26"], :sizeBytes => 231669643
              },
              {
                :names => ["docker.io/openshift/origin-pod@sha256:ba180ba987ad1f07187c35e2369923b04fb8969a4344064feb38de508d65c385",
                           "docker.io/openshift/origin-pod:v3.9.0-alpha.4"], :sizeBytes => 228576414
              }
            ],
            :nodeInfo => {
              :architecture => "amd64", :bootID => "c2c59d3a-79d4-4661-acff-daf685ae4edc", :containerRuntimeVersion => "docker://1.13.1",
              :kernelVersion => "3.10.0-693.21.1.el7.x86_64", :kubeProxyVersion => "v1.9.1+a0ce1bc657", :kubeletVersion => "v1.9.1+a0ce1bc657",
              :machineID => "52c01ad890e84b15a1be4be18bd64ecd", :operatingSystem => "linux", :osImage => "CentOS Linux 7 (Core)",
              :systemUUID => "52C01AD8-90E8-4B15-A1BE-4BE18BD64ECD"
            }
          }
  }
  object = RecursiveOpenStruct.new(node, recurse_over_arrays: true)
  Node.parse object_to_hash(object)
end
get_persistentvolume(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_persistentvolume.rb, line 11
def get_persistentvolume(name)
end
get_pvc(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_pvc.rb, line 11
def get_pvc(name)
end
get_raw_vm(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_vm.rb, line 43
def get_raw_vm(name)
  {
    :apiVersion=>"kubevirt.io/v1alpha3",
    :kind=>"VirtualMachine",
    :metadata=>{
      :creationTimestamp=>"2019-04-02T13:28:47Z",
      :generation=>1,
      :labels=>{
        :special=>"vm-multus-multiple-net"
      },
      :name=>"vm-multus-multiple-net",
      :namespace=>"default",
      :resourceVersion=>"24453",
      :selfLink=>"/apis/kubevirt.io/v1alpha3/namespaces/default/virtualmachines/vm-multus-multiple-net",
      :uid=>"3e959de9-554b-11e9-a3d6-525500d15501"
    },
    :spec=>{
      :running=>false,
      :template=>{
        :metadata=>{
          :labels=>{
            :"kubevirt.io/vm"=>"vm-multus-multiple-net"
          }
        },
        :spec=>{
          :domain=>{
            :devices=>{
              :disks=>[
                {
                  :disk=>{:bus=>"virtio"},
                  :name=>"containerdisk"
                },
                {
                  :disk=>{:bus=>"virtio"},
                  :name=>"cloudinitdisk"
                }
              ],
              :interfaces=>[
                {
                  :bridge=>{},
                  :name=>"default"
                },
                {
                  :bridge=>{},
                  :name=>"ptp"
                }
              ]
            },
            :machine=>{
              :type=>""
            },
            :resources=>{
              :requests=>{
                :memory=>"1024M"
              }
            }
          },
          :networks=>[
            {
              :name=>"default",
              :pod=>{}
            },
            {
              :multus=>{
                :networkName=>"ptp-conf"
              },
              :name=>"ptp"
            }
          ],
          :terminationGracePeriodSeconds=>0,
          :volumes=>[
            {
              :containerDisk=>{:image=>"registry:5000/kubevirt/fedora-cloud-container-disk-demo:devel"},
              :name=>"containerdisk"
            },
            {
              :cloudInitNoCloud=>{:userData=>"#!/bin/bash\necho \"fedora\" |passwd fedora --stdin\ndhclient eth1\n"},
              :name=>"cloudinitdisk"
            }
          ]
        }
      }
    }
  }
end
get_server(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_server.rb, line 83
def get_server(name)
  if name == "robin-rykert.example.com" || name == 'no_interfaces'
    disk1 = disk(name: "robin-rykert-example-com-disk-00", boot_order: nil,type: "disk", bus: "virtio", readonly: nil)
    disk2 = disk(name: "robin-rykert-example-com-disk-01", boot_order: nil,type: "disk", bus: "virtio", readonly: nil)

    volume1 = volume(name: "robin-rykert-example-com-disk-00", type: "persistentVolumeClaim", info: "robin-rykert-example-com-claim-1",
                     pvc: nil, config: {:claimName=>"robin-rykert-example-com-claim-1"}, boot_order: nil, bus: "virtio")
    volume2 = volume(name: "robin-rykert-example-com-disk-01", type: "persistentVolumeClaim", info: "robin-rykert-example-com-claim-2",
                     pvc: nil, config: {:claimName=>"robin-rykert-example-com-claim-2"}, boot_order: nil, bus: "virtio")

    vm_network = Fog::Kubevirt::Compute::VmData::VmNetwork.new
    vm_network.name="ovs-foreman"
    vm_network.type="multus"
    vm_network.network_name="ovs-foreman"

    interfaces = name != 'no_interfaces' ? [vm_nic(mac_address: "a2:b4:a2:b6:a2:a8")] : nil

    return {
      :namespace=>"default",
      :name=>"robin-rykert.example.com",
      :resource_version=>"1020275",
      :uid=>"00ae63ee-5875-11e9-9132-525400c5a686",
      :labels=>{:"kubevirt.io/vm"=>"robin-rykert.example.com"},
      :disks=>[disk1, disk2],
      :volumes=>[volume1, volume2],
      :status=>"stopped",
      :interfaces=>interfaces,
      :networks=>[vm_network],
      :machine_type=>"",
      :cpu_cores=>1,
      :memory=>"1024M",
      :state=>nil,
      :node_name=>nil,
      :ip_address=>nil
    }
  end

  if name == "olive-kempter.example.com"
    disk1 = disk(name: "olive-kempter-example-com-disk-00", boot_order: nil,type: "disk", bus: "virtio", readonly: nil)
    disk2 = disk(name: "olive-kempter-example-com-disk-01", boot_order: nil,type: "disk", bus: "virtio", readonly: nil)
    volume1 = volume(name: "olive-kempter-example-com-disk-00", type: "containerDisk", info: "kubevirt/fedora-cloud-registry-disk-demo",
                     pvc: nil, config: {:image=>"kubevirt/fedora-cloud-registry-disk-demo"}, boot_order: nil, bus: "virtio")
    volume2 = volume(name: "olive-kempter-example-com-disk-01", type: "containerDisk", info: "olive-kempter-example-com-claim-1",
                     pvc: nil, config: {:claimName=>"olive-kempter-example-com-claim-1"}, boot_order: nil, bus: "virtio")
    return {
      :namespace => "default",
      :name =>"olive-kempter.example.com",
      :resource_version => "1075555",
      :uid => "d4dba9e4-5945-11e9-9132-525400c5a686",
      :labels => {:"kubevirt.io/vm"=>"olive-kempter.example.com"},
      :disks => [disk1, disk2],
      :volumes => [ volume1, volume2],
      :status => "stopped",
      :interfaces => [vm_nic(mac_address: "a2:a4:a2:b2:a2:b6")],
      :networks => [vm_network],
      :machine_type => "",
      :cpu_cores => 1,
      :memory => "1024M",
      :state => nil,
      :node_name => nil,
      :ip_address => nil
    }
  end

  raise ::Fog::Kubevirt::Errors::ClientError, "HTTP status code 404, virtualmachines.kubevirt.io \"#{name}\" not found for GET"
end
get_service(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_service.rb, line 11
def get_service(name)
end
get_storage_class(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_storageclass.rb, line 11
def get_storage_class(name)
end
get_template(name) click to toggle source

TODO provide implementation

# File lib/fog/kubevirt/compute/requests/get_template.rb, line 12
def get_template(name)
end
get_vm(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_vm.rb, line 39
def get_vm(name)
  Vm.parse get_raw_vm(name)
end
get_vminstance(name) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_vminstance.rb, line 14
def get_vminstance(name)
  vm = {
    :apiVersion=>"kubevirt.io/v1alpha3",
    :kind=>"VirtualMachineInstance",
    :metadata=>{
      :creationTimestamp=>"2019-04-02T13:46:08Z",
      :finalizers=>["foregroundDeleteVirtualMachine"],
      :generation=>7,
      :labels=>{
        :"kubevirt.io/nodeName"=>"node02",
        :special=>"vmi-multus-multiple-net"
      },
      :name=>"vmi-multus-multiple-net",
      :namespace=>"default",
      :resourceVersion=>"27047",
      :selfLink=>"/apis/kubevirt.io/v1alpha3/namespaces/default/virtualmachineinstances/vmi-multus-multiple-net",
      :uid=>"ab5e450c-554d-11e9-a3d6-525500d15501"
    },
    :spec=>{
      :domain=>{
        :devices=>{
          :disks=>[
            {
              :disk=>{:bus=>"virtio"},
              :name=>"containerdisk"
            },
            {
              :disk=>{:bus=>"virtio"},
              :name=>"cloudinitdisk"
            }
          ],
          :interfaces=>[
            {
              :bridge=>{},
              :name=>"default"
            },
            {
              :bridge=>{},
              :name=>"ptp"
            }
          ]
        },
        :features=>{
          :acpi=>{:enabled=>true}
        },
        :firmware=>{:uuid=>"ff1ff019-c799-400f-9be1-375c3cee8b59"},
        :machine=>{:type=>"q35"},
        :resources=>{
          :requests=>{
            :memory=>"1024M"
          }
        }
      },
      :networks=>[
        {
          :name=>"default",
          :pod=>{}
        },
        {
          :multus=>{:networkName=>"ptp-conf"},
          :name=>"ptp"
        }
      ],
      :terminationGracePeriodSeconds=>0,
      :volumes=>[
        {
          :containerDisk=>{:image=>"registry:5000/kubevirt/fedora-cloud-container-disk-demo:devel"},
          :name=>"containerdisk"
        },
        {
          :cloudInitNoCloud=>{:userData=>"#!/bin/bash\necho \"fedora\" |passwd fedora --stdin\ndhclient eth1\n"},
          :name=>"cloudinitdisk"
        }
      ]
    },
    :status=>{
      :conditions=>[
        {
          :lastProbeTime=>nil,
          :lastTransitionTime=>nil,
          :status=>"True",
          :type=>"LiveMigratable"
        },
        {
          :lastProbeTime=>nil,
          :lastTransitionTime=>"2019-04-02T13:46:24Z",
          :status=>"True",
          :type=>"Ready"
        }
      ],
      :interfaces=>[
        {
          :ipAddress=>"10.244.1.14",
          :mac=>"0e:fc:6c:c3:20:ec",
          :name=>"default"
        },
        {
          :mac=>"4a:90:1c:2e:fe:d7",
          :name=>"ptp"
        }
      ],
      :migrationMethod=>"BlockMigration",
      :nodeName=>"node02",
      :phase=>"Running"
    }
  }
  Vminstance.parse object_to_hash(vm)
end
get_vnc_console_details(name, namespace) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_vnc_console_details.rb, line 24
def get_vnc_console_details(name, namespace)
end
list_networkattachmentdefs(_filters = {}) click to toggle source
# File lib/fog/kubevirt/compute/requests/list_networkattachmentdefs.rb, line 15
def list_networkattachmentdefs(_filters = {})
  if _filters == {}
    EntityCollection.new("NetworkAttachmentDefinition", "1080",
                         [{:namespace=>"default",
                           :name=>"ovs-foreman",
                           :resource_version=>"1080",
                           :uid=>"0e35b868-2464-11e9-93b4-525400c5a686",
                           :config=>"{ \"cniVersion\": \"0.3.1\",\"type\": \"ovs\",\"bridge\": \"foreman\" }"
                         }]
                        )
  end
end
list_nodes(_filters = {}) click to toggle source

TODO provide implementation

# File lib/fog/kubevirt/compute/requests/list_nodes.rb, line 14
def list_nodes(_filters = {})
end
list_persistentvolumes(_filters = {}) click to toggle source
# File lib/fog/kubevirt/compute/requests/list_persistentvolumes.rb, line 17
def list_persistentvolumes(_filters = {})
end
list_pvcs(_filters = {}) click to toggle source
# File lib/fog/kubevirt/compute/requests/list_pvcs.rb, line 17
def list_pvcs(_filters = {})
end
list_servers(_filters = {}) click to toggle source
# File lib/fog/kubevirt/compute/requests/list_servers.rb, line 27
def list_servers(_filters = {})
end
list_services(_filters = {}) click to toggle source
# File lib/fog/kubevirt/compute/requests/list_services.rb, line 17
def list_services(_filters = {})
end
list_storageclasses(_filters = {}) click to toggle source
# File lib/fog/kubevirt/compute/requests/list_storageclasses.rb, line 17
def list_storageclasses(_filters = {})
  if _filters == {}
    [{
      :name=>"local-storage",
      :resource_version=>"775504",
      :uid=>"c930bca9-5471-11e9-9132-525400c5a686",
      :parameters=>nil,
      :mount_options=>nil,
      :provisioner=>"kubernetes.io/no-provisioner",
      :reclaim_policy=>"Delete",
      :volume_binding_mode=>"WaitForFirstConsumer"
    }]
  end
end
list_templates(_filters = {}) click to toggle source
# File lib/fog/kubevirt/compute/requests/list_templates.rb, line 17
def list_templates(_filters = {})
  templates = [{ metadata: { name: 'linux-vm-template',
                             namespace: 'default',
                             selfLink: '/oapi/v1/namespaces/default/templates/linux-vm-template',
                             uid: '610c434f-17bc-11e8-a9f9-525400a7f647',
                             resourceVersion: '9240',
                             creationTimestamp: '2018-02-22T10:37:28Z',
                             labels: { :"miq.github.io/kubevirt-is-vm-template" => 'true',
                                       :"miq.github.io/kubevirt-os" => 'rhel-7' },
                                       annotations: { description: 'OCP kubevirt linux, template',
                                                      tags: 'kubevirt,ocp,template,linux' }
                           },
                                                      objects: [{ apiVersion: 'kubevirt.io/v1alpha2',
                                                                  kind: 'VirtualMachine',
                                                                  metadata: { name: '${NAME}' },
                                                                  spec: { template: { spec: { domain:
                                                                                              { cpu: { cores: '${CPU_CORES}' },
                                                                                                devices: { disks: [{ disk: { dev: 'vda' }, name: 'disk0', volumeName: 'disk0-pvc' }] },
                                                                                                machine: { type: 'q35' },
                                                                                                resources: { requests: { memory: '${MEMORY}' } } },
  volumes: [{ name: 'disk0-pvc', persistentVolumeClaim: { claimName: 'linux-vm-pvc-${NAME}' } }] } } } },
  { apiVersion: 'v1',
    kind: 'PersistentVolumeClaim',
    metadata: { name: 'linux-vm-pvc-${NAME}' },
    spec: { accessModes: ['ReadWriteOnce'],
            resources: { requests: { storage: '10Gi' } } } }],
  parameters: [{ name: 'NAME', description: 'Name for the new VM' },
               { name: 'MEMORY', description: 'Amount of memory', value: '4096Mi' },
               { name: 'CPU_CORES', description: 'Amount of cores', value: '4' }] }]
  object = RecursiveOpenStruct.new(templates, recurse_over_arrays: true)
  object.map { |kubevirt_obj| Template.parse object_to_hash(kubevirt_obj) }
end
list_vminstances(_filters = {}) click to toggle source

TODO provide implementation

# File lib/fog/kubevirt/compute/requests/list_vminstances.rb, line 16
def list_vminstances(_filters = {})
end
list_vms(_filters = {}) click to toggle source
# File lib/fog/kubevirt/compute/requests/list_vms.rb, line 22
def list_vms(_filters = {})
  vms = [{ apiVersion: 'kubevirt.io/v1alpha2',
           kind: 'VirtualMachine',
           metadata: {
             clusterName: '',
             creationTimestamp: '2018-02-21T11:15:41Z',
             name: 'aaa',
             namespace: 'default',
             resourceVersion: '967810',
             selfLink: '/apis/kubevirt.io/v1alpha2/namespaces/default/virtualmachines/aaa',
             uid: '8d27ad76-16f8-11e8-95dc-525400b2cba8'
           },
           spec: {
             template: {
               spec: { domain: { cpu: { cores: 4 },
                                 devices: { disks: [{ disk: { dev: 'vda' },
                                                      name: 'containerDisk',
                                                      volumeName: 'containervolume' },
                                                      { disk: { dev: 'vdb' },
                                                        name: 'cloudinitdisk',
                                                        volumeName: 'cloudinitvolume' }] },
                                                        machine: { type: 'q35' },
                                                        resources: { requests: { memory: '512Mi' } } },
                 volumes: [
                   { name: 'containervolume',
                     containerDisk: { image: 'kubevirt/fedora-cloud-registry-disk-demo:latest' }
                   },
                   { cloudInitNoCloud: { userDataBase64: 'I2Nsb3VkLWNvbmZpZwpwYXNzd29yZDogYXRvbWljCnNzaF9wd2F1dGg6IFRydWUKY2hwYXNzd2Q6IHsgZXhwaXJlOiBGYWxzZSB9Cg==' },
                     name: 'cloudinitvolume' }]
               }
             }
           }}]
  object = RecursiveOpenStruct.new(vms, recurse_over_arrays: true)
  object.map { |kubevirt_obj| Vm.parse object_to_hash(kubevirt_obj) }
end
list_volumes(vm_name = nil) click to toggle source
# File lib/fog/kubevirt/compute/requests/list_volumes.rb, line 25
def list_volumes(vm_name = nil)
end
update_vm(update) click to toggle source
# File lib/fog/kubevirt/compute/requests/update_vm.rb, line 11
def update_vm(update)
  update_args = {:apiVersion=>"kubevirt.io/v1alpha3",
                 :kind=>"VirtualMachine",
                 :metadata=>{:creationTimestamp=>"2019-04-06T14:05:15Z",
                             :generation=>1,
                             :labels=>{:"kubevirt.io/vm"=>"robin-rykert.example.com"},
                             :name=>"robin-rykert.example.com",
                             :namespace=>"default",
                             :resourceVersion=>"1020275",
                             :selfLink=>"/apis/kubevirt.io/v1alpha3/namespaces/default/virtualmachines/robin-rykert.example.com",
                             :uid=>"00ae63ee-5875-11e9-9132-525400c5a686"},
                             :spec=>{:running=>true,
                                     :template=>{:metadata=>{:creationTimestamp=>nil,
                                                             :labels=>{:"kubevirt.io/vm"=>"robin-rykert.example.com"}},
  :spec=>{:domain=>{:cpu=>{:cores=>1},
                    :devices=>{:disks=>[{:disk=>{:bus=>"virtio"},
                                         :name=>"robin-rykert-example-com-disk-00"},
                                         {:disk=>{:bus=>"virtio"},
                                          :name=>"robin-rykert-example-com-disk-01"}],
                                          :interfaces=>[{:bootOrder=>1,
                                                         :bridge=>{},
                                                         :macAddress=>"a2:b4:a2:b6:a2:a8",
                                                         :name=>"ovs-foreman"}]},
                                                         :machine=>{:type=>""},
                                                         :resources=>{:requests=>{:memory=>"1024M"}}},
  :networks=>[{:multus=>{:networkName=>"ovs-foreman"},
               :name=>"ovs-foreman"}],
               :terminationGracePeriodSeconds=>0,
               :volumes=>[{:name=>"robin-rykert-example-com-disk-00",
                           :persistentVolumeClaim=>{:claimName=>"robin-rykert-example-com-claim-1"}},
  {:name=>"robin-rykert-example-com-disk-01",
   :persistentVolumeClaim=>{:claimName=>"robin-rykert-example-com-claim-2"}}]}}}}
  if update == update_args
    result = Kubeclient::Resource.new
    result.apiVersion="kubevirt.io/v1alpha3"
    result.kind="VirtualMachine"
    result.metadata={:creationTimestamp=>"2019-04-06T14:05:15Z",
                     :generation=>2,
                     :labels=>{:"kubevirt.io/vm"=>"robin-rykert.example.com"},
                     :name=>"robin-rykert.example.com",
                     :namespace=>"default",
                     :resourceVersion=>"1020276",
                     :selfLink=>"/apis/kubevirt.io/v1alpha3/namespaces/default/virtualmachines/robin-rykert.example.com",
                     :uid=>"00ae63ee-5875-11e9-9132-525400c5a686"}
    result.spec={:running=>true,
                 :template=>{:metadata=>{:creationTimestamp=>nil,
                                         :labels=>{:"kubevirt.io/vm"=>"robin-rykert.example.com"}},
    :spec=>{:domain=>{:cpu=>{:cores=>1},
                      :devices=>{:disks=>[{:disk=>{:bus=>"virtio"},
                                           :name=>"robin-rykert-example-com-disk-00"},
                                           {:disk=>{:bus=>"virtio"},
                                            :name=>"robin-rykert-example-com-disk-01"}],
                                            :interfaces=>[{:bootOrder=>1,
                                                           :bridge=>{},
                                                           :macAddress=>"a2:b4:a2:b6:a2:a8",
                                                           :name=>"ovs-foreman"}]},
                                                           :machine=>{:type=>""},
                                                           :resources=>{:requests=>{:memory=>"1024M"}}},
    :networks=>[{:multus=>{:networkName=>"ovs-foreman"},
                 :name=>"ovs-foreman"}],
                 :terminationGracePeriodSeconds=>0,
                 :volumes=>[{:name=>"robin-rykert-example-com-disk-00",
                             :persistentVolumeClaim=>{:claimName=>"robin-rykert-example-com-claim-1"}},
    {:name=>"robin-rykert-example-com-disk-01",
     :persistentVolumeClaim=>{:claimName=>"robin-rykert-example-com-claim-2"}}]}}}
    return result
  end

  update_args_olive = {:apiVersion=>"kubevirt.io/v1alpha3",
                      :kind=>"VirtualMachine",
                      :metadata=>{:creationTimestamp=>"2019-04-07T15:00:07Z",
                                  :generation=>1,
                                  :labels=>{:"kubevirt.io/vm"=>"olive-kempter.example.com"},
                                  :name=>"olive-kempter.example.com",
                                  :namespace=>"default",
                                  :resourceVersion=>"1075555",
                                  :selfLink=>"/apis/kubevirt.io/v1alpha3/namespaces/default/virtualmachines/olive-kempter.example.com",
                                  :uid=>"d4dba9e4-5945-11e9-9132-525400c5a686"},
                                  :spec=>{:running=>true,
                                          :template=>{:metadata=>{:creationTimestamp=>nil,
                                                                  :labels=>{:"kubevirt.io/vm"=>"olive-kempter.example.com"}},
  :spec=>{:domain=>{:cpu=>{:cores=>1},
                    :devices=>{:disks=>[{:bootOrder=>1,
                                         :disk=>{:bus=>"virtio"},
                                         :name=>"olive-kempter-example-com-disk-00"},
                                         {:disk=>{:bus=>"virtio"},
                                          :name=>"olive-kempter-example-com-disk-01"}],
                                          :interfaces=>[{:bridge=>{},
                                                         :macAddress=>"a2:a4:a2:b2:a2:b6",
                                                         :name=>"ovs-foreman"}]},
                                                         :machine=>{:type=>""},
                                                         :resources=>{:requests=>{:memory=>"1024M"}}},
  :networks=>[{:multus=>{:networkName=>"ovs-foreman"},
               :name=>"ovs-foreman"}],
               :terminationGracePeriodSeconds=>0,
               :volumes=>[{:containerDisk=>{:image=>"kubevirt/fedora-cloud-registry-disk-demo"},
                           :name=>"olive-kempter-example-com-disk-00"},
                           {:name=>"olive-kempter-example-com-disk-01",
                            :persistentVolumeClaim=>{:claimName=>"olive-kempter-example-com-claim-1"}}]}}}}

  if update == update_args_olive
    result = Kubeclient::Resource.new
    result.apiVersion="kubevirt.io/v1alpha3"
    result.kind="VirtualMachine"
    result.metadata={:creationTimestamp=>"2019-04-07T15:00:07Z",
                     :generation=>2,
                     :labels=>{:"kubevirt.io/vm"=>"olive-kempter.example.com"},
                     :name=>"olive-kempter.example.com",
                     :namespace=>"default",
                     :resourceVersion=>"1075556",
                     :selfLink=>"/apis/kubevirt.io/v1alpha3/namespaces/default/virtualmachines/olive-kempter.example.com",
                     :uid=>"d4dba9e4-5945-11e9-9132-525400c5a686"}
    result.spec={:running=>true,
                 :template=>{:metadata=>{:creationTimestamp=>nil,
                                         :labels=>{:"kubevirt.io/vm"=>"olive-kempter.example.com"}},
    :spec=>{:domain=>{:cpu=>{:cores=>1},
                      :devices=>{:disks=>[{:bootOrder=>1,
                                           :disk=>{:bus=>"virtio"},
                                           :name=>"olive-kempter-example-com-disk-00"},
                                           {:disk=>{:bus=>"virtio"},
                                            :name=>"olive-kempter-example-com-disk-01"}],
                                            :interfaces=>[{:bridge=>{},
                                                           :macAddress=>"a2:a4:a2:b2:a2:b6",
                                                           :name=>"ovs-foreman"}]},
                                                           :machine=>{:type=>""},
                                                           :resources=>{:requests=>{:memory=>"1024M"}}},
    :networks=>[{:multus=>{:networkName=>"ovs-foreman"},
                 :name=>"ovs-foreman"}],
                 :terminationGracePeriodSeconds=>0,
                 :volumes=>[{:containerDisk=>{:image=>"kubevirt/fedora-cloud-registry-disk-demo"},
                             :name=>"olive-kempter-example-com-disk-00"},
                             {:name=>"olive-kempter-example-com-disk-01",
                              :persistentVolumeClaim=>{:claimName=>"olive-kempter-example-com-claim-1"}}]}}}
    return result
  end
end
vm_nic(mac_address: "", network: "ovs-foreman") click to toggle source
# File lib/fog/kubevirt/compute/requests/get_server.rb, line 72
def vm_nic(mac_address: "", network: "ovs-foreman")
  vm_nic = Fog::Kubevirt::Compute::VmNic.new
  vm_nic.mac_address = mac_address
  vm_nic.type = "bridge"
  vm_nic.network = network
  vm_nic.model = nil
  vm_nic.ports = nil
  vm_nic.boot_order = nil
  vm_nic
end
volume(name: "", type: "persistentVolumeClaim", info: "", pvc: nil, config: {}, boot_order: nil, bus: nil) click to toggle source
# File lib/fog/kubevirt/compute/requests/get_server.rb, line 50
def volume(name: "", type: "persistentVolumeClaim", info: "", pvc: nil, config: {}, boot_order: nil, bus: nil)
  volume = Fog::Kubevirt::Compute::Volume.new
  volume.name = name
  volume.type = type
  volume.info = info
  volume.pvc = pvc
  volume.config = config
  volume.boot_order = boot_order
  volume.bus = bus
  volume
end