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'), )