Modified WebServer to clean up the threading of socket communications: Made all communications via a socket (in or out) and via a linked pair of sockets (in or out of either when forwarding requests and responses to a remote server) single threaded; Attempted to clean up the way the socket listener flags are set.

Cleaned up ignored resources in the Brainstorm WebServer project by removing them from the repository.

.gitignore

@@ -25,3 +25,5 @@ build/
 archives/
 /*/controls/
 .metadata/
+Foundation TCV SWT Client Application/proxies/
+Foundation Web Server/proxies/

Foundation TCV SWT Client Application/proxies/com.foundation.tcv.controller.IServerSessionController__SZProxy.txt

@@ -1,6 +0,0 @@
-Method #0 = com.foundation.tcv.controller.IServerSessionController.closeSession
-Method #1 = com.foundation.tcv.controller.IServerSessionController.requestResourceGroupData(com.common.util.IList;
-Method #2 = com.foundation.tcv.controller.IServerSessionController.requestResourceData(com.common.util.IList;
-Method #3 = com.foundation.tcv.controller.IServerSessionController.requestInitialView
-Method #4 = com.foundation.tcv.controller.IServerSessionController.requestCodeData([Ljava.lang.String;;
-Method #5 = com.foundation.tcv.controller.IServerSessionController.processMessages(long;long;com.common.util.IList;boolean;

Foundation Web Core/src/com/foundation/web/application/WebServerApplication.java

@@ -406,6 +406,7 @@ protected void startApplication(File serverXmlPath) {
 	try {
 		ServerXml serverMetadata = parseServerXml(serverXmlPath);
 		IIterator listenerMetadataIterator = serverMetadata.listenerMetadata.iterator();
+		String debug = System.getProperty("debug");
 
 		//Setup the default log to send entries to the server app metadata which will log to file and make it available to the UI without a lot of memory overhead.//
 		try {
@@ -417,7 +418,7 @@ protected void startApplication(File serverXmlPath) {
 			Debug.log(e);
 		}//catch//
 		
-		server = new WebServer(false);
+		server = new WebServer(debug != null ? Boolean.parseBoolean(debug) : false);
 		
 		//Setup the listener services.//
 		while(listenerMetadataIterator.hasNext()) {

Foundation Web Core/src/com/foundation/web/server/WebServer.java

@@ -16,6 +16,7 @@ import java.io.PrintStream;
 import java.io.UnsupportedEncodingException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
+import java.net.URLDecoder;
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
 import java.nio.channels.ClosedChannelException;
@@ -98,7 +99,7 @@ public class WebServer {
 	/** Flag indicating whether the web server is active.  The attributes cannot be changed in a thread unsafe manner when this is set. */
 	private volatile boolean isStarted = false;
 	/** Whether to report all errors.  If false, many networking errors (usually results of browsers terminating connections) will not be reported. */
-	private boolean debug = false;
+	private boolean debug = true;
 	/** The handler called on to get a result for a bad request. */
 	private IWebServerErrorHandler errorHandler = null;
 	/** The maximum length of any request's content block. */
@@ -224,6 +225,7 @@ public class WebServer {
 			
 			//Flip the buffer (if not already flipped) so we can write out the bytes.//
 			if(buffer.position() != 0) buffer.flip();
+			this.response = response;
 		}//MessageBuffer()//
 		/**
 		 * MessageBuffer constructor.
@@ -283,7 +285,16 @@ public class WebServer {
 	private abstract class AbstractSocketContext extends ChannelContext {
 		/** The key that represents the connection between the channel (socket) and the selector used to multiplex the listener. */
 		public SelectionKey key = null;
+//		/** The SelectionKey flags that will be used when the NetworkListener thread finishes processing the input/output of a message.  The thread can safely change these flags without synchronizing. */
+//		private int flags = 0;
+		/** A socket context related to this one (when two are tied together such that data from one immediately is sent to the other). */
+		protected AbstractSocketContext relatedSocketContext = null;
 		
+		/**
+		 * Whether this socket context should be synchronized on before the related socket context (if one exists).  This simply allows locking to always occur in the same order, preventing deadlocking in the case of related sockets and bad behavior (or SPEEDY like pipelining).
+		 * @return Whether this context is to be locked before the related context (if it exists).
+		 */
+		protected abstract boolean lockFirst();
 		/**
 		 * Processes the next response in the sequence.
 		 * @throws IOException
@@ -304,11 +315,23 @@ public class WebServer {
 		 * Closes the socket context and cleans up.
 		 */
 		protected abstract void close();
+		protected AbstractSocketContext getRelatedSocketContext() {
+			return relatedSocketContext;
+		}
+		/*
+		protected void setFlags(int flags) {
+			this.flags = flags;
+		}
+		protected int getFlags() {
+			return flags;
+		}
+		*/
 		/**
 		 * Updates the write flag status.
 		 * @param requiresWrite Whether a write is required.
 		 */
 		protected void flagWrite(boolean requiresWrite) {
+			
 			synchronized(key) {
 				int ops = key.interestOps();
 				boolean hasWrite = (ops & SelectionKey.OP_WRITE) != 0;
@@ -324,12 +347,26 @@ public class WebServer {
 					}//if//
 				}//else//
 			}//synchronized//
