tomcat-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cos...@apache.org
Subject svn commit: r331062 - in /tomcat/sandbox/java/org/apache/coyote: ./ adapters/ standalone/
Date Sun, 06 Nov 2005 03:13:09 GMT
Author: costin
Date: Sat Nov  5 19:13:06 2005
New Revision: 331062

URL: http://svn.apache.org/viewcvs?rev=331062&view=rev
Log:
Code for testing ( and using ) coyote standalone. 

The adapters are very simple, more as example. The goal is to have a
minimal http connector, and play with nio and other apis in a simpler 
environment

About MessageWriter and MessageReader - they are copies of
Catalina/connector/OutputBuffer and InputBuffer. Renamed to avoid
confusion. Long term, they should be part of o.a.coyote package, there
is no dep on catalina and are usefull in in connector. 


Added:
    tomcat/sandbox/java/org/apache/coyote/
    tomcat/sandbox/java/org/apache/coyote/adapters/
    tomcat/sandbox/java/org/apache/coyote/adapters/Counters.java
    tomcat/sandbox/java/org/apache/coyote/adapters/FileAdapter.java
    tomcat/sandbox/java/org/apache/coyote/adapters/HelloWorldAdapter.java
    tomcat/sandbox/java/org/apache/coyote/adapters/JsAdapter.java
    tomcat/sandbox/java/org/apache/coyote/adapters/Mapper.java
    tomcat/sandbox/java/org/apache/coyote/standalone/
    tomcat/sandbox/java/org/apache/coyote/standalone/ClientAbortException.java
    tomcat/sandbox/java/org/apache/coyote/standalone/Main.java
    tomcat/sandbox/java/org/apache/coyote/standalone/MessageReader.java
    tomcat/sandbox/java/org/apache/coyote/standalone/MessageWriter.java

Added: tomcat/sandbox/java/org/apache/coyote/adapters/Counters.java
URL: http://svn.apache.org/viewcvs/tomcat/sandbox/java/org/apache/coyote/adapters/Counters.java?rev=331062&view=auto
==============================================================================
--- tomcat/sandbox/java/org/apache/coyote/adapters/Counters.java (added)
+++ tomcat/sandbox/java/org/apache/coyote/adapters/Counters.java Sat Nov  5 19:13:06 2005
@@ -0,0 +1,78 @@
+package org.apache.coyote.adapters;
+
+import java.util.List;
+import java.util.ArrayList;
+
+import org.apache.coyote.Adapter;
+import org.apache.coyote.Request;
+import org.apache.coyote.Response;
+
+/**
+ * Used to collect statistics to evaluate performance of the coyote layer.
+ * 
+ */
+public class Counters implements Adapter {
+    
+    // per thread
+    public static class CountData {
+        public long time;
+        public long requests;
+        public int exceptions;
+    }
+
+    // quick hack - need to move the per-thread code from tomcat
+    List counters=new ArrayList();
+    ThreadLocal tl=new ThreadLocal();
+    
+    Adapter next;
+    
+    public Counters() {
+    }
+    
+    public void setNext( Adapter adapter ) {
+        next=adapter;
+    }
+    
+    public Adapter getNext( ) {
+        return next;
+    }
+
+    public void service(Request req, final Response res) throws Exception {
+        long t0=System.currentTimeMillis();
+        CountData cnt=(CountData)tl.get();
+        if( cnt == null ) {
+            cnt=new CountData();
+            counters.add( cnt );
+            tl.set( cnt );
+            // TODO: deal with thread death
+        }
+        
+        cnt.requests++;
+        try {
+            next.service(req,res);
+        } catch( Exception ex ) {    
+            cnt.exceptions++;
+            throw ex;
+        } finally {
+            long t1=System.currentTimeMillis();            
+            cnt.time+=( t1-t0);            
+        }
+        
+    }
+
+    /** Returns statistics for the server.
+     *  TODO: make it per thread, agregate all threads
+     *  
+     * @return
+     */
+    public CountData getCounts() {
+        CountData total=new CountData();
+        for( int i=0; i< counters.size(); i++ ) {
+            CountData cd=((CountData)counters.get(i));
+            total.requests+= cd.requests;
+            total.time+=cd.time;
+            total.exceptions+=cd.exceptions;
+        }
+        return total;
+    }
+}
\ No newline at end of file

Added: tomcat/sandbox/java/org/apache/coyote/adapters/FileAdapter.java
URL: http://svn.apache.org/viewcvs/tomcat/sandbox/java/org/apache/coyote/adapters/FileAdapter.java?rev=331062&view=auto
==============================================================================
--- tomcat/sandbox/java/org/apache/coyote/adapters/FileAdapter.java (added)
+++ tomcat/sandbox/java/org/apache/coyote/adapters/FileAdapter.java Sat Nov  5 19:13:06 2005
@@ -0,0 +1,127 @@
+package org.apache.coyote.adapters;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Properties;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.coyote.Adapter;
+import org.apache.coyote.Request;
+import org.apache.coyote.Response;
+import org.apache.coyote.standalone.MessageWriter;
+import org.apache.tomcat.util.buf.ByteChunk;
+import org.apache.tomcat.util.buf.C2BConverter;
+
+/**
+ * Serve a static file. This is the traditional method, a separate adapter could
+ * use Sendfile.
+ * 
+ * No fancy things. Not sure if it should have dir support even.
+ */
+public class FileAdapter implements Adapter {
+    Log log = LogFactory.getLog("coyote.file");
+
+    private String baseDir = "html/";
+
+    private File baseDirF;
+
+    public FileAdapter() {
+        init();
+    }
+
+    public void setBaseDir(String s) {
+        baseDir = s;
+    }
+
+    public void init() {
+        baseDirF = new File(baseDir);
+        try {
+            baseDir = baseDirF.getCanonicalPath();
+        } catch (IOException e) {
+        }
+    }
+
+    public void service(Request req, final Response res) throws Exception {
+
+        String uri = req.requestURI().toString();
+        if (uri.indexOf("..") >= 0) {
+            // not supported, too dangerous
+            // what else to escape ?
+            log.info("Invalid .. in  " + uri);
+            res.setStatus(404);
+            return;
+        }
+
+        // local file
+        File f = new File(baseDirF, uri);
+
+        // extra check
+        if (!f.getCanonicalPath().startsWith(baseDir)) {
+            log.info("File outside basedir " + baseDir + " " + f);
+            res.setStatus(404);
+            return;
+        }
+
+        if (f.isDirectory()) {
+            // check for index.html, redirect if exists
+            // list dir if not
+
+            f = new File(f, "index.html");
+        }
+
+        if (!f.exists()) {
+            log.info("File not found  " + f);
+            res.setStatus(404);
+            return;
+        }
+
+        res.setStatus(200);
+
+        // TODO: read from a resources in classpath !
+        // TODO: refactor to allow sendfile
+        // TODO: read mime types
+
+        int dot=uri.lastIndexOf(".");
+        if( dot > 0 ) {
+            String ext=uri.substring(dot+1);
+            String ct=getContentType(ext);
+            if( ct!=null) {
+                res.setContentType(ct);
+            }
+        }
+
+        res.setContentLength(f.length());
+
+        res.sendHeaders();
+
+        // not used - writes directly to response
+        // MessageWriter out = MessageWriter.getWriter(req, res, 0);
+
+        FileInputStream fis = new FileInputStream(f);
+        byte b[] = new byte[4096];
+        ByteChunk mb = new ByteChunk();
+        int rd = 0;
+        while ((rd = fis.read(b)) > 0) {
+            mb.setBytes(b, 0, rd);
+            res.doWrite(mb);
+        }
+
+    }
+
+    static Properties contentTypes=new Properties();
+    static {
+        initContentTypes();
+    }
+    static void initContentTypes() {
+        contentTypes.put("html", "text/html");
+        contentTypes.put("txt", "text/plain");
+        contentTypes.put("xul", "application/vnd.mozilla.xul+xml");
+    }
+    
+    public String getContentType( String ext ) {
+        return contentTypes.getProperty( ext, "text/plain" );
+    }
+    
+}
\ No newline at end of file

