def createlgnetworks(keys,values):
phynetlen = (len(keys) - len(networkmap)*2 - 1)//2
phynetkeys = keys[1 + len(networkmap)*2 : 1 + len(networkmap)*2 + phynetlen]
phynetvalues = values[1 + len(networkmap)*2 : 1 + len(networkmap)*2 + phynetlen]
phynetmapkeys = keys[1+len(networkmap)*2 + phynetlen:]
phynetmapvalues = values[1+len(networkmap)*2 + phynetlen:]
phynetmapdict = dict(zip(phynetkeys,zip(phynetvalues,phynetmapvalues)))
for i in range(0,len(networks)):
phynet,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
if not phynet or not phymap:
raise ValueError("physicalnetwork key object not existed "+\
networkmap[i][0].physicalnetwork.getkey())
# set lgnetwork
values[1+i] = set_new(values[i + 1],networkmap[i][0])
# set lgnetworkmap
values[1+i+len(networks)] = set_new(values[i + 1 + len(networks)],networkmap[i][1])
# set phynetmap
#_,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
phymap.logicnetworks.dataset().add(networkmap[i][0].create_weakreference())
values[0].set.dataset().add(networkmap[i][0].create_weakreference())
return keys[0:1] + keys[1:1+len(networks)+len(networks)]+phynetmapkeys,\
values[0:1]+values[1:1+len(networks)+len(networks)] + phynetmapvalues
def create_phys(physet, *phynets):
return_nets = [None, None] * len(new_networks)
for i in range(0, len(new_networks)):
return_nets[i * 2] = set_new(phynets[i * 2], new_networks[i][0])
return_nets[i * 2 + 1] = set_new(phynets[i * 2 + 1], new_networks[i][1])
physet.set.dataset().add(new_networks[i][0].create_weakreference())
return [physet] + return_nets
def createphynetworks(keys,values):
for i in range(0,len(new_networks)):
values[i + 1] = set_new(values[i + 1],new_networks[i][0])
values[i + 1 + len(new_networks)] = set_new(values[i + 1 + len(new_networks)],
new_networks[i][1])
values[0].set.dataset().add(new_networks[i][0].create_weakreference())
return keys,values
def createphynetworks(keys,values):
for i in range(0,len(new_networks)):
values[i + 1] = set_new(values[i + 1],new_networks[i][0])
values[i + 1 + len(new_networks)] = set_new(values[i + 1 + len(new_networks)],
new_networks[i][1])
values[0].set.dataset().add(new_networks[i][0].create_weakreference())
return keys,values
def create_logs(logset, *networks):
phy_maps = list(networks[len(new_networks) * 2 : len(new_networks) * 2 + len(physical_networks)])
phy_nets = list(networks[len(new_networks) * 2 + len(physical_networks):])
phy_dict = dict(zip(physical_networks, zip(phy_nets, phy_maps)))
return_nets = [None, None] * len(new_networks)
for i in range(0, len(new_networks)):
return_nets[2 * i] = set_new(networks[2 * i], new_networks[i][0])
return_nets[2 * i + 1] = set_new(networks[2 * i + 1], new_networks[i][1])
for n in return_nets[::2]:
phynet, phymap = phy_dict.get(n.physicalnetwork.getkey())
if phynet is None:
_, (phyid,) = PhysicalNetwork._getIndices(n.physicalnetwork.getkey())
raise ValueError('Physical network %r does not exist' % (phyid,))
else:
if phynet.type == 'vlan':
if hasattr(n, 'vlanid'):
n.vlanid = int(n.vlanid)
if n.vlanid <= 0 or n.vlanid >= 4095:
raise ValueError('Invalid VLAN ID')
# VLAN id is specified
if str(n.vlanid) in phymap.network_allocation:
raise ValueError('VLAN ID %r is already allocated in physical network %r' % (n.vlanid,phynet.id))
else:
for start,end in phynet.vlanrange:
if start <= n.vlanid <= end:
break
else:
raise ValueError('VLAN ID %r is not in vlan range of physical network %r' % (n.vlanid,phynet.id))
phymap.network_allocation[str(n.vlanid)] = n.create_weakreference()
else:
# Allocate a new VLAN id
for start,end in phynet.vlanrange:
for vlanid in range(start, end + 1):
if str(vlanid) not in phymap.network_allocation:
break
else:
continue
break
else:
raise ValueError('Not enough VLAN ID to be allocated in physical network %r' % (phynet.id,))
n.vlanid = vlanid
phymap.network_allocation[str(vlanid)] = n.create_weakreference()
else:
if phymap.network_allocation:
raise ValueError('Physical network %r is already allocated by another logical network', (phynet.id,))
phymap.network_allocation['native'] = n.create_weakreference()
phymap.networks.dataset().add(n.create_weakreference())
logset.set.dataset().add(n.create_weakreference())
return [logset] + return_nets + phy_maps
def createpyports(keys, values):
phynetlen = (len(keys) - 1 - len(portobjs)) // 2
phynetkeys = keys[1 + len(portobjs):1 + len(portobjs) + phynetlen]
phynetvalues = values[1 + len(portobjs):1 + len(portobjs) +
phynetlen]
phynetmapkeys = keys[1 + len(portobjs) + phynetlen:]
phynetmapvalues = values[1 + len(portobjs) + phynetlen:]
phynetdict = dict(
zip(phynetkeys, zip(phynetvalues, phynetmapvalues)))
for i in range(0, len(portobjs)):
values[i + 1] = set_new(values[i + 1], portobjs[i])
key = portobjs[i].physicalnetwork.getkey()
phynet, phymap = phynetdict.get(key)
if not phynet or not phymap:
raise ValueError("key object not existed " + key)
phymap.ports.dataset().add(portobjs[i].create_weakreference())
values[0].set.dataset().add(portobjs[i].create_weakreference())
return keys[0:1 + len(ports)] + phynetmapkeys, values[
0:1 + len(ports)] + phynetmapvalues
def createrouterdb(keys,values):
routerset = values[0]
for i in range(0,len(routerkeys)):
values[i+1] = set_new(values[i+1],routerobjects[i])
routerset.set.dataset().add(routerobjects[i].create_weakreference())
return keys,values
def createlgnetworks(keys,values):
phynetlen = (len(keys) - len(networkmap)*2 - 1)//2
phynetkeys = keys[1 + len(networkmap)*2 : 1 + len(networkmap)*2 + phynetlen]
phynetvalues = values[1 + len(networkmap)*2 : 1 + len(networkmap)*2 + phynetlen]
phynetmapkeys = keys[1+len(networkmap)*2 + phynetlen:]
phynetmapvalues = values[1+len(networkmap)*2 + phynetlen:]
phynetmapdict = dict(zip(phynetkeys,zip(phynetvalues,phynetmapvalues)))
for i in range(0,len(networks)):
phynet,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
if not phynet or not phymap:
raise ValueError("physicalnetwork key object not existed "+\
networkmap[i][0].physicalnetwork.getkey())
if phymap.logicnetworks.dataset():
raise ValueError("native physicalnetwork only have one logicalnetwork")
# set lgnetwork
values[1+i] = set_new(values[i + 1],networkmap[i][0])
# set lgnetworkmap
values[1+i+len(networks)] = set_new(values[i + 1 + len(networks)],networkmap[i][1])
# set phynetmap
#_,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
phymap.logicnetworks.dataset().add(networkmap[i][0].create_weakreference())
values[0].set.dataset().add(networkmap[i][0].create_weakreference())
return keys[0:1] + keys[1:1+len(networks)+len(networks)]+phynetmapkeys,\
values[0:1]+values[1:1+len(networks)+len(networks)] + phynetmapvalues
def create_ports(portset, *objs):
old_ports = objs[:len(new_ports)]
logmaps = list(objs[len(new_ports):len(new_ports) + len(logical_networks)])
lognets = list(objs[len(new_ports) + len(logical_networks):])
logdict = dict(zip(logical_networks, zip(lognets, logmaps)))
return_ports = [None] * len(new_ports)
for i in range(0, len(new_ports)):
return_ports[i] = set_new(old_ports[i], new_ports[i])
for p in return_ports:
lognet, logmap = logdict[p.logicalnetwork.getkey()]
if lognet is None:
_, (logid,) = LogicalNetwork._getIndices(p.logicalnetwork.getkey())
raise ValueError('Logical network %r does not exist' % (logid,))
logmap.ports.dataset().add(p.create_weakreference())
portset.set.dataset().add(p.create_weakreference())
return [portset] + return_ports + logmaps
def create_ports(portset, *objs):
old_ports = objs[:len(new_ports)]
phymaps = list(objs[len(new_ports):len(new_ports) + len(physical_networks)])
phynets = list(objs[len(new_ports) + len(physical_networks):])
phydict = dict(zip(physical_networks, zip(phynets, phymaps)))
return_ports = [None] * len(new_ports)
for i in range(0, len(new_ports)):
return_ports[i] = set_new(old_ports[i], new_ports[i])
for p in return_ports:
phynet, phymap = phydict[p.physicalnetwork.getkey()]
if phynet is None:
_, (phyid,) = PhysicalNetwork._getIndices(p.physicalnetwork.getkey())
raise ValueError('Physical network %r does not exist' % (phyid,))
phymap.ports.dataset().add(p.create_weakreference())
portset.set.dataset().add(p.create_weakreference())
return [portset] + return_ports + phymaps
def _updater(keys, values, timestamp):
reservepool = values[0]
reserve_new_pool = set_new(values[1], new_pool)
remove_keys = self._remove_staled_pools(
reservepool, timestamp)
used_cidrs = set(
cidr
for _, (cidr, _) in reservepool.reserved_pools.items())
if not reserve_new_pool.pool:
# pool is not specified
for _ in range(0, self.cidrrange_end):
reservepool.nextalloc += 1
if reservepool.nextalloc >= self.cidrrange_end:
reservepool.nextalloc = 0
new_subnet = self.cidrrange_subnet | (
reservepool.nextalloc << 8)
new_cidr = ip4_addr.formatter(new_subnet) + '/24'
if new_cidr not in used_cidrs:
break
reserve_new_pool.pool = new_cidr
reserve_new_pool.subpool = ''
rets[:] = [reserve_new_pool.pool]
if reserve_new_pool.pool in used_cidrs:
# We must wait until this CIDR is released
raise IPAMUsingException
reservepool.reserved_pools[reserve_new_pool.id] = \
[reserve_new_pool.pool,
timestamp + self.pooltimeout * 1000000]
marker = IPAMReserveMarker.create_instance(
reserve_new_pool.pool)
if marker.getkey() in remove_keys:
remove_keys.remove(marker.getkey())
return (tuple(keys[0:2]) + tuple(remove_keys),
(reservepool, reserve_new_pool) +
(None, ) * len(remove_keys))
else:
return (tuple(keys[0:2]) + (marker.getkey(), ) +
tuple(remove_keys),
(reservepool, reserve_new_pool, marker) +
(None, ) * len(remove_keys))
def _walker(walk, write):
for p, port in zip(new_ports, ports):
key = p.getkey()
try:
value = walk(key)
except KeyError:
pass
else:
new_port = self._createphysicalport(**port)
value = set_new(value, new_port)
try:
phynet = walk(new_port.physicalnetwork.getkey())
except KeyError:
pass
else:
if phynet is None:
_, (phyid, ) = PhysicalNetwork._getIndices(
p.physicalnetwork.getkey())
raise ValueError(
'Physical network %r does not exist' %
(phyid, ))
write(key, value)
try:
phymap = walk(
PhysicalNetworkMap._network.leftkey(
new_port.physicalnetwork))
except KeyError:
pass
else:
if phymap is not None:
phymap.ports.dataset().add(
value.create_weakreference())
write(phymap.getkey(), phymap)
try:
portset = walk(PhysicalPortSet.default_key())
except KeyError:
pass
else:
portset.set.dataset().add(value.create_weakreference())
write(portset.getkey(), portset)
def _walker(walk, write):
for p in new_ports:
key = p.getkey()
try:
value = walk(key)
except KeyError:
pass
else:
value = set_new(value, p)
try:
lognet = walk(value.logicalnetwork.getkey())
except KeyError:
pass
else:
if lognet is None:
_, (logid, ) = LogicalNetwork._getIndices(
value.logicalnetwork.getkey())
raise ValueError(
"Logical network %r does not exist" %
(logid, ))
try:
logmap = walk(
LogicalNetworkMap._network.leftkey(
value.logicalnetwork))
except KeyError:
pass
else:
if logmap is not None:
logmap.ports.dataset().add(
value.create_weakreference())
write(key, value)
write(logmap.getkey(), logmap)
try:
portset = walk(LogicalPortSet.default_key())
except KeyError:
pass
else:
portset.set.dataset().add(value.create_weakreference())
write(portset.getkey(), portset)
def createpyports(keys,values):
phynetlen = (len(keys) - 1 - len(portobjs))//2
phynetkeys = keys[1+len(portobjs):1+len(portobjs)+phynetlen]
phynetvalues = values[1+len(portobjs):1+len(portobjs)+phynetlen]
phynetmapkeys = keys[1+len(portobjs)+phynetlen:]
phynetmapvalues = values[1+len(portobjs)+phynetlen:]
phynetdict = dict(zip(phynetkeys,zip(phynetvalues,phynetmapvalues)))
for i in range(0,len(portobjs)):
values[i + 1] = set_new(values[i + 1],portobjs[i])
key = portobjs[i].physicalnetwork.getkey()
phynet,phymap = phynetdict.get(key)
if not phynet or not phymap:
raise ValueError("key object not existed "+ key)
phymap.ports.dataset().add(portobjs[i].create_weakreference())
values[0].set.dataset().add(portobjs[i].create_weakreference())
return keys[0:1+len(ports)] + phynetmapkeys,values[0:1+len(ports)] + phynetmapvalues
def addrouterinterface(keys, values):
rkeys = keys[0:len(routerkeys)]
robjs = values[0:len(routerkeys)]
snkeys = keys[len(routerkeys):len(routerkeys) + len(subnetkeys)]
snobjs = values[len(routerkeys):len(routerkeys) + len(subnetkeys)]
snmkeys = keys[len(routerkeys) + len(subnetkeys):len(routerkeys) +
len(subnetkeys) + len(subnetmapkeys)]
snmobjs = values[len(routerkeys) +
len(subnetkeys):len(routerkeys) +
len(subnetkeys) + len(subnetmapkeys)]
rpkeys = keys[len(routerkeys) + len(subnetkeys) +
len(subnetmapkeys):]
rpobjs = values[len(routerkeys) + len(subnetkeys) +
len(subnetmapkeys):]
rdict = dict(zip(rkeys, robjs))
sndict = dict(zip(snkeys, zip(snobjs, snmobjs)))
rpdict = dict(zip(rpkeys, rpobjs))
for i, interface in enumerate(newinterfaces):
routerport = interface['id']
router = interface['router']
subnet = interface['subnet']
routerobj = rdict.get(VRouter.default_key(router))
subnetobj, subnetmapobj = sndict.get(
SubNet.default_key(subnet))
newrouterport = newrouterportdict.get(
RouterPort.default_key(routerport))
routerport = rpdict.get(RouterPort.default_key(routerport))
if routerobj and subnetobj and subnetmapobj:
# now subnet only have one router ,,so check it
if not hasattr(subnetobj, 'router'):
# new router port special ip address , we check it in subnetmap
if hasattr(newrouterport, "ip_address"):
ipaddress = ip4_addr(newrouterport.ip_address)
n, p = parse_ip4_network(subnetobj.cidr)
if not ip_in_network(ipaddress, n, p):
raise ValueError(
" special ip address not in subnet cidr")
if str(ipaddress
) not in subnetmapobj.allocated_ips:
subnetmapobj.allocated_ips[str(
ipaddress
)] = newrouterport.create_weakreference()
else:
raise ValueError(
" ip address have used in subnet " +
newrouterport.ip_address)
else:
# not have special ip address, special gateway to this only router port
# gateway in subnet existed be sure
#
# when this case , special subnet gateway as ip_address
# but we do not set ip_address attr , when subnet gateway change ,
# we do not need to change router port attr
#setattr(newrouterport,"ip_address",subnetobj.gateway)
# it may be subnet not have gateway, checkout it
if not hasattr(subnetobj, "gateway"):
raise ValueError(
" interface not special ip_address and subnet has no gateway"
)
#routerport = set_new(routerport,newrouterport)
values[len(routerkeys) + len(subnetkeys) +
len(subnetmapkeys) + i] = set_new(
values[len(routerkeys) + len(subnetkeys) +
len(subnetmapkeys) + i],
routerportobjects[i])
subnetobj.router = newrouterport.create_weakreference()
routerobj.interfaces.dataset().add(
newrouterport.create_weakreference())
else:
raise ValueError(" subnet " + subnet +
" have router port " +
subnetobj.router.getkey())
else:
raise ValueError(" routerobj " + router + "or subnetobj " +
subnet + " not existed ")
return keys, values
def createlgnetworks(keys,values):
phynetlen = (len(keys) - len(networkmap)*2 - 1)//2
phynetkeys = keys[1 + len(networkmap)*2 : 1 + len(networkmap)*2 + phynetlen]
phynetvalues = values[1 + len(networkmap)*2 : 1 + len(networkmap)*2 + phynetlen]
phynetmapkeys = keys[1+len(networkmap)*2 + phynetlen:]
phynetmapvalues = values[1+len(networkmap)*2 + phynetlen:]
phynetmapdict = dict(zip(phynetkeys,zip(phynetvalues,phynetmapvalues)))
#
# have an problem , when [{...},{... vni is least or last+1}]
# first one will allocate least one vni,second will conflict
#
# so set new lgnet that have user defind 'vni' first
for i in range(0,len(networks)):
if hasattr(networkmap[i][0],'vni'):
vni = int(networkmap[i][0].vni)
networkmap[i][0].vni = vni
phynet,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
if not phynet or not phymap:
raise ValueError("physicalnetwork key object not existed "+\
networkmap[i][0].physicalnetwork.getkey())
if _isavaliablevni(phynet.vnirange,phymap.network_allocation.keys(),vni):
phymap.network_allocation[str(vni)] = networkmap[i][0].create_weakreference()
else:
raise ValueError("user defind vni has been used or out of range!")
# set lgnetwork
values[1+i] = set_new(values[i + 1],networkmap[i][0])
# set lgnetworkmap
values[1+i+len(networks)] = set_new(values[i + 1 + len(networks)],networkmap[i][1])
# set phynetmap
#_,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
phymap.logicnetworks.dataset().add(networkmap[i][0].create_weakreference())
values[0].set.dataset().add(networkmap[i][0].create_weakreference())
for i in range(0,len(networks)):
if not getattr(networkmap[i][0],'vni',None):
# there is no 'vni' in lgnetwork
# allocated one from vnirange
phynet,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
if not phynet or not phymap:
raise ValueError("physicalnetwork key object not existed "+\
networkmap[i][0].physicalnetwork.getkey())
vni = _findavaliablevni(phynet.vnirange,phymap.network_allocation.keys())
if not vni:
raise ValueError("there is no avaliable vni")
setattr(networkmap[i][0],'vni',vni)
phymap.network_allocation[str(vni)] = networkmap[i][0].create_weakreference()
# set lgnetwork
values[1+i] = set_new(values[i + 1],networkmap[i][0])
# set lgnetworkmap
values[1+i+len(networks)] = set_new(values[i + 1 + len(networks)],networkmap[i][1])
# set phynetmap
#_,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
phymap.logicnetworks.dataset().add(networkmap[i][0].create_weakreference())
values[0].set.dataset().add(networkmap[i][0].create_weakreference())
endpointsets = [VXLANEndpointSet.create_instance(nm[0].id) for nm in networkmap]
return (tuple(itertools.chain(keys[0:1], keys[1:1+len(networks)+len(networks)], phynetmapkeys,
(e.getkey() for e in endpointsets))),\
tuple(itertools.chain(values[0:1], values[1:1+len(networks)+len(networks)],
phynetmapvalues, endpointsets)))
def _updater(dockerinfo):
dockerinfo = set_new(dockerinfo, info)
return (dockerinfo, )
def createlgnetworks(keys,values):
phynetlen = (len(keys) - len(networkmap)*2 - 1)//2
phynetkeys = keys[1 + len(networkmap)*2 : 1 + len(networkmap)*2 + phynetlen]
phynetvalues = values[1 + len(networkmap)*2 : 1 + len(networkmap)*2 + phynetlen]
phynetmapkeys = keys[1+len(networkmap)*2 + phynetlen:]
phynetmapvalues = values[1+len(networkmap)*2 + phynetlen:]
phynetmapdict = dict(zip(phynetkeys,zip(phynetvalues,phynetmapvalues)))
#
# have an problem , when [{...},{... vlanid is least or last+1}]
# first one will allocate least one vlanid,second will conflict
#
# so set new lgnet that have user defind 'vlanid' first
for i in range(0,len(networks)):
if hasattr(networkmap[i][0],'vlanid'):
vlanid = int(networkmap[i][0].vlanid)
networkmap[i][0].vlanid = vlanid
phynet,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
if not phynet or not phymap:
raise ValueError("physicalnetwork key object not existed "+\
networkmap[i][0].physicalnetwork.getkey())
if _isavaliablevlanid(phynet.vlanrange,phymap.network_allocation.keys(),vlanid):
phymap.network_allocation[str(vlanid)] = networkmap[i][0].create_weakreference()
else:
raise ValueError("user defind vlan id has been used or out of range!")
# set lgnetwork
values[1+i] = set_new(values[i + 1],networkmap[i][0])
# set lgnetworkmap
values[1+i+len(networks)] = set_new(values[i + 1 + len(networks)],networkmap[i][1])
# set phynetmap
#_,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
phymap.logicnetworks.dataset().add(networkmap[i][0].create_weakreference())
values[0].set.dataset().add(networkmap[i][0].create_weakreference())
for i in range(0,len(networks)):
if not getattr(networkmap[i][0],'vlanid',None):
# there is no 'vlanid' in lgnetwork
# allocated one from vlanrange
phynet,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
if not phynet or not phymap:
raise ValueError("physicalnetwork key object not existed "+\
networkmap[i][0].physicalnetwork.getkey())
vlanid = _findavaliablevlanid(phynet.vlanrange,phymap.network_allocation.keys())
if not vlanid:
raise ValueError("there is no avaliable vlan id")
setattr(networkmap[i][0],'vlanid',vlanid)
phymap.network_allocation[str(vlanid)] = networkmap[i][0].create_weakreference()
# set lgnetwork
values[1+i] = set_new(values[i + 1],networkmap[i][0])
# set lgnetworkmap
values[1+i+len(networks)] = set_new(values[i + 1 + len(networks)],networkmap[i][1])
# set phynetmap
#_,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
phymap.logicnetworks.dataset().add(networkmap[i][0].create_weakreference())
values[0].set.dataset().add(networkmap[i][0].create_weakreference())
return keys[0:1] + keys[1:1+len(networks)+len(networks)]+phynetmapkeys,\
values[0:1]+values[1:1+len(networks)+len(networks)] + phynetmapvalues
def create_phy(physet, phynet, phymap):
phynet = set_new(phynet, new_network)
phymap = set_new(phymap, new_map)
physet.set.dataset().add(phynet.create_weakreference())
return [physet, phynet, phymap]
def createlgnetworks(keys, values):
phynetlen = (len(keys) - len(networkmap) * 2 - 1) // 2
phynetkeys = keys[1 + len(networkmap) * 2:1 + len(networkmap) * 2 +
phynetlen]
phynetvalues = values[1 + len(networkmap) * 2:1 +
len(networkmap) * 2 + phynetlen]
phynetmapkeys = keys[1 + len(networkmap) * 2 + phynetlen:]
phynetmapvalues = values[1 + len(networkmap) * 2 + phynetlen:]
phynetmapdict = dict(
zip(phynetkeys, zip(phynetvalues, phynetmapvalues)))
#
# have an problem , when [{...},{... vni is least or last+1}]
# first one will allocate least one vni,second will conflict
#
# so set new lgnet that have user defind 'vni' first
for i in range(0, len(networks)):
if hasattr(networkmap[i][0], 'vni'):
vni = int(networkmap[i][0].vni)
networkmap[i][0].vni = vni
phynet, phymap = phynetmapdict.get(
networkmap[i][0].physicalnetwork.getkey())
if not phynet or not phymap:
raise ValueError("physicalnetwork key object not existed "+\
networkmap[i][0].physicalnetwork.getkey())
if _isavaliablevni(phynet.vnirange,
phymap.network_allocation.keys(), vni):
phymap.network_allocation[str(
vni)] = networkmap[i][0].create_weakreference()
else:
raise ValueError(
"user defind vni has been used or out of range!")
# set lgnetwork
values[1 + i] = set_new(values[i + 1], networkmap[i][0])
# set lgnetworkmap
values[1 + i + len(networks)] = set_new(
values[i + 1 + len(networks)], networkmap[i][1])
# set phynetmap
#_,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
phymap.logicnetworks.dataset().add(
networkmap[i][0].create_weakreference())
values[0].set.dataset().add(
networkmap[i][0].create_weakreference())
for i in range(0, len(networks)):
if not getattr(networkmap[i][0], 'vni', None):
# there is no 'vni' in lgnetwork
# allocated one from vnirange
phynet, phymap = phynetmapdict.get(
networkmap[i][0].physicalnetwork.getkey())
if not phynet or not phymap:
raise ValueError("physicalnetwork key object not existed "+\
networkmap[i][0].physicalnetwork.getkey())
vni = _findavaliablevni(phynet.vnirange,
phymap.network_allocation.keys())
if not vni:
raise ValueError("there is no avaliable vni")
setattr(networkmap[i][0], 'vni', vni)
phymap.network_allocation[str(
vni)] = networkmap[i][0].create_weakreference()
# set lgnetwork
values[1 + i] = set_new(values[i + 1], networkmap[i][0])
# set lgnetworkmap
values[1 + i + len(networks)] = set_new(
values[i + 1 + len(networks)], networkmap[i][1])
# set phynetmap
#_,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
phymap.logicnetworks.dataset().add(
networkmap[i][0].create_weakreference())
values[0].set.dataset().add(
networkmap[i][0].create_weakreference())
endpointsets = [
VXLANEndpointSet.create_instance(nm[0].id) for nm in networkmap
]
return (tuple(itertools.chain(keys[0:1], keys[1:1+len(networks)+len(networks)], phynetmapkeys,
(e.getkey() for e in endpointsets))),\
tuple(itertools.chain(values[0:1], values[1:1+len(networks)+len(networks)],
phynetmapvalues, endpointsets)))
def createlgnetworks(keys, values):
phynetlen = (len(keys) - len(networkmap) * 2 - 1) // 2
phynetkeys = keys[1 + len(networkmap) * 2:1 + len(networkmap) * 2 +
phynetlen]
phynetvalues = values[1 + len(networkmap) * 2:1 +
len(networkmap) * 2 + phynetlen]
phynetmapkeys = keys[1 + len(networkmap) * 2 + phynetlen:]
phynetmapvalues = values[1 + len(networkmap) * 2 + phynetlen:]
phynetmapdict = dict(
zip(phynetkeys, zip(phynetvalues, phynetmapvalues)))
"""
#
# have an problem , when [{...},{... sid is least or last+1}]
# first one will allocate least one vlanid,second will conflict
#
# so set new lgnet that have user defind 'vlanid' first
for i in range(0,len(networks)):
if hasattr(networkmap[i][0],'sid'):
sid = int(networkmap[i][0].sid)
networkmap[i][0].sid = sid
phynet,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
if not phynet or not phymap:
raise ValueError("physicalnetwork key object not existed "+\
networkmap[i][0].physicalnetwork.getkey())
if _isavaliablesid(phymap.network_allocation.keys(),sid):
phymap.network_allocation[str(sid)] = networkmap[i][0].create_weakreference()
else:
raise ValueError("user defind sid has been used or out of range!" + sid)
# set lgnetwork
values[1+i] = set_new(values[i + 1],networkmap[i][0])
# set lgnetworkmap
values[1+i+len(networks)] = set_new(values[i + 1 + len(networks)],networkmap[i][1])
# set phynetmap
#_,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
phymap.logicnetworks.dataset().add(networkmap[i][0].create_weakreference())
values[0].set.dataset().add(networkmap[i][0].create_weakreference())
for i in range(0,len(networks)):
if not getattr(networkmap[i][0],'sid',None):
# there is no 'sid' in lgnetwork
# allocate it max in allocate + 1
phynet,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
if not phynet or not phymap:
raise ValueError("physicalnetwork key object not existed "+\
networkmap[i][0].physicalnetwork.getkey())
sid = _findavaliablesid(phymap.network_allocation.keys())
if not sid:
raise ValueError("there is no avaliable sid")
setattr(networkmap[i][0],'sid',sid)
phymap.network_allocation[str(sid)] = networkmap[i][0].create_weakreference()
# set lgnetwork
values[1+i] = set_new(values[i + 1],networkmap[i][0])
# set lgnetworkmap
values[1+i+len(networks)] = set_new(values[i + 1 + len(networks)],networkmap[i][1])
# set phynetmap
#_,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
phymap.logicnetworks.dataset().add(networkmap[i][0].create_weakreference())
values[0].set.dataset().add(networkmap[i][0].create_weakreference())
"""
for i in range(0, len(networks)):
phynet, phymap = phynetmapdict.get(
networkmap[i][0].physicalnetwork.getkey())
if not phynet or not phymap:
raise ValueError("physicalnetwork key object not existed "+\
networkmap[i][0].physicalnetwork.getkey())
# set lgnetwork
values[1 + i] = set_new(values[i + 1], networkmap[i][0])
# set lgnetworkmap
values[1 + i + len(networks)] = set_new(
values[i + 1 + len(networks)], networkmap[i][1])
# set phynetmap
#_,phymap = phynetmapdict.get(networkmap[i][0].physicalnetwork.getkey())
phymap.logicnetworks.dataset().add(
networkmap[i][0].create_weakreference())
values[0].set.dataset().add(
networkmap[i][0].create_weakreference())
return keys[0:1] + keys[1:1+len(networks)+len(networks)]+phynetmapkeys,\
values[0:1]+values[1:1+len(networks)+len(networks)] + phynetmapvalues
def create_phy(physet, phynet, phymap):
phynet = set_new(phynet, new_network)
phymap = set_new(phymap, new_map)
physet.set.dataset().add(phynet.create_weakreference())
return [physet, phynet, phymap]
