def __validateNetwork(self, network: Network) -> None: \
# pylint: disable=no-self-use
"""
Raises:
InvalidArgument
"""
optionDict = {}
if 'address' in network and not network['address']:
raise InvalidArgument('Network address not set')
if 'netmask' in network and not network['netmask']:
raise InvalidArgument('Network mask not set')
# Get all of the network options
if network.getOptions():
for option in network.getOptions().split(';'):
tokens = option.split('=')
if len(tokens) == 2:
key, value = tokens
optionDict[key] = value
if 'startIp' in network and network['startIp']:
# Validate that the specified start IP address is on the
# provided subnet
startIp = ipaddress.IPv4Address(str(network['startIp']))
else:
# Start IP address not provided, fill it in since it can
# be calculated
increment = int(network['increment']) \
if 'increment' in network and network['increment'] else 1
startIp = ipaddress.IPv4Address(str(
network['address'])) + increment
ipaddrNetwork = ipaddress.IPv4Network(
'%s/%s' % (network['address'], network['netmask']))
if startIp not in ipaddrNetwork:
raise InvalidArgument(
'Starting IP address [%s] is not on network [%s]' %
(startIp, ipaddrNetwork))
network['startIp'] = str(startIp)
# Right now just check the VLAN vid
if 'vlan' in optionDict:
try:
if int(optionDict['vlan']) > 4095 or \
int(optionDict['vlan']) < 1:
raise InvalidArgument(
'The VLAN ID must be an integer in the range'
' 1-4095')
except ValueError:
# Convert all exceptions to this one...
raise InvalidArgument(
'The VLAN ID must be an integer in the range 1-4095')
def updateNetwork(self, network):
"""
Updates network in DB..
Returns:
network
Throws:
NetworkNotFound
DbError
"""
session = DbManager().openSession()
try:
dbNetwork = self._networksDbHandler.updateNetwork(session, network)
newNetwork = Network.getFromDbDict(dbNetwork.__dict__)
session.commit()
return newNetwork
except TortugaException as ex:
session.rollback()
raise
except Exception as ex:
session.rollback()
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def getNetworkFromXml(self):
"""
If the xmlFile option is present attempt to create a Network
object from the xml. Otherwise return None
"""
network = None
if self.getArgs().xmlFile:
# An XML file was provided as input...start with that...
f = open(self.getArgs().xmlFile, 'r')
try:
xmlString = f.read()
finally:
f.close()
try:
from tortuga.objects.network import Network
network = Network.getFromXml(xmlString)
except Exception as ex: # pylint: disable=W0703
self.getLogger().debug('Error parsing xml %s' % ex)
if network is None:
raise InvalidCliRequest(
_('File [%s] does not contain a valid network.') %
(self.getArgs().xmlFile))
return network
def populate_network(network: Network,
dbNetwork: Optional[NetworkModel] = None) \
-> NetworkModel:
if not dbNetwork:
dbNetwork = NetworkModel()
dbNetwork.address = network.getAddress()
dbNetwork.netmask = network.getNetmask()
dbNetwork.suffix = network.getSuffix()
dbNetwork.gateway = network.getGateway()
dbNetwork.options = network.getOptions()
dbNetwork.name = network.getName()
dbNetwork.startIp = network.getStartIp()
dbNetwork.type = network.getType()
dbNetwork.increment = network.getIncrement()
dbNetwork.usingDhcp = network.getUsingDhcp()
return dbNetwork
def updateNetwork(self, session: Session, network: Network) -> Network:
"""
Updates network in DB..
Returns:
network
Throws:
NetworkNotFound
InvalidArgument
"""
try:
if not network.getId():
raise InvalidArgument(
'Network id not set: unable to identify network')
self._logger.debug('Updating network [%s]' % (network))
dbNetwork = self._networksDbHandler.getNetworkById(
session, network.getId())
dbNetwork = populate_network(network, dbNetwork)
newNetwork = Network.getFromDbDict(dbNetwork.__dict__)
session.commit()
self._logger.info('Updated network [%s]' % (network))
return newNetwork
except TortugaException:
session.rollback()
raise
except Exception as ex:
session.rollback()
self._logger.exception(str(ex))
raise
def getFromDict(cls, _dict):
""" Get nic from _dict. """
nic = super(Nic, cls).getFromDict(_dict)
networkDict = _dict.get(Network.ROOT_TAG)
if networkDict:
nic.setNetwork(Network.getFromDict(networkDict))
networkDeviceDict = _dict.get(NetworkDevice.ROOT_TAG)
if networkDeviceDict:
nic.setNetworkDevice(NetworkDevice.getFromDict(networkDeviceDict))
return nic
def getFromDict(cls, _dict, ignore: Optional[Iterable[str]] = None):
""" Get nic from _dict. """
nic = super(Nic, cls).getFromDict(_dict)
networkDict = _dict.get(Network.ROOT_TAG)
if networkDict:
nic.setNetwork(Network.getFromDict(networkDict))
networkDeviceDict = _dict.get(NetworkDevice.ROOT_TAG)
if networkDeviceDict:
nic.setNetworkDevice(NetworkDevice.getFromDict(networkDeviceDict))
return nic
def getNetworkById(self, session: Session, id_):
"""
Get a network by id from the db.
"""
self._logger.debug('Retrieving network ID [%s]' % (id_))
try:
network = self._networksDbHandler.getNetworkById(session, id_)
return Network.getFromDbDict(network.__dict__)
except TortugaException:
raise
except Exception as ex:
self._logger.exception(str(ex))
raise
def getNetwork(self, session: Session, address: str, netmask: str):
"""
Get a network from the db.
"""
self._logger.debug('Retrieving network [%s/%s]' % (address, netmask))
try:
network = self._networksDbHandler.getNetwork(
session, address, netmask)
return Network.getFromDbDict(network.__dict__)
except TortugaException:
raise
except Exception as ex:
self._logger.exception(str(ex))
raise
def getFromDbDict(cls, _dict, ignore: Optional[Iterable[str]] = None):
nic = super(Nic, cls).getFromDict(_dict, ignore=ignore)
# network (relation)
networkDict = _dict.get(Network.ROOT_TAG)
if networkDict:
nic.setNetwork(Network.getFromDbDict(networkDict.__dict__))
# networkdevice (relation)
networkDeviceDict = _dict.get(NetworkDevice.ROOT_TAG)
if networkDeviceDict:
nic.setNetworkDevice(
NetworkDevice.getFromDbDict(networkDeviceDict.__dict__))
return nic
def getFromDbDict(cls, _dict):
nic = super(Nic, cls).getFromDict(_dict)
# network (relation)
networkDict = _dict.get(Network.ROOT_TAG)
if networkDict:
nic.setNetwork(Network.getFromDbDict(networkDict.__dict__))
# networkdevice (relation)
networkDeviceDict = _dict.get(NetworkDevice.ROOT_TAG)
if networkDeviceDict:
nic.setNetworkDevice(
NetworkDevice.getFromDbDict(networkDeviceDict.__dict__))
return nic
def getNetworkById(self, id_):
"""
Get a network by id from the db.
"""
session = DbManager().openSession()
try:
network = self._networksDbHandler.getNetworkById(session, id_)
return Network.getFromDbDict(network.__dict__)
except TortugaException as ex:
raise
except Exception as ex:
self.getLogger().exception('%s' % ex)
raise
finally:
DbManager().closeSession()
def runCommand(self):
self.parseArgs(
_("""
Registers a network within Tortuga. This network can then be associated with
hardware profile(s) to allow Tortuga to manage cluster node networking
configuration.
"""))
network = self.get_network_from_cmdline(retrieve_network=False)
if network is None:
network = Network()
# Apply command line parameters
self.updateNetwork(network)
# Check for required parameters
self.validateNetwork(network)
# Save the updated network
self.getNetworkApi().addNetwork(network)
def getNetworkList(self):
"""
Get network list.
Returns:
[networks]
Throws:
UserNotAuthorized
TortugaException
"""
url = 'v1/networks'
try:
_, responseDict = self.sendSessionRequest(url)
return Network.getListFromDict(responseDict)
except TortugaException:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def getNetworkById(self, id_):
"""
Get network information by id.
Returns:
network
Throws:
UserNotAuthorized
NetworkNotFound
TortugaException
"""
url = 'v1/networks/%s' % (id_)
try:
_, responseDict = self.sendSessionRequest(url)
return Network.getFromDict(responseDict.get(Network.ROOT_TAG))
except TortugaException:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def test_add_and_delete_network(dbm):
address = '192.168.1.0'
netmask = '255.255.255.0'
network = Network()
network.setAddress(address)
network.setNetmask(netmask)
network.setType('provision')
with dbm.session() as session:
NetworkDbApi().addNetwork(session, network)
# attempt to add the same network twice..
with pytest.raises(NetworkAlreadyExists):
NetworkDbApi().addNetwork(session, network)
stored_network = NetworkDbApi().getNetwork(session, address, netmask)
assert stored_network
new_netmask = '255.255.0.0'
stored_network.setNetmask(new_netmask)
assert NetworkDbApi().updateNetwork(session, stored_network)
updated_network = NetworkDbApi().getNetworkById(
session, stored_network.getId())
assert updated_network.getNetmask() == new_netmask
NetworkDbApi().deleteNetwork(session, updated_network.getId())
# attempt to delete network already deleted
with pytest.raises(NetworkNotFound):
NetworkDbApi().getNetwork(session, address, new_netmask)
def getNetwork(self, address, netmask):
"""
Get network information.
Returns:
network
Throws:
UserNotAuthorized
NetworkNotFound
TortugaException
"""
url = 'networks/?address=%s&netmask=%s' % (address, netmask)
try:
responseDict = self.get(url)
return Network.getListFromDict(responseDict)[0]
except TortugaException:
raise
except Exception as ex:
raise TortugaException(exception=ex)
def addNetwork(self, address, netmask):
'''
Handle put to networks/:(address)/:(netmask)/)
'''
response = None
postdata = cherrypy.request.json
network = Network.getFromDict(postdata)
try:
# Make sure the values are synced
network.setAddress(address)
network.setNetmask(netmask)
self.app.network_api.addNetwork(cherrypy.request.db, network)
except Exception as ex:
self._logger.error(str(ex))
self.handleException(ex)
response = self.errorResponse(str(ex))
return self.formatResponse(response)
def test_updateNetwork_failed(dbm):
bogus_network = Network()
with dbm.session() as session:
with pytest.raises(InvalidArgument):
NetworkDbApi().updateNetwork(session, bogus_network)
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)
