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 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 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 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 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 _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 _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 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)