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