def __getRuleList(self):
ruleList = TortugaObjectList()
for ruleId in self._ruleDict.keys():
ruleList.append(copy.deepcopy(self._ruleDict[ruleId]))
return ruleList
def getSoftwareUsesHardwareList(self, session: Session):
"""
Get list of all mappings
Returns:
[softwareProfileId, hardwareProfileId]
Throws:
DbError
"""
try:
dbMappings = self._softwareUsesHardwareDbHandler.\
getSoftwareUsesHardwareList(session)
mappingList = TortugaObjectList()
for dbMapping in dbMappings:
mappingList.append((dbMapping.softwareProfileId,
dbMapping.hardwareProfileId))
return mappingList
except TortugaException:
raise
except Exception as ex:
self._logger.exception(str(ex))
raise
def __getVolumeHelper(self, queryVolume=None):
"""
Returns a list of 0 or more volumes if 'queryVolume' is None, otherwise
returns a list containing the requested volume. Raises exception if
'queryVolume' is set and no volumes match.
Raises:
VolumeDoesNotExist
"""
config = self.__read_cache_file()
volumes = TortugaObjectList()
if not config.has_section(self.VOLUME_SECTION_NAME):
return volumes
for item in config.items(self.VOLUME_SECTION_NAME):
volume = item[0]
volinfo = self.__get_volume(volume, config)
if queryVolume:
if volume == queryVolume.lower():
volumes.append(volinfo)
break
else:
volumes.append(volinfo)
if not volumes and queryVolume is not None:
raise VolumeDoesNotExist('Volume [%s] does not exist' %
(queryVolume.lower()))
return volumes
def __convert_nodes_to_TortugaObjectList(
self, nodes: List[NodeModel],
optionDict: Optional[OptionsDict] = None) -> TortugaObjectList:
"""
Return TortugaObjectList of nodes with relations populated
:param nodes: list of Node objects
:param optionDict:
:param deleting: whether or not to include nodes in the deleting
state
:return: TortugaObjectList
"""
nodeList = TortugaObjectList()
for node in nodes:
self.loadRelations(node, optionDict)
# ensure 'resourceadapter' relation is always loaded. This one
# is special since it's a relationship inside of a relationship.
# It needs to be explicitly defined.
self.loadRelation(node.hardwareprofile, 'resourceadapter')
nodeList.append(Node.getFromDbDict(node.__dict__))
return nodeList
def getAllowedHardwareProfilesBySoftwareProfileName(
self, session: Session, softwareProfileName):
"""
Get list of hardware profiles for the given software profile
Returns:
[hardwareProfileId]
Throws:
DbError
"""
try:
dbMappings = self._softwareUsesHardwareDbHandler.\
getAllowedHardwareProfilesBySoftwareProfileName(
session, softwareProfileName)
mappingList = TortugaObjectList()
for dbMapping in dbMappings:
mappingList.append(dbMapping.hardwareProfileId)
return mappingList
except TortugaException:
raise
except Exception as ex:
self._logger.exception(str(ex))
raise
def getSoftwareUsesHardwareList(self):
"""
Get list of all mappings
Returns:
[softwareProfileId, hardwareProfileId]
Throws:
DbError
"""
session = DbManager().openSession()
try:
dbMappings = self._softwareUsesHardwareDbHandler.\
getSoftwareUsesHardwareList(session)
mappingList = TortugaObjectList()
for dbMapping in dbMappings:
mappingList.append(
(dbMapping.softwareProfileId, dbMapping.hardwareProfileId))
return mappingList
except TortugaException as ex:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def getEnabledComponentList(self, session: Session,
name: str) -> TortugaObjectList:
"""
Get a list of enabled components from the db.
Returns:
node
Throws:
DbError
"""
try:
componentList = TortugaObjectList()
for c in self._softwareProfilesDbHandler.getSoftwareProfile(
session, name).components:
self.loadRelation(c, 'kit')
componentList.append(Component.getFromDbDict(c.__dict__))
return componentList
except TortugaException:
raise
except Exception as ex:
self._logger.exception(str(ex))
raise
def getChildrenList(self, nodeName):
"""return the list of children currently on this node"""
url = 'v1/nodes/%s/children' % (nodeName)
try:
_, responseDict = self.sendSessionRequest(url)
nodeList = TortugaObjectList()
if responseDict:
if 'nodes' in responseDict:
cDicts = responseDict.get('nodes')
for cDict in cDicts:
node = tortuga.objects.node.Node.getFromDict(cDict)
nodeList.append(node)
else:
node = tortuga.objects.node.Node.getFromDict(
responseDict.get('node'))
nodeList.append(node)
return nodeList
except TortugaException:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def getNodeList(self, session: Session,
softwareProfile: SoftwareProfile) -> TortugaObjectList:
"""
Get list of nodes in 'softwareProfile'
Returns:
[node]
Throws:
DbError
"""
try:
dbSoftwareProfile = \
self._softwareProfilesDbHandler.getSoftwareProfile(
session, softwareProfile)
nodeList = TortugaObjectList()
for dbNode in dbSoftwareProfile.nodes:
self.loadRelation(dbNode, 'hardwareprofile')
nodeList.append(Node.getFromDbDict(dbNode.__dict__))
return nodeList
except TortugaException:
raise
except Exception as ex:
self._logger.exception(str(ex))
raise
def getNodeList(self, softwareProfile):
"""
Get list of nodes in 'softwareProfile'
Returns:
[node]
Throws:
DbError
"""
session = DbManager().openSession()
try:
dbSoftwareProfile = self._softwareProfilesDbHandler.\
getSoftwareProfile(session, softwareProfile)
nodeList = TortugaObjectList()
for dbNode in dbSoftwareProfile.nodes:
self.loadRelation(dbNode, 'hardwareprofile')
nodeList.append(Node.getFromDbDict(dbNode.__dict__))
return nodeList
except TortugaException as ex:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def getFromDbDict(cls, _dict, ignore: Optional[Iterable[str]] = None):
hardwareProfile = super(HardwareProfile,
cls).getFromDict(_dict, ignore=ignore)
hardwareProfile.setAdmins(
tortuga.objects.admin.Admin.getListFromDbDict(_dict))
if ignore and 'nodes' not in ignore:
hardwareProfile.setNodes(
tortuga.objects.node.Node.getListFromDbDict(_dict))
hardwareProfile.setProvisioningNics(
tortuga.objects.nic.Nic.getListFromDbDict(_dict))
resourceAdapterDict = _dict.get(
tortuga.objects.resourceAdapter.ResourceAdapter.ROOT_TAG)
if resourceAdapterDict:
hardwareProfile.setResourceAdapter(
tortuga.objects.resourceAdapter.ResourceAdapter.getFromDict(
resourceAdapterDict.__dict__))
defaultResourceAdapterConfig = _dict.get(
'default_resource_adapter_config')
if defaultResourceAdapterConfig:
hardwareProfile.setDefaultResourceAdapterConfig(
defaultResourceAdapterConfig.name)
if _dict.get('idlesoftwareprofile'):
hardwareProfile.setIdleSoftwareProfile(
tortuga.objects.softwareProfile.SoftwareProfile.getFromDbDict(
_dict.get('idlesoftwareprofile').__dict__))
# hardwareprofilenetworks (relation)
hardwareProfileNetworks = _dict.get('hardwareprofilenetworks')
if hardwareProfileNetworks:
networkList = TortugaObjectList()
for item in hardwareProfileNetworks:
networkDict = item.network.__dict__
networkDeviceDict = item.networkdevice.__dict__
network = tortuga.objects.network.Network.getFromDbDict(
networkDict)
networkdevice = tortuga.objects.networkDevice.\
NetworkDevice.getFromDbDict(networkDeviceDict)
network.setNetworkDevice(networkdevice)
networkList.append(network)
hardwareProfile.setNetworks(networkList)
tags = {tag.name: tag.value for tag in _dict.get('tags', [])}
hardwareProfile.setTags(tags)
return hardwareProfile
def getEnabledComponentList(self, name):
"""
Get a list of enabled components from the db.
Returns:
node
Throws:
DbError
"""
session = DbManager().openSession()
try:
componentList = TortugaObjectList()
for c in self._softwareProfilesDbHandler.getSoftwareProfile(
session, name).components:
self.loadRelation(c, 'kit')
componentList.append(Component.getFromDbDict(c.__dict__))
return componentList
except TortugaException as ex:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def getSoftwareProfileList(self, session: Session, tags=None):
"""
Get list of all available softwareProfiles from the db.
Returns:
[softwareProfile]
Throws:
DbError
"""
try:
dbSoftwareProfileList = \
self._softwareProfilesDbHandler.getSoftwareProfileList(
session, tags=tags)
softwareProfileList = TortugaObjectList()
for dbSoftwareProfile in dbSoftwareProfileList:
softwareProfileList.append(
self.__get_software_profile_obj(dbSoftwareProfile,
options={
'components': True,
'partitions': True,
'hardwareprofiles':
True,
'tags': True,
}))
return softwareProfileList
except TortugaException:
raise
except Exception as ex:
self._logger.exception(str(ex))
raise
def getAllowedHardwareProfilesBySoftwareProfileName(
self, softwareProfileName):
"""
Get list of hardware profiles for the given software profile
Returns:
[hardwareProfileId]
Throws:
DbError
"""
session = DbManager().openSession()
try:
dbMappings = self._softwareUsesHardwareDbHandler.\
getAllowedHardwareProfilesBySoftwareProfileName(
session, softwareProfileName)
mappingList = TortugaObjectList()
for dbMapping in dbMappings:
mappingList.append(dbMapping.hardwareProfileId)
return mappingList
except TortugaException as ex:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def getNodeList(self,
nodespec: Optional[Union[str, None]] = None,
tags: Optional[Union[dict, None]] = None,
addHostSession: Optional[Union[str, None]] = None):
"""
Get list of nodes
Returns:
a list of nodes
Throws:
TortugaException
"""
url = 'nodes/'
if nodespec:
url += '?name={}'.format(nodespec)
if addHostSession:
url += '?addHostSession={}'.format(addHostSession)
if tags:
params = []
for key, value in tags.items():
if value is None:
params.append(urllib.parse.urlencode({'tag': key}))
else:
params.append(
urllib.parse.urlencode(
{'tag': '{0}={1}'.format(key, value)}))
if params:
url += '?' + '&'.join(params)
try:
responseDict = self.get(url)
nodeList = TortugaObjectList()
if 'nodes' in responseDict:
for cDict in responseDict['nodes']:
node = tortuga.objects.node.Node.getFromDict(cDict)
nodeList.append(node)
else:
node = tortuga.objects.node.Node.getFromDict(
responseDict.get('node'))
nodeList.append(node)
return nodeList
except TortugaException:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def getFromDbDict(cls, _dict):
hardwareProfile = super(HardwareProfile, cls).getFromDict(_dict)
hardwareProfile.setAdmins(
tortuga.objects.admin.Admin.getListFromDbDict(_dict))
hardwareProfile.setNodes(
tortuga.objects.node.Node.getListFromDbDict(_dict))
hardwareProfile.setProvisioningNics(
tortuga.objects.nic.Nic.getListFromDbDict(_dict))
resourceAdapterDict = _dict.get(
tortuga.objects.resourceAdapter.ResourceAdapter.ROOT_TAG)
if resourceAdapterDict:
hardwareProfile.setResourceAdapter(
tortuga.objects.resourceAdapter.ResourceAdapter.getFromDict(
resourceAdapterDict.__dict__))
if _dict.get('idlesoftwareprofile'):
hardwareProfile.setIdleSoftwareProfile(
tortuga.objects.softwareProfile.SoftwareProfile.getFromDbDict(
_dict.get('idlesoftwareprofile').__dict__))
# hardwareprofilenetworks (relation)
hardwareProfileNetworks = _dict.get('hardwareprofilenetworks')
if hardwareProfileNetworks:
networkList = TortugaObjectList()
for item in hardwareProfileNetworks:
networkDict = item.network.__dict__
networkDeviceDict = item.networkdevice.__dict__
network = tortuga.objects.network.Network.getFromDbDict(
networkDict)
networkdevice = tortuga.objects.networkDevice.\
NetworkDevice.getFromDbDict(networkDeviceDict)
network.setNetworkDevice(networkdevice)
networkList.append(network)
hardwareProfile.setNetworks(networkList)
if 'tags' in _dict:
tags = {}
for tag in _dict['tags']:
tags[tag.name] = tag.value
hardwareProfile.setTags(tags)
return hardwareProfile
def getUniqueOsInfoList(self):
""" Get list of unique operating systems. """
osInfoList = TortugaObjectList()
for c in self['componentList']:
isDuplicate = False
for osInfo in osInfoList:
if c.getOsInfo() == osInfo:
isDuplicate = True
break
if not isDuplicate:
osInfoList.append(c.getOsInfo())
return osInfoList
def getNodeVolumes(self, nodeName):
vols = TortugaObjectList()
for drive in self.__getAllNodeDrives(nodeName):
try:
driveinfo = self.__getDriveInfo(nodeName, drive)
vols.append(driveinfo.volume)
except Exception as ex:
self.getLogger().debug(
'[%s] Error getting info for node [%s] drive [%s]:'
' %s' % (self.__class__.__name__, nodeName, drive, ex))
return vols
def getNodeList(self, tags=None):
"""
Get list of nodes
Returns:
a list of nodes
Throws:
TortugaException
"""
url = 'v1/nodes'
if tags:
params = []
for key, value in tags.items():
if value is None:
params.append(urllib.parse.urlencode({'tag': key}))
else:
params.append(
urllib.parse.urlencode(
{'tag': '{0}={1}'.format(key, value)}))
if params:
url += '?' + '&'.join(params)
try:
_, responseDict = self.sendSessionRequest(url)
nodeList = TortugaObjectList()
if 'nodes' in responseDict:
for cDict in responseDict['nodes']:
node = tortuga.objects.node.Node.getFromDict(cDict)
nodeList.append(node)
else:
node = tortuga.objects.node.Node.getFromDict(
responseDict.get('node'))
nodeList.append(node)
return nodeList
except TortugaException:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def __convert_nodes_to_TortugaObjectList(
self,
nodes,
relations: Optional[Union[dict,
None]] = None) -> TortugaObjectList:
nodeList = TortugaObjectList()
relations = relations or dict(softwareprofile=True,
hardwareprofile=True)
for t in nodes:
self.loadRelations(t, relations)
# Always load 'tags' relation
self.loadRelations(t, {'tags': True})
node = Node.getFromDbDict(t.__dict__)
nodeList.append(node)
return nodeList
def getHardwareProfileList(self,
optionDict: Optional[Union[dict, None]] = None,
tags: Optional[Union[dict, None]] = None):
"""
Get list of all available hardwareProfiles from the db.
Returns:
[hardwareProfile]
Throws:
DbError
"""
session = DbManager().openSession()
try:
dbHardwareProfileList = self._hardwareProfilesDbHandler.\
getHardwareProfileList(session, tags=tags)
hardwareProfileList = TortugaObjectList()
for dbHardwareProfile in dbHardwareProfileList:
# For now expand networks
self.loadRelation(dbHardwareProfile, 'hardwareprofilenetworks')
self.loadRelations(dbHardwareProfile, optionDict)
self.loadRelations(dbHardwareProfile, dict(tags=True))
hardwareProfileList.append(
HardwareProfile.getFromDbDict(dbHardwareProfile.__dict__))
return hardwareProfileList
except TortugaException as ex:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def getSoftwareProfileList(self, tags=None):
"""
Get list of all available softwareProfiles from the db.
Returns:
[softwareProfile]
Throws:
DbError
"""
session = DbManager().openSession()
try:
dbSoftwareProfileList = self._softwareProfilesDbHandler.\
getSoftwareProfileList(session, tags=tags)
softwareProfileList = TortugaObjectList()
for dbSoftwareProfile in dbSoftwareProfileList:
self.loadRelations(
dbSoftwareProfile, {
'components': True,
'partitions': True,
'hardwareprofiles': True,
'tags': True,
})
softwareProfileList.append(
SoftwareProfile.getFromDbDict(dbSoftwareProfile.__dict__))
return softwareProfileList
except TortugaException as ex:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def getHardwareProfileList(
self,
session: Session,
optionDict: Optional[OptionDict] = None,
tags: Optional[Tags] = None) -> TortugaObjectList:
"""
Get list of all available hardwareProfiles from the db.
Returns:
[hardwareProfile]
Throws:
DbError
"""
try:
dbHardwareProfileList = \
self._hardwareProfilesDbHandler.getHardwareProfileList(
session, tags=tags)
hardwareProfileList = TortugaObjectList()
for dbHardwareProfile in dbHardwareProfileList:
options = dict.copy(optionDict or {})
options['hardwareprofilenetworks'] = True
self.loadRelations(dbHardwareProfile,
get_default_relations(options))
hardwareProfileList.append(
HardwareProfile.getFromDbDict(dbHardwareProfile.__dict__))
return hardwareProfileList
except TortugaException:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
def getOsFamilyInfoList(self):
"""Get OS family info"""
osInfoList = TortugaObjectList()
for osFamilyComponent in self.getOsFamilyComponentList():
osInfoList.append(osFamilyComponent.getOsFamilyInfo())
return osInfoList
def runCommand(self):
self.parseArgs()
if not self.getArgs().name and \
not self.getArgs().hardwareProfileName:
self.getParser().error(
'the following arguments are required: NAME')
if self.getArgs().name and self.getArgs().hardwareProfileName:
self.getParser().error(
'argument name: not allowed with argument --name')
name = self.getArgs().name \
if self.getArgs().name else self.getArgs().hardwareProfileName
api = HardwareProfileWsApi(username=self.getUsername(),
password=self.getPassword(),
baseurl=self.getUrl(),
verify=self._verify)
spApi = SoftwareProfileWsApi(username=self.getUsername(),
password=self.getPassword(),
baseurl=self.getUrl(),
verify=self._verify)
nodeApi = NodeWsApi(username=self.getUsername(),
password=self.getPassword(),
baseurl=self.getUrl(),
verify=self._verify)
hp = api.getHardwareProfile(name, UpdateHardwareProfileCli.optionDict)
if self.getArgs().newName is not None:
hp.setName(self.getArgs().newName)
if self.getArgs().description is not None:
hp.setDescription(self.getArgs().description)
if self.getArgs().nameFormat is not None:
hp.setNameFormat(self.getArgs().nameFormat)
if self.getArgs().kernel is not None:
hp.setKernel(self.getArgs().kernel)
if self.getArgs().kernelParameters is not None:
hp.setKernelParams(self.getArgs().kernelParameters)
if self.getArgs().initrd is not None:
hp.setInitrd(self.getArgs().initrd)
if self.getArgs().soAllowed is not None:
if self.getArgs().soAllowed.lower() == _('true'):
hp.setSoftwareOverrideAllowed(True)
elif self.getArgs().soAllowed.lower() == _('false'):
hp.setSoftwareOverrideAllowed(False)
else:
raise InvalidCliRequest(
_('--software-override-allowed must be either "true" or'
' "false".'))
if self.getArgs().idleProfile is not None and \
self.getArgs().bUnsetIdleProfile:
raise InvalidCliRequest(
_('Conflicting options --idle-software-profile and'
' --unset-idle-software-profile'))
if self.getArgs().idleProfile is not None:
sp = spApi.getSoftwareProfile(self.getArgs().idleProfile)
hp.setIdleSoftwareProfileId(sp.getId())
if self.getArgs().bUnsetIdleProfile:
hp.setIdleSoftwareProfileId(None)
if self.getArgs().location is not None:
hp.setLocation(self.getArgs().location)
if self.getArgs().localBootParameters is not None:
hp.setLocalBootParams(self.getArgs().localBootParameters)
if self.getArgs().cost is not None:
hp.setCost(self.getArgs().cost)
if self.getArgs().resourceAdapter:
resourceAdapter = ResourceAdapter(
name=self.getArgs().resourceAdapter)
hp.setResourceAdapter(resourceAdapter)
if self.getArgs().default_adapter_config:
hp.setDefaultResourceAdapterConfig(
self.getArgs().default_adapter_config)
if self.getArgs().deletePNic is not None:
out = TortugaObjectList()
for nic in hp.getProvisioningNics():
for dnic in self.getArgs().deletePNic:
if dnic == nic.getIp():
# Skip over this item..its getting deleted
break
else:
# Not a NIC we are deleting
out.append(nic)
hp.setProvisioningNics(out)
if self.getArgs().addPNic is not None:
for nicIp in self.getArgs().addPNic:
nicsNode = nodeApi.getNodeByIp(nicIp)
if nicsNode is not None:
for nic in nicsNode.getNics():
if nic.getIp() == nicIp:
hp.getProvisioningNics().append(nic)
break
if self.getArgs().deleteNetwork is not None:
# Make sure we actually delete a network
out = TortugaObjectList()
out.extend(hp.getNetworks())
for netstring in self.getArgs().deleteNetwork:
try:
dnet, dmask, ddev = netstring.split('/')
except ValueError:
raise InvalidCliRequest(
_('Incorrect input format for --delete-network'
' ("address/mask/device")'))
for network in hp.getNetworks():
if dnet == network.getAddress() and \
dmask == network.getNetmask() and \
ddev == network.getNetworkDevice().getName():
# Skip over this item..its getting deleted
for n in out:
if n.getId() == network.getId():
out.remove(n)
break
break
else:
# Not a NIC we are deleting
print('Ignoring deletion of non-existent network:'
' %s/%s/%s' % (dnet, dmask, ddev))
hp.setNetworks(out)
if self.getArgs().addNetwork:
for netstring in self.getArgs().addNetwork:
try:
anet, amask, adev = netstring.split('/')
except ValueError:
raise InvalidCliRequest(
_('Incorrect input format for --add-network'
' ("address/mask/device")'))
network = Network()
networkDevice = NetworkDevice()
networkDevice.setName(adev)
network.setAddress(anet)
network.setNetmask(amask)
network.setNetworkDevice(networkDevice)
hp.getNetworks().append(network)
if self.getArgs().tags:
tags = hp.getTags()
tags.update(parse_tags(self.getArgs().tags))
hp.setTags(tags)
if self.getArgs().remove_tags:
tags = hp.getTags()
for string in self.getArgs().remove_tags:
for tag_name in string.split(','):
if tag_name in tags.keys():
tags.pop(tag_name)
hp.setTags(tags)
api.updateHardwareProfile(hp)
def runCommand(self):
self.parseArgs(usage=_("""
Updates software profile in the Tortuga system.
"""))
if not self.getArgs().name and \
not self.getArgs().softwareProfileName:
self.getParser().error(
'the following arguments are required: NAME'
)
if self.getArgs().name and self.getArgs().softwareProfileName:
self.getParser().error(
'argument name: not allowed with argument --name'
)
name = self.getArgs().name \
if self.getArgs().name else self.getArgs().softwareProfileName
api = SoftwareProfileWsApi(username=self.getUsername(),
password=self.getPassword(),
baseurl=self.getUrl(),
verify=self._verify)
sp = api.getSoftwareProfile(name, UpdateSoftwareProfileCli.optionDict)
if self.getArgs().new_name is not None:
sp.setName(self.getArgs().new_name)
if self.getArgs().description is not None:
sp.setDescription(self.getArgs().description)
if self.getArgs().kernel is not None:
sp.setKernel(self.getArgs().kernel)
if self.getArgs().kernelParameters is not None:
sp.setKernelParams(self.getArgs().kernelParameters)
if self.getArgs().initrd is not None:
sp.setInitrd(self.getArgs().initrd)
if self.getArgs().unlock:
if self.getArgs().soft_locked is not None:
raise InvalidCliRequest(
'--soft-locked/--hard-locked arguments and --unlock'
' argument are mutually exclusive'
)
sp.setLockedState('Unlocked')
if self.getArgs().soft_locked is not None:
sp.setLockedState(
'SoftLocked' if self.getArgs().soft_locked else 'HardLocked')
if self.getArgs().min_nodes is not None:
# update min_nodes value
try:
if self.getArgs().min_nodes.lower() == 'none':
min_nodes = -1
else:
min_nodes = int(self.getArgs().min_nodes)
except ValueError:
raise InvalidCliRequest(
'Invalid argument value for --min-nodes')
sp.setMinNodes(min_nodes)
else:
min_nodes = sp.getMinNodes()
if self.getArgs().max_nodes:
try:
max_nodes = -1 \
if self.getArgs().max_nodes.lower() == 'none' else \
int(self.getArgs().max_nodes)
except ValueError:
raise InvalidCliRequest(
'Invalid argument value for --max-nodes'
)
# update maxNodes value
if max_nodes < min_nodes:
# do not allow max nodes to be less than min nodes
raise InvalidCliRequest(
'Maximum number of allowed nodes must be greater or equal'
' to the mininum number of required nodes'
)
sp.setMaxNodes(max_nodes)
if self.getArgs().deletePartition is not None:
out = TortugaObjectList()
for p in sp.getPartitions():
for dp in self.getArgs().deletePartition:
if dp == p.getName():
# Skip over this item..its getting deleted
break
else:
# Not a partition we are deleting
out.append(p)
sp.setPartitions(out)
partitionObject = None
if self.getArgs().updatePartition:
if self.getArgs().addPartition:
raise InvalidCliRequest(
_('Must provide only one of --update-partition and'
' --add-partition'))
for p in sp.getPartitions():
if p.getName() == self.getArgs().updatePartition:
partitionObject = p
break
else:
raise InvalidCliRequest(
_('Cannot update non-existent partition "%s"') % (
self.getArgs().updatePartition))
if self.getArgs().addPartition:
from tortuga.objects.partition import Partition
partitionObject = Partition()
partitionObject.setName(self.getArgs().addPartition)
sp.getPartitions().append(partitionObject)
if self.getArgs().device is None or \
self.getArgs().fileSystem is None or \
self.getArgs().size is None:
raise InvalidCliRequest(
_('--device, --file-system, and --size options required'
' with --add-partition'))
if self.getArgs().grow:
if not partitionObject:
raise InvalidCliRequest(
_('The --grow/--no-grow options is only allowed with'
' --update-partition or --add-partition'))
partitionObject.setGrow(self.getArgs().grow)
if self.getArgs().maxsize:
if not partitionObject:
raise InvalidCliRequest(
_('The --max-size option is only allowed with'
' --update-partition or --add-partition'))
partitionObject.setMaxSize(self.getArgs().maxsize)
if self.getArgs().device is not None:
if partitionObject is None:
raise InvalidCliRequest(
_('The --device option is only allowed with'
' --update-partition or --add-partition'))
partitionObject.setDevice(self.getArgs().device)
if self.getArgs().mountPoint is not None:
if partitionObject is None:
raise InvalidCliRequest(
_('--mount-point option only allowed with'
' --update-partition or --add-partition'))
partitionObject.setMountPoint(self.getArgs().mountPoint)
if self.getArgs().fileSystem is not None:
if partitionObject is None:
raise InvalidCliRequest(
_('The --file-system option only allowed with'
' --update-partition or --add-partition'))
partitionObject.setFsType(self.getArgs().fileSystem)
if self.getArgs().size is not None:
if partitionObject is None:
raise InvalidCliRequest(
_('--size option only allowed with --update-partition or'
' --add-partition'))
partitionObject.setSize(self._parseDiskSize(self.getArgs().size))
if self.getArgs().options is not None:
if partitionObject is None:
raise InvalidCliRequest(
_('--options option only allowed with --update-partition'
' or --add-partition'))
partitionObject.setOptions(self.getArgs().options)
if self.getArgs().directAttachment is not None:
if partitionObject is None:
raise InvalidCliRequest(
_('--direct-attachment option only allowed with'
' --update-partition or --add-partition'))
partitionObject.setDirectAttachment(
self.getArgs().directAttachment)
if self.getArgs().indirectAttachment is not None:
if partitionObject is None:
raise InvalidCliRequest(
_('--indirect-attachment option only allowed with'
' --update-partition or --add-partition'))
partitionObject.setIndirectAttachment(
self.getArgs().indirectAttachment)
if self.getArgs().diskSize is not None:
if partitionObject is None:
raise InvalidCliRequest(
_('--disk-size option only allowed with'
' --update-partition or --add-partition'))
try:
partitionObject.setDiskSize(
self._parseDiskSize(self.getArgs().diskSize))
except ValueError:
raise InvalidCliRequest(_('Invalid --disk-size argument'))
if self.getArgs().sanVolume is not None:
if partitionObject is None:
raise InvalidCliRequest(
_('--san-volume option only allowed with'
' --update-partition or --add-partition'))
partitionObject.setSanVolume(self.getArgs().sanVolume)
if self.getArgs().preserve is None:
if self.getArgs().addPartition is not None:
raise InvalidCliRequest(
_('--preserve or --no-preserve must be specified when'
' adding a new partition.'))
else:
if partitionObject is None:
raise InvalidCliRequest(
_('--preserve and --no-preserve options are only allowed'
' with --update-partition or --add-partition'))
partitionObject.setPreserve(self.getArgs().preserve)
if self.getArgs().bootLoader is None:
if self.getArgs().addPartition is not None:
raise InvalidCliRequest(
_('--boot-loader or --no-boot-loader must be specified'
' when adding a new partition.'))
else:
if partitionObject is None:
raise InvalidCliRequest(
_('--boot-loader and --no-boot-loader options only'
' allowed with --update-partition or --add-partition'))
partitionObject.setBootLoader(self.getArgs().bootLoader)
if self.getArgs().tags:
tags = sp.getTags()
tags.update(parse_tags(self.getArgs().tags))
sp.setTags(tags)
print(tags) # DEBUG
if self.getArgs().remove_tags:
tags = sp.getTags()
for string in self.getArgs().remove_tags:
for tag_name in string.split(','):
if tag_name in tags.keys():
tags.pop(tag_name)
sp.setTags(tags)
print(tags) # DEBUG
if self.getArgs().dataRoot is not None:
sp.setDataRoot(self.getArgs().dataRoot)
if self.getArgs().dataRsync is not None:
sp.setDataRsync(self.getArgs().dataRsync)
api.updateSoftwareProfile(sp)
def getOsInfoList(self):
""" Get OS info. """
osInfoList = TortugaObjectList()
for osComponent in self.getOsComponentList():
osInfoList.append(osComponent.getOsInfo())
return osInfoList
