def _get_cluster_mappings(module):
clusterMappings = list()
for clusterMapping in module.params['cluster_mappings']:
clusterMappings.append(
otypes.RegistrationClusterMapping(
from_=otypes.Cluster(name=clusterMapping['source_name'], ),
to=otypes.Cluster(name=clusterMapping['dest_name'], ),
))
return clusterMappings
def update_clusters_cpu(self, timeout=2 * 60):
cpu_family = self.get_ovirt_cpu_family()
api = self.engine_vm().get_api_v4(check=True)
clusters_service = api.system_service().clusters_service()
clusters = clusters_service.list()
if clusters is None:
LOGGER.debug('no clusters found: skipping')
return
for cluster in clusters:
if cluster.cpu.type == cpu_family:
continue
LOGGER.debug(
('found CPU cluster mismatch, current: {0}, required: '
'{1}').format(cluster.cpu.type, cpu_family))
cluster_service = clusters_service.cluster_service(cluster.id)
cluster_service.update(
otypes.Cluster(cpu=otypes.Cpu(type=cpu_family)))
def _assert_cluster_cpu(cluster):
cluster = clusters_service.cluster_service(cluster.id).get()
return cluster.cpu.type == cpu_family
testlib.assert_true_within(partial(_assert_cluster_cpu, cluster),
timeout=timeout)
LOGGER.debug(('successfuly changed cluster id {0} to cpu family: '
'{1}').format(cluster.id, cpu_family))
def build_entity(self):
return otypes.Event(
description=self._module.params['description'],
severity=otypes.LogSeverity(self._module.params['severity']),
origin=self._module.params['origin'],
custom_id=self._module.params['custom_id'],
id=self._module.params['id'],
cluster=otypes.Cluster(
id=self._module.params['cluster']
) if self._module.params['cluster'] is not None else None,
data_center=otypes.DataCenter(
id=self._module.params['data_center']
) if self._module.params['data_center'] is not None else None,
host=otypes.Host(
id=self._module.params['host']
) if self._module.params['host'] is not None else None,
storage_domain=otypes.StorageDomain(
id=self._module.params['storage_domain']
) if self._module.params['storage_domain'] is not None else None,
template=otypes.Template(
id=self._module.params['template']
) if self._module.params['template'] is not None else None,
user=otypes.User(
id=self._module.params['user']
) if self._module.params['user'] is not None else None,
vm=otypes.Vm(
id=self._module.params['vm']
) if self._module.params['vm'] is not None else None,
)
def create_vm_template(self, vm, logger):
try:
# hosts specified
placement_policy = types.VmPlacementPolicy(
hosts=[types.Host(name=vm.host)])
# cpu number
cpu = types.CpuTopology(cores=vm.vcpu)
# template
template = types.Vm(
name=vm.name,
memory=vm.ram * 1024 * 1024, #MB
cpu=types.Cpu(topology=cpu),
cluster=types.Cluster(id=vm.cluster, ),
template=types.Template(name='Blank', ),
placement_policy=placement_policy)
logger.info('Successfully created vm template')
logger.info(
'Instance properties: name:{}, host:{}, cluster:{}, vcpu:{}, ram:{}'
.format(vm.name, vm.host, vm.cluster, vm.vcpu, vm.ram))
return template
except Exception as e:
logger.error('Can not add vm template')
logger.error(e)
return {"name": vm.name, "status": 'fail,template'}
def clone_vm_from_snapshot(vms_service, snapshot, vm_name, cluster_name, logger):
logger.info('Cloning VM from snapshot...')
cloned_vm = vms_service.add(
vm=otypes.Vm(
name=vm_name,
snapshots=[
otypes.Snapshot(
id=snapshot.id
)
],
cluster=otypes.Cluster(
name=cluster_name
)
)
)
OvirtBackup.wait(
service=vms_service.vm_service(cloned_vm.id),
condition=lambda vm: vm.status == otypes.VmStatus.DOWN,
logger=logger,
wait=True,
timeout=180000
)
logger.info(' --> done')
return cloned_vm
def build_entity(self):
return otypes.Vm(
name=self._module.params['name'],
cluster=otypes.Cluster(name=self._module.params['cluster'])
if self._module.params['cluster'] else None,
template=otypes.Template(name=self._module.params['template'])
if self._module.params['template'] else None,
stateless=self._module.params['stateless'],
delete_protected=self._module.params['delete_protected'],
high_availability=otypes.HighAvailability(
enabled=self._module.params['high_availability'])
if self._module.params['high_availability'] is not None else None,
cpu=otypes.Cpu(topology=otypes.CpuTopology(
cores=self._module.params['cpu_cores'],
sockets=self._module.params['cpu_sockets'],
)) if (self._module.params['cpu_cores']
or self._module.params['cpu_sockets']) else None,
cpu_shares=self._module.params['cpu_shares'],
os=otypes.OperatingSystem(
type=self._module.params['operating_system'],
boot=otypes.Boot(devices=[
otypes.BootDevice(dev)
for dev in self._module.params['boot_devices']
], ) if self._module.params['boot_devices'] else None,
) if (self._module.params['operating_system']
or self._module.params['boot_devices']) else None,
type=otypes.VmType(self._module.params['type'])
if self._module.params['type'] else None,
memory=convert_to_bytes(self._module.params['memory'])
if self._module.params['memory'] else None,
memory_policy=otypes.MemoryPolicy(guaranteed=convert_to_bytes(
self._module.params['memory_guaranteed']), )
if self._module.params['memory_guaranteed'] else None,
)
def build_entity(self):
return otypes.Host(
id=self._module.params.get('id'),
name=self.param('name'),
cluster=otypes.Cluster(
name=self.param('cluster')
) if self.param('cluster') else None,
comment=self.param('comment'),
address=self.param('address'),
root_password=self.param('password'),
ssh=otypes.Ssh(
authentication_method=otypes.SshAuthenticationMethod.PUBLICKEY if self.param('public_key') else None,
port=self.param('ssh_port'),
),
spm=otypes.Spm(
priority=self.param('spm_priority'),
) if self.param('spm_priority') else None,
override_iptables=self.param('override_iptables'),
display=otypes.Display(
address=self.param('override_display'),
) if self.param('override_display') else None,
os=otypes.OperatingSystem(
custom_kernel_cmdline=' '.join(self.param('kernel_params')),
) if self.param('kernel_params') else None,
power_management=otypes.PowerManagement(
enabled=self.param('power_management_enabled'),
kdump_detection=self.param('kdump_integration') == 'enabled',
) if self.param('power_management_enabled') is not None or self.param('kdump_integration') else None,
vgpu_placement=otypes.VgpuPlacement(
self.param('vgpu_placement')
) if self.param('vgpu_placement') is not None else None,
)
def import_image(system_service,
image_name,
template_name,
disk_name,
dest_storage_domain,
dest_cluster,
sd_name,
as_template=False):
storage_domains_service = system_service.storage_domains_service()
glance_storage_domain = storage_domains_service.list(
search='name={}'.format(sd_name))[0]
images = storage_domains_service.storage_domain_service(
glance_storage_domain.id).images_service().list()
image = [x for x in images if x.name == image_name][0]
image_service = storage_domains_service.storage_domain_service(
glance_storage_domain.id).images_service().image_service(image.id)
result = image_service.import_(
storage_domain=types.StorageDomain(name=dest_storage_domain, ),
template=types.Template(name=template_name, ),
cluster=types.Cluster(name=dest_cluster, ),
import_as_template=as_template,
disk=types.Disk(name=disk_name),
)
disk = system_service.disks_service().list(
search='name={}'.format(disk_name))[0]
assert disk
def build_entity(self):
return otypes.Template(
id=self._module.params['id'],
name=self._module.params['name'],
cluster=otypes.Cluster(name=self._module.params['cluster'])
if self._module.params['cluster'] else None,
vm=otypes.Vm(name=self._module.params['vm'])
if self._module.params['vm'] else None,
description=self._module.params['description'],
cpu_profile=otypes.CpuProfile(id=search_by_name(
self._connection.system_service().cpu_profiles_service(),
self._module.params['cpu_profile'],
).id) if self._module.params['cpu_profile'] else None,
os=otypes.OperatingSystem(type=self.param('operating_system'), )
if self.param('operating_system') else None,
memory=convert_to_bytes(self.param('memory'))
if self.param('memory') else None,
version=otypes.TemplateVersion(
base_template=self._get_base_template(),
version_name=self.param('version').get('name'),
) if self.param('version') else None,
memory_policy=otypes.MemoryPolicy(
guaranteed=convert_to_bytes(self.param('memory_guaranteed')),
max=convert_to_bytes(self.param('memory_max')),
) if any((self.param('memory_guaranteed'),
self.param('memory_max'))) else None,
io=otypes.Io(threads=self.param('io_threads'), )
if self.param('io_threads') is not None else None,
)
def createVM(self,
vmname,
cluster,
template,
group,
memory=10,
description=None):
vms_service = self.connection.system_service().vms_service()
vms = vms_service.list(search='name=%s' % vmname)
if vms:
# 根据 虚拟机名称区分 虚拟机是否存在
return ("%s虚拟机已存在" % vmname)
vms_service.add(
types.Vm(
name=vmname, # 虚拟机名称
comment=group, # 注释，这里用于分组
description=description, # 虚拟机的描述
cluster=types.Cluster(
name=cluster, # 虚拟机的集群环境
),
template=types.Template(
name=template, # 虚拟机集群环境的模板
),
memory=memory * 2**30, # 内存 memory 单位GB，默认字节算
))
self.checkVM(vmname, "down") # 创建虚拟机，如果状态是down表示虚拟机已经创建好了
def createVM(session):
""" Creates a virtual maschine """
print "\n\n=================[ CREATING VMS ]================="
try:
for vm in configFile['vms']:
hostname = vm['hostname']
cluster = vm['cluster']
template = vm['template']
memory = vm['memory']
vmService = session.system_service().vms_service()
vm = vmService.add(
types.Vm(
name=hostname,
memory = memory * 2**30,
cluster=types.Cluster(
name=cluster),
template=types.Template(
name=template),
os=types.OperatingSystem(
boot=types.Boot(
devices=[types.BootDevice.HD])),
)
)
print ("Created VM \"%s\" on cluster \"%s\" with template \"%s\"." % (hostname, cluster, template))
except Exception as e:
print str(e)
sys.exit(1)
def add_mac_pool_to_cluster(pname, pfrom, pto, pcluster):
print('Adding MAC Pool : ' + pname + 'to Cluster...')
# Add a new MAC pool:
pool = pools_service.add(
types.MacPool(
name=pname,
ranges=[
types.Range(
from_=pfrom,
to=pto,
),
],
), )
# Find the cluster:
cluster = clusters_service.list(search='name=' + pcluster)[0]
# Find the service that manages the cluster, as we need it in order to
# do the update:
cluster_service = clusters_service.cluster_service(cluster.id)
# Update the cluster so that it uses the new MAC pool:
cluster_service.update(
types.Cluster(mac_pool=types.MacPool(id=pool.id, ), ), )
def build_entity(self):
return otypes.Host(
name=self._module.params['name'],
cluster=otypes.Cluster(
name=self._module.params['cluster']
) if self._module.params['cluster'] else None,
comment=self._module.params['comment'],
address=self._module.params['address'],
root_password=self._module.params['password'],
ssh=otypes.Ssh(
authentication_method=otypes.SshAuthenticationMethod.PUBLICKEY,
) if self._module.params['public_key'] else None,
kdump_status=otypes.KdumpStatus(
self._module.params['kdump_integration']
) if self._module.params['kdump_integration'] else None,
spm=otypes.Spm(
priority=self._module.params['spm_priority'],
) if self._module.params['spm_priority'] else None,
override_iptables=self._module.params['override_iptables'],
display=otypes.Display(
address=self._module.params['override_display'],
) if self._module.params['override_display'] else None,
os=otypes.OperatingSystem(
custom_kernel_cmdline=' '.join(self._module.params['kernel_params']),
) if self._module.params['kernel_params'] else None,
)
def build_entity(self):
return otypes.Host(
name=self.param('name'),
cluster=otypes.Cluster(
name=self.param('cluster')
) if self.param('cluster') else None,
comment=self.param('comment'),
address=self.param('address'),
root_password=self.param('password'),
ssh=otypes.Ssh(
authentication_method=otypes.SshAuthenticationMethod.PUBLICKEY,
) if self.param('public_key') else None,
kdump_status=otypes.KdumpStatus(
self.param('kdump_integration')
) if self.param('kdump_integration') else None,
spm=otypes.Spm(
priority=self.param('spm_priority'),
) if self.param('spm_priority') else None,
override_iptables=self.param('override_iptables'),
display=otypes.Display(
address=self.param('override_display'),
) if self.param('override_display') else None,
os=otypes.OperatingSystem(
custom_kernel_cmdline=' '.join(self.param('kernel_params')),
) if self.param('kernel_params') else None,
power_management=otypes.PowerManagement(
enabled=self.param('power_management_enabled'),
) if self.param('power_management_enabled') is not None else None,
)
def _update_cluster_version(api, new_version):
engine = api.system_service()
clusters_service = engine.clusters_service()
cluster = clusters_service.list(search=TEST_CLUSTER)[0]
cluster_service = clusters_service.cluster_service(cluster.id)
vms_service = engine.vms_service()
old_version = types.Version(
major=cluster.version.major,
minor=cluster.version.minor
)
cluster_service.update(
cluster=types.Cluster(
version=new_version
)
)
updating_version = clusters_service.list(search=TEST_CLUSTER)[0].version
nt.assert_true(
updating_version.major == new_version.major and
updating_version.minor == new_version.minor
)
down_vm = vms_service.list(search=VM1_NAME)[0]
nt.assert_true(down_vm.custom_compatibility_version is None)
up_vm = vms_service.list(search=VM0_NAME)[0]
nt.assert_true(
up_vm.custom_compatibility_version.major == old_version.major and
up_vm.custom_compatibility_version.minor == old_version.minor
)
nt.assert_true(up_vm.next_run_configuration_exists)
events = engine.events_service()
last_event = int(events.list(max=2)[0].id)
vm_service = vms_service.vm_service(up_vm.id)
vm_service.stop()
testlib.assert_true_within_short(
lambda:
vms_service.list(search=VM0_NAME)[0].status == types.VmStatus.DOWN
)
events = engine.events_service()
testlib.assert_true_within_long(
lambda:
(next(e for e in events.list(from_=last_event)
if e.code == 253)).code == 253,
allowed_exceptions=[StopIteration]
)
vm_service.start()
testlib.assert_true_within_short(
lambda:
vms_service.list(search=VM0_NAME)[0].status == types.VmStatus.UP
)
up_vm = vms_service.list(search=VM0_NAME)[0]
nt.assert_false(up_vm.next_run_configuration_exists)
nt.assert_true(up_vm.custom_compatibility_version is None)
def add_vm(pname, pcluster, ptemplate):
print('Adding VM : ' + pname + '...')
vms_service.add(
types.Vm(
name=pname,
cluster=types.Cluster(name=pcluster, ),
template=types.Template(name=ptemplate, ),
), )
def add_vm_blank(api):
# Get the vms service
vms_service=api.system_service().vms_service()
#Create VM from blank template
vm_memory=256*MB
vm=types.Vm(
name=VM0_NAME,
memory=vm_memory,
type=types.VmType.SERVER,
os=types.OperatingSystem(
type='other_linux',
boot=types.Boot(
devices=[types.BootDevice.HD, types.BootDevice.NETWORK]
),
),
high_availability=types.HighAvailability(
enabled=False
),
cluster=types.Cluster(
name=TEST_CLUSTER
),
template=types.Template(
name=TEMPLATE_BLANK
),
display=types.Display(
smartcard_enabled=True,
keyboard_layout='en-us',
file_transfer_enabled=True,
copy_paste_enabled=True
),
memory_policy=types.MemoryPolicy(
guaranteed=vm_memory//2
)
)
#Add this VM
vm=vms_service.add(vm)
#Check that VM was added
vm_service=vms_service.vm_service(vm.id)
testlib.assert_true_within_short(
lambda: vm_service.get().status == types.VmStatus.DOWN
)
#Add another VM
vm.id=None
vm.name=VM1_NAME
vm.initialization=None
vm=vms_service.add(vm)
#Check that the second VM was added
vm_service=vms_service.vm_service(vm.id)
testlib.assert_true_within_short(
lambda: vm_service.get().status == types.VmStatus.DOWN
)
def build_entity(self):
return otypes.Template(
id=self._module.params['id'],
name=self._module.params['name'],
cluster=otypes.Cluster(
name=self._module.params['cluster']
) if self._module.params['cluster'] else None,
vm=otypes.Vm(
name=self._module.params['vm']
) if self._module.params['vm'] else None,
description=self._module.params['description'],
cpu_profile=otypes.CpuProfile(
id=search_by_name(
self._connection.system_service().cpu_profiles_service(),
self._module.params['cpu_profile'],
).id
) if self._module.params['cpu_profile'] else None,
display=otypes.Display(
smartcard_enabled=self.param('smartcard_enabled')
) if self.param('smartcard_enabled') is not None else None,
os=otypes.OperatingSystem(
type=self.param('operating_system'),
) if self.param('operating_system') else None,
memory=convert_to_bytes(
self.param('memory')
) if self.param('memory') else None,
soundcard_enabled=self.param('soundcard_enabled'),
usb=(
otypes.Usb(enabled=self.param('usb_support'))
) if self.param('usb_support') is not None else None,
sso=(
otypes.Sso(
methods=[otypes.Method(id=otypes.SsoMethod.GUEST_AGENT)] if self.param('sso') else []
)
) if self.param('sso') is not None else None,
time_zone=otypes.TimeZone(
name=self.param('timezone'),
) if self.param('timezone') else None,
version=otypes.TemplateVersion(
base_template=self._get_base_template(),
version_name=self.param('version').get('name'),
) if self.param('version') else None,
memory_policy=otypes.MemoryPolicy(
guaranteed=convert_to_bytes(self.param('memory_guaranteed')),
ballooning=self.param('ballooning_enabled'),
max=convert_to_bytes(self.param('memory_max')),
) if any((
self.param('memory_guaranteed'),
self.param('ballooning_enabled'),
self.param('memory_max')
)) else None,
io=otypes.Io(
threads=self.param('io_threads'),
) if self.param('io_threads') is not None else None,
initialization=self.get_initialization(),
)
def clone_snapshot_to_vm(vms_service, vm, snap):
counter = 0
snapshots_service = vms_service.vm_service(vm.id).snapshots_service()
new_vm_name = '{}_{}_{}'.format(vm.name, VM_MIDDLE,
datetime.now().strftime('%Y%m%d_%H%M%S'))
# It can happen, that the snapshot state gives ok,
# but the snapshot is still not free for cloning/deleting.
# For this case we have to wait a bit more.
sleep(120)
check_snapshot(snap, snapshots_service, True)
logger.info("[{}] Create VM clone from snapshot...".format(vm.name))
try:
vm_clone = vms_service.add(
vm=types.Vm(name=new_vm_name,
snapshots=[types.Snapshot(id=snap.id)],
cluster=types.Cluster(name=CLUSTER)))
except sdk.Error as oerr:
logger.error(oerr)
send_mail(oerr)
return None
cloned_vm_service = vms_service.vm_service(vm_clone.id)
created = True
# check if cloned vm is down,
# what means that the cloning process has been completed
while vm_clone.status != types.VmStatus.DOWN:
if counter >= MAX_OPERATION_TIME:
logger.error("[{}] Creating VM clone from snapshot failed".format(
vm.name))
send_mail("Creating VM clone from snapshot failed!\n" +
"No backup for: <b>{}</b> at: <b>{}</b>".format(
vm.name,
datetime.now().strftime('%H:%M:%S')))
created = None
break
sleep(5)
vm_clone = cloned_vm_service.get()
counter + 5
if created:
logger.info("[{}] Creating VM clone from snapshot completed!".format(
vm.name))
# is allways good to sleep a bit :)
sleep(2)
return vm_clone
else:
return None
def add_cluster(pname, pdescription, ptype, pdc):
print('Adding Cluster : ' + pname + '...')
clusters_service.add(
types.Cluster(
name=pname,
description=pdescription,
cpu=types.Cpu(
architecture=types.Architecture.X86_64,
type=ptype,
),
data_center=types.DataCenter(name=pdc, ),
), )
def import_template(self, edomain, sdomain, cluster, temp_template):
export_sd_service = self._get_storage_domain_service(edomain)
export_template = self.get_template_from_storage_domain(
temp_template, edomain)
target_storage_domain = self._get_storage_domain(sdomain)
cluster_id = self._get_cluster(cluster).id
sd_template_service = export_sd_service.templates_service(
).template_service(export_template.id)
sd_template_service.import_(
storage_domain=types.StorageDomain(id=target_storage_domain.id),
cluster=types.Cluster(id=cluster_id),
template=types.Template(id=export_template.id))
def create_vm_from_ovf(ovf_file_path, vms_service):
"""
Creates a new VM from the specified OVF
"""
ovf_data = open(ovf_file_path, 'r').read()
vm = vms_service.add(
types.Vm(
cluster=types.Cluster(name='Default', ),
initialization=types.Initialization(
configuration=types.Configuration(
type=types.ConfigurationType.OVF, data=ovf_data)),
), )
return vm.id
def build_entity(self):
return otypes.Template(
name=self._module.params['name'],
cluster=otypes.Cluster(name=self._module.params['cluster'])
if self._module.params['cluster'] else None,
vm=otypes.Vm(name=self._module.params['vm'])
if self._module.params['vm'] else None,
description=self._module.params['description'],
cpu_profile=otypes.CpuProfile(id=search_by_name(
self._connection.system_service().cpu_profiles_service(),
self._module.params['cpu_profile'],
).id) if self._module.params['cpu_profile'] else None,
)
def add_host(pname, pdescription, paddress, proot_password, pcluster,
wait_for_up):
print('Adding Host : ' + pname + '...')
host = hosts_service.add(
types.Host(
name=pname,
description=pdescription,
address=paddress,
root_password=proot_password,
cluster=types.Cluster(name=pcluster, ),
), )
if wait_for_up:
host_service = hosts_service.host_service(host.id)
track_status(host_service, types.HostStatus.UP, 1)
def add_image(self, image, pool, short=None, cmd=None, name=None, size=1):
"""
:param image:
:param pool:
:param short:
:param cmd:
:param name:
:param size:
:return:
"""
image = os.path.basename(image)
if image not in otemplates:
return {'result': 'failure', 'reason': "Image not supported"}
if image in self.volumes():
common.pprint("Image %s already there" % image)
return {'result': 'success'}
system_service = self.conn.system_service()
sds_service = system_service.storage_domains_service()
poolcheck = sds_service.list(search='name=%s' % pool)
if not poolcheck:
return {'result': 'failure', 'reason': "Pool %s not found" % pool}
sd = sds_service.list(search='name=%s' % self.imagerepository)
common.pprint("Using %s glance repository" % self.imagerepository,
color='green')
if not sd:
common.confirm(
"No glance repo found. Do you want public glance repo to be installed?"
)
providers_service = system_service.openstack_image_providers_service(
)
sd_service = providers_service.add(
provider=types.OpenStackImageProvider(
name='ovirt-image-repository',
url='http://glance.ovirt.org:9292',
requires_authentication=False))
common.pprint("Relaunch kcli download now", color='green')
return {'result': 'success'}
else:
sd_service = sds_service.storage_domain_service(sd[0].id)
images_service = sd_service.images_service()
images = images_service.list()
imageobject = next((i for i in images if i.name == otemplates[image]),
None)
image_service = images_service.image_service(imageobject.id)
image_service.import_(import_as_template=True,
template=types.Template(name=image),
cluster=types.Cluster(name=self.cluster),
storage_domain=types.StorageDomain(name=pool))
return {'result': 'success'}
def build_entity(self):
template = self.__get_template_with_version()
return otypes.Vm(
name=self.param('name'),
cluster=otypes.Cluster(
name=self.param('cluster')) if self.param('cluster') else None,
template=otypes.Template(id=template.id, ) if template else None,
use_latest_template_version=self.param(
'use_latest_template_version'),
stateless=self.param('stateless')
or self.param('use_latest_template_version'),
delete_protected=self.param('delete_protected'),
high_availability=otypes.HighAvailability(
enabled=self.param('high_availability'))
if self.param('high_availability') is not None else None,
cpu=otypes.Cpu(topology=otypes.CpuTopology(
cores=self.param('cpu_cores'),
sockets=self.param('cpu_sockets'),
)) if
(self.param('cpu_cores') or self.param('cpu_sockets')) else None,
cpu_shares=self.param('cpu_shares'),
os=otypes.OperatingSystem(
type=self.param('operating_system'),
boot=otypes.Boot(devices=[
otypes.BootDevice(dev)
for dev in self.param('boot_devices')
], ) if self.param('boot_devices') else None,
) if (self.param('operating_system')
or self.param('boot_devices')) else None,
type=otypes.VmType(self.param('type'))
if self.param('type') else None,
memory=convert_to_bytes(self.param('memory'))
if self.param('memory') else None,
memory_policy=otypes.MemoryPolicy(guaranteed=convert_to_bytes(
self.param('memory_guaranteed')), )
if self.param('memory_guaranteed') else None,
instance_type=otypes.InstanceType(id=get_id_by_name(
self._connection.system_service().instance_types_service(),
self.param('instance_type'),
), ) if self.param('instance_type') else None,
description=self.param('description'),
comment=self.param('comment'),
time_zone=otypes.TimeZone(name=self.param('timezone'), )
if self.param('timezone') else None,
serial_number=otypes.SerialNumber(
policy=otypes.SerialNumberPolicy(self.param('serial_policy')),
value=self.param('serial_policy_value'),
) if (self.param('serial_policy') is not None
or self.param('serial_policy_value') is not None) else None,
)
def build_entity(self):
return otypes.VmPool(
name=self._module.params['name'],
description=self._module.params['description'],
comment=self._module.params['comment'],
cluster=otypes.Cluster(name=self._module.params['cluster'])
if self._module.params['cluster'] else None,
template=otypes.Template(name=self._module.params['template'])
if self._module.params['template'] else None,
max_user_vms=self._module.params['vm_per_user'],
prestarted_vms=self._module.params['prestarted'],
size=self._module.params['vm_count'],
type=otypes.VmPoolType(self._module.params['type'])
if self._module.params['type'] else None,
)
def add_vm_template(api):
#TODO: Fix the exported domain generation
raise SkipTest('Exported domain generation not supported yet')
vm_params = types.VM(
name=VM1_NAME,
memory=512 * MB,
cluster=types.Cluster(name=TEST_CLUSTER, ),
template=types.Template(name=TEMPLATE_CENTOS7, ),
display=types.Display(type_='spice', ),
)
api.vms.add(vm_params)
testlib.assert_true_within_long(
lambda: api.vms.get(VM1_NAME).status.state == 'down', )
disk_name = api.vms.get(VM1_NAME).disks.list()[0].name
testlib.assert_true_within_long(lambda: api.vms.get(VM1_NAME).disks.get(
disk_name).status.state == 'ok')
def bucle():
try:
return vms_service.add(
types.Vm(
name=sys.argv[1],
cluster=types.Cluster(
name='Cluster-Rojo'
),
template=types.Template(
id=template_id
),
)
)
except:
time.sleep(100)
bucle()
def build_entity(self):
return otypes.Host(
name=self._module.params['name'],
cluster=otypes.Cluster(name=self._module.params['cluster'])
if self._module.params['cluster'] else None,
comment=self._module.params['comment'],
address=self._module.params['address'],
root_password=self._module.params['password'],
ssh=otypes.Ssh(authentication_method='publickey', )
if self._module.params['public_key'] else None,
kdump_status=otypes.KdumpStatus(
self._module.params['kdump_integration'])
if self._module.params['kdump_integration'] else None,
spm=otypes.Spm(priority=self._module.params['spm_priority'], )
if self._module.params['spm_priority'] else None,
override_iptables=self._module.params['override_iptables'],
)
