def getResources( parameters: typing.Any) -> typing.List[typing.Dict[str, typing.Any]]: """ This helper is designed as a callback for machine selector, so we can provide valid clusters and datastores domains based on it """ from .provider import OVirtProvider from uds.core.environment import Environment logger.debug('Parameters received by getResources Helper: %s', parameters) env = Environment(parameters['ev']) provider: 'OVirtProvider' = OVirtProvider(env) provider.unserialize(parameters['ov']) # Obtains datacenter from cluster ci = provider.getClusterInfo(parameters['cluster']) res = [] # Get storages for that datacenter for storage in provider.getDatacenterInfo(ci['datacenter_id'])['storage']: if storage['type'] == 'data': space, free = ( storage['available'] + storage['used'] ) / 1024 / 1024 / 1024, storage['available'] / 1024 / 1024 / 1024 res.append({ 'id': storage['id'], 'text': "%s (%4.2f GB/%4.2f GB) %s" % (storage['name'], space, free, storage['active'] and '(ok)' or '(disabled)') }) data = [{'name': 'datastore', 'values': res}] logger.debug('return data: %s', data) return data
def getResources( parameters: typing.Any) -> typing.List[typing.Dict[str, typing.Any]]: from .provider import OGProvider logger.debug('Parameters received by getResources Helper: %s', parameters) env = Environment(parameters['ev']) provider = OGProvider(env) provider.unserialize(parameters['ov']) api = provider.api labs = [gui.choiceItem('0', _('All Labs'))] + [ gui.choiceItem(l['id'], l['name']) for l in api.getLabs(ou=parameters['ou']) ] images = [ gui.choiceItem(z['id'], z['name']) for z in api.getImages(ou=parameters['ou']) ] data = [ { 'name': 'lab', 'values': labs }, { 'name': 'image', 'values': images }, ] logger.debug('Return data: %s', data) return data
def getStorage(parameters: typing.Any) -> typing.List[typing.Dict[str, typing.Any]]: from .provider import ProxmoxProvider from uds.core.environment import Environment logger.debug('Parameters received by getResources Helper: %s', parameters) env = Environment(parameters['ev']) provider: ProxmoxProvider = ProxmoxProvider(env) provider.unserialize(parameters['ov']) # Obtains datacenter from cluster try: vmInfo = provider.getMachineInfo(int(parameters['machine'])) except Exception: return [] storages = provider.listStorages(vmInfo.node) res = [] # Get storages for that datacenter for storage in sorted(provider.listStorages(vmInfo.node), key=lambda x: int(not x.shared)): if storage.type in ('lvm', 'iscsi', 'iscsidirect'): continue space, free = storage.avail / 1024 / 1024 / 1024, (storage.avail - storage.used) / 1024 / 1024 / 1024 extra = _(' shared') if storage.shared else _(' (bound to {})').format(vmInfo.node) res.append({'id': storage.storage, 'text': "%s (%4.2f GB/%4.2f GB)%s" % (storage.storage, space, free, extra)}) data = [ { 'name': 'datastore', 'values': res } ] logger.debug('return data: %s', data) return data
def executeOneDelayedTask(self) -> None: now = getSqlDatetime() filt = Q(execution_time__lt=now) | Q(insert_date__gt=now + timedelta(seconds=30)) # If next execution is before now or last execution is in the future (clock changed on this server, we take that task as executable) try: with transaction.atomic(): # Encloses # Throws exception if no delayed task is avilable task = DBDelayedTask.objects.select_for_update().filter( filt).order_by('execution_time')[0] # @UndefinedVariable if task.insert_date > now + timedelta(seconds=30): logger.warning( 'Executed %s due to insert_date being in the future!', task.type) taskInstanceDump = codecs.decode(task.instance.encode(), 'base64') task.delete() taskInstance = pickle.loads(taskInstanceDump) except IndexError: return # No problem, there is no waiting delayed task except Exception: # Transaction have been rolled back using the "with atomic", so here just return # Note that is taskInstance can't be loaded, this task will not be run logger.exception('Obtainint one task for execution') return if taskInstance: logger.debug('Executing delayedTask:>%s<', task) taskInstance.env = Environment.getEnvForType( taskInstance.__class__) DelayedTaskThread(taskInstance).start()
def getGui(self, parent: 'Provider', forType: str) -> typing.Iterable[typing.Any]: try: logger.debug('getGui parameters: %s, %s', parent, forType) parentInstance = parent.getInstance() serviceType = parentInstance.getServiceByType(forType) if not serviceType: raise self.invalidItemException( 'Gui for {} not found'.format(forType)) service = serviceType( Environment.getTempEnv(), parentInstance ) # Instantiate it so it has the opportunity to alter gui description based on parent localGui = self.addDefaultFields(service.guiDescription(service), ['name', 'comments', 'tags']) if GlobalConfig.EXPERIMENTAL_FEATURES.getBool(): self.addField( localGui, { 'name': 'proxy_id', 'values': [gui.choiceItem(-1, '')] + gui.sortedChoices([ gui.choiceItem(v.uuid, v.name) for v in models.Proxy.objects.all() ]), 'label': _('Proxy'), 'tooltip': _('Proxy for services behind a firewall'), 'type': gui.InputField.CHOICE_TYPE, 'tab': _('Advanced'), 'order': 132, }, ) else: self.addField( localGui, { 'name': 'proxy_id', 'value': '-1', 'type': gui.InputField.HIDDEN_TYPE, }, ) return localGui except Exception as e: logger.exception('getGui') raise ResponseError(str(e))
def getEnvironment(self): """ Returns an environment valid for the record this object represents """ # from uds.core.util.unique_mac_generator import UniqueMacGenerator # from uds.core.util.unique_name_generator import UniqueNameGenerator return Environment.getEnvForTableElement( self._meta.verbose_name, self.id, { 'mac': unique.UniqueMacGenerator, 'name': unique.UniqueNameGenerator, 'id': unique.UniqueGIDGenerator, })
def getEnvironment(self) -> Environment: """ Returns an environment valid for the record this object represents """ return Environment.getEnvForTableElement( self._meta.verbose_name, self.id, { 'mac': unique.UniqueMacGenerator, 'name': unique.UniqueNameGenerator, 'id': unique.UniqueGIDGenerator, }, )
def getApi(parameters: typing.Dict[str, str]) -> openStack.Client: from .provider_legacy import ProviderLegacy from .provider import OpenStackProvider from uds.core.environment import Environment env = Environment(parameters['ev']) provider: typing.Union[ProviderLegacy, OpenStackProvider] if parameters['legacy'] == 'true': provider = ProviderLegacy(env) else: provider = OpenStackProvider(env) provider.unserialize(parameters['ov']) return provider.api(parameters['project'], parameters['region'])
def getEnvironment(self) -> Environment: """ Returns an environment valid for the record this object represents. In the case of the user, there is an instatiation of "generators". Right now, there is two generators provided to child instance objects, that are valid for generating unique names and unique macs. In a future, there could be more generators To access this generators, use the Envirnment class, and the keys 'name' and 'mac'. (see related classes uds.core.util.unique_name_generator and uds.core.util.unique_mac_generator) """ return Environment.getEnvForTableElement( self._meta.verbose_name, self.id, { 'mac': unique.UniqueMacGenerator, 'name': unique.UniqueNameGenerator, 'id': unique.UniqueGIDGenerator, })
def test(self, type_: str): from uds.core.environment import Environment authType = auths.factory().lookup(type_) if not authType: raise self.invalidRequestException( 'Invalid type: {}'.format(type_)) self.ensureAccess(authType, permissions.PERMISSION_MANAGEMENT, root=True) dct = self._params.copy() dct['_request'] = self._request res = authType.test(Environment.getTempEnv(), dct) if res[0]: return self.success() return res[1]
def test(self, type_: str): from uds.core.environment import Environment logger.debug('Type: %s', type_) spType = services.factory().lookup(type_) if not spType: raise NotFound('Type not found!') tmpEnvironment = Environment.getTempEnv() logger.debug('spType: %s', spType) dct = self._params.copy() dct['_request'] = self._request res = spType.test(tmpEnvironment, dct) if res[0]: return 'ok' return res[1]
def test(self, type_: str): from uds.core.environment import Environment logger.debug('Type: %s', type_) spType = services.factory().lookup(type_) if not spType: raise NotFound('Type not found!') self.ensureAccess(spType, permissions.PERMISSION_MANAGEMENT, root=True) logger.debug('spType: %s', spType) dct = self._params.copy() dct['_request'] = self._request res = spType.test(Environment.getTempEnv(), dct) if res[0]: return 'ok' return res[1]
def getApi( parameters: typing.Dict[str, str]) -> typing.Tuple[openstack.Client, bool]: from .provider_legacy import ProviderLegacy from .provider import OpenStackProvider from uds.core.environment import Environment env = Environment(parameters['ev']) provider: typing.Union[ProviderLegacy, OpenStackProvider] if parameters['legacy'] == 'true': provider = ProviderLegacy(env) else: provider = OpenStackProvider(env) provider.unserialize(parameters['ov']) if isinstance(provider, OpenStackProvider): useSubnetsName = provider.useSubnetsName.isTrue() else: useSubnetsName = False return (provider.api(parameters['project'], parameters['region']), useSubnetsName)
def getEnvironment(self) -> Environment: """ Returns an environment valid for the record this object represents """ return Environment.getEnvForTableElement(self._meta.verbose_name, self.id)
def __init__(self): """ Remember to invoke parent init in derived clases using super(myClass,self).__init__() to let this initialize its own variables """ super().__init__(Environment('DelayedTask'))