def __init__(self, node, spec):
super().__init__(api.ObjectTypes.MIRROR, node)
self.Id = next(ResmgrClient[node].MirrorSessionIdAllocator)
self.GID("MirrorSession%d" % self.Id)
self.UUID = utils.PdsUuid(self.Id, self.ObjType)
################# PUBLIC ATTRIBUTES OF MIRROR OBJECT #####################
self.SnapLen = getattr(spec, 'snaplen', 100)
self.SpanType = getattr(spec, 'spantype', 'RSPAN')
if self.SpanType == "RSPAN":
self.Interface = getattr(spec, 'interface')
self.UplinkIfUUID = utils.PdsUuid(self.Interface)
self.VlanId = getattr(spec, 'vlanid', 1)
elif self.SpanType == "ERSPAN":
self.ErSpanType = utils.GetErspanProtocolType(getattr(spec, 'erspantype', \
topo.ErspanProtocolTypes.ERSPAN_TYPE_NONE))
self.VPCId = getattr(spec, 'vpcid', 1)
self.ErSpanDstType = getattr(spec, 'erspandsttype', 'tep')
self.TunnelId = getattr(spec, 'tunnelid')
if self.ErSpanDstType == 'ip' and (hasattr(spec, 'dstip')):
self.DstIP = ipaddress.ip_address(getattr(spec, 'dstip'))
else:
tunobj = tunnel.client.GetTunnelObject(node, self.TunnelId)
self.DstIP = ipaddress.ip_address(tunobj.RemoteIP)
self.SpanID = int(getattr(spec, 'spanid'))
self.Dscp = getattr(spec, 'dscp', 0)
self.VlanStripEn = getattr(spec, 'vlanstripen', False)
else:
assert (0)
self.Status = MirrorSessionStatus()
self.Stats = MirrorSessionStats()
################# PRIVATE ATTRIBUTES OF MIRROR OBJECT #####################
self.DeriveOperInfo()
self.Show()
return
def ModifyHostInterface(self, hostifidx=None):
if not utils.IsNetAgentMode():
return False
if utils.IsDryRun():
return True
if len(self.HostIfUuid) != 0:
#dissociate this from subnet first
InterfaceClient.UpdateHostInterfaces(self.Node, [self], True)
if hostifidx == None:
self.HostIfIdx = [InterfaceClient.GetHostInterface(self.Node)]
else:
self.HostIfIdx = [hostifidx]
node_uuid = EzAccessStoreClient[self.Node].GetNodeUuid(self.Node)
self.HostIfUuid = []
for ifidx in self.HostIfIdx:
self.HostIfUuid.append(utils.PdsUuid(ifidx, node_uuid=node_uuid))
vnicObjs = list(
filter(lambda x: (x.ObjType == api.ObjectTypes.VNIC),
self.Children))
for vnic in vnicObjs:
vnic.HostIfIdx = self.HostIfIdx[0]
vnic.HostIfUuid = utils.PdsUuid(vnic.HostIfIdx,
node_uuid=node_uuid)
InterfaceClient.UpdateHostInterfaces(self.Node, [self])
return True
def AutoUpdate(self):
self.VirtualRouterMACAddr = ResmgrClient[
self.Node].VirtualRouterMacAllocator.get()
if utils.IsDol():
hostIf = InterfaceClient.GetHostInterface(self.Node)
if hostIf != None:
self.HostIf = hostIf
self.HostIfIdx = [utils.LifId2HostIfIndex(self.HostIf.lif.id)]
self.HostIfUuid = [utils.PdsUuid(self.HostIfIdx[0])
] if self.HostIfIdx[0] else []
self.V4RouteTableId = 0
# remove self from dependee list of those policies before updating it
utils.ModifyPolicyDependency(self, True)
self.IngV4SecurityPolicyIds = [
PolicyClient.GetIngV4SecurityPolicyId(self.Node, self.VPC.VPCId)
]
self.EgV4SecurityPolicyIds = [
PolicyClient.GetEgV4SecurityPolicyId(self.Node, self.VPC.VPCId)
]
utils.ModifyPolicyDependency(self, False)
if self.IpV6Valid:
self.VirtualRouterIPAddr[0] = self.AllocIPv6Address()
self.VirtualRouterIPAddr[1] = self.AllocIPv4Address()
self.IPAMname = None
return
def __init__(self, node, spec):
super().__init__(api.ObjectTypes.SECURITY_PROFILE, node)
if hasattr(spec, 'origin'):
self.SetOrigin(spec.origin)
############### PUBLIC ATTRIBUTES OF SECURITY PROFILE OBJECT ###############
if (hasattr(spec, 'id')):
self.SecurityProfileId = spec.id
else:
self.SecurityProfileId = 1
self.GID('SecurityProfile%d'%self.SecurityProfileId)
self.UUID = utils.PdsUuid(self.SecurityProfileId, self.ObjType)
self.ConnTrackEn = getattr(spec, 'conntrack', False)
deffwaction = getattr(spec, 'deffwaction', 'allow')
self.DefaultFWAction = utils.GetRpcSecurityRuleAction(deffwaction)
self.TCPIdleTimeout = getattr(spec, 'tcpidletimeout', 600)
self.UDPIdleTimeout = getattr(spec, 'udpidletimeout', 120)
self.ICMPIdleTimeout = getattr(spec, 'icmpidletimeout', 15)
self.OtherIdleTimeout = getattr(spec, 'otheridletimeout', 90)
self.TCPCnxnSetupTimeout = getattr(spec, 'tcpsyntimeout', 10)
self.TCPHalfCloseTimeout = getattr(spec, 'tcphalfclosetimeout', 120)
self.TCPCloseTimeout = getattr(spec, 'tcpclosetimeout', 15)
self.TCPDropTimeout = getattr(spec, 'tcpdroptimeout', 90)
self.UDPDropTimeout = getattr(spec, 'udpdroptimeout', 60)
self.ICMPDropTimeout = getattr(spec, 'icmpdroptimeout', 30)
self.OtherDropTimeout = getattr(spec, 'otherdroptimeout', 60)
############### PRIVATE ATTRIBUTES OF SECURITY_PROFILE OBJECT ###############
self.__spec = spec
self.DeriveOperInfo()
self.Mutable = utils.IsUpdateSupported()
self.Show()
return
def __init__(self, node, parent, spec):
super().__init__(api.ObjectTypes.NEXTHOPGROUP, node)
if hasattr(spec, 'origin'):
self.SetOrigin(spec.origin)
elif (EzAccessStoreClient[node].IsDeviceOverlayRoutingEnabled()):
self.SetOrigin('discovered')
################# PUBLIC ATTRIBUTES OF NEXTHOPGROUP OBJECT ############
if (hasattr(spec, 'id')):
self.Id = spec.id
else:
self.Id = next(ResmgrClient[node].NexthopGroupIdAllocator)
self.GID('NexthopGroup%d' % self.Id)
self.UUID = utils.PdsUuid(self.Id, self.ObjType)
self.Nexthops = {}
self.DualEcmp = utils.IsDualEcmp(spec)
self.Type = nh_pb2.NEXTHOP_GROUP_TYPE_NONE
if spec.type == 'overlay':
self.Type = nh_pb2.NEXTHOP_GROUP_TYPE_OVERLAY_ECMP
self.NumNexthops = ResmgrClient[
node].OverlayNumNexthopsAllocator.rrnext()
elif spec.type == 'underlay':
self.Type = nh_pb2.NEXTHOP_GROUP_TYPE_UNDERLAY_ECMP
self.NumNexthops = ResmgrClient[
node].UnderlayNumNexthopsAllocator.rrnext()
self.Mutable = utils.IsUpdateSupported()
self.Status = NexthopGroupStatus()
self.DeriveOperInfo()
self.Show()
return
def ValidateLearntMacEntries(self, node, ret, cli_op):
if utils.IsDryRun(): return True
if not ret:
logger.error("pdsctl show learn mac cmd failed")
return False
# split output per object
mac_entries = cli_op.split("---")
for mac in mac_entries:
yamlOp = utils.LoadYaml(mac)
if not yamlOp:
continue
yamlOp = yamlOp['macentry']['entryauto']
mac_key = yamlOp['key']['macaddr']
subnet_uuid = utils.GetYamlSpecAttr(yamlOp['key'], 'subnetid')
vnic_uuid_str = utils.List2UuidStr(
utils.GetYamlSpecAttr(yamlOp, 'vnicid'))
# verifying if the info learnt is expected from config
vnic_obj = self.GetVnicByL2MappingKey(node, mac_key, subnet_uuid,
0)
if vnic_obj == None:
logger.error(
f"vnic not found in client object store for key {mac_key} {subnet_uuid}{0}"
)
return False
# verifying if VNIC has been programmed correctly by Learn
args = "--id " + vnic_uuid_str
ret, op = utils.RunPdsctlShowCmd(node, "vnic", args, True)
if not ret:
logger.error(f"show vnic failed for vnic id {vnic_uuid_str}")
return False
cmdop = op.split("---")
logger.info("Num entries returned for vnic show id %s is %s" %
(vnic_uuid_str, (len(cmdop) - 1)))
for vnic_entry in cmdop:
yamlOp = utils.LoadYaml(vnic_entry)
if not yamlOp:
continue
vnic_spec = yamlOp['spec']
hostif = vnic_spec['hostif']
if utils.PdsUuid(
hostif).GetUuid() != vnic_obj.HostIfUuid.GetUuid():
logger.error(
f"host interface did not match for {vnic_uuid_str}")
return False
if vnic_spec['macaddress'] != vnic_obj.MACAddr.getnum():
logger.error(
f"mac address did not match for {vnic_uuid_str}")
return False
logger.info(
"Found VNIC %s entry for learn MAC MAC:%s, Subnet:%s, VNIC:%s "
%
(utils.List2UuidStr(utils.GetYamlSpecAttr(
vnic_spec, 'id')), vnic_obj.MACAddr.get(),
vnic_obj.SUBNET.UUID, vnic_uuid_str))
return True
def Dup(self):
dupObj = copy.copy(self)
dupObj.NexthopId = next(ResmgrClient[
self.Node].NexthopIdAllocator) + Resmgr.BaseDuplicateIdAllocator
dupObj.GID('DupNexthop%d' % dupObj.NexthopId)
dupObj.UUID = utils.PdsUuid(dupObj.NexthopId, dupObj.ObjType)
dupObj.Interim = True
self.Duplicate = dupObj
return dupObj
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, node, parent, spec):
super().__init__(api.ObjectTypes.NEXTHOP, node)
if hasattr(spec, 'origin'):
self.SetOrigin(spec.origin)
elif (EzAccessStoreClient[node].IsDeviceOverlayRoutingEnabled()):
self.SetOrigin('discovered')
################# PUBLIC ATTRIBUTES OF NEXTHOP OBJECT #####################
if (hasattr(spec, 'id')):
self.NexthopId = spec.id
else:
self.NexthopId = next(ResmgrClient[node].NexthopIdAllocator)
self.GID('Nexthop%d' % self.NexthopId)
self.UUID = utils.PdsUuid(self.NexthopId, self.ObjType)
self.VPC = parent
nh_type = getattr(spec, 'type', 'ip')
self.DualEcmp = utils.IsDualEcmp(spec)
if nh_type == 'ip':
self.__type = topo.NhType.IP
self.PfxSel = parent.PfxSel
self.IPAddr = {}
self.IPAddr[0] = next(
ResmgrClient[node].NexthopIpV4AddressAllocator)
self.IPAddr[1] = next(
ResmgrClient[node].NexthopIpV6AddressAllocator)
self.VlanId = next(ResmgrClient[node].NexthopVlanIdAllocator)
if (hasattr(spec, 'macaddress')):
self.MACAddr = spec.macaddress
else:
self.MACAddr = ResmgrClient[node].NexthopMacAllocator.get()
elif nh_type == 'underlay':
self.__type = topo.NhType.UNDERLAY
self.L3Interface = InterfaceClient.GetL3UplinkInterface(node)
self.L3InterfaceId = self.L3Interface.InterfaceId
if (hasattr(spec, 'macaddress')):
self.underlayMACAddr = spec.macaddress
else:
self.underlayMACAddr = ResmgrClient[
node].NexthopMacAllocator.get()
elif nh_type == 'overlay':
self.__type = topo.NhType.OVERLAY
if self.DualEcmp:
self.TunnelId = ResmgrClient[
node].UnderlayECMPTunAllocator.rrnext().Id
elif (hasattr(spec, 'tunnelid')):
self.TunnelId = spec.tunnelid
else:
self.TunnelId = ResmgrClient[node].UnderlayTunAllocator.rrnext(
).Id
else:
self.__type = topo.NhType.NONE
self.Mutable = utils.IsUpdateSupported()
self.Status = NexthopStatus()
self.DeriveOperInfo()
self.Show()
return
def __init__(self, node, port, mode, state='UP'):
################# PUBLIC ATTRIBUTES OF PORT OBJECT #####################
self.Node = node
self.PortId = next(ResmgrClient[node].PortIdAllocator)
self.GID("Port ID:%s" % self.PortId)
self.Port = port
self.EthIfIndex = topo.PortToEthIfIdx(self.PortId)
self.UUID = utils.PdsUuid(self.EthIfIndex)
self.Mode = mode
self.AdminState = state
################# PRIVATE ATTRIBUTES OF PORT OBJECT #####################
self.Show()
return
def GetGrpcSvcMappingCreateMessage(self, cookie):
grpcmsg = service_pb2.SvcMappingRequest()
grpcmsg.BatchCtxt.BatchCookie = cookie
spec = grpcmsg.Request.add()
svc_uuid = utils.PdsUuid(self.MappingId, api.ObjectTypes.SVCMAPPING)
spec.Id = svc_uuid.GetUuid()
spec.Key.VPCId = self.VNIC.SUBNET.VPC.GetKey()
utils.GetRpcIPAddr(self.IPAddr, spec.Key.BackendIP)
spec.Key.BackendPort = self.LBPort
utils.GetRpcIPAddr(self.SvcIPAddr, spec.IPAddr)
spec.SvcPort = self.SvcPort
utils.GetRpcIPAddr(self.ProviderIPAddr, spec.ProviderIP)
return grpcmsg
def __init__(self, node, vpc, dhcprelaySpec):
super().__init__(api.ObjectTypes.DHCP_RELAY, node)
self.ServerIps = []
self.AgentIps = []
self.Id = next(ResmgrClient[node].DhcpIdAllocator)
self.GID("Dhcp%d" % self.Id)
self.UUID = utils.PdsUuid(self.Id, self.ObjType)
########## PUBLIC ATTRIBUTES OF DHCPRELAY CONFIG OBJECT ##############
self.Vpc = vpc
for dhcpobj in dhcprelaySpec:
self.ServerIps.append(ipaddress.ip_address(dhcpobj.serverip))
self.AgentIps.append(ipaddress.ip_address(dhcpobj.agentip))
########## PRIVATE ATTRIBUTES OF DHCPRELAY CONFIG OBJECT #############
self.Show()
return
def __init__(self, node, parent, af, routes, routetype, tunobj, vpcpeerid,
spec):
super().__init__(api.ObjectTypes.ROUTE, node)
self.Class = RouteTableObject
if hasattr(spec, 'origin'):
self.SetOrigin(spec.origin)
elif (EzAccessStoreClient[node].IsDeviceOverlayRoutingEnabled()):
self.SetOrigin('discovered')
################# PUBLIC ATTRIBUTES OF ROUTE TABLE OBJECT #####################
if af == utils.IP_VERSION_6:
self.RouteTblId = next(ResmgrClient[node].V6RouteTableIdAllocator)
self.AddrFamily = 'IPV6'
self.NEXTHOP = NexthopClient.GetV6Nexthop(node, parent.VPCId)
else:
self.RouteTblId = next(ResmgrClient[node].V4RouteTableIdAllocator)
self.AddrFamily = 'IPV4'
self.NEXTHOP = NexthopClient.GetV4Nexthop(node, parent.VPCId)
self.GID('RouteTable%d' % self.RouteTblId)
if af == utils.IP_VERSION_4:
parent.V4RouteTableName = self.GID()
self.UUID = utils.PdsUuid(self.RouteTblId, self.ObjType)
self.routes = routes
self.MeterEn = False
for r in routes.values():
if r.MeterEn:
self.MeterEn = True
break
self.TUNNEL = tunobj
self.NhGroup = None
self.DualEcmp = utils.IsDualEcmp(spec)
self.PriorityType = getattr(spec, "priority", None)
if self.TUNNEL:
self.TunnelId = self.TUNNEL.Id
self.TunEncap = tunobj.Encap
else:
self.TunnelId = 0
self.NexthopId = self.NEXTHOP.NexthopId if self.NEXTHOP else 0
self.VPCId = parent.VPCId
self.VPC = parent
self.Label = 'NETWORKING'
self.RouteType = routetype # used for lpm route cases
self.PeerVPCId = vpcpeerid
self.AppPort = ResmgrClient[node].TransportDstPort
self.Mutable = utils.IsUpdateSupported()
##########################################################################
self.DeriveOperInfo(spec)
self.Show()
return
def __init__(self, node, parent, af, rules):
super().__init__(api.ObjectTypes.METER, node)
################# PUBLIC ATTRIBUTES OF METER OBJECT #####################
self.VPCId = parent.VPCId
if af == utils.IP_VERSION_6:
self.MeterId = next(ResmgrClient[node].V6MeterIdAllocator)
self.AddrFamily = 'IPV6'
else:
self.MeterId = next(ResmgrClient[node].V4MeterIdAllocator)
self.AddrFamily = 'IPV4'
self.GID('Meter%d'%self.MeterId)
self.UUID = utils.PdsUuid(self.MeterId, self.ObjType)
self.Rules = rules
self.DeriveOperInfo()
self.Show()
return
def UpdateImplicit(self):
if not utils.IsNetAgentMode():
return
if utils.IsDol() and utils.IsDryRun():
return
if not self.IsOriginImplicitlyCreated():
return
# We need to read info from naples and update the DS
resp = api.client[self.Node].GetHttp(self.ObjType)
if not resp:
return
for ifinst in resp:
if self.Type == topo.InterfaceTypes.L3:
if (not ifinst['spec']['type'] == 'L3'):
continue
riid = ifinst['meta']['name']
if (self.InterfaceId != int(riid[len(riid) - 1])):
continue
elif self.Type == topo.InterfaceTypes.LOOPBACK:
if (not ifinst['spec']['type'] == 'LOOPBACK'):
continue
elif self.Type == topo.InterfaceTypes.ETH:
if (not ifinst['spec']['type'] == 'HOST_PF'):
continue
if (ifinst['status']['if-host-status']['host-ifname'] !=
self.IfName):
continue
else:
continue
# Found matching interface, get basic info
uuid_str = ifinst['meta']['uuid']
self.UUID = utils.PdsUuid(bytes.fromhex(uuid_str.replace('-','')),\
self.ObjType)
# instance found. Store meta info
self.Tenant = ifinst['meta']['tenant']
self.Namespace = ifinst['meta']['namespace']
self.SetIfNameFromAgentData(ifinst['meta']['name'])
# get ifinfo
if 'ip-address' in ifinst['spec']:
self.IpPrefix = ipaddress.ip_network(ifinst['spec']['ip-address'],\
False)
if 'vrf-name' in ifinst['spec']:
self.VrfName = ifinst['spec']['vrf-name']
return
def __init__(self, node, af, rules):
super().__init__(api.ObjectTypes.TAG, node)
################# PUBLIC ATTRIBUTES OF TAG TABLE OBJECT #####################
if af == utils.IP_VERSION_6:
self.TagTblId = next(ResmgrClient[node].V6TagIdAllocator)
self.AddrFamily = 'IPV6'
self.GID('IPv6TagTbl%d' % self.TagTblId)
else:
self.TagTblId = next(ResmgrClient[node].V4TagIdAllocator)
self.AddrFamily = 'IPV4'
self.GID('IPv4TagTbl%d' % self.TagTblId)
self.UUID = utils.PdsUuid(self.TagTblId, self.ObjType)
self.Rules = rules
##########################################################################
self.DeriveOperInfo()
self.Show()
return
def __init__(self, node, device, parent, spec):
super().__init__(api.ObjectTypes.IPSEC_DECRYPT_SA, node)
if (hasattr(spec, 'id')):
self.Id = spec.id
else:
self.Id = next(ResmgrClient[node].IpsecDecryptSAIdAllocator)
self.GID('IpsecDecryptSA%d'%self.Id)
self.UUID = utils.PdsUuid(self.Id, self.ObjType)
self.VPC = parent
self.DEVICE = device
self.Protocol = ipsec_pb2.IPSEC_PROTOCOL_ESP
self.AuthAlgo = ipsec_pb2.AUTHENTICATION_ALGORITHM_AES_GCM
self.AuthKey = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
self.EncAlgo = ipsec_pb2.ENCRYPTION_ALGORITHM_AES_GCM_256
self.EncKey = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
self.Spi = self.Id
self.Salt = 0xbbbbbbbb
def __init__(self, node, spec):
super().__init__(node, spec, topo.InterfaceTypes.L3)
if hasattr(spec, 'origin'):
self.SetOrigin(spec.origin)
self.IpPrefix = None
# In IOTA, get L3 interface IPs from testbed json file if present.
# If not, then we'll use the one in the cfgyml.
if EzAccessStoreClient[node].GetUnderlayIPs():
ifname = None
if self.InterfaceId == 1:
ifname = "Uplink0"
elif self.InterfaceId == 2:
ifname = "Uplink1"
if ifname:
self.IpPrefix = ipaddress.ip_network(EzAccessStoreClient[node].GetUnderlayIp(ifname) + "/" + \
EzAccessStoreClient[node].GetUnderlayMaskLen(ifname), False)
self.IfIpPrefix = ipaddress.ip_interface(EzAccessStoreClient[node].GetUnderlayIp(ifname) + "/" + \
EzAccessStoreClient[node].GetUnderlayMaskLen(ifname))
logger.info(
f"Configuring L3 Interface Id: {self.InterfaceId}"
f"IP Prefix: {self.IpPrefix} IF IP Prefix: {self.IfIpPrefix}"
)
if not self.IpPrefix:
if hasattr(spec, 'ipprefix'):
self.IpPrefix = ipaddress.ip_network(
spec.ipprefix.replace('\\', '/'), False)
self.IfIpPrefix = ipaddress.ip_interface(
spec.ipprefix.replace('\\', '/'))
else:
self.IpPrefix = next(ResmgrClient[node].L3InterfaceIPv4PfxPool)
self.IfIpPrefix = next(
ResmgrClient[node].L3InterfaceIPv4PfxPool)
self.EthIfIdx = getattr(spec, 'ethifidx', -1)
if utils.IsDol():
node_uuid = None
else:
node_uuid = EzAccessStoreClient[node].GetNodeUuid(node)
self.Port = utils.PdsUuid(self.EthIfIdx, node_uuid=node_uuid)
self.PortNum = getattr(spec, 'port', -1)
self.Encap = getattr(spec, 'encap', None)
self.UpdateImplicit()
self.Show()
return
def __init__(self, node, spec):
super().__init__(api.ObjectTypes.BGP, node)
self.BatchUnaware = True
self.Id = next(ResmgrClient[node].BgpIdAllocator)
self.GID("BGP%d" % self.Id)
self.UUID = utils.PdsUuid(self.Id, api.ObjectTypes.BGP)
self.Mutable = utils.IsUpdateSupported()
self.LocalASN = getattr(spec, "localasn", 0)
# If loopback ip exists in testbed json, use that,
# else use from cfgyaml
self.RouterId = utils.GetNodeLoopbackIp(node)
if not self.RouterId:
self.RouterId = ipaddress.ip_address(getattr(spec, "routerid", 0))
self.RouterId = int(self.RouterId)
self.ClusterId = getattr(spec, "clusterid", 0)
self.KeepAliveInterval = topo.KEEPALIVE_INTERVAL
self.HoldTime = topo.HOLD_TIME
self.Show()
return
def __init__(self, node, spec):
super().__init__(api.ObjectTypes.POLICER, node)
if hasattr(spec, 'origin'):
self.SetOrigin(spec.origin)
############### PUBLIC ATTRIBUTES OF POLICER OBJECT ###################
if hasattr(spec, 'id'):
self.PolicerId = spec.id
else:
self.PolicerId = next(ResmgrClient[node].PolicerIdAllocator)
self.type = spec.type
self.direction = spec.direction
self.rate = spec.rate
self.burst = spec.burst
self.token_refresh_rate = 4000
self.GID('Policer%d'%self.PolicerId)
self.UUID = utils.PdsUuid(self.PolicerId, api.ObjectTypes.POLICER)
self.DeriveOperInfo()
self.Show()
return
def __init__(self, node, spec, type):
super().__init__(api.ObjectTypes.INTERFACE, node)
super().SetOrigin(getattr(spec, 'origin', None))
if hasattr(spec, 'iid'):
self.InterfaceId = spec.iid
else:
self.InterfaceId = next(ResmgrClient[node].InterfaceIdAllocator)
self.Type = type
if hasattr(spec, 'uuid'):
self.UUID = spec.uuid
else:
self.UUID = utils.PdsUuid(self.InterfaceId, self.ObjType)
self.IfName = getattr(spec, 'ifname', None)
self.AdminState = getattr(spec, 'ifadminstatus', None)
self.MacAddr = getattr(spec, 'macaddress', None)
self.VPCId = getattr(spec, 'vpcid', None)
self.VrfName = None
self.TxPolicer = None
if hasattr(spec, 'vrfname'):
self.VrfName = spec.vrfname
elif self.VPCId:
self.VrfName = f'Vpc{self.VPCId}'
# Following attributes are valid only for netagent mode
self.Speed = ''
self.MTU = topo.MTU
self.PauseSpec = InterfaceSpec_()
self.PauseSpec.Type = 'DISABLE'
self.PauseSpec.TxPauseEnabled = False
self.PauseSpec.RxPauseEnabled = False
self.Status = InterfaceStatus()
self.Mutable = utils.IsUpdateSupported()
if self.IfName:
self.GID(f'{self.IfName}')
else:
self.GID(
f'{topo.INTFTYPE2STR.get(type)}Interface{self.InterfaceId:08x}'
)
return
def __init__(self,
node,
parent,
prefix,
port_lo,
port_hi,
proto,
addr_type,
threshold=0):
super().__init__(api.ObjectTypes.NAT, node)
self.Id = next(ResmgrClient[node].NatPoolIdAllocator)
self.GID('NatPortBlock%d' % self.Id)
self.UUID = utils.PdsUuid(self.Id, self.ObjType)
self.VPC = parent
self.Prefix = prefix
self.PortLo = port_lo
self.PortHi = port_hi
self.ProtoName = proto
self.ProtoNum = utils.GetIPProtoByName(proto)
self.AddrType = addr_type
self.Threshold = threshold
def UpdateImplicit(self):
if utils.IsDryRun():
return
if (not self.IsOriginImplicitlyCreated()):
return
# We need to read info from naples and update the DS
resp = api.client[self.Node].GetHttp(self.ObjType)
for vpcinst in resp:
if (not (vpcinst['spec']['vrf-type'] == 'INFRA')):
continue
uuid_str = vpcinst['meta']['uuid']
self.UUID = utils.PdsUuid(bytes.fromhex(uuid_str.replace('-','')),\
self.ObjType)
ms = getattr(vpcinst['spec'], 'router-mac', '00:00:00:00:00:00')
self.VirtualRouterMACAddr = objects.MacAddressBase(string=ms)
self.FabricEncap.SetVnid(
int(getattr(vpcinst['spec'], 'vxlan-vni',
'0'))) #assuming vxlan
self.Tenant = vpcinst['meta']['tenant']
self.Namespace = vpcinst['meta']['namespace']
self.GID(vpcinst['meta']['name'])
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 __init__(self, node, spec, peeraf_obj):
super().__init__(api.ObjectTypes.BGP_PEER, node)
self.BatchUnaware = True
self.Id = next(ResmgrClient[node].BgpPeerIdAllocator)
self.UUID = utils.PdsUuid(self.Id, api.ObjectTypes.BGP_PEER)
self.GID("BGPPeer%d" % self.Id)
self.State = getattr(spec, "adminstate", 0)
self.PeerAddr = None
self.LocalAddr = None
self.RemoteASN = None
if hasattr(spec, 'interface'):
# override IPs and RemoteASN from testbed json
self.LocalAddr = utils.GetNodeUnderlayIp(node, spec.interface)
self.PeerAddr = utils.GetNodeUnderlayNexthop(node, spec.interface)
self.RemoteASN = utils.GetNodeUnderlayBGPRemoteASN(
node, spec.interface)
if self.LocalAddr == None:
self.LocalAddr = ipaddress.ip_address(
getattr(spec, "localaddr", None))
if self.PeerAddr == None:
self.PeerAddr = ipaddress.ip_address(
getattr(spec, "peeraddr", None))
if self.RemoteASN == None:
self.RemoteASN = getattr(spec, "remoteasn", 0)
self.SendComm = getattr(spec, "sendcomm", False)
self.SendExtComm = getattr(spec, "sendextcomm", False)
self.RRClient = getattr(spec, "rrclient", None)
self.ConnectRetry = getattr(spec, "connectretry", 0)
self.HoldTime = getattr(spec, "holdtime", 0)
self.KeepAlive = getattr(spec, "keepalive", 0)
self.Password = ""
self.Password = bytes(getattr(spec, "password", ""), 'utf-8')
self.PeerAf = peeraf_obj
self.Show()
return
def __init__(self, node, ipaddr, priority=0, nh_type="", nhid=0, nhgid=0, vpcid=0, \
tunnelid=0, nat_type=None, service_nat_prefix=None, dnat_ip=None, \
classpriority=0, meteren=False):
super().__init__()
self.Id = next(ResmgrClient[node].RouteIdAllocator)
self.UUID = utils.PdsUuid(self.Id, api.ObjectTypes.ROUTE)
self.ipaddr = ipaddr
self.Priority = priority
self.MeterEn = meteren
self.ClassPriority = classpriority
self.NextHopType = nh_type
if self.NextHopType == "vpcpeer":
self.PeerVPCId = vpcid
elif self.NextHopType == "tep":
self.TunnelId = tunnelid
elif self.NextHopType == "nh":
self.NexthopId = nhid
elif self.NextHopType == "nhg":
self.NexthopGroupId = nhgid
if nat_type == "static":
self.SNatAction = topo.NatActionTypes.STATIC
elif nat_type == "napt":
self.SNatAction = topo.NatActionTypes.NAPT
elif nat_type == "service":
self.SNatAction = topo.NatActionTypes.NAPT_SERVICE
else:
self.SNatAction = topo.NatActionTypes.NONE
self.ServiceNatPrefix = None
self.DstNatIp = None
if service_nat_prefix:
svc_nat_prefix = ipaddress.ip_network(
service_nat_prefix.replace('\\', '/'))
if svc_nat_prefix.overlaps(ipaddr):
self.DstNatIp = dnat_ip
self.ServiceNatPrefix = svc_nat_prefix
self.SNatAction = topo.NatActionTypes.NAPT_SERVICE
def __init__(self, node, spec, peerspec):
super().__init__(api.ObjectTypes.BGP_PEER_AF, node)
self.BatchUnaware = True
self.Id = next(ResmgrClient[node].BgpPeerAfIdAllocator)
self.UUID = utils.PdsUuid(self.Id, api.ObjectTypes.BGP_PEER_AF)
self.GID("BGPPeerAf%d"%self.Id)
self.PeerAddr = None
self.LocalAddr = None
if hasattr(peerspec, 'interface'):
# override IPs from testbed json
self.LocalAddr = utils.GetNodeUnderlayIp(node, peerspec.interface)
self.PeerAddr = utils.GetNodeUnderlayNexthop(node, peerspec.interface)
if self.LocalAddr == None:
self.LocalAddr = ipaddress.ip_address(getattr(spec, "localaddr", "0.0.0.0"))
if self.PeerAddr == None:
self.PeerAddr = ipaddress.ip_address(getattr(spec, "peeraddr", "0.0.0.0"))
self.Afi = getattr(spec, "afi", "ipv4")
self.Safi = getattr(spec, "safi", "unicast")
self.AfiStr = f"{self.Afi}-{self.Safi}"
self.NexthopSelf = getattr(spec, "nexthopself", False)
self.DefaultOrig = getattr(spec, "defaultorig", False)
self.Show()
return
def __init__(self, node, dhcpspec):
super().__init__(api.ObjectTypes.DHCP_PROXY, node)
if (hasattr(dhcpspec, 'id')):
self.Id = dhcpspec.id
else:
self.Id = next(ResmgrClient[node].DhcpIdAllocator)
self.GID("Dhcp%d" % self.Id)
self.UUID = utils.PdsUuid(self.Id, self.ObjType)
self.ntpserver = [
ipaddress.IPv4Address(ntpserver)
for ntpserver in dhcpspec.ntpserver
]
self.serverip = ipaddress.IPv4Address(dhcpspec.serverip)
self.routers = ipaddress.IPv4Address(dhcpspec.routers)
self.dnsserver = [
ipaddress.IPv4Address(dnsserver)
for dnsserver in dhcpspec.dnsserver
]
self.domainname = getattr(dhcpspec, 'domainname', None)
self.filename = getattr(dhcpspec, 'filename', None)
self.leasetimeout = getattr(dhcpspec, 'leasetimeout', 3600)
self.interfacemtu = dhcpspec.interfacemtu
self.Mutable = utils.IsUpdateSupported()
return
def __init__(self, node, parent, spec, tunobj, ipversion, count, l2=False):
super().__init__(api.ObjectTypes.RMAPPING, node)
parent.AddChild(self)
if 'origin' in spec:
self.SetOrigin(spec['origin'])
elif (EzAccessStoreClient[node].IsDeviceOverlayRoutingEnabled()):
self.SetOrigin('discovered')
################# PUBLIC ATTRIBUTES OF REMOTE MAPPING OBJECT ##########
if 'id' in spec:
self.MappingId = spec['id']
else:
self.MappingId = next(ResmgrClient[node].RemoteMappingIdAllocator)
self.GID('RemoteMapping%d' % self.MappingId)
self.UUID = utils.PdsUuid(self.MappingId, self.ObjType)
self.SUBNET = parent
if l2:
self.TypeL2 = True
else:
self.TypeL2 = False
if 'rmacaddr' in spec:
self.MACAddr = spec['rmacaddr']
else:
self.MACAddr = ResmgrClient[node].RemoteMappingMacAllocator.get()
self.TunID = tunobj.Id
self.HasDefaultRoute = False
if tunobj.IsWorkload():
self.MplsSlot = next(tunobj.RemoteVnicMplsSlotIdAllocator)
self.Vnid = next(tunobj.RemoteVnicVxlanIdAllocator)
else:
self.MplsSlot = 0
self.Vnid = 0
self.TUNNEL = tunobj
if ipversion == utils.IP_VERSION_6:
self.IPAddr = parent.AllocIPv6Address()
self.AddrFamily = 'IPV6'
if self.SUBNET.V6RouteTable:
self.HasDefaultRoute = self.SUBNET.V6RouteTable.HasDefaultRoute
else:
if 'ripaddr' in spec:
self.IPAddr = ipaddress.IPv4Address(spec['ripaddr'])
else:
self.IPAddr = parent.AllocIPv4Address()
self.AddrFamily = 'IPV4'
if self.SUBNET.V4RouteTable:
self.HasDefaultRoute = self.SUBNET.V4RouteTable.HasDefaultRoute
# Handle tags generation
if spec.get("tag", False):
tag_type = spec.get("tag_type", "overlapping")
no_of_tags = spec.get("no_of_tags", 5)
tags = spec.get("tags", [])
self.GenerateTags(tag_type, no_of_tags, tags)
# Provider IP can be v4 or v6
self.ProviderIPAddr, self.TunFamily = EzAccessStoreClient[
node].GetProviderIPAddr(count)
self.ProviderIP = str(self.ProviderIPAddr) # For testspec
self.Label = 'NETWORKING'
self.FlType = "MAPPING"
self.IP = str(self.IPAddr) # For testspec
self.AppPort = ResmgrClient[node].TransportDstPort
################# PRIVATE ATTRIBUTES OF MAPPING OBJECT #####################
self.DeriveOperInfo()
self.Show()
return
def __init__(self, node, parent, spec, rxmirror, txmirror):
super().__init__(api.ObjectTypes.VNIC, node)
self.Class = VnicObject
parent.AddChild(self)
if hasattr(spec, 'origin'):
self.SetOrigin(spec.origin)
elif (EzAccessStoreClient[node].IsDeviceLearningEnabled()):
self.SetOrigin('discovered')
################# PUBLIC ATTRIBUTES OF VNIC OBJECT #####################
if (hasattr(spec, 'id')):
self.VnicId = spec.id
else:
self.VnicId = next(ResmgrClient[node].VnicIdAllocator)
self.GID('Vnic%d' % self.VnicId)
self.UUID = utils.PdsUuid(self.VnicId, self.ObjType)
self.SUBNET = parent
self.HostIfIdx = None
self.HostIfUuid = None
if utils.IsDol():
node_uuid = None
else:
node_uuid = EzAccessStoreClient[node].GetNodeUuid(node)
hostifidx = getattr(spec, 'hostifidx', None)
if hostifidx:
self.HostIfIdx = utils.LifIfIndex2HostIfIndex(int(hostifidx))
elif len(parent.HostIfIdx) != 0:
self.HostIfIdx = parent.HostIfIdx[0]
if self.HostIfIdx:
self.HostIfUuid = utils.PdsUuid(self.HostIfIdx,
node_uuid=node_uuid)
vmac = getattr(spec, 'vmac', None)
if vmac:
if isinstance(vmac, objects.MacAddressStep):
self.MACAddr = vmac.get()
elif vmac == 'usepfmac':
# used in IOTA for workload interface
hostif = InterfaceClient.FindHostInterface(
node, self.HostIfIdx)
if hostif != None:
self.MACAddr = hostif.GetInterfaceMac()
else:
self.MACAddr = ResmgrClient[node].VnicMacAllocator.get()
else:
self.MACAddr = vmac
else:
self.MACAddr = Resmgr.VnicMacAllocator.get()
self.VnicEncap = base.Encap.ParseFromSpec(
spec, 'vnicencap', 'none',
next(ResmgrClient[node].VnicVlanIdAllocator))
self.MplsSlot = next(ResmgrClient[node].VnicMplsSlotIdAllocator)
if utils.IsDol():
self.Vnid = next(ResmgrClient[node].VxlanIdAllocator)
else:
self.Vnid = parent.FabricEncap.GetValue()
self.SourceGuard = getattr(spec, 'srcguard', False)
self.Primary = getattr(spec, 'primary', False)
self.HostName = self.Node
self.MaxSessions = getattr(spec, 'maxsessions', 0)
self.MeterEn = getattr(spec, 'meteren', False)
self.FlowLearnEn = getattr(spec, 'flowlearnen', True)
self.SwitchVnic = getattr(spec, 'switchvnic', False)
# TODO: clean this host if logic
self.UseHostIf = getattr(spec, 'usehostif', True)
self.RxMirror = rxmirror
self.TxMirror = txmirror
self.V4MeterId = MeterClient.GetV4MeterId(node, parent.VPC.VPCId)
self.V6MeterId = MeterClient.GetV6MeterId(node, parent.VPC.VPCId)
self.IngV4SecurityPolicyIds = []
self.IngV6SecurityPolicyIds = []
self.EgV4SecurityPolicyIds = []
self.EgV6SecurityPolicyIds = []
self.Status = VnicStatus()
self.Stats = VnicStats()
policerid = getattr(spec, 'rxpolicer', 0)
self.RxPolicer = PolicerClient.GetPolicerObject(node, policerid)
policerid = getattr(spec, 'txpolicer', 0)
self.TxPolicer = PolicerClient.GetPolicerObject(node, policerid)
################# PRIVATE ATTRIBUTES OF VNIC OBJECT #####################
vnicPolicySpec = getattr(spec, 'policy', None)
if vnicPolicySpec and utils.IsVnicPolicySupported():
self.IngV4SecurityPolicyIds = utils.GetPolicies(
self, vnicPolicySpec, node, "V4", "ingress", False)
self.IngV6SecurityPolicyIds = utils.GetPolicies(
self, vnicPolicySpec, node, "V6", "ingress", False)
self.EgV4SecurityPolicyIds = utils.GetPolicies(
self, vnicPolicySpec, node, "V4", "egress", False)
self.EgV6SecurityPolicyIds = utils.GetPolicies(
self, vnicPolicySpec, node, "V6", "egress", False)
self.DeriveOperInfo(node)
self.Mutable = True if (utils.IsUpdateSupported()
and self.IsOriginFixed()) else False
self.VnicType = getattr(spec, 'vnictype', None)
self.HasPublicIp = getattr(spec, 'public', False)
remote_routes = getattr(spec, 'remoteroutes', [])
self.RemoteRoutes = []
for remote_route in remote_routes:
self.RemoteRoutes.append(remote_route.replace('\\', '/'))
service_ips = getattr(spec, 'serviceips', [])
self.ServiceIPs = []
for service_ip in service_ips:
self.ServiceIPs.append(service_ip.replace('\\', '/'))
self.Movable = getattr(spec, 'movable', False)
self.DhcpEnabled = getattr(spec, 'dhcpenabled', False)
self.Show()
############### CHILDREN OBJECT GENERATION
# Generate MAPPING configuration
lmapping.client.GenerateObjects(node, self, spec)
return
