Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * JBoss, Home of Professional Open Source.
    * Copyright 2012 Red Hat, Inc., and individual contributors
    * as indicated by the @author tags.
    *
    * 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.coyote.http11;
  
  import  java.nio.channels.CompletionHandler;
  
  
Http11NioProtocol Created on Jan 10, 2012 at 3:14:49 PM

Author(s):
Nabil Benothman
  
  public class Http11NioProtocol extends Http11AbstractProtocol {
  
  	protected NioEndpoint endpoint = new NioEndpoint();
  	protected NioJSSESocketChannelFactory socketFactory = null;

Create a new instance of Http11NioProtocol
  
  	public Http11NioProtocol() {
  	}
  
  	/*
  	 * (non-Javadoc)
  	 * 
  	 * @see org.apache.coyote.ProtocolHandler#getRequestGroupInfo()
  	 */
  		return .;
  	}
  
  	/*
  	 * (non-Javadoc)
  	 * 
  	 * @see org.apache.coyote.ProtocolHandler#init()
  	 */
  	public void init() throws Exception {
  
  		// Verify the validity of the configured socket factory
  		try {
  			if (isSSLEnabled()) {
  				//Possible pluggability ? SSLImplementation.getInstance(NioJSSEImplementation.class.getName());
  			}
  		} catch (Exception ex) {
  			throw ex;
 		}
 
 		if ( != null) {
 			while (attE.hasNext()) {
 				String key = attE.next();
 				Object v = .get(key);
 			}
 		}
 
 		try {
 			// endpoint.setKeepAliveTimeout(this.timeout);
 		} catch (Exception ex) {
 			throw ex;
 		}
 
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.apache.coyote.ProtocolHandler#start()
 	 */
 	public void start() throws Exception {
 			if (this. != null) {
 				try {
 					 = new ObjectName( + ":" + "type=ThreadPool,name=" + getJmxName());
 					Registry.getRegistry(nullnull).registerComponent(null);
 				} catch (Exception e) {
 				}
 				 = new ObjectName( + ":type=GlobalRequestProcessor,name=" + getJmxName());
 				Registry.getRegistry(nullnull).registerComponent(.null);
 			}
 		}
 		try {
 		} catch (Exception ex) {
 			throw ex;
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.apache.coyote.ProtocolHandler#pause()
 	 */
 	public void pause() throws Exception {
 		try {
 		} catch (Exception ex) {
 			throw ex;
 		}
 		 = false;
 		// Wait for a while until all the processors are idle
 		int retry = 0;
 		boolean done = false;
 		while (!done && retry < ....) {
 			retry++;
 			done = true;
 			for (int i = 0; i < states.lengthi++) {
 				if (states[i].getStage() == ....) {
 					try {
 						Thread.sleep(1000);
 					} catch (InterruptedException e) {
 						// NOTHING TO DO
 					}
 					done = false;
 					break;
 				}
 			}
 			if (done) {
 				 = true;
 			}
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.apache.coyote.ProtocolHandler#resume()
 	 */
 	public void resume() throws Exception {
 		try {
 		} catch (Exception ex) {
 			throw ex;
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.apache.coyote.ProtocolHandler#destroy()
 	 */
 	public void destroy() throws Exception {
 		if () {
 		} else {
 			try {
 				for (int i = 0; i < states.lengthi++) {
 					if (states[i].getStage() == ....) {
 						// FIXME: Log RequestInfo content
 					}
 				}
 			} catch (Exception ex) {
 				throw ex;
 			}
 		}
 			if ( != null)
 				Registry.getRegistry(nullnull).unregisterComponent();
 			if ( != null)
 				Registry.getRegistry(nullnull).unregisterComponent();
 		}
 	}
 
     public String getJmxName() {
         String encodedAddr = "";
         if (getAddress() != null) {
             encodedAddr = "" + getAddress();
             encodedAddr = URLEncoder.encode(encodedAddr.replace('/''-').replace(':''_').replace('%''-')) + "-";
         }
         return ("http-" + encodedAddr + .getPort());
     }
 
     public String getName() {
         String encodedAddr = "";
         if (getAddress() != null) {
             encodedAddr = getAddress() + ":";
         }
         return ("http-" + encodedAddr + .getPort());
     }

Returns:
the executor
 
 	public Executor getExecutor() {
 		return .getExecutor();
 	}

Setter for the executor

Parameters:
executor the executor to set
 
 	public void setExecutor(Executor executor) {
 		.setExecutor(executor);
 	}

Returns:
the maximum number of threads
 
 	public int getMaxThreads() {
 	}

Setter for the maximum number of threads

Parameters:
maxThreads the maximum number of threads to set
 
 	public void setMaxThreads(int maxThreads) {
 		.setMaxThreads(maxThreads);
 	}

Parameters:
size
 
 	public void setPollerSize(int size) {
 	}

Returns:
The poller size
 
 	public int getPollerSize() {
 		return this..getMaxConnections();
 	}

Returns:
the thread priority
 
 	public int getThreadPriority() {
 	}

Setter for the thread priority

Parameters:
threadPriority the thread priority to set
 
 	public void setThreadPriority(int threadPriority) {
 		.setThreadPriority(threadPriority);
 	}

Returns:
the backlog
 
 	public int getBacklog() {
 		return .getBacklog();
 	}

Setter for the backlog

Parameters:
backlog the backlog to set
 
 	public void setBacklog(int backlog) {
 		.setBacklog(backlog);
 	}

Returns:
the port number
 
 	public int getPort() {
 		return .getPort();
 	}

Setter for the port number

Parameters:
port the port number to set
 
 	public void setPort(int port) {
 	}

Returns:
the IP address
 
 	public InetAddress getAddress() {
 		return .getAddress();
 	}

Setter for the IP address

Parameters:
ia the IP address to set
 
 	public void setAddress(InetAddress ia) {
 	}

Returns:
TCP NO DELAY
 
 	public boolean getTcpNoDelay() {
 	}

Parameters:
tcpNoDelay
 
 	public void setTcpNoDelay(boolean tcpNoDelay) {
 		.setTcpNoDelay(tcpNoDelay);
 	}

Returns:
the soLinger
 
 	public int getSoLinger() {
 		return .getSoLinger();
 	}

Parameters:
soLinger the soLinger to set
 
 	public void setSoLinger(int soLinger) {
 		.setSoLinger(soLinger);
 	}

Returns:
the socket timeout
 
 	public int getSoTimeout() {
 	}

Setter for the socket timeout

Parameters:
soTimeout
 
 	public void setSoTimeout(int soTimeout) {
 		.setSoTimeout(soTimeout);
 	}

Returns:
TRUE if the reverse connection is enabled, else FALSE
 
 	public boolean getReverseConnection() {
 	}

Set the reverse connection

Parameters:
reverseConnection
 
 	public void setReverseConnection(boolean reverseConnection) {
 		.setReverseConnection(reverseConnection);
 	}

Returns:
TRUE if the defer accept is enabled, else FALSE
 
 	public boolean getDeferAccept() {
 	}

Set the defer accept

Parameters:
deferAccept
 
 	public void setDeferAccept(boolean deferAccept) {
 		.setDeferAccept(deferAccept);
 	}

The number of seconds Tomcat will wait for a subsequent request before closing the connection.

Returns:
the keep alive timeout value
 
 	public int getKeepAliveTimeout() {
 	}

Set the keep alive timeout value

Parameters:
timeout
 
 	public void setKeepAliveTimeout(int timeout) {
 	}

Returns:
the user send file boolean value
 
 	public boolean getUseSendfile() {
 	}

Set the user send file

Parameters:
useSendfile
 
 	public void setUseSendfile(boolean useSendfile) {
 		.setUseSendfile(useSendfile);
 	}

Returns:
the send file size
 
 	public int getSendfileSize() {
 	}

Parameters:
sendfileSize
 
 	public void setSendfileSize(int sendfileSize) {
 		.setSendfileSize(sendfileSize);
 	}

Return the Keep-Alive policy for the connection.

Returns:
keep-alive
 
 	public boolean getKeepAlive() {
 		return (( != 0) && ( != 1));
 	}

Set the keep-alive policy for this connection.

Parameters:
keepAlive
 
 	public void setKeepAlive(boolean keepAlive) {
 		if (!keepAlive) {
 		}
 	}
 
 	// -------------------- Various implementation classes --------------------
 
 	// -------------------- SSL related properties --------------------
 
SSL engine.

Returns:
true if the SSL is enabled, else false
 
 	public boolean isSSLEnabled() {
 	}

Parameters:
SSLEnabled
 
 	public void setSSLEnabled(boolean SSLEnabled) {
 		.setSSLEnabled(SSLEnabled);
 	}

SSL protocol.

Returns:
the SSL protocol
 
 	public String getSSLProtocol() {
 	}

Parameters:
SSLProtocol
 
 	public void setSSLProtocol(String SSLProtocol) {
 		.setSSLProtocol(SSLProtocol);
 	}

SSL password (if a cert is encrypted, and no password has been provided, a callback will ask for a password).

Returns:
the SSL password
 
 	public String getSSLPassword() {
 	}

Parameters:
SSLPassword
 
 	public void setSSLPassword(String SSLPassword) {
 		.setSSLPassword(SSLPassword);
 	}

SSL cipher suite.

Returns:
the SSL cipher suite
 
 	public String getSSLCipherSuite() {
 	}

Parameters:
SSLCipherSuite
 
 	public void setSSLCipherSuite(String SSLCipherSuite) {
 		.setSSLCipherSuite(SSLCipherSuite);
 	}

SSL certificate file.

Returns:
SSL certificate file
 
 	}

Parameters:
SSLCertificateFile
 
 	public void setSSLCertificateFile(String SSLCertificateFile) {
 		.setSSLCertificateFile(SSLCertificateFile);
 	}

SSL certificate key file.

Returns:
SSL certificate key file
 
 	}

Parameters:
SSLCertificateKeyFile
 
 	public void setSSLCertificateKeyFile(String SSLCertificateKeyFile) {
 		.setSSLCertificateKeyFile(SSLCertificateKeyFile);
 	}

SSL certificate chain file.

Returns:
SSL certificate chain file
 
 	}

Parameters:
SSLCertificateChainFile
 
 	public void setSSLCertificateChainFile(String SSLCertificateChainFile) {
 		.setSSLCertificateChainFile(SSLCertificateChainFile);
 	}

SSL CA certificate path.

Returns:
SSL CA certificate path
 
 	}

Parameters:
SSLCACertificatePath
 
 	public void setSSLCACertificatePath(String SSLCACertificatePath) {
 		.setSSLCACertificatePath(SSLCACertificatePath);
 	}

SSL CA certificate file.

Returns:
SSL CA certificate file
 
 	}

