Main discovery stitchers

This topic lists the main discovery stitchers.

The following table describes the main discovery stitchers currently included with Network Manager.
Note: This list is subject to change.
Table 1. List of main discovery stitchers
Stitcher Function

Add5GContainment

Called within the BuildContainment.stch stitcher. This stitcher processes the return records from the Collector5G agent to build all 5G-related entities, and n5gInterface entities of various types, such as OAM, N1, N2, N3, N4, N5, N6, N7, N8, N9, N10, N11, N12, N13, N14, N15, N22, N26, N29, N30, N33, N51, NRSectorCarrier, NRCellDU, NRCellCU, trackingArea, gnbDUFunction, gnbCUCPFunction, gnbCUUPFunction, AMFFunction, SMF Function, PCF Function, UPF Function, NEF Function, NRF Function, AUSF Function, AF Function, UDF Function, NSSF Function, antennaFunction, 5G Interface, lteControlPlane, lteDataPlane, and plmn.

The stitcher also builds the appropriate relationship records among these 5G entities and their respective chassis entities. Containment relationship records are built in the workingEntities.containment table. Relationship records of connection and dependency are built in the m_ExtraInfo->m_Members and m_ExtraInfo-> m_Depends member attributes of the appropriate workingEntity record.

AddAEPhysicalIFContainment

Adds physical interfaces to the chassis in the Link Aggregation Group (LAG) containment structure of Juniper devices. This stitcher is called by BuildContainment.stch.

AddBaseNATTags

Updates all the private NAT addresses that have a private address with their public address and adds a tag denoting the private address.

AddBasicContainment

Part of the mechanism for containment stitching. This stitcher inserts containment information into the simple chassis.

AddCardContainment

Adds card objects to the workingEntities.containment table.

AddChassisIPTag

Preprocessing stitcher that fixes the situation where a device on the network has IP access but the management IP address of that device is not in the IP table of the device. Consequently the device would end up in the NCIM physicalChassis table but with no corresponding entry in the NCIM ipEndPoint table. This stitcher fixes this issue by adding a tag, m_ChassisIPNotInIPTable, which is processed by the ModelNcimDb.cfg file to ensure that the ipEndPoint table is populated.

AddClass

For each discovered entity, retrieves class definition data from the Active Object Class manager, ncp_class, and adds this data to the workingEntities database. This stitcher is called by the PostLayerProcessing.stch stitcher.

AddEntityContainment

Adds general entity information to the workingEntities.containment table.

AddGenericEntityContainment

Processes non-Entity MIB data from the CollectorInventory agent and adds processed data to the workingEntities.finalEntity table. This stitcher is called by the BuildContainment stitcher.
V4.2 FixPack 2: AddGeoLocationData Adds geographic data to the m_ExtraInfo field of the topology record of a device from the SysLocation field.

AddGlobalVlans

Builds global Virtual Local Area Network (VLAN) objects using the translations.vlans table.

AddIfStackContainment

Adds interface stack objects to the workingEntities.containment table.

AddLayer3VPNInterfaceDependency

This stitcher determines all PE to core provider router (P) interfaces and P to PE interfaces involved in a VPN. These PE -> P and P ->PE interfaces are added to a dependency list. An event on any of the interfaces in this dependency list causes the system to generate a synthetic MPLS VPN SAE. If an MPLS VPN SAE has already been generated based on an event on any of the interfaces in the members list, then any events in interfaces in the dependency list will be added as related events to that already generated MPLS VPN SAE.

The BGP sessions set up between the PE speakers, and consequently, the VPNs, depend on the PE -> P and P -> PE interfaces for a given VPN and PE pair. The value of adding these interfaces to the VPN dependency list is that it allows the P->PE and PE->P links to be considered in Service Affected Event (SAE) calculations and thus provide a notification that some set of VPNs on a PE are affected by a link problem between PE and P routers.