Added: tomcat/sandbox/java/org/apache/coyote/adapters/HelloWorldAdapter.java
URL: http://svn.apache.org/viewcvs/tomcat/sandbox/java/org/apache/coyote/adapters/HelloWorldAdapter.java?rev=331062&view=auto
==============================================================================
--- tomcat/sandbox/java/org/apache/coyote/adapters/HelloWorldAdapter.java (added)
+++ tomcat/sandbox/java/org/apache/coyote/adapters/HelloWorldAdapter.java Sat Nov  5 19:13:06 2005
@@ -0,0 +1,15 @@
+package org.apache.coyote.adapters;
+
+import org.apache.coyote.Adapter;
+import org.apache.coyote.Request;
+import org.apache.coyote.Response;
+import org.apache.coyote.standalone.MessageWriter;
+
+public class HelloWorldAdapter implements Adapter {
+    public void service(Request req, Response res) throws Exception {
+        MessageWriter out=MessageWriter.getWriter(req, res, 0);
+        res.setContentType("text/html");
+        
+        out.write("<h1>Hello world</h1>");
+    }
+}

Added: tomcat/sandbox/java/org/apache/coyote/adapters/JsAdapter.java
URL: http://svn.apache.org/viewcvs/tomcat/sandbox/java/org/apache/coyote/adapters/JsAdapter.java?rev=331062&view=auto
==============================================================================
--- tomcat/sandbox/java/org/apache/coyote/adapters/JsAdapter.java (added)
+++ tomcat/sandbox/java/org/apache/coyote/adapters/JsAdapter.java Sat Nov  5 19:13:06 2005
@@ -0,0 +1,240 @@
+package org.apache.coyote.adapters;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.coyote.Adapter;
+import org.apache.coyote.Request;
+import org.apache.coyote.Response;
+import org.apache.coyote.http11.Http11BaseProtocol;
+import org.apache.coyote.standalone.Main;
+import org.apache.coyote.standalone.MessageWriter;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.EvaluatorException;
+import org.mozilla.javascript.Function;
+import org.mozilla.javascript.JavaScriptException;
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptableObject;
+import org.mozilla.javascript.WrappedException;
+
+/**
+ * Will load the 'default.js' and execute init. In init you can set params on
+ * the server and handler.
+ *
+ * Entry points:
+ * <ul> 
+ * <li>init() - called the first time, can set the port and other
+ * properties in the "server" object 
+ * <li>initThread() - called per thread. 
+ * <li>service( req, res, out)
+ * </ul>
+ * 
+ * Defined objects:
+ * <ul> 
+ * <li>log - commons logger log for this adapter 
+ * <li>server - the http connector 
+ * <li>jsAdapter, counterAdapter, fileAdapter, mapperAdapter - adapters.
+ * </ul>
+ * 
+ * Note: this is just an example, you can extend it or create your own
+ * with different semantics. After the coyote API is cleaned up and converted
+ * to NIO - I'll also define a better JS API.
+ * 
+ */
+public class JsAdapter extends Main implements Adapter {
+
+    // Js file to interpret
+    static String filename = "js-bin/default.js";
+
+    // to support reloading of the js file
+    static long lastModif = 0;
+
+    // Javascript main context and scope
+    private Context mainCx;
+
+    private Scriptable mainScope;
+
+    private Log log = LogFactory.getLog("js");
+
+    // we store them per thread. Need a way to manage the tokens
+    public static final int SCOPE_NOTE = 12;
+
+    public static final int ADAPTER_NOTES = 11;
+
+    boolean reload = true;
+
+    public JsAdapter() {
+    }
+
+    public boolean getReload() {
+        return reload;
+    }
+
+    public void setReload(boolean reload) {
+        this.reload = reload;
+    }
+
+    public void service(Request req, final Response res) throws Exception {
+        // Per thread.
+        Context cx = (Context) req.getNote(JsAdapter.ADAPTER_NOTES);
+        Scriptable scope = (Scriptable) req.getNote(JsAdapter.SCOPE_NOTE);
+        MessageWriter out = MessageWriter.getWriter(req, res, 0);
+
+        if (cx == null) {
+            cx = Context.enter();
+            req.setNote(JsAdapter.ADAPTER_NOTES, cx);
+            // TODO: exit on thread death
+
+            // Each thread will have an associated context, and an associated
+            // scope.
+            // The scope will hold the proxies for req, res and the other
+            // objects
+            // Because the req and response never change for a thread - we don't
+            // need to bind them again.
+
+            scope = cx.newObject(mainScope);
+            scope.setPrototype(mainScope);
+
+            req.setNote(JsAdapter.SCOPE_NOTE, scope);
+
+            Object fObj = mainScope.get("initThread", mainScope);
+            if ((fObj instanceof Function)) {
+                Object functionArgs[] = { req, res, out };
+                Function f = (Function) fObj;
+                Object result = f.call(mainCx, mainScope, mainScope,
+                        functionArgs);
+            }
+        }
+
+        // The file was loaded in initJS(), at server startup. We will only
+        // check if it changed, if we are in devel mode and reload it.
+        if (reload) {
+            load(filename);
+        }
+
+        // Now call the service() js function
+        Object fObj = ScriptableObject.getProperty(scope, "service");
+        if (!(fObj instanceof Function)) {
+            log.info("service is undefined or not a function. " + fObj);
+            log.info("Not found in scope... " + scope);
+            log.info("Parent: " + mainScope.get("service", mainScope));
+            fObj = mainScope.get("service", mainScope);
+        }
+        
+        Object functionArgs[] = { req, res, out };
+        Function f = (Function) fObj;
+        Object result = f.call(cx, scope, scope, functionArgs);
+        
+    }
+
+    /**
+     * Initialize. Will run the init() method in the script
+     * 
+     * @param proto
+     */
+    public void initJS() {
+        mainCx = Context.enter();
+        mainScope = mainCx.initStandardObjects();
+
+        Object jsOut;
+        
+        jsOut = Context.javaToJS(log, mainScope);
+        ScriptableObject.putProperty(mainScope, "log", jsOut);
+
+        jsOut = Context.javaToJS(proto, mainScope);
+        ScriptableObject.putProperty(mainScope, "server", jsOut);
+
+        Counters ct = (Counters) proto.getAdapter();
+        Mapper mp = (Mapper) ct.getNext();
+        FileAdapter fa = (FileAdapter) mp.getDefaultAdapter();
+
+        jsOut = Context.javaToJS(ct, mainScope);
+        ScriptableObject.putProperty(mainScope, "countersAdapter", jsOut);
+
+        jsOut = Context.javaToJS(mp, mainScope);
+        ScriptableObject.putProperty(mainScope, "mapperAdapter", jsOut);
+
+        jsOut = Context.javaToJS(fa, mainScope);
+        ScriptableObject.putProperty(mainScope, "fileAdapter", jsOut);
+
+        jsOut = Context.javaToJS(this, mainScope);
+        ScriptableObject.putProperty(mainScope, "jsAdapter", jsOut);
+
+        load(filename);
+
+        Object fObj = mainScope.get("init", mainScope);
+        if ((fObj instanceof Function)) {
+            Object functionArgs[] = {};
+            Function f = (Function) fObj;
+            Object result = f.call(mainCx, mainScope, mainScope, functionArgs);
+        }
+    }
+
+    /**
+     * Load a script.
+     */
+    private void load(String filename) {
+
+        FileReader in = null;
+        try {
+            File scriptF = new File(filename);
+
+            if (lastModif != 0 && scriptF.lastModified() <= lastModif) {
+                // already loaded
+                return;
+            }
+            lastModif = scriptF.lastModified();
+            in = new FileReader(filename);
+        } catch (FileNotFoundException ex) {
+            System.err.println("JS file not found " + ex);
+            return;
+        }
+
+        try {
+            // Here we evalute the entire contents of the file as
+            // a script. Text is printed only if the print() function
+            // is called.
+            Object result = mainCx.evaluateReader(mainScope, in, filename, 1,
+                    null);
+        } catch (WrappedException we) {
+            System.err.println(we.getWrappedException().toString());
+            we.printStackTrace();
+        } catch (EvaluatorException ee) {
+            System.err.println("js: " + ee.getMessage());
+        } catch (JavaScriptException jse) {
+            System.err.println("js: " + jse.getMessage());
+        } catch (IOException ioe) {
+            System.err.println(ioe.toString());
+        } finally {
+            try {
+                in.close();
+            } catch (IOException ioe) {
+                System.err.println(ioe.toString());
+            }
+        }
+    }
+
+    public void setProtocol(Http11BaseProtocol proto) {
+        this.proto = proto;
+    }
+
+    // ------------ Example on how to run it --------------------
+
+    public void init() {
+        super.init();
+        JsAdapter js = this; // new JsAdapter();
+        js.setProtocol(proto);
+        js.initJS();
+        mainAdapter.addAdapter("/js-bin", js);
+    }
+
+    public static void main(String args[]) {
+        JsAdapter sa = new JsAdapter();
+        sa.run(); // in Main - will call init first
+    }
+
+}
\ No newline at end of file

