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 test_add_vm1_from_template(engine_api, cirros_image_glance_template_name):
engine = engine_api.system_service()
templates_service = engine.templates_service()
glance_template = templates_service.list(
search='name=%s' % cirros_image_glance_template_name)[0]
if glance_template is None:
pytest.skip('%s: template %s not available.' %
(add_vm1_from_template.__name__,
cirros_image_glance_template_name))
vm_memory = 128 * MB # runs with 64 ok, but we need to do a hotplug later (64+256 is too much difference)
vms_service = engine.vms_service()
vms_service.add(
types.Vm(
name=VM1_NAME,
description='CirrOS imported from Glance as Template',
memory=vm_memory,
cluster=types.Cluster(name=TEST_CLUSTER, ),
template=types.Template(name=cirros_image_glance_template_name, ),
use_latest_template_version=True,
stateless=True,
display=types.Display(type=types.DisplayType.VNC, ),
memory_policy=types.MemoryPolicy(
guaranteed=
vm_memory, # with so little memory we don't want guaranteed to be any lower
ballooning=False,
),
os=types.OperatingSystem(
type=
'rhel_7x64', # even though it's CirrOS we want to check a non-default OS type
),
time_zone=types.TimeZone(name='Etc/GMT', ),
type=types.VmType.SERVER,
serial_number=types.SerialNumber(
policy=types.SerialNumberPolicy.CUSTOM,
value='12345678',
),
cpu=types.Cpu(
architecture=types.Architecture.X86_64,
topology=types.CpuTopology(
sockets=1,
cores=1,
threads=2,
),
),
))
def add_vm1_from_template(api):
engine = api.system_service()
templates_service = engine.templates_service()
glance_template = templates_service.list(search='name=%s' %
TEMPLATE_CIRROS)[0]
if glance_template is None:
raise SkipTest('%s: template %s not available.' % (
add_vm1_from_template.__name__,
TEMPLATE_CIRROS,
))
vm_memory = 512 * MB
vms_service = engine.vms_service()
vms_service.add(
types.Vm(
name=VM1_NAME,
description='CirrOS imported from Glance as Template',
memory=512 * MB,
cluster=types.Cluster(name=TEST_CLUSTER, ),
template=types.Template(name=TEMPLATE_CIRROS, ),
use_latest_template_version=True,
stateless=True,
display=types.Display(type=types.DisplayType.VNC, ),
memory_policy=types.MemoryPolicy(
guaranteed=vm_memory / 2,
ballooning=False,
),
os=types.OperatingSystem(type='other_lnux', ),
time_zone=types.TimeZone(name='Etc/GMT', ),
type=types.VmType.SERVER,
serial_number=types.SerialNumber(
policy=types.SerialNumberPolicy.CUSTOM,
value='12345678',
),
cpu=types.Cpu(
architecture=types.Architecture.X86_64,
topology=types.CpuTopology(
sockets=1,
cores=1,
threads=2,
),
),
))
def build_entity(self):
sched_policy = self._get_sched_policy()
return otypes.Cluster(
id=self.param('id'),
name=self.param('name'),
comment=self.param('comment'),
description=self.param('description'),
ballooning_enabled=self.param('ballooning'),
gluster_service=self.param('gluster'),
virt_service=self.param('virt'),
threads_as_cores=self.param('threads_as_cores'),
ha_reservation=self.param('ha_reservation'),
trusted_service=self.param('trusted_service'),
optional_reason=self.param('vm_reason'),
maintenance_reason_required=self.param('host_reason'),
scheduling_policy=otypes.SchedulingPolicy(id=sched_policy.id, )
if sched_policy 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,
migration=otypes.MigrationOptions(
auto_converge=otypes.InheritableBoolean(
self.param('migration_auto_converge'), )
if self.param('migration_auto_converge') else None,
bandwidth=otypes.MigrationBandwidth(
assignment_method=otypes.
MigrationBandwidthAssignmentMethod(
self.param('migration_bandwidth'), )
if self.param('migration_bandwidth') else None,
custom_value=self.param('migration_bandwidth_limit'),
) if (self.param('migration_bandwidth')
or self.param('migration_bandwidth_limit')) else None,
compressed=otypes.InheritableBoolean(
self.param('migration_compressed'), )
if self.param('migration_compressed') else None,
policy=otypes.MigrationPolicy(id=self._get_policy_id())
if self.param('migration_policy') else None,
) if (self.param('migration_bandwidth') is not None
or self.param('migration_bandwidth_limit') is not None
or self.param('migration_auto_converge') is not None
or self.param('migration_compressed') is not None
or self.param('migration_policy') is not None) else None,
error_handling=otypes.ErrorHandling(on_error=otypes.MigrateOnError(
self.param('resilience_policy')), )
if self.param('resilience_policy') else None,
fencing_policy=otypes.FencingPolicy(
enabled=self.param('fence_enabled'),
skip_if_gluster_bricks_up=self.param(
'fence_skip_if_gluster_bricks_up'),
skip_if_gluster_quorum_not_met=self.param(
'fence_skip_if_gluster_quorum_not_met'),
skip_if_connectivity_broken=otypes.SkipIfConnectivityBroken(
enabled=self.param('fence_skip_if_connectivity_broken'),
threshold=self.param('fence_connectivity_threshold'),
) if
(self.param('fence_skip_if_connectivity_broken') is not None
or self.param('fence_connectivity_threshold') is not None)
else None,
skip_if_sd_active=otypes.SkipIfSdActive(
enabled=self.param('fence_skip_if_sd_active'), )
if self.param('fence_skip_if_sd_active') is not None else None,
) if
(self.param('fence_enabled') is not None
or self.param('fence_skip_if_sd_active') is not None
or self.param('fence_skip_if_connectivity_broken') is not None
or self.param('fence_skip_if_gluster_bricks_up') is not None
or self.param('fence_skip_if_gluster_quorum_not_met') is not None
or self.param('fence_connectivity_threshold') is not None) else
None,
display=otypes.Display(proxy=self.param('spice_proxy'), )
if self.param('spice_proxy') else None,
required_rng_sources=[
otypes.RngSource(rng) for rng in self.param('rng_sources')
] if self.param('rng_sources') else None,
memory_policy=otypes.MemoryPolicy(
over_commit=otypes.MemoryOverCommit(
percent=self._get_memory_policy(), ), )
if self.param('memory_policy') else None,
ksm=otypes.Ksm(
enabled=self.param('ksm'),
merge_across_nodes=not self.param('ksm_numa'),
) if (self.param('ksm_numa') is not None
or self.param('ksm') is not None) else None,
data_center=otypes.DataCenter(name=self.param('data_center'), )
if self.param('data_center') else None,
management_network=otypes.Network(name=self.param('network'), )
if self.param('network') else None,
cpu=otypes.Cpu(
architecture=otypes.Architecture(self.param('cpu_arch'))
if self.param('cpu_arch') else None,
type=self.param('cpu_type'),
) if (self.param('cpu_arch') or self.param('cpu_type')) else None,
version=otypes.Version(
major=self.__get_major(self.param('compatibility_version')),
minor=self.__get_minor(self.param('compatibility_version')),
) if self.param('compatibility_version') else None,
switch_type=otypes.SwitchType(self.param('switch_type'))
if self.param('switch_type') else None,
mac_pool=otypes.MacPool(id=get_id_by_name(
self._connection.system_service().mac_pools_service(),
self.param('mac_pool'))) if self.param('mac_pool') else None,
external_network_providers=self.
_get_external_network_providers_entity(),
custom_scheduling_policy_properties=[
otypes.Property(
name=sp.get('name'),
value=str(sp.get('value')),
) for sp in self.param('scheduling_policy_properties') if sp
] if self.param('scheduling_policy_properties') is not None else
None,
firewall_type=otypes.FirewallType(self.param('firewall_type'))
if self.param('firewall_type') else None,
gluster_tuned_profile=self.param('gluster_tuned_profile'),
)
# This example shows how to set a custom serial number in a virtual
# machine:
# Create the connection to the server:
connection = sdk.Connection(
url='https://engine40.example.com/ovirt-engine/api',
username='******',
password='******',
ca_file='ca.pem',
debug=True,
log=logging.getLogger(),
)
# Locate the virtual machines service and use it to find the virtual
# machine:
vms_service = connection.system_service().vms_service()
vm = vms_service.list(search='name=myvm')[0]
# Locate the service that manages that specific virtual machine:
vm_service = vms_service.vm_service(vm.id)
# Use the "update" method to set a serial number policy and value:
vm_service.update(
types.Vm(serial_number=types.SerialNumber(
policy=types.SerialNumberPolicy.CUSTOM,
value='myserial',
), ))
# Close the connection to the server:
connection.close()
