def set_ip(self, network=None, ip=None):
if not network:
self.log.error("Network needs to be specified")
return None
if not ip:
return self.del_net(network=network)
connected = self.get('connected')
link = True
net = Network(name=network, mongo_db=self._mongo_db)
if str(net.id) in connected:
net.release_ip(connected[str(net.id)])
link = False
ip = net.reserve_ip(ip)
if not ip:
return None
connected[str(net.id)] = ip
res = self.set('connected', connected)
if link:
self.link(net)
return res
def get(self, key):
from luna.network import Network
if key == 'dhcp_net':
netid = super(Cluster, self).get(key)
if not netid:
return None
net = Network(id=ObjectId(netid), mongo_db=self._mongo_db)
try:
net = Network(id=ObjectId(netid), mongo_db=self._mongo_db)
return net.name
except:
self.log.error('Wrong DHCP network configured')
return None
if key == 'dhcp_range_start' or key == 'dhcp_range_end':
netid = super(Cluster, self).get('dhcp_net')
if not netid:
return None
net = Network(id=ObjectId(netid), mongo_db=self._mongo_db)
return utils.ip.reltoa(net._json['NETWORK'],
super(Cluster, self).get(key),
ver=net.version)
return super(Cluster, self).get(key)
def set_ip(self, network=None, ip=None):
if not network:
self.log.error("Network needs to be specified")
return None
if not ip:
return self.del_net(network=network)
connected = self.get('connected')
link = True
net = Network(name=network, mongo_db=self._mongo_db)
if str(net.id) in connected:
net.release_ip(connected[str(net.id)])
link = False
ip = net.reserve_ip(ip)
if not ip:
return None
connected[str(net.id)] = ip
res = self.set('connected', connected)
if link:
self.link(net)
return res
def delete(self):
obj_json = self._get_json()
for network in obj_json['connected']:
net = Network(id = ObjectId(network), mongo_db = self._mongo_db)
net.release_ip(obj_json['connected'][network])
self.unlink(net)
return super(OtherDev, self).delete()
def __init__(self,
name=None,
mongo_db=None,
create=False,
id=None,
network=None,
ip=None,
comment=''):
"""
network - the network the device is connected to
ip - device's ip
"""
self.log.debug("function args {}".format(self._debug_function()))
# Define the schema used to represent otherdev objects
self._collection_name = 'otherdev'
self._keylist = {'comment': type('')}
# Check if this device is already present in the datastore
# Read it if that is the case
dev = self._get_object(name, mongo_db, create, id)
if create:
cluster = Cluster(mongo_db=self._mongo_db)
if not network:
connected = {}
elif not ip:
err_msg = "IP needs to be specified"
self.log.error(err_msg)
raise RuntimeError, err_msg
else:
net = Network(name=network, mongo_db=self._mongo_db)
ipnum = net.reserve_ip(ip, ignore_errors=False)
if not ipnum:
err_msg = "Unable to allocate IP in network"
self.log.error(err_msg)
raise RuntimeError, err_msg
connected = {str(net.DBRef.id): ipnum}
# Store the new device in the datastore
dev = {'name': name, 'connected': connected, 'comment': comment}
self.log.debug("Saving dev '{}' to the datastore".format(dev))
self.store(dev)
# Link this device to its dependencies and the current cluster
self.link(cluster)
if connected and net:
self.link(net)
self.log = logging.getLogger('otherdev.' + self._name)
def delete(self):
obj_json = self._get_json()
net_dbref = obj_json['network']
net = Network(id = net_dbref.id, mongo_db = self._mongo_db)
ip_human_readable = self.get('ip')
net.release_ip(ip_human_readable)
self.unlink(net)
return super(Switch, self).delete()
def delete(self):
obj_json = self._get_json()
for network in obj_json['connected']:
net = Network(id = ObjectId(network), mongo_db = self._mongo_db)
if obj_json['connected'][network]:
net.release_ip(obj_json['connected'][network])
self.unlink(net)
return super(OtherDev, self).delete()
def delete(self):
obj_json = self._get_json()
net_dbref = obj_json['network']
net = Network(id = net_dbref.id, mongo_db = self._mongo_db)
ip_human_readable = self.get('ip')
net.release_ip(ip_human_readable)
self.unlink(net)
return super(Switch, self).delete()
def release_resources(self):
connected = self.get('connected')
for network in connected:
if connected[network]:
net = Network(id=ObjectId(network), mongo_db=self._mongo_db)
net.release_ip(connected[network])
return True
def release_resources(self):
connected = self.get('connected')
for network in connected:
if connected[network]:
net = Network(id=ObjectId(network), mongo_db=self._mongo_db)
net.release_ip(connected[network])
return True
def set(self, key, value):
if key == 'ip':
net = Network(id=self._json['network'].id, mongo_db=self._mongo_db)
if self._json['ip']:
net.release_ip(self._json['ip'])
ip = net.reserve_ip(value)
ret = super(Switch, self).set('ip', ip)
return ret
elif key == 'network':
net = Network(id=self._json['network'].id, mongo_db=self._mongo_db)
ip = self._json['ip']
new_net = Network(name=value, mongo_db=self._mongo_db)
if net.DBRef == new_net.DBRef:
return None
new_ip = ip
if not new_net.reserve_ip(new_ip):
return None
net.release_ip(ip)
self.unlink(net)
ret = super(Switch, self).set('network', new_net.DBRef)
self.link(new_net)
return ret
else:
return super(Switch, self).set(key, value)
def _release_bmc_ip(self, ip):
if not self._id:
self._logger.error("Was object deleted?")
return None
try:
net_dbref = self._get_json()['bmcnetwork']
except:
self._logger.error("No bmc network configured")
return None
net = Network(id = net_dbref.id, mongo_db = self._mongo_db)
return net.release_ip(ip)
def __init__(self, name=None, mongo_db=None, create=False, id=None,
network=None, ip=None, comment=''):
"""
network - the network the device is connected to
ip - device's ip
"""
self.log.debug("function args {}".format(self._debug_function()))
# Define the schema used to represent otherdev objects
self._collection_name = 'otherdev'
self._keylist = {'comment': type('')}
# Check if this device is already present in the datastore
# Read it if that is the case
dev = self._get_object(name, mongo_db, create, id)
if create:
cluster = Cluster(mongo_db=self._mongo_db)
if not network:
connected = {}
elif not ip:
err_msg = "IP needs to be specified"
self.log.error(err_msg)
raise RuntimeError, err_msg
else:
net = Network(name=network, mongo_db=self._mongo_db)
ipnum = net.reserve_ip(ip, ignore_errors=False)
if not ipnum:
err_msg = "Unable to allocate IP in network"
self.log.error(err_msg)
raise RuntimeError, err_msg
connected = {str(net.DBRef.id): ipnum}
# Store the new device in the datastore
dev = {'name': name, 'connected': connected, 'comment': comment}
self.log.debug("Saving dev '{}' to the datastore".format(dev))
self.store(dev)
# Link this device to its dependencies and the current cluster
self.link(cluster)
if connected and net:
self.link(net)
self.log = logging.getLogger('otherdev.' + self._name)
def get_num_bmc_ip(self, ip):
dbref = None
try:
dbref = self._get_json()['bmcnetwork']
except:
self._logger.error("Interface is not configured for BMC")
return None
if not bool(dbref):
return None
net = Network(id=dbref.id, mongo_db=self._mongo_db)
return net.ip_to_relnum(ip)
def get_num_bmc_ip(self, ip):
dbref = None
try:
dbref = self._get_json()['bmcnetwork']
except:
self._logger.error("Interface is not configured for BMC")
return None
if not bool(dbref):
return None
net = Network(id = dbref.id, mongo_db = self._mongo_db)
return utils.ip.atorel(ip, net._get_json()['NETWORK'], net._get_json()['PREFIX'])
def _release_bmc_ip(self, ip):
if not self._id:
self._logger.error("Was object deleted?")
return None
try:
net_dbref = self._get_json()['bmcnetwork']
except:
self._logger.error("No bmc network configured")
return None
net = Network(id = net_dbref.id, mongo_db = self._mongo_db)
return net.release_ip(ip)
def get_num_bmc_ip(self, ip):
dbref = None
try:
dbref = self._get_json()['bmcnetwork']
except:
self._logger.error("Interface is not configured for BMC")
return None
if not bool(dbref):
return None
net = Network(id = dbref.id, mongo_db = self._mongo_db)
return net.ip_to_relnum(ip)
def get_num_ip(self, interface, ip):
interfaces = self._get_json()['interfaces']
dbref = None
try:
dbref = interfaces[interface]['network']
except:
self._logger.error("Interface is not configured for '{}'".format(interface))
return None
if not bool(dbref):
return None
net = Network(id = dbref.id, mongo_db = self._mongo_db)
return utils.ip.atorel(ip, net._get_json()['NETWORK'], net._get_json()['PREFIX'])
def get_num_ip(self, interface, ip):
interfaces = self._get_json()['interfaces']
dbref = None
try:
dbref = interfaces[interface]['network']
except:
self._logger.error("Interface is not configured for '{}'".format(interface))
return None
if not bool(dbref):
return None
net = Network(id = dbref.id, mongo_db = self._mongo_db)
return net.ip_to_relnum(ip)
def get(self, key):
if key == 'ip':
dbref = None
try:
dbref = self._get_json()['network']
except:
self._logger.error("Network is not defined for switch")
return None
if not bool(dbref):
return None
net = Network(id = dbref.id, mongo_db = self._mongo_db)
return utils.ip.reltoa(net._get_json()['NETWORK'], self._get_json()['ip'])
return super(Switch, self).get(key)
def get_num_ip(self, interface, ip):
interfaces = self._get_json()['interfaces']
dbref = None
try:
dbref = interfaces[interface]['network']
except:
self._logger.error(
"Interface is not configured for '{}'".format(interface))
return None
if not bool(dbref):
return None
net = Network(id=dbref.id, mongo_db=self._mongo_db)
return net.ip_to_relnum(ip)
def get(self, key):
if key == 'ip':
dbref = None
try:
dbref = self._get_json()['network']
except:
self._logger.error("Network is not defined for switch")
return None
if not bool(dbref):
return None
net = Network(id = dbref.id, mongo_db = self._mongo_db)
return net.relnum_to_ip(self._get_json()['ip'])
return super(Switch, self).get(key)
def show_bmc_if(self, brief = False):
bmcnetwork = self._get_json()['bmcnetwork']
if not bool(bmcnetwork):
return ''
(NETWORK, PREFIX) = ("", "")
try:
net = Network(id = bmcnetwork.id, mongo_db = self._mongo_db)
NETWORK = net.get('NETWORK')
PREFIX = str(net.get('PREFIX'))
except:
pass
if brief:
return "[" +net.name + "]:"+ NETWORK + "/" + PREFIX
return NETWORK + "/" + PREFIX
def show_bmc_if(self, brief = False):
bmcnetwork = self._get_json()['bmcnetwork']
if not bool(bmcnetwork):
return ''
(NETWORK, PREFIX) = ("", "")
try:
net = Network(id = bmcnetwork.id, mongo_db = self._mongo_db)
NETWORK = net.get('NETWORK')
PREFIX = str(net.get('PREFIX'))
except:
pass
if brief:
return "[" +net.name + "]:"+ NETWORK + "/" + PREFIX
return NETWORK + "/" + PREFIX
def _reserve_bmc_ip(self, ip = None):
if not self._id:
self._logger.error("Was object deleted?")
return None
try:
net_dbref = self._get_json()['bmcnetwork']
except:
self._logger.error("No bmc network configured")
return None
if not bool(net_dbref):
self._logger.warning("No network configured for BMC interface")
return None
net = Network(id = net_dbref.id, mongo_db = self._mongo_db)
return net.reserve_ip(ip)
def _reserve_bmc_ip(self, ip = None):
if not self._id:
self._logger.error("Was object deleted?")
return None
try:
net_dbref = self._get_json()['bmcnetwork']
except:
self._logger.error("No bmc network configured")
return None
if not bool(net_dbref):
self._logger.warning("No network configured for BMC interface")
return None
net = Network(id = net_dbref.id, mongo_db = self._mongo_db)
return net.reserve_ip(ip)
def makedhcp(self, netname, startip, endip, no_ha = False):
from luna.network import Network
from bson.objectid import ObjectId
try:
if bool(netname):
objnet = Network(name = netname, mongo_db = self._mongo_db)
except:
ojbnet = None
if not bool(objnet):
self._logger.error("Proper DHCP network should be specified.")
return None
if not bool(startip) or not bool(endip):
self._logger.error("First and last IPs of range should be specified.")
return None
if not bool(self.get_cluster_ips()):
no_ha = True
n = objnet._get_json()
startip = utils.ip.atorel(startip, n['NETWORK'], n['PREFIX'])
endip = utils.ip.atorel(endip, n['NETWORK'], n['PREFIX'])
if not bool(startip) or not bool(endip):
self._logger.error("Error in acquiring IPs.")
return None
obj_json = self._get_json()
(oldnetid, oldstartip, oldendip) = (None, None, None)
try:
oldnetid = obj_json['dhcp_net']
oldstartip = obj_json['dhcp_range_start']
oldendip = obj_json['dhcp_range_end']
except:
(oldnetid, oldstartip, oldendip) = (None, None, None)
if str(oldnetid) == str(objnet.id):
objnet.release_ip(oldstartip, oldendip)
self.unlink(objnet)
(oldnetid, oldstartip, oldendip) = (None, None, None)
res = objnet.reserve_ip(startip, endip)
if not bool(res):
self._logger.error("Cannot reserve IP range for DHCP.")
super(Cluster, self).set('dhcp_net', str(objnet.id))
super(Cluster, self).set('dhcp_range_start', startip)
super(Cluster, self).set('dhcp_range_end', endip)
self.link(objnet)
if bool(oldnetid) and bool(oldstartip) and bool(oldendip):
oldnet_obj = Network(id = ObjectId(oldnetid), mongo_db = self._mongo_db)
self.unlink(oldnet_obj)
oldnet_obj.release_ip(oldstartip, oldendip)
self._create_dhcp_config(no_ha)
return True
def boot_params(self):
params = {}
params['boot_if'] = None
params['net_prefix'] = None
osimage = OsImage(id=self.get('osimage').id, mongo_db=self._mongo_db)
try:
params['kernel_file'] = osimage.get('kernfile')
except:
params['kernel_file'] = ""
try:
params['initrd_file'] = osimage.get('initrdfile')
except:
params['initrd_file'] = ""
try:
params['kern_opts'] = osimage.get('kernopts')
except:
params['kern_opts'] = ""
try:
params['boot_if'] = self.get('boot_if')
except:
params['boot_if'] = ""
params['net_prefix'] = ""
return params
interfaces = self._get_json()['interfaces']
try:
if_params = interfaces[params['boot_if']]
except:
self._logger.error(
"Boot interface '{}' does not present in configured interface list '{}'."
.format(params['boot_if'], interfaces.keys()))
params['boot_if'] = ""
params['net_prefix'] = ""
return params
net = None
try:
if_net = if_params['network']
net = Network(id=if_net.id, mongo_db=self._mongo_db)
except:
pass
if not bool(net):
self._logger.error(
"Boot interface '{}' has no network configured".format(
params['boot_if']))
params['boot_if'] = ""
params['net_prefix'] = ""
return params
params['net_prefix'] = net.get('PREFIX')
return params
def _create_dhcp_config(self, no_ha):
from luna.network import Network
from bson.objectid import ObjectId
from tornado import template
import os, base64
c = {}
conf_primary = {}
conf_secondary = {}
if self.is_ha() and not no_ha:
cluster_ips = self.get_cluster_ips()
conf_primary['my_addr'] = cluster_ips[0]
conf_secondary['my_addr'] = cluster_ips[1]
conf_primary['peer_addr'] = conf_secondary['my_addr']
conf_secondary['peer_addr'] = conf_primary['my_addr']
c['frontend_ip'] = self.get('frontend_address')
c['dhcp_start'] = self.get('dhcp_range_start')
c['dhcp_end'] = self.get('dhcp_range_end')
c['frontend_port'] = self.get('frontend_port')
netname = self.get('dhcp_net')
objnet = Network(name=netname, mongo_db=self._mongo_db)
c['NETMASK'] = objnet.get('NETMASK')
c['NETWORK'] = objnet.get('NETWORK')
c['hmac_key'] = str(
base64.b64encode(bytearray(os.urandom(32))).decode())
tloader = template.Loader(self.get('path') + '/templates')
if self.is_ha() and not no_ha:
dhcpd_conf_primary = tloader.load('templ_dhcpd.cfg').generate(
c=c, conf_primary=conf_primary, conf_secondary=None)
dhcpd_conf_secondary = tloader.load('templ_dhcpd.cfg').generate(
c=c, conf_primary=None, conf_secondary=conf_secondary)
f1 = open('/etc/dhcp/dhcpd.conf', 'w')
f2 = open('/etc/dhcp/dhcpd-secondary.conf', 'w')
f1.write(dhcpd_conf_primary)
f2.write(dhcpd_conf_secondary)
f1.close()
f2.close()
else:
dhcpd_conf = tloader.load('templ_dhcpd.cfg').generate(
c=c, conf_primary=None, conf_secondary=None)
f1 = open('/etc/dhcp/dhcpd.conf', 'w')
f2 = open('/etc/dhcp/dhcpd-secondary.conf', 'w')
f1.write(dhcpd_conf)
f2.write(dhcpd_conf)
f1.close()
f2.close()
return True
def list_nets(self):
nets = []
for elem in self.get('connected'):
net = Network(id=ObjectId(elem), mongo_db=self._mongo_db)
nets.append(net.name)
return nets
def _release_ip(self, interface, ip):
if not bool(interface):
self._logger.error("Interface needs to be specified")
return None
if not self._id:
self._logger.error("Was object deleted?")
return None
try:
net_dbref = self._get_json()['interfaces'][interface]['network']
except:
self._logger.error("No such interface '{}'".format(interface))
return None
net = Network(id = net_dbref.id, mongo_db = self._mongo_db)
if bool(ip):
return net.release_ip(ip)
return True
def set_net_to_if(self, interface, network):
if not self._id:
self._logger.error("Was object deleted?")
return None
interfaces = self._get_json()['interfaces']
net = Network(network, mongo_db = self._mongo_db)
try:
old_parms = interfaces[interface]
except:
old_parms = None
self._logger.error("Interface '{}' does not exist".format(interface))
return None
try:
old_net = old_parms['network']
except:
old_net = None
if bool(old_net):
self._logger.error("Network is already defined for this interface '{}'".format(interface))
return None
interfaces[interface]['network'] = net.DBRef
res = self._mongo_collection.update({'_id': self._id}, {'$set': {'interfaces': interfaces}}, multi=False, upsert=False)
if res['err']:
self._logger.error("Error adding network for interface '{}'".format(interface))
return None
self.link(net.DBRef)
reverse_links = self.get_back_links()
for link in reverse_links:
if link['collection'] != 'node':
continue
node = Node(id=link['DBRef'].id, mongo_db = self._mongo_db)
node.add_ip(interface)
return True
def get_ip(self, network_name = None):
if not bool(network_name):
self._logger.error("Network needs to be specified")
return None
nets = self._get_json()['connected']
if type(network_name) == ObjectId:
try:
return nets[str(network_name)]
except:
self._logger.error("Cannot find configured IP in the network '{}' for '{}'".format(str(network_name), self.name))
return None
for rec in nets:
net = Network(id = ObjectId(rec), mongo_db = self._mongo_db)
if net.name == network_name:
return net.relnum_to_ip(nets[rec])
return None
def get_ip(self, network_name = None):
if not bool(network_name):
self._logger.error("Network needs to be specified")
return None
nets = self._get_json()['connected']
if type(network_name) == ObjectId:
try:
return nets[str(network_name)]
except:
self._logger.error("Cannot find configured IP in the network '{}' for '{}'".format(str(network_name), self.name))
return None
for rec in nets:
net = Network(id = ObjectId(rec), mongo_db = self._mongo_db)
if net.name == network_name:
return utils.ip.reltoa(net._get_json()['NETWORK'], nets[rec])
return None
def _release_ip(self, interface, ip):
if not bool(interface):
self._logger.error("Interface needs to be specified")
return None
if not self._id:
self._logger.error("Was object deleted?")
return None
try:
net_dbref = self._get_json()['interfaces'][interface]['network']
except:
self._logger.error("No such interface '{}'".format(interface))
return None
net = Network(id = net_dbref.id, mongo_db = self._mongo_db)
if bool(ip):
return net.release_ip(ip)
return True
def _reserve_ip(self, interface = None, ip = None):
if not bool(interface):
self._logger.error("Interface needs to be specified")
return None
if not self._id:
self._logger.error("Was object deleted?")
return None
try:
net_dbref = self._get_json()['interfaces'][interface]['network']
except:
self._logger.error("No such interface '{}'".format(interface))
return None
if not bool(net_dbref):
self._logger.warning("No network configured for interface '{}'".format(interface))
return None
net = Network(id = net_dbref.id, mongo_db = self._mongo_db)
return net.reserve_ip(ip)
def _reserve_ip(self, interface = None, ip = None):
if not bool(interface):
self._logger.error("Interface needs to be specified")
return None
if not self._id:
self._logger.error("Was object deleted?")
return None
try:
net_dbref = self._get_json()['interfaces'][interface]['network']
except:
self._logger.error("No such interface '{}'".format(interface))
return None
if not bool(net_dbref):
self._logger.warning("No network configured for interface '{}'".format(interface))
return None
net = Network(id = net_dbref.id, mongo_db = self._mongo_db)
return net.reserve_ip(ip)
def __init__(self, name = None, mongo_db = None, create = False, id = None,
prescript = None, bmcsetup = None, bmcnetwork = None,
partscript = None, osimage = None, interfaces = None, postscript = None, boot_if = None, torrent_if = None):
"""
prescript - preinstall script
bmcsetup - bmcsetup options
bmcnetwork - used for bmc networking
partscript - parition script
osimage - osimage
interfaces - list of the newtork interfaces
postscript - postinstall script
"""
self._logger.debug("Arguments to function '{}".format(self._debug_function()))
self._collection_name = 'group'
mongo_doc = self._check_name(name, mongo_db, create, id)
self._keylist = {'prescript': type(''), 'partscript': type(''), 'postscript': type(''), 'boot_if': type(''), 'torrent_if': type('')}
if create:
cluster = Cluster(mongo_db = self._mongo_db)
(bmcobj, bmcnetobj) = (None, None)
if bool(bmcsetup):
bmcobj = BMCSetup(bmcsetup).DBRef
if bool(bmcnetwork):
bmcnetobj = Network(bmcnetwork, mongo_db = self._mongo_db).DBRef
osimageobj = OsImage(osimage)
if bool(interfaces) and type(interfaces) is not type([]):
self._logger.error("'interfaces' should be list")
raise RuntimeError
if_dict = {}
if not bool(interfaces):
interfaces = []
for interface in interfaces:
if_dict[interface] = {'network': None, 'params': ''}
if not bool(partscript):
partscript = "mount -t tmpfs tmpfs /sysroot"
if not bool(prescript):
prescript = ""
if not bool(postscript):
postscript = """cat <<EOF>>/sysroot/etc/fstab
tmpfs / tmpfs defaults 0 0
EOF"""
mongo_doc = {'name': name, 'prescript': prescript, 'bmcsetup': bmcobj, 'bmcnetwork': bmcnetobj,
'partscript': partscript, 'osimage': osimageobj.DBRef, 'interfaces': if_dict,
'postscript': postscript, 'boot_if': boot_if, 'torrent_if': torrent_if}
self._logger.debug("mongo_doc: '{}'".format(mongo_doc))
self._name = name
self._id = self._mongo_collection.insert(mongo_doc)
self._DBRef = DBRef(self._collection_name, self._id)
self.link(cluster)
if bmcobj:
self.link(bmcobj)
if bmcnetobj:
self.link(bmcnetobj)
self.link(osimageobj)
else:
self._name = mongo_doc['name']
self._id = mongo_doc['_id']
self._DBRef = DBRef(self._collection_name, self._id)
self._logger = logging.getLogger('group.' + self._name)
def del_net(self, network = None):
if not bool(network):
self._logger.error("Network should be specified")
return None
obj_json = self._get_json()
net = Network(network, mongo_db = self._mongo_db)
rel_ip = None
try:
rel_ip = obj_json['connected'][str(net.id)]
except:
self._logger.error("Cannot find configured IP in the network '{}' for '{}'".format(network, self.name))
return None
net.release_ip(net.relnum_to_ip(rel_ip))
obj_json['connected'].pop(str(net.id))
ret = self._mongo_collection.update({'_id': self._id}, {'$set': obj_json}, multi=False, upsert=False)
self.unlink(net)
return not ret['err']
def del_net(self, network = None):
if not bool(network):
self._logger.error("Network should be specified")
return None
obj_json = self._get_json()
net = Network(network, mongo_db = self._mongo_db)
rel_ip = None
try:
rel_ip = obj_json['connected'][str(net.id)]
except:
self._logger.error("Cannot find configured IP in the network '{}' for '{}'".format(network, self.name))
return None
net.release_ip(utils.ip.reltoa(net._get_json()['NETWORK'], rel_ip))
obj_json['connected'].pop(str(net.id))
ret = self._mongo_collection.update({'_id': self._id}, {'$set': obj_json}, multi=False, upsert=False)
self.unlink(net)
return not ret['err']
def _create_dhcp_config(self, no_ha):
from luna.network import Network
from bson.objectid import ObjectId
from tornado import template
import os, base64
c = {}
conf_primary = {}
conf_secondary = {}
if self.is_ha() and not no_ha:
cluster_ips = self.get_cluster_ips()
conf_primary['my_addr'] = cluster_ips[0]
conf_secondary['my_addr'] = cluster_ips[1]
conf_primary['peer_addr'] = conf_secondary['my_addr']
conf_secondary['peer_addr'] = conf_primary['my_addr']
c['frontend_ip'] = self.get('frontend_address')
c['dhcp_start'] = self.get('dhcp_range_start')
c['dhcp_end'] = self.get('dhcp_range_end')
c['frontend_port'] = self.get('frontend_port')
netname = self.get('dhcp_net')
objnet = Network(name = netname, mongo_db = self._mongo_db)
c['NETMASK'] = objnet.get('NETMASK')
c['NETWORK'] = objnet.get('NETWORK')
c['hmac_key'] = str(base64.b64encode(bytearray(os.urandom(32))).decode())
tloader = template.Loader(self.get('path') + '/templates')
if self.is_ha() and not no_ha:
dhcpd_conf_primary = tloader.load('templ_dhcpd.cfg').generate(c = c, conf_primary = conf_primary, conf_secondary = None)
dhcpd_conf_secondary = tloader.load('templ_dhcpd.cfg').generate(c = c, conf_primary = None, conf_secondary = conf_secondary)
f1 = open('/etc/dhcp/dhcpd.conf', 'w')
f2 = open('/etc/dhcp/dhcpd-secondary.conf', 'w')
f1.write(dhcpd_conf_primary)
f2.write(dhcpd_conf_secondary)
f1.close()
f2.close()
else:
dhcpd_conf = tloader.load('templ_dhcpd.cfg').generate(c = c, conf_primary = None, conf_secondary = None)
f1 = open('/etc/dhcp/dhcpd.conf', 'w')
f2 = open('/etc/dhcp/dhcpd-secondary.conf', 'w')
f1.write(dhcpd_conf)
f2.write(dhcpd_conf)
f1.close()
f2.close()
return True
def boot_params(self):
params = {}
params['boot_if'] = None
params['net_prefix'] = None
osimage = OsImage(id = self.get('osimage').id, mongo_db = self._mongo_db)
try:
params['kernel_file'] = osimage.get('kernfile')
except:
params['kernel_file'] = ""
try:
params['initrd_file'] = osimage.get('initrdfile')
except:
params['initrd_file'] = ""
try:
params['kern_opts'] = osimage.get('kernopts')
except:
params['kern_opts'] = ""
try:
params['boot_if'] = self.get('boot_if')
except:
params['boot_if'] = ""
params['net_prefix'] = ""
return params
interfaces = self._get_json()['interfaces']
try:
if_params = interfaces[params['boot_if']]
except:
self._logger.error("Boot interface '{}' does not present in configured interface list '{}'.".format(params['boot_if'], interfaces.keys()))
params['boot_if'] = ""
params['net_prefix'] = ""
return params
net = None
try:
if_net = if_params['network']
net = Network(id = if_net.id, mongo_db = self._mongo_db)
except:
pass
if not bool(net):
self._logger.error("Boot interface '{}' has no network configured".format(params['boot_if']))
params['boot_if'] = ""
params['net_prefix'] = ""
return params
params['net_prefix'] = net.get('PREFIX')
return params
def del_net(self, network=None):
if not network:
self.log.error("Network needs to be specified")
return None
connected = self.get('connected')
net = Network(network, mongo_db=self._mongo_db)
if not str(net.id) in connected:
self.log.error("Device '{}' is not attached to network '{}'"
.format(self.name, str(network)))
return None
net.release_ip(connected[str(net.id)])
connected.pop(str(net.id))
res = self.set('connected', connected)
self.unlink(net)
return res
def makedhcp(self, netname, startip, endip, no_ha = False):
from luna.network import Network
from bson.objectid import ObjectId
try:
if bool(netname):
objnet = Network(name = netname, mongo_db = self._mongo_db)
except:
ojbnet = None
if not bool(objnet):
self._logger.error("Proper DHCP network should be specified.")
return None
if not bool(startip) or not bool(endip):
self._logger.error("First and last IPs of range should be specified.")
return None
if not bool(self.get_cluster_ips()):
no_ha = True
startip = objnet.ip_to_relnum(startip)
endip = objnet.ip_to_relnum(endip)
if not bool(startip) or not bool(endip):
self._logger.error("Error in acquiring IPs.")
return None
obj_json = self._get_json()
(oldnetid, oldstartip, oldendip) = (None, None, None)
try:
oldnetid = obj_json['dhcp_net']
oldstartip = obj_json['dhcp_range_start']
oldendip = obj_json['dhcp_range_end']
except:
(oldnetid, oldstartip, oldendip) = (None, None, None)
if str(oldnetid) == str(objnet.id):
objnet.release_ip(oldstartip, oldendip)
self.unlink(objnet)
(oldnetid, oldstartip, oldendip) = (None, None, None)
res = objnet.reserve_ip(startip, endip)
if not bool(res):
self._logger.error("Cannot reserve IP range for DHCP.")
super(Cluster, self).set('dhcp_net', str(objnet.id))
super(Cluster, self).set('dhcp_range_start', startip)
super(Cluster, self).set('dhcp_range_end', endip)
self.link(objnet)
if bool(oldnetid) and bool(oldstartip) and bool(oldendip):
oldnet_obj = Network(id = ObjectId(oldnetid), mongo_db = self._mongo_db)
self.unlink(oldnet_obj)
oldnet_obj.release_ip(oldstartip, oldendip)
self._create_dhcp_config(no_ha)
return True
def set_ip(self, network = None, ip = None):
if not bool(network):
self._logger.error("Network should be specified")
return None
if not bool(ip):
return self.del_net(network = network)
obj_json = self._get_json()
net = Network(name = network, mongo_db = self._mongo_db)
try:
old_rel_ip = obj_json['connected'][str(net.DBRef.id)]
except:
old_rel_ip = None
if old_rel_ip:
net.release_ip(net.relnum_to_ip(old_rel_ip))
new_ip = net.reserve_ip(ip)
if not new_ip:
return None
obj_json['connected'][str(net.DBRef.id)] = new_ip
ret = self._mongo_collection.update({'_id': self._id}, {'$set': obj_json}, multi=False, upsert=False)
if not old_rel_ip:
self.link(net)
def clone(self, name):
osimage_dbref = self.get('osimage')
osimage = OsImage(id=osimage_dbref.id, mongo_db=self._mongo_db)
bmcsetup_name = None
bmcsetup_dbref = self.get('bmcsetup')
if bmcsetup_dbref:
bmcsetup = BMCSetup(id=bmcsetup_dbref.id, mongo_db=self._mongo_db)
bmcsetup_name = bmcsetup.name
pre = self.get('prescript')
post = self.get('postscript')
part = self.get('partscript')
comment = self.get('comment')
if_list = self.list_ifs().keys()
domain_dbref = self.get('domain')
domain_name = None
if domain_dbref:
domain_net = Network(id=domain_dbref.id, mongo_db=self._mongo_db)
domain_name = domain_net.name
torrent_if = self.get('torrent_if')
if not torrent_if:
torrent_if = None
group = Group(
name=name,
create=True,
bmcsetup=bmcsetup_name,
osimage=osimage.name,
interfaces=if_list,
prescript=pre,
partscript=part,
postscript=post,
torrent_if=torrent_if,
domain=domain_name,
mongo_db=self._mongo_db,
)
group.set('comment', comment)
for if_name in if_list:
if_dict = self.show_if(if_name)
for ver in ['4', '6']:
if not if_dict['network'][ver]['name']:
continue
group.set_net_to_if(if_name, if_dict['network'][ver]['name'])
return group
def del_net(self, network=None):
if not network:
self.log.error("Network needs to be specified")
return None
connected = self.get('connected')
net = Network(network, mongo_db=self._mongo_db)
if not str(net.id) in connected:
self.log.error(
"Device '{}' is not attached to network '{}'".format(
self.name, str(network)))
return None
net.release_ip(connected[str(net.id)])
connected.pop(str(net.id))
res = self.set('connected', connected)
self.unlink(net)
return res
def set_net_to_if(self, interface_name, network_name):
interfaces_dict = self.get('interfaces')
if_list = self.list_ifs()
if interface_name not in if_list.keys():
self.log.error(
"Interface '{}' does not exist".format(interface_name)
)
return False
interface_uuid = if_list[interface_name]
network_obj = Network(network_name, mongo_db=self._mongo_db)
version = str(network_obj.version)
if interfaces_dict[interface_uuid]['network'][version]:
self.log.error(
"Network IPv{} is already defined for interface '{}'"
.format(version, interface_name)
)
return False
interfaces_dict[interface_uuid]['network'][version] = network_obj.DBRef
res = self.set('interfaces', interfaces_dict)
if not res:
self.log.error("Error adding network for interface '{}'"
.format(interface_name))
return False
self.link(network_obj)
self._invalidate_network(network_obj.id)
reverse_links = self.get_back_links()
# Now we need to assign ip for every node in group
nodes = {}
for link in reverse_links:
if link['collection'] == 'node':
node_obj = Node(id=link['DBRef'].id, mongo_db=self._mongo_db)
nodes[node_obj.name] = node_obj
nodenames = nodes.keys()
nodenames.sort()
for nodename in nodenames:
node_obj = nodes[nodename]
node_obj.add_ip(interface_name)
return True
def get(self, key):
if key == 'ip':
net_dbref = self._json['network']
if not net_dbref:
return None
net = Network(id=net_dbref.id, mongo_db=self._mongo_db)
return utils.ip.reltoa(net._json['NETWORK'], self._json['ip'],
net.version)
if key == 'network':
net_dbref = self._json['network']
if not net_dbref:
return None
net = Network(id=net_dbref.id, mongo_db=self._mongo_db)
return net.name
return super(Switch, self).get(key)
def __init__(self, name = None, mongo_db = None, create = False, id = None, network = None,
ip = None):
"""
netwwork - network device connected
ip - ip of the switch
"""
self._logger.debug("Arguments to function '{}".format(self._debug_function()))
self._collection_name = 'otherdev'
mongo_doc = self._check_name(name, mongo_db, create, id)
self._keylist = {}
if create:
cluster = Cluster(mongo_db = self._mongo_db)
passed_vars = inspect.currentframe().f_locals
for key in self._keylist:
if type(passed_vars[key]) is not self._keylist[key]:
self._logger.error("Argument '{}' should be '{}'".format(key, self._keylist[key]))
raise RuntimeError
if not bool(network):
connected = {}
else:
if not bool(ip):
self._logger.error("IP needs to be specified")
raise RuntimeError
net = Network(name = network, mongo_db = self._mongo_db)
ip = net.reserve_ip(ip, ignore_errors = False)
if not bool(ip):
raise RuntimeError
connected = {str(net.DBRef.id): ip}
mongo_doc = { 'name': name, 'connected': connected}
self._logger.debug("mongo_doc: '{}'".format(mongo_doc))
self._name = name
self._id = self._mongo_collection.insert(mongo_doc)
self._DBRef = DBRef(self._collection_name, self._id)
self.link(cluster)
if bool(connected):
self.link(net)
else:
self._name = mongo_doc['name']
self._id = mongo_doc['_id']
self._DBRef = DBRef(self._collection_name, self._id)
def __init__(self, name = None, mongo_db = None, create = False, id = None, network = None,
ip = None):
"""
netwwork - network device connected
ip - ip of the switch
"""
self._logger.debug("Arguments to function '{}".format(self._debug_function()))
self._collection_name = 'otherdev'
mongo_doc = self._check_name(name, mongo_db, create, id)
self._keylist = {}
if create:
cluster = Cluster(mongo_db = self._mongo_db)
passed_vars = inspect.currentframe().f_locals
for key in self._keylist:
if type(passed_vars[key]) is not self._keylist[key]:
self._logger.error("Argument '{}' should be '{}'".format(key, self._keylist[key]))
raise RuntimeError
if not bool(network):
connected = {}
else:
if not bool(ip):
self._logger.error("IP needs to be specified")
raise RuntimeError
net = Network(name = network, mongo_db = self._mongo_db)
ip = net.reserve_ip(ip, ignore_errors = False)
if not bool(ip):
raise RuntimeError
connected = {str(net.DBRef.id): ip}
mongo_doc = { 'name': name, 'connected': connected}
self._logger.debug("mongo_doc: '{}'".format(mongo_doc))
self._name = name
self._id = self._mongo_collection.insert(mongo_doc)
self._DBRef = DBRef(self._collection_name, self._id)
self.link(cluster)
if bool(connected):
self.link(net)
else:
self._name = mongo_doc['name']
self._id = mongo_doc['_id']
self._DBRef = DBRef(self._collection_name, self._id)
def show_if(self, interface, brief = False):
interfaces = self._get_json()['interfaces']
try:
params = interfaces[interface]
except:
self._logger.error("Interface '{}' does not exist".format(interface))
return ""
(outstr, NETWORK, PREFIX) = ("", "", "")
try:
net = Network(id = params['network'].id, mongo_db = self._mongo_db)
NETWORK = net.get('NETWORK')
PREFIX = str(net.get('PREFIX'))
except:
pass
if NETWORK:
if brief:
return "[" +net.name + "]:" + NETWORK + "/" + PREFIX
outstr = "NETWORK=" + NETWORK + "\n"
outstr += "PREFIX=" + PREFIX
if params['params'] and not brief:
outstr += "\n" + params['params']
return outstr.rstrip()
def show_if(self, interface, brief = False):
interfaces = self._get_json()['interfaces']
try:
params = interfaces[interface]
except:
self._logger.error("Interface '{}' does not exist".format(interface))
return ""
(outstr, NETWORK, PREFIX) = ("", "", "")
try:
net = Network(id = params['network'].id, mongo_db = self._mongo_db)
NETWORK = net.get('NETWORK')
PREFIX = str(net.get('PREFIX'))
except:
pass
if NETWORK:
if brief:
return "[" +net.name + "]:" + NETWORK + "/" + PREFIX
outstr = "NETWORK=" + NETWORK + "\n"
outstr += "PREFIX=" + PREFIX
if params['params'] and not brief:
outstr += "\n" + params['params']
return outstr.rstrip()
def __init__(self, name = None, mongo_db = None, create = False, id = None, network = None,
ip = None, read = 'public', rw = 'private', oid = None):
"""
ip - ip of the switch
read - read community
rw - rw community
oid - could be, for instance
.1.3.6.1.2.1.17.7.1.2.2.1.2
.1.3.6.1.2.1.17.4.3.1.2
.1.3.6.1.2.1.17.7.1.2.2
.1.3.6.1.2.1.17.4.3.1.2
"""
self._logger.debug("Arguments to function '{}".format(self._debug_function()))
self._collection_name = 'switch'
mongo_doc = self._check_name(name, mongo_db, create, id)
self._keylist = { 'ip': type(''), 'read': type(''), 'rw': type(''), 'oid': type(''), 'network': type('')}
if create:
cluster = Cluster(mongo_db = self._mongo_db)
passed_vars = inspect.currentframe().f_locals
for key in self._keylist:
if type(passed_vars[key]) is not self._keylist[key]:
self._logger.error("Argument '{}' should be '{}'".format(key, self._keylist[key]))
raise RuntimeError
net = Network(name = network, mongo_db = self._mongo_db)
ip = net.reserve_ip(ip)
if not bool(ip):
self._logger.error("Could not acquire ip for switch.")
raise RuntimeError
mongo_doc = { 'name': name, 'network': net.DBRef, 'ip': ip, 'read': read, 'rw': rw, 'oid': oid}
self._logger.debug("mongo_doc: '{}'".format(mongo_doc))
self._name = name
self._id = self._mongo_collection.insert(mongo_doc)
self._DBRef = DBRef(self._collection_name, self._id)
self.link(cluster)
self.link(net)
else:
self._name = mongo_doc['name']
self._id = mongo_doc['_id']
self._DBRef = DBRef(self._collection_name, self._id)
def get(self, key):
if key == 'dhcp_net':
from luna.network import Network
from bson.objectid import ObjectId
netid = super(Cluster, self).get(key)
if not bool(netid):
return None
net = Network(id = ObjectId(netid), mongo_db = self._mongo_db)
try:
net = Network(id = ObjectId(netid), mongo_db = self._mongo_db)
return net.name
except:
self._logger.error('Wrong DHCP network configured')
return None
if key == 'dhcp_range_start' or key == 'dhcp_range_end':
from luna.network import Network
from bson.objectid import ObjectId
netid = super(Cluster, self).get('dhcp_net')
if not bool(netid):
return None
net = Network(id = ObjectId(netid), mongo_db = self._mongo_db)
return net.relnum_to_ip(super(Cluster, self).get(key))
return super(Cluster, self).get(key)
def set(self, key, value):
if not bool(key) or type(key) is not str :
self._logger.error("Field should be specified")
return None
if not key in self._keylist:
self._logger.error("Cannot change '{}' field".format(key))
return None
obj_json = self._get_json()
if key == 'ip':
net_dbref = obj_json['network']
old_ip = obj_json['ip']
net = Network(id = net_dbref.id, mongo_db = self._mongo_db)
if not net.ip_in_net(value):
self._logger.error("This IP: '{}' does not belong to defined network.".format(value))
return None
if old_ip:
net.release_ip(old_ip)
ip = net.reserve_ip(value)
obj_json['ip'] = ip
ret = self._mongo_collection.update({'_id': self._id}, {'$set': obj_json}, multi=False, upsert=False)
return not ret['err']
if key == 'network':
old_net_dbref = obj_json['network']
old_net = Network(id = old_net_dbref.id, mongo_db = self._mongo_db)
old_ip_rel = obj_json['ip']
old_ip_human_readable = self.get('ip')
new_net = Network(name = value, mongo_db = self._mongo_db)
if old_net.DBRef == new_net.DBRef:
return None
new_ip_rel = old_ip_rel
new_ip_human_readable = new_net.relnum_to_ip(new_ip_rel)
if not new_net.reserve_ip(new_ip_human_readable):
return None
old_net.release_ip(old_ip_human_readable)
obj_json['network'] = new_net.DBRef
ret = self._mongo_collection.update({'_id': self._id}, {'$set': obj_json}, multi=False, upsert=False)
self.link(new_net)
self.unlink(old_net)
return not ret['err']
return super(Switch, self).set(key, value)
def makedns(self):
from luna.network import Network
from bson.objectid import ObjectId
from tornado import template
import pwd
import grp
import os
# get network _id configured for cluster
obj_json = self._get_json()
try:
rev_links = obj_json[usedby_key]
except:
self._logger.error("No IP addresses for network '{}' configured.".format(self.name))
return None
netids = []
for elem in rev_links:
if elem == 'network':
for netid in rev_links[elem]:
netids.extend([netid])
# fill network dictionary {'netname': {'ns_hostname': 'servername', 'ns_ip': 'IP', 'hosts' {'name': 'IP'}}}
networks = {}
for netid in netids:
netobj = Network(id = ObjectId(netid))
networks[netobj.name] = {}
master_ip = netobj.get('ns_ip')
networks[netobj.name]['ns_hostname'] = netobj.get('ns_hostname')
networks[netobj.name]['ns_ip'] = master_ip
networks[netobj.name]['hosts'] = netobj.resolve_used_ips()
# some inout for reverse zones
# here is steps to figure out which octets in ipadresses are common for all ips in network.
# we can not rely on mask here, as mask can not be devisible by 8 (/12, /15, /21, etc)
arr1 = [int(elem) for elem in master_ip.split('.')]
logical_arr1 = [True, True, True, True]
for host in networks[netobj.name]['hosts']:
ip = networks[netobj.name]['hosts'][host]
arr2 = [int(elem) for elem in ip.split('.')]
logical_arr = [ bool(arr1[n] == arr2[n]) for n in range(len(arr1))]
logical_arr2 = [logical_arr[n] & logical_arr1[n] for n in range(len(logical_arr))]
arr1 = arr2[:]
logical_arr1 = logical_arr2[:]
# get fist octet in ip adresses which is changing
try:
mutable_octet = [i for i in range(len(logical_arr1)) if not logical_arr1[i]][0]
except IndexError:
mutable_octet = 3
# generate zone file name
revzonename = '.'.join(list(reversed(master_ip.split('.')[:mutable_octet]))) + ".in-addr.arpa"
networks[netobj.name]['mutable_octet'] = mutable_octet
networks[netobj.name]['rev_zone_name'] = revzonename
# figure out paths
includefile = self.get('named_include_file')
zonedir = self.get('named_zone_dir')
if not includefile:
self._logger.error("named_include_file should be configured")
return None
if not zonedir:
self._logger.error("named_zone_dir should be configured")
return None
# load templates
tloader = template.Loader(self.get('path') + '/templates')
# create include file for named.conf
namedconffile = open(includefile, 'w')
zonenames = []
for network in networks:
zonenames.extend([network, networks[network]['rev_zone_name']])
namedconffile.write(tloader.load('templ_named_conf.cfg').generate(networks = zonenames))
namedconffile.close()
nameduid = pwd.getpwnam("named").pw_uid
namedgid = grp.getgrnam("named").gr_gid
os.chown(includefile, 0, namedgid)
self._logger.info("Created '{}'".format(includefile))
# remove zone files
filelist = [ f for f in os.listdir(zonedir) if f.endswith(".luna.zone") ]
for f in filelist:
filepath = zonedir + "/" + f
try:
os.remove(filepath)
self._logger.info("Removed old '{}'".format(filepath))
except:
self._logger.info("Unable to remove '{}'".format(filepath))
# create zone files
for network in networks:
# create zone
z = {}
z['master_hostname'] = networks[network]['ns_hostname']
z['master_ip'] = networks[network]['ns_ip']
z['serial_num'] = 1
z['hosts'] = networks[network]['hosts']
zonefilepath = zonedir + "/" + network + ".luna.zone"
zonefile = open(zonefilepath, 'w')
zonefile.write(tloader.load('templ_zone.cfg').generate(z = z))
zonefile.close()
os.chown(zonefilepath, nameduid, namedgid)
self._logger.info("Created '{}'".format(zonefilepath))
revzonepath = zonedir + "/" + networks[network]['rev_zone_name'] + ".luna.zone"
z['master_hostname'] = networks[network]['ns_hostname'] + "." + network
z['hosts'] = {}
for host in networks[network]['hosts']:
hostname = host + "." + network
iparr = [int(elem) for elem in networks[network]['hosts'][host].split('.')]
reverseiplist = list(reversed(iparr[networks[network]['mutable_octet']:]))
reverseip = '.'.join([str(elem) for elem in reverseiplist])
z['hosts'][hostname] = reverseip
zonefile = open(revzonepath, 'w')
zonefile.write(tloader.load('templ_zone_arpa.cfg').generate(z = z))
zonefile.close()
os.chown(revzonepath, nameduid, namedgid)
self._logger.info("Created '{}'".format(revzonepath))
return True
def __init__(self, name=None, mongo_db=None, create=False,
id=None, network=None, ip=None, read='public',
rw='private', oid=None, comment=''):
"""
ip - ip of the switch
read - read community
rw - rw community
oid - could be, for instance
.1.3.6.1.2.1.17.7.1.2.2.1.2
.1.3.6.1.2.1.17.4.3.1.2
.1.3.6.1.2.1.17.7.1.2.2
.1.3.6.1.2.1.17.4.3.1.2
"""
self.log.debug("function args {}".format(self._debug_function()))
# Define the schema used to represent switch objects
self._collection_name = 'switch'
self._keylist = {
'read': type(''),
'rw': type(''),
'oid': type(''),
'comment': type(''),
}
# Check if this switch is already present in the datastore
# Read it if that is the case
switch = self._get_object(name, mongo_db, create, id)
if create:
cluster = Cluster(mongo_db=self._mongo_db)
if not network:
err_msg = "Network must be provided"
self.log.error(err_msg)
raise RuntimeError, err_msg
if not name:
err_msg = "Name must be provided"
self.log.error(err_msg)
raise RuntimeError, err_msg
net = Network(name=network, mongo_db=self._mongo_db)
ip = net.reserve_ip(ip)
if not ip:
err_msg = "Could not acquire ip for switch"
self.log.error(err_msg)
raise RuntimeError, err_msg
# Store the new switch in the datastore
switch = {'name': name, 'network': net.DBRef, 'ip': ip,
'read': read, 'rw': rw, 'oid': oid, 'comment': comment}
self.log.debug("Saving switch '{}' to the datastore"
.format(switch))
self.store(switch)
# Link this switch to its dependencies and the current cluster
self.link(cluster)
self.link(net)
self.log = logging.getLogger('switch.' + self._name)
def release_resources(self):
net_dbref = self._json['network']
net = Network(id=net_dbref.id, mongo_db=self._mongo_db)
net.release_ip(self.get('ip'))
return True
def manage_ip(self, interface_uuid=None,
ip=None, release=False, version=None):
"""
operations with IP: add/delete
"""
if version:
version = str(version)
if version and version not in ['4', '6']:
self.log.error("Only IPv4 and IPv6 are supported")
return False
if interface_uuid not in self.get('interfaces'):
self.log.error("Interface {} does not exixt"
.format(interface_uuid))
return False
interface_name = self.get('interfaces')[interface_uuid]['name']
net4_dbref = self.get('interfaces')[interface_uuid]['network']['4']
net6_dbref = self.get('interfaces')[interface_uuid]['network']['6']
if not version:
if net4_dbref and net6_dbref:
self.log.error(
("Both IPv4 and IPv6 " +
"are configured for the interface {}. " +
"Version needs to be specified.")
.format(interface_name)
)
return False
if not version and not net4_dbref and not net6_dbref:
self.log.warning("Network is not configured for the interface {}."
.format(interface_name))
return False
net_dbref = net4_dbref
if not version:
if net6_dbref:
net_dbref = net6_dbref
else:
if int(version) == 6:
net_dbref = net6_dbref
if not net_dbref:
self.log.warning(
"Network IPv{} is not configured for the interface {}."
.format(version, interface_name)
)
return False
net_obj = Network(id=net_dbref.id, mongo_db=self._mongo_db)
self._invalidate_network(net_obj)
if release and ip:
return net_obj.release_ip(ip)
else:
return net_obj.reserve_ip(ip)