Parameters:
SSLCACertificateFile
 
 	public void setSSLCACertificateFile(String SSLCACertificateFile) {
 		.setSSLCACertificateFile(SSLCACertificateFile);
 	}

SSL CA revocation path.

Returns:
SSL CA revocation path
 
 	}

Parameters:
SSLCARevocationPath
 
 	public void setSSLCARevocationPath(String SSLCARevocationPath) {
 		.setSSLCARevocationPath(SSLCARevocationPath);
 	}

SSL CA revocation file.

Returns:
the SSL CA revocation file
 
 	}

Parameters:
SSLCARevocationFile
 
 	public void setSSLCARevocationFile(String SSLCARevocationFile) {
 		.setSSLCARevocationFile(SSLCARevocationFile);
 	}

SSL verify client.

Returns:
SSLVerifyClient
 
 	public String getSSLVerifyClient() {
 	}

Parameters:
SSLVerifyClient
 
 	public void setSSLVerifyClient(String SSLVerifyClient) {
 		.setSSLVerifyClient(SSLVerifyClient);
 	}

SSL verify depth.

Returns:
the SSL verify depth
 
 	public int getSSLVerifyDepth() {
 	}

Parameters:
SSLVerifyDepth the SSL verify depth
 
 	public void setSSLVerifyDepth(int SSLVerifyDepth) {
 		.setSSLVerifyDepth(SSLVerifyDepth);
 	}
 
 	// -------------------- Connection handler --------------------
 