Added: tomcat/sandbox/java/org/apache/coyote/adapters/Mapper.java
URL: http://svn.apache.org/viewcvs/tomcat/sandbox/java/org/apache/coyote/adapters/Mapper.java?rev=331062&view=auto
==============================================================================
--- tomcat/sandbox/java/org/apache/coyote/adapters/Mapper.java (added)
+++ tomcat/sandbox/java/org/apache/coyote/adapters/Mapper.java Sat Nov  5 19:13:06 2005
@@ -0,0 +1,125 @@
+package org.apache.coyote.adapters;
+
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+import org.apache.coyote.Adapter;
+import org.apache.coyote.Request;
+import org.apache.coyote.Response;
+import org.apache.coyote.http11.Http11BaseProtocol;
+import org.apache.coyote.standalone.MessageWriter;
+import org.apache.tomcat.util.loader.Loader;
+import org.apache.tomcat.util.loader.Repository;
+
+/**
+ * Very, very simple mapper for standalone coyote. Used to test and experiment
+ * various low level changes, or for very simple http servers.
+ * 
+ * It currently supports only prefix mapping, using the first url component.
+ */
+public class Mapper implements Adapter {
+    
+    // TODO: add extension mappings 
+    // Key = prefix, one level only, value= class name of Adapter
+    // key starts with a / and has no other / ( /foo - but not /foo/bar )
+    Hashtable prefixMap=new Hashtable();
+
+    String fileAdapterCN="org.apache.coyote.adapters.FileAdapter";
+    Adapter defaultAdapter=new FileAdapter();    
+
+    public Mapper() {
+    }
+
+    public void service(Request req, final Response res)
+    throws Exception {
+        try {           
+            String uri=req.requestURI().toString();
+            if( uri.equals("/") ) uri="index.html";
+            String ctx="";
+            String local=uri;
+            if( uri.length() > 1 ) {
+                int idx=uri.indexOf('/', 1);
+                if( idx > 0 ) {
+                    ctx=uri.substring(0, idx);
+                    local=uri.substring( idx );
+                }
+            }
+            Adapter h=(Adapter)prefixMap.get( ctx );
+            if( h != null ) {
+                h.service( req, res );
+            } else {
+                defaultAdapter.service( req, res );
+            }
+        } catch( Throwable t ) {
+            t.printStackTrace();
+        } 
+
+        //out.flushBuffer();
+        //out.getByteChunk().flushBuffer(); - part of res.finish()
+        // final processing
+        MessageWriter.getWriter(req, res, 0).flush();
+        res.finish();
+
+        req.recycle();
+        res.recycle();
+
+    }
+
+    /** Load the handler table. Just a hack, I'll find a better solution
+     */
+    public void initHandlers() {
+
+        prefixMap=new Hashtable();
+        Enumeration keys=System.getProperties().keys();
+
+        Loader loader=null;
+        if( loader == null ) {
+            // Not started from loader, we are embedded - create the loader, so we
+            // can do reloading.
+            //LoaderProperties.setPropertiesFile("");
+            try {
+                loader=new Loader();
+                ClassLoader myL=this.getClass().getClassLoader();
+                loader.setParentClassLoader( myL );
+                loader.init();
+            } catch( Throwable t ) {
+                t.printStackTrace();
+            }
+        }
+
+        Repository sR=loader.getRepository("shared");
+        // Construct handlers. Handlers will be created, they can get the protocol
+        // if they need additional init
+
+        while( keys.hasMoreElements()) {
+            String n=(String)keys.nextElement();
+            if( n.startsWith("handler.")) {
+                String cls=System.getProperty( n );
+                String map=n.substring(8);
+                Adapter hC=null;
+                try {
+                    // use the loader's server common repository
+                    Class c=sR.getClassLoader().loadClass(cls);
+                    //Class c=Class.forName(cls);
+                    hC=(Adapter)c.newInstance();
+                    prefixMap.put( map, hC );
+                } catch( Throwable t ) {
+                    t.printStackTrace();
+                }
+            }
+        }
+    }
+
+    public void addAdapter( String prefix, Adapter adapter ) {
+        prefixMap.put(prefix, adapter);
+    }
+    
+    public void setDefaultAdapter(Adapter adapter) {
+        defaultAdapter=adapter;
+    }
+
+    public Adapter getDefaultAdapter() {
+        return defaultAdapter;
+    }
+
+}
\ No newline at end of file

