Java Patterns for MPLS Network Management, Part 1

Like this article? We recommend

Design Patterns in Java, 2nd Edition

Learn More Buy

Like this article? We recommend

Like this article? We recommend 

Design Patterns in Java, 2nd Edition

Learn More Buy

Java Patterns and MPLS Network Management

The two Java patterns I want to describe are AbstractFactory and Prototype.

Abstract Factory

The Abstract Factory pattern is used for defining and creating objects such as the LSPs and EROs in Figure 1. Listing 1 (VirtualCircuitFactory.java) illustrates the use of this pattern as an interface with two methods:

• createVirtualCircuit(): Creates a generic virtual circuit.
• createTrafficEngineering(): Creates TE data for the generic virtual circuit.

The VirtualCircuitFactory interface is implemented by LSPFactory.java (Listing 2), which uses the VirtualCircuit.java (Listing 3) abstract class. VirtualCircuit provides network node endpoints for a generic virtual circuit type (the latter can be ATM, FR, MPLS, etc.). LSPFactory specializes the behavior of VirtualCircuit by adding MPLS-specific attributes. Similarly, to model ATM or FR virtual circuits, you just have to add an associated factory class. The two methods in LSPFactory returns two objects:

• LSP()
• LSPTrafficEngineering()

The LSP class (Listing 4) extends the VirtualCircuit class with the addition of LSP-specific attributes, such as MIB index variables. The latter are used to distinguish between the other LSPs that originate on the same network node—i.e., LSP 1 and LSP 2. It’s important to note that there are many more attributes associated with an LSP than those indicated here. The MPLS-TE MIB [2] illustrates the relevant attributes in the mplsTunnelTable object. The LSP class sits at the bottom of our pattern hierarchy and provides us with Java code for manipulating LSPs.

As noted above, an important attribute of an LSP is TE data—i.e., the path taken by the LSP as it traverses the network. This is modelled by the class LSPTrafficEngineering.java (Listing 5) that provides type and route data.

The above classes are combined in RunPattern.java (6) where the virtual circuit factory is used to instantiate an LSP object. Next, the attributes of the LSP are set—in this case, the two MIB index values (1 and 0) and the originating and terminating node details (LER A-10.1.1.1 and LER B-20.1.1.1). The traffic engineering details are then set up for this LSP using the setRouteData() method. Listing 1 illustrates the executed pattern.

Listing 1 AbstractFactory in Operation—LSP and TE Creation

E:\Abstract Factory>java RunPattern

LSP creation example using the AbstractFactory pattern

 (I use the VirtualCircuit and TrafficEngineering classes when writing
 almost all of the code. This allows you to produce a
 generic framework, and plug in Concrete Factories
 and Products to specialize the behavior of the code.
 The LSP and LSPTrafficEngineering classes provide
 the required behavior specialization in this case.)

Creating LSP and TrafficEngineering objects:
LSP Data (MIB index values):
1 0 LER A-10.1.1.1 LER B-20.1.1.1

STANDARD MPLS

LSP Traffic Engineering Data: (please see Figure 1 for the details)
Traffic Engineering Data is typically defined in terms of IP addresses.
We just use node and interface names for simplicity.
LER A(d) + LSR A(e,f) + LSR B(g,h) + LER B(i)
ERO - Explicit

Once these objects have been created (e.g., under the direction of a GUI client user), they can be written to a database or they can be provisioned to the network (such as Figure 1). These require access to specific backend technology—e.g., JDBC for the database and JDMK for SNMP.

Listings 2 through 7 illustrate the main elements of the Java code. Listing 2 illustrates the factory class for all virtual circuit types.

Listing 2 VirtualCircuitFactory.java

public interface VirtualCircuitFactory{
    public VirtualCircuit createVirtualCircuit();
    public TrafficEngineering createTrafficEngineering();
    //public QualityOfService createQualityOfService();
}

Listing 3 illustrates the specialized LSPFactory class.

Listing 3 LSPFactory.java

public class LSPFactory implements VirtualCircuitFactory{
  public VirtualCircuit createVirtualCircuit(){
    return new LSP();
  }

  public TrafficEngineering createTrafficEngineering(){
    return new LSPTrafficEngineering();
  }
}

Listing 4 illustrates the generic virtual circuit class.

Listing 4 VirtualCircuit.java

public abstract class VirtualCircuit {
    private String origNode;
    private String termNode;

    public static final String EOL_STRING =
        System.getProperty("line.separator");
    public static final String SPACE = " ";

    public String getOrigNode(){ return origNode; }
    public String getTermNode(){ return termNode; }

    public abstract String getVirtualCircuitType();

    public String getVCEndpoints(){
        return origNode + SPACE + termNode;
    }

    public void setOrigNode(String newOrigNode){ origNode = newOrigNode; }
    public void setTermNode(String newTermNode){ termNode = newTermNode; }
}

Listing 5 illustrates the specialized VirtualCircuit class: the LSP class.

Listing 5 LSP.java

public class LSP extends VirtualCircuit {
  private int index;
  private int instanceIndex;

  // Add many more items here as per the MPLS MIB tunnel table

  private static final String TYPE = "STANDARD MPLS";
  private static final String COMMA = ",";

  public int getIndexValue(){ return index; }
  public int getInstanceIndexValue(){ return instanceIndex; }
  public String getVirtualCircuitType(){ return TYPE; }

  public void setIndexValue(int newIndex){ index = newIndex; }
  public void setInstanceIndexValue(int newInstanceIndex){
      instanceIndex = newInstanceIndex; }

