Reorganize compiler for more flexibility.

[jagi.git] / src / jagi / scgi / SimpleServer.java

package jagi.scgi;

import jagi.*;
import java.util.*;
import java.util.function.*;
import java.io.*;
import java.nio.*;
import java.nio.channels.*;

public class SimpleServer implements Runnable {
    private final ServerSocketChannel sk;
    private final Function handler;

    public SimpleServer(ServerSocketChannel sk, Function handler) {
	this.sk = sk;
	this.handler = handler;
    }

    private void respond(SocketChannel cl, String status, Map resp) throws IOException {
	Object output = resp.get("jagi.output");
	try {
	    BufferedWriter fm = new BufferedWriter(Channels.newWriter(cl, Utils.UTF8.newEncoder(), -1));
	    fm.write("Status: ");
	    fm.write(status);
	    fm.write("\n");
	    for(Iterator it = resp.entrySet().iterator(); it.hasNext();) {
		Map.Entry ent = (Map.Entry)it.next();
		Object val = ent.getValue();
		if((ent.getKey() instanceof String) && (val != null)) {
		    String key = (String)ent.getKey();
		    if(key.startsWith("http.")) {
			String head = key.substring(5);
			if(head.equalsIgnoreCase("status"))
			    continue;
			if(val instanceof Collection) {
			    for(Object part : (Collection)val) {
				fm.write(head);
				fm.write(": ");
				fm.write(part.toString());
				fm.write("\n");
			    }
			} else {
			    fm.write(head);
			    fm.write(": ");
			    fm.write(val.toString());
			    fm.write("\n");
			}
		    }
		}
	    }
	    fm.write("\n");
	    fm.flush();
	    if(output == null) {
	    } else if(output instanceof byte[]) {
		Utils.writeall(cl, ByteBuffer.wrap((byte[])output));
	    } else if(output instanceof ByteBuffer) {
		Utils.writeall(cl, (ByteBuffer)output);
	    } else if(output instanceof String) {
		Utils.writeall(cl, ByteBuffer.wrap(((String)output).getBytes(Utils.UTF8)));
	    } else if(output instanceof CharSequence) {
		Utils.writeall(cl, Utils.UTF8.encode(CharBuffer.wrap((CharSequence)output)));
	    } else if(output instanceof InputStream) {
		Utils.transfer(cl, Channels.newChannel((InputStream)output));
	    } else if(output instanceof ReadableByteChannel) {
		Utils.transfer(cl, (ReadableByteChannel)output);
	    } else {
		throw(new  IllegalArgumentException("response-body: " + String.valueOf(output)));
	    }
	} finally {
	    if(output instanceof Closeable)
		((Closeable)output).close();
	}
    }

    private void feedinput(SocketChannel cl, Map resp) throws IOException {
	Object sink = resp.get("jagi.input-sink");
	try {
	    if(sink instanceof OutputStream) {
		Utils.transfer(Channels.newChannel((OutputStream)sink), cl);
	    } else if(sink instanceof WritableByteChannel) {
		Utils.transfer((WritableByteChannel)sink, cl);
	    } else {
		throw(new IllegalArgumentException("input-sink: " + String.valueOf(sink)));
	    }
	} finally {
	    if(sink instanceof Closeable)
		((Closeable)sink).close();
	}
    }

    @SuppressWarnings("unchecked")
    private void serve(SocketChannel cl) throws IOException {
	Function handler = this.handler;
	Map<Object, Object> env = Jagi.mkenv(cl);
	Throwable error = null;
	try {
	    while(true) {
		Map resp = (Map)handler.apply(env);
		String st;
		if((st = (String)resp.get("jagi.status")) != null) {
		    handler = (Function)resp.get("jagi.next");
		    switch(st) {
		    case "feed-input":
			feedinput(cl, resp);
			break;
		    case "chain":
			break;
		    default:
			throw(new IllegalArgumentException(st));
		    }
		} else if((st = (String)resp.get("http.status")) != null) {
		    respond(cl, st, resp);
		    break;
		}
	    }
	} catch(Throwable t) {
	    error = t;
	    throw(t);
	} finally {
	    Collection cleanup = (Collection)env.get("jagi.cleanup");
	    RuntimeException ce = null;
	    for(Object obj : cleanup) {
		if(obj instanceof AutoCloseable) {
		    try {
			((AutoCloseable)obj).close();
		    } catch(Exception e) {
			if(error == null)
			    error = ce = new RuntimeException("error(s) occurred during cleanup");
			error.addSuppressed(e);
		    }
		}
	    }
	    if(ce != null)
		throw(ce);
	}
    }

    public void run() {
	while(true) {
	    SocketChannel cl;
	    try {
		cl = sk.accept();
	    } catch(IOException e) {
		throw(new RuntimeException(e));
	    }
	    try {
		serve(cl);
	    } catch(Exception e) {
		e.printStackTrace();
	    } finally {
		try {
		    cl.close();
		} catch(IOException e) {
		    e.printStackTrace();
		}
	    }
	}
    }
}