gogo/jline/src/test/java/org/apache/felix/gogo/jline/telnet/Connection.java - felix - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 /***
  * Java TelnetD library (embeddable telnet daemon)
  * Copyright (c) 2000-2005 Dieter Wimberger
  * All rights reserved.
  * <p/>
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  * Redistributions of source code must retain the above copyright notice,
  * this list of conditions and the following disclaimer.
  * Redistributions in binary form must reproduce the above copyright notice,
  * this list of conditions and the following disclaimer in the documentation
  * and/or other materials provided with the distribution.
  * <p/>
  * Neither the name of the author nor the names of its contributors
  * may be used to endorse or promote products derived from this software
  * without specific prior written permission.
  * <p/>
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS
  * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  ***/

 package org.apache.felix.gogo.jline.telnet;

 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.logging.Level;
 import java.util.logging.Logger;

 /**
  * Class that implements a connection with this telnet daemon.<br>
  * It is derived from java.lang.Thread, which reflects the architecture
  * constraint of one thread per connection. This might seem a waste of
  * resources, but as a matter of fact sharing threads would require a
  * far more complex imlementation, due to the fact that telnet is not a
  * stateless protocol (i.e. alive throughout a session of multiple requests
  * and responses).<br>
  * Each Connection instance is created by the listeners ConnectionManager
  * instance, making it part of a threadgroup and passing in an associated
  * ConnectionData instance, that holds vital information about the connection.
  * Be sure to take a look at their documention.<br>
  * <p/>
  * Once the thread has started and is running, it will get a login
  * shell instance from the ShellManager and run passing its own reference.
  *
  * @author Dieter Wimberger
  * @version 2.0 (16/07/2006)
  * @see ConnectionManager
  * @see ConnectionData
  */
 public abstract class Connection
         extends Thread {

     private static final Logger LOG = Logger.getLogger(Connection.class.getName());
     private static int number;            //unique number for a thread in the thread group
     private boolean dead;
     private List<ConnectionListener> listeners;

     //Associations
     private ConnectionData connectionData;    //associated information

     /**
      * Constructs a TelnetConnection by invoking its parent constructor
      * and setting of various members.<br>
      * Subsequently instantiates the whole i/o subsystem, negotiating
      * telnet protocol level options etc.<br>
      *
      * @param tcg ThreadGroup that this instance is running in.
      * @param cd  ConnectionData instance containing all vital information
      *            of this connection.
      * @see ConnectionData
      */
     public Connection(ThreadGroup tcg, ConnectionData cd) {
         super(tcg, ("Connection" + (++number)));

         connectionData = cd;
         //init the connection listeners for events
         //(there should actually be only one or two)
         listeners = new CopyOnWriteArrayList<>();
         dead = false;
     }//constructor

     /**
      * Method overloaded to implement following behaviour:
      * <ol>
      * <li> On first entry, retrieve an instance of the configured
      * login shell from the ShellManager and run it.
      * <li> Handle a shell switch or close down disgracefully when
      * problems (i.e. unhandled unchecked exceptions) occur in the
      * running shell.
      * </ol>
      */
     public void run() {
         try {
             doRun();

         } catch (Exception ex) {
             LOG.log(Level.SEVERE, "run()", ex); //Handle properly
         } finally {
             //call close if not dead already
             if (!dead) {
                 close();
             }
         }
         LOG.log(Level.FINE, "run():: Returning from " + this.toString());
     }//run

     protected abstract void doRun() throws Exception;

     protected abstract void doClose() throws Exception;

     /**
      * Method to access the associated connection data.
      *
      * @return ConnectionData associated with the Connection instance.
      * @see ConnectionData
      */
     public ConnectionData getConnectionData() {
         return connectionData;
     }//getConnectionData

     /**
      * Closes the connection and its underlying i/o and network
      * resources.<br>
      */
     public synchronized void close() {
         if (!dead) {
             try {
                 //connection dead
                 dead = true;
                 //close i/o
                 doClose();
             } catch (Exception ex) {
                 LOG.log(Level.SEVERE, "close()", ex);
                 //handle
             }
             try {
                 //close socket
                 connectionData.getSocket().close();
             } catch (Exception ex) {
                 LOG.log(Level.SEVERE, "close()", ex);
                 //handle
             }
             try {
                 //register closed connection in ConnectionManager
                 connectionData.getManager().registerClosedConnection(this);
             } catch (Exception ex) {
                 LOG.log(Level.SEVERE, "close()", ex);
                 //handle
             }
             try {
                 //try to interrupt it
                 interrupt();
             } catch (Exception ex) {
                 LOG.log(Level.SEVERE, "close()", ex);
                 //handle
             }


             LOG.log(Level.FINE, "Closed " + this.toString() + " and inactive.");
         }
     }//close

     /**
      * Returns if a connection has been closed.<br>
      *
      * @return the state of the connection.
      */
     public boolean isActive() {
         return !dead;
     }//isClosed

     /****** Event handling ****************/

     /**
      * Method that registers a ConnectionListener with the
      * Connection instance.
      *
      * @param cl ConnectionListener to be registered.
      * @see ConnectionListener
      */
     public void addConnectionListener(ConnectionListener cl) {
         listeners.add(cl);
     }//addConnectionListener

     /**
      * Method that removes a ConnectionListener from the
      * Connection instance.
      *
      * @param cl ConnectionListener to be removed.
      * @see ConnectionListener
      */
     public void removeConnectionListener(ConnectionListener cl) {
         listeners.remove(cl);
     }//removeConnectionListener


     /**
      * Method called by the io subsystem to pass on a
      * "low-level" event. It will be properly delegated to
      * all registered listeners.
      *
      * @param ce ConnectionEvent to be processed.
      * @see ConnectionEvent
      */
     public void processConnectionEvent(ConnectionEvent ce) {
         for (ConnectionListener cl : listeners) {
             switch (ce.getType()) {
                 case CONNECTION_IDLE:
                     cl.connectionIdle(ce);
                     break;
                 case CONNECTION_TIMEDOUT:
                     cl.connectionTimedOut(ce);
                     break;
                 case CONNECTION_LOGOUTREQUEST:
                     cl.connectionLogoutRequest(ce);
                     break;
                 case CONNECTION_BREAK:
                     cl.connectionSentBreak(ce);
                     break;
                 case CONNECTION_TERMINAL_GEOMETRY_CHANGED:
                     cl.connectionTerminalGeometryChanged(ce);
             }
         }
     }//processConnectionEvent

 }//class Connection
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	/***
	* Java TelnetD library (embeddable telnet daemon)
	* Copyright (c) 2000-2005 Dieter Wimberger
	* All rights reserved.
	* <p/>
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	* Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	* <p/>
	* Neither the name of the author nor the names of its contributors
	* may be used to endorse or promote products derived from this software
	* without specific prior written permission.
	* <p/>
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS
	* IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	* POSSIBILITY OF SUCH DAMAGE.
	***/

	package org.apache.felix.gogo.jline.telnet;

	import java.util.List;
	import java.util.concurrent.CopyOnWriteArrayList;
	import java.util.logging.Level;
	import java.util.logging.Logger;

	/**
	* Class that implements a connection with this telnet daemon.<br>
	* It is derived from java.lang.Thread, which reflects the architecture
	* constraint of one thread per connection. This might seem a waste of
	* resources, but as a matter of fact sharing threads would require a
	* far more complex imlementation, due to the fact that telnet is not a
	* stateless protocol (i.e. alive throughout a session of multiple requests
	* and responses).<br>
	* Each Connection instance is created by the listeners ConnectionManager
	* instance, making it part of a threadgroup and passing in an associated
	* ConnectionData instance, that holds vital information about the connection.
	* Be sure to take a look at their documention.<br>
	* <p/>
	* Once the thread has started and is running, it will get a login
	* shell instance from the ShellManager and run passing its own reference.
	*
	* @author Dieter Wimberger
	* @version 2.0 (16/07/2006)
	* @see ConnectionManager
	* @see ConnectionData
	*/
	public abstract class Connection
	extends Thread {

	private static final Logger LOG = Logger.getLogger(Connection.class.getName());
	private static int number; //unique number for a thread in the thread group
	private boolean dead;
	private List<ConnectionListener> listeners;

	//Associations
	private ConnectionData connectionData; //associated information

	/**
	* Constructs a TelnetConnection by invoking its parent constructor
	* and setting of various members.<br>
	* Subsequently instantiates the whole i/o subsystem, negotiating
	* telnet protocol level options etc.<br>
	*
	* @param tcg ThreadGroup that this instance is running in.
	* @param cd ConnectionData instance containing all vital information
	* of this connection.
	* @see ConnectionData
	*/
	public Connection(ThreadGroup tcg, ConnectionData cd) {
	super(tcg, ("Connection" + (++number)));

	connectionData = cd;
	//init the connection listeners for events
	//(there should actually be only one or two)
	listeners = new CopyOnWriteArrayList<>();
	dead = false;
	}//constructor

	/**
	* Method overloaded to implement following behaviour:
	* <ol>
	* <li> On first entry, retrieve an instance of the configured
	* login shell from the ShellManager and run it.
	* <li> Handle a shell switch or close down disgracefully when
	* problems (i.e. unhandled unchecked exceptions) occur in the
	* running shell.
	* </ol>
	*/
	public void run() {
	try {
	doRun();

	} catch (Exception ex) {
	LOG.log(Level.SEVERE, "run()", ex); //Handle properly
	} finally {
	//call close if not dead already
	if (!dead) {
	close();
	}
	}
	LOG.log(Level.FINE, "run():: Returning from " + this.toString());
	}//run

	protected abstract void doRun() throws Exception;

	protected abstract void doClose() throws Exception;

	/**
	* Method to access the associated connection data.
	*
	* @return ConnectionData associated with the Connection instance.
	* @see ConnectionData
	*/
	public ConnectionData getConnectionData() {
	return connectionData;
	}//getConnectionData

	/**
	* Closes the connection and its underlying i/o and network
	* resources.<br>
	*/
	public synchronized void close() {
	if (!dead) {
	try {
	//connection dead
	dead = true;
	//close i/o
	doClose();
	} catch (Exception ex) {
	LOG.log(Level.SEVERE, "close()", ex);
	//handle
	}
	try {
	//close socket
	connectionData.getSocket().close();
	} catch (Exception ex) {
	LOG.log(Level.SEVERE, "close()", ex);
	//handle
	}
	try {
	//register closed connection in ConnectionManager
	connectionData.getManager().registerClosedConnection(this);
	} catch (Exception ex) {
	LOG.log(Level.SEVERE, "close()", ex);
	//handle
	}
	try {
	//try to interrupt it
	interrupt();
	} catch (Exception ex) {
	LOG.log(Level.SEVERE, "close()", ex);
	//handle
	}


	LOG.log(Level.FINE, "Closed " + this.toString() + " and inactive.");
	}
	}//close

	/**
	* Returns if a connection has been closed.<br>
	*
	* @return the state of the connection.
	*/
	public boolean isActive() {
	return !dead;
	}//isClosed

	/**** Event handling **************/

	/**
	* Method that registers a ConnectionListener with the
	* Connection instance.
	*
	* @param cl ConnectionListener to be registered.
	* @see ConnectionListener
	*/
	public void addConnectionListener(ConnectionListener cl) {
	listeners.add(cl);
	}//addConnectionListener

	/**
	* Method that removes a ConnectionListener from the
	* Connection instance.
	*
	* @param cl ConnectionListener to be removed.
	* @see ConnectionListener
	*/
	public void removeConnectionListener(ConnectionListener cl) {
	listeners.remove(cl);
	}//removeConnectionListener


	/**
	* Method called by the io subsystem to pass on a
	* "low-level" event. It will be properly delegated to
	* all registered listeners.
	*
	* @param ce ConnectionEvent to be processed.
	* @see ConnectionEvent
	*/
	public void processConnectionEvent(ConnectionEvent ce) {
	for (ConnectionListener cl : listeners) {
	switch (ce.getType()) {
	case CONNECTION_IDLE:
	cl.connectionIdle(ce);
	break;
	case CONNECTION_TIMEDOUT:
	cl.connectionTimedOut(ce);
	break;
	case CONNECTION_LOGOUTREQUEST:
	cl.connectionLogoutRequest(ce);
	break;
	case CONNECTION_BREAK:
	cl.connectionSentBreak(ce);
	break;
	case CONNECTION_TERMINAL_GEOMETRY_CHANGED:
	cl.connectionTerminalGeometryChanged(ce);
	}
	}
	}//processConnectionEvent

	}//class Connection