def CreateInternetTunnels(self):
objs = EzAccessStoreClient[self.Node].GetIgwNonNatTunnels()
if len(objs) != 0:
self.RemoteInternetNonNatTunAllocator = utils.rrobiniter(objs)
objs = EzAccessStoreClient[self.Node].GetIgwNatTunnels()
if len(objs) != 0:
self.RemoteInternetNatTunAllocator = utils.rrobiniter(objs)
def CreateUnderlayTunnels(self):
objs = EzAccessStoreClient[self.Node].GetUnderlayTunnels()
if len(objs) != 0:
self.UnderlayTunAllocator = utils.rrobiniter(objs)
objs = EzAccessStoreClient[self.Node].GetUnderlayTunnels(ecmp=True)
if len(objs) != 0:
self.UnderlayECMPTunAllocator = utils.rrobiniter(objs)
def GenerateObjects(self, node, parent, vpc_spec_obj):
if not self.__supported:
return
vpcid = parent.VPCId
isV4Stack = utils.IsV4Stack(parent.Stack)
isV6Stack = utils.IsV6Stack(parent.Stack)
self.__v4objs[node][vpcid] = []
self.__v6objs[node][vpcid] = []
self.__v4iter[node][vpcid] = None
self.__v6iter[node][vpcid] = None
nhg_spec = getattr(vpc_spec_obj, 'nexthop-group', None)
if nhg_spec == None:
self.__num_nhgs_per_vpc.append(0)
return
for nhg_spec_obj in nhg_spec:
for c in range(nhg_spec_obj.count):
obj = NexthopGroupObject(node, parent, nhg_spec_obj)
self.Objs[node].update({obj.Id: obj})
if isV4Stack:
self.__v4objs[node][vpcid].append(obj)
if isV6Stack:
self.__v6objs[node][vpcid].append(obj)
if len(self.__v4objs[node][vpcid]):
self.__v4iter[node][vpcid] = utils.rrobiniter(
self.__v4objs[node][vpcid])
if len(self.__v6objs[node][vpcid]):
self.__v6iter[node][vpcid] = utils.rrobiniter(
self.__v6objs[node][vpcid])
self.__num_nhgs_per_vpc.append(nhg_spec_obj.count)
return
def CollectSvcTunnels(self):
if utils.IsPipelineArtemis():
objs = EzAccessStoreClient[self.Node].GetSvcTunnels()
if len(objs) != 0:
self.SvcTunAllocator = utils.rrobiniter(objs)
objs = EzAccessStoreClient[self.Node].GetSvcTunnels(True)
if len(objs) != 0:
self.RemoteSvcTunAllocator = utils.rrobiniter(objs)
def __generate_l3_uplink_interfaces(self, node, parent, iflist):
uplink_ports = PortClient.Objects()
if not uplink_ports:
return
for port in uplink_ports:
spec = InterfaceSpec_()
spec.vpcid = parent.VPCId
spec.port = port.Port - 1
spec.ethifidx = topo.PortToEthIfIdx(port.Port)
spec.ifname = 'Uplink%d' % spec.port
spec.ifadminstatus = port.AdminState
for ifspec in iflist:
if ifspec.iftype != 'l3':
continue
if ifspec.portid == port.Port:
spec = utils.CopySpec(spec, ifspec)
if not hasattr(ifspec, 'macaddress'):
spec.macaddress = ResmgrClient[
node].DeviceMacAllocator.get()
ifobj = L3InterfaceObject(node, spec)
self.Objs[node].update({ifobj.InterfaceId: ifobj})
self.__uplinkl3ifs[node].update({ifobj.InterfaceId: ifobj})
if self.__uplinkl3ifs[node]:
self.__uplinkl3ifs_iter[node] = utils.rrobiniter(
self.__uplinkl3ifs[node].values())
return
def GenerateObjects(self, node, parent, vpc_spec_obj):
if not self.__supported:
return
def __isNhFeatureSupported(nh_type):
if nh_type == 'underlay' or nh_type == 'overlay':
return utils.IsPipelineApulu()
return not utils.IsPipelineApulu()
vpcid = parent.VPCId
isV4Stack = utils.IsV4Stack(parent.Stack)
isV6Stack = utils.IsV6Stack(parent.Stack)
self.__v4objs[node][vpcid] = []
self.__v6objs[node][vpcid] = []
self.__v4iter[node][vpcid] = None
self.__v6iter[node][vpcid] = None
if getattr(vpc_spec_obj, 'nexthop', None) == None:
self.__num_nh_per_vpc.append(0)
return
for nh_spec_obj in vpc_spec_obj.nexthop:
nh_type = getattr(nh_spec_obj, 'type', 'ip')
if not __isNhFeatureSupported(nh_type):
continue
for c in range(nh_spec_obj.count):
obj = NexthopObject(node, parent, nh_spec_obj)
self.Objs[node].update({obj.NexthopId: obj})
if nh_type == "underlay":
self.__underlay_objs[node].update({obj.NexthopId: obj})
if isV4Stack:
self.__v4objs[node][vpcid].append(obj)
if isV6Stack:
self.__v6objs[node][vpcid].append(obj)
if len(self.__v4objs[node][vpcid]):
self.__v4iter[node][vpcid] = utils.rrobiniter(
self.__v4objs[node][vpcid])
if len(self.__v6objs[node][vpcid]):
self.__v6iter[node][vpcid] = utils.rrobiniter(
self.__v6objs[node][vpcid])
self.__num_nh_per_vpc.append(nh_spec_obj.count)
return
def GenerateObjects(self, node, topospecobj):
if not hasattr(topospecobj, 'policer'):
return
if utils.IsReconfigInProgress(node):
return
rxpol = []
txpol = []
for policer_spec_obj in topospecobj.policer:
obj = PolicerObject(node, policer_spec_obj)
self.Objs[node].update({obj.PolicerId: obj})
if (policer_spec_obj.direction == 'ingress'):
rxpol.append(obj)
self.rxpolicercount += 1
else:
txpol.append(obj)
self.txpolicercount += 1
if len(rxpol):
self.rxpoliceriter[node] = utils.rrobiniter(rxpol)
if len(txpol):
self.txpoliceriter[node] = utils.rrobiniter(txpol)
return
def __generate_host_interfaces_iota(self, node, topospec):
cmd_op = self.ReadLifs(node)
if utils.IsDryRun():
return
for lif in cmd_op:
lif_yaml = utils.LoadYaml(lif)
if not lif_yaml:
continue
lif_spec = lif_yaml['spec']
lif_status = lif_yaml['status']
intf_type = lif_spec['type']
spec = InterfaceSpec_()
spec.iid = utils.LifIfIndex2HostIfIndex(lif_status['ifindex'])
node_mac = 0
for x in lif_spec['id'][-6:]:
node_mac = ((node_mac << 8) | x)
spec.uuid = utils.PdsUuid(spec.iid, node_uuid=node_mac)
spec.ifname = lif_status['name']
spec.macaddress = objects.MacAddressBase(
integer=lif_spec['macaddress'])
spec.origin = 'implicitly-created'
spec.txpolicer = False
if hasattr(topospec, 'hostinterface'):
if getattr(topospec.hostinterface, 'txpolicer', False) == True:
spec.txpolicer = True
if intf_type == types_pb2.LIF_TYPE_INBAND_MGMT:
inb_mgmtif = InbandMgmtInterfaceObject(node, spec)
self.__inband_mgmt_ifs[node].update(
{inb_mgmtif.GetInterfaceName(): inb_mgmtif})
elif intf_type == types_pb2.LIF_TYPE_HOST:
hostif = HostInterfaceObject(node, spec)
self.__hostifs[node].update({hostif.InterfaceId: hostif})
if self.__hostifs[node]:
self.__hostifs_iter[node] = utils.rrobiniter(
sorted(self.__hostifs[node].keys()))
return
def __generate_host_interfaces_dol(self, node, ifspec):
if not ifspec:
return
spec = InterfaceSpec_()
spec.ifadminstatus = 'UP'
spec.lifspec = ifspec.lif.Get(EzAccessStoreClient[node])
spec.txpolicer = False
for obj in ResmgrClient[node].HostIfs.values():
spec = utils.CopySpec(spec, ifspec)
spec.ifname = obj.IfName
spec.lifinfo = obj
lifstart = obj.LifBase
lifend = lifstart + obj.LifCount - 1
spec.lifns = objects.TemplateFieldObject("range/%d/%d" %
(lifstart, lifend))
spec = utils.CopySpec(spec, ifspec)
hostif_obj = HostInterfaceObject(node, spec)
self.__hostifs[node].update({hostif_obj.InterfaceId: hostif_obj})
if self.__hostifs[node]:
self.__hostifs_iter[node] = utils.rrobiniter(
self.__hostifs[node].values())
return
def CreateIpsecDecryptSAAllocator(self):
objs = EzAccessStoreClient[self.Node].GetIpsecDecryptSAs()
if len(objs) != 0:
self.IpsecDecryptSAAllocator = utils.rrobiniter(objs)
def CreateIpsecTransportModeTunnels(self):
objs = EzAccessStoreClient[self.Node].GetIpsecTransportModeTunnels()
if len(objs) != 0:
self.IpsecTransportModeTunAllocator = utils.rrobiniter(objs)
def CreateDHCPProxyAllocator(self):
objs = EzAccessStoreClient[self.Node].GetDhcpProxyObjects()
if len(objs) != 0:
self.DhcpProxyAllocator = utils.rrobiniter(objs)
def CreateDualEcmpNhGroupAllocator(self):
objs = EzAccessStoreClient[self.Node].GetDualEcmpNhGroups()
if len(objs) != 0:
self.DualEcmpNhGroupAllocator = utils.rrobiniter(objs)
def CreateOverlayNhGroupAllocator(self):
objs = EzAccessStoreClient[self.Node].GetOverlayNhGroups()
if len(objs) != 0:
self.OverlayNhGroupAllocator = utils.rrobiniter(objs)
def CreateUnderlayNHAllocator(self):
objs = EzAccessStoreClient[self.Node].GetUnderlayNexthops()
if len(objs) != 0:
self.UnderlayNHAllocator = utils.rrobiniter(objs)
def GenerateObjects(self, node, parent, vpc_spec_obj):
vpcpeerid = parent.GetVPCPeerId()
if not self.__supported:
return
vpcid = parent.VPCId
isV4Stack = utils.IsV4Stack(parent.Stack)
isV6Stack = utils.IsV6Stack(parent.Stack) and self.__v6supported
self.__v4objs[node][vpcid] = dict()
self.__v6objs[node][vpcid] = dict()
self.__v4iter[node][vpcid] = None
self.__v6iter[node][vpcid] = None
if utils.IsNatSupported():
if ResmgrClient[node].RemoteInternetNonNatTunAllocator == None and \
ResmgrClient[node].RemoteInternetNatTunAllocator == None:
logger.info(
"Skipping route creation as there are no Internet tunnels")
return
def __get_adjacent_routes(base, count):
routes = OrderedDict()
ipaddr = ipaddress.ip_network(base)
af = ipaddr.version
spec = routetbl_spec_obj
priority = topo.DEFAULT_ROUTE_PRIORITY
priorityType = getattr(spec, "priority", None)
if priorityType:
priority = __get_priority(priorityType, True)
nh_type, nh_id, nhgid, vpcid, tunnelid, nat_type, service_nat_prefix, \
dnat_ip, classpriority, meteren = __get_route_attribs(spec, af)
obj = RouteObject(node, ipaddr, priority, nh_type, nh_id, nhgid, \
vpcid, tunnelid, nat_type, service_nat_prefix, \
dnat_ip, classpriority, meteren)
routes.update({obj.Id: obj})
c = 1
while c < count:
ipaddr = utils.GetNextSubnet(ipaddr)
if priorityType:
priority = __get_priority(priorityType, False, priority)
nh_type, nh_id, nhgid, vpcid, tunnelid, nat_type, service_nat_prefix, \
dnat_ip, classpriority, meteren = __get_route_attribs(spec, af)
obj = RouteObject(node, ipaddr, priority, nh_type, nh_id, \
nhgid, vpcid, tunnelid, nat_type, \
service_nat_prefix, dnat_ip, classpriority, \
meteren)
routes.update({obj.Id: obj})
c += 1
return routes
def __get_overlap(basepfx, base, count):
# for overlap, add user specified base prefix with original prefixlen
routes = __get_user_specified_routes([basepfx])
routes = utils.MergeDicts(routes,
__get_adjacent_routes(base, count))
return routes
def __get_first_subnet(ip, prefixlen):
for ip in ip.subnets(new_prefix=prefixlen):
return (ip)
return
def __add_v4routetable(v4routes, spec):
obj = RouteTableObject(node, parent, utils.IP_VERSION_4, v4routes,
spec.routetype, tunobj, vpcpeerid, spec)
self.__v4objs[node][vpcid].update({obj.RouteTblId: obj})
self.Objs[node].update({obj.RouteTblId: obj})
def __add_v6routetable(v6routes, spec):
obj = RouteTableObject(node, parent, utils.IP_VERSION_6, v6routes,
spec.routetype, tunobj, vpcpeerid, spec)
self.__v6objs[node][vpcid].update({obj.RouteTblId: obj})
self.Objs[node].update({obj.RouteTblId: obj})
def __derive_nh_type_info(spec):
routetype = spec.routetype
if 'vpc_peer' in routetype:
return 'vpcpeer'
elif 'blackhole' in routetype:
return 'blackhole'
elif utils.IsPipelineArtemis():
# handle service tunnel case, return tep
return "nh"
elif utils.IsPipelineApulu():
if 'overlay-ecmp' in spec.teptype:
return "nhg"
else:
return "tep"
else:
return "tep"
def __internet_tunnel_get(nat, teptype=None):
if teptype is not None:
if "service" in teptype:
if "remoteservice" == teptype:
return ResmgrClient[node].RemoteSvcTunAllocator.rrnext(
)
return ResmgrClient[node].SvcTunAllocator.rrnext()
if "underlay" in teptype:
if "underlay-ecmp" == teptype:
return ResmgrClient[
node].UnderlayECMPTunAllocator.rrnext()
return ResmgrClient[node].UnderlayTunAllocator.rrnext()
if "overlay-ecmp" in teptype:
# Fill NhGroup later
return None
if nat is False:
return ResmgrClient[
node].RemoteInternetNonNatTunAllocator.rrnext()
else:
return ResmgrClient[node].RemoteInternetNatTunAllocator.rrnext(
)
def __get_tunnel(spec):
routetype = spec.routetype
nat, teptype = __get_nat_teptype_from_spec(spec)
tunobj = __internet_tunnel_get(nat, teptype)
return tunobj
def __get_nexthop(af):
nh = None
if af == utils.IP_VERSION_4:
nh = NexthopClient.GetV4Nexthop(node, parent.VPCId)
else:
nh = NexthopClient.GetV6Nexthop(node, parent.VPCId)
return nh
def __get_route_attribs(spec, af=utils.IP_VERSION_4):
nhid = 0
nhgid = 0
vpcid = 0
tunnelid = 0
nat_type = None
service_nat_prefix = getattr(spec, 'servicenatprefix', None)
classpriority = getattr(spec, 'classpriority', 0)
meteren = getattr(spec, 'meteren', False)
dnat_ip = getattr(spec, 'dnatip', None)
natspec = getattr(spec, 'nat', None)
if natspec:
nat_type = getattr(natspec, 'type', None)
nat_level = getattr(natspec, 'level', None)
nh_type = __derive_nh_type_info(spec)
if nh_type == "vpcpeer":
vpcid = vpcpeerid
elif nh_type == "tep":
tunobj = __get_tunnel(spec)
if utils.IsPipelineArtemis() and tunobj.IsSvc():
# service tunnel case
nh_type = "nh"
nexthop = __get_nexthop(af)
nh_id = nexthop.NexthopId
else:
tunnelid = tunobj.Id
elif nh_type == "nh":
nexthop = __get_nexthop(af)
if nexthop:
nhid = nexthop.NexthopId
elif nh_type == "nhg":
nhgid = 1 # fill later
return nh_type, nhid, nhgid, vpcid, tunnelid, nat_type, \
service_nat_prefix, dnat_ip, classpriority, meteren
def __get_priority(priotype, firstVal=False, priority=0):
if priotype == "increasing":
if firstVal: return topo.MIN_ROUTE_PRIORITY
return (priority - 1)
elif priotype == "decreasing":
if firstVal: return topo.MAX_ROUTE_PRIORITY
return (priority + 1)
elif priotype == "random":
return (random.randint(topo.MAX_ROUTE_PRIORITY,
topo.MIN_ROUTE_PRIORITY))
else:
logger.error("Unknown priority type", priotype)
return (random.randint(topo.MAX_ROUTE_PRIORITY,
topo.MIN_ROUTE_PRIORITY))
def __get_user_specified_routes(routespec):
routes = OrderedDict()
spec = routetbl_spec_obj
priorityType = getattr(spec, "priority", None)
priority = topo.DEFAULT_ROUTE_PRIORITY
if priorityType:
priority = __get_priority(spec.priority, True)
if routespec:
for route in routespec:
if priorityType:
priority = __get_priority(spec.priority, False,
priority)
nh_type, nh_id, nhgid, vpcid, tunnelid, nat_type, \
service_nat_prefix, dnat_ip, classpriority, \
meteren = __get_route_attribs(spec)
obj = RouteObject(node, ipaddress.ip_network(route.replace('\\', '/')),\
priority, nh_type, nh_id, nhgid, vpcid, tunnelid,\
nat_type, service_nat_prefix, dnat_ip,\
classpriority, meteren)
routes.update({obj.Id: obj})
return routes
def __add_user_specified_routetable(spec):
if isV4Stack:
__add_v4routetable(__get_user_specified_routes(spec.v4routes),
spec)
if isV6Stack:
__add_v6routetable(__get_user_specified_routes(spec.v6routes),
spec)
def __get_valid_route_count_per_route_table(count):
if count > Resmgr.MAX_ROUTES_PER_ROUTE_TBL:
return Resmgr.MAX_ROUTES_PER_ROUTE_TBL
return count
def __get_nat_teptype_from_spec(routetbl_spec_obj):
nat = False
natSpec = getattr(routetbl_spec_obj, 'nat', None)
if natSpec:
level = getattr(natSpec, 'level')
if level == 'tunnel' and not utils.IsPipelineApulu():
nat = True
teptype = getattr(routetbl_spec_obj, 'teptype', None)
return nat, teptype
for routetbl_spec_obj in vpc_spec_obj.routetbl:
if utils.IsReconfigInProgress(node):
id = getattr(routetbl_spec_obj, 'id', None)
if id:
obj = self.GetRouteTableObject(node, id)
if obj:
obj.ObjUpdate(routetbl_spec_obj)
else:
for obj in list(self.Objs[node].values()):
obj.ObjUpdate(routetbl_spec_obj)
continue
routetbltype = routetbl_spec_obj.type
routetype = routetbl_spec_obj.routetype
nat, teptype = __get_nat_teptype_from_spec(routetbl_spec_obj)
tunobj = __internet_tunnel_get(nat, teptype)
if routetbltype == "specific":
__add_user_specified_routetable(routetbl_spec_obj)
continue
routetablecount = routetbl_spec_obj.count
v4routecount = __get_valid_route_count_per_route_table(
routetbl_spec_obj.nv4routes)
v6routecount = __get_valid_route_count_per_route_table(
routetbl_spec_obj.nv6routes)
v4prefixlen = routetbl_spec_obj.v4prefixlen
v6prefixlen = routetbl_spec_obj.v6prefixlen
v4base = __get_first_subnet(
ipaddress.ip_network(
routetbl_spec_obj.v4base.replace('\\', '/')), v4prefixlen)
v6base = __get_first_subnet(
ipaddress.ip_network(
routetbl_spec_obj.v6base.replace('\\', '/')), v6prefixlen)
# get user specified routes if any for 'base' routetbltype
user_specified_v4routes = __get_user_specified_routes(
routetbl_spec_obj.v4routes)
user_specified_v6routes = __get_user_specified_routes(
routetbl_spec_obj.v6routes)
v4routecount -= len(user_specified_v4routes)
v6routecount -= len(user_specified_v6routes)
if 'overlap' in routetype:
v4routecount -= 1
v6routecount -= 1
for i in range(routetablecount):
if 'adjacent' in routetype:
if isV4Stack:
routes = utils.MergeDicts(user_specified_v4routes, \
__get_adjacent_routes(v4base, v4routecount-1))
__add_v4routetable(routes, routetbl_spec_obj)
v4base = utils.GetNextSubnet(
routes.get(list(routes)[-1]).ipaddr)
if isV6Stack:
routes = utils.MergeDicts(user_specified_v6routes, \
__get_adjacent_routes(v6base, v6routecount-1))
__add_v6routetable(routes, routetbl_spec_obj)
v6base = utils.GetNextSubnet(
routes.get(list(routes)[-1]).ipaddr)
elif 'overlap' in routetype:
if isV4Stack:
routes = utils.MergeDicts(user_specified_v4routes, \
__get_overlap(routetbl_spec_obj.v4base, v4base, v4routecount))
__add_v4routetable(routes, routetbl_spec_obj)
v4base = utils.GetNextSubnet(
routes.get(list(routes)[-1]).ipaddr)
if isV6Stack:
routes = utils.MergeDicts(user_specified_v6routes, \
__get_overlap(routetbl_spec_obj.v6base, v6base, v6routecount))
__add_v6routetable(routes, routetbl_spec_obj)
v6base = utils.GetNextSubnet(
routes.get(list(routes)[-1]).ipaddr)
if self.__v6objs[node][vpcid]:
self.__v6iter[node][vpcid] = utils.rrobiniter(
self.__v6objs[node][vpcid].values())
if self.__v4objs[node][vpcid]:
self.__v4iter[node][vpcid] = utils.rrobiniter(
self.__v4objs[node][vpcid].values())
def CreateVnicTunnels(self):
objs = EzAccessStoreClient[self.Node].GetWorkloadTunnels()
if len(objs) != 0:
self.RemoteMplsVnicTunAllocator = utils.rrobiniter(objs)
def GenerateObjects(self, node, parent, vpcspecobj):
vpcid = parent.VPCId
isV4Stack = utils.IsV4Stack(parent.Stack)
isV6Stack = utils.IsV6Stack(parent.Stack)
self.__v4objs[node][vpcid] = []
self.__v6objs[node][vpcid] = []
self.__v4iter[node][vpcid] = None
self.__v6iter[node][vpcid] = None
if getattr(vpcspecobj, 'meter', None) == None:
self.__num_v4_meter_per_vpc.append(0)
self.__num_v6_meter_per_vpc.append(0)
return
if not utils.IsMeteringSupported():
return
def __add_specific_meter_prefixes(rulespec, af):
prefixes = []
if af == utils.IP_VERSION_4:
for r in rulespec.v4prefixes:
base = ipaddress.ip_network(r.replace('\\', '/'))
prefix = ipaddress.ip_network(base)
prefixes.append(prefix)
else:
for r in rulespec.v6prefixes:
base = ipaddress.ip_network(r.replace('\\', '/'))
prefix = ipaddress.ip_network(base)
prefixes.append(prefix)
return prefixes
def __add_meter_rules(rule_spec, af, metercount):
rules = []
for rulespec in rule_spec:
prefixes = []
if af == utils.IP_VERSION_4:
pfx = ipaddress.ip_network(rulespec.v4base.replace('\\', '/'))
else:
pfx = ipaddress.ip_network(rulespec.v6base.replace('\\', '/'))
totalhosts = ipaddress.ip_network(pfx).num_addresses * (metercount * rulespec.num_prefixes)
new_pfx = str(pfx.network_address + totalhosts) + '/' + str(pfx.prefixlen)
prefix = ipaddress.ip_network(new_pfx)
prefixes.append(prefix)
c = 1
while c < rulespec.num_prefixes:
pfx = utils.GetNextSubnet(prefix)
prefix = ipaddress.ip_network(pfx)
prefixes.append(prefix)
c += 1
prefixes.extend(__add_specific_meter_prefixes(rulespec, af))
obj = MeterRuleObject(rulespec.type, rulespec.priority, prefixes)
rules.append(obj)
return rules
def __add_meter_rules_from_routetable(meterspec, af):
base_priority = meterspec.base_priority
rule_type = meterspec.rule_type
rules = []
if af == utils.IP_VERSION_4:
total_rt = route.client.GetRouteV4Tables(node, vpcid)
else:
total_rt = route.client.GetRouteV6Tables(node, vpcid)
if total_rt != None:
for rt_id, rt_obj in total_rt.items():
if rt_obj.RouteType != 'overlap':
# one rule for all routes in one route table
pfxs = list(rt_obj.routes.values())
prefixes = []
for pfx in pfxs:
prefixes.append(pfx.ipaddr)
ruleobj = MeterRuleObject(rule_type, base_priority, prefixes)
base_priority += 1
rules.append(ruleobj)
return rules
for meter in vpcspecobj.meter:
c = 0
v4_count = 0
v6_count = 0
if meter.auto_fill:
if isV4Stack:
rules = __add_meter_rules_from_routetable(meter, utils.IP_VERSION_4)
obj = MeterObject(node, parent, utils.IP_VERSION_4, rules)
self.__v4objs[node][vpcid].append(obj)
self.Objs[node].update({obj.MeterId: obj})
v4_count += len(rules)
if isV6Stack:
rules = __add_meter_rules_from_routetable(meter, utils.IP_VERSION_6)
obj = MeterObject(node, parent, utils.IP_VERSION_6, rules)
self.__v6objs[node][vpcid].append(obj)
self.Objs[node].update({obj.MeterId: obj})
v6_count += len(rules)
else:
while c < meter.count:
if isV4Stack:
rules = __add_meter_rules(meter.rule, utils.IP_VERSION_4, c)
obj = MeterObject(node, parent, utils.IP_VERSION_4, rules)
self.__v4objs[node][vpcid].append(obj)
self.Objs[node].update({obj.MeterId: obj})
v4_count += len(rules)
if isV6Stack:
rules = __add_meter_rules(meter.rule, utils.IP_VERSION_6, c)
obj = MeterObject(node, parent, utils.IP_VERSION_6, rules)
self.__v6objs[node][vpcid].append(obj)
self.Objs[node].update({obj.MeterId: obj})
v6_count += len(rules)
c += 1
if len(self.__v4objs[node][vpcid]):
self.__v4iter[node][vpcid] = utils.rrobiniter(self.__v4objs[node][vpcid])
if len(self.__v6objs[node][vpcid]):
self.__v6iter[node][vpcid] = utils.rrobiniter(self.__v6objs[node][vpcid])
self.__num_v4_meter_per_vpc.append(v4_count)
self.__num_v6_meter_per_vpc.append(v6_count)
return
def __init__(self, node):
super().__init__()
self.Node = node
self.EpochAllocator = iter(irange(1, 4096))
# tunnel id=1 is mytep
self.TunnelIdAllocator = iter(irange(2, 4096))
self.VpcIdAllocator = iter(irange(1, 1024))
self.SubnetIdAllocator = iter(irange(1, 1024))
self.FlowIdAllocator = iter(irange(1, 1 * 1024 * 1024))
self.VnicVlanIdAllocator = iter(irange(1, 1024))
self.VnicMplsSlotIdAllocator = iter(irange(10000, 11024))
self.VnicIdAllocator = iter(irange(1, 1024))
self.InterfaceIdAllocator = iter(irange(1, 66))
self.V4RouteTableIdAllocator = iter(irange(1, 1024))
self.V6RouteTableIdAllocator = iter(irange(10001, 11024))
self.RouteIdAllocator = iter(irange(1, 1024 * 1023))
self.V4SecurityPolicyIdAllocator = iter(irange(1, 2048))
self.V6SecurityPolicyIdAllocator = iter(irange(10001, 12048))
self.RuleIdAllocator = iter(irange(1, 1023 * 1023))
self.SecurityPolicyIdAllocator = iter(irange(1, 4 * 1024 * 1024))
self.VirtualRouterMacAllocator = objects.TemplateFieldObject(
"macstep/00CC.0000.0001/0000.0000.0001")
self.RemoteMappingMacAllocator = objects.TemplateFieldObject(
"macstep/00EE.0000.0001/0000.0000.0001")
self.TepIpAddressAllocator = ipaddress.IPv4Network(
'172.16.0.0/16').hosts()
self.TepIpv6AddressAllocator = ipaddress.IPv6Network(
'ffff::100:0/104').hosts()
self.IGWMplsSlotIdAllocator = iter(irange(30001, 31024))
self.RemoteInternetNonNatTunAllocator = None
self.RemoteInternetNatTunAllocator = None
self.RemoteMplsVnicTunAllocator = None
self.PublicIpAddressAllocator = ipaddress.IPv4Network(
'200.0.0.0/16').hosts()
self.PublicIpv6AddressAllocator = ipaddress.IPv6Network(
'eeee:0:0:0::/64').hosts()
self.IGWVxlanIdAllocator = iter(irange(50001, 51024))
self.VxlanIdAllocator = iter(irange(80001, 81024))
self.MirrorSessionIdAllocator = iter(irange(1, 8))
self.PortIdAllocator = iter(irange(1, 4))
self.DhcpIdAllocator = iter(irange(1, 32))
self.NatPoolIdAllocator = iter(irange(1, 1000))
self.PolicerIdAllocator = iter(irange(1, 2048))
self.EvpnEviIdAllocator = iter(irange(1, 50))
self.EvpnEviRtIdAllocator = iter(irange(1, 50))
self.EvpnIpVrfIdAllocator = iter(irange(1, 50))
self.EvpnIpVrfRtIdAllocator = iter(irange(1, 50))
self.IpsecTunAllocator = None
self.IpsecTunnelModeTunAllocator = None
self.IpsecTransportModeTunAllocator = None
self.IpsecEncryptSAIdAllocator = iter(irange(1, 1000))
self.IpsecDecryptSAIdAllocator = iter(irange(1, 1000))
self.IpsecTunnelAddressAllocator = ipaddress.IPv4Network(
'205.10.0.0/16').hosts()
# ---------------------------------------------------------------------------------
# Artemis specific configs
# Nexthop IP allocator. Curently unique IP (globally)
# TODO : Can have same IP across VPCs.
self.NexthopIdAllocator = iter(irange(1, 1 * 1024 * 1024))
self.NexthopIpV4AddressAllocator = ipaddress.IPv4Network(
'210.0.0.0/16').hosts()
self.NexthopIpV6AddressAllocator = ipaddress.IPv6Network(
'eeee:eeee:0:0::/64').hosts()
self.NexthopMacAllocator = objects.TemplateFieldObject(
"macstep/0055.0000.0001/0000.0000.0001")
self.NexthopGroupIdAllocator = iter(irange(1, 1 * 1024))
self.V4TagIdAllocator = iter(irange(1, 1))
self.V6TagIdAllocator = iter(irange(2, 2))
self.NexthopVxlanIdAllocator = iter(irange(90001, 91024))
self.V4MeterIdAllocator = iter(irange(1, 64))
self.V6MeterIdAllocator = iter(irange(65, 129))
# Currently one to one mapping with CA-IP. TODO. Many to one
self.SvcMappingPublicIpV4AddressAllocator = ipaddress.IPv4Network(
'150.0.0.0/16').hosts()
self.SvcMappingPublicIpV6AddressAllocator = ipaddress.IPv6Network(
'eeee:dddd:dddd:0::/64').hosts()
self.NexthopVlanIdAllocator = iter(irange(4001, 5124))
# Provider IP for local and remote. One to One mapping now. Many to one can be done later
self.ProviderIpV4Network = '220.0.0.0/8'
self.ProviderIpV6Network = 'eeee:eeee:eee0:0::/64'
self.ProviderIpV4Network = ipaddress.IPv4Network(
self.ProviderIpV4Network)
self.ProviderIpV6Network = ipaddress.IPv6Network(
self.ProviderIpV6Network)
self.ProviderIpV4AddressAllocator = ipaddress.IPv4Network(
self.ProviderIpV4Network).hosts()
self.ProviderIpV6AddressAllocator = ipaddress.IPv6Network(
self.ProviderIpV6Network).hosts()
self.VpcVxlanIdAllocator = iter(irange(50000, 51024))
self.Nat46Address = ipaddress.IPv6Network('aaaa:aaaa:0:0::/64')
self.TepMacAllocator = objects.TemplateFieldObject(
"macstep/0065.0000.0001/0000.0000.0001")
# Public IP adddress in the underlay VC
self.SvcMappingPublicIpV4AddressAllocator = ipaddress.IPv4Network(
'150.0.0.0/16').hosts()
self.SvcMappingPublicIpV6AddressAllocator = ipaddress.IPv6Network(
'eeee:dddd:dddd:0::/64').hosts()
# -------------------------------------------------------------------
self.SvcTunAllocator = None
self.RemoteSvcTunAllocator = None
self.UnderlayTunAllocator = None
self.UnderlayECMPTunAllocator = None
self.OverlayNhGroupAllocator = None
self.RemoteSvcTunIPv4Addr = ipaddress.IPv4Network(
'30.0.0.0/24').hosts()
#Apulu specific configs
self.UnderlayNHAllocator = None
self.OverlayNHAllocator = None
self.DualEcmpNhAllocator = None
self.UnderlayNhGroupAllocator = None
self.DualEcmpNhGroupAllocator = None
self.DhcpRelayAllocator = None
self.IpsecEncryptSAAllocator = None
self.IpsecDecryptSAAllocator = None
self.DeviceMacAllocator = objects.TemplateFieldObject(
"macstep/0002.0100.0000/0000.0000.0001")
self.NumVnicPolicyAllocator = utils.rrobiniter(
range(Resmgr.MAX_POLICY_PER_VNIC + 1))
self.UnderlayNumNexthopsAllocator = utils.rrobiniter(
range(1, Resmgr.MAX_UNDERLAY_NHS + 1))
self.OverlayNumNexthopsAllocator = utils.rrobiniter(
range(1, Resmgr.MAX_OVERLAY_NHS + 1))
self.L3InterfaceIPv4PfxPool = iter(
ipaddress.IPv4Network('40.40.0.0/16').subnets(new_prefix=24))
# Host interface configs
self.HostMemoryAllocator = None
self.HostIfs = dict()
# Host interface index allocator for IOTA.
# Ifindices 72 and 73 (0x48, 0x49) are reserved, so we have a non-contiuous list
#TODO: Fix it properly later
HostIfIdxList = [
0x80000047, 0x8000004A, 0x8000004B, 0x8000004C, 0x8000004D,
0x8000004E, 0x8000004F, 0x80000050
]
self.HostIfIdxAllocator = iter(HostIfIdxList)
self.LoopbackIfIdAllocator = iter(irange(1, 16))
# Metaswitch
self.BgpIdAllocator = iter(irange(1, 10))
self.BgpPeerIdAllocator = iter(irange(1, 10))
self.BgpPeerAfIdAllocator = iter(irange(1, 10))
return
def GenerateObjects(self, node, parent, vpc_spec_obj):
vpcid = parent.VPCId
isV4Stack = utils.IsV4Stack(parent.Stack)
isV6Stack = utils.IsV6Stack(parent.Stack)
self.__v4objs[node][vpcid] = dict()
self.__v6objs[node][vpcid] = dict()
self.__v4iter[node][vpcid] = None
self.__v6iter[node][vpcid] = None
if not utils.IsTagSupported():
return
def __get_adjacent_routes(base, count):
routes = []
c = 1
routes.append(ipaddress.ip_network(base))
while c < count:
routes.append(utils.GetNextSubnet(routes[c - 1]))
c += 1
return routes
def __get_overlap(basepfx, base, count):
# for overlap, add user specified base prefix with original prefixlen
routes = __get_user_specified_routes([basepfx])
routes.extend(__get_adjacent_routes(base, count))
return routes
def __get_first_subnet(ip, prefixlen):
for ip in ip.subnets(new_prefix=prefixlen):
return (ip)
return
def __add_v4tagtable(v4rules):
obj = TagObject(node, utils.IP_VERSION_4, v4rules)
self.__v4objs[node][vpcid].update({obj.TagTblId: obj})
self.Objs[node].update({obj.TagTblId: obj})
def __add_v6tagtable(v6rules):
obj = TagObject(node, utils.IP_VERSION_6, v6rules)
self.__v6objs[node][vpcid].update({obj.TagTblId: obj})
self.Objs[node].update({obj.TagTblId: obj})
def __get_user_specified_rules(rulesspec):
rules = []
if rulesspec:
for rule in rulesspec:
prefixes = []
for prefix in rule.prefixes:
prefixes.append(
ipaddress.ip_network(prefix.replace('\\', '/')))
obj = TagRuleObject(prefixes, rule.tag, rule.priority)
rules.append(obj)
return rules
def __add_user_specified_tagtable(tagtablespec, pfxtype):
if isV4Stack:
__add_v4tagtable(
__get_user_specified_rules(tagtablespec.v4rules))
if isV6Stack:
__add_v6tagtable(
__get_user_specified_rules(tagtablespec.v6rules))
if not hasattr(vpc_spec_obj, 'tagtbl'):
return
for tagtbl_spec_obj in vpc_spec_obj.tagtbl:
tagtbltype = tagtbl_spec_obj.type
tagpfxtype = tagtbl_spec_obj.pfxtype
if tagtbltype == "specific":
__add_user_specified_tagtable(tagtbl_spec_obj, tagpfxtype)
continue
if self.__v6objs[node][vpcid]:
self.__v6iter[node][vpcid] = utils.rrobiniter(
self.__v6objs[node][vpcid].values())
if self.__v4objs[node][vpcid]:
self.__v4iter[node][vpcid] = utils.rrobiniter(
self.__v4objs[node][vpcid].values())
return
