8 About Design Studio Extension

This chapter contains examples and explanations on how to extend certain aspects of the Oracle Communications Network Integrity Optical TMF814 CORBA cartridge using Oracle Communications Design Studio. See Network Integrity Developer's Guide for more information. See Network Integrity Concepts for guidelines and best practices for extending cartridges.

The following examples are explained in this section:

Initializing a Custom Object Request Broker
Extending the Discover TMF814 Action to Collect Vendor-Specific Information
Collecting Vendor-Specific Details for CTPs
Adding New Managers
Creating a Custom Equipment Reconciliation Cartridge
Creating a Custom Circuit Reconciliation Cartridge
Customizing the JKLM Value Calculation
Adding New CORBA API Calls
Collecting and Modeling Protection Role Information
Discovering Custom Device or Result Group Names

Initializing a Custom Object Request Broker

This example explains how you can initialize a custom object request broker (ORB) instead of using the default ORB provided by the Network Integrity Cartridge for CORBA (CORBA cartridge).

To initialize a custom ORB:

Open Oracle Communications Design Studio in the Design perspective.
Create a Network Integrity cartridge project.
Make the cartridge project dependent on the CORBA cartridge project.
Create a discovery action that uses the CORBA Abstract Discovery action as a processor.
Create a discovery processor named Custom CORBA Property Initializer and add it after the CORBA Property Initializer processor.

This processor overrides org.omg.CORBA.ORBClass, org.omg.CORBA.ORBSingletonClass, and any additional parameters specific to ORB implementation from the CORBAProperties JavaBean.
Create a discovery processor named Custom ORB Manager to perform custom lookup.
(Optional) Disable NamingContextExt lookup.

This operation may set the Naming Service Connection Flag to false, causing custom lookup to fail.

Extending the Discover TMF814 Action to Collect Vendor-Specific Information

This example explains how to model vendor-specific information. No new common object request broker architecture (CORBA) calls are required to the server because this data is already collected. In this example, managementIP of a managed element (ME) is used as the desired vendor-specific information.

Open Design Studio in the Design perspective.
Create a Network Integrity cartridge project named TMF814SampleVendorExtension.
Make TMF814SampleVendorExtension dependent on the Optical TMF814 CORBA cartridge project and the TMF814_Model cartridge.
Create a discovery action named TMF814 Sample Vendor Extension.
Add the Discover TMF814 action as a processor in the TMF814 Sample Vendor Extension action.
Create a Physical Device specification named customTMF814MEGeneric and add all the same characteristics as tmf814MEGeneric.
Add the managementIP characteristic to customTMF814MEGeneric.
Create a new discovery processor named Custom Device Modeler and insert it after the TMF814 Device Modeler processor. Specify physical device and managed element as input parameters to the processor.

In the Custom Device Modeler processor implementation, add code to populate physical device with managementIP, as shown in the following example:

//Get ME form request
ManagedElement_T me = request.getManagedElement();
PhysicalDevice dev = request.getPhysicalDevice();
 
//Create CustomTMF814MEGeneric spec isntance
CustomTMF814MEGeneric customDevice = new CustomTMF814MEGeneric(dev);
 
//TMFAdditionalInfoHelper is helper calls bundled with this cartridge

String managementIP = TMFAdditionalInfoHelper.getAdditionalInfo (me.additionalInfo, "managementIP");

customDevice.setManagementIP(managementIP);

Build, deploy, and test your cartridge.

Your new Custom Device Modeler processor is run in the order shown in Figure 8-1.

Figure 8-1 Custom Device Modeler Processor Workflow

Description of ''Figure 8-1 Custom Device Modeler Processor Workflow''

Collecting Vendor-Specific Details for CTPs

This example explains how to model vendor-specific details about connection termination points (CTPs). CTP collection is handled differently from other objects because both the collecting and the modeling are handled by the same processor. In this example, vendorState of a CTP is used as the sought vendor-specific information.

Open Design Studio in the Design perspective.
Create a Network Integrity cartridge project named TMF814SampleVendorExtension.
Make TMF814SampleVendorExtension dependent on the Optical TMF814 CORBA cartridge project and the TMF814 Model cartridge.
Create a discovery action named TMF814 Sample Vendor Extension.
Add the Discover TMF814 action as a processor in the TMF814 Sample Vendor Extension action.
In the Studio Projects view, expand the TMF814_Model project.
Expand the Device Interface specifications and copy the tmf814TPInterfaceGeneric specification.
Copy the Device Interface into your project and call it customTMF814TPInterfaceGeneric.
Add a characteristic named vendorState to the customTMF814TPInterfaceGeneric specification.
Change to the Java perspective.

