Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright 1997-2008 Sun Microsystems, Inc. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License. You can obtain
  * a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
  * or glassfish/bootstrap/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
  * Sun designates this particular file as subject to the "Classpath" exception
  * as provided by Sun in the GPL Version 2 section of the License file that
  * accompanied this code.  If applicable, add the following below the License
  * Header, with the fields enclosed by brackets [] replaced by your own
  * identifying information: "Portions Copyrighted [year]
  * [name of copyright owner]"
  *
  * Contributor(s):
  *
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  *
  *
  * This file incorporates work covered by the following copyright and
  * permission notice:
  *
  * Copyright 2004 The Apache Software Foundation
  *
  * Licensed 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.
  */
 
 
 
 
 package org.apache.tomcat.util.net;
 
 
 
 /* Similar with MPM module in Apache2.0. Handles all the details related with
    "tcp server" functionality - thread management, accept policy, etc.
    It should do nothing more - as soon as it get a socket ( and all socket options
    are set, etc), it just handle the stream to ConnectionHandler.processConnection. (costin)
 */



Handle incoming TCP connections. This class implement a simple server model: one listener thread accepts on a socket and creates a new worker thread for each incoming connection. More advanced Endpoints will reuse the threads, use queues, etc.

Author(s):
James Duncan Davidson [duncan@eng.sun.com]
Jason Hunter [jch@eng.sun.com]
James Todd [gonzo@eng.sun.com]
Costin@eng.sun.com
Gal Shachor [shachor@il.ibm.com]
 
 public class PoolTcpEndpoint { // implements Endpoint {
 
    private StringManager sm = 
        StringManager.getManager("org.apache.tomcat.util.net.res");
    private static final int BACKLOG = 100;
    private static final int TIMEOUT = 1000;
    private final Object threadSync = new Object();
    private boolean isPool = true;
    private int backlog = ;
    private int serverTimeout = ;
    private InetAddress inet;
    private int port;
    private ServerSocketFactory factory;
    private ServerSocket serverSocket;
    private volatile boolean running = false;
    private boolean initialized = false;
    private boolean reinitializing = false;
    static final int debug=0;
    ThreadPool tp;
    // XXX Do we need it for backward compat ?
    //protected Log _log=Log.getLog("tc/PoolTcpEndpoint", "PoolTcpEndpoint");
    static Log log=LogFactory.getLog(PoolTcpEndpoint.class );
    protected boolean tcpNoDelay=false;
    protected int linger=100;
    protected int socketTimeout=-1;
    
    public PoolTcpEndpoint() {
	//	super("tc_log");	// initialize default logger
	 = new ThreadPool();
    }
    public PoolTcpEndpointThreadPool tp ) {
        this.=tp;
    }
    // -------------------- Configuration --------------------
    public void setPoolOn(boolean isPool) {
        this. = isPool;
    }
    public boolean isPoolOn() {
        return ;
    }
    public void setMaxThreads(int maxThreads) {
	ifmaxThreads > 0)
	    .setMaxThreads(maxThreads);
    }
    public int getMaxThreads() {
        return .getMaxThreads();
    }
    public void setMaxSpareThreads(int maxThreads) {
	if(maxThreads > 0) 
	    .setMaxSpareThreads(maxThreads);
    }
    public int getMaxSpareThreads() {
        return .getMaxSpareThreads();
    }
    public void setMinSpareThreads(int minThreads) {
	if(minThreads > 0) 
	    .setMinSpareThreads(minThreads);
    }
    public int getMinSpareThreads() {
        return .getMinSpareThreads();
    }
    public int getPort() {
        return ;
    }
    public void setPort(int port ) {
        this.=port;
    }
    public InetAddress getAddress() {
	    return ;
    }
    public void setAddress(InetAddress inet) {
	    this.=inet;
    }
    public void setServerSocket(ServerSocket ss) {
	     = ss;
    }
    public void setServerSocketFactory(  ServerSocketFactory factory ) {
	    this.=factory;
    }
 	    return ;
   }
    public void setConnectionHandlerTcpConnectionHandler handler ) {
    	this.=handler;
    }
	    return ;
    }
    public boolean isRunning() {
	return ;
    }
    
    
