def __update_nexthops_from_uplink_info(): nodes = api.GetNaplesHostnames() nhClient = config_api.GetObjClient('nexthop') interfaceClient = config_api.GetObjClient('interface') for targetNode in nodes: nexthops = nhClient.GetUnderlayNexthops(targetNode) if len(nexthops) == 0: # Skip updating nexthops if none of them are created via config api.Logger.verbose(f"Skipping nexthops updates as " f"none exist in {targetNode}") continue num = 0 for nh in nexthops: api.Logger.verbose(f"Updating NH {nh} in node {targetNode}") for srcNode in nodes: if targetNode == srcNode: continue peer_intf_mac = interfaceClient.GetNHInterfaceMac(srcNode, 'dsc0') if peer_intf_mac is None: # ignore for dry run api.Logger.error(f"Failed to retrive dsc0 intf mac from " f"{srcNode} - Skip updating NH {nh} " f"in {targetNode}") continue api.Logger.debug(f"Updating NH {nh} with intf-mac " f"{peer_intf_mac} of {srcNode}") nh.underlayMACAddr = peer_intf_mac num += 1 nhClient.UpdateUnderlayObjects(targetNode) api.Logger.debug(f"Updated {num} NH Objects in {targetNode}") return
def ValidateLearnInfo(node=None): if node is None: nodes = api.GetNaplesHostnames() else: nodes = [node] for n in nodes: if not config_api.GetObjClient('vnic').ValidateLearnMACInfo(n): api.Logger.error("MAC validation failed on node %s" % n) return False if not config_api.GetObjClient('lmapping').ValidateLearnIPInfo(n): api.Logger.error("IP validation failed on node %s" % n) return False remote_nodes = api.GetNaplesHostnames() for remote_node in remote_nodes: for n in nodes: if n == remote_node: continue if not config_api.GetObjClient('rmapping').\ ValidateLearnIPWithRMapInfo(remote_node, n): api.Logger.error("RMap validation failed on node %s" % remote_node) return False api.Logger.verbose("MAC and IP validation successful") return True
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 GetLearnIPObjects(node, vnic=None): if vnic is None: return list(config_api.GetObjClient('lmapping').Objects(node)) else: ip_objs = list( filter(lambda x: (x.ObjType == APIObjTypes.LMAPPING and x.IsV4()), vnic.Children)) return ip_objs
def Setup(tc): api.Logger.info(f"API_CRUD_CFG_SCALE : TC for {tc.iterators.objtype}") result = api.types.status.SUCCESS tc.objClient = config_api.GetObjClient(tc.iterators.objtype) tc.Nodes = api.GetNaplesHostnames() tc.ValidateTrigger = 'ReadObjects' if tc.iterators.oper == 'delete': tc.cfgTrigger = 'DeleteObjects' tc.RollbackTrigger = 'RestoreObjects' elif tc.iterators.oper == 'update': tc.cfgTrigger = 'UpdateObjects' tc.RollbackTrigger = 'RollbackUpdateObjects' else: api.Logger.critical(f"Unsupported operation {tc.iterators.oper}") return api.types.status.FAILURE result = verifyDataPortState(tc.Nodes, "up", "up") api.Logger.info(f"API_CRUD_CFG_SCALE : Setup final result {result}") return result
def verify_dhclient_lease(): api.Logger.info("Verifying dhclient leases") if not api.IsSimulation(): req = api.Trigger_CreateExecuteCommandsRequest(serial=True) else: req = api.Trigger_CreateExecuteCommandsRequest(serial=False) for workload in workloads.keys(): cmd = "cat /var/lib/dhclient/dhclient.leases" api.Trigger_AddCommand(req, workload.node_name, workload.workload_name, cmd) resp = api.Trigger(req) dhcp_proxy_client = config_api.GetObjClient("dhcp_proxy") for workload, cmd in zip(workloads.keys(), resp.commands): match = False dhclient_info = dhclient_db(cmd.stdout) dhcp_policies = dhcp_proxy_client.Objects(workload.node_name) if not dhcp_policies: continue for dhcp_policy in dhcp_policies: # Currently we have only one dhcp interface per workload lease = list(dhclient_info.values())[0] prefix = ".".join(str(dhcp_policy.serverip).split(".")[:3]) if prefix in lease["fixed-address"]: for ntpserver in dhcp_policy.ntpserver: assert str(ntpserver) in lease["ntp-servers"] assert str(dhcp_policy.interfacemtu) in lease["interface-mtu"] assert str(dhcp_policy.domainname) in lease["domain-name"] for dnsserver in dhcp_policy.dnsserver: assert str(dnsserver) in lease["domain-name-servers"] assert "255.255.255.0" in lease["subnet-mask"] match = True break assert match return api.types.status.SUCCESS
import iota.harness.api as api import iota.harness.infra.store as store import iota.test.apulu.config.api as config_api import iota.test.apulu.config.bringup_workloads as wl_api import iota.test.utils.arping as arp import iota.test.utils.host as host_utils import iota.harness.infra.utils.parser as parser import iota.test.apulu.utils.connectivity as conn_utils import iota.test.apulu.utils.learn as learn_utils import pdb # DOL import infra.common.objects as objects import apollo.config.utils as utils lmap_client = config_api.GetObjClient('lmapping') rmap_client = config_api.GetObjClient('rmapping') vnic_client = config_api.GetObjClient('vnic') subnet_client = config_api.GetObjClient('subnet') intf_client = config_api.GetObjClient('interface') def __add_ip_to_workloads(workload, ip_addr, secondary=False): """ Adds IP addresses to workload Interface. """ if not api.IsSimulation(): req = api.Trigger_CreateAllParallelCommandsRequest() else: req = api.Trigger_CreateExecuteCommandsRequest(serial=False)
def UpdateConfigAfterUpgrade(tc): api.Logger.info("Updating Host Interfaces after Upgrade") SubnetClient = config_api.GetObjClient('subnet') for n in tc.Nodes: SubnetClient.UpdateHostInterfaces(n)
def __update_host_interfaces(): interfaceClient = config_api.GetObjClient('interface') nodes = api.GetNaplesHostnames() for targetNode in nodes: interfaceClient.PublishHostInterfaces(targetNode) return
#! /usr/bin/python3 import random import iota.harness.api as api import iota.test.apulu.config.api as config_api import iota.test.apulu.config.bringup_workloads as wl_api import iota.test.apulu.utils.learn as learn_utils import iota.test.apulu.utils.misc as misc_utils import iota.test.apulu.config.add_routes as add_routes import iota.test.apulu.utils.move as move_utils import iota.harness.infra.store as store import iota.test.utils.arping as arp intf_client = config_api.GetObjClient('interface') def Setup(tc): # select one of the LearnIP objects from dictionary tc.node = random.choice(api.GetNaplesHostnames()) tc.learn_mac_obj = random.choice(learn_utils.GetLearnMACObjects(tc.node)) tc.subnet = tc.learn_mac_obj.SUBNET if api.IsDryrun(): tc.hostifidx = 'dryrun' else: tc.hostifidx = tc.subnet.HostIfIdx[0] tc.wload = config_api.FindWorkloadByVnic(tc.learn_mac_obj) api.Logger.debug("Chosen subnet %s" % tc.subnet) return api.types.status.SUCCESS def __modify_workload_interface(tc):
def GetLearnMACObjects(node): return list(config_api.GetObjClient('vnic').Objects(node))
#! /usr/bin/python3 import iota.harness.api as api import iota.test.apulu.config.api as config_api import iota.test.apulu.utils.connectivity as conn_utils import iota.test.apulu.utils.move as move_utils import iota.test.apulu.utils.flow as flow_utils import iota.test.apulu.utils.learn_stats as stats_utils import iota.test.apulu.utils.learn as learn_utils import iota.test.apulu.utils.misc as misc_utils from apollo.config.resmgr import client as ResmgrClient from iota.harness.infra.glopts import GlobalOptions subnet_client = config_api.GetObjClient('subnet') def __get_skip(subnet_mov, mac_mov, ip_mov): # TODO: Need topology change to support this. # if "inter-subnet" in subnet_mov and (mac_mov != "same" or ip_mov in ["subset", "all"]) # # return True if "inter-subnet" in subnet_mov: api.Logger.info( f"Skipping subnet_mov: {subnet_mov}, mac_mov: {mac_mov}, ip_mov: {ip_mov}" ) return True else: return False