In the TMF814SampleVendorExtension project, add a class that implements the oracle.communications.integrity.tmf814discovery.model.ctp.CTPModelCustomizer interface, as shown in the following example:

/**
* This is a CTP model customizer.
*/
 
package com.vendor.ctp;
import oracle.communications.integrity.tmf814discovery.model.ctp.CTPModelCustomizer;
import oracle.communications.integrity.tmf814discovery.model.ocimtree.LogicalTree;
import oracle.communications.inventory.api.entity.DeviceInterface;
import org.tmforum.mtnm.terminationPoint.TerminationPoint_T;
 
public class CTPModelCustomizerImpl implements CTPModelCustomizer {
 
  /**
  * Overriding customize method.
  * @param inter, modeled DeviceInterface
  * @param tp, TerminationPoint_T tmf object
  * @param tree
  */
 
  public void customize(DeviceInterface inter, TerminationPoint_T tp,  LogicalTree<Object> tree) {
    //1. Get vendor data from termination point.
    //2. Create new specification
    //3. Set vendor specific data to Information Model data.
  }
}

Switch back to the Design Studio perspective.

Add a new discovery processor to the TMF814 Sample Vendor Extension action. This processor should be added after TMF814 Property Customizer. Name the processor Vendor Property Customizer.
For the Vendor Property Customizer processor, set the following context parameters:
- Input: tmf814Properties(oracle.communications.integrity.tmf814discovery.beans.TMF814Properties)
- Output: tmf814Properties(oracle.communications.integrity.tmf814discovery.beans.TMF814Properties)

Create a Java implementation for the Vendor Property Customizer processor by adding code similar to the following example to the processor implementation:

import oracle.communications.integrity.scanCartridges.sdk.ProcessorException;
import oracle.communications.integrity.scanCartridges.sdk.context.DiscoveryProcessorContext;
import oracle.communications.integrity.tmf814discovery.beans.TMF814Properties;
 
public class VendorPropertyCustomizerProcessorImpl implements VendorPropertyCustomizerProcessorInterface {
 
  @Override
  public VendorPropertyCustomizerProcessorResponse invoke(
  DiscoveryProcessorContext context,
  VendorPropertyCustomizerProcessorRequest request) throws ProcessorException {
    //Get properties from request
    TMF814Properties prop = request.getTmf814Properties();
    //Set fully qualified name of above CTP customizer implementation class.
    prop.setCtpModelCustomizerImplClass("com.vendor.ctp.CT PModelCustomizerImpl");
    //Create processor response and set the prop to the response
    VendorPropertyCustomizerProcessorResponse response = new        VendorPropertyCustomizerProcessorResponse();
    response.setTmf814Properties(prop);
    return response;
  }
}

Save and close all files.
Build, deploy, and test your cartridge.

Adding New Managers

To add a new manager:

Open Design Studio in the Design perspective.
Create a Network Integrity cartridge project.
Make the cartridge project dependent on the Optical TMF814 CORBA cartridge project.
Create a discovery action named TMF814 New Manager Extension.
Add the Discover TMF814 action as a processor in the TMF814 New Manager Extension action.
Create a new processor named My Manager Initializer and insert it after the TMF814 Session Manager processor.
For the My Manager Initializer processor, set the following context parameters:
- input: sessionManager(oracle.communications.integrity.tmf814discovery.session.SessionManager)
- output: all managers initialized by the processor

Add the necessary logic to initialize the managers in the generated MyManagerInitilizerImpl class invoke() method.

The following example shows the logic to initialize a new manager named My Manager:

oracle.communications.integrity.tmf814discovery.session.SessionManager sessionManager = request.getSessionManager();
 
//This method in sessionManager tries to create a manager identified by //specified manager name using currently active Ems Session.
 
org.omg.CORBA.Object obj = sessionManager.getManager("My_Manager_Name");
 
//Narrow the generic CORBA object to specific type. 
My_Manager myManaer = My_Manager_IHelper.narrow(obj);

Add all the managers to the response object of the invoke() method.

