|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
See:
Description
Packages | |
jain.protocol.ss7 | |
jain.protocol.ss7.oam | |
jain.protocol.ss7.oam.mtp2 | This package contains all of the classes and interfaces that are required to provision and maintain an SS7 stack at the MTP Level 2 layer. |
jain.protocol.ss7.oam.mtp3 | This package contains all of the classes and interfaces that are required to provision and maintain an SS7 stack at the MTP Level 3 layer. |
jain.protocol.ss7.oam.sccp | This package contains all of the classes and interfaces that are required to provision and maintain an SS7 stack at the SCCP layer. |
jain.protocol.ss7.oam.tcap | This package contains all of the classes and interfaces that are required to provision and maintain an SS7 stack at the TCAP layer. |
The JAIN(tm) SS7 OAM API defines the attributes and operations required by a Management Application to provision and manage a JAIN OAM compliant SS7 Stack including the capability to collect statistics and handle alarms emitted by the Stack.
Copyrights
Copyright - 1999 Sun Microsystems, Inc. All rights reserved.
901 San Antonio Road, Palo Alto, California 94043, U.S.A.
This product and related documentation are protected by copyright and distributed under licenses restricting its use, copying, distribution, and decompilation. No part of this product or related documentation may be reproduced in any form by any means without prior written authorization of Sun and its licensors, if any.
RESTRICTED RIGHTS LEGEND: Use, duplication, or disclosure by the United States Government is subject to the restrictions set forth in DFARS 252.227-7013 (c)(1)(ii) and FAR 52.227-19.
The product described in this manual may be protected by one or more U.S. patents, foreign patents, or pending applications.
TRADEMARKS
Sun, the Sun logo, Sun Microsystems, Java, Java Compatible, JavaBeans, Solaris,Write Once, Run Anywhere, JDK, Java Development Kit, and JavaStation are trademarks or registered trademarks of Sun Microsystems, Inc. in the U.S. and certain other countries. UNIX is a registered trademark in the United States and other countries, exclusively licensed through X/Open Company, Ltd. All other product names mentioned herein are the trademarks of their respective owners.
THIS PUBLICATION IS PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
THIS PUBLICATION COULD INCLUDE TECHNICAL INACCURACIES OR TYPOGRAPHICAL ERRORS. CHANGES ARE PERIODICALLY ADDED TO THE INFORMATION HEREIN; THESE CHANGES WILL BE INCORPORATED IN NEW EDITIONS OF THE PUBLICATION. SUN MICROSYSTEMS, INC. MAY MAKE IMPROVEMENTS AND/OR CHANGES IN THE PRODUCT(S) AND/OR THE PROGRAM(S) DESCRIBED IN THIS PUBLICATION AT ANY TIME.
In order to operate, administrate and manage the components of an SS7 network, a network operator needs the ability to set and inspect certain values that characterize the configuration of the network components. Each SS7 stack vendor provides their own proprietary method for setting and inspecting the characteristics of network components. As a result the management of an SS7 node is tied to a vendor's implementation, and so is not portable across all SS7 Stacks.
By defining a standard JavaTM API for managing an SS7 Stack (JAIN OAM),
each SS7 stack vendor can map from the JavaTM methods defined in this API
to their own proprietary management interface (usually a series of C functions).
Assuming that all SS7 stack vendors implement this mapping, any SS7 management
application that uses the JAIN OAM API specification will have the ability
to manage any JAIN compliant SS7 stack. Figure 1 illustrates how the JAIN
OAM API specification allows the development of portable management applications.
Figure 1 - Application portability provided by the JAIN OAM API specification
To effectively manage the resources provided by an SS7 network, it is necessary to monitor and measure the present, and estimate the future performance, utilization and availability of these resources. Proprietary management interfaces typically employ a combination of measurements and alarms to monitor the current status of the SS7 Network. From these results an operator can derive the expected future performance. Measurements (or statistics) are network characteristics that are occasionally or periodically polled by management applications. Alarms, on the other hand, are used to inform management applications that an unexpected change in state has occurred within a network element. While measurement requests are explicitly initiated by management applications, the sending of alarms to management applications is automatically triggered when a particular condition becomes true.
A complete list of the potential fault, real-time, performance, network
administration, accounting and configuration measurements that potentially
can be invoked by a manager application are listed for MTP-L3, SCCP, ISUP
and TCAP protocol layers in the ITU recommendation for monitoring and measuring
SS7 networks (ITU Q.752). These measurements are the raw, primitive data
that potentially can be extracted from an SS7 network and utilized by a
manager application. This is not an exhaustive list of measurements but
rather a collection of what may be considered the measurements most desirable
to collect from a monitoring, control and maintenance point of view. Recommendations
are given for measurements regarding the categorization, unit of measurement,
when and how often collection should be made, and whether or not it is
defined as obligatory from a management point of view to present these
measurements. Although this clearly defined set of statistics is contained
in an international recommendation, most proprietary management interfaces
only support a subset of the obligatory measurements listed.
The JAIN OAM API specification will use the Managed Object (MO) paradigm
for managing the components of an SS7 network. A more detailed explanation
of the managed object model can be found in the OSI systems management
overview (ITU-T Recommendation X.701). A MO is an external representation
of a functional and physical domain of a system. A set of attributes and
valid operations are defined for each MO. The attribute values define an
instance of a MO while the operations may be performed on the MO. By representing
each component in an SS7 network as a managed object it will be possible
to inspect the attributes of that component and modify the component through
the operations it's associated MO supplies.
Figure 2 - JAIN TCAP and JAIN OAM objects and their relationship with an SS7 stack
Figure2 depicts the relationship between JAIN OAM objects, JAIN TCAP objects and an SS7 stack. Each stack vendor shall be responsible for implementing the interaction between the JAIN objects and their SS7 stack. Whether or not two physical stacks are used for high availability shall be hidden from a JAIN application by the stack vendor's implementation.
Each Protocol layer supported has a discreet set of MOs defined. For each MO a set of attributes, allowable operations and possible alarms and statistics (events) that may be emitted by the MO shall be defined.
For each protocol layer a particular MO, hereafter known as a 'Protocol Layer MO', shall be used to create instances of any MOs belonging to that layer. Once an instance of a MO has been created an application may directly modify or inspect the characteristics of the MO using the operations the MO supplies.
An application shall express an interest in MOs belonging to a particular
protocol layer of the SS7 Stack by registering with the appropriate Protocol
Layer MO as an Event Listener. Once registered as a Listener, an application
will be informed of state changes in any of the MOs belonging to that layer
by Events sent to the application from the MOs. Note that in SS7 stack
management systems these Events are frequently known as 'alarms'. For the
purposes of the JAIN OAM API specification Release 1.0, the scope of the
MOs supported will be limited to the MOs belonging to the MTP-2, MTP-3,
SCCP and TCAP layers. An application may register as an Event Listener
for more than one protocol layer. If an application registers as a Listener
for more than one protocol layer, the application shall receive Events
from each layer.
The examples cover the main concepts in SS7 network management and include:
// OBTAIN AN INSTANCE OF THE FACTORY AND SET THE VENDOR PATHNAME
JainSS7Factory ss7Factory = JainSS7Factory.getInstance();
ss7Factory.setPathName(vendorPathname);
try {
// CREATE A LAYER MANAGER FOR EACH PROTOCOL LAYERtcapLayerManager = (TcapLayerManager) ss7Factory.createSS7Object("jain.protocol.ss7.oam.tcap.TcapLayerManagerImpl");sccpLayerManager = (SccpLayerManager) ss7Factory.createSS7Object("jain.protocol.ss7.oam.sccp.SccpLayerManagerImpl");mtp3LayerManager = (Mtp3LayerManager) ss7Factory.createSS7Object("jain.protocol.ss7.oam.mtp3.Mtp3LayerManagerImpl");mtp2LayerManager = (Mtp2LayerManager) ss7Factory.createSS7Object("jain.protocol.ss7.oam.mtp2.Mtp2LayerManagerImpl");
} catch (SS7PeerUnavailableException e) {
System.err.println("Cannot locate a Layer Manager implementation.\n" + e.getMessage());
}
// PROVISION THE MTP2 MANAGED OBJECTS // create arrays to hold the created Managed Objects and their names Mtp2SapMO[] mtp2Saps = new Mtp2SapMO[NUM_MTP2_SAPS]; Mtp2TimerProfileMO[] mtp2TimerProfiles = new Mtp2TimerProfileMO[NUM_MTP2_SAPS]; String mtp2SapNames[] = new String[NUM_MTP2_SAPS]; String mtp2TimerProfileNames[] = new String[NUM_MTP2_SAPS]; // CREATE EACH Mtp2SapMO AND ITS ASSOCIATED Mtp2TimerProfileMO for (int i=0; i < NUM_MTP2_SAPS; i++) { try { // CREATE AN Mtp2SapMO AND SET ITS NAME mtp2Saps[i] = mtp2LayerManager.createMtp2Sap(Mtp2SapMO.PORT_TYPE_DTE); mtp2SapNames[i] = "Mtp2SapMO #" + i; mtp2Saps[i].setName(mtp2SapNames[i]); // CREATE AN Mtp2TimerProfileMO AND SET ITS NAME mtp2TimerProfiles[i] = mtp2LayerManager.createMtp2TimerProfile(); mtp2TimerProfileNames[i] = "Mtp2TimerProfileMO #" +i; mtp2TimerProfiles[i].setName(mtp2TimerProfileNames[i]); // INITIALISE THE TIMERS mtp2TimerProfiles[i].initialiseTimers(); // ASSOCIATE THE Mtp2TimerProfileMO WITH THE Mtp2SapMO mtp2Saps[i].setMtp2TimerProfile(mtp2TimerProfiles[i]); } catch (TooManyInstancesException tooManySaps) { System.err.println("Cannot create more than maximum number of MO instances.\n" +e.getMessage()); } } // end for each Mtp2SapMO // NOW COMMIT THE CHANGES. // NB: // If you want to receive any Alarms or Errors then register as an Mtp2AlarmListener // and an Mtp2ErrorListener before committing the changes. try { mtp2LayerManager.commit(); } catch (CommitException e) { System.err.println("Failed to commit the Mtp2MO changes.\n" + e.getMessage(); }Collecting Statistics:
public class Mtp2StatsCollector implements Mtp2StatisticListener { /** * CONSTRUCTOR: Registers this Mtp2StatsCollector as a Mtp2StatisticListener of * the specified Mtp2LayerManager */ public Mtp2StatsCollector(Mtp2LayerManager layerManager) { // REGISTER AS A STATISTIC LISTENER OF THE LAYER MANAGER try { layerManager.addMtp2StatisticListener(this); } catch (TooManyListenersException e) { System.err.println("Could not register as a Statistic Listener, there are too many listeners already registered"; } catch (SS7ListenerAlreadyRegisteredException e) { System.err.println("This Mtp2StatisticListener is already registered."); } } /** * This method is called by an Mtp2LayerManager when it is emitting an Asynchronous * Mtp2StatisticEvent */ public void processMtp2StatisticEvent(Mtp2StatisticEvent asynchronousStat) { System.out.println("Received an Mtp2StatisticEvent:\n" + asynchronousStat.toString()); if(asynchronousStat.getStatisticType() == Mtp2StatisticEvent.MTP2_NUM_SIF_SIO_RECIEVED) { System.out.println("The number of SIF and SIO octets received is " + asynchronousStat.getStatisticValue()); } } /** * This method collects a single synchronous (one off) statistic */ public void collectStat() { // COLLECT A SYNCHRONOUS STATISTIC Mtp2StaticticEvent synchronousStat = null; try { // collect the number of MSUs discarded due to Signalling Link congestion for the first Mtp2SapMO synchronousStat = mtp2LayerManager.getStatistic(Mtp2StatisticEvent.MTP2_MSU_DISCARD_SL_CONGESTION, Mtp2Saps[0]); // display the value of the returned statistic System.out.println( "The number of MSUs discarded due to Signalling Link congestion for [" + Mtp2Saps[0].getName() + "] is [" + synchronousStat.getStatisticValue() +"]"); } catch (StatisticNotSupportedException e) { System.err.println("The implementation does not support the collection of statistics of type [MTP2_MSU_DISCARD_SL_CONGESTION]"; } } /** * This method starts polling a particular statistic at the specified polling interval. * The polled statistic will be processed by the processMtp2StatisticEvent() method * * @param pollingInterval - the polling interval in milliseconds */ public void pollStatistic() { try { // Start polling the Number of SIF and SIO octets received by the first Mtp2SapMO // with the supplied polling interval. mtp2LayerManager.startPollingStatistic( Mtp2StatisticEvent.MTP2_NUM_SIF_SIO_RECIEVED, Mtp2Saps[0], pollingInterval); } catch (StatisticNotSupportedException e) { System.err.println("The implementation does not support the collection of statistics of type [MTP2_NUM_SIF_SIO_RECIEVED]"; } }
public class Mtp2AlarmAndErrorHandler implements Mtp2ErrorListener, Mtp2AlarmListener { /** * This constructor registers this Mtp2AlarmAndErrorHandler as an * Mtp2AlarmListener and an Mtp2ErrorListener of the MTP2 Managed Objects * @param mtp2LayerManager - the Mtp2LayerManager whose Managed Objects we want to * register with. */ public Mtp2AlarmAndErrorHandler(Mtp2LayerManager mtp2LayerManager){ // register as an Error Listener of all the Mtp2SapMOs Mtp2SapMO[] allMtp2Saps = mtp2LayerManager.getAllMtp2Saps(); for(i =0; i< allMtp2Saps.length; i++) { allMtp2Saps[i].addMtp2ErrorListener(this); } // use the OamUtility class to register as an Mtp2AlarmListener // with every Mtp2ManagedObject OamUtility.addAlarmListener(mtp2LayerManager, this); } /** * This method is called whenever an MTP2 Error Event is emitted by the * Mtp2LayerManager */ public void processMtp2ErrorEvent(Mtp2ErrorEvent error) { if(error.getErrorType() == Mtp2ErrorEvent.NON_OAM_RELATED_ERROR) { System.out.println("Received a non-OAM related error:\n" +error.getNonOamErrorMessage()); } else { System.out.println("Received an error from the MTP2 Layer of type [" +error.getErrorType() +"]" } } /** * This method is called whenever an MTP2 Alarm Event is emitted by the * Mtp2LayeManager */ public void processMtp2AlarmEvent(Mtp2AlarmEvent alarm) { if(alarm.getAlarmType() == Mtp2AlarmEvent.ALARM_MO_DELETED) { System.out.println("One of the Managed Objects has been deleted"); } else if (alarm.getAlarmType() == Mtp2AlarmEvent.ALARM_TIMER_EXPIRED) { System.out.println( "The MTP2 Timer [" +alarm.getTimerId() +"] has expired."); } } }Reading the Current Configuration:
The following piece of code can be used to read the current configuration of the MTP3 layer. This functionality can be used to determine the current configuration when an OamLayerManager is created for a protocol layer that is already configured.
// OBTAIN AN INSTANCE OF THE FACTORY AND SET THE VENDOR PATHNAME
JainSS7Factory ss7Factory = JainSS7Factory.getInstance();
ss7Factory.setPathName(vendorPathname);
try {
// CREATE A MTP3 LAYER MANAGER
mtp3LayerManager = (Mtp3LayerManager) ss7Factory.createSS7Object("jain.protocol.ss7.oam.mtp3.Mtp3LayerManagerImpl");
} catch (SS7PeerUnavailableException e) {
System.err.println("Cannot locate the MTP3 Layer Manager implementation.\n" + e.getMessage());
}
// At this stage although there are links configured, this method will not return the LinkMOs // corresponding to already configured signalling linkss as the current configuration has not // yet been read.
LinkMO[] allLinks = layerManager.getAllLinks();
System.out.println("Before reading the configuration, the current number of LinkMOs is " + allLinks.length);
try {
layerManager.readCurrentConfiguration();
} catch (ReadConfigurationException e) {
System.err.println("Unable to read the current MTP3 configuration");
};
// after reading the current configuration, we should have all of the LinkMOs corresponding to // the configured signalling links returned to us.
LinkMO[] allLinks = layerManager.getAllLinks();
System.out.println("After reading the configuration, the current number of Links is " + allLinks.length);Removing Managed Objects:
public void deleteAllMtp2ManagedObjects(Mtp2LayerManager manager) {
// DELETE ALL MTP2 TIMER PROFILES
Mtp2TimerProfileMO[] timerProfiles = manager.getAllMtp2TimerProfiles(); for (int i = 0; i < timerProfiles.length; i++) { manager.deleteMtp2TimerProfile(timerProfiles[i]); }
// DELETE ALL MTP2 SAPS
Mtp2SapMO[] mtp2Saps = manager.getAllMtp2Saps();
for (int x = 0; x < mtp2Saps.length; x++) {
manager.deleteMtp2Sap(mtp2Saps[x]);
}
// WE MUST FIRST COMMIT THE OPERATIONS BEFORE THEY WILL TAKE EFFECT // NB: // If you want to receive any MO_DELETED Alarms then register as an Mtp2AlarmListener // before committing the changes. try { manager.commit(); } catch (CommitException e) { System.err.println("Failed to commit the Mtp2MO changes.\n" + e.getMessage(); }
}
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |