def updateHardwareProfile(
self, session: Session,
hardwareProfileObject: HardwareProfile) -> None:
"""
Update Hardware Profile Object
"""
try:
dbHardwareProfile = \
self._hardwareProfilesDbHandler.getHardwareProfileById(
session, hardwareProfileObject.getId())
self.__populateHardwareProfile(
session, hardwareProfileObject, dbHardwareProfile)
self._set_tags(dbHardwareProfile, hardwareProfileObject.getTags())
session.commit()
except TortugaException:
session.rollback()
raise
except Exception as ex:
session.rollback()
self._logger.exception(str(ex))
raise
def createHardwareProfile(self,
hwProfile: HardwareProfile,
settingsDict: Optional[Union[dict,
None]] = None):
"""
Create hardware profile from template
Returns:
None
Throws:
TortugaException
"""
url = 'hardwareprofiles/'
postdata = {
'hardwareProfile': hwProfile.getCleanDict(),
'settingsDict': settingsDict,
}
try:
responseDict = self.post(url, postdata)
return responseDict
except TortugaException as ex:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def getHardwareProfileById(
self,
session: Session,
hardwareProfileId: int,
optionDict: Optional[OptionDict] = None) -> HardwareProfile:
"""
Get hardwareProfile from the db.
Returns:
hardwareProfile
Throws:
HardwareProfileNotFound
DbError
"""
try:
dbHardwareProfile = \
self._hardwareProfilesDbHandler.getHardwareProfileById(
session, hardwareProfileId)
self.loadRelations(dbHardwareProfile,
get_default_relations(optionDict))
return HardwareProfile.getFromDbDict(dbHardwareProfile.__dict__)
except TortugaException:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
def getHardwareProfile(self,
name: str,
optionDict: Optional[Union[dict, None]] = None):
"""
Get hardwareProfile from the db.
Returns:
hardwareProfile
Throws:
HardwareProfileNotFound
DbError
"""
session = DbManager().openSession()
try:
dbHardwareProfile = self._hardwareProfilesDbHandler.\
getHardwareProfile(session, name)
self.loadRelations(dbHardwareProfile, optionDict)
self.loadRelations(dbHardwareProfile, dict(tags=True))
return HardwareProfile.getFromDbDict(dbHardwareProfile.__dict__)
except TortugaException as ex:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def createHardwareProfile(self):
"""
Create hardware profile
"""
response = None
postdata = cherrypy.request.json
hwProfileDict = postdata['hardwareProfile']
settingsDict = postdata['settingsDict'] \
if 'settingsDict' in postdata else {}
if 'osInfo' in settingsDict and settingsDict['osInfo']:
settingsDict['osInfo'] = OsInfo.getFromDict(settingsDict['osInfo'])
hwProfile = HardwareProfile.getFromDict(hwProfileDict)
try:
HardwareProfileManager().createHardwareProfile(
cherrypy.request.db, hwProfile, settingsDict=settingsDict)
except Exception as ex:
self.getLogger().exception(
'hardware profile WS API createHardwareProfile() failed')
self.getLogger().exception(ex)
self.handleException(ex)
response = self.errorResponse(str(ex))
return self.formatResponse(response)
def getHardwareProfileById(self, hardwareProfileId, optionDict=None):
"""
Get hardwareProfile from the db.
Returns:
hardwareProfile
Throws:
HardwareProfileNotFound
DbError
"""
session = DbManager().openSession()
try:
dbHardwareProfile = self._hardwareProfilesDbHandler.\
getHardwareProfileById(session, hardwareProfileId)
self.loadRelations(dbHardwareProfile, optionDict or {})
return HardwareProfile.getFromDbDict(dbHardwareProfile.__dict__)
except TortugaException as ex:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def updateHardwareProfile(self, hardwareProfileId):
"""
Handle PUT to "hardwareprofiles/:(hardwareProfileId)"
"""
response = None
try:
postdata = cherrypy.request.json
hw_profile = HardwareProfile.getFromDict(postdata)
hw_profile.setId(hardwareProfileId)
hp_mgr = HardwareProfileManager()
hp_mgr.updateHardwareProfile(cherrypy.request.db, hw_profile)
except HardwareProfileNotFound as ex:
self.handleException(ex)
code = self.getTortugaStatusCode(ex)
response = self.notFoundErrorResponse(str(ex), code)
except Exception as ex:
self._logger.exception(
'hardware profile WS API updateHardwareProfile() failed')
self.handleException(ex)
response = self.errorResponse(str(ex))
return self.formatResponse(response)
def getHardwareProfile(self, session: Session, name: str,
optionDict: Optional[OptionDict] = None) \
-> HardwareProfile:
"""
Get hardwareProfile from the db.
Returns:
hardwareProfile
Throws:
HardwareProfileNotFound
DbError
"""
try:
dbHardwareProfile = \
self._hardwareProfilesDbHandler.getHardwareProfile(
session, name)
self.loadRelations(
dbHardwareProfile, get_default_relations(optionDict))
return HardwareProfile.getFromDbDict(
dbHardwareProfile.__dict__)
except TortugaException:
raise
except Exception as ex:
self._logger.exception(str(ex))
raise
def updateHardwareProfile(self, hardwareProfileId):
'''
Handle PUT to "hardwareprofiles/:(hardwareProfileId)"
'''
response = None
try:
postdata = cherrypy.request.json
hwProfile = HardwareProfile.getFromDict(postdata)
# Make sure the id is synced
hwProfile.setId(hardwareProfileId)
hpMgr = HardwareProfileManager()
hpMgr.updateHardwareProfile(hwProfile)
except HardwareProfileNotFound as ex:
self.handleException(ex)
code = self.getTortugaStatusCode(ex)
response = self.notFoundErrorResponse(str(ex), code)
except Exception as ex:
self.getLogger().exception(
'hardware profile WS API updateHardwareProfile() failed')
self.handleException(ex)
response = self.errorResponse(str(ex))
return self.formatResponse(response)
def addHardwareProfile(
self, session: Session,
hardwareProfile: HardwareProfile) -> None:
"""
Insert hardwareProfile into the db.
Returns:
(none)
Throws:
HardwareProfileAlreadyExists
DbError
"""
try:
try:
self._hardwareProfilesDbHandler.getHardwareProfile(
session, hardwareProfile.getName())
raise HardwareProfileAlreadyExists(
'Hardware profile [%s] already exists' % (
hardwareProfile))
except HardwareProfileNotFound as ex:
pass
dbHardwareProfile = self.__populateHardwareProfile(
session, hardwareProfile)
session.add(dbHardwareProfile)
session.flush()
self._set_tags(dbHardwareProfile, hardwareProfile.getTags())
session.commit()
self._logger.info(
'Added hardware profile [%s]' % (dbHardwareProfile.name))
except TortugaException:
session.rollback()
raise
except Exception as ex:
session.rollback()
self._logger.exception(str(ex))
raise
def test_serialization():
hp = HardwareProfile()
hp.setName('test')
hp.setDefaultResourceAdapterConfig('resadapterconfig')
hp_dict = hp.getCleanDict()
assert hp_dict['name'] == 'test'
assert 'default_resource_adapter_config' in hp_dict
def test_deserialization():
name = 'testEXAMPLE'
cfg_name = 'configEXAMPLE'
hp_dict = {
'name': name,
'default_resource_adapter_config': cfg_name,
}
hp = HardwareProfile.getFromDict(hp_dict)
assert hp.getName() == name
assert hp.getDefaultResourceAdapterConfig() == cfg_name
def test_addHardwareProfile(dbm):
"""
Add new hardware profile
"""
hwprofile = HardwareProfile()
hwprofile.setName('example')
hwprofile.setNameFormat('compute-#NN')
with dbm.session() as session:
hardwareProfileDbApi.addHardwareProfile(session, hwprofile)
stored_hwprofile = hardwareProfileDbApi.getHardwareProfile(
session, hwprofile.getName())
assert stored_hwprofile.getName() == hwprofile.getName()
hardwareProfileDbApi.updateHardwareProfile(session, stored_hwprofile)
def getHardwareProfileList(self,
optionDict: Optional[Union[dict, None]] = None,
tags=None): \
# pylint: disable=unused-argument
"""
Get list of hardware profiles by calling WS API
"""
url = 'hardwareprofiles/'
# TODO: add support for building query string with 'tags'
try:
responseDict = self.get(url)
return HardwareProfile.getListFromDict(responseDict)
except Exception as ex:
raise TortugaException(exception=ex)
def getHardwareProfileList(self, optionDict=None, tags=None):
"""
Get list of hardware profiles by calling WS API
"""
url = 'v1/hardwareProfiles'
# TODO: add support for building query string with 'tags'
postdata = json.dumps(optionDict or {})
try:
(response, responseDict) = self.sendSessionRequest(url,
data=postdata)
return HardwareProfile.getListFromDict(responseDict)
except Exception as ex:
raise TortugaException(exception=ex)
def getHardwareProfileById(self, id_, optionDict=None):
"""
Get hardware profile by name
"""
postdata = json.dumps(optionDict or {})
url = 'v1/hardwareProfiles/id/%s' % (id_)
try:
(response, responseDict) = self.sendSessionRequest(url,
method='POST',
data=postdata)
return HardwareProfile.getFromDict(
responseDict.get('hardwareprofile'))
except TortugaException as ex:
raise
except Exception as ex:
raise TortugaException(exception=ex)
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 getHardwareProfile(self,
hardwareProfileName: str,
optionDict: Optional[Union[dict, None]] = None):
"""
Get hardware profile by name
"""
url = 'hardwareprofiles/?name=%s' % (hardwareProfileName)
if optionDict:
for key, value in optionDict.items():
if not value:
continue
url += '&include={}'.format(key)
try:
responseDict = self.get(url)
return HardwareProfile.getListFromDict(responseDict)[0]
except TortugaException as ex:
raise
except Exception as ex:
raise TortugaException(exception=ex)
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 getHardwareProfileById(self,
id_,
optionDict: Optional[Union[dict, None]] = None):
"""
Get hardware profile by name
"""
url = 'hardwareprofiles/%d' % (id_)
if optionDict:
for key, value in optionDict.items():
if not value:
continue
url += '&include={}'.format(key)
try:
responseDict = self.get(url)
return HardwareProfile.getFromDict(
responseDict.get('hardwareprofile'))
except TortugaException as ex:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def runCommand(self):
self.parseArgs()
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
if self.getArgs().jsonTemplatePath:
# load from template
if self.getArgs().jsonTemplatePath and \
not os.path.exists(self.getArgs().jsonTemplatePath):
raise InvalidCliRequest(
_('Cannot read template from %s') %
(self.getArgs().jsonTemplatePath))
try:
with open(self.getArgs().jsonTemplatePath) as fp:
buf = json.load(fp)
tmpl_dict = buf['hardwareProfile']
except Exception as exc:
raise InvalidProfileCreationTemplate(
'Invalid profile creation template: {}'.format(exc))
else:
tmpl_dict = {}
# build up dict from scratch
if name:
tmpl_dict['name'] = name
if self.getArgs().description:
tmpl_dict['description'] = self.getArgs().description
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().nameFormat:
tmpl_dict['nameFormat'] = self.getArgs().nameFormat
elif 'nameFormat' not in tmpl_dict:
tmpl_dict['nameFormat'] = 'compute-#NN'
if self.getArgs().tags:
tmpl_dict['tags'] = parse_tags(self.getArgs().tags)
settings_dict = {
'defaults':
self.getArgs().bUseDefaults,
'osInfo':
getattr(self.getArgs(), 'osInfo') if hasattr(
self.getArgs(), 'osInfo') else None,
}
hw_profile_spec = HardwareProfile.getFromDict(tmpl_dict)
api = HardwareProfileWsApi(username=self.getUsername(),
password=self.getPassword(),
baseurl=self.getUrl(),
verify=self._verify)
api.createHardwareProfile(hw_profile_spec, settings_dict)
def createHardwareProfile(self,
session: Session,
hwProfileSpec: HardwareProfile,
settingsDict: Optional[Union[dict,
None]] = None):
bUseDefaults = settingsDict['defaults'] \
if settingsDict and 'defaults' in settingsDict else False
osInfo = settingsDict['osInfo'] \
if settingsDict and \
settingsDict and 'osInfo' in settingsDict else None
validation.validateProfileName(hwProfileSpec.getName())
if hwProfileSpec.getDescription() is None:
hwProfileSpec.setDescription('%s Nodes' %
(hwProfileSpec.getName()))
installerNode = self._nodeDbApi.getNode(session,
ConfigManager().getInstaller(),
{'softwareprofile': True})
if bUseDefaults:
if not hwProfileSpec.getNetworks():
# No <network>...</network> entries found in the template,
# use the default provisioning interface from the primary
# installer.
# Find first provisioning network and use it
for nic in installerNode.getNics():
network = nic.getNetwork()
if network.getType() == 'provision':
# for now set the default interface to be index 0
# with the same device
networkDevice = fixNetworkDeviceName(
nic.getNetworkDevice().getName())
network.setNetworkDevice(
NetworkDevice(name=networkDevice))
hwProfileSpec.getNetworks().append(network)
break
else:
raise NetworkNotFound(
'Unable to find provisioning network')
else:
# Ensure network device is defined
installerNic = None
for network in hwProfileSpec.getNetworks():
for installerNic in installerNode.getNics():
installerNetwork = installerNic.getNetwork()
if network.getId() and \
network.getId() == installerNetwork.getId():
break
elif network.getAddress() and \
network.getAddress() == \
installerNetwork.getAddress() and \
network.getNetmask() and \
network.getNetmask() == \
installerNetwork.getNetmask():
break
else:
# Unable to find network matching specification in
# template.
raise NetworkNotFound(
'Unable to find provisioning network [%s]' %
(network))
networkDevice = fixNetworkDeviceName(
installerNic.getNetworkDevice().getName())
network.setNetworkDevice(NetworkDevice(name=networkDevice))
if not osInfo:
osInfo = installerNode.getSoftwareProfile().getOsInfo()
osObjFactory = osUtility.getOsObjectFactory(osInfo.getName())
if not hwProfileSpec.getKernel():
hwProfileSpec.setKernel(
osObjFactory.getOsSysManager().getKernel(osInfo))
if not hwProfileSpec.getInitrd():
hwProfileSpec.setInitrd(
osObjFactory.getOsSysManager().getInitrd(osInfo))
self._hpDbApi.addHardwareProfile(session, hwProfileSpec)
# Iterate over all networks in the newly defined hardware profile
# and build assocations to provisioning NICs
if bUseDefaults:
for network in \
[network for network in hwProfileSpec.getNetworks()
if network.getType() == 'provision']:
# Get provisioning nic for network
try:
provisioningNic = self.getProvisioningNicForNetwork(
session, network.getAddress(), network.getNetmask())
except NicNotFound:
# There is currently no provisioning NIC defined for
# this network. This is not a fatal error.
continue
self.setProvisioningNic(session, hwProfileSpec.getName(),
provisioningNic.getId())
#
# Fire the tags changed event for all creates that have tags
#
# Get the latest version from the db in case the create method
# added some embellishments
#
hwp = self.getHardwareProfile(session, hwProfileSpec.getName())
if hwp.getTags():
HardwareProfileTagsChanged.fire(hardwareprofile_id=str(
hwp.getId()),
hardwareprofile_name=hwp.getName(),
tags=hwp.getTags(),
previous_tags={})
def __populateHardwareProfile(
self, session: Session, hardwareProfile: HardwareProfile,
dbHardwareProfile: Optional[HardwareProfileModel] = None) \
-> HardwareProfileModel:
"""
Helper function for creating / updating hardware profiles. If
'dbHardwareProfile' is specified, this is an update (vs. add)
operation
Raises:
NicNotFound
ResourceAdapterNotFound
InvalidArgument
ConfigurationError
"""
# Preload provisioning nics and networks
prov_nics = self.__get_provisioning_nics(session)
all_networks = self.__get_all_networks(session)
# Validate hw profile
if hardwareProfile.getName() is None:
raise ConfigurationError('Hardware profile requires name.')
if hardwareProfile.getNameFormat() is None:
raise ConfigurationError(
'Hardware profile requires name format field.')
if dbHardwareProfile is None:
dbHardwareProfile = HardwareProfileModel()
dbHardwareProfile.name = hardwareProfile.getName()
dbHardwareProfile.description = hardwareProfile.getDescription()
dbHardwareProfile.nameFormat = hardwareProfile.getNameFormat()
if hardwareProfile.getInstallType() is None:
if hardwareProfile.getLocation() == 'remote':
dbHardwareProfile.installType = 'bootstrap'
else:
dbHardwareProfile.installType = 'package'
else:
dbHardwareProfile.installType = hardwareProfile.\
getInstallType()
if hardwareProfile.getLocation() != 'remote':
dbHardwareProfile.kernel = hardwareProfile.getKernel()
dbHardwareProfile.kernelParams = \
hardwareProfile.getKernelParams()
dbHardwareProfile.initrd = hardwareProfile.getInitrd()
dbHardwareProfile.localBootParams = \
hardwareProfile.getLocalBootParams()
dbHardwareProfile.softwareOverrideAllowed = hardwareProfile.\
getSoftwareOverrideAllowed()
dbHardwareProfile.location = hardwareProfile.getLocation()
dbHardwareProfile.cost = hardwareProfile.getCost()
# Add resource adapter
resource_adapter_name = \
hardwareProfile.getResourceAdapter().getName() \
if hardwareProfile.getResourceAdapter() else 'default'
dbHardwareProfile.resourceadapter = \
self._resourceAdaptersDbHandler.getResourceAdapter(
session, resource_adapter_name)
if hardwareProfile.getDefaultResourceAdapterConfig():
adapter_cfg = None
self._logger.debug(
'Setting default resource adapter config: {}'.format(
hardwareProfile.getDefaultResourceAdapterConfig())
)
for adapter_cfg in \
dbHardwareProfile.resourceadapter.resource_adapter_config:
if adapter_cfg.name == \
hardwareProfile.getDefaultResourceAdapterConfig():
break
else:
raise InvalidArgument(
'Resource adapter configuration profile [{}] is'
' invalid'.format(
hardwareProfile.getDefaultResourceAdapterConfig())
)
dbHardwareProfile.default_resource_adapter_config = adapter_cfg
else:
dbHardwareProfile.default_resource_adapter_config = None
# Add networks
networks = []
for network in hardwareProfile.getNetworks():
for prov_network in all_networks:
if prov_network.address == network.getAddress():
dbNetwork = prov_network
break
else:
raise NetworkNotFound(
'Network [%s] does not exist' % (network.getAddress()))
dbNetworkDevice = \
self._networkDevicesDbHandler.createNetworkDeviceIfNotExists(
session, network.getNetworkDevice().getName())
# Now check if we have this one already...
for dbHardwareProfileNetwork in \
dbHardwareProfile.hardwareprofilenetworks:
if dbHardwareProfileNetwork.networkDeviceId == \
dbNetworkDevice.id and \
dbHardwareProfileNetwork.networkId == dbNetwork.id:
break
else:
dbHardwareProfileNetwork = HardwareProfileNetwork()
dbHardwareProfileNetwork.hardwareprofile = dbHardwareProfile
if dbNetwork.id is not None:
dbHardwareProfileNetwork.networkId = dbNetwork.id
else:
dbHardwareProfileNetwork.network = dbNetwork
dbHardwareProfileNetwork.hardwareProfileId = \
dbHardwareProfile.id
if dbNetworkDevice.id is not None:
dbHardwareProfileNetwork.networkDeviceId = \
dbNetworkDevice.id
else:
dbHardwareProfileNetwork.networkdevice = dbNetworkDevice
dbHardwareProfile.hardwareprofilenetworks.append(
dbHardwareProfileNetwork)
networks.append(dbHardwareProfileNetwork)
# Now remove all old networks
for dbNetwork in dbHardwareProfile.hardwareprofilenetworks:
for network in networks:
if network.networkDeviceId == dbNetwork.networkDeviceId \
and network.networkId == dbNetwork.networkId:
# Its a keeper
break
else:
# No match...delete time
session.delete(dbNetwork)
# Add provisioning Nics
if hardwareProfile.getProvisioningNics():
# Only one provisioning nic is possible
nic = hardwareProfile.getProvisioningNics()[0]
for prov_nic in prov_nics:
if nic.getIp() == prov_nic.ip:
dbNic = prov_nic
break
else:
raise NicNotFound(
'Provisioning NIC with IP [%s] not found' % nic.getIp())
if dbNic not in dbHardwareProfile.nics:
dbHardwareProfile.nics.append(dbNic)
return dbHardwareProfile
