def setup(self, parms):
try:
vcenter_complex = self.getScriptValue('foundation',
'vcenter_complex')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation vcenter_complex: {0}'.format(e))
self.connection_paramaters = vcenter_complex.connection_paramaters
self.datacenter = vcenter_complex.vcenter_datacenter
self.cluster = vcenter_complex.vcenter_cluster
for key in ('min_memory', 'min_cpu'): # memory in MB
try:
setattr(self, key, int(parms[key]))
except KeyError:
raise ParamaterError(key, 'required')
except (ValueError, TypeError):
raise ParamaterError(key, 'must be an integer')
for key in ('cpu_scaler', 'memory_scaler'):
try:
setattr(self, key, int(parms.get(key, 1)))
except (ValueError, TypeError):
raise ParamaterError(key, 'must be an integer')
def setup(self, parms):
try:
proxmox_complex = self.getScriptValue('foundation',
'proxmox_complex')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation proxmox_complex: {0}'.format(e))
self.connection_paramaters = proxmox_complex.connection_paramaters
# TODO: also add IO Delay - % of time spent waiting for io
for key in ('min_memory', 'min_cores'): # memory in MB
try:
setattr(self, key, int(parms[key]))
except KeyError:
raise ParamaterError(key, 'required')
except (ValueError, TypeError):
raise ParamaterError(key, 'must be an integer')
for key in ('cpu_scaler', 'memory_scaler', 'io_scaler'):
try:
setattr(self, key, int(parms.get(key, 1)))
except (ValueError, TypeError):
raise ParamaterError(key, 'must be an integer')
def setup(self, parms):
try:
vcenter_complex = self.getScriptValue('foundation',
'vcenter_complex')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation vcenter_complex: {0}'.format(e))
self.connection_paramaters = vcenter_complex.connection_paramaters
self.datacenter = vcenter_complex.vcenter_datacenter
try:
self.host = self.getScriptValue('config', 'vcenter_hostname')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation vcenter_hostname: {0}'.format(e))
try:
self.name = parms['name']
except AttributeError as e:
raise ParamaterError('name', 'required')
try:
self.model = parms['model']
except AttributeError as e:
raise ParamaterError('model', 'required')
def setup(self, parms):
try:
vcenter_complex = self.getScriptValue('foundation',
'vcenter_complex')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation vcenter_complex: {0}'.format(e))
self.connection_paramaters = vcenter_complex.connection_paramaters
self.datacenter = vcenter_complex.vcenter_datacenter
self.cluster = vcenter_complex.vcenter_cluster
try:
self.host = parms.get('host')
except AttributeError as e:
raise ParamaterError('host', 'Required')
try:
self.min_free_space = int(parms.get('min_free_space')) # in GB
except KeyError:
raise ParamaterError('min_free_space', 'required')
except (ValueError, TypeError):
raise ParamaterError('min_free_space', 'must be an integer')
self.name_regex = parms.get('name_regex', None)
def setup( self, parms ):
try:
instance_type = self.getScriptValue( 'config', 'awsec2_type' )
except ValueError as e:
raise ParamaterError( '<internal>', 'Unable to get awsec2_type: {0}'.format( e ) )
try:
image_id = self.getScriptValue( 'config', 'awsec2_image_id' )
except ValueError as e:
raise ParamaterError( '<internal>', 'Unable to get awsec2_image_id: {0}'.format( e ) )
try:
name = self.getScriptValue( 'foundation', 'locator' )
except ValueError as e:
raise ParamaterError( '<internal>', 'Unable to get Foundation Locator: {0}'.format( e ) )
if not NAME_REGEX.match( name ):
raise ParamaterError( '<internal>', 'invalid name (ie: Foundation Locator)' )
self.instance_paramaters = {
'name': name,
'image_id': image_id,
'instance_type': instance_type,
'interface_list': [ { 'name': 'public' } ] # name is name of network to attach to
}
def setup( self, parms ):
try:
self.target = parms[ 'target' ]
except KeyError:
raise ParamaterError( 'target', 'required' )
try:
self.port = int( parms[ 'port' ] )
except ( ValueError, TypeError, KeyError ):
raise ParamaterError( 'count', 'is required and must be an integer' )
def setup( self, parms ):
try:
self.target = parms[ 'target' ]
except KeyError:
raise ParamaterError( 'target', 'required' )
try:
self.count = int( parms.get( 'count', 5 ) )
except ( ValueError, TypeError ):
raise ParamaterError( 'count', 'must be an integer' )
def setup(self, parms):
try:
self.count_by = int(parms['count_by'])
except (KeyError, ValueError):
raise ParamaterError('count_by', 'not provided or is not an int')
try:
self.stop_at = int(parms['stop_at'])
except (KeyError, ValueError):
raise ParamaterError('stop_at', 'not provided or is not an int')
def __call__( self, interface_list ):
for interface in interface_list:
try:
iface = self.foundation.interfaces.get( name=interface[ 'name' ] )
except ObjectDoesNotExist:
raise ParamaterError( 'interface_list', 'interface named "{0}" not found'.format( interface[ 'name' ] ) )
iface.mac = interface[ 'mac' ]
try:
iface.full_clean()
except ValidationError as e:
raise ParamaterError( 'interface_list', 'Error saving interface "{0}": {1}'.format( interface[ 'name' ], e ) )
iface.save()
def setup(self, parms):
_snmpSetup(self, parms)
try:
self.new_value = parms['value']
except KeyError:
raise ParamaterError('value', 'required')
def setup(self, parms):
try:
self.as_template = bool(parms.get('as_template', True))
except ValueError:
raise ParamaterError('as_template', 'must be boolean')
except KeyError:
pass
def _snmpSetup(obj, parms):
try:
obj.host = parms['host']
except KeyError:
raise ParamaterError('host', 'required')
if obj.host is None:
raise ParamaterError('host', 'is None')
try:
obj.protocol = parms['protocol']
if obj.protocol not in ('SNMPv1', 'SNMPv2c', 'SNMPv3'):
raise ParamaterError('protocol', 'invalid')
except KeyError:
obj.protocol = 'SNMPv2c'
creds = {}
if obj.protocol == 'SNMPv3':
try:
creds['user'] = parms['user']
except KeyError:
raise ParamaterError('user', 'required')
if creds['user'] is None:
raise ParamaterError('user', 'is None')
for name in ('auth_key', 'priv_key'):
try:
creds[name] = parms[name]
except KeyError:
pass
else:
try:
creds['community'] = parms['community']
except KeyError:
raise ParamaterError('community', 'required')
if creds['community'] is None:
raise ParamaterError('community', 'is None')
obj.creds = creds
try:
obj.oid = parms['oid']
except KeyError:
raise ParamaterError('oid', 'required')
if obj.oid is None:
raise ParamaterError('oid', 'is None')
def setup(self, parms):
for name in ('username', 'password', 'command'):
try:
setattr(self, name, parms[name])
except KeyError:
raise ParamaterError(name, 'required')
try:
self.dir = parms['dir']
except KeyError:
pass
for name in ('timeout', 'expected_rc'):
try:
setattr(self, name, int(parms[name]))
except ValueError:
raise ParamaterError(name, 'must be valid integer')
except KeyError:
pass
def setup(self, parms):
try:
vcenter_complex = self.getScriptValue('foundation',
'vcenter_complex')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation vcenter_complex: {0}'.format(e))
self.connection_paramaters = vcenter_complex.connection_paramaters
self.datacenter = vcenter_complex.vcenter_datacenter
self.cluster = vcenter_complex.vcenter_cluster
try:
self.host = parms.get('host')
except AttributeError as e:
raise ParamaterError('host', 'Required')
self.name_regex = parms.get('name_regex', None)
def __call__(self, interface_map):
for physical_location in interface_map:
try:
iface = self.foundation.networkinterface_set.get(
physical_location=physical_location)
except ObjectDoesNotExist:
raise ParamaterError(
'interface_map',
'interface at "{0}" not found'.format(physical_location))
iface.mac = interface_map[physical_location]
try:
iface.full_clean()
except ValidationError as e:
raise ParamaterError(
'interface_map',
'Error saving interface "{0}": {1}'.format(
physical_location, e))
iface.save()
def __call__( self, name, value ):
path = [ int( i ) if i.isdigit() else i for i in name.split( '.' ) ]
name = path.pop( 0 )
if not config_name_regex.match( name ):
raise ParamaterError( 'name', 'invalid' )
config_values = self.structure.config_values
if name not in config_values:
raise ParamaterError( 'name', '"{0}" not found'.format( name ) )
while path:
if not isinstance( config_values, ( dict, list ) ):
raise ParamaterError( 'name', '"{0}" at non indexable level'.format( name ) )
try:
config_values = config_values[ name ]
except ( KeyError, IndexError ):
raise ParamaterError( 'name', '"{0}" not found'.format( name ) )
name = path.pop( 0 )
if not isinstance( config_values, ( dict, list ) ):
raise ParamaterError( 'name', '"{0}" at non indexable level'.format( name ) )
if name not in config_values:
raise ParamaterError( 'name', '"{0}" not found'.format( name ) )
config_values[ name ] = value
self.structure.full_clean()
self.structure.save( update_fields=[ 'config_values' ] )
def setup(self, parms):
try:
pxe_name = parms['pxe']
except KeyError:
raise ParamaterError('pxe', 'required')
try:
interface = parms['interface']
except KeyError:
raise ParamaterError('interface', 'required')
if interface is None:
raise ParamaterError('interface', 'can not be None')
try:
pxe = PXE.objects.get(name=pxe_name)
except PXE.DoesNotExist:
raise ParamaterError('pxe', 'pxe "{0}" not found'.format(pxe_name))
interface.pxe = pxe
interface.full_clean()
interface.save()
def setup(self, parms):
try:
container_spec = parms['container_spec']
except KeyError:
raise ParamaterError('container_spec', 'required')
try:
port_map = parms['port_map']
except KeyError:
raise ParamaterError('port_map', 'required')
try:
name = self.getScriptValue('foundation', 'locator')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation Locator: {0}'.format(e))
if not NAME_REGEX.match(name):
raise ParamaterError('<internal>',
'invalid name (ie: Foundation Locator)')
try:
docker_complex = self.getScriptValue('foundation',
'docker_complex')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation docker_complex: {0}'.format(e))
self.connection_paramaters = docker_complex.connection_paramaters
self.docker_paramaters = {
'name': name,
'docker_image': container_spec['image'],
'port_map': port_map,
'environment_map': container_spec.get('environment_map', {}),
'command': container_spec.get('command', None)
}
def __call__(self, ip_address_map):
for interface, ip_address in ip_address_map.items():
address_block, address_offset = ipAddress2Native(ip_address)
try:
addr = Address.objects.get(networked=self.foundation.structure,
interface_name=interface)
except ObjectDoesNotExist:
raise ParamaterError(
'ip_address_map',
'Address for interface "{0}" does not exist'.format(
interface))
addr.offset = address_offset
addr.address_block = address_block
try:
addr.full_clean()
except ValidationError as e:
raise ParamaterError(
'ip_address_map',
'Error Saving ip Address "{0}": {1}'.format(interface, e))
addr.save()
def setup(self, parms):
try:
foundation = self.getScriptValue('foundation', 'foundation')
except ValueError as e:
raise ParamaterError('<internal>',
'Unable to get Foundation: {0}'.format(e))
try:
vcenter_complex = self.getScriptValue('foundation',
'vcenter_complex')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation vcenter_complex: {0}'.format(e))
self.connection_paramaters = vcenter_complex.connection_paramaters
self.vm_paramaters = {}
self.vm_paramaters['datacenter'] = vcenter_complex.vcenter_datacenter
self.vm_paramaters['cluster'] = vcenter_complex.vcenter_cluster
try:
self.vm_paramaters['name'] = self.getScriptValue(
'foundation', 'locator')
except KeyError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation Locator: {0}'.format(e))
if not NAME_REGEX.match(self.vm_paramaters['name']):
raise ParamaterError('invalid name')
for key in ('host', 'datastore'):
try:
self.vm_paramaters[key] = parms[key]
except KeyError:
raise ParamaterError(key, 'required')
try:
vm_spec = parms['vm_spec']
except KeyError:
raise ParamaterError('vm_spec', 'required')
if not isinstance(vm_spec, dict):
raise ParamaterError('vm_spec', 'must be a dict')
# for now we will cary on CPU, Memeory, for OVAs evntually something will pull this info from the OVA
for key in ('cpu_count', 'memory_size'):
try:
self.vm_paramaters[key] = int(vm_spec[key])
except KeyError:
raise ParamaterError('vm_spec.{0}'.format(key), 'required')
except (ValueError, TypeError):
raise ParamaterError('vm_spec.{0}'.format(key),
'must be an integer')
if self.vm_paramaters['cpu_count'] > 64 or self.vm_paramaters[
'cpu_count'] < 1:
raise ParamaterError('cpu_count', 'must be from 1 to 64')
if self.vm_paramaters['memory_size'] > 1048510 or self.vm_paramaters[
'memory_size'] < 512: # in MB
raise ParamaterError('memory_size', 'must be from 512 to 1048510')
# is this an OVA, if so, short cut, just deploy it
ova = vm_spec.get('ova', None)
if ova is not None:
self.vm_paramaters['ova'] = ova
self.vm_paramaters['boot_order'] = ['hdd']
try:
self.vm_paramaters['disk_provisioning'] = vm_spec[
'disk_provisioning']
except KeyError:
pass
for key in ('vcenter_property_map', 'vcenter_deployment_option',
'vcenter_ip_protocol'):
try:
self.vm_paramaters[key[8:]] = vm_spec[key]
except KeyError:
pass
interface_list = []
for interface in foundation.networkinterface_set.all().order_by(
'physical_location'):
interface_list.append({
'name': interface.name,
'physical_location': interface.physical_location,
'network': interface.network.name
})
self.vm_paramaters['interface_list'] = interface_list
return
# is this an template deploy, if so, short cut, just deploy it
template = vm_spec.get('template', None)
if template is not None:
self.vm_paramaters['template'] = template
self.vm_paramaters['boot_order'] = ['hdd']
for key in ('vcenter_hostname', 'vcenter_domain',
'vcenter_dnsserver_list', 'vcenter_dnssuffix_list',
'vcenter_property_map'):
try:
self.vm_paramaters[key[8:]] = vm_spec[key]
except KeyError:
pass
interface_list = []
for interface in foundation.networkinterface_set.all().order_by(
'physical_location'):
address = interface.config['address_list'][0]
item = {
'name': interface.name,
'physical_location': interface.physical_location,
'network': interface.network.name
}
item['address'] = address['address']
item['netmask'] = address['netmask']
if address['gateway'] is not None:
item['gateway'] = address['gateway']
interface_list.append(item)
self.vm_paramaters['interface_list'] = interface_list
return
# not OVA/Template do scratch
try:
interface_type = vm_spec['vcenter_network_interface_class']
except KeyError:
interface_type = 'E1000'
interface_list = []
for interface in foundation.networkinterface_set.all().order_by(
'physical_location'):
interface_list.append({
'name': interface.name,
'physical_location': interface.physical_location,
'network': interface.network.name,
'type': interface_type
})
self.vm_paramaters['disk_list'] = [
{
'size': vm_spec.get('disk_size', 10),
'name': 'sda',
'type': vm_spec.get('disk_provisioning', 'thin')
}
] # disk size in G, see _createDisk in subcontractor_plugsin/vcenter/lib.py
self.vm_paramaters['interface_list'] = interface_list
self.vm_paramaters['boot_order'] = [
'net', 'hdd'
] # list of 'net', 'hdd', 'cd', 'usb'
if False: # boot from iso instead
self.vm_paramaters['disk_list'].append({
'name':
'cd',
'file':
'/home/peter/Downloads/ubuntu-16.04.2-server-amd64.iso'
})
self.vm_paramaters['boot_order'] = ['cd', 'net', 'hdd']
for key in ('vcenter_guest_id', 'vcenter_virtual_exec_usage',
'vcenter_virtual_mmu_usage', 'vcenter_virtual_vhv',
'vcenter_property_map'):
try:
self.vm_paramaters[key[8:]] = vm_spec[key]
except KeyError:
pass
def setup(self, parms):
try:
foundation = self.getScriptValue('foundation', 'foundation')
except ValueError as e:
raise ParamaterError('<internal>',
'Unable to get Foundation: {0}'.format(e))
try:
azure_complex = self.getScriptValue('foundation', 'azure_complex')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation azure_complex: {0}'.format(e))
self.connection_paramaters = azure_complex.connection_paramaters
self.resource_group = azure_complex.azure_resource_group
self.location = azure_complex.azure_location
try:
vm_name = self.getScriptValue('foundation', 'locator')
except KeyError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation Locator: {0}'.format(e))
if not NAME_REGEX.match(vm_name):
raise ParamaterError('<internal>',
'invalid name (ie: Foundation Locator)')
try:
vm_spec = parms['vm_spec']
except KeyError:
raise ParamaterError('vm_spec', 'required')
if not isinstance(vm_spec, dict):
raise ParamaterError('vm_spec', 'must be a dict')
self.vm_paramaters = {}
self.vm_paramaters['name'] = vm_name
interface_list = []
for interface in foundation.networkinterface_set.all().order_by(
'physical_location'):
nic_name = '{0}-{1}'.format(vm_name, interface.name)
config_list = []
counter = 0
for address in interface.config['address_list']:
config_list.append({
'name':
'{0}-ipconfig-{1}'.format(nic_name, counter),
'address':
address['address']
})
counter += 1
interface_list.append({
'name': '{0}-nic'.format(nic_name),
'network': interface.network.name,
'config_list': config_list
})
self.vm_paramaters['interface_list'] = interface_list
self.vm_paramaters['admin'] = {
'username': vm_spec['azure_admin_username'],
'password': vm_spec['azure_admin_password']
}
for key in ('azure_size', 'azure_image'):
try:
self.vm_paramaters[key[6:]] = vm_spec[key]
except KeyError:
pass
if 'image' in self.vm_paramaters and set(
self.vm_paramaters['image'].keys()) != set(
['publisher', 'offer', 'sku', 'version']):
raise ValueError('azure_image defination is invalid')
def setup(self, parms):
try:
self._value = int(parms['value'])
except (KeyError, ValueError):
raise ParamaterError('value', 'not provided or is not an int')
def setup(self, parms):
try:
foundation_id = self.getScriptValue('foundation', 'id')
except ValueError as e:
raise ParamaterError('<internal>',
'Unable to get Foundation Id: {0}'.format(e))
try:
name = self.getScriptValue('foundation', 'locator')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation Locator: {0}'.format(e))
if not NAME_REGEX.match(name):
raise ParamaterError('<internal>',
'invalid name (ie: Foundation Locator)')
try:
cpu_count = self.getScriptValue('config', 'cpu_count')
except ValueError as e: # TODO: would be nice to log a warning here
cpu_count = 1
try:
cpu_count = int(cpu_count)
except TypeError:
raise ParamaterError('<internal>', 'cpu count must be integer')
if cpu_count > 64 or cpu_count < 1:
raise ParamaterError('cpu_count', 'cpu_count must be from 1 to 64')
try:
memory_size = self.getScriptValue('config', 'memory_size')
except ValueError as e: # TODO: would be nice to log a warning here
memory_size = 512
try:
memory_size = int(memory_size)
except TypeError:
raise ParamaterError('<internal>', 'cpu count must be integer')
if memory_size > 1048510 or memory_size < 512:
raise ParamaterError('memory_size', 'must be from 512 to 1048510')
mac = '080027{0:06x}'.format(
(4 *
foundation_id)) # leaving room for 4 interfaces per foundation
self.vm_paramaters = {
'name': name,
'cpu_count': cpu_count,
'memory_size': memory_size, # in Meg
'disk_list': [{
'name': 'sda',
'size': 5
}], # disk size in G
'interface_list': [
{
'type': 'host',
'name': 'vboxnet0',
'mac': mac
}
], # type one of 'host', 'bridge', 'nat', 'internal', name is name of network to attach to, max 4 interfaces
'boot_order': ['net', 'hdd'] # list of 'net', 'hdd', 'cd', 'usb'
}
if False: # boot from iso instead
self.vm_paramaters['disk_list'].append({
'name':
'cd',
'file':
'/home/peter/Downloads/ubuntu-16.04.2-server-amd64.iso'
})
self.vm_paramaters['boot_order'][0] = 'cd'
def setup(self, parms):
try:
foundation = self.getScriptValue('foundation', 'foundation')
except ValueError as e:
raise ParamaterError('<internal>',
'Unable to get Foundation: {0}'.format(e))
try:
proxmox_complex = self.getScriptValue('foundation',
'proxmox_complex')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation proxmox_complex: {0}'.format(e))
self.connection_paramaters = proxmox_complex.connection_paramaters
self.vm_paramaters = {'vmid': foundation.proxmox_vmid}
try:
self.vm_paramaters['name'] = self.getScriptValue(
'foundation', 'locator')
except KeyError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation Locator: {0}'.format(e))
if not NAME_REGEX.match(self.vm_paramaters['name']):
raise ParamaterError('invalid name')
try:
vm_spec = parms['vm_spec']
except KeyError:
raise ParamaterError('vm_spec', 'required')
if not isinstance(vm_spec, dict):
raise ParamaterError('vm_spec', 'must be a dict')
for key in ('node', ):
try:
self.vm_paramaters[key] = parms[key]
except KeyError:
raise ParamaterError(key, 'required')
for key in ('core_count', 'memory_size'): # , 'swap_size' ): for lxc
try:
self.vm_paramaters[key] = int(vm_spec[key])
except KeyError:
raise ParamaterError('vm_spec.{0}'.format(key), 'required')
except (ValueError, TypeError):
raise ParamaterError('vm_spec.{0}'.format(key),
'must be an integer')
if self.vm_paramaters['core_count'] > 64 or self.vm_paramaters[
'core_count'] < 1:
raise ParamaterError('core_count', 'must be from 1 to 64')
if self.vm_paramaters['memory_size'] > 1048510 or self.vm_paramaters[
'memory_size'] < 512: # in MiB
raise ParamaterError('memory_size', 'must be from 512 to 1048510')
# if self.vm_paramaters[ 'swap_size' ] > 1048510 or self.vm_paramaters[ 'swap_size' ] < 512: # in MiB for lxc
# raise ParamaterError( 'swap_size', 'must be from 512 to 1048510' )
for key in ('proxmox_ostype', ):
try:
self.vm_paramaters[key[8:]] = vm_spec[key]
except KeyError:
pass
interface_type = 'virtio'
interface_list = []
for interface in foundation.networkinterface_set.all().order_by(
'physical_location'):
interface_list.append({
'name': interface.name,
'physical_location': interface.physical_location,
'network': interface.network.name,
'type': interface_type
})
self.vm_paramaters['disk_list'] = [{
'size':
vm_spec.get('disk_size', 10),
'name':
'sda',
'type':
vm_spec.get('disk_provisioning', 'thick')
}] # disk size in GiB
self.vm_paramaters['interface_list'] = interface_list
self.vm_paramaters['boot_order'] = ['net', 'hdd'
] # list of 'net', 'hdd', 'cd'
def setup(self, parms):
try:
foundation = self.getScriptValue('foundation', 'foundation')
except ValueError as e:
raise ParamaterError('<internal>',
'Unable to get Foundation: {0}'.format(e))
try:
virtualbox_complex = self.getScriptValue('foundation',
'virtualbox_complex')
except ValueError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation virtualbox_complex: {0}'.format(e))
self.connection_paramaters = virtualbox_complex.connection_paramaters
try:
vm_spec = parms['vm_spec']
except KeyError:
raise ParamaterError('vm_spec', 'required')
if not isinstance(vm_spec, dict):
raise ParamaterError('vm_spec', 'must be a dict')
try:
adapter_type = vm_spec['virtualbox_network_adapter_type']
except KeyError:
adapter_type = 'I82540EM'
interface_list = []
counter = 0
for interface in foundation.networkinterface_set.all().order_by(
'physical_location')[:4]: # max 4 interfaces
interface_list.append({
'name': interface.name,
'index': counter,
'network': interface.network.name,
'type': 'host',
'adapter_type': adapter_type
}) # type one of 'host', 'bridge', 'nat', 'internal'
counter += 1
self.vm_paramaters = { # the defaults
'disk_list': [{
'name': 'sda',
'size': 10
}], # disk size in GiB
'interface_list': interface_list,
'boot_order': ['net', 'hdd'] # list of 'net', 'hdd', 'cd', 'usb'
}
if False: # boot from iso instead
self.vm_paramaters['disk_list'].append({
'name':
'cd',
'file':
'/home/peter/Downloads/ubuntu-16.04.2-server-amd64.iso'
})
self.vm_paramaters['boot_order'][0] = 'cd'
for key in ('cpu_count', 'memory_size'):
try:
self.vm_paramaters[key] = int(vm_spec[key])
except KeyError:
raise ParamaterError('vm_spec.{0}'.format(key), 'required')
except (ValueError, TypeError):
raise ParamaterError('vm_spec.{0}'.format(key),
'must be an integer')
if self.vm_paramaters['cpu_count'] > 64 or self.vm_paramaters[
'cpu_count'] < 1:
raise ParamaterError('cpu_count', 'must be from 1 to 64')
if self.vm_paramaters['memory_size'] > 1048510 or self.vm_paramaters[
'memory_size'] < 512: # in MiB
raise ParamaterError('memory_size', 'must be from 512 to 1048510')
try:
self.vm_paramaters['name'] = self.getScriptValue(
'foundation', 'locator')
except KeyError as e:
raise ParamaterError(
'<internal>',
'Unable to get Foundation Locator: {0}'.format(e))
if not NAME_REGEX.match(self.vm_paramaters['name']):
raise ParamaterError('invalid name')
for key in ('virtualbox_guest_type', ):
try:
self.vm_paramaters[key[11:]] = vm_spec[key]
except KeyError:
pass
def setup(self, parms):
for name in ('host', 'username', 'password', 'source', 'destination'):
try:
setattr(self, name, parms[name])
except KeyError:
raise ParamaterError(name, 'required')
def setup(self, parms):
try:
self.url = parms.get('url')
except KeyError:
raise ParamaterError('url', 'required')