Allows the server developer to specify the backlog that should be used for server sockets. By default, this value is 100.
    public void setBacklog(int backlog) {
	ifbacklog>0)
	    this. = backlog;
    }
    public int getBacklog() {
        return ;
    }

    
Sets the timeout in ms of the server sockets created by this server. This method allows the developer to make servers more or less responsive to having their server sockets shut down.

By default this value is 1000ms.

    public void setServerTimeout(int timeout) {
	this. = timeout;
    }
    public boolean getTcpNoDelay() {
        return ;
    }
    
    public void setTcpNoDelayboolean b ) {
    }
    public int getSoLinger() {
        return ;
    }
    
    public void setSoLingerint i ) {
    }
    public int getSoTimeout() {
        return ;
    }
    
    public void setSoTimeoutint i ) {
    }
    
    public int getServerSoTimeout() {
        return ;
    }  
    
    public void setServerSoTimeoutint i ) {
    }
    // -------------------- Public methods --------------------
    public void initEndpoint() throws IOExceptionInstantiationException {
	try {
	    if(==null)
		=ServerSocketFactory.getDefault();
	    if(==null) {
                try {
                    if ( == null) {
                         = .createSocket();
                    } else {
                         = .createSocket();
                    }
                } catch ( BindException be ) {
                    throw new BindException(be.getMessage() + ":" + );
                }
	    }
            if >= 0 )
catchIOException ex ) {
	    //	    log("couldn't start endpoint", ex, Logger.DEBUG);
            throw ex;
catchInstantiationException ex1 ) {
	    //	    log("couldn't start endpoint", ex1, Logger.DEBUG);
            throw ex1;
	}
         = true;
    }
    public void startEndpoint() throws IOExceptionInstantiationException {
        if (!) {
            initEndpoint();
        }
	if() {
	    .start();
	}
	 = true;
        if() {
    	     = new TcpWorkerThread(this);
            .runIt();
        } else {
	    .error("XXX Error - need pool !");
	}
    }
    public void stopEndpoint() {
	if () {
	    .shutdown();
	     = false;
            if ( != null) {
                closeServerSocket();
            }
	}
    }
    protected void closeServerSocket() {
        Socket s = null;
        try {
            // Need to create a connection to unlock the accept();
            if ( == null) {
                s=new Socket("127.0.0.1" );
            }else{
                s=new Socket( );
                    // setting soLinger to a small value will help shutdown the
                    // connection quicker
                s.setSoLinger(true, 0);
            }
        } catch(Exception e) {
            .error("Caught exception trying to unlock accept on " + 
                    + " " + e.toString());
        } finally {
            if (s != null) {
                try {
                    s.close();
                } catch (Exception e) {
                    // Ignore
                }
            }
        }
        try {
            if!=null)
                .close();
        } catch(Exception e) {
            .error("Caught exception trying to close socket."e);
        }
         = null;
    }
    // -------------------- Private methods
    Socket acceptSocket() {
        if( ! || ==null ) return null;
        Socket accepted = null;
    	try {
            if(==null) {
                accepted = .accept();
            } else {
                accepted = .acceptSocket();
            }
            if (null == accepted) {
                .warn("Null socket returned by accept");
            } else {
                if (!) {
                    accepted.close();  // rude, but unlikely!
                    accepted = null;
                } else if ( != null) {
                    .initSocketaccepted );
                }
            }
        }
        catch(InterruptedIOException iioe) {
            // normal part -- should happen regularly so
            // that the endpoint can release if the server
            // is shutdown.
        }
        catch (AccessControlException ace) {
            // When using the Java SecurityManager this exception
            // can be thrown if you are restricting access to the
            // socket with SocketPermission's.
            // Log the unauthorized access and continue
            String msg = .getString("endpoint.warn.security",
                                      ,ace);
            .warn(msg);
        }
        catch (IOException e) {
            String msg = null;
            if () {
                msg = .getString("endpoint.err.nonfatal",
                        e);
                .error(msge);
            }
            if (accepted != null) {
                try {
                    accepted.close();
                } catch(Throwable ex) {
                    msg = .getString("endpoint.err.nonfatal",
                                       acceptedex);
                    .warn(msgex);
                }
                accepted = null;
            }
            if( !  ) return null;
             = true;
            // Restart endpoint when getting an IOException during accept
            synchronized () {
                if () {
                     = false;
                    // 1) Attempt to close server socket
                    closeServerSocket();
                     = false;
                    // 2) Reinit endpoint (recreate server socket)
                    try {
                        msg = .getString("endpoint.warn.reinit");
                        .warn(msg);
                        initEndpoint();
                    } catch (Throwable t) {
                        msg = .getString("endpoint.err.nonfatal",
                                           t);
                        .error(msgt);
                    }
                    // 3) If failed, attempt to restart endpoint
                    if (!) {
                        msg = .getString("endpoint.warn.restart");
                        .warn(msg);
                        try {
                            stopEndpoint();
                            initEndpoint();
                            startEndpoint();
                        } catch (Throwable t) {
                            msg = .getString("endpoint.err.fatal",
                                               t);
                            .error(msgt);
                        } finally {
                            // Current thread is now invalid: kill it
                            throw new ThreadDeath();
                        }
                    }
                }
            }
        }
        return accepted;
    }

    

