def connect(params):
"""
Connect ovirt manager API.
"""
url = params.get('ovirt_engine_url')
username = params.get('ovirt_engine_user')
password = params.get('ovirt_engine_password')
version = params.get('ovirt_engine_version')
if not all([url, username, password]):
logging.error('ovirt_engine[url|user|password] are necessary!!')
if version is None:
version = types.Version(major='4', minor='2')
else:
version = types.Version(version)
global connection, _connected
try:
# Try to connect oVirt API if connection doesn't exist,
# otherwise, directly return existing API connection.
if not _connected:
connection = sdk.Connection(url=url,
username=username,
password=password,
insecure=True)
_connected = True
return connection, version
else:
return connection, version
except Exception as e:
logging.error('Failed to connect: %s\n' % str(e))
else:
logging.info('Succeed to connect oVirt/Rhevm manager\n')
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_dc(pname, pdescription, plocal, pmajor, pminor):
print('Adding DC : ' + pname + '...')
dc = dcs_service.add(
types.DataCenter(
name=pname,
description=pdescription,
local=plocal,
version=types.Version(major=pmajor, minor=pminor),
), )
def update_cluster_versions(api):
versions = [(4, 3), (4, 4)]
for major, minor in versions:
_update_cluster_version(
api=api,
new_version=types.Version(
major=major,
minor=minor
)
)
def build_entity(self):
return otypes.DataCenter(
name=self._module.params['name'],
comment=self._module.params['comment'],
description=self._module.params['description'],
quota_mode=otypes.QuotaModeType(self._module.params['quota_mode'])
if self._module.params['quota_mode'] else None,
local=self._module.params['local'],
version=otypes.Version(
major=self.__get_major(
self._module.params['compatibility_version']),
minor=self.__get_minor(
self._module.params['compatibility_version']),
) if self._module.params['compatibility_version'] else None,
)
def build_entity(self):
return otypes.DataCenter(
name=self._module.params['name'],
comment=self._module.params['comment'],
description=self._module.params['description'],
mac_pool=otypes.MacPool(
id=getattr(self._get_mac_pool(), 'id', None),
) if self._module.params.get('mac_pool') else None,
quota_mode=otypes.QuotaModeType(
self._module.params['quota_mode']
) if self._module.params['quota_mode'] else None,
local=self._module.params['local'],
version=otypes.Version(
major=self.__get_major(self._module.params['compatibility_version']),
minor=self.__get_minor(self._module.params['compatibility_version']),
) if self._module.params['compatibility_version'] else None,
)
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'),
)
