Module: Fog::Kubevirt::Compute::VmParser

Included in:
VmBase, Vminstance
Defined in:
lib/fog/kubevirt/compute/models/vm_parser.rb

Instance Method Summary collapse

Instance Method Details

#parse_disks(object) ⇒ Object

Returns an array of parsed disks

Parameters:

  • object (Hash) —

    A hash with raw disks data.



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/fog/kubevirt/compute/models/vm_parser.rb', line 67

def parse_disks(object)
  return [] if object.nil?
  disks = []
  object.each do |d|
    disk = VmData::VmDisk.new
    disk.name = d[:name]
    disk.boot_order = d[:bootOrder]

    if d.keys.include?(:cdrom)
      disk.type = 'cdrom'
      disk.bus = d.dig(:cdrom, :bus)
      disk.readonly = d.dig(:cdrom, :readonly)
    elsif d.keys.include?(:disk)
      disk.type = 'disk'
      disk.bus = d.dig(:disk, :bus)
      disk.readonly = d.dig(:disk, :readonly)
    elsif d.keys.include?(:floppy)
      disk.type = 'floppy'
      disk.readonly = d.dig(:floppy, :readonly)
    elsif d.keys.include?(:lun)
      disk.type = 'lun'
      disk.readonly = d.dig(:lun, :readonly)
    end
    disks << disk
  end

  disks
end

#parse_interfaces(object, object_status, networks) ⇒ Object

Returns an array of parsed network interfaces

Parameters:

  • object (Hash) —

    A hash with raw interfaces data.



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/fog/kubevirt/compute/models/vm_parser.rb', line 15

def parse_interfaces(object, object_status, networks)
  return [] if object.nil?
  nics = []
  object.each do |iface|
    nic = VmNic.new
    nic.name = iface[:name]
    status_iface = object_status.find { |hash| hash[:name] == iface[:name] } unless object_status.nil?
    # get mac address from status and use device definition if not available
    nic.mac_address = !status_iface.nil? && status_iface.key?(:mac) ? status_iface[:mac] : iface[:macAddress]
    nic.type = 'bridge' if iface.keys.include?(:bridge)
    nic.type = 'slirp' if iface.keys.include?(:slirp)

    net = networks.detect { |n| n.name == iface[:name] }
    if net
      nic.cni_provider = net.type
      nic.network = net.network_name
    end

    nics << nic
  end

  nics
end

#parse_networks(object) ⇒ Object

Returns an array of parsed networks

Parameters:

  • object (Hash) —

    A hash with raw networks data.



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/fog/kubevirt/compute/models/vm_parser.rb', line 44

def parse_networks(object)
  return [] if object.nil?
  networks = []
  object.each do |net|
    network = VmData::VmNetwork.new
    network.name = net[:name]
    network.type = 'pod' if net.keys.include?(:pod)
    if net.keys.include?(:multus)
      network.type = 'multus'
      network.network_name = net[:multus][:networkName]
    end
    network.type = 'genie' if net.keys.include?(:genie)
    networks << network
  end

  networks
end

#parse_volumes(object, disks) ⇒ Object

Returns an array of parsed volumes

Parameters:

  • object (Hash) —

    A hash with raw volumes data.

  • disks (Array) —

    the disks of the vm associated to the volumes



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/fog/kubevirt/compute/models/vm_parser.rb', line 102

def parse_volumes(object, disks)
  return [] if object.nil?
  volumes = []
  object.each do |v|
    volume = Volume.new
    volume.name = v[:name]
    if v.keys.include?(:containerDisk)
      volume.type = 'containerDisk'
      volume.info = v.dig(:containerDisk, :image)
    elsif v.keys.include?(:persistentVolumeClaim)
      volume.type = 'persistentVolumeClaim'
      volume.info = v.dig(:persistentVolumeClaim, :claimName)
    elsif v.keys.include?(:emptyDisk)
      volume.type = 'emptyDisk'
      volume.info = v.dig(:emptyDisk, :capacity)
    elsif v.keys.include?(:ephemeral)
      volume.type = 'ephemeral'
      volume.info = v.dig(:ephemeral, :persistentVolumeClaim, :claimName)
    elsif v.keys.include?(:cloudInitNoCloud)
      volume.type = 'cloudInitNoCloud'
      volume.info = v.dig(:cloudInitNoCloud, :userDataBase64)
    elsif v.keys.include?(:hostDisk)
      volume.type = 'hostDisk'
      volume.info = v.dig(:hostDisk, :path)
    elsif v.keys.include?(:secret)
      volume.type = 'secret'
      volume.info = v.dig(:secret, :secretName)
    elsif v.keys.include?(:dataVolume)
      volume.type = 'dataVolume'
      volume.info = v.dig(:dataVolume, :name)
    elsif v.keys.include?(:serviceAccount)
      volume.type = 'serviceAccount'
      volume.info = v.dig(:serviceAccount, :serviceAccountName)
    elsif v.keys.include?(:configMap)
      volume.type = 'configMap'
      volume.info = v.dig(:configMap, :name)
    end

    volume.config = v[volume.type.to_sym]
    disk = disks.detect { |d| d.name == volume.name }
    volume.boot_order = disk.boot_order if disk.respond_to?(:boot_order)
    volume.bus = disk.bus if disk.respond_to?(:bus)

    volumes << volume
  end

  volumes
end