All the processors following the TMF814 Manager Initializer processor can make use of the newly initialized managers.

Note:
If the new managers are used to collect new objects, you should design corresponding collector, discoverer, and modeler processors.
If you wish to record the results, the discoverer processor needs to extend the TMF814 Device Recorded Initializer and TMF814 Device Recorder Persister processors. The postProcess() method needs to be run after each object is fetched. Update the writeRecord() method Java class for any new objects.

Creating a Custom Equipment Reconciliation Cartridge

You can create a custom equipment reconciliation cartridge that discovers your TMF814 equipment and reconciles it with your inventory system.

To create a custom equipment reconciliation cartridge:

Open Design Studio in the Design perspective.
Create a Network Integrity cartridge project.
Make the cartridge project dependent on the Optical TMF814 CORBA cartridge project.
Create a discovery action named TMF814 Equipment Reconciliation.
Add either the Discover TMF814 action Discover Abstract TMF814 action as a processor in the TMF814 Equipment Reconciliation action.
Create an import action to import your inventory data into Network Integrity.
Create a discrepancy detection action to compare your discovered TMF814 equipment data with your imported inventory equipment data.
Create a discrepancy resolution action to correct discrepancies between your discovered TMF814 equipment data and your imported inventory equipment data.
Build, deploy, and test your cartridge.

See Network Integrity Optical UIM Integration Cartridge Guide for more information if you use Oracle Communications Unified Inventory Management (UIM) as your inventory system.

Creating a Custom Circuit Reconciliation Cartridge

You can create a custom circuit reconciliation cartridge that discovers your TMF814 circuit data and reconciles it with your inventory system.

Some element management systems (EMSs) and network management systems (NMSs) use a device model where the connection termination point (CTP) circuit name is assigned to the userLabel attribute. The following example requires that the EMS or NMS device model use the userLabel attribute of a CTP to hold the circuit name.

To create a custom circuit reconciliation cartridge:

Open Design Studio in the Design perspective.
Create a Network Integrity cartridge project.
Create an import action that does the following:
- Retrieves physical devices
- Retrieves logical devices
- Maps circuit channel assignments by setting the userLabel attribute of the channel subinterface to the circuit name
Create a discrepancy detection action.
(Optional) Extend the discrepancy detection action to allow Network Integrity to search and group the discrepancy results by doing the following:
1. Extend the initializer processor to register a filter against the device interface.
2. Extend the action to run the filter when a discrepancy is detected against an interface. Populate either the Priority or Owner field with the corresponding circuit name.
  
  Tip:
  In the event of an attribute mismatch discrepancy, obtain the circuit name from the compareEntity entity.
  In the event of a missing or extra entity, obtain the circuit name from the childTargetEntity entity.
This action obtains the circuit name and adds it to either the Owner or Priority field in the Network Integrity UI, allowing you to search for and sort by the circuit name.
Create a discrepancy resolution action to handle circuit discrepancies.

Note:
A channel assignment discrepancy may exist due to an incorrect userLabel attribute on the subinterface, or an extra or missing entity on the subinterface.
If the circuit exists in the network but is missing from the inventory system, the discrepancy detection action returns multiple discrepancies. The reconciliation action may need to perform additional operations to correct a missing circuit.
Build, deploy, and test your cartridge.

Customizing the JKLM Value Calculation

You can customize the JKLM value calculation used to model collected cross-connect data.

To customize the JKLM value calculation:

Open Design Studio in the Design perspective.
Create a Network Integrity cartridge project.
Make the cartridge project dependent on the Optical TMF814 CORBA cartridge project.
Create a discovery action that uses the Discovery TMF814 action as a processor.
Create a new processor called XCModelCustomizer and insert it after the TMF814 Property Customizer processor.
For the XCModelCustomizer processor, set the following context parameters:
- input: tmf814Properties(oracle.communications.integrity.tmf814discovery.beans.TMF814Properties)
Develop a new MyXCCustomizer.java Java class by implementing the oracle.communications.integrity.tmf814discovery.model.xc.XCModelCustomizer class with the customize() method.
Develop the customize() method of the MyXCCustomizer.java class to customize the JKLM values for each cross-connect type.
Develop the invoke() method of the MyXCCustomizer.java class to set the new class in the setXCModelCustomizerImplClass class, as shown in the following example:
```
request.getTmf814Properties().setXCModelCustomizerImplClass("MyXCCustomizer")
 
```
Build, deploy and test your cartridge.

