Back to index...

	/*
	* Copyright (c) 2003, 2004, 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.remote.internal;

	import java.io.IOException;

	import com.sun.jmx.remote.util.ClassLogger;

	public abstract class ServerCommunicatorAdmin {
	public ServerCommunicatorAdmin(long timeout) {
	if (logger.traceOn()) {
	logger.trace("Constructor",
	"Creates a new ServerCommunicatorAdmin object "+
	"with the timeout "+timeout);
	}

	this.timeout = timeout;

	timestamp = 0;
	if (timeout < Long.MAX_VALUE) {
	Runnable timeoutTask = new Timeout();
	final Thread t = new Thread(timeoutTask);
	t.setName("JMX server connection timeout " + t.getId());
	// If you change this name you will need to change a unit test
	// (NoServerTimeoutTest)
	t.setDaemon(true);
	t.start();
	}
	}

	/**
	* Tells that a new request message is received.
	* A caller of this method should always call the method
	* <code>rspOutgoing</code> to inform that a response is sent out
	* for the received request.
	* @return the value of the termination flag:
	* <ul><code>true</code> if the connection is already being terminated,
	* <br><code>false</code> otherwise.</ul>
	*/
	public boolean reqIncoming() {
	if (logger.traceOn()) {
	logger.trace("reqIncoming", "Receive a new request.");
	}

	synchronized(lock) {
	if (terminated) {
	logger.warning("reqIncoming",
	"The server has decided to close " +
	"this client connection.");
	}
	++currentJobs;

	return terminated;
	}
	}

	/**
	* Tells that a response is sent out for a received request.
	* @return the value of the termination flag:
	* <ul><code>true</code> if the connection is already being terminated,
	* <br><code>false</code> otherwise.</ul>
	*/
	public boolean rspOutgoing() {
	if (logger.traceOn()) {
	logger.trace("reqIncoming", "Finish a request.");
	}

	synchronized(lock) {
	if (--currentJobs == 0) {
	timestamp = System.currentTimeMillis();
	logtime("Admin: Timestamp=",timestamp);
	// tells the adminor to restart waiting with timeout
	lock.notify();
	}
	return terminated;
	}
	}

	/**
	* Called by this class to tell an implementation to do stop.
	*/
	protected abstract void doStop();

	/**
	* Terminates this object.
	* Called only by outside, so do not need to call doStop
	*/
	public void terminate() {
	if (logger.traceOn()) {
	logger.trace("terminate",
	"terminate the ServerCommunicatorAdmin object.");
	}

	synchronized(lock) {
	if (terminated) {
	return;
	}

	terminated = true;

	// tell Timeout to terminate
	lock.notify();
	}
	}

	// --------------------------------------------------------------
	// private classes
	// --------------------------------------------------------------
	private class Timeout implements Runnable {
	public void run() {
	boolean stopping = false;

	synchronized(lock) {
	if (timestamp == 0) timestamp = System.currentTimeMillis();
	logtime("Admin: timeout=",timeout);
	logtime("Admin: Timestamp=",timestamp);

	while(!terminated) {
	try {
	// wait until there is no more job
	while(!terminated && currentJobs != 0) {
	if (logger.traceOn()) {
	logger.trace("Timeout-run",
	"Waiting without timeout.");
	}

	lock.wait();
	}

	if (terminated) return;

	final long remaining =
	timeout - (System.currentTimeMillis() - timestamp);

	logtime("Admin: remaining timeout=",remaining);

	if (remaining > 0) {

	if (logger.traceOn()) {
	logger.trace("Timeout-run",
	"Waiting with timeout: "+
	remaining + " ms remaining");
	}

	lock.wait(remaining);
	}

	if (currentJobs > 0) continue;

	final long elapsed =
	System.currentTimeMillis() - timestamp;
	logtime("Admin: elapsed=",elapsed);

	if (!terminated && elapsed > timeout) {
	if (logger.traceOn()) {
	logger.trace("Timeout-run",
	"timeout elapsed");
	}
	logtime("Admin: timeout elapsed! "+
	elapsed+">",timeout);
	// stopping
	terminated = true;

	stopping = true;
	break;
	}
	} catch (InterruptedException ire) {
	logger.warning("Timeout-run","Unexpected Exception: "+
	ire);
	logger.debug("Timeout-run",ire);
	return;
	}
	}
	}

	if (stopping) {
	if (logger.traceOn()) {
	logger.trace("Timeout-run", "Call the doStop.");
	}

	doStop();
	}
	}
	}

	private void logtime(String desc,long time) {
	timelogger.trace("synchro",desc+time);
	}

	// --------------------------------------------------------------
	// private variables
	// --------------------------------------------------------------
	private long timestamp;

	private final int[] lock = new int[0];
	private int currentJobs = 0;

	private long timeout;

	// state issue
	private boolean terminated = false;

	private static final ClassLogger logger =
	new ClassLogger("javax.management.remote.misc",
	"ServerCommunicatorAdmin");
	private static final ClassLogger timelogger =
	new ClassLogger("javax.management.remote.timeout",
	"ServerCommunicatorAdmin");
	}

Back to index...