def getSoftwareProfileById(self, swProfileId, optionDict=None):
"""
Get software profile information
Returns:
softwareProfile
Throws:
SoftwareProfileNotFound
TortugaException
"""
url = 'v1/softwareProfiles/id/%s' % (swProfileId)
postdata = json.dumps(optionDict or {})
try:
_, responseDict = self.sendSessionRequest(url, data=postdata)
return SoftwareProfile.getFromDict(
responseDict.get('softwareprofile'))
# except HttpErrorException as exc:
except urllib.error.HTTPError as exc:
if exc.code == 404:
raise SoftwareProfileNotFound(
'Software profile ID [%s] not found' % (swProfileId))
except TortugaException:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def updateSoftwareProfile(self, softwareProfileId):
'''
Handle put to softwareprofiles/:(softwareProfileId)
'''
response = None
try:
postdata = cherrypy.request.json
swProfile = SoftwareProfile.getFromDict(postdata)
# Make sure the id is synced
swProfile.setId(softwareProfileId)
self._softwareProfileManager.updateSoftwareProfile(swProfile)
except Exception as ex:
self.getLogger().exception(
'software profile WS API updateSoftwareProfile() failed')
self.handleException(ex)
response = self.errorResponse(str(ex))
return self.formatResponse(response)
def getSoftwareProfile(self, softwareProfileName, optionDict=None):
"""
Get software profile information
Returns:
softwareProfile
Throws:
SoftwareProfileNotFound
TortugaException
"""
url = 'v1/softwareProfiles/%s' % (softwareProfileName)
postdata = json.dumps({'optionDict': optionDict or {}})
try:
_, responseDict = self.sendSessionRequest(
url, method='POST', data=postdata)
return SoftwareProfile.getFromDict(
responseDict.get('softwareprofile'))
except TortugaException as ex:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def getSoftwareProfileById(self, softwareProfileId, optionDict=None):
"""
Get softwareProfile from the db.
Returns:
softwareProfile
Throws:
SoftwareProfileNotFound
DbError
"""
session = DbManager().openSession()
try:
dbSoftwareProfile = self._softwareProfilesDbHandler.\
getSoftwareProfileById(session, softwareProfileId)
self.loadRelations(dbSoftwareProfile, optionDict or {})
return SoftwareProfile.getFromDbDict(dbSoftwareProfile.__dict__)
except TortugaException as ex:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def createSoftwareProfile(self):
"""Create software profile"""
response = None
postdata = cherrypy.request.json
if 'softwareProfile' not in postdata:
raise Exception('Malformed request')
settingsDict = postdata['settingsDict'] \
if 'settingsDict' in postdata else {}
self.getLogger().debug(
'[%s] createSoftwareProfile(): softwareProfile=[%s]' % (
self.__module__, postdata['softwareProfile']))
swProfileSpec = SoftwareProfile.getFromDict(
postdata['softwareProfile'])
try:
SoftwareProfileApi().createSoftwareProfile(
swProfileSpec, settingsDict=settingsDict)
except Exception as ex:
self.getLogger().exception(
'software profile WS API createSoftwareProfile() failed')
self.handleException(ex)
response = self.errorResponse(str(ex))
return self.formatResponse(response)
def getSoftwareProfileById(self, swProfileId,
optionDict: Optional[Dict[str, bool]] = None):
"""
Get software profile information
Returns:
softwareProfile
Throws:
SoftwareProfileNotFound
TortugaException
"""
url = 'softwareprofiles/%d' % (swProfileId)
if optionDict:
for key, value in optionDict.items():
if not value:
continue
url += '&include={}'.format(key)
try:
responseDict = self.get(url)
return SoftwareProfile.getFromDict(
responseDict.get('softwareprofile'))
except urllib.error.HTTPError as exc:
if exc.code == 404:
raise SoftwareProfileNotFound(
'Software profile ID [%s] not found' % (swProfileId))
except TortugaException:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def getSoftwareProfile(self, softwareProfileName,
optionDict: Optional[Dict[str, bool]] = None):
"""
Get software profile information
Returns:
softwareProfile
Throws:
SoftwareProfileNotFound
TortugaException
"""
url = 'softwareprofiles/?name=%s' % (softwareProfileName)
if optionDict:
for key, value in optionDict.items():
if not value:
continue
url += '&include={}'.format(key)
try:
responseDict = self.get(url)
return SoftwareProfile.getListFromDict(responseDict)[0]
except TortugaException:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def getSoftwareProfile(
self,
name: str,
optionDict: Optional[Union[dict, None]] = None) -> SoftwareProfile:
"""
Get softwareProfile from the db.
Returns:
softwareProfile
Throws:
SoftwareProfileNotFound
DbError
"""
session = DbManager().openSession()
try:
dbSoftwareProfile = self._softwareProfilesDbHandler.\
getSoftwareProfile(session, name)
self.loadRelations(dbSoftwareProfile, optionDict)
self.loadRelations(dbSoftwareProfile, dict(tags=True))
return SoftwareProfile.getFromDbDict(dbSoftwareProfile.__dict__)
except TortugaException as ex:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def runCommand(self):
self.parseArgs(_('Create software profile'))
if self.getArgs().name and self.getArgs().deprecated_name:
self.getParser().error(
'argument name: not allowed with argument --name')
name = self.getArgs().name \
if self.getArgs().name else self.getArgs().deprecated_name
# load template if specified with '--template', otherwise build
# template
tmpl_dict = {} if not self.getArgs().jsonTemplatePath else \
self.load_software_profile_template(
self.getArgs().jsonTemplatePath)
if name:
tmpl_dict['name'] = name
if self.getArgs().description:
tmpl_dict['description'] = self.getArgs().description
if self.getArgs().profileType:
tmpl_dict['type'] = self.getArgs().profileType
elif 'type' not in tmpl_dict:
tmpl_dict['type'] = 'compute'
if self.getArgs().tags:
tmpl_dict['tags'] = parse_tags(self.getArgs().tags)
if hasattr(self.getArgs(), 'osInfo'):
tmpl_dict['os'] = {
'name': getattr(self.getArgs(), 'osInfo').getName(),
'version': getattr(self.getArgs(), 'osInfo').getVersion(),
'arch': getattr(self.getArgs(), 'osInfo').getArch(),
}
if self.getArgs().dataRoot:
tmpl_dict['dataRoot'] = self.getArgs().dataRoot
if self.getArgs().dataRsync:
tmpl_dict['dataRsync'] = self.getArgs().dataRsync
sw_profile_spec = SoftwareProfile.getFromDict(tmpl_dict)
api = SoftwareProfileWsApi(username=self.getUsername(),
password=self.getPassword(),
baseurl=self.getUrl(),
verify=self._verify)
# Populate 'settings_dict' from command-line arguments
settings_dict = {
'bOsMediaRequired': self.getArgs().bOsMediaRequired,
'unmanagedProfile': self.getArgs().unmanaged,
}
api.createSoftwareProfile(sw_profile_spec, settings_dict)
def addSoftwareProfile(
self, session: Session,
softwareProfile: SoftwareProfile) -> SoftwareProfileModel:
"""
Insert software profile into the db.
Raises:
SoftwareProfileAlreadyExists
DbError
"""
try:
try:
dbSoftwareProfile = self._softwareProfilesDbHandler.\
getSoftwareProfile(
session, softwareProfile.getName())
raise SoftwareProfileAlreadyExists(
'Software profile [%s] already exists' % (softwareProfile))
except SoftwareProfileNotFound as ex:
pass
dbSoftwareProfile = self.__populateSoftwareProfile(
session, softwareProfile)
session.query(func.max(SoftwareProfileModel.id)).one()
softwareProfile.setId(dbSoftwareProfile.id)
self._logger.info('Added software profile [%s]' %
(dbSoftwareProfile.name))
return dbSoftwareProfile
except TortugaException:
session.rollback()
raise
except Exception as ex:
session.rollback()
self._logger.exception(str(ex))
raise
def getSoftwareProfileList(self, tags=None):
"""
Returns a list of all software profiles in the system.
"""
url = 'v1/softwareProfiles'
try:
_, responseDict = self.sendSessionRequest(url)
return SoftwareProfile.getListFromDict(responseDict)
except TortugaException as ex:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def updateSoftwareProfile(self, softwareProfileObject):
"""
Update the given Software Profile by calling WS API
"""
url = 'softwareprofiles/%s' % (softwareProfileObject.getId())
postdata = softwareProfileObject.getCleanDict()
test = SoftwareProfile.getFromDict(postdata)
try:
self.put(url, postdata)
except Exception as ex:
raise TortugaException(exception=ex)
def __get_software_profile_obj(
self,
software_profile: SoftwareProfileModel,
options: Optional[dict] = None) -> SoftwareProfile:
"""
Deserialize SQLAlchemy object to TortugaObject
"""
self.loadRelations(software_profile, options)
self.loadRelations(software_profile, dict(tags=True))
# if 'components' is specified, ensure 'kit' relationship is
# also serialized
if options and 'components' in options and options['components']:
for component in software_profile.components:
self.loadRelation(component, 'kit')
software_profile_obj = SoftwareProfile.getFromDbDict(
software_profile.__dict__)
return software_profile_obj
def updateSoftwareProfile(self, session: Session,
softwareProfileObject: SoftwareProfile) -> None:
"""
Update a software profile
"""
try:
dbSoftwareProfile = self._softwareProfilesDbHandler.\
getSoftwareProfileById(
session, softwareProfileObject.getId())
self.__populateSoftwareProfile(session, softwareProfileObject,
dbSoftwareProfile)
session.commit()
except TortugaException:
session.rollback()
raise
except Exception as ex:
session.rollback()
self._logger.exception(str(ex))
raise
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 __populateSoftwareProfile(
self, session: Session, softwareProfile: SoftwareProfile,
dbSoftwareProfile: Optional[SoftwareProfileModel] = None) \
-> SoftwareProfileModel:
"""
Helper function for creating/updating dbSoftwareProfile Object
"""
# Validate object
if softwareProfile.getName() is None:
raise UpdateSoftwareProfileFailed('Software profile name required')
if softwareProfile.getType() is None:
raise UpdateSoftwareProfileFailed(
'Software profile must have valid type')
osInfo = softwareProfile.getOsInfo()
if osInfo is None or osInfo.getName() is None:
raise UpdateSoftwareProfileFailed(
'Software profile must have valid operating system')
if dbSoftwareProfile is None:
dbSoftwareProfile = SoftwareProfileModel()
dbOs = self._osDbHandler.addOsIfNotFound(session, osInfo)
dbSoftwareProfile.name = softwareProfile.getName()
dbSoftwareProfile.description = softwareProfile.getDescription()
dbSoftwareProfile.kernel = softwareProfile.getKernel()
dbSoftwareProfile.kernelParams = softwareProfile.getKernelParams()
dbSoftwareProfile.initrd = softwareProfile.getInitrd()
dbSoftwareProfile.os = dbOs
dbSoftwareProfile.type = softwareProfile.getType()
dbSoftwareProfile.minNodes = softwareProfile.getMinNodes()
dbSoftwareProfile.maxNodes = softwareProfile.getMaxNodes()
dbSoftwareProfile.lockedState = softwareProfile.getLockedState()
dbSoftwareProfile.dataRoot = softwareProfile.getDataRoot()
dbSoftwareProfile.dataRsync = softwareProfile.getDataRsync()
# Add partitions
partitions: Dict[Tuple[str, str], Partition] = {}
for partition in softwareProfile.getPartitions():
# This is a new partition
dbPartition = PartitionModel()
dbPartition.name = partition.getName()
dbPartition.device = partition.getDevice()
dbPartition.mountPoint = partition.getMountPoint()
dbPartition.fsType = partition.getFsType()
dbPartition.size = partition.getSize()
dbPartition.options = partition.getOptions()
dbPartition.preserve = partition.getPreserve()
dbPartition.bootLoader = partition.getBootLoader()
dbPartition.diskSize = partition.getDiskSize()
dbPartition.directAttachment = partition.getDirectAttachment()
dbPartition.indirectAttachment = partition.\
getIndirectAttachment()
dbPartition.sanVolume = partition.getSanVolume()
if not dbPartition.name:
raise InvalidPartitionScheme(
'Invalid partition in software profile:'
' missing or empty name')
if not dbPartition.device:
raise InvalidPartitionScheme(
'Invalid partition in software profile:'
' missing or empty device')
if not dbPartition.fsType:
raise InvalidPartitionScheme(
'Invalid partition [%s/%s] in software profile:'
' missing or empty fsType' %
(dbPartition.name, dbPartition.device))
if dbPartition.size is None:
raise InvalidPartitionScheme(
'Invalid partition [%s/%s] in software profile:'
' missing size' % (dbPartition.name, dbPartition.device))
if partitions.get(
(dbPartition.name, dbPartition.device)) is not None:
# Duplicate partition ...error
raise UpdateSoftwareProfileFailed(
'Duplicate partition [%s/%s] found' %
(dbPartition.name, dbPartition.device))
try:
int(dbPartition.size)
except ValueError:
raise InvalidPartitionScheme(
'Invalid partition [%s/%s] in software profile:'
' non-integer size' %
(dbPartition.name, dbPartition.device))
try:
if dbPartition.diskSize is not None:
int(dbPartition.diskSize)
except ValueError:
raise InvalidPartitionScheme(
'Invalid partition [%s/%s] in software profile:'
' non-integer disk size' %
(dbPartition.name, dbPartition.device))
bGrow = partition.getGrow()
if bGrow is not None:
dbPartition.grow = bGrow
maxSize = partition.getMaxSize()
if maxSize is not None:
dbPartition.maxSize = maxSize
partitions[(dbPartition.name, dbPartition.device)] = \
dbPartition
# Delete out the old ones
dbSoftwareProfile.partitions = []
session.flush()
dbSoftwareProfile.partitions = list(partitions.values())
self._set_tags(dbSoftwareProfile, softwareProfile.getTags())
session.add(dbSoftwareProfile)
session.flush()
return dbSoftwareProfile