The XCModelCustomizer processor is run in the order shown by Figure 8-2. All the processors following the XCModelCustomizer processor can make use of the newly initialized managers.

Figure 8-2 Customized JKLM Value Calculation Processors Workflow

Description of ''Figure 8-2 Customized JKLM Value Calculation Processors Workflow''

Adding New CORBA API Calls

This example explains how arbitrary TMF814 objects that are not collected by default by the Optical TMF814 CORBA cartridge can be collection and modeled.

This example shows the collection and modeling of the GTP_T object, though this is the general approach for any object.

To add new CORBA API calls:

Open Design Studio in the Design perspective.
Create a Network Integrity cartridge project.
Make the cartridge project dependent on the Optical TMF814 CORBA cartridge project.
Create a discovery action with name Discover Custom TMF814 Objects.
Add the Discover TMF814 action as a processor in the Discover Custom TMF814 Objects action.
Create a new discovery processor named TMF814 GTP Collector and insert it before the TMF814 Device Persister processor.
Configure the TMF814 GTP Collector processor to have the following input parameters:
- managedElement(org.tmforum.mtnm.managedElement.ManagedElement_T)
- sessionManager(oracle.communications.integrity.tmf814discovery.session.SessionManager)
- tmf814Properties(oracle.communications.integrity.tmf814discovery.beans.TMF814Properties)
Configure the TMF814 GTP Collector processor to have the following output parameters:
- gtpIterable(oracle.communications.integrity.tmf814discovery.collection.
  
  TMF814DiscoveryIterable< org.tmforum.mtnm.terminationPoint.GTP_T >)

Create the TMF814GTPCollectorProcessorImpl Java class to resemble the following example:

import oracle.communications.integrity.scanCartridges.sdk.ProcessorException;
import oracle.communications.integrity.scanCartridges.sdk.context.DiscoveryProcessorContext;
import oracle.communications.integrity.tmf814discovery.beans.CustomProperties;
import oracle.communications.integrity.tmf814discovery.beans.TMF814Properties;
import oracle.communications.integrity.tmf814discovery.collection.TMF814DiscoveryIterable;
import oracle.communications.integrity.tmf814discovery.discoverers.DiscovererRequest;
import oracle.communications.integrity.tmf814discovery.discoverers.factory.Type;
import oracle.communications.integrity.tmf814discovery.session.SessionManager;
import oracle.communications.sce.integrity.sdk.processor.ProcessorFinalizer;
 
import org.tmforum.mtnm.globaldefs.NameAndStringValue_T;
import org.tmforum.mtnm.terminationPoint.GTP_T;
 
import com.oracle.tmf814discovery.discoverers.GTPDiscoverer;
 
public class TMF814GTPCollectorProcessorImpl implements
TMF814GTPCollectorProcessorInterface, ProcessorFinalizer {
  private GTPDiscoverer discoverer;
 
  @Override
  public TMF814GTPCollectorProcessorResponse invoke(DiscoveryProcessorContext context, TMF814GTPCollectorProcessorRequest request) throws ProcessorException {
 
    //Get SessionManager from request
    SessionManager mgr = request.getSessionManager();
    NameAndStringValue_T[] meName = request.getManagedElement().name;
    TMF814Properties prop = request.getTmf814Properties();
 
    //Create GTPDiscoverer, this has the API calls to get GTP objects from Ems sytem.  
    discoverer =  new GTPDiscoverer(meName, prop, mgr);
 
    DiscovererRequest req= new DiscovererRequest(request.getTmf814Properties(), new CustomProperties());
    TMF814DiscoveryIterable<GTP_T> gtpIterable = new TMF814DiscoveryIterable<GTP_T>(Type.OTHER,req,  discoverer);
 
    //Create iterable for GTP and set to resposne
    TMF814GTPCollectorProcessorResponse res = new TMF814GTPCollectorProcessorResponse();
    res.setGtpIterable(gtpIterable);
    return res;
  }
  @Override
  public void close(boolean arg0) {
    if(discoverer != null){
      discoverer.destroy();
    }
  }
}
 
package com.oracle.tmf814discovery.discoverers;
 
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
 
