Back to index...

	/*
	* Copyright (c) 1996, 2001, 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 sun.rmi.transport.tcp;

	import java.io.*;
	import java.net.InetAddress;
	import java.net.Socket;
	import java.net.SocketException;
	import java.rmi.*;
	import java.rmi.server.RMISocketFactory;
	import sun.rmi.runtime.Log;
	import sun.rmi.transport.*;
	import sun.rmi.transport.proxy.*;

	public class TCPConnection implements Connection {

	private Socket socket;
	private Channel channel;
	private InputStream in = null;
	private OutputStream out = null;
	private long expiration = Long.MAX_VALUE;
	private long lastuse = Long.MIN_VALUE;
	private long roundtrip = 5; // round-trip time for ping

	/**
	* Constructor used for creating a connection to accept call
	* (an input connection)
	*/
	TCPConnection(TCPChannel ch, Socket s, InputStream in, OutputStream out)
	{
	socket = s;
	channel = ch;
	this.in = in;
	this.out = out;
	}

	/**
	* Constructor used by subclass when underlying input and output streams
	* are already available.
	*/
	TCPConnection(TCPChannel ch, InputStream in, OutputStream out)
	{
	this(ch, null, in, out);
	}

	/**
	* Constructor used when socket is available, but not underlying
	* streams.
	*/
	TCPConnection(TCPChannel ch, Socket s)
	{
	this(ch, s, null, null);
	}

	/**
	* Gets the output stream for this connection
	*/
	public OutputStream getOutputStream() throws IOException
	{
	if (out == null)
	out = new BufferedOutputStream(socket.getOutputStream());
	return out;
	}

	/**
	* Release the output stream for this connection.
	*/
	public void releaseOutputStream() throws IOException
	{
	if (out != null)
	out.flush();
	}

	/**
	* Gets the input stream for this connection.
	*/
	public InputStream getInputStream() throws IOException
	{
	if (in == null)
	in = new BufferedInputStream(socket.getInputStream());
	return in;
	}


	/**
	* Release the input stream for this connection.
	*/
	public void releaseInputStream()
	{
	}

	/**
	* Determine if this connection can be used for multiple operations.
	* If the socket implements RMISocketInfo, then we can query it about
	* this; otherwise, assume that it does provide a full-duplex
	* persistent connection like java.net.Socket.
	*/
	public boolean isReusable()
	{
	if ((socket != null) && (socket instanceof RMISocketInfo))
	return ((RMISocketInfo) socket).isReusable();
	else
	return true;
	}

	/**
	* Set the expiration time of this connection.
	* @param time The time at which the time out expires.
	*/
	void setExpiration(long time)
	{
	expiration = time;
	}

	/**
	* Set the timestamp at which this connection was last used successfully.
	* The connection will be pinged for liveness if reused long after
	* this time.
	* @param time The time at which the connection was last active.
	*/
	void setLastUseTime(long time)
	{
	lastuse = time;
	}

	/**
	* Returns true if the timeout has expired on this connection;
	* otherwise returns false.
	* @param time The current time.
	*/
	boolean expired(long time)
	{
	return expiration <= time;
	}

	/**
	* Probes the connection to see if it still alive and connected to
	* a responsive server. If the connection has been idle for too
	* long, the server is pinged. ``Too long'' means ``longer than the
	* last ping round-trip time''.
	* <P>
	* This method may misdiagnose a dead connection as live, but it
	* will never misdiagnose a live connection as dead.
	* @return true if the connection and server are recently alive
	*/
	public boolean isDead()
	{
	InputStream i;
	OutputStream o;

	// skip ping if recently used within 1 RTT
	long start = System.currentTimeMillis();
	if ((roundtrip > 0) && (start < lastuse + roundtrip))
	return (false); // still alive and warm

	// Get the streams
	try {
	i = getInputStream();
	o = getOutputStream();
	} catch (IOException e) {
	return (true); // can't even get a stream, must be very dead
	}

	// Write the ping byte and read the reply byte
	int response = 0;
	try {
	o.write(TransportConstants.Ping);
	o.flush();
	response = i.read();
	} catch (IOException ex) {
	TCPTransport.tcpLog.log(Log.VERBOSE, "exception: ", ex);
	TCPTransport.tcpLog.log(Log.BRIEF, "server ping failed");

	return (true); // server failed the ping test
	}

	if (response == TransportConstants.PingAck) {
	// save most recent RTT for future use
	roundtrip = (System.currentTimeMillis() - start) * 2;
	// clock-correction may make roundtrip < 0; doesn't matter
	return (false); // it's alive and 5-by-5
	}

	if (TCPTransport.tcpLog.isLoggable(Log.BRIEF)) {
	TCPTransport.tcpLog.log(Log.BRIEF,
	(response == -1 ? "server has been deactivated" :
	"server protocol error: ping response = " + response));
	}
	return (true);
	}

	/**
	* Close the connection. */
	public void close() throws IOException
	{
	TCPTransport.tcpLog.log(Log.BRIEF, "close connection");

	if (socket != null)
	socket.close();
	else {
	in.close();
	out.close();
	}
	}

	/**
	* Returns the channel for this connection.
	*/
	public Channel getChannel()
	{
	return channel;
	}
	}

Back to index...