Module: ProxmoxServerHelper

Included in:
ForemanFogProxmox::Proxmox
Defined in:
app/helpers/proxmox_server_helper.rb

Constant Summary collapse

KILO = 
1024
MEGA = 
KILO * KILO
GIGA = 
KILO * MEGA

Instance Method Summary collapse

Instance Method Details

#add_server_interface(interface_attributes, interfaces_to_delete, interfaces_to_add) ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'app/helpers/proxmox_server_helper.rb', line 137

def add_server_interface(interface_attributes, interfaces_to_delete, interfaces_to_add)
  interface_attributes.delete_if { |_key,value| ForemanFogProxmox::Value.empty?(value) }
  nic = {}
  id = interface_attributes['id']
  logger.debug("add_server_interface(): id=#{id}")
  delete = interface_attributes['_delete'].to_i == 1
  if delete
    interfaces_to_delete.push(id.to_s)
  else
    nic.store(:id, id)
    nic.store(:macaddr, interface_attributes['macaddr']) if interface_attributes['macaddr']
    nic.store(:tag, interface_attributes['tag'].to_i) if interface_attributes['tag']
    nic.store(:model, interface_attributes['model'].to_s)
    nic.store(:bridge, interface_attributes['bridge'].to_s) if interface_attributes['bridge']
    nic.store(:firewall, interface_attributes['firewall'].to_i) if interface_attributes['firewall']
    nic.store(:rate, interface_attributes['rate'].to_i) if interface_attributes['rate']
    nic.store(:link_down, interface_attributes['link_down'].to_i) if interface_attributes['link_down']
    nic.store(:queues, interface_attributes['queues'].to_i) if interface_attributes['queues']
    logger.debug("add_server_interface(): add nic=#{nic}")
    interfaces_to_add.push(Fog::Proxmox::NicHelper.flatten(nic))
  end
end

#parse_server_cdrom(args) ⇒ Object 



96
97
98
99
100
101
102
103
 
# File 'app/helpers/proxmox_server_helper.rb', line 96

def parse_server_cdrom(args)
  cdrom = args['cdrom']
  cdrom_image = args['cdrom_iso']
  volid = cdrom_image.empty? ? cdrom : cdrom_image
  return {} unless volid
  cdrom = "#{volid},media=cdrom"
  {ide2: cdrom}
end

#parse_server_cpu(args) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'app/helpers/proxmox_server_helper.rb', line 80

def parse_server_cpu(args)
  return {} unless args['cpu_type']
  cpu = "cputype=#{args['cpu_type']}"
  spectre = args['spectre'].to_i == 1
  pcid = args['pcid'].to_i == 1
  cpu += ",flags=" if spectre || pcid
  cpu += "+spec-ctrl" if spectre
  cpu += ";" if spectre && pcid
  cpu += "+pcid" if pcid      
  args.delete_if { |key,value| %w[cpu_type spectre pcid].include?(key) || ForemanFogProxmox::Value.empty?(value) }
  args.each_value { |value| value.to_i }
  parsed_cpu = { cpu: cpu }.merge(args)
  logger.debug("parse_server_cpu(): #{parsed_cpu}")
  parsed_cpu
end

#parse_server_interfaces(interfaces_attributes) ⇒ Object 



129
130
131
132
133
134
135
 
# File 'app/helpers/proxmox_server_helper.rb', line 129

def parse_server_interfaces(interfaces_attributes)
  interfaces_to_add = []
  interfaces_to_delete = []
  interfaces_attributes.each_value { |value| add_server_interface(value,interfaces_to_delete,interfaces_to_add)} if interfaces_attributes
  logger.debug("parse_server_interfaces(): interfaces_to_delete=#{interfaces_to_delete} interfaces_to_add=#{interfaces_to_add}")
  [interfaces_to_add, interfaces_to_delete]
end

#parse_server_memory(args) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'app/helpers/proxmox_server_helper.rb', line 67

