Make interfaces more sensible

Author: ngallagher

simple-demo/simple-demo/src/main/java/org/simpleframework/demo/http/WebServer.java

@@ -8,21 +8,21 @@
 
 import org.simpleframework.demo.ssl.Certificate;
 import org.simpleframework.http.core.Container;
-import org.simpleframework.http.core.ContainerServer;
-import org.simpleframework.transport.Server;
+import org.simpleframework.http.core.ContainerSocketConnector;
+import org.simpleframework.transport.SocketConnector;
 import org.simpleframework.transport.connect.Connection;
 import org.simpleframework.transport.connect.SocketConnection;
-import org.simpleframework.transport.trace.Analyzer;
+import org.simpleframework.transport.trace.TraceAnalyzer;
 
 public class WebServer {
 
    private final Certificate certificate;
    private final Connection connection;
    private final SocketAddress address;  
-   private final Server server;
+   private final SocketConnector server;
 
-   public WebServer(Container container, Certificate certificate, Analyzer analyzer, int port) throws IOException {
-      this.server = new ContainerServer(container, 2);
+   public WebServer(Container container, Certificate certificate, TraceAnalyzer analyzer, int port) throws IOException {
+      this.server = new ContainerSocketConnector(container, 2);
       this.connection = new SocketConnection(server, analyzer);
       this.address = new InetSocketAddress(port);
       this.certificate = certificate;

simple-demo/simple-demo/src/main/java/org/simpleframework/demo/trace/LogAnalyzer.java

@@ -9,10 +9,10 @@
 
 import org.apache.log4j.Logger;
 import org.simpleframework.common.thread.Daemon;
-import org.simpleframework.transport.trace.Analyzer;
+import org.simpleframework.transport.trace.TraceAnalyzer;
 import org.simpleframework.transport.trace.Trace;
 
-public class LogAnalyzer extends Daemon implements Analyzer {
+public class LogAnalyzer extends Daemon implements TraceAnalyzer {
 
    private static final Logger LOG = Logger.getLogger(LogAnalyzer.class);
 

simple-test/src/main/java/org/simpleframework/http/validate/test/Adapter.java

@@ -9,8 +9,8 @@
 import org.simpleframework.http.Request;
 import org.simpleframework.http.Response;
 import org.simpleframework.http.core.Container;
-import org.simpleframework.http.core.ContainerServer;
-import org.simpleframework.transport.Server;
+import org.simpleframework.http.core.ContainerSocketConnector;
+import org.simpleframework.transport.SocketConnector;
 import org.simpleframework.transport.connect.Connection;
 import org.simpleframework.transport.connect.SocketConnection;
 
@@ -19,7 +19,7 @@ class Adapter implements Container {
    private final Analyser handler;
    private final Scenario scenario;
    private final Connection connection;
-   private final Server server;
+   private final SocketConnector server;
    private final SecurityManager manager;
    private final AtomicInteger requests;
    private final AtomicInteger failures;
@@ -28,7 +28,7 @@ class Adapter implements Container {
 
    public Adapter(Analyser handler, Scenario scenario) throws Exception {
       this.requestIds = Collections.synchronizedSet(new HashSet<String>());
-      this.server = new ContainerServer(this, 10);
+      this.server = new ContainerSocketConnector(this, 10);
       this.connection = new SocketConnection(server);
       this.manager = new SecurityManager();
       this.requests = new AtomicInteger();

simple-test/src/test/java/org/simpleframework/http/core/DribbleCursor.java

@@ -2,15 +2,15 @@
 
 import java.io.IOException;
 
-import org.simpleframework.transport.Cursor;
+import org.simpleframework.transport.ByteCursor;
 
-public class DribbleCursor implements Cursor {
+public class DribbleCursor implements ByteCursor {
 
-   private Cursor cursor;
+   private ByteCursor cursor;
    private byte[] swap;
    private int dribble;
 
-   public DribbleCursor(Cursor cursor, int dribble) {
+   public DribbleCursor(ByteCursor cursor, int dribble) {
       this.cursor = cursor;
       this.dribble = dribble;
       this.swap = new byte[1];

simple-test/src/test/java/org/simpleframework/http/core/StreamCursor.java

@@ -5,11 +5,11 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 
-import org.simpleframework.transport.Cursor;
+import org.simpleframework.transport.ByteCursor;
 import org.simpleframework.transport.Transport;
 import org.simpleframework.transport.TransportCursor;
 
-public class StreamCursor implements Cursor {
+public class StreamCursor implements ByteCursor {
 
    private TransportCursor cursor;
    private Transport transport;

simple/simple-http/src/main/java/org/simpleframework/http/core/BodyEncoder.java

@@ -0,0 +1,108 @@
+/*
+ * BodyEncoder.java February 2007
+ *
+ * Copyright (C) 2001, Niall Gallagher <niallg@users.sf.net>
+ *
+ * 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.simpleframework.http.core;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * The <code>BodyEncoder</code> object is used to encode content from
+ * the HTTP response. This acts in much the same way as an output
+ * stream would. As a requirement of RFC 2616 any HTTP/1.1 compliant
+ * server must support a set of transfer types. These are fixed size,
+ * chunked encoded, and connection close. A producer implementation
+ * is required to implement one of this formats for delivery of the
+ * response message. 
+ *
+ * @author Niall Gallagher
+ *
+ * @see org.simpleframework.http.core.BodyObserver
+ */ 
+interface BodyEncoder {
+   
+   /**
+    * This method is used to encode the provided array of bytes in
+    * a HTTP/1.1 compliant format and sent it to the client. Once
+    * the data has been encoded it is handed to the transport layer
+    * within the server, which may choose to buffer the data if the
+    * content is too small to send efficiently or if the socket is
+    * not write ready.
+    *
+    * @param array this is the array of bytes to send to the client
+    */         
+   void encode(byte[] array) throws IOException;
+
+   /**
+    * This method is used to encode the provided array of bytes in
+    * a HTTP/1.1 compliant format and sent it to the client. Once
+    * the data has been encoded it is handed to the transport layer
+    * within the server, which may choose to buffer the data if the
+    * content is too small to send efficiently or if the socket is
+    * not write ready.
+    *
+    * @param array this is the array of bytes to send to the client
+    * @param off this is the offset within the array to send from
+    * @param size this is the number of bytes that are to be sent
+    */          
+   void encode(byte[] array, int off, int size) throws IOException;
+
+   /**
+    * This method is used to encode the provided buffer of bytes in
+    * a HTTP/1.1 compliant format and sent it to the client. Once
+    * the data has been encoded it is handed to the transport layer
+    * within the server, which may choose to buffer the data if the
+    * content is too small to send efficiently or if the socket is
+    * not write ready.
+    *
+    * @param buffer this is the buffer of bytes to send to the client
+    */         
+   void encode(ByteBuffer buffer) throws IOException;
+
+   /**
+    * This method is used to encode the provided buffer of bytes in
+    * a HTTP/1.1 compliant format and sent it to the client. Once
+    * the data has been encoded it is handed to the transport layer
+    * within the server, which may choose to buffer the data if the
+    * content is too small to send efficiently or if the socket is
+    * not write ready.
+    *
+    * @param buffer this is the buffer of bytes to send to the client
+    * @param off this is the offset within the buffer to send from
+    * @param size this is the number of bytes that are to be sent
+    */          
+   void encode(ByteBuffer buffer, int off, int size) throws IOException;
+   
+   /**
+    * This method is used to flush the contents of the buffer to 
+    * the client. This method will block until such time as all of
+    * the data has been sent to the client. If at any point there
+    * is an error sending the content an exception is thrown.    
+    */ 
+   void flush() throws IOException;
+ 
+   /**
+    * This is used to signal to the producer that all content has 
+    * been written and the user no longer needs to write. This will
+    * either close the underlying transport or it will notify the
+    * monitor that the response has completed and the next request
+    * can begin. This ensures the content is flushed to the client.
+    */   
+   void close() throws IOException;
+}
+

simple/simple-http/src/main/java/org/simpleframework/http/core/BodyEncoderException.java

@@ -0,0 +1,58 @@
+/*
+ * BodyEncoderException.java February 2007
+ *
+ * Copyright (C) 2001, Niall Gallagher <niallg@users.sf.net>
+ *
+ * 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.simpleframework.http.core;
+
+import java.io.IOException;
+
+/**
+ * The <code>BodyEncoderException</code> object is used to represent 
+ * an exception that is thrown when there is a problem producing the
+ * response body. This can be used to wrap <code>IOException</code>
+ * objects that are thrown from the underlying transport.
+ * 
+ * @author Niall Gallagher
+ */
+class BodyEncoderException extends IOException {
+   
+   /**
+    * Constructor for the <code>BodyEncoderException</code> object. This
+    * is used to represent an exception that is thrown when producing
+    * the response body. The encoder exception is an I/O exception
+    * and thus exceptions can propagate out of stream methods.
+    * 
+    * @param message this is the message describing the exception
+    */
+   public BodyEncoderException(String message) {
+      super(message);
+   }
+   
+   /**
+    * Constructor for the <code>BodyEncoderException</code> object. This
+    * is used to represent an exception that is thrown when producing
+    * the response body. The encoder exception is an I/O exception
+    * and thus exceptions can propagate out of stream methods.
+    * 
+    * @param message this is the message describing the exception
+    * @param cause this is the cause of the encoder exception
+    */
+   public BodyEncoderException(String message, Throwable cause) {
+      super(message);
+      initCause(cause);
+   }
+}

simple/simple-http/src/main/java/org/simpleframework/http/core/BodyEncoderFactory.java

@@ -0,0 +1,118 @@
+/*
+ * BodyEncoderFactory.java February 2007
+ *
+ * Copyright (C) 2001, Niall Gallagher <niallg@users.sf.net>
+ *
+ * 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.simpleframework.http.core;
+
+import org.simpleframework.transport.Channel;
+import org.simpleframework.transport.ByteWriter;
+
+/**
+ * The <code>BodyEncoderFactory</code> is used to create a producer to
+ * match the HTTP header sent with the response. This interprets the
+ * headers within the response and composes a producer that will
+ * match those. Producers can be created to send in chunked encoding
+ * format, as well as fixed length and connection close for HTTP/1.0.
+ *
+ * @author Niall Gallagher
+ *
+ * @see org.simpleframework.http.core.ResponseEncoder
+ */
+class BodyEncoderFactory {
+
+   /**
+    * This is used to determine the semantics of the HTTP pipeline.
+    */         
+   private final Conversation support;   
+
+   /**
+    * This is the monitor used to notify the initiator of events.
+    */ 
+   private final BodyObserver observer;   
+
+   /**
+    * This is the underlying sender used to deliver the raw data.
+    */ 
+   private final ByteWriter writer;   
+   
+   /**
+    * Constructor for the <code>BodyEncoderFactory</code> object. 
+    * This is used to create producers that can encode data in a HTTP
+    * compliant format. Each producer created will produce its data
+    * and deliver it to the specified sender, should an I/O events
+    * occur such as an error, or completion of the response then 
+    * the monitor is notified and the server kernel takes action.
+    *
+    * @param observer this is used to deliver signals to the kernel  
+    * @param support this contains details regarding the semantics
+    * @param writer this is used to send to the underlying transport  
+    */ 
+   public BodyEncoderFactory(BodyObserver observer, Conversation support, Channel channel) {
+      this.writer = channel.getWriter();
+      this.observer = observer;
+      this.support = support;
+   }
+  
+   /**
+    * This is used to create an a <code>BodyEncoder</code> object 
+    * that can be used to encode content according to the HTTP header.
+    * If the request was from a HTTP/1.0 client that did not ask 
+    * for keep alive connection semantics a simple close producer
+    * is created. Otherwise the content is chunked encoded or sent
+    * according the the Content-Length.
+    *
+    * @return this returns the producer used to send the response
+    */  
+   public BodyEncoder getInstance() {
+      boolean keepAlive = support.isKeepAlive();
+      boolean chunkable = support.isChunkedEncoded();
+      boolean tunnel = support.isTunnel();
+      
+      if(!keepAlive || tunnel) {
+         return new CloseEncoder(observer, writer);
+      }
+      return getInstance(chunkable);
+   }
+   
+   /**
+    * This is used to create an a <code>BodyEncoder</code> object 
+    * that can be used to encode content according to the HTTP header.
+    * If the request was from a HTTP/1.0 client that did not ask 
+    * for keep alive connection semantics a simple close producer
+    * is created. Otherwise the content is chunked encoded or sent
+    * according the the Content-Length.
+    *
+    * @param chunkable does the connected client support chunked
+    *
+    * @return this returns the producer used to send the response
+    */     
+   private BodyEncoder getInstance(boolean chunkable) {      
+      long length = support.getContentLength();
+      
+      if(!support.isHead()) { 
+         if(length > 0) {
+            return new FixedLengthEncoder(observer, writer, length);
+         }
+         if(chunkable) {
+            return new ChunkedEncoder(observer, writer);
+         }
+      } 
+      return new EmptyEncoder(observer, writer);
+   }
+}
+
+