Added: tomcat/sandbox/java/org/apache/coyote/standalone/ClientAbortException.java
URL: http://svn.apache.org/viewcvs/tomcat/sandbox/java/org/apache/coyote/standalone/ClientAbortException.java?rev=331062&view=auto
==============================================================================
--- tomcat/sandbox/java/org/apache/coyote/standalone/ClientAbortException.java (added)
+++ tomcat/sandbox/java/org/apache/coyote/standalone/ClientAbortException.java Sat Nov  5 19:13:06 2005
@@ -0,0 +1,144 @@
+/*
+ * Copyright 1999,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.coyote.standalone;
+
+import java.io.IOException;
+
+/**
+ * Wrap an IOException identifying it as being caused by an abort
+ * of a request by a remote client.
+ *
+ * @author Glenn L. Nielsen
+ * @version $Revision: 304063 $ $Date: 2005-08-18 06:25:18 -0700 (Thu, 18 Aug 2005) $
+ */
+
+public final class ClientAbortException extends IOException {
+
+
+    //------------------------------------------------------------ Constructors
+
+
+    /**
+     * Construct a new ClientAbortException with no other information.
+     */
+    public ClientAbortException() {
+
+        this(null, null);
+
+    }
+
+
+    /**
+     * Construct a new ClientAbortException for the specified message.
+     *
+     * @param message Message describing this exception
+     */
+    public ClientAbortException(String message) {
+
+        this(message, null);
+
+    }
+
+
+    /**
+     * Construct a new ClientAbortException for the specified throwable.
+     *
+     * @param throwable Throwable that caused this exception
+     */
+    public ClientAbortException(Throwable throwable) {
+
+        this(null, throwable);
+
+    }
+
+
+    /**
+     * Construct a new ClientAbortException for the specified message
+     * and throwable.
+     *
+     * @param message Message describing this exception
+     * @param throwable Throwable that caused this exception
+     */
+    public ClientAbortException(String message, Throwable throwable) {
+
+        super();
+        this.message = message;
+        this.throwable = throwable;
+
+    }
+
+
+    //------------------------------------------------------ Instance Variables
+
+
+    /**
+     * The error message passed to our constructor (if any)
+     */
+    protected String message = null;
+
+
+    /**
+     * The underlying exception or error passed to our constructor (if any)
+     */
+    protected Throwable throwable = null;
+
+
+    //---------------------------------------------------------- Public Methods
+
+
+    /**
+     * Returns the message associated with this exception, if any.
+     */
+    public String getMessage() {
+
+        return (message);
+
+    }
+
+
+    /**
+     * Returns the cause that caused this exception, if any.
+     */
+    public Throwable getCause() {
+        
+        return (throwable);
+        
+    }
+
+    
+    /**
+     * Return a formatted string that describes this exception.
+     */
+    public String toString() {
+
+        StringBuffer sb = new StringBuffer("ClientAbortException:  ");
+        if (message != null) {
+            sb.append(message);
+            if (throwable != null) {
+                sb.append(":  ");
+            }
+        }
+        if (throwable != null) {
+            sb.append(throwable.toString());
+        }
+        return (sb.toString());
+
+    }
+
+
+}