The diagram below marks with an asterisk the interfaces that the AddLayer3VPNInterfaceDependency stitcher adds as an MPLS VPN SAE dependency. In this diagram, the following conventions are used: [ce] is a customer-edge router; [PE is a provider-edge router; [P] is a provide core router.

[ce]---[PE]*---*[P]---[P]---[P]*---*[PE]---[ce]
                       |*
                       |
                       |*
                      [PE]---[ce]

The results of the stitcher manifest themselves as the m_DependsOn list in the following sample record which shows that an example VPN, VPN_CONTAINER_ACME consists of a number of interfaces in the VPN (m_Members list contains the PE->CE facing interfaces) and subsequently depends on the PE->P/P->PE facing interfaces in the m_DependsOn list.

AddLayer3VPNInterfaceDependency (continued)

 
{
m_Name='VPN_CONTAINER_ACME';
m_Creator='STITCHER CREATED';
m_Description='Logical object for VPN ACME';
m_EntityType=7;
m_ObjectId='VIRTUAL_PRIVATE_NETWORK';
m_HaveAccess=0;
m_IsActive=0;
m_ExtraInfo={
     m_VPNName='ACME';
     m_MPLSVPNType='MPLS IP VPN MESH';
     m_Members=['pe7-cr38.core.eu.test.lab[Vl2]',       'pe7-cr38.core.eu.test.lab[Fa0/3/1]',       'pe8-cr72.core.eu.test.lab[Fa5/0]'];
     m_DependsOn=['pe7-cr38.core.eu.test.lab[Se0/0/0:0.202]',       'pe8-cr72.core.eu.test.lab[Fa0/0]',       'p4-cr28.core.eu.test.lab[Se0/0/1:0.202]',       'p4-cr28.core.eu.test.lab[Gi0/0]'];
             };
}
AddLogicalToIpToBaseName Adds logical information to the translations.ipToBaseName table.
AddLoopbackTag Adds a tag to the ExtraInfo column of the topology database indicating that an interface is a globally addressable loopback interface.
AddLteEntityContainment Called within the BuildContainment.stch stitcher.
This stitcher processes the return records from the CollectorLTE agent and, using this data it builds LTE-related entities within the workingEntities.finalEntity table, as follows:
  • All LTE-related entities, such as enbFunction, mmeFunction, sgwFunction, and so on.
  • All lteIinterface entities of various types, such as S1-U , S1-MME , X2 , S5/S8 ,S11.
The stitcher also builds the appropriate relationship records among these LTE entities and their respective chassis entities.
  • Containment relationship records are built in the workingEntities.containment table.
  • Relationship records of connection and dependency are built in the m_ExtraInfo->m_Members and m_ExtraInfo-> m_Depends member attributes of the appropriate workingEntity record.
AddNoConnectionsToLayer The final topology layer is constructed by merging the topology information from the various layers. If there is a mismatch in connectivity information provided by the different layers, information from the more detailed layer takes precedence.

For example, the Network Layer (layer 3) provides information indicating that a router interface is connected to another router interface. However, information from the more detailed Data Link Layer (layer 2) shows that there is actually a switch between the two router interfaces.

The AddNoConnectionsToLayer is used in cases where it is necessary to remove a connection at one layer but keep the connection at a different layer.
AddSwitchRoutingLinks Adds switch routing data (that assists the RCA plug-in when performing Root Cause Analysis) to the topology database.
AddTechnologyType Optional stitcher called by the PostScratchProcessing.stch stitcher. This stitcher is commented out by default. If enabled, this stitcher creates a technology type variable for each interface object. This variable can then be used to create technology-based Network Views.

The stitcher creates the technology type variable by adding an m_Technology field to the ExtraInfo field within the scratchTopology.entityByName table for each interface object. The m_Technology field is a string, such as Ethernet, ATM. The stitcher contains a large collection of default technology types; more can be added by directly altering the stitcher.

The small processing load associated with activating this stitcher might slow down your discovery slightly.
AddUnconnectedContainment Gives unconnected entities a default containment. Unconnected entities do not have a parent, except for their main node or interface.
AddVlanContainers Uses information in the workingEntities.finalEntity and translations.vlans tables to add VLAN objects to the workingEntities.containment table.
AddWLANContainment Populates workingEntities.containment with WLAN containment data.
AddZTEEntityContainment Invokes either the AddZTEMSeriesEntityContainment.stch stitcher or the AddZTETSeriesEntityContainment.stch stitcher, based on the device series OID.
AddZTEMSeriesEntityContainment Builds up the containment information for the ZTE M series device.
AddZTETSeriesEntityContainment Builds up the containment information for the ZTE T series device.
AdjustedIPLayer Adjusts the IP layer to move the IP layer connectivity on logical interfaces down to the physical interface for some routers.
AdjustVlanInterfaceContainment

V4.2 FixPack 2: A real world example stitcher to show how containment could be adjusted to meet user requirements. This stitcher is not run.
AgentRetProcessing Processes data from the returns table of each table.
AgentRetToInstrumentationCiscoFrameRelay Populates the instrumentation.ciscoFrameRelay table with information from the returns table of the appropriate agent.
AgentRetToInstrumentationFddi Populates the instrumentation.fddi table with information from the returns table of the appropriate agent.
AgentRetToInstrumentationFrameRelay Populates the instrumentation.frameRelay table with information from the returns table of the appropriate agent.
AgentRetToInstrumentationHSRP Populates the instrumentation.hsrp table with information from the returns table of the appropriate agent.
AgentRetToInstrumentationIp Populates the instrumentation.ip table with information from the returns table of the appropriate agent.
AgentRetToInstrumentationName Populates the instrumentation.name table with information from the returns table of the appropriate agent.
AgentRetToInstrumentationPnniPgi Populates the instrumentation.pnniPeerGroup table with information from the returns table of the appropriate agent.
AgentRetToInstrumentationSubnet Populates the instrumentation.subNet table with information from the returns table of the appropriate agent.
AgentRetToInstrumentationVlan Populates the instrumentation.vlan table with information from the returns table of the appropriate agent.

AgentStatus

 This stitcher sends events to the disco.events table about the status of the discovery agents. These events indicate changes in the state of the agent; for example, if it has started, has finished, or has crashed. See also, FinderStatus, CreateStchTimeEvent, and DiscoEventProcessing stitchers.
AnalyseTopology Analyses a connectivity database to find how many connections there are on each interface.
AnalyseTopologySummary This stitcher uses the analysis summary information produced by the AnalyseTopology stitcher to provide an optional deeper topology analysis. This functionality is kept separate from the basic topology analysis as it might affect performance or create topology issues on some networks.

ApplyMainDisplayLabel

Sets the display label for devices in the GUI based on the setting of m_DisplayMode in the disco.config configuration file. Modifies the entities in the workingEntities.finalEntity database table. Called by the BuildFinalEntityTable.stch and RebuildFinalEntityTable.stch stitchers.
ASMAgentRetProcessing Based on MIB variable data retrieved by the ASM stitcher, this stitcher generates a list of ASM sub agents running on a given device. Each ASM subagent running on a device corresponds to a commercial server or database product running on that device. The list of ASMs enables autopartitioning of devices within a network based on the commercial server or database products running on those devices.
ASAMIfStringLayer Uses the ASAM ifDescr format to deduce connectivity.
ASMProcessing Updates entities based on the services running on them.
ASRetProcessing Used in MPLS discoveries where devices in different customer VPNs have identical IP addresses. This stitcher performs the processing necessary to differentiate between these devices and correctly resolve device connectivity. This stitcher is called by the AsAgent agent and works with the ASMap.txt file in NCHOME/precision/etc.
AssocAddressRetProcessing Processes data in the AssocAddress.returns table, sending the device details to the appropriate discovery agent if the device has not already been discovered.
BGPLayer Builds the BGP layer created by BGP agent. In common with other layer stitchers, this stitcher receives input from relevant agents. This input consists of entity records containing local and remote neighbor data fields. The stitcher uses these records to work out the local and remote connections for each entity.
BuildBaseSubnetRegex Takes a given subnet and mask and produces a regular expression to find IP addresses in that subnet.
BuildContainment Calls the following stitchers to add different types of objects to the workingEntities.finalEntity table:
  • AddBasicContainment stitcher, which adds device containment information.
  • AddCardContainment stitcher, which adds card containment information.
  • AddIfStackContainment stitcher, which adds interface stack containment information.
  • AddEntityContainment stitcher, which adds general containment information.
  • NATAddressSpaceContainment stitcher, which adds containment information associated with NAT address spaces.
  • AddVlanContainers stitcher, which adds VLAN containment information.

You can comment out lines in this stitcher as appropriate in order to exclude types of objects that are not needed.

Note: This stitcher also manages collector-discovered devices by accepting data from the CollectorInventory agent.
BuildFinalEntity Builds the records for a single chassis. The BuildFinalEntity stitcher merges data from multiple agents to create the complete definition of an entity. This stitcher is called by the BuildFinalEntityTable stitcher.
BuildFinalEntityTable Uses the entries in the translations.ipToBaseName table to populate the workingEntities.finalEntity table.
BuildHuaweiVSIContainers Creates Virtual Switch Instance (VSI) and Virtual Forwarding Instance (VFI) entities and associated containment for Network Provider Edge devices of Huawei VPNs.
BuildInterfaceName Used to control the naming of interfaces. By default, this stitcher is called by the BuildFinalEntity stitcher.

The default naming strategy for any device interface is as follows:

baseName[<card>[<port>]]

Alternatively Network Manager uses the following default naming convention if the card and port are not valid:

baseName[0[<ifIndex>]]

You can use the BuildInterfaceName stitcher to change the naming convention for an interface in one of the following ways:

  • Specify that you want to use ifName or ifDescr to name the interfaces rather than the ifIndex, card or port information. Using this option, interfaces would have names like the following example:
    baseName[eth0/0]

    In this example eth0 is the ifName of an interface.

    To change the naming convention in this way, change the value of m_UseIfName in the disco.config table.

  • Modify the BuildInterfaceName stitcher directly to specify any interface naming convention.
BuildLayers Activated in the final phase to implement the stitchers that build the layer databases.
BuildMPLSContainers This stitcher calls the BuildVPNContainers and BuildVRAndVRFContainers stitchers. It builds VPN, VR, and VRF containers.
BuildNATTranslation Builds a global translation table for all NAT devices.

BuildNexusVRFContainers

Builds Virtual Route Forwarding (VRF) containers for Cisco Nexus devices.
BuildVPNContainers Creates objects to represent the MPLS VPNs within the system.
BuildVRAndVRFContainers Creates virtual router (VR) and virtual routing and forwarding table (VRF) objects within the system. These objects are useful for displaying MPLS information.
BuildVSIContainers Creates Virtual Switch Instance (VSI) and Virtual Forwarding Instance (VFI) entities. This stitcher also creates logical containment of devices associated with VSIs, VFIs, and CE-PE links.
CabletronLayer Determines connectivity information based on Cabletron data returned by the discovery agents.
CDPLayer Determines connectivity information based on the data returned by the CDP agent.
CheckAndSendNATGatewaysToArpCache Sends the NAT gateways to the ArpCache agent.
CheckForMasterLink Looks for connections lower down the interface stack that take precedence over connections higher up the stack.
CheckIfMgmtAddress Determines if a given IP address is a defined management address.
CheckIndirectResponse Handles indirect ICMP responses due to NAT.
CheckInterfaceStatus Checks the ifOperStatus data and updates the interfaces status where the ifOperStatus is not 1.
CheckManagedProcesses Checks if the processes in the disco.managedProcesses database table have been started, and if they have not been started it attempts to start them.
CheckMultipleIPNoAccess Checks for devices with no access but multiple IP addresses. Creates interface objects for these IP addresses and updates the entity appropriately.
CheckValidVirtual Determines if the given IP address is a valid virtual IP address.
CiscoUCSBladeContainment

V4.2 FixPack 14: Builds blade server containment for Cisco UCS devices.
CiscoSerialInterfaceLayer Creates a new layer called CiscoSerialInterfaceLayer connecting Cisco switches that are connected by serial interfaces. By default, the stitcher removes any connections in the CiscoSerialInterfaceLayer that are duplicated in the IPLayer database, to prevent wrong connectivity. The function to remove mesh connections can be turned on or off by editing a flag in the stitcher.

CiscoVSSContainment

CiscoVSSContainment adds new containment entities, representing the two physical chassis and their respective interfaces and objects, to the workingEntities.finalEntity table.
CMTSLayer Uses the data downloaded by the CMTS agent to build the connection information between cable modem termination systems and the attached cable modem devices.
Collector5GLayer Processes all return records from the Collector5G agent where the variable m_RemoteNbr is not null. Based on information in the m_RemoteNbr variable, the stitcher populates the Collector5GControlLayer.entityByNeighbor OQL table to store all 5G control plane connectivity records. This stitcher also determines the 5G Data plane connectivity from information available in the m_RemoteNbr variable and populates the OQL table Collector5GDataPlaneLayer.entityByNeighbor to store all 5G Data plane connectivity records.
CollectorAddressTranslation This stitcher processes devices discovered using an EMS collector. This stitcher performs the following activities:
  • Ensures that any collector-discovered devices are identified as being the same as the equivalent SNMP-discovered devices.
  • Stores data on the collector associated with each device.
  • Performs other administration tasks related to a collector discovery.
CollectorDetailsRetProcessing This stitcher processes devices discovered using an EMS collector. It processes entries in the returns table of the CollectorDetails agent and sends these entries to other collector discovery agents. The collector discovery agents retrieve detailed device data from the EMS collectors.
CollectorIPLayer This stitcher builds layer 2 connectivity for devices discovered using an EMS collector based on the connection data supplied by the CollectorLayer2 agent.
CollectorL1Layer

Uses the data downloaded by the CollectorLayer1 agent to build Layer 1 connectivity information between optical devices and neighboring optical devices. As long as layer 1 data is present, this stitcher will be invoked.
CollectorLTELayer Processes all return records from the CollectorLTE agent where the variable m_RemoteNbr is not null. Based on information in the m_RemoteNbr variable, the stitcher populates the CollectorLTEControlLayer.entityByNeighbor OQL table to store all LTE control plane connectivity records. For example, the CollectorLTEControlLayer.entityByNeighbor table stores eNodeB to eNodeB connectivity over the X2 interface, and eNodeB to MME connectivity over the S1-MME interface.

This stitcher also determines the LTE user plane connectivity from information available in the m_RemoteNbr variable and populates the OQL table CollectorLTEUserPlaneLayer.entityByNeighbor  to store all LTE user plane connectivity records. For example , the CollectorLTEUserPlaneLayer.entityByNeighbor table stores eNodeB to Serving Gateway connectivity over the S1-U interface, and Serving Gateway to Packet Data Network Gateway  connectivity over the S5/58 interface.
CollectorLTEMMEPool Builds MME pools in the database. It does this by processing LTE-related records in the workingEntities.finalEntity OQL table and identifying unique MME group identifiers. The stitcher then builds an LTE pool object of type MMEPool in the workingEntities.finalEntity table for every unique MME group. For every LTE pool object of type MMEPool, the stitcher builds an m_MMEList collection list attribute. This attribute stores the entity names of all MMEfunction entities in that LTE pool object.
CollectorLTETrackingArea Builds a Tracking Area entity in the workingEntities.finalEntity table for every unique tracking area code. It does this by processing LTE related records in the workingEntities.finalEntity OQL table and identifying unique tracking area codes. For every tracking area entity, the stitcher builds an m_CellList collection list attribute. This attribute stories the entity names of all eUtranCell entities in that tracking area.
CollectorONTOLTLayer Populates the connectivity between OLT and ONT devices for data from collector discovery.
CollectorRANLayer Populates the CollectorRANLayer.entityByNeighbor table with logical RAN connections.
CollectorSwitchLayer This stitcher builds layer 3 connectivity for devices discovered using an EMS collector based on the connection data supplied by the CollectorLayer3 agent.
CreateAndSendTopology Activates the stitchers that create the topology and send the final Scratch Topology to MODEL.
Note: If you are using the embedded relational database, dNCIM, instead of the scratchTopology database, then the dNCIM stitchers are called from this stitcher.

ContainResolvableGenericPortEntities

Creates containment for non-ENTITY MIB- like port entities that have existing corresponding interface records.
ContextAgentRetProcessing This stitcher is used for context-sensitive discovery data flow. It merges the outputs of all the Context agents for each entity. It then inserts the results of this merge into the AssocAddress.despatch table, using the DetailsOrContextRetProcToAgent stitcher.
CreateBGPServices Creates BGP hosted service entities. A hosted service is a service or application running on a specific device. For example, a device might host BGP and OSPF services. Each BGP hosted service entity describes a BGP process on a router. This stitcher is called by the PostScratchProcessing stitcher following the creation of the scratch topology.
CreateBGPTopology Creates connections between BGP speakers. These connections are presented in the Network Views, and correspond to working BGP connections at the time of the discovery. This stitcher can also infer BGP peer routers that Network Manager cannot access. These inferred routers might correspond to BGP autonomous systems outside of your company. This stitcher is called by the PostScratchProcessing stitcher following the creation of the scratch topology.
CreateEmsEntities Creates an element management system (EMS) object for each known EMS in the topology. In a situation where a collector is acting as the EMS itself (that is, the collector does not specify an EMS source) an EMS object is still created to represent the collector. The discovery infers the chassis hosting the EMS if the chassis has not been discovered.
CreateImpactTopology An optional stitcher that can be used to make a copy of the Scratch Topology before it is sent to the Topology Manager, ncp_model.
CreateIPMRouteRoutes Manages the creation of upstream and downstream route entities for the routes downloaded from multicast routers. It also aids MDT resolution.
CreateMPLSPE This stitcher uses BGP information on the customer edge (CE) routers to infer the existence of inaccessible provider edge (PE) routers. The stitcher builds a single object to represent the provider network and each interface represents a BGP peer found on the customer edge device. This allows RCA to be evaluated across the MPLS provider core. Note the stitcher assumes that all out-of-scope BGP peers are members of the provider network. If this is not true then you can configure which specific sections of the network can be considered valid PE IPs and which not. The inferred interfaces will then be limited to those that are within the defined MPLS scope (scope.inferMPLSPEs). Whether an IP is within the MPLS PE scope is determined by the IsInMPLSScope.stch stitcher.
CreateOSPFAreas Creates and names an OSPF area. This stitcher is called by the PostScratchProcessing stitcher following the creation of the scratch topology.
CreateOSPFNetworkLSAPseudoNodes Retrieves data associated with OSPF pseudonodes advertised by designated routers and builds these pseudonodes in the topology. This overcomes the problem of full meshing when representing OSPF area in Network Views and enables connections within OSPF areas to be visualized in a clear, uncluttered manner.

CreateStchTimeEvent

 This stitcher sends events to the disco.events table about progress within the data processing phase. For example, the stitcher generates events to indicate that the discovery process has started building the working entities table, and that the discovery process has started building the containment table. See also, AgentStatus, FinderStatus, and DiscoEventProcessing stitchers.
CreateVRRPCollection Creates collections based on the Virtual Router Redundancy Protocol (VRRP) virtual router ID and associated IP address. Called by the PostScratchProcessing stitcher.
CreateTrunkConnections Modifies the containment model to take account of VLAN trunks.
CreateVlanEntity This stitcher creates a single VLAN entity object by adding VLAN data to the Scratch Topology.
CreateWLANAP Populates WLAN Access Points from WLAN agent data.
CreateWLANAPInterfaces Populates WLAN Access Points interfaces from WLAN agent data.
CreateWLANAPIPLayer Populates the IPLayer tables from WLAN data.
DetailsOrContextRetProcToAgent This stitcher is used as part of the context-sensitive discovery data flow. It is equivalent to DetailsRetProcessing but handles context-sensitive discovery. It processes entities from the details.returns table, and sends the details to the despatch table of the relevant Context agent.
DetailsRetProcessing Processes entities from the details.returns table, and sends the details to the AssocAddress.despatch table.
DetectionFilter Determines whether a given device passes the detection filter and is to be discovered based on the detectionFilter defined in the scope database.

By default, the discovery filters do not filter out the Network Manager server, because this server usually also serves as the polling station for root cause analysis. In order for root cause analysis to work correctly, the polling station, and hence the Network Manager server, must be part of the topology.

If you need to filter out the Network Manager server using the detectionFilter, modify the DetectionFilter stitcher and remove the sections of code indicated by comments that prevent the Network Manager server from being filtered.

DetermineProtocol
Called by other stitchers. This stitcher receives an IP address string as input and based on the contents of the string it determines the associated IP protocol; for example, an input string of:
  • 1.1.1.1 returns a value of 1, corresponding to the IPv4 protocol.
  • 2003:3542:45AB::34 returns a value of 3, corresponding to the IPv6 protocol.
  • any-old-string returns a value of 0, corresponding to unknown protocol.

DiscoEventProcessing

 This stitcher responds to an insert into the disco.events table and creates and sends the appropriate discovery event to the probe for Tivoli Netcool/OMNIbus, nco_p_ncpmonitor process, which then forwards the event to the ObjectServer. You can control whether discovery events are generated by changing the value of the m_CreateStchrEvents field in the disco.config table. See also, AgentStatus, FinderStatus, and CreateStchTimeEvent stitchers.
DiscoShutdown Activated when DISCO is shut down. Calls the RefreshDiscoveryTables stitcher.
DomainQueueCheck V4.2 FixPack 18:Triggers a check of the domain queue in the domainOrder NCIM database table and calls the ncp_domain_discovery_start.pl script to discover the next valid domain in the queue.
ExampleContainment1 An example stitcher that could be modified to configure the containment model.
ExampleContainment2 An example stitcher that could be modified to configure the containment model.
FddiLayer Deduces the FDDI layer topology.
FDPLayer Determines connectivity between Brocade devices, based on data returned by the BrocadeFDPSnmp agent.
Feedback Sends device details back to the Ping finder to seed the discovery again.
FinalPhase Activated in the final phase to implement the final stitchers.
FindAddressSpace Identifies the address space of an IP address.

FinderStatus

 This stitcher sends events to the disco.events table about the status of the finders. For each finder, the stitcher sends an event to indicate changes in the state of the finder; for example, if the finder has started, has finished, or has failed. See also, AgentStatus, CreateStchTimeEvent, and DiscoEventProcessing stitchers.
FindGatewayInterfaces Identifies the gateway interface on NAT translation devices.
FindPhysIpForVirtIp Used in resolution of HSRP issues. Finds the physical IP address corresponding to a virtual HSRP address.
FnderProcToDetailsDesp Processes entries in the finders.processing table, and sends the details to one of the following agents:
  • Details agent, if the device was discovered directly in the network.
  • CollectorDetails agent, if the record is a device discovered using an EMS collector.
FnderRediscoveryProcessing Processes data inserted into the finders.rediscovery table. Commonly it will cause the device or subnet range inserted into the table to be rediscovered, either immediately or indirectly after verification by the ping finder.
FnderRetProcessing Processes entities in the finders.returns table. Checks whether the device is in scope and moves this entry to the finders.processing or finders.pending table, depending on whether the discovery is in blackout state.
FullDiscovery Determines whether a full discovery is to be run.
GetEntityNameByBase For a given base name and interface index (or interface ID), this stitcher resolves the associated entity name.
GetEntityNameByIp For a given address and optional address space, this stitcher resolves the associated entity name. An optional base name can also be specified to restrict the search.
GetBaseNameByIp Returns the base name associated with the supplied IP address, or "" if none is found. If there are multiple matches then the first is used.
HandleIPMRouteDownstream Processes the IPMRoute downstream routing data for the current device. It creates downstream route entities which populate the ipMRouteDownstream NCIM table. It also tracks end points required by the route, which are created later, and which MDT to associate the route with.
HandleIPMRouteUpstream Processes the IPMRoute upstream routing data for the current device. It creates upstream route entities which populate the ipMRouteUpstream NCIM table. It also tracks end points required by the route, which are created later, and which MDT uses to associate the route with.
HubFdbToConnections A precompiled stitcher that processes all of the connections for the Ethernet hubs. It also requires the connectivity information from the Ethernet switch discovery.
IlmiLayer Creates the ILMI (Interim Local Management Interface) topology connections based upon ATM ILMI information.
InitiateNATGatewayDiscovery Seeds the Ping finder with the NAT gateway addresses.

IPAddressNaming

 Causes the system to name devices using the IP address where the data is valid. This stitcher is optional and is off by default.
IPLayer

Creates the IP layer topology connections.

V4.2 FixPack 19:You can configure how data retrieved by the IPLayer stitcher is handled by using parameters in the DiscoConfig.cfg file. Set m_RemoveSlash30NonPTPCon to 1 to ignore all interfaces that are not connected to a slash 30 subnet. Set m_RemoveSlash31NonPTPCon to 1 to ignore all interfaces that are not connected to a slash 31 subnet. The default for both values is 0.
IpToBaseName Populates the translations.ipToBaseName table with information from the AssocAddress agent.
IsForcedRediscovery This stitcher is used to determine if a finder insert is part of a forced rediscovery. Forced rediscovery contrasts with reactive rediscovery, the mode that the Discovery Engine, ncp_disco, adopts after completion of a discovery. In this mode a device is typically only rediscovered if it is new or if the finder insert references a trap, thus suggesting that the entity has been modified.

Forced rediscoveries are started using the Discovery Configuration GUI.
IsInMPLSScope Determines if a given IP address is in the scope of devices considered to be valid CE devices connected to an inaccessible third-party MPLS PE device.
IsInScope Used by other stitchers to check that an entity is within the scope of the discovery (that is, within the scope defined in the scope.zones table).
Prior to checking whether an entity is in scope, the stitcher first determines whether the entity is IP or non-IP:
  • If the entity is an IP-based entity, then scoping is required. The stitcher proceeds to determine if the entity is in scope.
  • If the entity is non-IP, for example a layer 1 optical device, or a radio access network device, then no scoping is performed. The system assumes that the device is in scope.
ISISAgentRetProcessing

V4.2 FixPack 17:Builds the translations.isisChassis and translations.isisArea ISIS lookup tables.
ISISLayer

V4.2 FixPack 17:Builds the ISISLayer.entityByNeighbor table containing ISIS relationship data, which is merged into IPLayer where present.
LAGLayer V4.2 FixPack 13: Creates Layer 2 connectivity between the LAG (Link Aggregation Group) physical member ports, and Layer 3 connectivity between LAGs.

LLDPLayer

Determines connectivity information of remote neighbors based on data returned by the LLDP agent.

Note:

If connectivity is incorrectly displayed for a devices, then this might mean that the LLDP MIB on the network device is incorrectly populated. In some cases the relevant MIB data is incorrectly populated with device model number instead of a unique identifier. In this case the LLDP stitcher is unable to calculate LLDP connectivity correctly.

To verify that this is the problem, for each of the devices that are not connected correctly you must examine the values of the LLDPChassisId field in the LLDP agent's LLDP.returns table. If you determine that the LLDPChassisId field values are not unique, then edit the LLDPLayer stitcher and set the processing method to a value of 2, by changing the following line in the stitcher:
int processingMethod = 2;
MergeLayers Merges the layer topologies.
ModifyIPContainment Modifies the containment of IP interfaces on non-IP forwarding devices so that they are not upwardly connected. This modification is required to trace root cause.
MPLSCE Tries to resolve CE to PE connectivity for VRF interfaces on a PE where the connecting CE has not been identified. It uses layer 3 information to try to find the correct connectivity.
MPLSProcessing

The route target-based MPLS post-layer processing is performed. The MPLSProcessing stitcher calls the RTBasedVPNDiscovery stitcher to perform this processing. The MPLS discovery results in the ability to display an edge view.

This stitcher also performs the background processing required to generate service-affected events.
MPLStackProcessing Ensures that any interfaces that are situated below a VPN supporting interface in the interface stack are marked as being part of the VPNs which flow through the higher interfaces.
NameResolution Finds entities where the name has not been resolved and attempts to resolve the entity name based on the resolved names of the other interfaces of the device.
NamingFromLoopbackDetails Provided there is a LoopBack agent running, this stitcher updates the names in the translations.ipToBaseName table. The management IP address of the device used by the poll policies is set to one of the loopback addresses, if Network Manager has confirmed that it has SNMP access.
NamingViaManagementInterface Looks for management IP addresses from the translations.ipToBaseName and ensures the base address and name of an entity is that of the management server.
NATAddressSpaceContainers Optional stitcher that builds NAT container objects holding devices within a particular address space and creates inserts into the workingEntities.finalEntity table for these NAT container objects. Also builds relevant entries into the workingEntities.containment table.
NATAgentRetProcessing Processes the output from the NAT gateway agents.
NATFnderRetProcessing Performs processing of NAT devices.
NATGatewayRetProcessing Used in discoveries involving NAT gateways where one or more of the management interfaces of the NAT gateway device is in private address space. This stitcher performs the processing necessary to determine whether each management interface is in public or private address space. This stitcher is called by the NATGatewayAgent agent and works with the NATGateways.txt file in NCHOME/precision/etc.
NATIpCheck Resolves an issue where a NAT gateway adds all of its translated IP addresses to its own IP table.
NATTimer Triggers rediscovery of NAT gateways.
NortelPassportLayer Resolves the NortelPassport connectivity discovered by the NortelPassport agent.
OSPFLayer Creates a topology of the OSPF routing within the network. This OSPF routing information is used by the DetermineOSPFDomains stitcher in order to tag devices and interfaces with OSPF domain information.
OspfPostLayerProcessing Performs OSPF processing after the OSPF topology has been calculated, for example, assignment of OSPF domains.
ParseASAMIfString Parses the ASAM Interface description data into its component parts. Called from the ASAMIfStringLayer stitcher.
ParseZyxelIfString Parses the ZYXEL Interface description data into its component parts. Called from the ZyxelIfStringLayer stitcher.
PeerBasedHuaweiVPLSDiscovery Identifies the membership and pseudowire interfaces of middle Network Provider Edge and User-facing Provider Edge devices for each Virtual Switch Instance.
PeerBasedPWDiscovery Used in discovery of enhanced Layer 2 VPNs on an MPLS core network. This stitcher identifies MPLS pseudowire connections retrieved by the Cisco MPLS agents and adds information about these connections to the relevant network entities for viewing in Topoviz. The information is stored as a pseudowire VPN and provides information about the two provider edge (PE) router ends of the pseudowire.
PIMLayer Creates PIM Topology table based on remote neighbor data from PIM supporting agents. The topology data is used to populate the m_PIMAdjacency data, which in turn is used to populate the PIM Topology in NCIM
PingFinderScopeRefresh Tells the Ping Finder to refresh its scope. This stitcher is activated by the Discovery Configuration GUI when you refresh the scope, ensuring that the Ping finder has an up-to-date scope.
PnniLayer Creates the PNNI topology connections provided the connections at both ends have been discovered.
PostLayerProcessing The PostLayerProcessing stitcher runs stitchers that extend the network model. These stitchers use data from the workingEntities.finalEntity and workingEntities.containment database tables and the topology layers that were created recently in the stitching process. They create entities such as MPLS entities, global VLANs, and switch modules. If you create any custom discovery stitchers, you can run them from the PostLayerProcessing stitcher.
PreProcessIGMPEndPointData Creates and populates a temporary table consisting of end-point information for each IGMP-enabled interface and known groups. It also tracks the Multicast groups for which there is IGMP data. This data is used by other IGMP stitchers to create end point and group entities.
PresetLayer Can be used to "preset" undiscoverable connections, if required. This stitcher is not used by default.

This stitcher contains advanced configuration settings. Any changes must be made by certified personnel only.

ProcessQinQData

Processes QinQ data associated with interfaces and builds appropriate containment.
ProcessSwitchModules Identifies which switch modules have their own IP addresses.
ProcRemoteConns Takes a record containing a remote neighbor and processes remote connections if the agent that discovered it supports indirect connections.

ProfilingEndFinal

ProfilingPhase1

ProfilingPhase2

ProfilingPhase3

ProfilingStartFinal

 These stitchers populate the disco.profilingData table, providing data on discovery duration, memory usage, and a broad overview of the results of the discovery. This information is used in the estimation of scaling, and provides you with an overview of discovery performance.
PruneSwitchConnections This stitcher can be used as a way of improving switch connectivity in cases where the switches do not provide full connectivity information. This stitcher is not enabled by default, and must be enabled only on advice from IBM® Support.
PVCNamePath Adds the name of a PVC path to the internal atmPVCs.memberships database table.
PVCProcessedRecord Updates the atmPVCs database to indicate which record is currently being processed.
PVCProcessingRecord Updates the atmPVCs database to indicate which record is currently being processed.
PVCTraceAway Performs PVC tracing.
PVCTraceCrossConnected Performs PVC tracing.
PVCTracePath Performs PVC tracing for a given interface using the other PVC tracing stitchers to trace all the paths through the entire ATM section of the network.
PVCTraceTowards Performs PVC tracing.
RebuildFinalEntityTable This stitcher is very similar to the BuildFinalEntityTable. It also uses the entries in the translations.ipToBaseName table to populate the workingEntities.finalEntity table. The difference is that this stitcher is used in rediscovery mode rather than full discovery mode.
RecreateAndSendTopology This stitcher is very similar to the CreateAndSendTopology.stch. It also activates the stitchers that create the topology and sends the final Scratch Topology to MODEL. The difference is that this stitcher is used in rediscovery mode rather than full discovery mode.
Note: The dNCIM stitchers, the stitchers that interact with the dNCIM database during the discovery process, are called from this stitcher.
ReDoIpToBaseName Refreshes the translations.ipToBaseName table.
RefreshDiscoveryTables Refreshes the discovery database tables.
RefreshLayerDatabase Refreshes a given layer topology database.
RefreshMPLSTEScope Refreshes the scope of the StandardMPLSTE agent.
RefreshMulticastScope Refreshes the scope of the StandardPIM agent.

RelateVirtualDevices

Creates virtual device instances based on Virtual Device Contexts (VDCs) data discovered by the CiscoNexusVdc agent. Links the VDC instances to the physical device through the hostedServices relationship and Hypervisor entity.
RemoveDeviceFromTopology Removes a device from the topology. The first argument of this stitcher must be the base name of the device to be removed.
RemoveInferredCEDuplicates When the existence of a CE router is inferred, this stitcher removes potential duplicate devices from the topology.
RemoveOutOfBandConnectivity Removes connectivity for out of band devices from the fullTopology.entityByNeighbor table.
RemoveWrongConnectionsToTA838 Removes wrong connections from Cisco 7609 and Cisco 3400 to Adtran TA838 devices.
ResetNATMainNodes Resets the IP of devices whose addresses have been translated by NAT from the private IP we use to resolve connectivity back to the public IP for monitoring. This allows the devices to be connected and visualized correctly and also remain accessible for monitoring purposes.
ResolveHSRPIssues Checks for entities that have been discovered through their virtual Hot Standby Routing Protocol (HSRP) address. In that situation, the stitcher updates the discovery agent returns tables and the translations.ipToBaseName to show the correct physical interface.
ResolveHuaweiVPLSConnections Adds Temporary Wire information for middle Network Provider Edge devices to the data that is modeled by the ResolveVPLSConnections stitcher. This stitcher is called by the ResolveVPLSConnections stitcher, if discovery of Huawei VPNs is enabled.
ResolveVPLSConnections Identifies the User-facing Provider Edge interfaces and Pseudowire interfaces of middle Network Provider Edge devices, and far end Network Provider Edges for each VSI. If discovery of Huawei VPNs is not configured, only User-facing Provider Edge interface information is modeled.
ResolveVPLSPortVlans Uses data returned from the CISCO-IETF-PW-ENET MIB to associate pseudo wires with the correct logical interface.
ResolveVRRPAssocAddresses Resolves issues caused by VRRP addresses. In such a situation, the stitcher updates the discovery agent returns tables and the translations.ipToBaseName to show the correct physical interface.
RestartDiscoProcess Calls the restart_disco_process.pl script which stops the currently running discovery process and starts a new instance of it. It takes a single argument and a new full discovery is initiated by the newly started discovery process if the value is set to 1. If set to 0, then a full discovery is not initiated.
Restitcher Re-stitches the topology together.
RTBasedVPNDiscovery Discovers MPLS VPNs based on route target usage. This results in an edge view only which shows the MPLS core network with provider edge (PE) routers for VPNs and VRFs within the scope of the discovery. This view does not show the provider (P) routers within the MPLS core network and associated LSPs (label switched paths) that link these P routers. For each PE router discovered, Network Manager holds information on the route targets imported into and exported from that PE router. This enables you to identify which VPNs use which PE routers.
RTBasedVPNResolution Uses the VRF data pre-processed by the RTBasedVPDiscovery stitcher to resolve VPNs based on Route Target import and export.
ScopeRefresh Informs the finders and agents that require scope information when the scope table has changed.
SendRelationalTopologyToModel Sends the relational topology model network traffic detailing the latest discovery.
SendToCollectors Sends the supplied seed to the Collector finder for rediscover.
SendTopologyToModel Sends the stitched topology to MODEL.
SerialLinkLayer Determines connections from the data returned by the SerialLink agent.
SetOSPFServiceDesignatedStatus Specifies whether or not the router running an OSPF service is a designated router or a backup router.
SONMPLayer Determines connections from the data returned by the SONMP agent.
SubnetConnections Creates subnet entities and inserts into each of the interfaces belonging to the subnet. At layer 3 level the interfaces within a subnet are all considered to be connected, so any connections not already discovered are added to the IP layer database.
SubnetToIPLayer Adds default layer-three containment and/or connectivity.
SRPLayer Builds the SRP layer to hold the containment information discovered by the SRP agent. In common with other layer stitchers, this stitcher receives input from relevant agents. This input consists of entity records containing local and remote neighbor data fields. The stitcher uses these records to work out the local and remote connections for each entity.
SwitchFdbToConnections Copies entries from the Switch agent returns tables to the connections table.
SwitchStpMltProcessing Adds connections for all links in a multi-link trunk to an entityByNeighbor table.
SwitchStpToConnections Builds a new layer based on the SwitchStp connectivity. Processes the data from the STP agent to create correctly named local and remote entity connection records in the stpTopology database.

In common with other layer stitchers, this stitcher receives input from relevant agents. This input consists of entity records containing local and remote neighbor data fields. The stitcher uses these records to work out the local and remote connections for each entity.
SysNameNaming Causes the system to name devices using the SNMP sysName where the data is valid. This is an optional stitcher that is off by default.
TagManagementInterfaces Tags the interface that has the IP address used as the main access IP address for a given entity. This stitcher is used in root cause analysis.
TraceRouteConnectivity Updates the IPLayer.entityByNeighbor table with connectivity information retrieved from the TraceRoute agent returns data.
VRFBasedVPNResolution Uses the VRF data pre-processed by the RTBasedVPDiscovery stitcher to resolve VPNs based on VRF names.
ZTEEnumerationLookup Provides a lookup table of enum type for cards, subcards, slots, NPC, systemId, port, PSU, fan, and so on for AddZTEMSeriesEntityContainment.stch and AddZTETSeriesEntityContainment.stch.
ZyxelIfStringLayer Uses the ZYXEL ifDescr format to deduce connectivity.