snmpmanager.java

this is example use EJB with jboss.

/*
 * Copyright(C) 2008, NTT AT Co., Ltd.
 * Project: AWGView
 *
 * Notes:
 *  N/A
 *
 * Record of change:
 * Date         Version      Name       Content
 * 2008/12/15   1.0          TriNT      First create       
 */
package jp.co.ntt.awgview.server.snmp;

import java.io.IOException;

import jp.co.ntt.awgview.server.common.AlarmLevel;
import jp.co.ntt.awgview.server.common.LogWriter;
import jp.co.ntt.awgview.server.common.Setting;
import jp.co.ntt.awgview.server.common.Utils;
import jp.co.ntt.awgview.server.constant.Constants;
import jp.co.ntt.awgview.server.constant.AWGNEConstants;
import jp.co.ntt.awgview.server.dao.DBFunctionsManager;
import jp.co.ntt.awgview.server.dao.JResult;
import jp.co.ntt.awgview.server.jms.TrapPublisher;
import jp.co.ntt.awgview.server.vo.BlockVO;
import jp.co.ntt.awgview.server.vo.NodeVO;
import jp.co.ntt.awgview.server.vo.OperationVO;
import jp.co.ntt.awgview.server.vo.SnmpVO;
import jp.co.ntt.awgview.server.vo.TrapVO;

import org.snmp4j.CommandResponder;
import org.snmp4j.CommandResponderEvent;
import org.snmp4j.CommunityTarget;
import org.snmp4j.MessageDispatcher;
import org.snmp4j.MessageDispatcherImpl;
import org.snmp4j.MessageException;
import org.snmp4j.PDU;
import org.snmp4j.PDUv1;
import org.snmp4j.ScopedPDU;
import org.snmp4j.Snmp;
import org.snmp4j.Target;
import org.snmp4j.event.ResponseEvent;
import org.snmp4j.event.ResponseListener;
import org.snmp4j.mp.CounterSupport;
import org.snmp4j.mp.DefaultCounterListener;

import org.snmp4j.mp.MPv1;
import org.snmp4j.mp.MPv2c;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.mp.StateReference;
import org.snmp4j.mp.StatusInformation;

import org.snmp4j.security.Priv3DES;
import org.snmp4j.security.SecurityProtocols;
import org.snmp4j.smi.Address;
import org.snmp4j.smi.GenericAddress;
import org.snmp4j.smi.Integer32;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.TcpAddress;
import org.snmp4j.smi.UdpAddress;
import org.snmp4j.smi.VariableBinding;

import org.snmp4j.transport.AbstractTransportMapping;
import org.snmp4j.transport.DefaultTcpTransportMapping;
import org.snmp4j.transport.DefaultUdpTransportMapping;

import org.snmp4j.util.MultiThreadedMessageDispatcher;
import org.snmp4j.util.PDUFactory;
import org.snmp4j.util.ThreadPool;

/**
 * Class name : SnmpManager <BR>
 * Package : jp.co.ntt_at.awgview.server.snmp <BR>
 * 
 * Description : This class provides functions to send SNMP Command and receive
 * SNMP data. <BR>
 * A SNMP Manager that is supposed to do the following: <BR> 
 * (1) Send SNMP commands to SNMP-Agents, and handle their response.  <BR>
 * (2) Receive SNMP traps from SNMP-Agents. <BR>
 * 
 * @author : AI&T
 * @version : 1.0
 */
