jubilee 2.1.0.Alpha1-java → 2.1.0.beta-java

data/java/src/org/jruby/jubilee/RackInput.java

@@ -6,19 +6,19 @@ import org.jruby.runtime.builtin.IRubyObject;
 
 /**
  * @author isaiah
+ * @author nicksieger
  * @since Nov 26, 2012
- *
+ * <p/>
  * Specification for Rack input, translated to a Java interface.
- * @author nicksieger
  */
-public interface RackInput
-{
+public interface RackInput {
     /**
      * gets must be called without arguments and return a string, or nil on EOF.
+     *
      * @param context it's a JRuby thing
      * @return a string, or nil on EOF
      */
-    IRubyObject gets( ThreadContext context );
+    IRubyObject gets(ThreadContext context);
 
     /**
      * read behaves like IO#read. Its signature is read([length, [buffer]]). If given,
@@ -29,29 +29,32 @@ public interface RackInput
      * method returns nil if length is given and not nil, or "" if length is not
      * given or is nil. If buffer is given, then the read data will be placed into
      * buffer instead of a newly created String object.
+     *
      * @param context it's a JRuby thing
-     * @param args [length, [buffer]]
+     * @param args    [length, [buffer]]
      * @return nil if length is given and not nil, or "" if length is not given or nil
      */
-    IRubyObject read( ThreadContext context, IRubyObject[] args );
+    IRubyObject read(ThreadContext context, IRubyObject[] args);
 
     /**
      * each must be called without arguments and only yield Strings.
+     *
      * @param context it's a JRuby thing
-     * @param block that receives yield of Strings
+     * @param block   that receives yield of Strings
      * @return pretty much nil
      */
-    public IRubyObject each( ThreadContext context, Block block );
+    public IRubyObject each(ThreadContext context, Block block);
 
     /**
      * rewind must be called without arguments. It rewinds the input stream back
      * to the beginning. It must not raise Errno::ESPIPE: that is, it may not be
      * a pipe or a socket. Therefore, handler developers must buffer the input
      * data into some rewindable object if the underlying input stream is not rewindable.
+     *
      * @param context it's a JRuby thing
      * @return pretty much nil
      */
-    public IRubyObject rewind( ThreadContext context );
+    public IRubyObject rewind(ThreadContext context);
 
     /**
      * Close the input. Exposed only to the Java side because the Rack spec says

data/java/src/org/jruby/jubilee/RubyCallable.java

@@ -0,0 +1,52 @@
+package org.jruby.jubilee;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * A RubyClass that expose a call method, like a proc
+ * There must be a class in JRuby for this, but I just couldn't find it.
+ */
+public class RubyCallable extends RubyObject {
+    private Callable callable;
+
+    public static RubyClass createClallableClass(final Ruby runtime) {
+        RubyModule jubilee = runtime.getOrCreateModule("Jubilee");
+        RubyClass klazz = jubilee.defineClassUnder("Callable", runtime.getObject(), new ObjectAllocator() {
+            @Override
+            public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+                return new RubyCallable(ruby, rubyClass);
+            }
+        });
+        klazz.defineAnnotatedMethods(RubyCallable.class);
+        return klazz;
+    }
+
+    public RubyCallable(Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    public RubyCallable(Ruby ruby, RubyClass rubyClass, Callable callable) {
+        super(ruby, rubyClass);
+        this.callable = callable;
+    }
+
+    @JRubyMethod
+    public IRubyObject call(ThreadContext context) {
+        this.callable.call();
+        return context.runtime.getNil();
+    }
+
+    public static abstract class Callable {
+        public void call() {
+        }
+
+        ;
+    }
+}

data/java/src/org/jruby/jubilee/RubyChannel.java

@@ -0,0 +1,89 @@
+package org.jruby.jubilee;
+
+import io.netty.channel.Channel;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * Created by isaiah on 25/12/2013.
+ */
+@JRubyClass(name = "Channel")
+public class RubyChannel extends RubyObject {
+    private Channel chan;
+
+    public static RubyClass createChannelClass(final Ruby runtime) {
+        RubyModule vertxModule = runtime.getOrCreateModule("Jubilee");
+        RubyClass klazz = vertxModule.defineClassUnder("Channel", runtime.getObject(), new ObjectAllocator() {
+            @Override
+            public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+                return new RubyChannel(ruby, rubyClass);
+            }
+        });
+        klazz.defineAnnotatedMethods(RubyChannel.class);
+        return klazz;
+    }
+
+    public RubyChannel(Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    @JRubyMethod
+    public IRubyObject read(ThreadContext context) throws InterruptedException {
+        return context.runtime.getNil();
+    }
+
+    @JRubyMethod
+    public IRubyObject write(ThreadContext context) {
+        return context.runtime.getNil();
+
+    }
+
+    @JRubyMethod
+    public IRubyObject readNonBlock(ThreadContext context) {
+
+        return context.runtime.getNil();
+    }
+
+    @JRubyMethod
+    public IRubyObject writeNonBlock(ThreadContext context) {
+
+        return context.runtime.getNil();
+    }
+
+    @JRubyMethod
+    public IRubyObject flush(ThreadContext context) {
+
+        return context.runtime.getNil();
+    }
+
+    @JRubyMethod
+    public IRubyObject close(ThreadContext context) {
+
+        return context.runtime.getNil();
+    }
+
+    @JRubyMethod
+    public IRubyObject closeRead(ThreadContext context) {
+
+        return context.runtime.getNil();
+    }
+
+    @JRubyMethod
+    public IRubyObject closeWrite(ThreadContext context) {
+
+        return context.runtime.getNil();
+    }
+
+    @JRubyMethod(name = "closed?")
+    public IRubyObject isClosed(ThreadContext context) {
+
+        return context.runtime.getNil();
+    }
+}

data/java/src/org/jruby/jubilee/RubyHttpServerResponse.java

@@ -6,6 +6,8 @@ import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.vertx.java.core.http.HttpServer;
+import org.vertx.java.core.http.HttpServerRequest;
 import org.vertx.java.core.http.HttpServerResponse;
 
 import java.util.Arrays;
@@ -15,74 +17,84 @@ import java.util.Arrays;
  */
 @JRubyClass(name = "HttpServerResponse")
 public class RubyHttpServerResponse extends RubyObject {
-  private HttpServerResponse resp;
-  private String lineSeparator;
+    private HttpServerResponse resp;
+    private HttpServerRequest req;
+    private String lineSeparator;
 
-  public static RubyClass createHttpServerResponseClass(final Ruby runtime) {
-    RubyModule mJubilee = runtime.getOrCreateModule("Jubilee");
-    RubyClass klazz = mJubilee.defineClassUnder("HttpServerResponse", runtime.getObject(), new ObjectAllocator() {
-      @Override
-      public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
-        return new RubyHttpServerResponse(ruby, rubyClass);
-      }
-    });
-    klazz.defineAnnotatedMethods(RubyHttpServerResponse.class);
-    return klazz;
-  }
+    public static RubyClass createHttpServerResponseClass(final Ruby runtime) {
+        RubyModule mJubilee = runtime.getOrCreateModule("Jubilee");
+        RubyClass klazz = mJubilee.defineClassUnder("HttpServerResponse", runtime.getObject(), new ObjectAllocator() {
+            @Override
+            public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+                return new RubyHttpServerResponse(ruby, rubyClass);
+            }
+        });
+        klazz.defineAnnotatedMethods(RubyHttpServerResponse.class);
+        return klazz;
+    }
 
-  public RubyHttpServerResponse(Ruby ruby, RubyClass rubyClass) {
-    super(ruby, rubyClass);
-  }
+    public RubyHttpServerResponse(Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
 
-  public RubyHttpServerResponse(Ruby ruby, RubyClass rubyClass, HttpServerResponse resp) {
-    super(ruby, rubyClass);
-    this.resp = resp;
-    this.lineSeparator = System.getProperty("line.separator");
-  }
+    public RubyHttpServerResponse(Ruby ruby, RubyClass rubyClass, HttpServerRequest request) {
+        super(ruby, rubyClass);
+        this.resp = request.response();
+        this.req = request;
+        this.lineSeparator = System.getProperty("line.separator");
+    }
 
-  @JRubyMethod
-  public IRubyObject write(ThreadContext context, IRubyObject string) {
-    this.resp.write(string.asJavaString());
-    return context.runtime.getNil();
-  }
+    @JRubyMethod
+    public IRubyObject write(ThreadContext context, IRubyObject string) {
+        this.resp.write(string.asJavaString());
+        return context.runtime.getNil();
+    }
 
-  @JRubyMethod(name = "status_code=")
-  public IRubyObject setStatusCode(ThreadContext context, IRubyObject statusCode) {
-    this.resp.setStatusCode(RubyNumeric.num2int(statusCode));
-    return context.runtime.getNil();
-  }
+    @JRubyMethod(name = "status_code=")
+    public IRubyObject setStatusCode(ThreadContext context, IRubyObject statusCode) {
+        this.resp.setStatusCode(RubyNumeric.num2int(statusCode));
+        return context.runtime.getNil();
+    }
 
-  @JRubyMethod(name = "chunked=")
-  public IRubyObject setChunked(ThreadContext context, IRubyObject chunked) {
-    this.resp.setChunked(chunked.isTrue());
-    return context.runtime.getNil();
-  }
+    @JRubyMethod(name = "chunked=")
+    public IRubyObject setChunked(ThreadContext context, IRubyObject chunked) {
+        this.resp.setChunked(chunked.isTrue());
+        return context.runtime.getNil();
+    }
 
-  @JRubyMethod(name = "put_header")
-  public IRubyObject putHeader(ThreadContext context, IRubyObject key, IRubyObject val) {
-    String cookie = val.asJavaString();
-    if (cookie.indexOf(this.lineSeparator) != -1)
-      this.resp.putHeader(key.asJavaString(),
-              Arrays.asList(val.asJavaString().split(this.lineSeparator)));
-    else this.resp.putHeader(key.asJavaString(), val.asJavaString());
-    return context.runtime.getNil();
-  }
+    @JRubyMethod(name = "put_header")
+    public IRubyObject putHeader(ThreadContext context, IRubyObject key, IRubyObject val) {
+        String cookie = val.asJavaString();
+        if (cookie.indexOf(this.lineSeparator) != -1)
+            this.resp.putHeader(key.asJavaString(),
+                    Arrays.asList(val.asJavaString().split(this.lineSeparator)));
+        else this.resp.putHeader(key.asJavaString(), val.asJavaString());
+        return context.runtime.getNil();
+    }
 
-  @JRubyMethod(name = "send_file")
-  public IRubyObject sendFile(ThreadContext context, IRubyObject filePath) {
-    this.resp.sendFile(filePath.asJavaString());
-    return context.runtime.getNil();
-  }
+    @JRubyMethod(name = "send_file")
+    public IRubyObject sendFile(ThreadContext context, IRubyObject filePath) {
+        this.resp.sendFile(filePath.asJavaString());
+        return context.runtime.getNil();
+    }
 
-  @JRubyMethod
-  public IRubyObject end(ThreadContext context) {
-    this.resp.end();
-    return context.runtime.getNil();
-  }
+    @JRubyMethod
+    public IRubyObject end(ThreadContext context) {
+        this.resp.end();
+        return context.runtime.getNil();
+    }
 
-  @JRubyMethod(name = "put_default_headers")
-  public IRubyObject putDefaultHeaders(ThreadContext context) {
-    this.resp.putHeader("Server", Const.JUBILEE_VERSION);
-    return context.runtime.getNil();
-  }
+    @JRubyMethod(name = "put_default_headers")
+    public IRubyObject putDefaultHeaders(ThreadContext context) {
+        this.resp.putHeader("Server", Const.JUBILEE_VERSION);
+        return context.runtime.getNil();
+    }
+
+    //TODO(isaiah) At the moment Vertx doesn't support hijack the response socket,
+    // between request.response() and request.netSocket() only one can be invoked.
+    @JRubyMethod
+    public IRubyObject net_socket(ThreadContext context) {
+        RubyClass netSocketClass = (RubyClass) context.runtime.getClassFromPath("Jubilee::NetSocket");
+        return new RubyNetSocket(context.runtime, netSocketClass, this.req.netSocket());
+    }
 }

data/java/src/org/jruby/jubilee/RubyNetSocket.java

@@ -0,0 +1,169 @@
+package org.jruby.jubilee;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import org.jruby.*;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.vertx.java.core.Handler;
+import org.vertx.java.core.VoidHandler;
+import org.vertx.java.core.buffer.Buffer;
+import org.vertx.java.core.net.NetSocket;
+import org.vertx.java.core.streams.WriteStream;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * This class create a ruby IO interface by wrapping a Vertx NetSocket object.
+ * <p/>
+ * Not threadsafe.
+ */
+@JRubyClass(name="NetSocket")
+public class RubyNetSocket extends RubyObject {
+    private NetSocket sock;
+    private ByteBuf buf;
+    private AtomicBoolean eof;
+    private boolean readClosed = false;
+    private boolean writeClosed = false;
+    private boolean closed = false;
+
+    private final static int BUFSIZE = 4096 * 2;
+
+    public static RubyClass createNetSocketClass(final Ruby runtime) {
+        RubyModule jubilee = runtime.getOrCreateModule("Jubilee");
+        RubyClass klazz = jubilee.defineClassUnder("NetSocket", runtime.getObject(), new ObjectAllocator() {
+            @Override
+            public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+                return new RubyNetSocket(ruby, rubyClass);
+            }
+        });
+        klazz.defineAnnotatedMethods(RubyNetSocket.class);
+        return klazz;
+    }
+
+    public RubyNetSocket(Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    public RubyNetSocket(Ruby ruby, RubyClass rubyClass, NetSocket socket) {
+        super(ruby, rubyClass);
+        this.sock = socket;
+        this.buf = Unpooled.buffer(BUFSIZE);
+        this.eof = new AtomicBoolean(false);
+        this.sock.dataHandler(new Handler<Buffer>() {
+            @Override
+            public void handle(Buffer buffer) {
+                if (buf.isWritable(buffer.length()))
+                    buf.writeBytes(buffer.getByteBuf());
+                else sock.pause();
+            }
+        });
+
+        this.sock.endHandler(new VoidHandler() {
+            @Override
+            protected void handle() {
+                eof.set(true);
+            }
+        });
+    }
+
+    /**
+     * Both of the calls block
+     *
+     * @param context
+     * @param args
+     * @return
+     */
+    @JRubyMethod(name = {"read", "read_nonblock"}, required = 1, optional = 1)
+    public IRubyObject read(ThreadContext context, IRubyObject[] args) {
+        if (this.readClosed) throw context.runtime.newIOError("closed stream");
+        int length = RubyNumeric.num2int(args[0]);
+        byte[] data;
+        if (args.length == 1)
+            data = new byte[length];
+        else data = ((RubyString) args[1]).getBytes();
+        if (!(eof.get() || buf.isReadable())) {
+            this.buf.clear();
+            this.sock.resume();
+        }
+        waitReadable(this.buf);
+        while (!eof.get() && length > 0) {
+            int readedLength = Math.min(this.buf.readableBytes(), length);
+            this.buf.readBytes(data, this.buf.readerIndex(), readedLength);
+            length -= readedLength;
+        }
+        return context.runtime.newString(new ByteList(data));
+    }
+
+    /**
+     * Though required by rack spec to impelement write_nonblock, it's just easier to block both of the calls.
+     *
+     * @param context the calling threadcontext
+     * @param str     the string to write to the underline stream
+     * @return the length written
+     */
+    @JRubyMethod(name = {"write", "write_nonblock"}, required = 1)
+    public IRubyObject write(ThreadContext context, IRubyObject str) {
+        if (this.writeClosed) throw context.runtime.newIOError("closed stream");
+        RubyString data;
+        if (str instanceof RubyString)
+            data = (RubyString) str;
+        else
+            data = (RubyString) str.callMethod(context, "to_s");
+        if (this.sock.writeQueueFull())
+            waitWritable(this.sock);
+        this.sock.write(data.asJavaString());
+        // TODO return the length actually written
+        return data.length();
+    }
+
+    @JRubyMethod(name = "close_write")
+    public IRubyObject closeWrite(ThreadContext context) {
+        this.writeClosed = true;
+        return context.runtime.getTrue();
+    }
+
+    @JRubyMethod(name = "closeRead")
+    public IRubyObject closeRead(ThreadContext context) {
+        this.readClosed = true;
+        return context.runtime.getTrue();
+    }
+
+    @JRubyMethod(name = "close")
+    public IRubyObject close(ThreadContext context) {
+        this.sock.close();
+        this.closed = true;
+        return context.runtime.getTrue();
+    }
+
+    @JRubyMethod(name = "closed?")
+    public IRubyObject isClosed(ThreadContext context) {
+        return context.runtime.newBoolean(this.closed);
+    }
+
+    @JRubyMethod(name = "flush")
+    public IRubyObject flush(ThreadContext context) {
+        return context.runtime.getTrue();
+    }
+
+    private void waitWritable(WriteStream<?> stream) {
+        final AtomicBoolean writable = new AtomicBoolean(false);
+        stream.drainHandler(new Handler<Void>() {
+            @Override
+            public void handle(Void empty) {
+                writable.set(true);
+            }
+        });
+        while (!writable.get())
+            ;
+    }
+
+    private void waitReadable(ByteBuf buf) {
+        while (!buf.isReadable())
+            ;
+    }
+}