Deprecated:
    public void log(String msg)
    {
	.info(msg);
    }

    

Deprecated:
    public void log(String msgThrowable t)
    {
	.errormsgt );
    }

    

Deprecated:
    public void log(String msgint level)
    {
	.infomsg );
    }

    

Deprecated:
    public void log(String msgThrowable tint level) {
    	.errormsgt );
    }
    void setSocketOptions(Socket socket)
        throws SocketException {
        if( >= 0 ) 
            socket.setSoLingertrue);
        if )
            socket.setTcpNoDelay();
        if > 0 )
            socket.setSoTimeout );
    }
// -------------------- Threads --------------------
/*
 * I switched the threading model here.
 *
 * We used to have a "listener" thread and a "connection"
 * thread, this results in code simplicity but also a needless
 * thread switch.
 *
 * Instead I am now using a pool of threads, all the threads are
 * simmetric in their execution and no thread switch is needed.
 */
class TcpWorkerThread implements ThreadPoolRunnable {
    /* This is not a normal Runnable - it gets attached to an existing
       thread, runs and when run() ends - the thread keeps running.
       It's better to keep the name ThreadPoolRunnable - avoid confusion.
       We also want to use per/thread data and avoid sync wherever possible.
    */
    
    public TcpWorkerThread(PoolTcpEndpoint endpoint) {
	this. = endpoint;
    }
    public Object[] getInitData() {
        // no synchronization overhead, but 2 array access 
        Object obj[]=new Object[2];
        obj[1]= .getConnectionHandler().init();
        obj[0]=new TcpConnection();
        return obj;
    }
    
    public void runIt(Object perThrData[]) {
	// Create per-thread cache
	    Socket s = null;
	    try {
                s = .acceptSocket();
	    } finally {
		// Continue accepting on another thread...
                if (.isRunning()) {
                    ..runIt(this);
                }
            }
	    if (null != s) {
                TcpConnection con = null;
                int step = 1;
                try {
                    // 1: Set socket options: timeout, linger, etc
                    .setSocketOptionss );
                    // 2: SSL handshake
                    step = 2;
 		    if(.getServerSocketFactory()!=null) {
                        .getServerSocketFactory().handshake(s);
 		    }
                    // 3: Process the connection
                    step = 3;
                    con = (TcpConnectionperThrData[0];
		    con.setEndpoint();
		    con.setSocket(s);
                        .processConnection(con, (Object []) perThrData[1]);
                } catch (SocketException se) {
                    ..error
                        ("Remote Host " + s.getInetAddress() +
                         " SocketException: " + se.getMessage());
                    // Try to close the socket
                    try {
                        s.close();
                    } catch (IOException e) {}
                } catch (Throwable t) {
                    if (step == 2) {
                        ..error("Handshake failed"t);
                    } else {
                        ..error("Unexpected error"t);
                    }
                    // Try to close the socket
                    try {
                        s.close();
                    } catch (IOException e) {}
                } finally {
                    if (con != null) {
                        con.recycle();
                    }
                }
	    }
	}
    }
New to GrepCode? Check out our FAQ X