public class SnmpManager implements CommandResponder, PDUFactory, ResponseListener {		
	/** Number dispathcher thread*/
	private static final int NUM_DISPATCHER_THREAD = 10;
	/** Defined for each AWG-NE port.*/
	private static final int START_PORT_NUM = 3000;
	/** Defined for time sleep waiting*/
	private static final int STEP_WAIT = 1;
	/** The UdpAddress represents UDP/IP transport addresses */
	private static final String UDP_ADDRESS = "0.0.0.0/162";
	/** Dispatcher pool name*/
	private static final String DISPATCHER_POOL = "DispatcherPool";
	/** Community type*/
	private static final String COMMUNITY_PUBLIC = Setting.getSNMPCommunity();
	/** The SMI type OCTET STRING*/
	private OctetString community = new OctetString(COMMUNITY_PUBLIC);
	/** PDUv1 represents SNMPv1 PDUs*/
	private PDUv1 v1TrapPDU = new PDUv1();
	/** SNMP Retry*/
	private int retries = Setting.getSNMPRetry();
	/** Snmp Time out*/
	private int timeout = Setting.getSNMPTimeOut();
	/** PDU Type*/
	private int pduType = PDU.TRAP;
	/** The address value from the supplied String*/
	private Address address = null;
	/** Snmp object provides functions to send and receive SNMP PDUs. */
	private Snmp snmpManager = null;
	/** TrapPublisher object provides public trap to client using JMS Topic*/
	private TrapPublisher trapPublisher = null;
	/** This class provide methods necessary in order to communicate with the database.*/
	private static DBFunctionsManager dbFunctionManager = null;
	/** Keep the Snmp response form AWG-NE*/
	private static ResultVOHelper dataVOHelper = new ResultVOHelper();
	/** Snmp object provides functions to send and receive SNMP PDUs. */
	private Snmp snmpTrap = null;	
	/** Number trap receive from AGN-NE to debug*/
	private long countTrap = 0;
	/** Ip address of AWG-NE*/
	private String ipAddress = "Unknow";
	/** Defined for each AWG-NE uses only 1 port.*/
	private static int snmpPort = START_PORT_NUM;
	/** ThreadPool object provides a pool of a fixed number of threads that are capable to execute tasks*/
	private ThreadPool trapThreadPool = null;
	
	/**
	 * SnmpManager constructor
	 */
	public SnmpManager(boolean isInitTrap) {
		if (isInitTrap){
			trapPublisher = new TrapPublisher();		
			if (dbFunctionManager == null) {
				dbFunctionManager = new DBFunctionsManager();
				LogWriter.getSNMPLogger().debug("Created Database Manager Object");
			}	
		}		
	}

	/**
	 * Listen for incoming messages. For connection oriented transports, this
	 * method needs to be called before is called for the first time.
	 * 
	 * @throws IOException
	 */
	public synchronized void startTrapListener() throws IOException {
		try {
			AbstractTransportMapping transport;

			LogWriter.getSNMPLogger().debug("Listen for incoming trap messages...");
			// Set the default counter listener to return proper USM and MP error counters.
			CounterSupport.getInstance().addCounterListener(
					new DefaultCounterListener());

			Address address = new UdpAddress(UDP_ADDRESS);

			transport = new DefaultUdpTransportMapping((UdpAddress) address);

			trapThreadPool = ThreadPool.create(DISPATCHER_POOL, NUM_DISPATCHER_THREAD);
			MessageDispatcher mtDispatcher = new MultiThreadedMessageDispatcher(
					trapThreadPool, new MessageDispatcherImpl());

			// Add message processing models
			mtDispatcher.addMessageProcessingModel(new MPv1());
			mtDispatcher.addMessageProcessingModel(new MPv2c());

			// Add all security protocols
			SecurityProtocols.getInstance().addDefaultProtocols();
			SecurityProtocols.getInstance().addPrivacyProtocol(new Priv3DES());

			snmpTrap = new Snmp(mtDispatcher, transport);

			if (snmpTrap != null) {
				snmpTrap.addCommandResponder(this);
				transport.listen();
				LogWriter.getSNMPLogger().info("Listening Trap on " + address);
			} else {
				throw new Exception("Cannot start Trap Listener");
			}
		} catch (Exception ex) {
			if (Thread.currentThread().isAlive()){
				Thread.currentThread().interrupt();
			}
			LogWriter.getSNMPLogger().error("Can not start Trap Listener");
			LogWriter.getSNMPLogger().error(ex.toString());
			if(LogWriter.getSNMPLogger().isDebugEnabled()){
				LogWriter.getSNMPLogger().debug(Utils.parseException(ex));
			}			
		}
	}