def parse_server_memory(args)
  memory = { }
  memory.store(:memory,args['memory'].to_i) if args['memory']
  ballooned = args['balloon'].to_i == 1
  if ballooned
    memory.store(:shares,args['shares'].to_i) if args['shares']
    memory.store(:min_memory,args['min_memory'].to_i) if args['min_memory']
  end
  memory.store(:balloon,args['balloon'].to_i) if args['balloon']
  logger.debug("parse_server_memory(): #{memory}")
  memory
end

#parse_server_vm(args) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'app/helpers/proxmox_server_helper.rb', line 30

def parse_server_vm(args)
  logger.debug("parse_server_vm args=#{args}")
  args = ActiveSupport::HashWithIndifferentAccess.new(args)
  return {} unless args
  return {} if args.empty?
  return {} unless args['type'] == 'qemu'
  config = args['config_attributes']
  main_a = %w[name type node_id vmid interfaces mount_points disks]
  config = args.reject { |key,_value| main_a.include? key } unless config
  cdrom_a = %w[cdrom cdrom_storage cdrom_iso]
  cdrom = parse_server_cdrom(config.select { |key,_value| cdrom_a.include? key })
  vols = args['volumes_attributes']
  volumes = parse_server_volumes(vols)
  cpu_a = %w[cpu_type spectre pcid]
  cpu = parse_server_cpu(config.select { |key,_value| cpu_a.include? key })
  memory_a = %w[memory min_memory balloon shares]
  memory = parse_server_memory(config.select { |key,_value| memory_a.include? key })
  interfaces_attributes = args['interfaces_attributes']
  interfaces_to_add, interfaces_to_delete = parse_server_interfaces(interfaces_attributes)
  general_a = %w[node_id type config_attributes volumes_attributes interfaces_attributes firmware_type provision_method container_volumes server_volumes]
  logger.debug("general_a: #{general_a}")
  parsed_vm = args.reject { |key,value| general_a.include?(key) || ForemanFogProxmox::Value.empty?(value) }
  config_a = []
  config_a += cpu_a
  config_a += cdrom_a
  config_a += memory_a
  config_a += general_a
  parsed_config = config.reject { |key,value| config_a.include?(key) || ForemanFogProxmox::Value.empty?(value) }
  logger.debug("parse_server_config(): #{parsed_config}")
  parsed_vm = parsed_vm.merge(parsed_config).merge(cpu).merge(memory).merge(cdrom)
  interfaces_to_add.each { |interface| parsed_vm = parsed_vm.merge(interface) }
  parsed_vm = parsed_vm.merge(delete: interfaces_to_delete.join(',')) unless interfaces_to_delete.empty?
  volumes.each { |volume| parsed_vm = parsed_vm.merge(volume) }
  logger.debug("parse_server_vm(): #{parsed_vm}")
  parsed_vm
end

#parse_server_volume(args) ⇒ Object 



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'app/helpers/proxmox_server_helper.rb', line 105

def parse_server_volume(args)
  disk = {}
  id = args['id']
  id = "#{args['controller']}#{args['device']}" if args.has_key?('controller') && args.has_key?('device') && !id
  return args if ForemanFogProxmox::Value.empty?(id) || id == 'rootfs'
  delete = args['_delete'].to_i == 1
  args.delete_if { |_key,value| ForemanFogProxmox::Value.empty?(value) }
  disk.store(:id, id)
  disk.store(:volid, args['volid']) if args.has_key?('volid')
  disk.store(:storage, args['storage'].to_s) if args.has_key?('storage')
  disk.store(:size, args['size'].to_i) if args.has_key?('size')
  options = args.reject { |key,_value| %w[id volid controller device storage size _delete].include? key}
  disk.store(:options, options)
  logger.debug("parse_server_volume(): disk=#{disk}")
  Fog::Proxmox::DiskHelper.flatten(disk)
end

#parse_server_volumes(args) ⇒ Object 



122
123
124
125
126
127
 
# File 'app/helpers/proxmox_server_helper.rb', line 122

def parse_server_volumes(args)
  volumes = []
  args.each_value { |value| volumes.push(parse_server_volume(value))} if args
  logger.debug("parse_server_volumes(): volumes=#{volumes}")
  volumes
end