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 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(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 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 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 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 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(utils.ip.reltoa(net._get_json()['NETWORK'], 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 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 utils.ip.ip_in_net(value, net._get_json['NETWORK'], net._get_json['PREFIX']):
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 = utils.ip.reltoa(new_net._get_json()['NETWORK'], 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 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 utils.ip.reltoa(net._get_json()['NETWORK'], super(Cluster, self).get(key))
return super(Cluster, self).get(key)
