def free_cidr(cidr, uuid): """ Frees a issued CIDR thus it can be reused. :param cidr: The currently used CIDR. :type cidr: ``str`` :param uuid: The UUID of the Subnet, which uses this CIDR. :type uuid: ``str`` :return: Returns False if the CIDR is None or the UUID did not correspond tho the used CIDR. Else it returns True. :rtype: ``bool`` """ if cidr is None: return False global __current_ip int_ip = Net.cidr_2_int(cidr) global lock lock.acquire() if int_ip in __issued_ips and __issued_ips[int_ip] == uuid: del __issued_ips[int_ip] if int_ip < __current_ip: __current_ip = int_ip lock.release() return True lock.release() return False
def __init__(self, net, switch, name='osm', vca_host=os.environ.get('VCA_HOST'), vca_secret=os.environ.get('VCA_SECRET'), osm_version='releasefive-daily', ip_start='10.0.0.100'): ip_int = Net.ip_2_int(ip_start) zookeeper_ip = ip_start kafka_ip = Net.int_2_ip(ip_int + 1) mongo_ip = Net.int_2_ip(ip_int + 2) nbi_ip = Net.int_2_ip(ip_int + 3) ro_db_ip = Net.int_2_ip(ip_int + 4) ro_ip = Net.int_2_ip(ip_int + 5) lcm_ip = Net.int_2_ip(ip_int + 6) name_prefix = '%s-' % name self.zookeeper = Zookeeper(net, '%s/16' % zookeeper_ip, name_prefix=name_prefix) self.kafka = Kafka(net, '%s/16' % kafka_ip, zookeeper_ip, name_prefix=name_prefix) self.mongo = Mongo(net, '%s/16' % mongo_ip, name_prefix=name_prefix) self.nbi = NBI(net, '%s/16' % nbi_ip, mongo_ip, kafka_ip, version=osm_version, name_prefix=name_prefix) self.ro_db = Mysql(net, '%s/16' % ro_db_ip, name_prefix=name_prefix) self.ro = RO(net, '%s/16' % ro_ip, ro_db_ip, version=osm_version, name_prefix=name_prefix) self.lcm = LCM(net, '%s/16' % lcm_ip, ro_ip, mongo_ip, kafka_ip, vca_host, vca_secret, version=osm_version, name_prefix=name_prefix) net.addLink(self.zookeeper.instance, switch) net.addLink(self.kafka.instance, switch) net.addLink(self.mongo.instance, switch) net.addLink(self.nbi.instance, switch) net.addLink(self.ro_db.instance, switch) net.addLink(self.ro.instance, switch) net.addLink(self.lcm.instance, switch)
def create_network(self, name, stack_operation=False): """ Creates a new network with the given name. Raises an exception when a network with the given name already exists! :param name: Name of the new network. :type name: ``str`` :param stack_operation: Allows the heat parser to create modules without adapting the current emulation. :type stack_operation: ``bool`` :return: :class:`heat.resources.net` """ LOG.debug("Creating network with name %s" % name) if self.find_network_by_name_or_id( name) is not None and not stack_operation: LOG.warning( "Creating network with name %s failed, as it already exists" % name) raise Exception("Network with name %s already exists." % name) network = Net(name) network.id = str(uuid.uuid4()) if not stack_operation: self.nets[network.id] = network return network
def is_cidr_issued(cidr): """ Returns True if the CIDR is used. :param cidr: The requested CIDR. :type cidr: ``str`` :return: Returns True if the CIDR is used, else False. :rtype: ``bool`` """ if cidr is None: return False int_ip = Net.cidr_2_int(cidr) if int_ip in __issued_ips: return True return False
def init_floating_network(self, name="default"): """ Initialize the floating network component for the emulator. Will not do anything if already initialized. """ if self.net is not None and self.floating_switch is None: # create a floating network fn = self.floating_network = Net(name) fn.id = str(uuid.uuid4()) fn.set_cidr(self.floating_netmask) # create a subnet fn.subnet_id = str(uuid.uuid4()) fn.subnet_name = fn.name + "-sub" # create a port for the host port = Port("root-port") # port.id = str(uuid.uuid4()) port.net_name = fn.name # get next free ip root_ip = fn.get_new_ip_address(port.name) port.ip_address = root_ip # floating ip network setup # wierd way of getting a datacenter object first_dc = self.net.dcs.values()[0] # set a dpid for the switch. for this we have to get the id of the # next possible dc self.floating_switch = self.net.addSwitch( "fs1", dpid=hex(first_dc._get_next_dc_dpid())[2:]) # this is the interface appearing on the physical host self.floating_root = Node('root', inNamespace=False) self.net.hosts.append(self.floating_root) self.net.nameToNode['root'] = self.floating_root self.floating_intf = self.net.addLink( self.floating_root, self.floating_switch).intf1 self.floating_root.setIP(root_ip, intf=self.floating_intf) self.floating_nodes[(self.floating_root.name, root_ip)] = self.floating_root
def is_my_cidr(cidr, uuid): """ Checks if the UUID and the used CIDR are related. :param cidr: The issued CIDR. :type cidr: ``str`` :param uuid: The Subnet UUID. :type uuid: ``str`` :return: Returns False if the CIDR is None or if the CIDR is not issued. Else returns True. :rtype: ``bool`` """ if cidr is None: return False int_ip = Net.cidr_2_int(cidr) if int_ip not in __issued_ips: return False if __issued_ips[int_ip] == uuid: return True return False
def get_new_cidr(uuid): """ Calculates a unused cidr for a subnet. :param uuid: The UUID of the subnet - Thus it can store which subnet gets which CIDR :type uuid: ``str`` :return: Returns None if all available CIDR are used. Otherwise returns a valid CIDR. :rtype: ``str`` """ global lock lock.acquire() global __current_ip while __first_ip <= __current_ip < __last_ip and __current_ip in __issued_ips: __current_ip += __default_subnet_size if __current_ip >= __last_ip or __current_ip < __first_ip or __current_ip in __issued_ips: return None __issued_ips[__current_ip] = uuid lock.release() return Net.int_2_ip(__current_ip) + '/' + str(__default_subnet_bitmask)
def assign_cidr(cidr, uuid): """ Allows a subnet to request a specific CIDR. :param cidr: The requested CIDR. :type cidr: ``str`` :param uuid: The Subnet UUID. :type uuid: ``str`` :return: Returns False if the CIDR is None or if the CIDR is already issued. Returns True if the CIDR could be assigned to the UUID. """ if cidr is None: return False int_ip = Net.cidr_2_int(cidr) if int_ip in __issued_ips: return False global lock lock.acquire() __issued_ips[int_ip] = uuid lock.release() return True
# permission. # # This work has been performed in the framework of the SONATA project, # funded by the European Commission under Grant number 671517 through # the Horizon 2020 and 5G-PPP programmes. The authors would like to # acknowledge the contributions of their colleagues of the SONATA # partner consortium (www.sonata-nfv.eu). from emuvim.api.openstack.resources.net import Net import threading lock = threading.Lock() __issued_ips = dict() __default_subnet_size = 256 __default_subnet_bitmask = 24 __first_ip = Net.ip_2_int('10.0.0.0') __last_ip = Net.ip_2_int('10.255.255.255') __current_ip = __first_ip def get_new_cidr(uuid): """ Calculates a unused cidr for a subnet. :param uuid: The UUID of the subnet - Thus it can store which subnet gets which CIDR :type uuid: ``str`` :return: Returns None if all available CIDR are used. Otherwise returns a valid CIDR. :rtype: ``str`` """ global lock lock.acquire()