/*
* Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.jmx.snmp.daemon;
// java import
//
import java.io.ObjectInputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.util.Enumeration;
import java.util.logging.Level;
import java.util.Vector;
import java.util.NoSuchElementException;
// jmx import
//
import javax.management.MBeanServer;
import javax.management.MBeanRegistration;
import javax.management.ObjectName;
import javax.management.NotificationListener;
import javax.management.NotificationFilter;
import javax.management.NotificationBroadcaster;
import javax.management.NotificationBroadcasterSupport;
import javax.management.MBeanNotificationInfo;
import javax.management.AttributeChangeNotification;
import javax.management.ListenerNotFoundException;
import javax.management.loading.ClassLoaderRepository;
import javax.management.MBeanServerFactory;
import static com.sun.jmx.defaults.JmxProperties.SNMP_ADAPTOR_LOGGER;
// JSR 160 import
//
// XXX Revisit:
// used to import com.sun.jmx.snmp.MBeanServerForwarder
// Now using JSR 160 instead. => this is an additional
// dependency to JSR 160.
//
import javax.management.remote.MBeanServerForwarder;
/**
* Defines generic behavior for the server part of a connector or an adaptor.
* Most connectors or adaptors extend <CODE>CommunicatorServer</CODE>
* and inherit this behavior. Connectors or adaptors that do not fit into
* this model do not extend <CODE>CommunicatorServer</CODE>.
* <p>
* A <CODE>CommunicatorServer</CODE> is an active object, it listens for
* client requests and processes them in its own thread. When necessary, a
* <CODE>CommunicatorServer</CODE> creates other threads to process multiple
* requests concurrently.
* <p>
* A <CODE>CommunicatorServer</CODE> object can be stopped by calling the
* <CODE>stop</CODE> method. When it is stopped, the
* <CODE>CommunicatorServer</CODE> no longer listens to client requests and
* no longer holds any thread or communication resources.
* It can be started again by calling the <CODE>start</CODE> method.
* <p>
* A <CODE>CommunicatorServer</CODE> has a <CODE>State</CODE> attribute
* which reflects its activity.
* <p>
* <TABLE>
* <TR><TH>CommunicatorServer</TH> <TH>State</TH></TR>
* <TR><TD><CODE>stopped</CODE></TD> <TD><CODE>OFFLINE</CODE></TD></TR>
* <TR><TD><CODE>starting</CODE></TD> <TD><CODE>STARTING</CODE></TD></TR>
* <TR><TD><CODE>running</CODE></TD> <TD><CODE>ONLINE</CODE></TD></TR>
* <TR><TD><CODE>stopping</CODE></TD> <TD><CODE>STOPPING</CODE></TD></TR>
* </TABLE>
* <p>
* The <CODE>STARTING</CODE> state marks the transition
* from <CODE>OFFLINE</CODE> to <CODE>ONLINE</CODE>.
* <p>
* The <CODE>STOPPING</CODE> state marks the transition from
* <CODE>ONLINE</CODE> to <CODE>OFFLINE</CODE>. This occurs when the
* <CODE>CommunicatorServer</CODE> is finishing or interrupting active
* requests.
* <p>
* When a <CODE>CommunicatorServer</CODE> is unregistered from the MBeanServer,
* it is stopped automatically.
* <p>
* When the value of the <CODE>State</CODE> attribute changes the
* <CODE>CommunicatorServer</CODE> sends a
* <tt>{@link javax.management.AttributeChangeNotification}</tt> to the
* registered listeners, if any.
*
* <p><b>This API is a Sun Microsystems internal API and is subject
* to change without notice.</b></p>
*/
public abstract class CommunicatorServer
implements Runnable, MBeanRegistration, NotificationBroadcaster,
CommunicatorServerMBean {
//
// States of a CommunicatorServer
//
/**
* Represents an <CODE>ONLINE</CODE> state.
*/
public static final int ONLINE = 0 ;
/**
* Represents an <CODE>OFFLINE</CODE> state.
*/
public static final int OFFLINE = 1 ;
/**
* Represents a <CODE>STOPPING</CODE> state.
*/
public static final int STOPPING = 2 ;
/**
* Represents a <CODE>STARTING</CODE> state.
*/
public static final int STARTING = 3 ;
//
// Types of connectors.
//
/**
* Indicates that it is an RMI connector type.
*/
//public static final int RMI_TYPE = 1 ;
/**
* Indicates that it is an HTTP connector type.
*/
//public static final int HTTP_TYPE = 2 ;
/**
* Indicates that it is an HTML connector type.
*/
//public static final int HTML_TYPE = 3 ;
/**
* Indicates that it is an SNMP connector type.
*/
public static final int SNMP_TYPE = 4 ;
/**
* Indicates that it is an HTTPS connector type.
*/
//public static final int HTTPS_TYPE = 5 ;
//
// Package variables
//
/**
* The state of the connector server.
*/
transient volatile int state = OFFLINE ;
/**
* The object name of the connector server.
* @serial
*/
ObjectName objectName ;
MBeanServer topMBS;
MBeanServer bottomMBS;
/**
*/
transient String dbgTag = null ;
/**
* The maximum number of clients that the CommunicatorServer can
* process concurrently.
* @serial
*/
int maxActiveClientCount = 1 ;
/**
*/
transient int servedClientCount = 0 ;
/**
* The host name used by this CommunicatorServer.
* @serial
*/
String host = null ;
/**
* The port number used by this CommunicatorServer.
* @serial
*/
int port = -1 ;
//
// Private fields
//
/* This object controls access to the "state" and "interrupted" variables.
If held at the same time as the lock on "this", the "this" lock must
be taken first. */
private transient Object stateLock = new Object();
private transient Vector<ClientHandler>
clientHandlerVector = new Vector<ClientHandler>() ;
private transient Thread fatherThread = Thread.currentThread() ;
private transient Thread mainThread = null ;
private volatile boolean stopRequested = false ;
private boolean interrupted = false;
private transient Exception startException = null;
// Notifs count, broadcaster and info
private transient long notifCount = 0;
private transient NotificationBroadcasterSupport notifBroadcaster =
new NotificationBroadcasterSupport();
private transient MBeanNotificationInfo[] notifInfos = null;
/**
* Instantiates a <CODE>CommunicatorServer</CODE>.
*
* @param connectorType Indicates the connector type. Possible values are:
* SNMP_TYPE.
*
* @exception <CODE>java.lang.IllegalArgumentException</CODE>
* This connector type is not correct.
*/
public CommunicatorServer(int connectorType)
throws IllegalArgumentException {
switch (connectorType) {
case SNMP_TYPE :
//No op. int Type deciding debugging removed.
break;
default:
throw new IllegalArgumentException("Invalid connector Type") ;
}
dbgTag = makeDebugTag() ;
}
protected Thread createMainThread() {
return new Thread (this, makeThreadName());
}
/**
* Starts this <CODE>CommunicatorServer</CODE>.
* <p>
* Has no effect if this <CODE>CommunicatorServer</CODE> is
* <CODE>ONLINE</CODE> or <CODE>STOPPING</CODE>.
* @param timeout Time in ms to wait for the connector to start.
* If <code>timeout</code> is positive, wait for at most
* the specified time. An infinite timeout can be specified
* by passing a <code>timeout</code> value equals
* <code>Long.MAX_VALUE</code>. In that case the method
* will wait until the connector starts or fails to start.
* If timeout is negative or zero, returns as soon as possible
* without waiting.
* @exception CommunicationException if the connectors fails to start.
* @exception InterruptedException if the thread is interrupted or the
* timeout expires.
*/
public void start(long timeout)
throws CommunicationException, InterruptedException {
boolean start;
synchronized (stateLock) {
if (state == STOPPING) {
// Fix for bug 4352451:
// "java.net.BindException: Address in use".
waitState(OFFLINE, 60000);
}
start = (state == OFFLINE);
if (start) {
changeState(STARTING);
stopRequested = false;
interrupted = false;
startException = null;
}
}
if (!start) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"start","Connector is not OFFLINE");
}
return;
}
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"start","--> Start connector ");
}
mainThread = createMainThread();
mainThread.start() ;
if (timeout > 0) waitForStart(timeout);
}
/**
* Starts this <CODE>CommunicatorServer</CODE>.
* <p>
* Has no effect if this <CODE>CommunicatorServer</CODE> is
* <CODE>ONLINE</CODE> or <CODE>STOPPING</CODE>.
*/
public void start() {
try {
start(0);
} catch (InterruptedException x) {
// cannot happen because of `0'
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"start","interrupted", x);
}
}
}
/**
* Stops this <CODE>CommunicatorServer</CODE>.
* <p>
* Has no effect if this <CODE>CommunicatorServer</CODE> is
* <CODE>OFFLINE</CODE> or <CODE>STOPPING</CODE>.
*/
public void stop() {
synchronized (stateLock) {
if (state == OFFLINE || state == STOPPING) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"stop","Connector is not ONLINE");
}
return;
}
changeState(STOPPING);
//
// Stop the connector thread
//
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"stop","Interrupt main thread");
}
stopRequested = true ;
if (!interrupted) {
interrupted = true;
mainThread.interrupt();
}
}
//
// Call terminate on each active client handler
//
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"stop","terminateAllClient");
}
terminateAllClient() ;
// ----------------------
// changeState
// ----------------------
synchronized (stateLock) {
if (state == STARTING)
changeState(OFFLINE);
}
}
/**
* Tests whether the <CODE>CommunicatorServer</CODE> is active.
*
* @return True if connector is <CODE>ONLINE</CODE>; false otherwise.
*/
public boolean isActive() {
synchronized (stateLock) {
return (state == ONLINE);
}
}
/**
* <p>Waits until either the State attribute of this MBean equals the
* specified <VAR>wantedState</VAR> parameter,
* or the specified <VAR>timeOut</VAR> has elapsed.
* The method <CODE>waitState</CODE> returns with a boolean value
* indicating whether the specified <VAR>wantedState</VAR> parameter
* equals the value of this MBean's State attribute at the time the method
* terminates.</p>
*
* <p>Two special cases for the <VAR>timeOut</VAR> parameter value are:</p>
* <UL><LI> if <VAR>timeOut</VAR> is negative then <CODE>waitState</CODE>
* returns immediately (i.e. does not wait at all),</LI>
* <LI> if <VAR>timeOut</VAR> equals zero then <CODE>waitState</CODE>
* waits untill the value of this MBean's State attribute
* is the same as the <VAR>wantedState</VAR> parameter (i.e. will wait
* indefinitely if this condition is never met).</LI></UL>
*
* @param wantedState The value of this MBean's State attribute to wait
* for. <VAR>wantedState</VAR> can be one of:
* <ul>
* <li><CODE>CommunicatorServer.OFFLINE</CODE>,</li>
* <li><CODE>CommunicatorServer.ONLINE</CODE>,</li>
* <li><CODE>CommunicatorServer.STARTING</CODE>,</li>
* <li><CODE>CommunicatorServer.STOPPING</CODE>.</li>
* </ul>
* @param timeOut The maximum time to wait for, in milliseconds,
* if positive.
* Infinite time out if 0, or no waiting at all if negative.
*
* @return true if the value of this MBean's State attribute is the
* same as the <VAR>wantedState</VAR> parameter; false otherwise.
*/
public boolean waitState(int wantedState, long timeOut) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitState", wantedState + "(0on,1off,2st) TO=" + timeOut +
" ; current state = " + getStateString());
}
long endTime = 0;
if (timeOut > 0)
endTime = System.currentTimeMillis() + timeOut;
synchronized (stateLock) {
while (state != wantedState) {
if (timeOut < 0) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitState", "timeOut < 0, return without wait");
}
return false;
} else {
try {
if (timeOut > 0) {
long toWait = endTime - System.currentTimeMillis();
if (toWait <= 0) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitState", "timed out");
}
return false;
}
stateLock.wait(toWait);
} else { // timeOut == 0
stateLock.wait();
}
} catch (InterruptedException e) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitState", "wait interrupted");
}
return (state == wantedState);
}
}
}
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitState","returning in desired state");
}
return true;
}
}
/**
* <p>Waits until the communicator is started or timeout expires.
*
* @param timeout Time in ms to wait for the connector to start.
* If <code>timeout</code> is positive, wait for at most
* the specified time. An infinite timeout can be specified
* by passing a <code>timeout</code> value equals
* <code>Long.MAX_VALUE</code>. In that case the method
* will wait until the connector starts or fails to start.
* If timeout is negative or zero, returns as soon as possible
* without waiting.
*
* @exception CommunicationException if the connectors fails to start.
* @exception InterruptedException if the thread is interrupted or the
* timeout expires.
*
*/
private void waitForStart(long timeout)
throws CommunicationException, InterruptedException {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitForStart", "Timeout=" + timeout +
" ; current state = " + getStateString());
}
final long startTime = System.currentTimeMillis();
synchronized (stateLock) {
while (state == STARTING) {
// Time elapsed since startTime...
//
final long elapsed = System.currentTimeMillis() - startTime;
// wait for timeout - elapsed.
// A timeout of Long.MAX_VALUE is equivalent to something
// like 292271023 years - which is pretty close to
// forever as far as we are concerned ;-)
//
final long remainingTime = timeout-elapsed;
// If remainingTime is negative, the timeout has elapsed.
//
if (remainingTime < 0) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitForStart", "timeout < 0, return without wait");
}
throw new InterruptedException("Timeout expired");
}
// We're going to wait until someone notifies on the
// the stateLock object, or until the timeout expires,
// or until the thread is interrupted.
//
try {
stateLock.wait(remainingTime);
} catch (InterruptedException e) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitForStart", "wait interrupted");
}
// If we are now ONLINE, then no need to rethrow the
// exception... we're simply going to exit the while
// loop. Otherwise, throw the InterruptedException.
//
if (state != ONLINE) throw e;
}
}
// We're no longer in STARTING state
//
if (state == ONLINE) {
// OK, we're started, everything went fine, just return
//
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitForStart", "started");
}
return;
} else if (startException instanceof CommunicationException) {
// There was some exception during the starting phase.
// Cast and throw...
//
throw (CommunicationException)startException;
} else if (startException instanceof InterruptedException) {
// There was some exception during the starting phase.
// Cast and throw...
//
throw (InterruptedException)startException;
} else if (startException != null) {
// There was some exception during the starting phase.
// Wrap and throw...
//
throw new CommunicationException(startException,
"Failed to start: "+
startException);
} else {
// We're not ONLINE, and there's no exception...
// Something went wrong but we don't know what...
//
throw new CommunicationException("Failed to start: state is "+
getStringForState(state));
}
}
}
/**
* Gets the state of this <CODE>CommunicatorServer</CODE> as an integer.
*
* @return <CODE>ONLINE</CODE>, <CODE>OFFLINE</CODE>,
* <CODE>STARTING</CODE> or <CODE>STOPPING</CODE>.
*/
public int getState() {
synchronized (stateLock) {
return state ;
}
}
/**
* Gets the state of this <CODE>CommunicatorServer</CODE> as a string.
*
* @return One of the strings "ONLINE", "OFFLINE", "STARTING" or
* "STOPPING".
*/
public String getStateString() {
return getStringForState(state) ;
}
/**
* Gets the host name used by this <CODE>CommunicatorServer</CODE>.
*
* @return The host name used by this <CODE>CommunicatorServer</CODE>.
*/
public String getHost() {
try {
host = InetAddress.getLocalHost().getHostName();
} catch (Exception e) {
host = "Unknown host";
}
return host ;
}
/**
* Gets the port number used by this <CODE>CommunicatorServer</CODE>.
*
* @return The port number used by this <CODE>CommunicatorServer</CODE>.
*/
public int getPort() {
synchronized (stateLock) {
return port ;
}
}
/**
* Sets the port number used by this <CODE>CommunicatorServer</CODE>.
*
* @param port The port number used by this
* <CODE>CommunicatorServer</CODE>.
*
* @exception java.lang.IllegalStateException This method has been invoked
* while the communicator was ONLINE or STARTING.
*/
public void setPort(int port) throws java.lang.IllegalStateException {
synchronized (stateLock) {
if ((state == ONLINE) || (state == STARTING))
throw new IllegalStateException("Stop server before " +
"carrying out this operation");
this.port = port;
dbgTag = makeDebugTag();
}
}
/**
* Gets the protocol being used by this <CODE>CommunicatorServer</CODE>.
* @return The protocol as a string.
*/
public abstract String getProtocol() ;
/**
* Gets the number of clients that have been processed by this
* <CODE>CommunicatorServer</CODE> since its creation.
*
* @return The number of clients handled by this
* <CODE>CommunicatorServer</CODE>
* since its creation. This counter is not reset by the
* <CODE>stop</CODE> method.
*/
int getServedClientCount() {
return servedClientCount ;
}
/**
* Gets the number of clients currently being processed by this
* <CODE>CommunicatorServer</CODE>.
*
* @return The number of clients currently being processed by this
* <CODE>CommunicatorServer</CODE>.
*/
int getActiveClientCount() {
int result = clientHandlerVector.size() ;
return result ;
}
/**
* Gets the maximum number of clients that this
* <CODE>CommunicatorServer</CODE> can process concurrently.
*
* @return The maximum number of clients that this
* <CODE>CommunicatorServer</CODE> can
* process concurrently.
*/
int getMaxActiveClientCount() {
return maxActiveClientCount ;
}
/**
* Sets the maximum number of clients this
* <CODE>CommunicatorServer</CODE> can process concurrently.
*
* @param c The number of clients.
*
* @exception java.lang.IllegalStateException This method has been invoked
* while the communicator was ONLINE or STARTING.
*/
void setMaxActiveClientCount(int c)
throws java.lang.IllegalStateException {
synchronized (stateLock) {
if ((state == ONLINE) || (state == STARTING)) {
throw new IllegalStateException(
"Stop server before carrying out this operation");
}
maxActiveClientCount = c ;
}
}
/**
* For SNMP Runtime internal use only.
*/
void notifyClientHandlerCreated(ClientHandler h) {
clientHandlerVector.addElement(h) ;
}
/**
* For SNMP Runtime internal use only.
*/
synchronized void notifyClientHandlerDeleted(ClientHandler h) {
clientHandlerVector.removeElement(h);
notifyAll();
}
/**
* The number of times the communicator server will attempt
* to bind before giving up.
**/
protected int getBindTries() {
return 50;
}
/**
* The delay, in ms, during which the communicator server will sleep before
* attempting to bind again.
**/
protected long getBindSleepTime() {
return 100;
}
/**
* For SNMP Runtime internal use only.
* <p>
* The <CODE>run</CODE> method executed by this connector's main thread.
*/
public void run() {
// Fix jaw.00667.B
// It seems that the init of "i" and "success"
// need to be done outside the "try" clause...
// A bug in Java 2 production release ?
//
int i = 0;
boolean success = false;
// ----------------------
// Bind
// ----------------------
try {
// Fix for bug 4352451: "java.net.BindException: Address in use".
//
final int bindRetries = getBindTries();
final long sleepTime = getBindSleepTime();
while (i < bindRetries && !success) {
try {
// Try socket connection.
//
doBind();
success = true;
} catch (CommunicationException ce) {
i++;
try {
Thread.sleep(sleepTime);
} catch (InterruptedException ie) {
throw ie;
}
}
}
// Retry last time to get correct exception.
//
if (!success) {
// Try socket connection.
//
doBind();
}
} catch(Exception x) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"run", "Got unexpected exception", x);
}
synchronized(stateLock) {
startException = x;
changeState(OFFLINE);
}
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"run","State is OFFLINE");
}
doError(x);
return;
}
try {
// ----------------------
// State change
// ----------------------
changeState(ONLINE) ;
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"run","State is ONLINE");
}
// ----------------------
// Main loop
// ----------------------
while (!stopRequested) {
servedClientCount++;
doReceive() ;
waitIfTooManyClients() ;
doProcess() ;
}
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"run","Stop has been requested");
}
} catch(InterruptedException x) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"run","Interrupt caught");
}
changeState(STOPPING);
} catch(Exception x) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"run","Got unexpected exception", x);
}
changeState(STOPPING);
} finally {
synchronized (stateLock) {
interrupted = true;
Thread.currentThread().interrupted();
}
// ----------------------
// unBind
// ----------------------
try {
doUnbind() ;
waitClientTermination() ;
changeState(OFFLINE);
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"run","State is OFFLINE");
}
} catch(Exception x) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"run","Got unexpected exception", x);
}
changeState(OFFLINE);
}
}
}
/**
*/
protected abstract void doError(Exception e) throws CommunicationException;
//
// To be defined by the subclass.
//
// Each method below is called by run() and must be subclassed.
// If the method sends an exception (Communication or Interrupt), this
// will end up the run() method and switch the connector offline.
//
// If it is a CommunicationException, run() will call
// Debug.printException().
//
// All these methods should propagate the InterruptedException to inform
// run() that the connector must be switch OFFLINE.
//
//
//
// doBind() should do all what is needed before calling doReceive().
// If doBind() throws an exception, doUnbind() is not to be called
// and run() ends up.
//
/**
*/
protected abstract void doBind()
throws CommunicationException, InterruptedException ;
/**
* <CODE>doReceive()</CODE> should block until a client is available.
* If this method throws an exception, <CODE>doProcess()</CODE> is not
* called but <CODE>doUnbind()</CODE> is called then <CODE>run()</CODE>
* stops.
*/
protected abstract void doReceive()
throws CommunicationException, InterruptedException ;
/**
* <CODE>doProcess()</CODE> is called after <CODE>doReceive()</CODE>:
* it should process the requests of the incoming client.
* If it throws an exception, <CODE>doUnbind()</CODE> is called and
* <CODE>run()</CODE> stops.
*/
protected abstract void doProcess()
throws CommunicationException, InterruptedException ;
/**
* <CODE>doUnbind()</CODE> is called whenever the connector goes
* <CODE>OFFLINE</CODE>, except if <CODE>doBind()</CODE> has thrown an
* exception.
*/
protected abstract void doUnbind()
throws CommunicationException, InterruptedException ;
/**
* Get the <code>MBeanServer</code> object to which incoming requests are
* sent. This is either the MBean server in which this connector is
* registered, or an <code>MBeanServerForwarder</code> leading to that
* server.
*/
public synchronized MBeanServer getMBeanServer() {
return topMBS;
}
/**
* Set the <code>MBeanServer</code> object to which incoming
* requests are sent. This must be either the MBean server in
* which this connector is registered, or an
* <code>MBeanServerForwarder</code> leading to that server. An
* <code>MBeanServerForwarder</code> <code>mbsf</code> leads to an
* MBean server <code>mbs</code> if
* <code>mbsf.getMBeanServer()</code> is either <code>mbs</code>
* or an <code>MBeanServerForwarder</code> leading to
* <code>mbs</code>.
*
* @exception IllegalArgumentException if <code>newMBS</code> is neither
* the MBean server in which this connector is registered nor an
* <code>MBeanServerForwarder</code> leading to that server.
*
* @exception IllegalStateException This method has been invoked
* while the communicator was ONLINE or STARTING.
*/
public synchronized void setMBeanServer(MBeanServer newMBS)
throws IllegalArgumentException, IllegalStateException {
synchronized (stateLock) {
if (state == ONLINE || state == STARTING)
throw new IllegalStateException("Stop server before " +
"carrying out this operation");
}
final String error =
"MBeanServer argument must be MBean server where this " +
"server is registered, or an MBeanServerForwarder " +
"leading to that server";
Vector<MBeanServer> seenMBS = new Vector<MBeanServer>();
for (MBeanServer mbs = newMBS;
mbs != bottomMBS;
mbs = ((MBeanServerForwarder) mbs).getMBeanServer()) {
if (!(mbs instanceof MBeanServerForwarder))
throw new IllegalArgumentException(error);
if (seenMBS.contains(mbs))
throw new IllegalArgumentException("MBeanServerForwarder " +
"loop");
seenMBS.addElement(mbs);
}
topMBS = newMBS;
}
//
// To be called by the subclass if needed
//
/**
* For internal use only.
*/
ObjectName getObjectName() {
return objectName ;
}
/**
* For internal use only.
*/
void changeState(int newState) {
int oldState;
synchronized (stateLock) {
if (state == newState)
return;
oldState = state;
state = newState;
stateLock.notifyAll();
}
sendStateChangeNotification(oldState, newState);
}
/**
* Returns the string used in debug traces.
*/
String makeDebugTag() {
return "CommunicatorServer["+ getProtocol() + ":" + getPort() + "]" ;
}
/**
* Returns the string used to name the connector thread.
*/
String makeThreadName() {
String result ;
if (objectName == null)
result = "CommunicatorServer" ;
else
result = objectName.toString() ;
return result ;
}
/**
* This method blocks if there are too many active clients.
* Call to <CODE>wait()</CODE> is terminated when a client handler
* thread calls <CODE>notifyClientHandlerDeleted(this)</CODE> ;
*/
private synchronized void waitIfTooManyClients()
throws InterruptedException {
while (getActiveClientCount() >= maxActiveClientCount) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitIfTooManyClients","Waiting for a client to terminate");
}
wait();
}
}
/**
* This method blocks until there is no more active client.
*/
private void waitClientTermination() {
int s = clientHandlerVector.size() ;
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
if (s >= 1) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitClientTermination","waiting for " +
s + " clients to terminate");
}
}
// The ClientHandler will remove themselves from the
// clientHandlerVector at the end of their run() method, by
// calling notifyClientHandlerDeleted().
// Since the clientHandlerVector is modified by the ClientHandler
// threads we must avoid using Enumeration or Iterator to loop
// over this array. We must also take care of NoSuchElementException
// which could be thrown if the last ClientHandler removes itself
// between the call to clientHandlerVector.isEmpty() and the call
// to clientHandlerVector.firstElement().
// What we *MUST NOT DO* is locking the clientHandlerVector, because
// this would most probably cause a deadlock.
//
while (! clientHandlerVector.isEmpty()) {
try {
clientHandlerVector.firstElement().join();
} catch (NoSuchElementException x) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitClientTermination","No elements left", x);
}
}
}
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
if (s >= 1) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"waitClientTermination","Ok, let's go...");
}
}
}
/**
* Call <CODE>interrupt()</CODE> on each pending client.
*/
private void terminateAllClient() {
final int s = clientHandlerVector.size() ;
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
if (s >= 1) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"terminateAllClient","Interrupting " + s + " clients");
}
}
// The ClientHandler will remove themselves from the
// clientHandlerVector at the end of their run() method, by
// calling notifyClientHandlerDeleted().
// Since the clientHandlerVector is modified by the ClientHandler
// threads we must avoid using Enumeration or Iterator to loop
// over this array.
// We cannot use the same logic here than in waitClientTermination()
// because there is no guarantee that calling interrupt() on the
// ClientHandler will actually terminate the ClientHandler.
// Since we do not want to wait for the actual ClientHandler
// termination, we cannot simply loop over the array until it is
// empty (this might result in calling interrupt() endlessly on
// the same client handler. So what we do is simply take a snapshot
// copy of the vector and loop over the copy.
// What we *MUST NOT DO* is locking the clientHandlerVector, because
// this would most probably cause a deadlock.
//
final ClientHandler[] handlers =
clientHandlerVector.toArray(new ClientHandler[0]);
for (ClientHandler h : handlers) {
try {
h.interrupt() ;
} catch (Exception x) {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINER)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINER, dbgTag,
"terminateAllClient",
"Failed to interrupt pending request. " +
"Ignore the exception.", x);
}
}
}
}
/**
* Controls the way the CommunicatorServer service is deserialized.
*/
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException {
// Call the default deserialization of the object.
//
stream.defaultReadObject();
// Call the specific initialization for the CommunicatorServer service.
// This is for transient structures to be initialized to specific
// default values.
//
stateLock = new Object();
state = OFFLINE;
stopRequested = false;
servedClientCount = 0;
clientHandlerVector = new Vector<ClientHandler>();
fatherThread = Thread.currentThread();
mainThread = null;
notifCount = 0;
notifInfos = null;
notifBroadcaster = new NotificationBroadcasterSupport();
dbgTag = makeDebugTag();
}
//
// NotificationBroadcaster
//
/**
* Adds a listener for the notifications emitted by this
* CommunicatorServer.
* There is only one type of notifications sent by the CommunicatorServer:
* they are <tt>{@link javax.management.AttributeChangeNotification}</tt>,
* sent when the <tt>State</tt> attribute of this CommunicatorServer
* changes.
*
* @param listener The listener object which will handle the emitted
* notifications.
* @param filter The filter object. If filter is null, no filtering
* will be performed before handling notifications.
* @param handback An object which will be sent back unchanged to the
* listener when a notification is emitted.
*
* @exception IllegalArgumentException Listener parameter is null.
*/
public void addNotificationListener(NotificationListener listener,
NotificationFilter filter,
Object handback)
throws java.lang.IllegalArgumentException {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"addNotificationListener","Adding listener "+ listener +
" with filter "+ filter + " and handback "+ handback);
}
notifBroadcaster.addNotificationListener(listener, filter, handback);
}
/**
* Removes the specified listener from this CommunicatorServer.
* Note that if the listener has been registered with different
* handback objects or notification filters, all entries corresponding
* to the listener will be removed.
*
* @param listener The listener object to be removed.
*
* @exception ListenerNotFoundException The listener is not registered.
*/
public void removeNotificationListener(NotificationListener listener)
throws ListenerNotFoundException {
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"removeNotificationListener","Removing listener "+ listener);
}
notifBroadcaster.removeNotificationListener(listener);
}
/**
* Returns an array of MBeanNotificationInfo objects describing
* the notification types sent by this CommunicatorServer.
* There is only one type of notifications sent by the CommunicatorServer:
* it is <tt>{@link javax.management.AttributeChangeNotification}</tt>,
* sent when the <tt>State</tt> attribute of this CommunicatorServer
* changes.
*/
public MBeanNotificationInfo[] getNotificationInfo() {
// Initialize notifInfos on first call to getNotificationInfo()
//
if (notifInfos == null) {
notifInfos = new MBeanNotificationInfo[1];
String[] notifTypes = {
AttributeChangeNotification.ATTRIBUTE_CHANGE};
notifInfos[0] = new MBeanNotificationInfo( notifTypes,
AttributeChangeNotification.class.getName(),
"Sent to notify that the value of the State attribute "+
"of this CommunicatorServer instance has changed.");
}
return notifInfos;
}
/**
*
*/
private void sendStateChangeNotification(int oldState, int newState) {
String oldStateString = getStringForState(oldState);
String newStateString = getStringForState(newState);
String message = new StringBuffer().append(dbgTag)
.append(" The value of attribute State has changed from ")
.append(oldState).append(" (").append(oldStateString)
.append(") to ").append(newState).append(" (")
.append(newStateString).append(").").toString();
notifCount++;
AttributeChangeNotification notif =
new AttributeChangeNotification(this, // source
notifCount, // sequence number
System.currentTimeMillis(), // time stamp
message, // message
"State", // attribute name
"int", // attribute type
new Integer(oldState), // old value
new Integer(newState) ); // new value
if (SNMP_ADAPTOR_LOGGER.isLoggable(Level.FINEST)) {
SNMP_ADAPTOR_LOGGER.logp(Level.FINEST, dbgTag,
"sendStateChangeNotification","Sending AttributeChangeNotification #"
+ notifCount + " with message: "+ message);
}
notifBroadcaster.sendNotification(notif);
}
/**
*
*/
private static String getStringForState(int s) {
switch (s) {
case ONLINE: return "ONLINE";
case STARTING: return "STARTING";
case OFFLINE: return "OFFLINE";
case STOPPING: return "STOPPING";
default: return "UNDEFINED";
}
}
//
// MBeanRegistration
//
/**
* Preregister method of connector.
*
*@param server The <CODE>MBeanServer</CODE> in which the MBean will
* be registered.
*@param name The object name of the MBean.
*
*@return The name of the MBean registered.
*
*@exception java.langException This exception should be caught by
* the <CODE>MBeanServer</CODE> and re-thrown
* as an <CODE>MBeanRegistrationException</CODE>.
*/
public ObjectName preRegister(MBeanServer server, ObjectName name)
throws java.lang.Exception {
objectName = name;
synchronized (this) {
if (bottomMBS != null) {
throw new IllegalArgumentException("connector already " +
"registered in an MBean " +
"server");
}
topMBS = bottomMBS = server;
}
dbgTag = makeDebugTag();
return name;
}
/**
*
*@param registrationDone Indicates whether or not the MBean has been
* successfully registered in the <CODE>MBeanServer</CODE>.
* The value false means that the registration phase has failed.
*/
public void postRegister(Boolean registrationDone) {
if (!registrationDone.booleanValue()) {
synchronized (this) {
topMBS = bottomMBS = null;
}
}
}
/**
* Stop the connector.
*
* @exception java.langException This exception should be caught by
* the <CODE>MBeanServer</CODE> and re-thrown
* as an <CODE>MBeanRegistrationException</CODE>.
*/
public void preDeregister() throws java.lang.Exception {
synchronized (this) {
topMBS = bottomMBS = null;
}
objectName = null ;
final int cstate = getState();
if ((cstate == ONLINE) || ( cstate == STARTING)) {
stop() ;
}
}
/**
* Do nothing.
*/
public void postDeregister(){
}
/**
* Load a class using the default loader repository
**/
Class loadClass(String className)
throws ClassNotFoundException {
try {
return Class.forName(className);
} catch (ClassNotFoundException e) {
final ClassLoaderRepository clr =
MBeanServerFactory.getClassLoaderRepository(bottomMBS);
if (clr == null) throw new ClassNotFoundException(className);
return clr.loadClass(className);
}
}
}