def deleteNode(self, nodespec, **kwargs):
"""
Handle /nodes/:(nodespec) (DELETE)
"""
try:
transaction_id = enqueue_delete_hosts_request(
cherrypy.request.db, nodespec, str2bool(kwargs.get('force')))
self._logger.debug(
'NodeController.deleteNode(): delete request queued: %s' %
(transaction_id))
response = dict(transaction_id=transaction_id)
except (OperationFailed, NodeNotFound) as ex:
self.handleException(ex)
code = self.getTortugaStatusCode(ex)
response = self.errorResponse(str(ex)) \
if isinstance(ex, OperationFailed) else \
self.notFoundErrorResponse(str(ex), code)
except Exception as ex: # noqa pylint: disable=broad-except
self._logger.exception('node WS API deleteNode() failed')
self.handleException(ex)
response = self.errorResponse(str(ex))
return self.formatResponse(response)
def is_offline_installation(self) -> bool:
cfg = self._get_cfg()
if not cfg.has_option('installer', 'offline_installation'):
return False
return str2bool(cfg.get('installer', 'offline_installation'))
def addAdmin(self):
"""
Add a new admin to the system
"""
response = None
postdata = cherrypy.request.json
if 'admin' not in postdata:
raise cherrypy.HTTPError(400)
adminRequestObject = Admin.getFromDict(postdata['admin'])
isCrypted = str2bool(postdata['isCrypted'])
try:
self.app.admin_api.addAdmin(cherrypy.request.db,
adminRequestObject.getUsername(),
adminRequestObject.getPassword(),
isCrypted,
adminRequestObject.getRealname(),
adminRequestObject.getDescription())
except Exception as ex:
self._logger.error(str(ex))
self.handleException(ex)
response = self.errorResponse(str(ex))
return self.formatResponse(response)
def __update_network(self, network, postdata): \
# pylint: disable=no-self-use
updated = False
if 'address' in postdata:
network.setAddress(network['address'])
updated = True
if 'gateway' in postdata:
network.setGateway(postdata['gateway'])
updated = True
if 'increment' in postdata:
network.setIncrement(postdata['increment'])
updated = True
if 'netmask' in postdata:
network.setNetmask(postdata['netmask'])
updated = True
if 'name' in postdata:
network.setName(postdata['name'])
updated = True
if 'options' in postdata:
network.setOptions(postdata['options'])
updated = True
if 'suffix' in postdata:
network.setSuffix(postdata['suffix'])
updated = True
if 'type' in postdata:
network.setType(postdata['type'])
updated = True
if 'usingDhcp' in postdata:
network.setUsingDhcp(str2bool(postdata['usingDhcp']))
updated = True
if 'startIp' in postdata:
network.setStartIp(postdata['startIp'])
updated = True
return updated
def rebootNode(self, nodeName, **kwargs):
response = None
soft_reset = not str2bool(kwargs['hard']) \
if 'hard' in kwargs else True
reinstall = str2bool(kwargs['reinstall']) \
if 'reinstall' in kwargs else False
try:
self.app.node_api.rebootNode(cherrypy.request.db,
nodeName,
bSoftReset=soft_reset,
bReinstall=reinstall)
except NodeNotFound as ex:
self.handleException(ex)
code = self.getTortugaStatusCode(ex)
response = self.notFoundErrorResponse(str(ex), code)
except Exception as ex: # noqa pylint: disable=broad-except
self._logger.exception('node WS API rebootNode() failed')
self.handleException(ex)
response = self.errorResponse(str(ex))
return self.formatResponse(response)
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 enableComponent(self, softwareProfileName):
response = None
try:
postdata = cherrypy.request.json
if 'components' not in postdata or not postdata['components']:
raise InvalidArgument('Malformed enable component request')
# Reserved for possible future use where it will be possible to
# enable multiple components in one request.
component = postdata['components'][0]
kitName = component['kitName']
kitVersion = component['kitVersion']
kitIteration = component['kitIteration']
componentName = component['componentName']
componentVersion = component['componentVersion']
puppet_sync = str2bool(postdata['sync']) \
if 'sync' in postdata else True
self._softwareProfileManager.enableComponent(
cherrypy.request.db,
softwareProfileName,
kitName,
kitVersion,
kitIteration,
componentName,
comp_version=componentVersion,
sync=puppet_sync)
except Exception as ex:
self.getLogger().exception(
'software profile WS API enableComponent() failed')
self.handleException(ex)
response = self.errorResponse(str(ex))
return self.formatResponse(response)
def setBootLoader(self, bootLoader):
""" Set boot loader flag."""
self['bootLoader'] = str2bool(bootLoader)
def getPreserve(self):
""" Return preserve. """
return str2bool(self.get('preserve'))
def setPreserve(self, preserve):
""" Set preserve."""
self['preserve'] = str2bool(preserve)
def getBoot(self):
""" Return boot. """
return str2bool(self.get('boot'))
def setIsRemovable(self, isRemovable):
""" Set isRemovable flag."""
self['isRemovable'] = str2bool(isRemovable)
def getIsRunning(self):
return str2bool(self.get('running'))
def getGrow(self):
return str2bool(self.get('grow'))
def setShared(self, val):
self['shared'] = str2bool(val)
def getPersistent(self):
return str2bool(self.get('persistent'))
def setPersistent(self, val):
self['persistent'] = str2bool(val)
def setIsOs(self, isOs):
""" Set isOs flag."""
self['isOs'] = str2bool(isOs)
def getIsRemovable(self):
""" Return removable flag. """
return str2bool(self.get('isRemovable'))
def getBootLoader(self):
""" Return boot loader flag. """
return str2bool(self.get('bootLoader'))
def setGrow(self, value=True):
self['grow'] = str2bool(value)
def setUsingDhcp(self, usingDhcp):
""" Set using dhcp flag. """
self['usingDhcp'] = str2bool(usingDhcp)
def setIsRunning(self, val):
self['running'] = str2bool(val)
def setSoftwareOverrideAllowed(self, allowed):
""" Set hardware profile override allowed flag."""
self['softwareOverrideAllowed'] = str2bool(allowed)
def getShared(self):
return str2bool(self.get('shared'))
def getIsOs(self):
""" Return isOs flag. """
return str2bool(self.get('isOs'))
def getUsingDhcp(self):
""" Get using dhcp flag. """
return str2bool(self.get('usingDhcp'))
def setIsIdle(self, val):
self['isIdle'] = str2bool(val)
def getSoftwareOverrideAllowed(self):
""" Return hardware profile override allowed flag. """
return str2bool(self.get('softwareOverrideAllowed'))
def getIsIdle(self):
return str2bool(self.get('isIdle'))
