def getHardwareProfiles(self, **kwargs): tagspec = [] if 'tag' in kwargs and kwargs['tag']: tagspec.extend(parse_tag_query_string(kwargs['tag'])) try: if 'name' in kwargs and kwargs['name']: options = make_options_from_query_string( kwargs['include'] if 'include' in kwargs else None, ['resourceadapter']) hardwareProfiles = TortugaObjectList([ HardwareProfileManager().getHardwareProfile( cherrypy.request.db, kwargs['name'], optionDict=options) ]) else: hardwareProfiles = \ HardwareProfileManager().getHardwareProfileList( cherrypy.request.db, tags=tagspec) response = { 'hardwareprofiles': hardwareProfiles.getCleanDict(), } except Exception as ex: # pylint: disable=broad-except self.getLogger().exception( 'hardware profile WS API getHardwareProfiles() failed') self.handleException(ex) response = self.errorResponse(str(ex)) return self.formatResponse(response)
def __getRuleList(self): ruleList = TortugaObjectList() for ruleId in self._ruleDict.keys(): ruleList.append(copy.deepcopy(self._ruleDict[ruleId])) return ruleList
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 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 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 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 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 __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 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 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 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 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, 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 __init__(self, name=None, version=None, iteration=None): TortugaObject.__init__(self, { 'name': name, 'version': version, 'iteration': iteration, 'componentList': TortugaObjectList(), 'sources': TortugaObjectList(), }, ['name', 'version', 'iteration', 'id'], Kit.ROOT_TAG)
def __init__(self, name=None): TortugaObject.__init__(self, { 'name': name, 'networks': TortugaObjectList(), 'admins': TortugaObjectList(), 'nodes': TortugaObjectList(), 'nics': TortugaObjectList(), }, ['name', 'id'], HardwareProfile.ROOT_TAG)
def __init__(self): TortugaObject.__init__( self, { 'nodes': TortugaObjectList(), 'strings': TortugaObjectList(), 'running': False }, [], AddHostStatus.ROOT_TAG)
def __init__(self, name=None, version=None): TortugaObject.__init__( self, { 'name': name, 'version': version, 'packageList': TortugaObjectList(), 'osComponentList': TortugaObjectList(), 'osFamilyComponentList': TortugaObjectList() }, ['name', 'version', 'id'], Component.ROOT_TAG)
def __init__(self, applicationName='', name='', description=''): TortugaObject.__init__(self, { 'applicationName': applicationName, 'name': name, 'description': description, 'status': Rule.ENABLED_STATUS, 'conditions': TortugaObjectList(), 'xPathVariables': TortugaObjectList(), }, ['applicationName', 'name', 'id'], Rule.ROOT_TAG)
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 __init__(self, name=None): TortugaObject.__init__( self, { 'name': name, 'admins': TortugaObjectList(), 'partitions': TortugaObjectList(), 'components': TortugaObjectList(), 'nodes': TortugaObjectList(), 'kitsources': TortugaObjectList(), }, ['name', 'id'], SoftwareProfile.ROOT_TAG)
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 getStatus(self, session: str, startMessage: int, getNodes: bool) -> AddHostStatus: """ Raises: NotFound """ with self._addHostLock: nodeList = self._nodeDbApi.getNodesByAddHostSession(session) \ if getNodes else TortugaObjectList() # Lock and copy for data consistency if session not in self._sessions: raise NotFound('Invalid add host session ID [%s]' % (session)) sessionDict = self._sessions.get(session) statusCopy = AddHostStatus() # Copy simple data for key in sessionDict['status'].getKeys(): statusCopy.set(key, sessionDict['status'].get(key)) # Get slice of status messages messages = sessionDict['status'].getMessageList()[startMessage:] statusCopy.setMessageList(messages) if nodeList: statusCopy.getNodeList().extend(nodeList) return statusCopy
def getIdleSoftwareProfileList(self, session: Session): """ Get list of all available idle softwareProfiles from the db. Returns: [idle softwareProfile] Throws: DbError """ try: dbSoftwareProfileList = \ self._softwareProfilesDbHandler.getIdleSoftwareProfileList( session) result = TortugaObjectList() for software_profile in dbSoftwareProfileList: self.__get_software_profile_obj(software_profile) return result except TortugaException: raise except Exception as ex: self.getLogger().exception('%s' % ex) raise
def getSoftwareProfiles(self, **kwargs): """ TODO: implement support for optionDict through query string """ try: tags = {} if 'tag' in kwargs and kwargs['tag']: tags.update(dict(parse_tag_query_string(kwargs['tag']))) if 'name' in kwargs and kwargs['name']: default_options = [ 'components', 'partitions', 'hardwareprofiles', 'tags', ] options = make_options_from_query_string( kwargs['include'] if 'include' in kwargs else None, default_options) softwareProfiles = TortugaObjectList([ self._softwareProfileManager.getSoftwareProfile( cherrypy.request.db, kwargs['name'], optionDict=options) ]) else: softwareProfiles = \ self._softwareProfileManager.getSoftwareProfileList( cherrypy.request.db, tags=tags) response = { 'softwareprofiles': softwareProfiles.getCleanDict(), } except Exception as ex: self.handleException(ex) http_status = 404 \ if isinstance(ex, SoftwareProfileNotFound) else 400 response = self.errorResponse(str(ex), http_status=http_status) return self.formatResponse(response)
def getTortugaObjectList( self, cls: Type[ResourceAdapter], db_list: List[ResourceAdapterModel]) -> List[ResourceAdapter]: item_list: List[ResourceAdapter] = [] for db_item in db_list: item: ResourceAdapter = cls.getFromDbDict(db_item.__dict__) item.set_settings(db_item.settings) item_list.append(item) return TortugaObjectList(item_list)
def getNodes(self, **kwargs): """ Return list of all available nodes """ tagspec = [] if 'tag' in kwargs and kwargs['tag']: tagspec.extend(parse_tag_query_string(kwargs['tag'])) try: options = make_options_from_query_string( kwargs['include'] if 'include' in kwargs else None, ['softwareprofile', 'hardwareprofile']) if 'addHostSession' in kwargs and kwargs['addHostSession']: nodeList = self.app.node_api.getNodesByAddHostSession( cherrypy.request.db, kwargs['addHostSession'], options) elif 'name' in kwargs and kwargs['name']: nodeList = self.app.node_api.getNodesByNameFilter( cherrypy.request.db, kwargs['name'], optionDict=options) elif 'installer' in kwargs and str2bool(kwargs['installer']): nodeList = TortugaObjectList( [self.app.node_api.getInstallerNode(cherrypy.request.db)]) elif 'ip' in kwargs: nodeList = TortugaObjectList([ self.app.node_api.getNodeByIp(cherrypy.request.db, kwargs['ip']) ]) else: nodeList = self.app.node_api.getNodeList(cherrypy.request.db, tags=tagspec) response = {'nodes': NodeSchema().dump(nodeList, many=True).data} except Exception as ex: # noqa pylint: disable=broad-except self._logger.exception('node WS API getNodes() failed') self.handleException(ex) response = self.errorResponse(str(ex)) return self.formatResponse(response)
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 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 __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