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