import oracle.communications.integrity.scanCartridges.sdk.ProcessorException;
import oracle.communications.integrity.tmf814discovery.beans.TMF814Properties;
import oracle.communications.integrity.tmf814discovery.discoverers.TMF814Discoverer;
import oracle.communications.integrity.tmf814discovery.session.SessionManager;
 
import org.tmforum.mtnm.globaldefs.NameAndStringValue_T;
import org.tmforum.mtnm.globaldefs.ProcessingFailureException;
import org.tmforum.mtnm.managedElementManager.ManagedElementMgr_I;
import org.tmforum.mtnm.terminationPoint.GTP_T;
import org.tmforum.mtnm.terminationPoint.GTPiterator_I;
import org.tmforum.mtnm.terminationPoint.GTPiterator_IHolder;
import org.tmforum.mtnm.terminationPoint.GTPlist_THolder;
 
public class GTPDiscoverer implements TMF814Discoverer<GTP_T>{
  protected static final Logger logger = Logger.getLogger(GTPDiscoverer.class.getName());
 
  private int fetchSize;
  private boolean isInitialTMFOperInvoked = false;
  private TMF814Properties tmf814Properties;
  private boolean isEOD = false; //Is End Of Discovery reached.
 
  private NameAndStringValue_T[] meName = null; //parent ME name
  private GTPiterator_I gtpIter = null;
  private ManagedElementMgr_I meMgr;
 
  public GTPDiscoverer(NameAndStringValue_T[] meName, TMF814Properties prop, SessionManager sessionMgr) throws ProcessorException {
    this.tmf814Properties = prop;
    this.meName = meName; 
    this.meMgr = sessionMgr.getManagedElementMgr();
    this.fetchSize = 1000;
  }
 
  /**
  *Every time the discover() method is called, certain number of objects
  *are called. Number of object to return is up the implementation. 
  *Empty iterator is returned indicating that there are no objects
  *to discover/retrieve further.
  */
 
  @Override
  public java.util.Iterator<GTP_T> discover(){
    if(isEOD){
      return Collections.<GTP_T>emptyList().iterator();   
    }
 
    List<GTP_T> result;
    if(! isInitialTMFOperInvoked ) {
      //Initialize GTP iteraror  
      result = fetchInitialElements();
      isInitialTMFOperInvoked = true;
    }else{
      //Once GTP iteraror is initialized, fetchMoreElements is called by the iterable. 
      result = fetchMoreElements();
    }
    if(result.isEmpty() || (getFetchSize() >  result.size()) ){
      isEOD= true;
      destroy();
    }
    return result.iterator();
  }
 
  private int getFetchSize() {
    return fetchSize;
  }
 
  public List<GTP_T> fetchInitialElements() {
    GTPlist_THolder gtpListHolder = new GTPlist_THolder();
    GTPiterator_IHolder gtpIterHolder = new GTPiterator_IHolder();
    try {
      meMgr.getAllGTPs(meName, new short[]{}, 2000, gtpListHolder, gtpIterHolder);
      gtpIter = gtpIterHolder.value;
      if ( gtpListHolder.value != null) {
        return Arrays.<GTP_T>asList(gtpListHolder.value);
      }
    } catch (Exception e) {
      logger.log(Level.SEVERE, "getAllGTP: Error while getting initial gtps", e);
    }
    return Collections.<GTP_T>emptyList();
  }
 
  public List<GTP_T> fetchMoreElements() {
    if(gtpIter != null){
      GTPlist_THolder gtpListHolder = new GTPlist_THolder();
      try {
        gtpIter.next_n(2000, gtpListHolder);
      } catch (ProcessingFailureException e) {
        logger.log(Level.SEVERE, "getAllGTP(next_n): Error while getting more gtps", e);
      }
      if(gtpListHolder.value != null && gtpListHolder.value.length > 0){
        return Arrays.<GTP_T>asList(gtpListHolder.value);
      }
    }
    return Collections.<GTP_T>emptyList();
  }
 
  @Override
  public void destroy() {
    if (gtpIter != null) {
      try{
        gtpIter.destroy();
      }catch (ProcessingFailureException e) {
        logger.log(Level.INFO, "exception while closing gtp iterator", e);
      }
      gtpIter = null;
    }
  }
}

