def InitQos(topospec):
global QosCosAllocator
global QosDscpAllocator
qos = getattr(topospec, "qos", False)
if qos is False:
QosCosAllocator = objects.TemplateFieldObject("range/7/7")
QosDscpAllocator = objects.TemplateFieldObject("range/7/7")
QosCosAllocator.EnableWrapAround()
QosDscpAllocator.EnableWrapAround()
def __init__(self):
''' Class which will give the next hash-value to use according to the
policy
'''
self.hash_lsb = objects.TemplateFieldObject('range/0x0/0x1fffff')
self.hash_msb = objects.TemplateFieldObject('range/0x0/0x7ff')
# For 32 bit collision, hints should be 1
self.hash_policy = [
# 2 Flows - 1 recirc
{
'name': '32BIT F1',
'hints': 0,
'hint_depth': 1,
'skip': 1
},
# 3 Flows - 2 recirc
{
'name': '32BIT F2',
'hints': 0,
'hint_depth': 2,
'skip': 1
},
# 5 Flows - 4 recirc
{
'name': '32BIT F3',
'hints': 0,
'hint_depth': 4,
'skip': 1
},
# 2 Flows - 1 recirc
{
'name': '21BIT F1',
'hints': 1,
'hint_depth': 1,
'skip': 1
},
# 3 Flows - 1 recirc
{
'name': '21BIT F2',
'hints': 2,
'hint_depth': 1,
'skip': 1
},
# 15 Flows - 2/3 recircs
{
'name': '21BIT F3',
'hints': 7,
'hint_depth': 2,
'skip': 1
},
]
self.cur_hash_lsb = self.hash_lsb.get()
self.cur_hash_msb = self.hash_msb.get()
self.cur_iter = 0
self.cur_step = 0
def CreateSlabs(self):
logger.debug("In CreateSlabs, NVMe LIF %s" % (self.GID()))
self.slab_allocator = objects.TemplateFieldObject("range/0/2048")
self.slabs = objects.ObjectDatabase()
self.obj_helper_slab = slab.SlabObjectHelper()
self.obj_helper_slab.Generate2(self, self.total_slabs, self.spec.host_page_size, self.spec.host_page_size)
self.obj_helper_slab.Configure()
self.slabs.SetAll(self.obj_helper_slab.slabs)
def CreateSlabs(self, spec):
logger.debug("In CreateSlabs, Endpoint %s" % (self.GID()))
self.slab_allocator = objects.TemplateFieldObject("range/0/2048")
self.slabs = objects.ObjectDatabase()
self.mr_slabs = objects.ObjectDatabase()
self.obj_helper_slab = slab.SlabObjectHelper()
self.obj_helper_slab.Generate(self.intf.lif, spec)
self.slabs.SetAll(self.obj_helper_slab.slabs)
self.mr_slabs.SetAll(self.obj_helper_slab.slabs)
self.total_mr_slabs += len(self.mr_slabs)
def ChangeSubnet(self, vnic, new_subnet):
logger.info(
f"Changing subnet for {vnic} {vnic.SUBNET} => {new_subnet}")
# Handle child/parent relationship
old_subnet = vnic.SUBNET
old_subnet.DeleteChild(vnic)
new_subnet.AddChild(vnic)
vnic.SUBNET = new_subnet
vnic.Vnid = vnic.SUBNET.Vnid
if not utils.IsDryRun():
node_uuid = EzAccessStoreClient[new_subnet.Node].GetNodeUuid(
new_subnet.Node)
vnic.HostIfIdx = vnic.SUBNET.HostIfIdx[0]
vnic.HostIfUuid = utils.PdsUuid(vnic.HostIfIdx,
node_uuid=node_uuid)
# Handle node change scenario
if old_subnet.Node != new_subnet.Node:
# Delete VNIC from old node
del self.Objs[vnic.Node][vnic.VnicId]
del self.__l2mapping_objs[vnic.Node][(vnic.MACAddr.getnum(),
vnic.SUBNET.UUID.GetUuid(),
vnic.VlanId())]
vnic.Node = new_subnet.Node
self.Objs[vnic.Node].update({vnic.VnicId: vnic})
self.__l2mapping_objs[vnic.Node].update({
(vnic.MACAddr.getnum(), vnic.SUBNET.UUID.GetUuid(),
vnic.VlanId()):
vnic
})
# Move children to new Node
for lmap in vnic.Children:
# Operate only on lmapping objects
if lmap.GetObjectType() != api.ObjectTypes.LMAPPING:
continue
# Move lmap entry to new Node
lmapping.client.ChangeNode(lmap, new_subnet.Node)
# Destroy rmap entry in new subnet
rmap = new_subnet.GetRemoteMappingObjectByIp(lmap.IP)
assert (rmap)
rmap.Destroy()
# Add rmap entry in old subnet
mac = "macaddr/%s" % vnic.MACAddr.get()
rmap_spec = {}
rmap_spec['rmacaddr'] = objects.TemplateFieldObject(mac)
rmap_spec['ripaddr'] = lmap.IP
ipversion = utils.IP_VERSION_6 if lmap.AddrFamily == 'IPV6' else utils.IP_VERSION_4
rmapClient.GenerateObj(old_subnet.Node, old_subnet, rmap_spec,
ipversion)
return
def Init(self, lif, spec):
self.GID(spec.id)
self.lif = lif
self.spec = spec
self.id = spec.id
self.type = spec.type
self.purpose = spec.purpose.upper()
self.size = spec.size
self.count = spec.count
self.entries = None
self.queueid_allocator = objects.TemplateFieldObject("range/0/16384")
self.queues = objects.ObjectDatabase()
self.need_type_specific_configure = True
if spec.id in eth_queue_type_ids:
self.obj_helper_q = eth_queue.EthQueueObjectHelper()
if GlobalOptions.rtl and not GlobalOptions.skipverify:
if self.purpose == "LIF_QUEUE_PURPOSE_RX":
# Ring the doorbell, don't increment the PI and don't set
# the scheduler bit.
# The PI will be incremented by directly writing to QState.
self.upd = 0x0
elif self.purpose == "LIF_QUEUE_PURPOSE_TX":
# Ring the doorbell, don't increment the PI and but set
# the scheduler bit.
# The PI will be incremented by directly writing to QState.
self.upd = 0x1
else:
self.upd = 0x0
else:
if self.purpose == "LIF_QUEUE_PURPOSE_RX":
# Ring the doorbell, set PI=index and the scheduler bit.
self.upd = 0x9
elif self.purpose == "LIF_QUEUE_PURPOSE_TX":
# Ring the doorbell, set PI=index and the scheduler bit.
self.upd = 0x9
else:
self.upd = 0x0
self.doorbell = doorbell.Doorbell()
self.doorbell.Init(self, self.spec)
elif spec.id in rdma_queue_type_ids:
self.obj_helper_q = rdma_queue.RdmaQueueObjectHelper()
elif spec.id in nvme_queue_type_ids:
logger.info("nvme queue type %s" %(self.id))
self.obj_helper_q = nvme_queue.NvmeQueueObjectHelper()
else:
self.need_type_specific_configure = False
return
self.obj_helper_q.Generate(self, spec)
if len(self.obj_helper_q.queues) > 0:
self.queues.SetAll(self.obj_helper_q.queues)
self.Show()
def __mapping_entry_handler(vnic, ep_ip_prefixes):
"""
Generate/Destroy the lmap and rmap entries associated with vnic
based on input EP IP entries.
"""
api.Logger.info(
f"Fixing local and remote mapping for {vnic}, ip prefixes {ep_ip_prefixes} "
)
ep_ips = set()
for prefix in ep_ip_prefixes:
ep_ips.add(__ip_from_prefix(prefix))
api.Logger.info(f"IP address set: {ep_ips}")
# Delete lmap entries
for lmap in vnic.Children.copy():
api.Logger.info(f"Handling lmap {lmap} {lmap.IP}")
if lmap.IP in ep_ips:
ep_ips.remove(lmap.IP)
else:
lmap.Delete()
lmap.Destroy()
# Delete rmap entries on other nodes
for node in api.GetNaplesHostnames():
if node != vnic.Node:
node_subnet = subnet_client.GetSubnetObject(
node, vnic.SUBNET.SubnetId)
rmap = node_subnet.GetRemoteMappingObjectByIp(lmap.IP)
assert (rmap)
rmap.Delete()
rmap.Destroy()
# Add new lmap entries
for ep_ip in ep_ips:
lmap_spec = dict()
lmap_spec['origin'] = 'discovered'
lmap_spec['lipaddr'] = ep_ip
vnic_spec = parser.Dict2Object({'lmap': [lmap_spec]})
lmap_client.GenerateObjects(vnic.Node, vnic, vnic_spec)
# Add rmap entries on other nodes
for node in api.GetNaplesHostnames():
if node != vnic.Node:
mac = "macaddr/%s" % vnic.MACAddr.get()
rmap_spec = dict()
rmap_spec['rmacaddr'] = objects.TemplateFieldObject(mac)
rmap_spec['ripaddr'] = ep_ip
ipversion = utils.IP_VERSION_6 if lmap.AddrFamily == 'IPV6' else utils.IP_VERSION_4
node_subnet = subnet_client.GetSubnetObject(
node, vnic.SUBNET.SubnetId)
rmap_client.GenerateObj(node, node_subnet, rmap_spec,
ipversion)
def MoveEpMACEntry(workload, target_subnet, ep_mac_addr, ep_ip_prefixes):
"""
Moves workload to target subnet.
"""
vnic = workload.vnic
old_subnet = vnic.SUBNET
# Update vnic information from target subnet
vnic_client.ChangeMacAddr(
vnic, objects.TemplateFieldObject(f"macaddr/{ep_mac_addr}"))
# Move vnic to target subnet
vnic_client.ChangeSubnet(vnic, target_subnet)
# Move around mapping entries
__mapping_entry_handler(vnic, ep_ip_prefixes)
# Delete the workload.
wl_api.DeleteWorkload(workload)
# Update workload object with new information
workload.node_name = target_subnet.Node
workload.ip_prefix = ep_ip_prefixes[0]
workload.ip_address = __ip_from_prefix(ep_ip_prefixes[0])
workload.sec_ip_prefixes = ep_ip_prefixes[1:]
workload.sec_ip_addresses = [
__ip_from_prefix(prefix) for prefix in ep_ip_prefixes[1:]
]
if api.GlobalOptions.dryrun:
workload.parent_interface = 'dryrun'
else:
workload.parent_interface = intf_client.FindHostInterface(
target_subnet.Node, target_subnet.HostIfIdx[0]).GetInterfaceName()
workload.interface = workload.parent_interface
workload.mac_address = vnic.MACAddr.get()
workload.vlan = vnic.VlanId()
# Set workload in running state, otherwise command trigger on workload will fail.
store.SetWorkloadRunning(workload.workload_name)
# Re add workload
wl_api.ReAddWorkload(workload)
# Add routes
__add_routes(workload)
# Send Grat ARP
arp.SendGratArp([workload])
return api.types.status.SUCCESS
def __process_list(self, elem_list):
fobj = []
for elem in elem_list:
if isinstance(elem, objects.FrameworkObject):
elemobj = self.__process_yml_obj(elem)
elif isinstance(elem, list):
logger.verbose("Processing LIST %s" % elem)
elemobj = self.__process_list(elem)
elif utils.IsTemplateField(elem):
logger.verbose("Processing TEMPLATE FIELD %s" % elem)
elemobj = objects.TemplateFieldObject(elem)
else:
elemobj = elem
fobj.append(elemobj)
return fobj
def __generate_rmappings_from_lmappings():
nodes = api.GetNaplesHostnames()
lmapClient = config_api.GetObjClient('lmapping')
rmapClient = config_api.GetObjClient('rmapping')
rmapSpec = dict()
for targetNode in nodes:
isOverlayRoutingEnabled = EzAccessStoreClient[targetNode].IsDeviceOverlayRoutingEnabled()
if isOverlayRoutingEnabled:
rmapSpec['origin'] = 'discovered'
else:
rmapSpec['origin'] = 'fixed'
if rmapClient.GetNumObjects(targetNode) != 0:
# Skip since Remote mapping configs are already generated from cfgspec
api.Logger.verbose(f"Skipping Remote mapping generation "
f"since they already exist")
continue
for srcNode in nodes:
num = 0
if targetNode == srcNode:
continue
lmappings = lmapClient.Objects(srcNode)
for lmap in lmappings:
if lmap.VNIC.IsIgwVnic():
api.Logger.verbose(f"Skipping Remote mapping generation "
f"for IgwVnic's lmapping {lmap.GID()}")
continue
mac = "macaddr/%s" %lmap.VNIC.MACAddr.get()
rmapSpec['rmacaddr'] = objects.TemplateFieldObject(mac)
rmapSpec['ripaddr'] = lmap.IP
if lmap.AddrFamily == 'IPV6':
ipversion = utils.IP_VERSION_6
else:
ipversion = utils.IP_VERSION_4
parent = config_api.GetObjClient('subnet').GetSubnetObject(targetNode, lmap.VNIC.SUBNET.SubnetId)
rmapClient.GenerateObj(targetNode, parent, rmapSpec, ipversion)
num += 1
api.Logger.info(f"Generated {num} RMAPPING Objects in {targetNode}")
# Create the generated objects if their origin is fixed.
if not isOverlayRoutingEnabled:
if not rmapClient.CreateObjects(targetNode):
api.Logger.error(f"Failed to create remote mappings on "
f"{targetNode}, Aborting!!!")
return False
if not rmapClient.ReadObjects(targetNode):
api.Logger.error(f"Failed to read remote mappings on "
f"{targetNode}, Aborting!!!")
return False
return True
def __get_mff(tc, prefix, default):
lkplabel = __get_lookup_label(tc, prefix)
if lkplabel in MFFS:
val = MFFS[lkplabel]
else:
val = default
if type(val) is not str:
return val
if objects.IsTemplateFieldString(val):
obj = objects.TemplateFieldObject(val)
if objects.IsReference(obj):
return obj.Get(tc)
else:
assert (0)
return val
def __process_yml_obj(self, yobj):
obj = objects.FrameworkTemplateObject()
for fname, fval in yobj.__dict__.items():
if isinstance(fval, list):
logger.verbose("Processing LIST %s" % fname)
fobj = self.__process_list(fval)
elif isinstance(fval, objects.FrameworkObject):
logger.verbose("Processing OBJECT %s" % fname)
fobj = self.__process_yml_obj(fval)
elif utils.IsTemplateField(fval):
logger.verbose("Processing TEMPLATE FIELD %s = %s" %
(fname, fval))
fobj = objects.TemplateFieldObject(fval)
else:
logger.verbose("Processing basic FIELD %s =" % fname, fval)
fobj = fval
obj.__dict__[fname] = fobj
return obj
def Init(self, lif, spec):
self.GID(spec.id)
self.lif = lif
self.spec = spec
self.id = spec.id
self.type = spec.type
self.purpose = spec.purpose.upper()
self.size = spec.size
self.count = spec.count
self.entries = None
self.queueid_allocator = objects.TemplateFieldObject("range/0/16384")
self.queues = objects.ObjectDatabase()
self.need_type_specific_configure = True
if spec.id in eth_queue_type_ids:
self.obj_helper_q = eth_queue.EthQueueObjectHelper()
if self.purpose == "LIF_QUEUE_PURPOSE_RX":
# Ring the doorbell, set PI=index and the scheduler bit.
self.upd = 0x9
elif self.purpose == "LIF_QUEUE_PURPOSE_TX":
# Ring the doorbell, set PI=index and the scheduler bit.
self.upd = 0x9
else:
self.upd = 0x0
self.doorbell = doorbell.Doorbell()
self.doorbell.Init(self, self.spec)
else:
self.need_type_specific_configure = False
return
self.obj_helper_q.Generate(self, spec)
if len(self.obj_helper_q.queues) > 0:
self.queues.SetAll(self.obj_helper_q.queues)
self.Show()
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 CreateIpv6AddrPool(subnet):
allocator = objects.TemplateFieldObject("ipv6step/" + subnet + "/::1")
# Dont use the Subnet/128 address
allocator.get()
return allocator
def Init(self, tenant, spec, namespace=None):
if namespace:
self.id = namespace.get()
else:
self.id = resmgr.LifIdAllocator.get()
self.GID("Lif%d" % self.id)
self.status = haldefs.interface.IF_STATUS_UP
self.hw_lif_id = -1
self.qstate_base = {}
self.promiscuous = False
self.allmulticast = False
self.pds = []
self.c_lib_name = getattr(spec, 'c_lib', None)
if self.c_lib_name:
self.c_lib = clibs.LoadCLib(self.c_lib_name)
if self.c_lib:
self.c_lib_config = self.c_lib[self.c_lib_name + '_config']
self.c_lib_config.argtypes = [ctypes.POINTER(QInfoStruct)]
self.c_lib_config.restype = None
else:
self.c_lib = None
if hasattr(spec, 'rdma') and spec.rdma.enable:
self.enable_rdma = spec.rdma.enable
self.rdma_max_pt_entries = spec.rdma.max_pt_entries
self.rdma_max_keys = spec.rdma.max_keys
self.rdma_max_ahs = spec.rdma.max_ahs
self.hostmem_pg_size = spec.rdma.hostmem_pg_size
self.hbm_barmap_entries = (int(spec.rdma.hbm_barmap_size /
spec.rdma.hostmem_pg_size))
self.rdma_tbl_pos = BitArray(length=self.rdma_max_pt_entries)
self.hbm_tbl_pos = BitArray(length=self.hbm_barmap_entries)
self.rdma_async_eq_id = 0
self.rdma_admin_aq_id = 1
self.rdma_admin_cq_id = 0
else:
self.enable_rdma = False
self.rdma_max_pt_entries = 0
self.rdma_max_keys = 0
self.rdma_max_ahs = 0
self.hbm_barmap_entries = 0
self.hostmem_pg_size = 0
self.rdma_pt_base_addr = 0
self.rdma_kt_base_addr = 0
self.rdma_dcqcn_profile_base_addr = 0
self.rdma_at_base_addr = 0
if hasattr(spec, 'nvme') and spec.nvme.enable:
self.enable_nvme = spec.nvme.enable
self.nvme_lif = nvme_lif.NvmeLifObject(self, spec.nvme)
else:
self.enable_nvme = False
self.vlan_strip_en = False
self.vlan_insert_en = False
self.queue_types = objects.ObjectDatabase()
self.obj_helper_q = queue_type.QueueTypeObjectHelper()
self.obj_helper_q.Generate(self, spec)
self.queue_types.SetAll(self.obj_helper_q.queue_types)
self.queue_types_list = self.obj_helper_q.queue_types
self.queue_list = []
for q_type in self.queue_types_list:
for queue in q_type.queues.GetAll():
self.queue_list.append(queue)
# RDMA per LIF allocators
if self.enable_rdma:
# QP 0, 1 are special QPs
self.qpid_allocator = objects.TemplateFieldObject(
"range/2/" + str(spec.rdma.max_qp))
# AQ ID 0 is owned by ETH
self.aqid_allocator = objects.TemplateFieldObject(
"range/1/" + str(spec.rdma.max_aq))
# Reserve CQ 0, 1 for special QPs, AQ
self.cqid_allocator = objects.TemplateFieldObject(
"range/2/" + str(spec.rdma.max_cq))
self.eqid_allocator = objects.TemplateFieldObject(
"range/0/" + str(spec.rdma.max_eq))
self.pd_allocator = objects.TemplateFieldObject(
"range/0/" + str(spec.rdma.max_pd))
self.mr_key_allocator = objects.TemplateFieldObject(
"range/1/" + str(spec.rdma.max_mr))
self.slab_allocator = objects.TemplateFieldObject("range/0/2048")
self.kslab_allocator = objects.TemplateFieldObject("range/0/2048")
# Generate RDMA LIF owned resources
self.slabs = objects.ObjectDatabase()
# Generate KernelSlab of 4KB and 10 MB for FRPMR
self.kslab_4KB = slab.SlabObject(self, 4096, True)
self.obj_helper_slab = slab.SlabObjectHelper()
#slab_spec = spec.rdma.slab.Get(Store)
#self.obj_helper_slab.Generate(self, slab_spec)
#self.slabs.SetAll(self.obj_helper_slab.slabs)
# Create EQs for RDMA LIF
self.eqs = objects.ObjectDatabase()
self.obj_helper_eq = eq.EqObjectHelper()
self.obj_helper_eq.Generate(self, spec.rdma.max_eq,
spec.rdma.max_eqe)
if len(self.obj_helper_eq.eqs):
self.eqs.SetAll(self.obj_helper_eq.eqs)
# Create CQ 0 for adminQ
logger.info("Creating 1 Cqs. for LIF:%s" % (self.GID()))
# Hardcode CQ 0 for AQ
# Page size is calculated as max_cqe * cqe_size by the CQ for privileged resources
cq_id = 0
self.cq = cqs.CqObject(None, cq_id, spec.rdma.max_cqe, 0, True,
self)
# Create AdminQ
logger.info("Creating 1 Aqs. for LIF:%s" % (self.GID()))
aq_id = self.GetAqid()
self.aq = aqs.AqObject(self, aq_id, spec.rdma.max_aqe,
spec.rdma.hostmem_pg_size)
self.dcqcn_config_spec = spec.rdma.dcqcn_config.Get(Store)
if hasattr(spec, 'rss'):
self.rss_type = (
haldefs.interface.LifRssType.Value("RSS_TYPE_IPV4")
| haldefs.interface.LifRssType.Value("RSS_TYPE_IPV4_TCP")
| haldefs.interface.LifRssType.Value("RSS_TYPE_IPV4_UDP")
| haldefs.interface.LifRssType.Value("RSS_TYPE_IPV6")
| haldefs.interface.LifRssType.Value("RSS_TYPE_IPV6_TCP")
| haldefs.interface.LifRssType.Value("RSS_TYPE_IPV6_UDP"))
self.rss_key = array.array('B', toeplitz.toeplitz_msft_key)
self.rss_indir = array.array('B', [0] * 128)
else:
self.rss_type = haldefs.interface.LifRssType.Value("RSS_TYPE_NONE")
self.rss_key = array.array('B', toeplitz.toeplitz_msft_key)
self.rss_indir = array.array('B', [0] * 128)
self.tenant = tenant
self.spec = spec
self.tx_qos_class = None
self.rx_qos_class = None
if self.tenant.IsQosEnabled():
self.tx_qos_class = getattr(spec, 'tx_qos_class', None)
self.rx_qos_class = getattr(spec, 'rx_qos_class', None)
if self.tx_qos_class:
self.tx_qos_class = Store.objects.Get(self.tx_qos_class)
if self.rx_qos_class:
self.rx_qos_class = Store.objects.Get(self.rx_qos_class)
self.Show()
#! /usr/bin/python3
from infra.common.glopts import GlobalOptions
import infra.common.objects as objects
HostMemoryAllocator = None
FlowIdAllocator = objects.TemplateFieldObject("range/1/65535")
GftFlowIdAllocator = objects.TemplateFieldObject("range/1/65535")
L4LbServiceIdAllocator = objects.TemplateFieldObject("range/1/4096")
L4LbBackendIdAllocator = objects.TemplateFieldObject("range/1/16384")
InterfaceIdAllocator = objects.TemplateFieldObject("range/128/32768")
LifIdAllocator = objects.TemplateFieldObject("range/1025/2047")
QueueIdAllocator = objects.TemplateFieldObject("range/0/16384")
TenIdAllocator = objects.TemplateFieldObject("range/11/1000")
SegIdAllocator = objects.TemplateFieldObject("range/1/8192")
OifListIdAllocator = objects.TemplateFieldObject("range/1/65535")
RdmaOifListIdAllocator = objects.TemplateFieldObject("range/1/65535")
MulticastGroupIdAllocator = objects.TemplateFieldObject("range/1/65535")
SegVlanAllocator = objects.TemplateFieldObject("range/2/1000")
SegProviderVlanAllocator = objects.TemplateFieldObject("range/1001/2000")
EncapVlanAllocator = objects.TemplateFieldObject("range/3001/4000")
SegVxlanAllocator = objects.TemplateFieldObject("range/0xFF0000/0xFFFFFF")
BlackHoleSegVlanAllocator = objects.TemplateFieldObject("range/4090/4095")
BlackHoleSegVxlanAllocator = objects.TemplateFieldObject("range/0xDDDDD0/0xDDDDDF")
AclIdAllocator = objects.TemplateFieldObject("range/100/512")
QosClassIdAllocator = objects.TemplateFieldObject("range/1/16")
class Constraints(Enum):
Assignment = 1
Equality = 2
def proto_eval(expr):
expr = expr.split('.')
module = importlib.import_module(expr[0])
ret = module
for val in expr[1:]:
ret = getattr(ret, val)
return ret
IpSubnetAllocator = objects.TemplateFieldObject("ipstep/64.0.0.0/0.1.0.0")
Ipv6SubnetAllocator = objects.TemplateFieldObject(
"ipv6step/2000::0:0/0::1:0:0")
KeyIdAllocator = objects.TemplateFieldObject("range/1/65535")
class GrpcReqRspMsg:
def __init__(self, message):
self._message_type = type(message)
@staticmethod
def split_repeated_messages(message):
requests = getattr(message, 'request')
messages = []
for request in requests:
sub_message = type(message)()
def CreateIpv4AddrPool(subnet):
allocator = objects.TemplateFieldObject("ipstep/" + subnet + "/0.0.0.1")
# Dont use the Subnet/32 address
allocator.get()
return allocator
class Resmgr(base.ConfigObjectBase):
#TODO: read from PDS header files / naples mem & init
MAX_OPER = 1
MAX_UPGRADE = 1
MAX_DEVICE = 1
MAX_INTERFACE = 4
MAX_TUNNEL = 2048 if utils.IsPipelineApulu() else 1023
MAX_NEXTHOP = 4095
MAX_NEXTHOPGROUP = 2048
MAX_LMAPPING = 131072
MAX_RMAPPING = 2097152
MAX_VPC = 64
MAX_VNIC = 128 if utils.IsPipelineArtemis() or utils.IsPipelineApulu(
) else 64
MAX_HOST_INTERFACES = 8 if utils.IsPipelineApulu() else 2
# Apulu supports 8 lif for now and therefore cfg cannot have more than 8 subnets
MAX_SUBNET = MAX_HOST_INTERFACES if utils.IsPipelineApulu() else 64
MAX_RULES_PER_V4_POLICY = 1023
MAX_RULES_PER_V6_POLICY = 15
if utils.IsPipelineArtemis():
MAX_POLICY = 1023
MAX_ROUTE_TABLE = 128
MAX_ROUTES_PER_ROUTE_TBL = 63
elif utils.IsPipelineApulu():
# TODO: init based on mem
# 32 vnics, 32 subnets, 5 policies per vnic per direction, 1 policy per subnet per direction
# ((32 * 5) * 2) + ((32 * 1) * 2) = 384
MAX_POLICY = 384 # 384 (8G) and 32 (4G)
MAX_RULES_PER_V4_POLICY = 256
MAX_ROUTE_TABLE = 1024 # 1024 (8G) and 8 (4G)
MAX_ROUTES_PER_ROUTE_TBL = 16383 # 1023 (8G) and 16383 (4G)
else:
MAX_POLICY = 1023
MAX_ROUTE_TABLE = 1024
MAX_ROUTES_PER_ROUTE_TBL = 1023
MAX_POLICY_PER_VNIC = 2
MAX_POLICER_PER_DIRECTION = 1024
MAX_SECURITY_PROFILE = 1
MAX_MIRROR = 8
MAX_TAG = 1
MAX_METER = 64
MAX_UNDERLAY_NHS = 2
MAX_OVERLAY_NHS = 8
MAX_DHCP_RELAY = 16
MAX_DHCP_PROXY = 16
MAX_NAT_PB = 1024
MAX_BGP_SESSIONS = 5
MAX_BGP_PEER_AF_SESSIONS = 5
MAX_BGP_PEERS = 10
MAX_BGP_EVPN_EVI = 50
MAX_BGP_EVPN_EVI_RT = 50
MAX_BGP_EVPN_IP_VRF = 50
MAX_BGP_EVPN_IP_VRF_RT = 50
MAX_IPSEC_SA = 1024
NICMGR_HOST_LIF_BASE = 72
NICMGR_HOST_LIF_COUNT = 1
# Starts VPC prefixes from 10/8 to 42/8
VPC_V4_PREFIX_BASE = 10
# Create overlapping prefixes for every 32 VPCs
VPC_V4_PREFIX_OVERLAP_DIST = 32
# Starts VPC prefixes from aaaa:0001:0010/48 to aaaa:0001:00042/48
VPC_V6_BASE = 'aaaa:0001'
VPC_V6_PREFIX_BASE = 10
# Create overlapping prefixes for every 32 VPCs
VPC_V6_PREFIX_OVERLAP_DIST = 128
InvalidMplsSlotIdAllocator = iter(irange(50001, 90000))
InvalidVxlanIdAllocator = iter(irange(10001, 12000))
# This will be used to avoid overlap between topology and resource manager id allocation
# used only for Tunnel, Nexthop and Interface objects
BaseDuplicateIdAllocator = 100000
# TCP/UDP ports for flow and service mapping. Right now keeping it in resmgr.
TransportSrcPort = 100 # For VNET packets
TransportDstPort = 200 # For VNET packets
TransportSvcPort = 400 # For VIP, Underlay tcp/udp port
TransportSrcLBPort = 101 # Local backend service port, 101 mapped to 400
# Subnet address pools for multi node topology where same subnet exists on many nodes
SubnetIPv4AddrPool = dict()
SubnetIPv6AddrPool = dict()
SubnetVRIPv4 = dict()
SubnetVRIPv6 = dict()
LocalMappingIdAllocator = iter(irange(1, 128 * 1024))
RemoteMappingIdAllocator = iter(irange(1, 16 * 1024 * 1024))
LocalMappingV4TagIdAllocator = iter(irange(1, 2 * 1024 * 1024))
LocalMappingV6TagIdAllocator = iter(irange(1, 2 * 1024 * 1024))
RemoteMappingV4TagIdAllocator = iter(irange(1, 2 * 1024 * 1024))
RemoteMappingV6TagIdAllocator = iter(irange(1, 2 * 1024 * 1024))
VnicMacAllocator = objects.TemplateFieldObject(
"macstep/00DD.0000.0001/0000.0000.0001")
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 Show(self):
return
def ReadHostInterfaceInfo(self):
if utils.IsDryRun(): return
# reads nicmgr.log and get interface info
nicmgrlog = utils.GetNicmgrLogPath()
f = open(nicmgrlog, "r")
for ifobj in self.HostIfs.values():
# get lifbase and count
pattern = ' %s: lif_base (\w+) lif_count (\w+)' % (ifobj.IfName)
for line in f:
match = re.search(pattern, line)
if match is None:
continue
lifbase = int(match.groups()[0])
lifcount = int(match.groups()[1])
ifobj.SetLifBase(lifbase)
ifobj.SetLifCount(lifcount)
break
# get devcmd addr
pattern = ' %s: regs_mem_addr (\w+) devcmd_mem_addr (\w+)' % (
ifobj.IfName)
for line in f:
match = re.search(pattern, line)
if match is None:
continue
devcmdaddr = int(match.groups()[1], base=16)
ifobj.SetDevCmdAddr(devcmdaddr)
break
# get qstate addr for all lifs under this device
for i in range(lifcount):
lif_id = lifbase + i
pattern = ' lif-%d: qtype: (\d{1}), qstate_base: (\w+)' % (
lif_id)
for line in f:
match = re.search(pattern, line)
if match is None:
continue
q_type = int(match.groups()[0])
qstate_base = int(match.groups()[1], base=16)
qstateaddr_list = ifobj.Lif2QstateMap.get(lif_id, [])
qstateaddr_list.insert(q_type, qstate_base)
ifobj.Lif2QstateMap.update({lif_id: qstateaddr_list})
if (q_type == 7):
break
f.close()
return
def InitializeHostMemMgr(self):
if utils.IsDryRun(): return
self.HostMemoryAllocator = objects.GetHostMemMgrObject()
assert self.HostMemoryAllocator is not None
def InitializeHostInterfaces(self):
if not utils.IsDol(): return
with open(utils.GetDeviceJsonPath(), 'r') as fp:
obj = json.load(fp)
lifbase = Resmgr.NICMGR_HOST_LIF_BASE
lifcount = Resmgr.NICMGR_HOST_LIF_COUNT
# read host interface info from device.json
for ethdev in obj["eth_dev"]:
if ethdev["type"] != 'host':
continue
ifname = ethdev["name"]
intf = NicmgrInterface(ifname)
intf.SetLifBase(lifbase)
self.HostIfs.update({ifname: intf})
lifbase += lifcount
if utils.IsInterfaceSupported():
self.InitializeHostMemMgr()
self.ReadHostInterfaceInfo()
def Initialize(self):
self.InitializeHostInterfaces()
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 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 CreateVnicTunnels(self):
objs = EzAccessStoreClient[self.Node].GetWorkloadTunnels()
if len(objs) != 0:
self.RemoteMplsVnicTunAllocator = 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 CreateUnderlayNHAllocator(self):
objs = EzAccessStoreClient[self.Node].GetUnderlayNexthops()
if len(objs) != 0:
self.UnderlayNHAllocator = utils.rrobiniter(objs)
def CreateOverlayNHAllocator(self):
objs = EzAccessStoreClient[self.Node].GetOverlayNexthops()
if len(objs) != 0:
self.OverlayNHAllocator = utils.rrobiniter(objs)
def CreateDualEcmpNhAllocator(self):
objs = EzAccessStoreClient[self.Node].GetDualEcmpNexthops()
if len(objs) != 0:
self.DualEcmpNhAllocator = utils.rrobiniter(objs)
def CreateUnderlayNhGroupAllocator(self):
objs = EzAccessStoreClient[self.Node].GetUnderlayNhGroups()
if len(objs) != 0:
self.UnderlayNhGroupAllocator = utils.rrobiniter(objs)
def CreateOverlayNhGroupAllocator(self):
objs = EzAccessStoreClient[self.Node].GetOverlayNhGroups()
if len(objs) != 0:
self.OverlayNhGroupAllocator = utils.rrobiniter(objs)
def CreateDualEcmpNhGroupAllocator(self):
objs = EzAccessStoreClient[self.Node].GetDualEcmpNhGroups()
if len(objs) != 0:
self.DualEcmpNhGroupAllocator = utils.rrobiniter(objs)
def CreateDHCPRelayAllocator(self):
objs = EzAccessStoreClient[self.Node].GetDhcpRelayObjects()
if len(objs) != 0:
self.DhcpRelayAllocator = utils.rrobiniter(objs)
def CreateDHCPProxyAllocator(self):
objs = EzAccessStoreClient[self.Node].GetDhcpProxyObjects()
if len(objs) != 0:
self.DhcpProxyAllocator = utils.rrobiniter(objs)
def CreateIpsecTunnels(self):
objs = EzAccessStoreClient[self.Node].GetIpsecTunnels()
if len(objs) != 0:
self.IpsecTunAllocator = utils.rrobiniter(objs)
def CreateIpsecTunnelModeTunnels(self):
objs = EzAccessStoreClient[self.Node].GetIpsecTunnelModeTunnels()
if len(objs) != 0:
self.IpsecTunnelModeTunAllocator = utils.rrobiniter(objs)
def CreateIpsecTransportModeTunnels(self):
objs = EzAccessStoreClient[self.Node].GetIpsecTransportModeTunnels()
if len(objs) != 0:
self.IpsecTransportModeTunAllocator = utils.rrobiniter(objs)
def CreateIpsecEncryptSAAllocator(self):
objs = EzAccessStoreClient[self.Node].GetIpsecEncryptSAs()
if len(objs) != 0:
self.IpsecEncryptSAAllocator = utils.rrobiniter(objs)
def CreateIpsecDecryptSAAllocator(self):
objs = EzAccessStoreClient[self.Node].GetIpsecDecryptSAs()
if len(objs) != 0:
self.IpsecDecryptSAAllocator = utils.rrobiniter(objs)
# Create subnets from base prefix
# - base is a prefix in the form of '10.0.0.0/16'
# - sublen is the subnet length, gt base prefix length.
# - poolid , subnet pool index with in a vpc
@staticmethod
def CreateIPv4SubnetPool(base, sublen, poolid):
assert (isinstance(base, ipaddress.IPv4Network))
assert (sublen >= 10)
assert (poolid < 16)
addr = base.network_address + (poolid << (32 - 8))
pfxstr = "%s/8" % (str(ipaddress.IPv4Address(addr)))
base = ipaddress.IPv4Network(pfxstr)
return iter(base.subnets(new_prefix=sublen))
@staticmethod
def CreateIPv6SubnetPool(base, sublen, poolid):
assert (isinstance(base, ipaddress.IPv6Network))
assert (sublen >= 64)
assert (poolid < 16)
addr = base.network_address + (poolid << (128 - 56))
pfxstr = "%s/56" % (str(ipaddress.IPv6Address(addr)))
base = ipaddress.IPv6Network(pfxstr)
return iter(base.subnets(new_prefix=sublen))
@staticmethod
def CreateIpv4AddrPool(subnet):
assert (isinstance(subnet, ipaddress.IPv4Network))
return iter(subnet.hosts())
@staticmethod
def CreateIpv6AddrPool(subnet):
assert (isinstance(subnet, ipaddress.IPv6Network))
return iter(subnet.hosts())
@staticmethod
def CreateIPv4AddrPoolForSubnet(subnet_id, prefix):
if subnet_id in Resmgr.SubnetIPv4AddrPool:
return
assert (isinstance(prefix, ipaddress.IPv4Network))
Resmgr.SubnetIPv4AddrPool[subnet_id] = iter(prefix.hosts())
# store first IP as VRIP
Resmgr.SubnetVRIPv4[subnet_id] = next(
Resmgr.SubnetIPv4AddrPool[subnet_id])
return
@staticmethod
def CreateIPv6AddrPoolForSubnet(subnet_id, prefix):
if subnet_id in Resmgr.SubnetIPv6AddrPool:
return
assert (isinstance(prefix, ipaddress.IPv6Network))
Resmgr.SubnetIPv6AddrPool[subnet_id] = iter(prefix.hosts())
# store first IP as VRIP
Resmgr.SubnetVRIPv6[subnet_id] = next(
Resmgr.SubnetIPv6AddrPool[subnet_id])
return
@staticmethod
def GetIPv4AddrFromSubnetPool(subnet_id):
if subnet_id in Resmgr.SubnetIPv4AddrPool:
return next(Resmgr.SubnetIPv4AddrPool[subnet_id])
else:
return None
@staticmethod
def GetIPv6AddrFromSubnetPool(subnet_id):
if subnet_id in Resmgr.SubnetIPv6AddrPool:
return next(Resmgr.SubnetIPv6AddrPool[subnet_id])
else:
return None
@staticmethod
def GetSubnetVRIPv4(subnet_id):
if subnet_id in Resmgr.SubnetVRIPv4:
return Resmgr.SubnetVRIPv4[subnet_id]
else:
return None
@staticmethod
def GetSubnetVRIPv6(subnet_id):
if subnet_id in Resmgr.SubnetVRIPv6:
return Resmgr.SubnetVRIPv6[subnet_id]
else:
return None
# The below function will be called for every Remote TEP
@staticmethod
def CreateRemoteVnicMplsSlotAllocator():
mplsbase = 20000
return iter(irange(mplsbase,
mplsbase + 1027)) # 1M Remote Mappings/1022 Teps
# The below function will be called for every Remote TEP
@staticmethod
def CreateRemoteVnicVxlanIdAllocator():
vxlanbase = 30000
return iter(irange(vxlanbase,
vxlanbase + 1027)) # 1M Remote Mappings/1022 Teps
@staticmethod
def GetVpcIPv4Prefix(vpcid):
pfxstr = '%d.0.0.0/8' % ((vpcid % Resmgr.VPC_V4_PREFIX_OVERLAP_DIST) +
Resmgr.VPC_V4_PREFIX_BASE)
return ipaddress.IPv4Network(pfxstr)
@staticmethod
def GetVpcIPv6Prefix(vpcid):
pfxstr = '%s:%04x::/48' % (Resmgr.VPC_V6_BASE, (
(vpcid % Resmgr.VPC_V6_PREFIX_OVERLAP_DIST) +
Resmgr.VPC_V6_PREFIX_BASE))
return ipaddress.IPv6Network(pfxstr)
@staticmethod
def GetVpcInternetNatPoolPfx(vpcid):
pfxstr = '50.5.%d.0/24' % (vpcid)
return ipaddress.IPv4Network(pfxstr)
@staticmethod
def GetVpcInfraNatPoolPfx(vpcid):
pfxstr = '10.%d.199.0/24' % (vpcid)
return ipaddress.IPv4Network(pfxstr)
@staticmethod
def GetNatPoolPortRange(proto):
if proto == 'icmp':
return 0, 0
return 10000, 20000
def UpdateFromTCConfig(self, flow, sep, dep, segment, tenant):
if self.ConfigFlowMiss():
# Generate configs with locally generated values
smac = resmgr.AclMacAllocator.get()
dmac = resmgr.AclMacAllocator.get()
etype = resmgr.AclEtypeAllocator.get()
if flow.IsIPV4():
sip = resmgr.AclIPv4Allocator.get()
dip = resmgr.AclIPv4Allocator.get()
elif flow.IsIPV6():
sip = resmgr.AclIPv6Allocator.get()
dip = resmgr.AclIPv6Allocator.get()
sport = resmgr.AclL4PortAllocator.get()
dport = resmgr.AclL4PortAllocator.get()
icmpcode = resmgr.AclICMPTypeCodeAllocator.get()
icmptype = resmgr.AclICMPTypeCodeAllocator.get()
else:
# Update the config with values from the flow
if flow.IsMAC():
smac = sep.macaddr
dmac = dep.macaddr
etype = flow.ethertype
if flow.IsIP():
sip = flow.sip
dip = flow.dip
if flow.IsTCP() or flow.IsUDP():
sport = flow.sport
dport = flow.dport
if flow.IsICMP():
icmpcode = flow.icmpcode
icmptype = flow.icmptype
if self.MatchOnSIF():
self.fields.match.src_if = sep.intf
if self.MatchOnDIF():
self.fields.match.dst_if = dep.intf
if self.MatchOnTenant():
self.fields.match.tenant = tenant
if self.MatchOnSegment():
self.fields.match.segment = segment
if self.MatchOnEtherType():
self.fields.match.eth.ethertype = \
objects.TemplateFieldObject("const/%d" % etype)
if self.MatchOnMacSA():
self.fields.match.eth.src = smac
if self.MatchOnMacDA():
self.fields.match.eth.dst = dmac
if self.MatchOnSIP():
self.fields.match.ip.src_ip = sip
if self.MatchOnDIP():
self.fields.match.ip.dst_ip = dip
if self.MatchOnTCPSport():
self.fields.match.l4.tcp.src_port_range = \
objects.TemplateFieldObject("range/%d/%d" % (sport, sport))
if self.MatchOnTCPDport():
self.fields.match.l4.tcp.dst_port_range = \
objects.TemplateFieldObject("range/%d/%d" % (dport, dport))
if self.MatchOnUDPSport():
self.fields.match.l4.udp.src_port_range = \
objects.TemplateFieldObject("range/%d/%d" % (sport, sport))
if self.MatchOnUDPDport():
self.fields.match.l4.udp.dst_port_range = \
objects.TemplateFieldObject("range/%d/%d" % (dport, dport))
if self.MatchOnICMPCode():
self.fields.match.l4.icmp.code = \
objects.TemplateFieldObject("const/%d" % icmpcode)
if self.MatchOnICMPType():
self.fields.match.l4.icmp.type = \
objects.TemplateFieldObject("const/%d" % icmptype)
if self.ActionSupRedirect():
self.fields.action.redirect_if = Store.objects.Get('Cpu1')
elif self.ActionTunnelRedirect():
self.fields.action.redirect_if = \
(set(Store.GetTunnelsVxlan()) - set([dep.intf])).pop()
self.fields.action.encap_id = 30
self.fields.action.macsa = resmgr.AclMacAllocator.get()
self.fields.action.macda = resmgr.AclMacAllocator.get()
elif self.ActionUplinkRedirect():
self.fields.action.redirect_if = \
(set(Store.GetTrunkingUplinks()) - set([dep.intf])).pop()
self.fields.action.encap_id = 20
self.fields.action.macsa = resmgr.AclMacAllocator.get()
self.fields.action.macda = resmgr.AclMacAllocator.get()
import infra.common.defs as defs
import infra.common.utils as utils
import infra.common.logging as logging
import infra.common.objects as objects
import infra.common.loader as loader
import infra.factory.testspec as testspec
import infra.factory.testcase as testcase
import infra.factory.factory as factory
from infra.factory.store import FactoryStore as FactoryStore
from infra.common.logging import logger
from infra.common.glopts import GlobalOptions
from infra.config.store import ConfigStore as ConfigStore
from infra.misc import coverage
ModuleIdAllocator = objects.TemplateFieldObject("range/1/8192")
TestCaseIdAllocator = objects.TemplateFieldObject("range/1/65535")
MODULE_CB_INIT_TRACKER = 'InitTracker'
MODULE_CB_SETUP = 'Setup'
MODULE_CB_TEARDOWN = 'Teardown'
class ModuleStats:
def __init__(self):
self.Reset()
return
def Reset(self):
self.passed = 0
self.failed = 0
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
#! /usr/bin/python3
import infra.common.defs as defs
import infra.common.objects as objects
from factory.objects.ut.descriptor import InfraUtTxDescriptorObject
RingIdAllocator = objects.TemplateFieldObject("range/1/256")
class RingObject(objects.FrameworkObject):
def __init__(self, size, entrysz, pi=0, ci=0):
super().__init__()
self.ID(RingIdAllocator.get())
self.size = size
self.entrysz = entrysz
self.pi = pi
self.ci = ci
self.list = [None] * self.size
return
def configure(self):
return
def Post(self, descriptor):
descriptor.Write(self.GID(), self.pi)
self.pi += 1
return self.pi
def Read(self, descriptor, index):
descriptor.Read(self.GID(), index - 1)