	/**
	 * Create Snmp Session to execute Snmp command
	 * 
	 * @return Snmp Object
	 * @throws IOException
	 */
	public Snmp createSnmpSession(String ipAddress) throws IOException {
		AbstractTransportMapping transport;
		
		snmpPort++;		
		UdpAddress address = new UdpAddress(ipAddress + "/" + snmpPort);	
		
		transport = new DefaultUdpTransportMapping(address);
		
		ThreadPool threadPool = ThreadPool.create(DISPATCHER_POOL, NUM_DISPATCHER_THREAD);
		MultiThreadedMessageDispatcher dispatcher = new MultiThreadedMessageDispatcher(
				threadPool, new MessageDispatcherImpl());
		
		// add message processing models
		dispatcher.addMessageProcessingModel(new MPv1());
		dispatcher.addMessageProcessingModel(new MPv2c());
		
		Snmp snmp = new Snmp(dispatcher, transport);
		
		return snmp;
	}

	
	/**
	 * Create Snmp Session to execute Snmp command
	 * 
	 * @return Snmp Object
	 * @throws IOException
	 */
	public Snmp createSnmpSession() throws IOException {
		AbstractTransportMapping transport;
		if (this.address instanceof TcpAddress) {
			transport = new DefaultTcpTransportMapping();
		} else {
			transport = new DefaultUdpTransportMapping();
		}
		// Could save some CPU cycles:
		// transport.setAsyncMsgProcessingSupported(false);
		Snmp snmp = new Snmp(transport);

		return snmp;
	}

	/**
	 * Create CommunityTarget A CommunityTarget represents SNMP target
	 * properties for community based message processing models (SNMPv1 and
	 * SNMPv2c).
	 * 
	 * @param strAddress
	 * @param timeOut
	 * @param retries
	 * @return
	 */
	private Target createCommunityTarget(String strAddress, int timeOut,
			int retries) {
		try {
			Address targetAddress = GenericAddress
					.parse(getAddressUDP(strAddress));
			CommunityTarget comTarget = new CommunityTarget();
			comTarget.setCommunity(this.community);
			comTarget.setAddress(targetAddress);
			comTarget.setTimeout(timeOut);
			comTarget.setRetries(retries);
			comTarget.setVersion(Setting.getSnmpVersion());			
			return comTarget;
		} catch (Exception e) {
			LogWriter.getSNMPLogger().error(e.toString());
			if(LogWriter.getSNMPLogger().isDebugEnabled()){
				LogWriter.getSNMPLogger().debug(Utils.parseException(e));
			}
			return null;
		}
	}

	/**
	 * Create PDU object The PDU object represents a SNMP protocol data unit.
	 * 
	 * @param intPduType
	 * @return
	 */
	private PDU createPDU(int intPduType) {
		PDU pduRequest;
		// V1.0, V2C
		if (this.pduType == PDU.V1TRAP) { // SNMPv1 TRAP PDU
			pduRequest = new PDUv1();
		} else { // SNMPv1, SNMPv2c
			pduRequest = new PDU();
		}
		this.pduType = intPduType;
		pduRequest.setType(intPduType);

		return pduRequest;
	}