+			
+//			boolean hasWrite = (flags & SelectionKey.OP_WRITE) != 0;
+//			
+//			if(requiresWrite) {
+//				if(!hasWrite) {
+//					flags |= SelectionKey.OP_WRITE;
+//				}//if//
+//			}//if//
+//			else {
+//				if(hasWrite) {
+//					flags ^= SelectionKey.OP_WRITE;
+//				}//if//
+//			}//else//
 		}//flagWrite()//
 		/**
 		 * Updates the read flag status.
 		 * @param requiresRead Whether a read is required.
 		 */
 		protected void flagRead(boolean requiresRead) {
+			
 			synchronized(key) {
 				int ops = key.interestOps();
 				boolean hasRead = (ops & SelectionKey.OP_READ) != 0;
@@ -345,21 +382,68 @@ public class WebServer {
 					}//if//
 				}//else//
 			}//synchronized//
+			
+//			boolean hasRead = (flags & SelectionKey.OP_READ) != 0;
+//			
+//			if(requiresRead) {
+//				if(!hasRead) {
+//					flags |= SelectionKey.OP_READ;
+//				}//if//
+//			}//if//
+//			else {
+//				if(hasRead) {
+//					flags ^= SelectionKey.OP_READ;
+//				}//if//
+//			}//else//
 		}//flagWrite()//
+		protected void flagReadWrite(boolean requiresRead, boolean requiresWrite) {
+			synchronized(key) {
+				int ops = key.interestOps();
+				boolean hasRead = (ops & SelectionKey.OP_READ) != 0;
+				boolean hasWrite = (ops & SelectionKey.OP_WRITE) != 0;
+				
+				if(requiresRead) {
+					if(!hasRead) {
+						ops |= SelectionKey.OP_READ;
+					}//if//
+				}//if//
+				else {
+					if(hasRead) {
+						ops ^= SelectionKey.OP_READ;
+					}//if//
+				}//else//
+				
+				if(requiresWrite) {
+					if(!hasWrite) {
+						ops |= SelectionKey.OP_WRITE;
+					}//if//
+				}//if//
+				else {
+					if(hasWrite) {
+						ops ^= SelectionKey.OP_WRITE;
+					}//if//
+				}//else//
+				
+				key.interestOps(ops);
+			}//synchronized//
+		}//flagReadWrite()//
 		protected void flagReadWrite() {
 			synchronized(key) {
 				key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
 			}//synchronized//
+//			flags = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
 		}//flagReadWrite()//
 		protected void flagWriteOnly() {
 			synchronized(key) {
 				key.interestOps(SelectionKey.OP_WRITE);
 			}//synchronized//
+//			flags = SelectionKey.OP_WRITE;
 		}//flagWriteOnly()//
 		protected void flagReadOnly() {
 			synchronized(key) {
 				key.interestOps(SelectionKey.OP_READ);
 			}//synchronized//
+//			flags = SelectionKey.OP_READ;
 		}//flagReadOnly()//
 	}//AbstractSocketContext//
 	