Create a For Each processor after the TMF814 GTP Collector processor.
Specify the following values for the For Each processor:
- In the Select Collection Name field, enter gtpIterable.
- In the Variable Name field, enter gtp.
Within the For Each processor, create a processor named TMF814 GTP Modeler. The TMF814 GTP Modeler processor is responsible for modeling each input GTP_T as an Oracle Communications Information Model object and adding it to the result.
Configure the TMF814 GTP Modeler processor to have the following input parameters:
- gtp(org.tmforum.mtnm.terminationPoint.GTP_T)
Configure the TMF814 GTP Modeler processor to have the following output parameters:
- Modeled Information Model representation of gtp.
Design the TMF814 GTP Modeler processor to find the correct Information Model mapping object for the TMF814 GTP object and add to the result.
Build, deploy, and test your cartridge.

The TMF814 GTP Collector and TMF814 GTP Modeler processors are run in the order shown by Figure 8-3.

Figure 8-3 New CORBA API Calls Processor Workflow

Description of ''Figure 8-3 New CORBA API Calls Processor Workflow''

Collecting and Modeling Protection Role Information

You can extend the Optical TMF814 CORBA cartridge to collect protection role information on cross-connect segments. The protection role status can be made available to other cartridges and follow-on actions.

Because there are no known APIs to obtain protection data from devices, this scenario assumes that the protection role information is available from another source of data, such as in a CVS file.

To collect protection role data on cross-connect segments:

Open Design Studio in the Design perspective.
Create a Network Integrity cartridge project.
Make the cartridge project dependent on the Optical TMF814 CORBA cartridge project.
Create a discovery action that uses the Discover TMF814 action as a processor.
Create a discovery processor called XCModelCustomizer and insert it after the TMF814 Property Customizer processor.
Configure the new processor to have the following input parameter:
- tmf814Properties(oracle.communications.integrity.tmf814discovery.beans.TMF814Properties)
Develop a new MyXCCustomizer.java Java class by implementing the oracle.communications.integrity.tmf814discovery.model.xc.XCModelCustomizer class with the customize() method.

Develop the customize() method of the MyXCCustomizer.java class to populate the protection role for each cross-connect segment, as shown in the example below:

import oracle.communications.integrity.tmf814discovery.model.xc.XCModelCustomizer;
import oracle.communications.inventory.api.entity.InvGroupRef;
import oracle.communications.inventory.api.entity.InventoryGroup;
import oracle.communications.inventory.api.entity.Pipe;
 
import org.tmforum.mtnm.subnetworkConnection.CrossConnect_T;
 
public class MyXCCustomizer implements XCModelCustomizer {
  public static final String PROTECTIONROLE = "protectionRole";
  @Override
  public InventoryGroup customize(CrossConnect_T xc, InventoryGroup ccGroup) {
    Set<InvGroupRef>  segmentRelSet = ccGroup.getMembers();
    for(InvGroupRef ref : segmentRelSet){
      Pipe pipe = ref.getPipe();
    //Get protection information for this segment from a data source. 
      String prorectionRole = /*Get it from external source*/
      pipe.getCharacteristicMap().get(PROTECTIONROLE).setValue(prorectionRole);
    }
    return ccGroup;
  }
}

Develop the invoke() method of the MyXCCustomizer.java class to set the new class in the setXCModelCustomizerImplClass class, as in the following example:
```
request.getTmf814Properties().setXCModelCustomizerImplClass("MyXCCustomizer")
 
```
Build, deploy and test your cartridge.

All the processors following the XCModelCustomizer processor can make use of the information.

Discovering Custom Device or Result Group Names

You can customize the way discovered devices and result groups are named to match how they are named in your inventory system.

To customize how discovered devices and result groups are named:

Open Design Studio in the Design perspective.
Create a Network Integrity cartridge project.
Make the cartridge project dependent on the Optical TMF814 CORBA cartridge project.
Create a new discovery action that uses the Discover TMF814 action as a processor.
Create a discovery processor and insert it after the TMF814 Property Initializer processor.
Set the new processor to use tmfNameToDeviceMap, the output from the TMF814 Property Initializer processor, as its input.
Map each device or result group to tmfNameToDeviceMap, as in the following example:
```
nameToNativeEmsMap1.addMapping(tmf814_Name, custom_Name)
 
```
Where tmf814_Name is the ManagedElement tuple value of ManagedElement_T.name and custom_Name is the custom name of the device.
Build, deploy and test your cartridge.