Http11ConnectionHandler Created on Jan 13, 2012 at 10:45:44 AM

Author(s):
Nabil Benothman
 
 	static class Http11ConnectionHandler implements NioEndpoint.Handler {
 
 		protected Http11NioProtocol proto;
 		protected AtomicLong registerCount = new AtomicLong(0);
 		protected RequestGroupInfo global = new RequestGroupInfo();
 
 
 			private static final long serialVersionUID = 1L;
 			protected AtomicInteger size = new AtomicInteger(0);
 
 			public boolean offer(Http11NioProcessor processor) {
 				boolean offer = (. == -1) ? true
 				// avoid over growing our cache or add after we have stopped
 				boolean result = false;
 				if (offer) {
 					result = super.offer(processor);
 					if (result) {
 					}
 				}
 				if (!result)
 					unregister(processor);
 				return result;
 			}
 
 			public Http11NioProcessor poll() {
 				Http11NioProcessor result = super.poll();
 				if (result != null) {
 				}
 				return result;
 			}
 
 			public void clear() {
 				Http11NioProcessor next = poll();
 				while (next != null) {
 					unregister(next);
 					next = poll();
 				}
 				super.clear();
 				.set(0);
 			}
 		};

Create a new instance of Http11ConnectionHandler

Parameters:
proto
 
 			this. = proto;
 		}
 
 		/*
 		 * (non-Javadoc)
 		 * 
 		 * @see
 		 * org.apache.tomcat.util.net.NioEndpoint.Handler#event(java.nio.channels
 		 * .AsynchronousSocketChannel, org.apache.tomcat.util.net.ChannelStatus)
 		 */
 		// FIXME: probably needs sync due to concurrent read/write possibilities
 		public SocketState event(NioChannel channelSocketStatus status) {
 
 			Http11NioProcessor processor = .get(channel.getId());
 			if (processor != null) {
 				processor.startProcessing();
 				// Call the appropriate event
 				try {
 					state = processor.event(status);
 				} catch (java.net.SocketException e) {
 					// SocketExceptions are normal
 				} catch (java.io.IOException e) {
 					// IOExceptions are normal
                     ..socketException(e);
 				}
 				// Future developers: if you discover any other
 				// rare-but-nonfatal exceptions, catch them here, and log as
 				// above.
 				catch (Throwable e) {
 					// any other exception or error is odd. Here we log it
 					// with "ERROR" level, so it will show up even on
 					// less-than-verbose logs.
                     ..socketError(e);
 				} finally {
 					if (state != .) {
 						.remove(channel.getId());
 						if (..isRunning() && state == .) {
 							final NioChannel ch = channel;
 							try {
 										new CompletionHandler<IntegerNioEndpoint>() {
 
 											public void completed(Integer nBytes,
 													NioEndpoint endpoint) {
 												if (nBytes < 0) {
 													failed(new ClosedChannelException(), endpoint);
 												} else {
 													if (!endpoint.processChannel(chnull)) {
 													    endpoint.closeChannel(ch);
 													}
 												}
 											}
 
 											public void failed(Throwable excNioEndpoint endpoint) {
 												endpoint.closeChannel(ch);
 											}
 										});
 							} catch (Exception exp) {
 								// NOPE
 							}
 						}
 	                    processor.endProcessing();
 					} else {
 					    if (processor.isAvailable() && processor.getReadNotifications()) {
 					        // Call a read event right away
 					        state = event(channel.);
 		                    processor.endProcessing();
 					    } else if (..isRunning()) {
 					        synchronized (processor) {
 					            ..addEventChannel(channelprocessor.getTimeout(),
 					                    false,
 					                    processor.getWriteNotification(),
 					                    processor.getResumeNotification(), false);
 					            processor.endProcessing();
 					        }
 					    }
 					}
 				}
 			}
 
 			return state;
 		}
 
 		/*
 		 * (non-Javadoc)
 		 * 
 		 * @see
 		 * org.apache.tomcat.util.net.NioEndpoint.Handler#process(java.nio.channels
 		 * .AsynchronousSocketChannel)
 		 */
 		public SocketState process(NioChannel channel) {
 			try {
 				if (processor == null) {
 					processor = createProcessor();
 				}
                 processor.startProcessing();
 
                 if (. && (. != null)) {
 				} else {
 					processor.setSSLSupport(null);
 				}
 
 				SocketState state = processor.process(channel);
 
 				if (state == .) {
 					// Associate the connection with the processor. The next
 					// request processed by this thread will use either a new or
 					// a recycled processor.
 					.put(channel.getId(), processor);
 
 					if (processor.isAvailable() && processor.getReadNotifications()) {
 						// Call a read event right away
 					    state = event(channel.);
 		                processor.endProcessing();
 					} else {
 					    synchronized (processor) {
 					        ..addEventChannel(channelprocessor.getTimeout(),
 					                processor.getReadNotifications(), false,
 					                processor.getResumeNotification(), false);
 					        processor.endProcessing();
 					    }
 					}
 				} else {
 	                processor.endProcessing();
 				}
 				return state;
 
 			} catch (IOException e) {
 				if (e instanceof java.net.SocketException) {
 					// SocketExceptions are normal
                     ..socketException(e);
 				} else {
 					// IOExceptions are normal
                     ..socketException(e);
 				}
 			}
 			// Future developers: if you discover any other
 			// rare-but-non-fatal exceptions, catch them here, and log as
 			// above.
 			catch (Throwable e) {
 				// any other exception or error is odd. Here we log it
 				// with "ERROR" level, so it will show up even on
 				// less-than-verbose logs.
                 ..socketError(e);
 			}
             processor.endProcessing();
 		}

Returns:
 
 			processor.setAdapter(.);
 			processor.setTimeout(.);
 			processor.setServer(.);
 			register(processor);
 			return processor;
 		}

Parameters:
processor
 
 		protected void register(Http11NioProcessor processor) {
 				synchronized (this) {
 					try {
 						long count = .incrementAndGet();
 						ObjectName rpName = new ObjectName(.getDomain()
 								+ ":type=RequestProcessor,worker=" + .getJmxName()
 								+ ",name=HttpRequest" + count);
 						Registry.getRegistry(nullnull).registerComponent(rprpNamenull);
 						rp.setRpName(rpName);
 					} catch (Exception e) {
 					}
 				}
		}

Parameters:
processor
		protected void unregister(Http11NioProcessor processor) {
				synchronized (this) {
					try {
						ObjectName rpName = rp.getRpName();
						Registry.getRegistry(nullnull).unregisterComponent(rpName);
						rp.setRpName(null);
catch (Exception e) {
New to GrepCode? Check out our FAQ X