	/**
	 * Create PDU object The PDU object represents a SNMP protocol data unit.
	 * 
	 * @param strOID
	 * @param pduType
	 * @param strValue
	 * @return
	 */
	private PDU createPDU(String strOID, int pduType, String strValue) {
		try {
			PDU pdu = createPDU(pduType);
			if ((strOID != null) && (strOID.trim().length() > 0)) {
				boolean isNumber = Utils.isInteger(strValue);
				if (isNumber) {
					int intValue = Utils.parseInt(strValue, -1);
					pdu.add(new VariableBinding(new OID(strOID), new Integer32(intValue)));
				} else {
					pdu.add(new VariableBinding(new OID(strOID), createOctetString(strValue)));
				}
				pdu.setType(pduType);
				return pdu;
			} else {
				return null;
			}
		} catch (Exception e) {
			LogWriter.getSNMPLogger().error(e.toString());
			if(LogWriter.getSNMPLogger().isDebugEnabled()){
				LogWriter.getSNMPLogger().debug(Utils.parseException(e));
			}
			return null;
		}
	}

	/***
	 * Create OctetString object The OctetString represents the SMI type OCTET
	 * STRING.
	 * 
	 * @param s
	 * @return
	 */
	private static OctetString createOctetString(String strOctect) {
		OctetString octetString;
		if (strOctect.startsWith("0x")) {
			octetString = OctetString.fromHexString(strOctect.substring(2), ':');
		} else {
			octetString = new OctetString(strOctect);
		}
		return octetString;
	}

	/**
	 * Create a <code>PDU</code> instance for the supplied target. The created
	 * PDU has to be complaint to the SNMP version defined by the supplied
	 * target.
	 * 
	 * @param target
	 *            the <code>Target</code> where the PDU to be created will be
	 *            sent.
	 * @return PDU a PDU instance that is compatible with the supplied target.
	 */
	public PDU createPDU(Target target) {
		PDU request;
		if (target.getVersion() == SnmpConstants.version3) {
			request = new ScopedPDU();
		} else {
			if (this.pduType == PDU.V1TRAP) {
				request = this.v1TrapPDU;
			} else {
				request = new PDU();
			}
		}

		request.setType(this.pduType);
		return request;
	}

	/**
	 * The default implementation of processPdu() in this class
	 * Process an incoming request, report or notification PDU.
	 * 
	 * @param commandResEvent
	 *            CommandResponderEvent
	 */
	public synchronized void processPdu(CommandResponderEvent commandResEvent) {
		PDU response = commandResEvent.getPDU();
		if (response != null) {			
			LogWriter.getSNMPLogger().debug("PTE send Trap to Server with:");
			// LogWriter.getSNMPLogger().debug("IP Address:" +
			// commandResEvent.getPeerAddress());
			LogWriter.getSNMPLogger().debug("All data from PTE:" + response.toString());
			// LogWriter.getSNMPLogger().debug("RequestID:" +
			// response.getRequestID());
			// LogWriter.getSNMPLogger().debug("ErrorStatus:" +
			// response.getErrorStatus());
			// LogWriter.getSNMPLogger().debug("PDU Type:" + response.getType());			

			if ((response.getType() != PDU.TRAP)
					&& (response.getType() != PDU.V1TRAP)
					&& (response.getType() != PDU.REPORT)
					&& (response.getType() != PDU.RESPONSE)) {
				response.setErrorIndex(0);
				response.setErrorStatus(0);
				response.setType(PDU.RESPONSE);
				StatusInformation statusInformation = new StatusInformation();
				StateReference ref = commandResEvent.getStateReference();
				try {
					commandResEvent.getMessageDispatcher().returnResponsePdu(
							commandResEvent.getMessageProcessingModel(),
							commandResEvent.getSecurityModel(),
							commandResEvent.getSecurityName(),
							commandResEvent.getSecurityLevel(), response,
							commandResEvent.getMaxSizeResponsePDU(), ref,
							statusInformation);
				} catch (MessageException ex) {
					LogWriter.getSNMPLogger().error("Error while sending response: " + ex.getMessage());
					if(LogWriter.getSNMPLogger().isDebugEnabled()){
						LogWriter.getSNMPLogger().debug(Utils.parseException(ex));
					}
				}
			} else {
				countTrap++;
				String peerAddress = "" + commandResEvent.getPeerAddress();