  public String getLSPDetails(){
    return getIndexValue() + SPACE +
    getInstanceIndexValue() + SPACE +
    getVCEndpoints() + EOL_STRING +
    getVirtualCircuitType() + EOL_STRING;
  }
}

Listing 6 illustrates the additional traffic engineering detail for the LSP class.

Listing 6 LSPTrafficEngineering.java

public abstract class TrafficEngineering{
    private String routeData;
    public abstract String getTrafficEngineeringType();

    public String getRouteData(){ return routeData; }

    public void setRouteData(String newRouteData){routeData = newRouteData; }
}

Listing 7 illustrates the RunPattern class that executes the pattern.

Listing 7 RunPattern.java

    System.out.println("Creating LSP and TrafficEngineering objects:");

    VirtualCircuitFactory lspFactory = new LSPFactory();
    LSP lsp = (LSP)lspFactory.createVirtualCircuit();

    lsp.setIndexValue(1);
    lsp.setInstanceIndexValue(0);
    lsp.setOrigNode("LER A-10.1.1.1");
    lsp.setTermNode("LER B-20.1.1.1");

    TrafficEngineering lspTrafficEngineering = lspFactory.createTrafficEngineering();
    lspTrafficEngineering.setRouteData("LER A(d) + LSR A(e,f) + LSR B(g,h) + LER B(i)");

LSP 1 in Figure 1 could be created using this pattern. The Prototype pattern that we discuss next could in turn be used to create LSP 2.

The Prototype Pattern

A common NMS requirement is the ability to clone an existing object. Very often, NMS objects require a lot of error-prone, manual configuration; in many cases, dozens of variables must be set. It’s similar to setting up a new PC! An example is when you want to create a backup LSP to protect an existing LSP or if you want to create a new LSP that is similar to an existing one as we saw in Figure 1. Cloning provides the ability to re-use the fruits of your labors!

The Prototype pattern gives us a convenient way of providing cloning. I’ve added to the AbstractFactory example to show how this can be done. Firstly, I provide the Copyable() interface, which has a single method copy(). The copy() method must be implemented by LSP.java. In addition, I added a default constructor and a non-default constructor to LSP.java. The non-default constructor is called when a client wants to clone an LSP by calling the copy() method.

Listing 8 illustrates the executed pattern.

Listing 8 The Prototype in Operation—LSP and TE Creation Followed by Cloning

E:\prototype>java RunPattern
 Example of the Prototype pattern

 I use the AbstractFactory to create an LSP.
 This is then cloned to create a copy.
 The new LSP can then be modified as required.

Creating LSP and TrafficEngineering objects:
LSP Data:
1 0 LER A-10.1.1.1 LER B-20.1.1.1
STANDARD MPLS

LSP Traffic Engineering Data: (please see Figure 1 for the details)
Traffic Engineering Data is typically defined in terms of IP addresses.
We just use node and interface names for simplicity.
LSP Traffic Engineering Data:
LER A(d) + LSR A(e,f) + LSR B(g,h) + LER B(i)
ERO - Explicit

Creating second LSP using the clone() method.
Second LSP created.
1 0 LER A-10.1.1.1 LER B-20.1.1.1
STANDARD MPLS

The following files include the required changes.

Listing 9 Copyable.java

public interface Copyable{
  public Object copy();
}

Listing 10 illustrates the LSP class.

Listing 10 LSP.java

public class LSP extends VirtualCircuit {
  private int index;
  private int instanceIndex;

  // Add many more items here as per the MPLS MIB tunnel table

  private static final String TYPE = "STANDARD MPLS";
  private static final String COMMA = ",";

  public LSP(){
  }

  public LSP(int initIndex, int initInstanceIndex,
    String newOrigNode, String newTermNode){
      index = initIndex;
      instanceIndex = initInstanceIndex;

      super.setOrigNode(newOrigNode);
      super.setTermNode(newTermNode);
  }

  public int getIndexValue(){ return index; }
  public int getInstanceIndexValue(){ return instanceIndex; }
  public String getVirtualCircuitType(){ return TYPE; }

  public void setIndexValue(int newIndex){ index = newIndex; }
  public void setInstanceIndexValue(int newInstanceIndex){
      instanceIndex = newInstanceIndex; }

  public Object copy(){
    return new LSP(index, instanceIndex,
    super.getOrigNode(), super.getTermNode());
  }

  public String getLSPDetails(){
    return getIndexValue() + SPACE +
    getInstanceIndexValue() + SPACE +
    getVCEndpoints() + EOL_STRING +
    getVirtualCircuitType() + EOL_STRING;
  }
}

Listing 11 illustrates the RunPattern class to execute the pattern.

Listing 11 RunPattern.java

    System.out.println("Creating LSP and TrafficEngineering objects:");

    VirtualCircuitFactory lspFactory = new LSPFactory();
    LSP lsp = (LSP)lspFactory.createVirtualCircuit();

    lsp.setIndexValue(1);
    lsp.setInstanceIndexValue(0);
    lsp.setOrigNode("LER A-10.1.1.1");
    lsp.setTermNode("LER B-20.1.1.1");

    TrafficEngineering lspTrafficEngineering = lspFactory.createTrafficEngineering();

    lspTrafficEngineering.setRouteData("LER A(d) + LSR A(e,f) + LSR B(g,h) + LER B(i)");

The Prototype pattern makes it easy to create new LSPs based on existing ones. Clearly, this applies to other varieties of managed objects as well.