Added: tomcat/sandbox/java/org/apache/coyote/standalone/Main.java
URL: http://svn.apache.org/viewcvs/tomcat/sandbox/java/org/apache/coyote/standalone/Main.java?rev=331062&view=auto
==============================================================================
--- tomcat/sandbox/java/org/apache/coyote/standalone/Main.java (added)
+++ tomcat/sandbox/java/org/apache/coyote/standalone/Main.java Sat Nov  5 19:13:06 2005
@@ -0,0 +1,66 @@
+package org.apache.coyote.standalone;
+
+import org.apache.coyote.adapters.Counters;
+import org.apache.coyote.adapters.HelloWorldAdapter;
+import org.apache.coyote.adapters.Mapper;
+import org.apache.coyote.http11.Http11BaseProtocol;
+
+
+/** 
+ * Simple example of embeding coyote.
+ * 
+ */
+public class Main  {
+    
+    protected Http11BaseProtocol proto;
+    protected Mapper mainAdapter;
+    
+    public Main() {        
+    }
+
+    public Http11BaseProtocol getProtocol() {
+        return proto;
+    }
+    
+    public void init() {
+        proto = new Http11BaseProtocol();
+
+        mainAdapter = new Mapper();        
+        mainAdapter.addAdapter("/hello", new HelloWorldAdapter());
+
+        Counters cnt=new Counters();
+        cnt.setNext( mainAdapter );
+
+        //proto.setAdapter(mainAdapter);
+        proto.setAdapter(cnt);
+    }
+    
+    /**
+     */
+    public void run() {
+        init();
+        
+        if( proto.getPort() == 0 )
+            proto.setPort(8800);
+        
+        try {
+            proto.init();
+
+            proto.getThreadPool().setDaemon(false);
+            
+            proto.start();
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+    
+    // ------------------- Main ---------------------
+    public static void main( String args[]) {
+        Main sa=new Main();
+        sa.run();
+    }
+
+    
+}
\ No newline at end of file

Added: tomcat/sandbox/java/org/apache/coyote/standalone/MessageReader.java
URL: http://svn.apache.org/viewcvs/tomcat/sandbox/java/org/apache/coyote/standalone/MessageReader.java?rev=331062&view=auto
==============================================================================
--- tomcat/sandbox/java/org/apache/coyote/standalone/MessageReader.java (added)
+++ tomcat/sandbox/java/org/apache/coyote/standalone/MessageReader.java Sat Nov  5 19:13:06 2005
@@ -0,0 +1,503 @@
+/*
+ * Copyright 1999,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.coyote.standalone;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.util.HashMap;
+
+import org.apache.coyote.Request;
+import org.apache.tomcat.util.buf.B2CConverter;
+import org.apache.tomcat.util.buf.ByteChunk;
+import org.apache.tomcat.util.buf.CharChunk;
+
+/**
+ * Refactored from catalina.connector.InputBuffer. Renamed to avoid conflict
+ * with coyote class.
+ * 
+ * TODO: move to coyote package.
+ */
+
+/**
+ * The buffer used by Tomcat request. This is a derivative of the Tomcat 3.3
+ * OutputBuffer, adapted to handle input instead of output. This allows 
+ * complete recycling of the facade objects (the ServletInputStream and the
+ * BufferedReader).
+ *
+ * @author Remy Maucherat
+ */
+public class MessageReader extends Reader
+    implements ByteChunk.ByteInputChannel, CharChunk.CharInputChannel,
+               CharChunk.CharOutputChannel {
+
+
+    // -------------------------------------------------------------- Constants
+
+
+    public static final String DEFAULT_ENCODING = 
+        org.apache.coyote.Constants.DEFAULT_CHARACTER_ENCODING;
+    public static final int DEFAULT_BUFFER_SIZE = 8*1024;
+
+    // The buffer can be used for byte[] and char[] reading
+    // ( this is needed to support ServletInputStream and BufferedReader )
+    public final int INITIAL_STATE = 0;
+    public final int CHAR_STATE = 1;
+    public final int BYTE_STATE = 2;
+
+
+    // ----------------------------------------------------- Instance Variables
+
+
+    /**
+     * The byte buffer.
+     */
+    private ByteChunk bb;
+
+
+    /**
+     * The chunk buffer.
+     */
+    private CharChunk cb;
+
+
+    /**
+     * State of the output buffer.
+     */
+    private int state = 0;
+
+
+    /**
+     * Number of bytes read.
+     */
+    private int bytesRead = 0;
+
+
+    /**
+     * Number of chars read.
+     */
+    private int charsRead = 0;
+
+
+    /**
+     * Flag which indicates if the input buffer is closed.
+     */
+    private boolean closed = false;
+
+
+    /**
+     * Byte chunk used to input bytes.
+     */
+    private ByteChunk inputChunk = new ByteChunk();
+
+
+    /**
+     * Encoding to use.
+     */
+    private String enc;
+
+
+    /**
+     * Encoder is set.
+     */
+    private boolean gotEnc = false;
+
+
+    /**
+     * List of encoders.
+     */
+    protected HashMap encoders = new HashMap();
+
+
+    /**
+     * Current byte to char converter.
+     */
+    protected B2CConverter conv;
+
+
+    /**
+     * Associated Coyote request.
+     */
+    private Request coyoteRequest;
+
+
+    /**
+     * Buffer position.
+     */
+    private int markPos = -1;
+
+
+    /**
+     * Buffer size.
+     */
+    private int size = -1;
+
+
+    // ----------------------------------------------------------- Constructors
+
+
+    /**
+     * Default constructor. Allocate the buffer with the default buffer size.
+     */
+    public MessageReader() {
+
+        this(DEFAULT_BUFFER_SIZE);
+
+    }
+
+
+    /**
+     * Alternate constructor which allows specifying the initial buffer size.
+     * 
+     * @param size Buffer size to use
+     */
+    public MessageReader(int size) {
+
+        this.size = size;
+        bb = new ByteChunk(size);
+        bb.setLimit(size);
+        bb.setByteInputChannel(this);
+        cb = new CharChunk(size);
+        cb.setLimit(size);
+        cb.setOptimizedWrite(false);
+        cb.setCharInputChannel(this);
+        cb.setCharOutputChannel(this);
+
+    }
+
+
+    // ------------------------------------------------------------- Properties
+
+
+    /**
+     * Associated Coyote request.
+     * 
+     * @param coyoteRequest Associated Coyote request
+     */
+    public void setRequest(Request coyoteRequest) {
+	this.coyoteRequest = coyoteRequest;
+    }
+
+
+    /**
+     * Get associated Coyote request.
+     * 
+     * @return the associated Coyote request
+     */
+    public Request getRequest() {
+        return this.coyoteRequest;
+    }
+
+
+    // --------------------------------------------------------- Public Methods
+
+
+    /**
+     * Recycle the output buffer.
+     */
+    public void recycle() {
+        
+        state = INITIAL_STATE;
+        bytesRead = 0;
+        charsRead = 0;
+        
+        // If usage of mark made the buffer too big, reallocate it
+        if (cb.getChars().length > size) {
+            cb = new CharChunk(size);
+            cb.setLimit(size);
+            cb.setCharInputChannel(this);
+            cb.setCharOutputChannel(this);
+        } else {
+            cb.recycle();
+        }
+        markPos = -1;
+        bb.recycle(); 
+        closed = false;
+        
+        if (conv != null) {
+            conv.recycle();
+        }
+        
+        gotEnc = false;
+        enc = null;
+        
+    }
+
+
+    /**
+     * Close the input buffer.
+     * 
+     * @throws IOException An underlying IOException occurred
+     */
+    public void close()
+        throws IOException {
+        closed = true;
+    }
+
+
+    public int available()
+        throws IOException {
+        if (state == BYTE_STATE) {
+            return bb.getLength();
+        } else if (state == CHAR_STATE) {
+            return cb.getLength();
+        } else {
+            return 0;
+        }
+    }
+
+
+    // ------------------------------------------------- Bytes Handling Methods
+
+
+    /** 
+     * Reads new bytes in the byte chunk.
+     * 
+     * @param cbuf Byte buffer to be written to the response
+     * @param off Offset
+     * @param len Length
+     * 
+     * @throws IOException An underlying IOException occurred
+     */
+    public int realReadBytes(byte cbuf[], int off, int len)
+	throws IOException {
+
+        if (closed)
+            return -1;
+        if (coyoteRequest == null)
+            return -1;
+
+        state = BYTE_STATE;
+
+        int result = coyoteRequest.doRead(bb);
+
+        return result;
+
+    }
+
+
+    public int readByte()
+        throws IOException {
+        return bb.substract();
+    }
+
+
+    public int read(byte[] b, int off, int len)
+        throws IOException {
+        return bb.substract(b, off, len);
+    }
+
+
+    // ------------------------------------------------- Chars Handling Methods
+
+
+    /**
+     * Since the converter will use append, it is possible to get chars to
+     * be removed from the buffer for "writing". Since the chars have already
+     * been read before, they are ignored. If a mark was set, then the
+     * mark is lost.
+     */
+    public void realWriteChars(char c[], int off, int len) 
+        throws IOException {
+        markPos = -1;
+    }
+
+
+    public void setEncoding(String s) {
+        enc = s;
+    }
+
+
+    public int realReadChars(char cbuf[], int off, int len)
+        throws IOException {
+
+        if (!gotEnc)
+            setConverter();
+
+        if (bb.getLength() <= 0) {
+            int nRead = realReadBytes(bb.getBytes(), 0, bb.getBytes().length);
+            if (nRead < 0) {
+                return -1;
+            }
+        }
+
+        if (markPos == -1) {
+            cb.setOffset(0);
+            cb.setEnd(0);
+        }
+
+        conv.convert(bb, cb);
+        bb.setOffset(bb.getEnd());
+        state = CHAR_STATE;
+
+        return cb.getLength();
+
+    }
+
+
+    public int read()
+        throws IOException {
+        return cb.substract();
+    }
+
+
+    public int read(char[] cbuf)
+        throws IOException {
+        return read(cbuf, 0, cbuf.length);
+    }
+
+
+    public int read(char[] cbuf, int off, int len)
+        throws IOException {
+        return cb.substract(cbuf, off, len);
+    }
+
+
+    public long skip(long n)
+        throws IOException {
+
+        if (n < 0) {
+            throw new IllegalArgumentException();
+        }
+
+        long nRead = 0;
+        while (nRead < n) {
+            if (cb.getLength() >= n) {
+                cb.setOffset(cb.getStart() + (int) n);
+                nRead = n;
+            } else {
+                nRead += cb.getLength();
+                cb.setOffset(cb.getEnd());
+                int toRead = 0;
+                if (cb.getChars().length < (n - nRead)) {
+                    toRead = cb.getChars().length;
+                } else {
+                    toRead = (int) (n - nRead);
+                }
+                int nb = realReadChars(cb.getChars(), 0, toRead);
+                if (nb < 0)
+                    break;
+            }
+        }
+
+        return nRead;
+
+    }
+
+
+    public boolean ready()
+        throws IOException {
+        return (cb.getLength() > 0);
+    }
+
+
+    public boolean markSupported() {
+        return true;
+    }
+
+
+    public void mark(int readAheadLimit)
+        throws IOException {
+        if (cb.getLength() <= 0) {
+            cb.setOffset(0);
+            cb.setEnd(0);
+        } else {
+            if ((cb.getBuffer().length > (2 * size)) 
+                && (cb.getLength()) < (cb.getStart())) {
+                System.arraycopy(cb.getBuffer(), cb.getStart(), 
+                                 cb.getBuffer(), 0, cb.getLength());
+                cb.setEnd(cb.getLength());
+                cb.setOffset(0);
+            }
+        }
+        int offset = readAheadLimit;
+        if (offset < size) {
+            offset = size;
+        }
+        cb.setLimit(cb.getStart() + offset);
+        markPos = cb.getStart();
+    }
+
+
+    public void reset()
+        throws IOException {
+        if (state == CHAR_STATE) {
+            if (markPos < 0) {
+                cb.recycle();
+                markPos = -1;
+                throw new IOException();
+            } else {
+                cb.setOffset(markPos);
+            }
+        } else {
+            bb.recycle();
+        }
+    }
+
+
+    public void checkConverter() 
+        throws IOException {
+
+        if (!gotEnc)
+            setConverter();
+
+    }
+
+
+    protected void setConverter()
+        throws IOException {
+
+        if (coyoteRequest != null)
+            enc = coyoteRequest.getCharacterEncoding();
+
+        gotEnc = true;
+        if (enc == null)
+            enc = DEFAULT_ENCODING;
+        conv = (B2CConverter) encoders.get(enc);
+        if (conv == null) {
+            if (packageDefinitionEnabled && System.getSecurityManager() !=  null) {
+                //SecurityUtil.isPackageProtectionEnabled()){
+                try{
+                    conv = (B2CConverter)AccessController.doPrivileged(
+                            new PrivilegedExceptionAction(){
+
+                                public Object run() throws IOException{
+                                    return new B2CConverter(enc);
+                                }
+
+                            }
+                    );              
+                }catch(PrivilegedActionException ex){
+                    Exception e = ex.getException();
+                    if (e instanceof IOException)
+                        throw (IOException)e; 
+                }
+            } else {
+                conv = new B2CConverter(enc);
+            }
+            encoders.put(enc, conv);
+        }
+
+    }
+
+    private static boolean packageDefinitionEnabled =  
+        (System.getProperty("package.definition") == null && 
+          System.getProperty("package.access")  == null) ? false : true;
+
+}

Added: tomcat/sandbox/java/org/apache/coyote/standalone/MessageWriter.java
URL: http://svn.apache.org/viewcvs/tomcat/sandbox/java/org/apache/coyote/standalone/MessageWriter.java?rev=331062&view=auto
==============================================================================
--- tomcat/sandbox/java/org/apache/coyote/standalone/MessageWriter.java (added)
+++ tomcat/sandbox/java/org/apache/coyote/standalone/MessageWriter.java Sat Nov  5 19:13:06 2005
@@ -0,0 +1,677 @@
+/*
+ * Copyright 1999,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.coyote.standalone;
+
+
+import java.io.IOException;
+import java.io.Writer;
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.util.HashMap;
+
+import org.apache.coyote.ActionCode;
+import org.apache.coyote.Request;
+import org.apache.coyote.Response;
+import org.apache.tomcat.util.buf.ByteChunk;
+import org.apache.tomcat.util.buf.C2BConverter;
+import org.apache.tomcat.util.buf.CharChunk;
+import org.apache.tomcat.util.buf.MessageBytes;
+
+/*
+ * Refactoring: original code in catalina.connector.
+ * - renamed to OutputWriter to avoid confusion with coyote OutputBuffer
+ * - 
+ * TODO: move it to coyote, add Response.getWriter 
+ * 
+ */
+
+/**
+ * The buffer used by Tomcat response. This is a derivative of the Tomcat 3.3
+ * OutputBuffer, with the removal of some of the state handling (which in 
+ * Coyote is mostly the Processor's responsability).
+ *
+ * @author Costin Manolache
+ * @author Remy Maucherat
+ */
+public class MessageWriter extends Writer
+    implements ByteChunk.ByteOutputChannel, CharChunk.CharOutputChannel {
+
+    // used in getWriter, until a method is added to res.
+    private static final int WRITER_NOTE = 3;
+
+    // -------------------------------------------------------------- Constants
+
+
+    public static final String DEFAULT_ENCODING = 
+        org.apache.coyote.Constants.DEFAULT_CHARACTER_ENCODING;
+    public static final int DEFAULT_BUFFER_SIZE = 8*1024;
+
+
+    // The buffer can be used for byte[] and char[] writing
+    // ( this is needed to support ServletOutputStream and for
+    // efficient implementations of templating systems )
+    public final int INITIAL_STATE = 0;
+    public final int CHAR_STATE = 1;
+    public final int BYTE_STATE = 2;
+
+
+    // ----------------------------------------------------- Instance Variables
+
+
+    /**
+     * The byte buffer.
+     */
+    private ByteChunk bb;
+
+
+    /**
+     * The chunk buffer.
+     */
+    private CharChunk cb;
+
+
+    /**
+     * State of the output buffer.
+     */
+    private int state = 0;
+
+
+    /**
+     * Number of bytes written.
+     */
+    private int bytesWritten = 0;
+
+
+    /**
+     * Number of chars written.
+     */
+    private int charsWritten = 0;
+
+
+    /**
+     * Flag which indicates if the output buffer is closed.
+     */
+    private boolean closed = false;
+
+
+    /**
+     * Do a flush on the next operation.
+     */
+    private boolean doFlush = false;
+
+
+    /**
+     * Byte chunk used to output bytes.
+     */
+    private ByteChunk outputChunk = new ByteChunk();
+
+
+    /**
+     * Encoding to use.
+     */
+    private String enc;
+
+
+    /**
+     * Encoder is set.
+     */
+    private boolean gotEnc = false;
+
+
+    /**
+     * List of encoders.
+     */
+    protected HashMap encoders = new HashMap();
+
+
+    /**
+     * Current char to byte converter.
+     */
+    protected C2BConverter conv;
+
+
+    /**
+     * Associated Coyote response.
+     */
+    private Response coyoteResponse;
+
+
+    /**
+     * Suspended flag. All output bytes will be swallowed if this is true.
+     */
+    private boolean suspended = false;
+
+
+    // ----------------------------------------------------------- Constructors
+
+
+    /**
+     * Default constructor. Allocate the buffer with the default buffer size.
+     */
+    public MessageWriter() {
+
+        this(DEFAULT_BUFFER_SIZE);
+
+    }
+
+
+    /**
+     * Alternate constructor which allows specifying the initial buffer size.
+     * 
+     * @param size Buffer size to use
+     */
+    public MessageWriter(int size) {
+
+        bb = new ByteChunk(size);
+        bb.setLimit(size);
+        bb.setByteOutputChannel(this);
+        cb = new CharChunk(size);
+        cb.setCharOutputChannel(this);
+        cb.setLimit(size);
+
+    }
+
+
+    // ------------------------------------------------------------- Properties
+
+
+    /**
+     * Associated Coyote response.
+     * 
+     * @param coyoteResponse Associated Coyote response
+     */
+    public void setResponse(Response coyoteResponse) {
+	this.coyoteResponse = coyoteResponse;
+    }
+
+
+    /**
+     * Get associated Coyote response.
+     * 
+     * @return the associated Coyote response
+     */
+    public Response getResponse() {
+        return this.coyoteResponse;
+    }
+
+
+    /**
+     * Is the response output suspended ?
+     * 
+     * @return suspended flag value
+     */
+    public boolean isSuspended() {
+        return this.suspended;
+    }
+
+
+    /**
+     * Set the suspended flag.
+     * 
+     * @param suspended New suspended flag value
+     */
+    public void setSuspended(boolean suspended) {
+        this.suspended = suspended;
+    }
+
+
+    // --------------------------------------------------------- Public Methods
+
+
+    /**
+     * Recycle the output buffer.
+     */
+    public void recycle() {
+        
+        state = INITIAL_STATE;
+        bytesWritten = 0;
+        charsWritten = 0;
+        
+        cb.recycle();
+        bb.recycle(); 
+        closed = false;
+        suspended = false;
+        
+        if (conv!= null) {
+            conv.recycle();
+        }
+        
+        gotEnc = false;
+        enc = null;
+        
+    }
+
+
+    /**
+     * Close the output buffer. This tries to calculate the response size if 
+     * the response has not been committed yet.
+     * 
+     * @throws IOException An underlying IOException occurred
+     */
+    public void close()
+        throws IOException {
+
+        if (closed)
+            return;
+        if (suspended)
+            return;
+
+        if ((!coyoteResponse.isCommitted()) 
+            && (coyoteResponse.getContentLengthLong() == -1)) {
+            // Flushing the char buffer
+            if (state == CHAR_STATE) {
+                cb.flushBuffer();
+                state = BYTE_STATE;
+            }
+            // If this didn't cause a commit of the response, the final content
+            // length can be calculated
+            if (!coyoteResponse.isCommitted()) {
+                coyoteResponse.setContentLength(bb.getLength());
+            }
+        }
+
+        doFlush(false);
+        closed = true;
+
+        coyoteResponse.finish();
+
+    }
+
+
+    /**
+     * Flush bytes or chars contained in the buffer.
+     * 
+     * @throws IOException An underlying IOException occurred
+     */
+    public void flush()
+        throws IOException {
+        doFlush(true);
+    }
+
+
+    /**
+     * Flush bytes or chars contained in the buffer.
+     * 
+     * @throws IOException An underlying IOException occurred
+     */
+    protected void doFlush(boolean realFlush)
+        throws IOException {
+
+        if (suspended)
+            return;
+
+        doFlush = true;
+        if (state == CHAR_STATE) {
+            cb.flushBuffer();
+            bb.flushBuffer();
+            state = BYTE_STATE;
+        } else if (state == BYTE_STATE) {
+            bb.flushBuffer();
+        } else if (state == INITIAL_STATE) {
+            // If the buffers are empty, commit the response header
+            coyoteResponse.sendHeaders();
+        }
+        doFlush = false;
+
+        if (realFlush) {
+            coyoteResponse.action(ActionCode.ACTION_CLIENT_FLUSH, 
+                                  coyoteResponse);
+            // If some exception occurred earlier, or if some IOE occurred
+            // here, notify the servlet with an IOE
+            if (coyoteResponse.isExceptionPresent()) {
+                throw new ClientAbortException
+                    (coyoteResponse.getErrorException());
+            }
+        }
+
+    }
+
+
+    // ------------------------------------------------- Bytes Handling Methods
+
+
+    /** 
+     * Sends the buffer data to the client output, checking the
+     * state of Response and calling the right interceptors.
+     * 
+     * @param buf Byte buffer to be written to the response
+     * @param off Offset
+     * @param cnt Length
+     * 
+     * @throws IOException An underlying IOException occurred
+     */
+    public void realWriteBytes(byte buf[], int off, int cnt)
+	throws IOException {
+
+        if (closed)
+            return;
+        if (coyoteResponse == null)
+            return;
+
+        // If we really have something to write
+        if (cnt > 0) {
+            // real write to the adapter
+            outputChunk.setBytes(buf, off, cnt);
+            try {
+                coyoteResponse.doWrite(outputChunk);
+            } catch (IOException e) {
+                // An IOException on a write is almost always due to
+                // the remote client aborting the request.  Wrap this
+                // so that it can be handled better by the error dispatcher.
+                throw new ClientAbortException(e);
+            }
+        }
+
+    }
+
+
+    public void write(byte b[], int off, int len) throws IOException {
+
+        if (suspended)
+            return;
+
+        if (state == CHAR_STATE)
+            cb.flushBuffer();
+        state = BYTE_STATE;
+        writeBytes(b, off, len);
+
+    }
+
+
+    private void writeBytes(byte b[], int off, int len) 
+        throws IOException {
+
+        if (closed)
+            return;
+
+        bb.append(b, off, len);
+        bytesWritten += len;
+
+        // if called from within flush(), then immediately flush
+        // remaining bytes
+        if (doFlush) {
+            bb.flushBuffer();
+        }
+
+    }
+
+
+    public void writeByte(int b)
+        throws IOException {
+
+        if (suspended)
+            return;
+
+        if (state == CHAR_STATE)
+            cb.flushBuffer();
+        state = BYTE_STATE;
+
+        bb.append( (byte)b );
+        bytesWritten++;
+
+    }
+
+
+    // ------------------------------------------------- Chars Handling Methods
+
+
+    public void write(int c)
+        throws IOException {
+
+        if (suspended)
+            return;
+
+        state = CHAR_STATE;
+
+        cb.append((char) c);
+        charsWritten++;
+
+    }
+
+
+    public void write(char c[])
+        throws IOException {
+
+        if (suspended)
+            return;
+
+        write(c, 0, c.length);
+
+    }
+
+
+    public void write(char c[], int off, int len)
+        throws IOException {
+
+        if (suspended)
+            return;
+
+        state = CHAR_STATE;
+
+        cb.append(c, off, len);
+        charsWritten += len;
+
+    }
+
+
+    public void write(StringBuffer sb)
+        throws IOException {
+
+        if (suspended)
+            return;
+
+        state = CHAR_STATE;
+
+        int len = sb.length();
+        charsWritten += len;
+        cb.append(sb);
+
+    }
+
+
+    /**
+     * Append a string to the buffer
+     */
+    public void write(String s, int off, int len)
+        throws IOException {
+
+        if (suspended)
+            return;
+
+        state=CHAR_STATE;
+
+        charsWritten += len;
+        if (s==null)
+            s="null";
+        cb.append( s, off, len );
+
+    }
+
+
+    public void write(String s)
+        throws IOException {
+
+        if (suspended)
+            return;
+
+        state = CHAR_STATE;
+        if (s==null)
+            s="null";
+        write(s, 0, s.length());
+
+    } 
+
+
+    public void flushChars()
+        throws IOException {
+
+        cb.flushBuffer();
+        state = BYTE_STATE;
+
+    }
+
+
+    public boolean flushCharsNeeded() {
+        return state == CHAR_STATE;
+    }
+
+
+    public void setEncoding(String s) {
+        enc = s;
+    }
+
+
+    public void realWriteChars(char c[], int off, int len) 
+        throws IOException {
+
+        if (!gotEnc)
+            setConverter();
+
+        conv.convert(c, off, len);
+        conv.flushBuffer();	// ???
+
+    }
+
+
+    public void checkConverter() 
+        throws IOException {
+
+        if (!gotEnc)
+            setConverter();
+
+    }
+
+
+    protected void setConverter() 
+        throws IOException {
+
+        if (coyoteResponse != null)
+            enc = coyoteResponse.getCharacterEncoding();
+
+        gotEnc = true;
+        if (enc == null)
+            enc = DEFAULT_ENCODING;
+        conv = (C2BConverter) encoders.get(enc);
+        if (conv == null) {
+            
+            if (System.getSecurityManager() != null){
+                try{
+                    conv = (C2BConverter)AccessController.doPrivileged(
+                            new PrivilegedExceptionAction(){
+
+                                public Object run() throws IOException{
+                                    return new C2BConverter(bb, enc);
+                                }
+
+                            }
+                    );              
+                }catch(PrivilegedActionException ex){
+                    Exception e = ex.getException();
+                    if (e instanceof IOException)
+                        throw (IOException)e; 
+                }
+            } else {
+                conv = new C2BConverter(bb, enc);
+            }
+            
+            encoders.put(enc, conv);
+
+        }
+    }
+
+    
+    // --------------------  BufferedOutputStream compatibility
+
+
+    /**
+     * Real write - this buffer will be sent to the client
+     */
+    public void flushBytes()
+        throws IOException {
+
+        bb.flushBuffer();
+
+    }
+
+
+    public int getBytesWritten() {
+        return bytesWritten;
+    }
+
+
+    public int getCharsWritten() {
+        return charsWritten;
+    }
+
+
+    public int getContentWritten() {
+        return bytesWritten + charsWritten;
+    }
+
+
+    /** 
+     * True if this buffer hasn't been used ( since recycle() ) -
+     * i.e. no chars or bytes have been added to the buffer.  
+     */
+    public boolean isNew() {
+        return (bytesWritten == 0) && (charsWritten == 0);
+    }
+
+
+    public void setBufferSize(int size) {
+        if (size > bb.getLimit()) {// ??????
+	    bb.setLimit(size);
+	}
+    }
+
+
+    public void reset() {
+
+        //count=0;
+        bb.recycle();
+        bytesWritten = 0;
+        cb.recycle();
+        charsWritten = 0;
+        gotEnc = false;
+        enc = null;
+        state = INITIAL_STATE;
+    }
+
+
+    public int getBufferSize() {
+	return bb.getLimit();
+    }
+
+
+    public static MessageWriter getWriter(Request req, Response res, int size) 
+    {        
+        MessageWriter out=(MessageWriter)req.getNote(MessageWriter.WRITER_NOTE);
+        if( out == null ) {
+            if( size<=0 ) {
+                out=new MessageWriter();
+            } else {
+                out=new MessageWriter(size);
+            }
+            out.setResponse(res);
+            req.setNote(MessageWriter.WRITER_NOTE, out );
+        }
+        return out;
+    }
+
+
+}



---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org


Mime
View raw message