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