@@ -406,14 +490,13 @@ public class WebServer {
 	 * Allows the web server to act as an SSL front to another web server or service.
 	 */
 	private class PassThroughSocketContext extends AbstractSocketContext {
-		private SocketContext linkedClientContext;
 		private MessageBuffer pendingMessageBuffer = null;
 		private MessageBuffer lastAddedMessageBuffer = null;
 		/** The byte buffer used to read data from the socket. */
 		public ByteBuffer socketReadBuffer = ByteBuffer.allocate(BUFFER_SIZE);
 		
 		public PassThroughSocketContext(SocketContext linkedClientContext, String address, int port) throws IOException {
-			this.linkedClientContext = linkedClientContext;
+			this.relatedSocketContext = linkedClientContext;
 			SocketChannel channel = SocketChannel.open();
 			RegisterKeyRunnable runnable;
 			
@@ -428,13 +511,19 @@ public class WebServer {
 			linkedClientContext.key.selector().wakeup();
 			runnable.waitForRun();
 			key = runnable.getKey();
-			flagRead(true);
+			flagReadOnly();
 		}//PassThroughSocketContext()//
+		/* (non-Javadoc)
+		 * @see com.foundation.web.server.WebServer.AbstractSocketContext#lockFirst()
+		 */
+		protected boolean lockFirst() {
+			return false;
+		}//lockFirst()//
 		/* (non-Javadoc)
 		 * @see com.foundation.web.server.WebServer.AbstractSocketContext#processResponses()
 		 */
 		protected synchronized void processResponses() throws IOException {
-			//Actually this is called when a request is being sent via the pass through socket (sending the request to the remote process).//
+			//Actually this is called when a request is being sent via the pass through socket (sending the request to the remote server).//
 			//Synchronized to avoid accessing the pendingMessageBuffer and lastAddedMessageBuffer at the same time as a thread that is calling passThrough(ByteBuffer) which also accesses these variables.//
 			boolean result = true;
 			
@@ -481,9 +570,13 @@ public class WebServer {
 				}//while//
 			}//if//
 			
-			if(result) {
+			//If we were able to send all the message data, then flag to read the response from the remote server (if more data comes in from the client, we will change this flag).//
-				flagWrite(true);
+			if(pendingMessageBuffer == null) {
+				flagReadOnly();
 			}//if//
+			else {
+				flagReadWrite();
+			}//else//
 		}//processResponses()//
 		/* (non-Javadoc)
 		 * @see com.foundation.web.server.WebServer.AbstractSocketContext#processRequest()
@@ -506,12 +599,12 @@ public class WebServer {
 //TODO: Comment me.
 //Debug.log("Git Closed Socket");
 					//The socket has been closed by the client.//
-					linkedClientContext.close();
+					try {relatedSocketContext.close();} catch(Throwable e) {}
 				}//if//
 				else if(socketReadBuffer.hasRemaining()) {
 //TODO: Comment me.
 //Debug.log("Git Sent " + count + " bytes.");
-					result = linkedClientContext.passThrough(socketReadBuffer);
+					result = relatedSocketContext.passThrough(socketReadBuffer);
 					socketReadBuffer.compact();
 				}//else//
 				else {
@@ -520,7 +613,7 @@ public class WebServer {
 				}//else//
 			}//while//
 			
-			//Always keep the read flag up for pass through sockets.//
+			//Always keep the read flag up for pass through sockets (leave the write flag alone).//
 			flagRead(true);
 		}//processRequest()//
 		/* (non-Javadoc)
@@ -540,7 +633,7 @@ public class WebServer {
 //TODO: Comment me.
 //Debug.log("Posting request content to Git.");
 				pendingMessageBuffer = lastAddedMessageBuffer = message;
-				flagWrite(true);
+				flagReadWrite();
 			}//if//
 			else {
 //TODO: Comment me.
@@ -615,10 +708,10 @@ public class WebServer {
 		private int sentBytes = 0;
 		/** Tracks the debug output for the current request/response cycle.  This is only used when debugging. */
 		public StringBuffer debugBuffer = null; //debug ? new StringBuffer(1000) : null;
-		/** Used to pass all traffic (once unencrypted) through another socket to another process. */
-		private PassThroughSocketContext passThroughSocketContext = null;
 		/** The optional application specific data indexed by an application spectific key.  Elements (values, not keys) which implement ISessionLifecycleAware will be released when the socket context is released. */
 		private LiteHashMap applicationDataMap;
+		/** Used to identify the first unencrypted message (ignored if ssl is being used) so that forwarding to a remote server can be accomplished. */
+		private boolean isFirstUnencryptedMessage = true;
 		
 		public SocketContext(ServerSocketContext serverSocketContext) {
 			super();
@@ -626,6 +719,19 @@ public class WebServer {
 				this.id = nextSocketContextId++;
 			}//synchronized//
 		}//SocketContext()//
+		/**
+		 * Gets the pass through socket context associated with this socket context, or null if none exists.
+		 * @return The socket context for the pass through socket used to handle all incoming requests from the client on this socket.
+		 */
+		protected PassThroughSocketContext getPassThroughSocketContext() {
+			return (PassThroughSocketContext) getRelatedSocketContext();
+		}//getPassThroughSocketContext()//
+		/* (non-Javadoc)
+		 * @see com.foundation.web.server.WebServer.AbstractSocketContext#lockFirst()
+		 */
+		protected boolean lockFirst() {
+			return true;
+		}//lockFirst()//
 		protected synchronized void close() {
 			try {
 				if(applicationDataMap != null) {
@@ -651,8 +757,8 @@ public class WebServer {
 			//Clean up after the response and request.//
 			try {if(currentResponse != null) currentResponse.close();} catch(Throwable e2) {}
 			
-			if(passThroughSocketContext != null) {
+			if(getPassThroughSocketContext() != null) {
-				passThroughSocketContext.close();
+				getPassThroughSocketContext().close();
 			}//if//
 		}//close()//
 		/* (non-Javadoc)
@@ -1020,12 +1126,12 @@ public class WebServer {
 		 * @see com.foundation.web.server.WebServer.AbstractSocketContext#processResponses()
 		 */
 		protected void processResponses() throws IOException {
-			if(passThroughSocketContext != null) {
+			if(getPassThroughSocketContext() != null) {
 				//Synchronized to avoid multiple threads accessing the pendingOutboundMessage chain at one time and updating the write flag out of order (could happen if we enabled request chaining over a single socket).//
 				synchronized(this) {
 					writeClientResponse();
 					//Set the write flag if we have more to write.//
-					flagWrite(pendingOutboundMessage != null);
+					flagReadWrite(true, pendingOutboundMessage != null);
 				}//synchronized//
 			}//if//
 			else {
@@ -1036,7 +1142,7 @@ public class WebServer {
 					flagReadOnly();
 				}//if//
 				else {
-					flagWriteOnly();
+					flagReadWrite();
 				}//else//
 			}//else//
 		}//processCurrentResponse()//
@@ -1203,6 +1309,22 @@ public class WebServer {
 				if(result && pendingOutboundMessage != null) {
 					//Check to see if the outbound message is prepared to send more content.  For chunked transfers the outbound message may be waiting for additional content from another stream and we should return later.//
 					if(result && !pendingOutboundMessage.getBuffer().hasRemaining()) {
+						/*
+						if(!pendingOutboundMessage.loadBuffer()) {
+							if(pendingOutboundMessage.getNext() != null) {
+								pendingOutboundMessage = pendingOutboundMessage.getNext();
+							}//if//
+							else {
+								result = false;
+							}//else//
+						}//if//
+						
+						if(pendingOutboundMessage.getBuffer() == null) {
+							pendingOutboundMessage = null;
+							lastAddedMessageBuffer = null;
+						}//if//
+						*/
+						
 						//Attempt to load additional message bytes into the buffer.//
 						boolean couldLoadAdditionalBytes = pendingOutboundMessage.loadBuffer();
 						
@@ -1336,6 +1458,22 @@ public class WebServer {
 									result = false;
 								}//if//
 								else {
+									/*
+									if(!pendingOutboundMessage.loadBuffer()) {
+										if(pendingOutboundMessage.getNext() != null) {
+											pendingOutboundMessage = pendingOutboundMessage.getNext();
+										}//if//
+										else {
+											result = false;
+										}//else//
+									}//if//
+									
+									if(pendingOutboundMessage.getBuffer() == null) {
+										pendingOutboundMessage = null;
+										lastAddedMessageBuffer = null;
+									}//if//
+									*/
+									
 									//Attempt to load additional message bytes into the buffer.//
 									boolean couldLoadAdditionalBytes = pendingOutboundMessage.loadBuffer();
 									
@@ -1468,7 +1606,7 @@ public class WebServer {
 							IPassThroughDomain passThroughDomain = ((IPassThroughDomain) application);
 							
 							//Setup the pass through socket context (and socket channel).  All data will be sent to this context to be sent to the remote process.//
-							passThroughSocketContext = new PassThroughSocketContext(this, passThroughDomain.getAddress(), passThroughDomain.getPort());
+							relatedSocketContext = new PassThroughSocketContext(this, passThroughDomain.getAddress(), passThroughDomain.getPort());
 						}//if//
 					}//if//
 				}//if//
@@ -1557,7 +1695,7 @@ public class WebServer {
 										sslNeedsWrap = true;
 										
 										//Need to synchronize if this is a pass through socket so that multiple threads don't access pendingOutboundMessage or lastAddedMessageBuffer (via a call to passThrough(ByteBuffer) on another thread).//
-										if(passThroughSocketContext == null) {
+										if(getPassThroughSocketContext() == null) {
 											result = writeClientResponse();
 										}//if//
 										else {
@@ -1570,14 +1708,14 @@ public class WebServer {
 									//If bytes were produced then process them.//
 									if(sslResult.bytesProduced() > 0) {
 										//If we are not passing all content to another process then handle it by calling processClientRequest, otherwise pass it through.//
-										if(passThroughSocketContext == null) {
+										if(getPassThroughSocketContext() == null) {
 											result = WebServer.this.processClientRequest((SocketContext) this, unencryptedReadBuffer, key);
 										}//if//
 										else {
 //TODO: Comment me.
 //Debug.log("Receiving message (" + unencryptedReadBuffer.remaining() + " bytes) from client for git.");
 											//Queue the data for sending to the remote process via the pass through socket context.//
-											passThroughSocketContext.passThrough(unencryptedReadBuffer);
+											getPassThroughSocketContext().passThrough(unencryptedReadBuffer);
 											result = true;
 										}//else//
 									}//if//
@@ -1605,15 +1743,41 @@ public class WebServer {
 				//Note: We are throddling this for active connections to prevent a single connection from hogging all the resources.//
 				while(loopCount < 10 && result && count > 0) {
 					loopCount++;
-					socketReadBuffer.position(0);
+					//Allow data to be left on the socket read buffer.//
-					socketReadBuffer.limit(socketReadBuffer.capacity());
+					if(socketReadBuffer.position() != 0) socketReadBuffer.compact();
 					count = channel.read(socketReadBuffer);
 					socketReadBuffer.flip();
 					
+					//Setup the pass through socket if the application is an instance of IPassThroughDomain.//
+					if(count != -1 && isFirstUnencryptedMessage) {
+						//Read enough of the header to identify the application.//
+						if(WebServer.this.processRequestedHost((SocketContext) this, socketReadBuffer, key)) {
+							//Create a pass through socket and context and attach it to this context if the application is setup as a pass through to another process.//
+							IWebApplication application = webApplicationContainer.getWebApplication();
+							
+							if(application instanceof IPassThroughDomain) {
+								IPassThroughDomain passThroughDomain = ((IPassThroughDomain) application);
+								
+								//Setup the pass through socket context (and socket channel).  All data will be sent to this context to be sent to the remote process.//
+								relatedSocketContext = new PassThroughSocketContext(this, passThroughDomain.getAddress(), passThroughDomain.getPort());
+							}//if//
+							
+							isFirstUnencryptedMessage = false;
+						}//if//
+						else {
+							//We couldn't even read the host from the first bytes sent by the client - very unusual (it should be in the first couple hundred bytes - less than a single packet).//
+							//TODO: We could cycle and wait for the next packet.  For now just close the socket since this should never really happen in the first place.
+							close();
+						}//else//
+					}//if//
+					
 					if(count == -1) {
 						//The socket has been closed by the client.//
 						close();
 					}//if//
+					else if(relatedSocketContext != null) {
+						relatedSocketContext.passThrough(socketReadBuffer);
+					}//else if//
 					else if(socketReadBuffer.hasRemaining()) {
 						result = WebServer.this.processClientRequest((SocketContext) this, socketReadBuffer, key);
 					}//else//
@@ -1627,7 +1791,7 @@ public class WebServer {
 				flagReadOnly();
 			}//if//
 			else {
-				flagWriteOnly();
+				flagReadWrite();
 			}//else//
 		}//processRequest()//
 	}//SocketContext//
@@ -1801,8 +1965,16 @@ public class WebServer {
 
 						//Toggle the write or read flag.//
 						synchronized(key) {
-							//Enabling pipelining of messages (some HTTP protocols allow it now - see Google Speedy), and pass through might require it.//
+//							//Save the ops that will be set when the processing is complete.//
+//							((AbstractSocketContext) context).setFlags(key.interestOps());
+							
+							//Notes: Java (pre-jdk7) does not have the ability to read and write to a socket at the same time (two threads, one socket).  Post jdk7 there is AsynchronousSocketChannel and AsynchronousServerSocketChannel which could be used to send/receive at the same time.
+							//Truely enabling Speedy would require a thread to read which when finished would flag read again BEFORE processing the message and BEFORE sending a response.
+							//For now (so we don't have to require jdk7 yet) we will simply allow Speedy to queue up messages, but only read, process, and then write them one at a time.  Most of the speed loss is in the waiting for the WRITE to finish before handling the next request (due to it being broken into packets and the mechanics of TCP), and that is generally minimal (speed lose) since usually the bottleneck in speed is the browser's connection to the internet (most of us haven't got Gigabit Ethernet at home).  Anyone with enough home juice to have this be a problem would only notice the difference for really porky websites (which is a problem in and of its self).
+							
 							key.interestOps(key.interestOps() ^ (isWrite ? SelectionKey.OP_WRITE : SelectionKey.OP_READ));
+							//Not allowing either reads or writes to continue until all processing of this message is done.//
+//							key.interestOps(0);
 						}//synchronized//
 						
 						try {
@@ -1820,17 +1992,53 @@ public class WebServer {
 //										Debug.log("Socket is write available: " + ((SocketChannel) channel).socket().getInetAddress() + ":" + ((SocketChannel) channel).socket().getPort());
 //									}//if//
 									
-									//Process the pending write to the socket as much as is possible, then return.//
+									//Lock on both contexts if there is a related socket - do it deadlock safe.//
-									((AbstractSocketContext) context).processResponses();
+									if(((AbstractSocketContext) context).getRelatedSocketContext() == null) {
+										//Prevent another thread from reading/writing on the same socket at the same time (safety).  This would have to be removed if SPEEDY (or similar pipelining) were allowed, and AsynchronousSocketChannel/AsynchronousServerSocketChannel would have to be used (requiring jdk7).//
+										synchronized(context) {
+											//Process the pending write to the socket as much as is possible, then return.//
+											((AbstractSocketContext) context).processResponses();
+										}//synchronized//
+									}//if//
+									else {
+										Object lockFirst = ((AbstractSocketContext) context).lockFirst() ? context : ((AbstractSocketContext) context).getRelatedSocketContext();
+										Object lockSecond = ((AbstractSocketContext) context).lockFirst() ? ((AbstractSocketContext) context).getRelatedSocketContext() : context;
+										
+										//Prevent another thread from reading/writing on the same socket at the same time (safety).  This would have to be removed if SPEEDY (or similar pipelining) were allowed, and AsynchronousSocketChannel/AsynchronousServerSocketChannel would have to be used (requiring jdk7).//
+										synchronized(lockFirst) {
+											synchronized(lockSecond) {
+												//Process the pending write to the socket as much as is possible, then return.//
+												((AbstractSocketContext) context).processResponses();
+											}//synchronized//
+										}//synchronized//
+									}//else//
 								}//if//
 								else {
 //									if(debug) {
 //										((SocketContext) context).debugBuffer.append("Socket is now read available.\n");
 //										Debug.log("Socket is read available: " + ((SocketChannel) channel).socket().getInetAddress() + ":" + ((SocketChannel) channel).socket().getPort());
 //									}//if//
-									
+
-									//Process the incoming request and send the response (a partial response may be sent in which case the socket will be set to wait for a write opportunity and not a read opportunity).//
+									//Lock on both contexts if there is a related socket - do it deadlock safe.//
-									((AbstractSocketContext) context).processRequest();
+									if(((AbstractSocketContext) context).getRelatedSocketContext() == null) {
+										//Prevent another thread from reading/writing on the same socket at the same time (safety).  This would have to be removed if SPEEDY (or similar pipelining) were allowed, and AsynchronousSocketChannel/AsynchronousServerSocketChannel would have to be used (requiring jdk7).//
+										synchronized(context) {
+											//Process the incoming request and send the response (a partial response may be sent in which case the socket will be set to wait for a write opportunity and not a read opportunity).//
+											((AbstractSocketContext) context).processRequest();
+										}//synchronized//
+									}//if//
+									else {
+										Object lockFirst = ((AbstractSocketContext) context).lockFirst() ? context : ((AbstractSocketContext) context).getRelatedSocketContext();
+										Object lockSecond = ((AbstractSocketContext) context).lockFirst() ? ((AbstractSocketContext) context).getRelatedSocketContext() : context;
+										
+										//Prevent another thread from reading/writing on the same socket at the same time (safety).  This would have to be removed if SPEEDY (or similar pipelining) were allowed, and AsynchronousSocketChannel/AsynchronousServerSocketChannel would have to be used (requiring jdk7).//
+										synchronized(lockFirst) {
+											synchronized(lockSecond) {
+												//Process the incoming request and send the response (a partial response may be sent in which case the socket will be set to wait for a write opportunity and not a read opportunity).//
+												((AbstractSocketContext) context).processRequest();
+											}//synchronized//
+										}//synchronized//
+									}//else//
 								}//else//
 							}//if//
 						}//try//
@@ -1839,9 +2047,7 @@ public class WebServer {
 							try {((SocketChannel) channel).close();}catch(Throwable e2) {}  //Release the socket so the message doesn't continue to be processed.//
 						}//catch//
 						catch(Throwable e) {
-							if(debug) {
+							if(debug) Debug.log(e);
-								Debug.log(e);
-							}//if//
 							
 							//Force the socket to be closed (for sure).//
 							try {((SocketChannel) channel).close();}catch(Throwable e2) {}
@@ -1854,6 +2060,10 @@ public class WebServer {
 							if(channel != null && !socketClosed && channel.isOpen() && key != null && context != null) {
 								requiresWakeup = true;
 								
+//								//Set the flags (either READ/WRITE) for the socket.//
+//								synchronized(key) {
+//									key.interestOps(((AbstractSocketContext) context).getFlags());
+//								}//synchronized//
 							}//if//
 							else if(channel != null && (!channel.isOpen() || socketClosed) && channel instanceof SocketChannel && context instanceof SocketContext) {
 								cleanupClientChannel((SocketContext) context, (SocketChannel) channel);
@@ -2416,6 +2626,84 @@ private boolean parseFirstTlsMessage(SocketContext context, SocketChannel channe
 private boolean isCompleteHeader(StringBuffer buffer) {
 	return (buffer.length() > 4) && (buffer.charAt(buffer.length() - 4) == '\r') && (buffer.charAt(buffer.length() - 3) == '\n') && (buffer.charAt(buffer.length() - 2) == '\r') && (buffer.charAt(buffer.length() - 1) == '\n');
 }//isCompleteHeader()//
+/**
+ * Processes enough of the header of this first request to identify the application and set it for the socket.  Used to forward unencrypted message to a remote server.
+ * @param context
+ * @param fragment
+ * @param key
+ * @return Whether enough of the request could be read to identify the application.  The caller should ignore the result if key.channel() is closed since the request was incomplete, incorrectly formatted, or the socket failed.
+ */
+private boolean processRequestedHost(SocketContext context, ByteBuffer fragment, SelectionKey key) throws IOException {
+	boolean result = false;
+
+	try {
+		fragment.mark();
+		
+		//Check whether we already read this message's header and we are simply appending to the end of it.//
+		if(context.request == null) {
+			String host = null;
+			StringBuilder buffer = new StringBuilder(4096);
+			int totalHeaderSize = 0;
+			
+			while(fragment.hasRemaining() && host == null) {
+				//Keep adding ASCII characters to the message header fragment until the next line is read or we exceed the maximum length of the header.//
+				while(fragment.hasRemaining() && (!(buffer.length() > 1 && (buffer.charAt(buffer.length() - 2) == '\r') && (buffer.charAt(buffer.length() - 1) == '\n')))) {
+					if(totalHeaderSize == 4096) {
+						//Force the connection to the client to be closed.//
+						try {key.channel().close();}catch(Throwable e2) {}
+						//Throw an exception that should not be logged.  This happens occationally when an attacker tries to exploit any buffer overrun weaknesses.//
+						throw new IgnoredIOException(null);
+					}//if//
+					
+					buffer.append((char) fragment.get());
+					totalHeaderSize++;
+				}//while//
+				
+				//If we have the minimum number of bytes and the last bytes are a line end, then check the line for "Host: xxxxxxx\r\n"
+				String line = buffer.toString().substring(0, buffer.length() - 2).trim();
+				if(line.startsWith("Host: ")) {
+					host = line.substring(6).trim();
+				}//if//
+				
+				if(host == null) {
+					if(buffer.length() == 2) {
+						//End of the header reached.  No host provided.  Kill the connection?//
+						//Force the connection to the client to be closed.//
+						try {key.channel().close();}catch(Throwable e2) {}
+						//Throw an exception that should not be logged.  This happens occationally when an attacker tries to exploit any header reading weaknesses (all major browsers send a host header).//
+						throw new IgnoredIOException(null);
+					}//if//
+					else {
+						//Clear the line.//
+						buffer.setLength(0);
+					}//else//
+				}//if//
+			}//while//
+			
+			//If we found the complete first line of the header before running out of bytes, then identify the application.//
+			if(host != null) {
+				context.domain = host.toLowerCase();
+				
+				//Get the web application for the given domain.//
+				//Synchronize to prevent another thread from altering the service's web applications while we are accessing it.//
+				synchronized(WebServer.this) {
+					context.webApplicationContainer = context.serverSocketContext.serviceListener.getWebApplicationContainer(context.domain);
+				}//synchronized//
+				
+				result = true;
+			}//if//
+		}//if//
+		
+		fragment.reset();
+	}//try//
+	catch(IgnoredIOException e) {}
+	catch(Throwable e) {
+		Debug.log(e);
+		throw new IOException("Failed to process the request headers.");
+	}//catch//
+	
+	return result;
+}//processRequestedHost()//
 /**
  * Processes the client request given the latest fragment of a message.
  * @param context The client context.

Foundation Web Server/Web Server (Brainstorm Web Server) Loads Webapps From Project.launch

@@ -11,5 +11,5 @@
 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="com.foundation.web.application.BrainstormWebServer"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="&quot;./../Archives/Binaries/Brainstorm Web Server Core.jar&quot; &quot;./../SWT/releases/win32-win32-x86_64/swt.jar&quot;"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="Foundation Web Server"/>
-<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Dpath.server.xml=&quot;./server.xml&quot; -Dproperties=&quot;./release.properties&quot;"/>
+<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Dpath.server.xml=&quot;./server.xml&quot; -Dproperties=&quot;./release.properties&quot; -Ddebug=true"/>
 </launchConfiguration>

Foundation Web Server/installed.webapps.xml

@@ -1,3 +0,0 @@
-<webapps>
-<webapp name="Declarative Engineering" zip-file=".&#92;webapp-archives&#92;Declarative Engineering.zip" base-dir=".&#92;webapps&#92;Declarative Engineering" webapp-class-name="com.de22.release.application.WebApplicationFactory" hash="B3138EB7B50F081463CFCE8BC7BC9AA7B1A86DE1"/>
-</webapps>

Foundation Web Server/proxies/com.foundation.web.server.shared.model.IWebappLog__SZProxy.txt

@@ -1,62 +0,0 @@
-Method #0 = com.foundation.web.server.shared.model.IWebappLog.getEntryCount
-Method #1 = com.foundation.web.server.shared.model.IWebappLog.getEntries(int;int;
-Method #2 = com.foundation.common.IEntity.getApplication
-Method #3 = com.foundation.common.IEntity.getTransactionService
-Method #4 = com.foundation.common.IEntity.getIsAltered
-Method #5 = com.foundation.common.IEntity.entityUpdate(com.foundation.transaction.TransactionContextHolder;
-Method #6 = com.foundation.common.IEntity.entityUpdate(java.lang.Runnable;int;
-Method #7 = com.foundation.common.IEntity.entityUpdate(java.lang.Runnable;java.lang.Object;int;
-Method #8 = com.foundation.common.IEntity.entityUpdate(java.lang.Runnable;
-Method #9 = com.foundation.common.IEntity.entityUpdate(int;
-Method #10 = com.foundation.common.IEntity.entityUpdate
-Method #11 = com.foundation.common.IEntity.entityUpdate(java.lang.Runnable;java.lang.Object;
-Method #12 = com.foundation.common.IEntity.entityDelete(com.foundation.transaction.TransactionContextHolder;
-Method #13 = com.foundation.common.IEntity.entityDelete(int;
-Method #14 = com.foundation.common.IEntity.entityDelete
-Method #15 = com.foundation.common.IEntity.isObjectNew
-Method #16 = com.foundation.common.IEntity.entitySetKey(java.lang.Object;
-Method #17 = com.foundation.common.IEntity.entityGetKey
-Method #18 = com.foundation.common.IEntity.getAttributeSupport
-Method #19 = com.foundation.common.IEntity.getAttributeCount
-Method #20 = com.foundation.common.IEntity.getAttributeName(int;
-Method #21 = com.foundation.common.IEntity.getOldAttributeValue(com.foundation.metadata.Attribute;
-Method #22 = com.foundation.common.IEntity.isObjectRepositoryBound
-Method #23 = com.foundation.common.IEntity.getIsObjectChanged
-Method #24 = com.foundation.common.IEntity.getIsVirtualObjectChanged
-Method #25 = com.foundation.common.IEntity.resetObjectChangeFlags
-Method #26 = com.foundation.common.IEntity.resetVirtualObjectChangeFlags
-Method #27 = com.foundation.common.IEntity.reverseObjectChanges
-Method #28 = com.foundation.common.IEntity.reverseVirtualObjectChanges
-Method #29 = com.foundation.common.IEntity.getIsVirtualObjectAltered
-Method #30 = com.foundation.common.IEntity.resetAlteredFlag
-Method #31 = com.foundation.common.IEntity.getPartOfEntity
-Method #32 = com.foundation.common.IEntity.getPartOfEntityCounter
-Method #33 = com.foundation.common.IEntity.getRepositoryIdentifier(java.lang.Object;
-Method #34 = com.foundation.common.IEntity.getRepositoryIdentifier
-Method #35 = com.foundation.common.IEntity.useRepositoryVersionTracking
-Method #36 = com.foundation.common.IEntity.resetVirtualObjectAlteredFlags
-Method #37 = com.foundation.attribute.IReflectableObject.reflectionLoadAttribute(java.lang.String;com.foundation.attribute.IReflectUpdateHandler;com.foundation.attribute.ReflectRegistrationData;
-Method #38 = com.foundation.attribute.IReflectable.isReflection(com.foundation.attribute.ReflectionContext;
-Method #39 = com.foundation.attribute.IReflectable.isReflection
-Method #40 = com.foundation.attribute.IReflectable.getReflected
-Method #41 = com.foundation.attribute.IReflectable.getReflectionContext
-Method #42 = com.foundation.attribute.IReflectable.zzrReflectionRegister(com.foundation.attribute.IReflectUpdateHandler;com.foundation.attribute.ReflectRegistrationData;
-Method #43 = com.foundation.attribute.IReflectable.reflectionSynchronize(com.foundation.attribute.IReflectUpdateHandler;com.foundation.attribute.AbstractReflectData;com.foundation.attribute.CreateReflectDataContext;
-Method #44 = com.foundation.attribute.IReflectable.reflectionUnregister(com.foundation.attribute.IReflectUpdateHandler;
-Method #45 = com.foundation.attribute.IReflectable.zzrIsReflection(java.lang.Object;com.foundation.attribute.ReflectionContext;
-Method #46 = com.foundation.attribute.IReflectable.zzrGetReflectionContext(java.lang.Object;
-Method #47 = com.foundation.attribute.IReflectable.zzrGetReflectionId(java.lang.Object;
-Method #48 = com.foundation.attribute.IReflectable.zzrReflectionCreateSafeCopy(java.lang.Object;com.foundation.attribute.ReflectionContext;
-Method #49 = com.foundation.attribute.IReflectable.zzrReflectionPreSynchronize(java.lang.Object;com.foundation.attribute.ReflectionContext;com.foundation.attribute.ReflectionContext;com.foundation.common.IEntity;com.foundation.attribute.IReflectable;com.foundation.attribute.ReflectionContext;
-Method #50 = com.foundation.attribute.IReflectable.zzrReflectionDestroy(java.lang.Object;
-Method #51 = com.foundation.attribute.IReflectable.zzrReflectionInitialize(java.lang.Object;com.foundation.attribute.AbstractReflectData;
-Method #52 = com.foundation.attribute.IReflectable.zzrReflectionPostInitialize(java.lang.Object;com.foundation.attribute.AbstractReflectData;
-Method #53 = com.foundation.attribute.IReflectable.zzrReflectionLocalRegister(java.lang.Object;com.foundation.attribute.CreateReflectDataContext;
-Method #54 = com.foundation.attribute.IReflectable.zzrReflectionGetLastUpdateMessageNumber(java.lang.Object;com.foundation.attribute.IReflectUpdateHandler;
-Method #55 = com.foundation.attribute.IReflectable.zzrCollectPostSynchronizeReflectables(java.lang.Object;com.foundation.attribute.CreateReflectDataContext;
-Method #56 = com.foundation.clone.ICloneable.cloneObject(com.foundation.metadata.CloneContext;com.foundation.common.MetadataContainer;
-Method #57 = com.foundation.metadata.ISupportsContainment.getMonitor
-Method #58 = com.foundation.event.IEventEmitter.registerListener(com.foundation.metadata.Event;com.foundation.event.IHandler;boolean;
-Method #59 = com.foundation.event.IEventEmitter.registerListener(int;com.foundation.event.IHandler;boolean;
-Method #60 = com.foundation.event.IEventEmitter.unregisterListener(int;com.foundation.event.IHandler;
-Method #61 = com.foundation.event.IEventEmitter.unregisterListener(com.foundation.metadata.Event;com.foundation.event.IHandler;