nio4r 0.2.0 → 2.7.5

data/ext/nio4r/org/nio4r/ByteBuffer.java

@@ -0,0 +1,295 @@
+package org.nio4r;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.nio.channels.Channel;
+import java.nio.channels.SelectableChannel;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.WritableByteChannel;
+import java.nio.BufferOverflowException;
+import java.nio.BufferUnderflowException;
+import java.nio.InvalidMarkException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyIO;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.Block;
+
+/*
+created by Upekshej
+ */
+public class ByteBuffer extends RubyObject {
+    private static final long serialVersionUID = -6903439483039149324L;
+    private transient java.nio.ByteBuffer byteBuffer;
+
+    public static RaiseException newOverflowError(ThreadContext context, String message) {
+        RubyClass klass = context.runtime.getModule("NIO").getClass("ByteBuffer").getClass("OverflowError");
+        return context.runtime.newRaiseException(klass, message);
+    }
+
+    public static RaiseException newUnderflowError(ThreadContext context, String message) {
+        RubyClass klass = context.runtime.getModule("NIO").getClass("ByteBuffer").getClass("UnderflowError");
+        return context.runtime.newRaiseException(klass, message);
+    }
+
+    public static RaiseException newMarkUnsetError(ThreadContext context, String message) {
+        RubyClass klass = context.runtime.getModule("NIO").getClass("ByteBuffer").getClass("MarkUnsetError");
+        return context.runtime.newRaiseException(klass, message);
+    }
+
+    public ByteBuffer(final Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    @JRubyMethod
+    public IRubyObject initialize(ThreadContext context, IRubyObject capacity) {
+        this.byteBuffer = java.nio.ByteBuffer.allocate(RubyNumeric.num2int(capacity));
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject clear(ThreadContext context) {
+        this.byteBuffer.clear();
+        return this;
+    }
+
+    @JRubyMethod(name = "position")
+    public IRubyObject getPosition(ThreadContext context) {
+        return context.getRuntime().newFixnum(this.byteBuffer.position());
+    }
+
+    @JRubyMethod(name = "position=")
+    public IRubyObject setPosition(ThreadContext context, IRubyObject newPosition) {
+        int pos = RubyNumeric.num2int(newPosition);
+
+        if(pos < 0) {
+            throw context.runtime.newArgumentError("negative position given");
+        }
+
+        if(pos > this.byteBuffer.limit()) {
+            throw context.runtime.newArgumentError("specified position exceeds limit");
+        }
+
+        try {
+            this.byteBuffer.position(pos);
+            return newPosition;
+        } catch(IllegalArgumentException e) {
+            throw context.runtime.newArgumentError(e.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod(name = "limit")
+    public IRubyObject getLimit(ThreadContext context) {
+        return context.getRuntime().newFixnum(this.byteBuffer.limit());
+    }
+
+    @JRubyMethod(name = "limit=")
+    public IRubyObject setLimit(ThreadContext context, IRubyObject newLimit) {
+        int lim = RubyNumeric.num2int(newLimit);
+
+        if(lim < 0) {
+            throw context.runtime.newArgumentError("negative limit given");
+        }
+
+        if(lim > this.byteBuffer.capacity()) {
+            throw context.runtime.newArgumentError("specified limit exceeds capacity");
+        }
+
+        try {
+            this.byteBuffer.limit(lim);
+            return newLimit;
+        } catch(IllegalArgumentException e) {
+            throw context.runtime.newArgumentError(e.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod(name = {"capacity", "size"})
+    public IRubyObject capacity(ThreadContext context) {
+        return context.getRuntime().newFixnum(this.byteBuffer.capacity());
+    }
+
+    @JRubyMethod
+    public IRubyObject remaining(ThreadContext context) {
+        return context.getRuntime().newFixnum(this.byteBuffer.remaining());
+    }
+
+    @JRubyMethod(name = "full?")
+    public IRubyObject isFull(ThreadContext context) {
+        if (this.byteBuffer.hasRemaining()) {
+            return context.getRuntime().getFalse();
+        } else {
+            return context.getRuntime().getTrue();
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject get(ThreadContext context) {
+        return this.get(context, context.getRuntime().newFixnum(this.byteBuffer.remaining()));
+    }
+
+    @JRubyMethod
+    public IRubyObject get(ThreadContext context, IRubyObject length) {
+        int len = RubyNumeric.num2int(length);
+        byte[] bytes = new byte[len];
+
+        try {
+            this.byteBuffer.get(bytes);
+        } catch(BufferUnderflowException e) {
+            throw ByteBuffer.newUnderflowError(context, "not enough data in buffer");
+        }
+
+        return RubyString.newString(context.getRuntime(), bytes);
+    }
+
+    @JRubyMethod(name = "[]")
+    public IRubyObject fetch(ThreadContext context, IRubyObject index) {
+        int i = RubyNumeric.num2int(index);
+
+        if(i < 0) {
+            throw context.runtime.newArgumentError("negative index given");
+        }
+
+        if(i >= this.byteBuffer.limit()) {
+            throw context.runtime.newArgumentError("index exceeds limit");
+        }
+
+        return context.getRuntime().newFixnum(this.byteBuffer.get(i));
+    }
+
+    @JRubyMethod(name = "<<")
+    public IRubyObject put(ThreadContext context, IRubyObject str) {
+        try {
+            this.byteBuffer.put(str.convertToString().getByteList().bytes());
+        } catch(BufferOverflowException e) {
+            throw ByteBuffer.newOverflowError(context, "buffer is full");
+        }
+
+        return this;
+    }
+
+    @JRubyMethod(name = "read_from")
+    public IRubyObject readFrom(ThreadContext context, IRubyObject io) {
+        Ruby runtime = context.runtime;
+        Channel channel = RubyIO.convertToIO(context, io).getChannel();
+
+        if(!this.byteBuffer.hasRemaining()) {
+            throw ByteBuffer.newOverflowError(context, "buffer is full");
+        }
+
+        if(!(channel instanceof ReadableByteChannel) || !(channel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("unsupported IO object: " + io.getType().toString());
+        }
+
+        try {
+            ((SelectableChannel)channel).configureBlocking(false);
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+
+        try {
+            int bytesRead = ((ReadableByteChannel)channel).read(this.byteBuffer);
+
+            if(bytesRead >= 0) {
+                return runtime.newFixnum(bytesRead);
+            } else {
+                throw runtime.newEOFError();
+            }
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod(name = "write_to")
+    public IRubyObject writeTo(ThreadContext context, IRubyObject io) {
+        Ruby runtime = context.runtime;
+        Channel channel = RubyIO.convertToIO(context, io).getChannel();
+
+        if(!this.byteBuffer.hasRemaining()) {
+            throw ByteBuffer.newUnderflowError(context, "not enough data in buffer");
+        }
+
+        if(!(channel instanceof WritableByteChannel) || !(channel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("unsupported IO object: " + io.getType().toString());
+        }
+
+        try {
+            ((SelectableChannel)channel).configureBlocking(false);
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+
+        try {
+            int bytesWritten = ((WritableByteChannel)channel).write(this.byteBuffer);
+
+            if(bytesWritten >= 0) {
+                return runtime.newFixnum(bytesWritten);
+            } else {
+                throw runtime.newEOFError();
+            }
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject flip(ThreadContext context) {
+        this.byteBuffer.flip();
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject rewind(ThreadContext context) {
+        this.byteBuffer.rewind();
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject mark(ThreadContext context) {
+        this.byteBuffer.mark();
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject reset(ThreadContext context) {
+        try {
+            this.byteBuffer.reset();
+            return this;
+        } catch(InvalidMarkException ie) {
+            throw ByteBuffer.newMarkUnsetError(context, "mark has not been set");
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject compact(ThreadContext context) {
+        this.byteBuffer.compact();
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject each(ThreadContext context, Block block) {
+        for(int i = 0; i < this.byteBuffer.limit(); i++) {
+            block.call(context, context.getRuntime().newFixnum(this.byteBuffer.get(i)));
+        }
+
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject inspect(ThreadContext context) {
+        return context.runtime.newString(String.format(
+            "#<%s:0x%x @position=%d @limit=%d @capacity=%d>",
+            this.getType().toString(),
+            System.identityHashCode(this),
+            this.byteBuffer.position(),
+            this.byteBuffer.limit(),
+            this.byteBuffer.capacity()
+        ));
+    }
+}

data/ext/nio4r/org/nio4r/Monitor.java

@@ -0,0 +1,176 @@
+package org.nio4r;
+
+import java.nio.channels.Channel;
+import java.nio.channels.SelectableChannel;
+import java.nio.channels.SelectionKey;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyIO;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class Monitor extends RubyObject {
+    private static final long serialVersionUID = -3733782997115074794L;
+    private transient SelectionKey key;
+    private RubyIO io;
+    private transient IRubyObject interests, selector, value, closed;
+
+    public Monitor(final Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    @JRubyMethod
+    public IRubyObject initialize(ThreadContext context, IRubyObject selectable, IRubyObject interests, IRubyObject selector) {
+        this.io        = RubyIO.convertToIO(context, selectable);
+        this.interests = interests;
+        this.selector  = selector;
+
+        this.value  = context.nil;
+        this.closed = context.getRuntime().getFalse();
+
+        return context.nil;
+    }
+
+    public void setSelectionKey(SelectionKey key) {
+        this.key = key;
+        key.attach(this);
+    }
+
+    @JRubyMethod
+    public IRubyObject io(ThreadContext context) {
+        return io;
+    }
+
+    @JRubyMethod
+    public IRubyObject selector(ThreadContext context) {
+        return selector;
+    }
+
+    @JRubyMethod(name = "interests")
+    public IRubyObject getInterests(ThreadContext context) {
+        return interests;
+    }
+
+    @JRubyMethod(name = "interests=")
+    public IRubyObject setInterests(ThreadContext context, IRubyObject interests) {
+        if(this.closed == context.getRuntime().getTrue()) {
+            throw context.getRuntime().newEOFError("monitor is closed");
+        }
+
+        Ruby ruby = context.getRuntime();
+        SelectableChannel channel = (SelectableChannel)io.getChannel();
+
+        if(interests != context.nil) {
+            key.interestOps(Nio4r.symbolToInterestOps(ruby, channel, interests));
+        } else {
+            key.interestOps(0);
+        }
+        
+        this.interests = interests;
+
+        return this.interests;
+    }
+
+    @JRubyMethod(name = "add_interest")
+    public IRubyObject addInterest(ThreadContext context, IRubyObject interest) {
+        if(this.closed == context.getRuntime().getTrue()) {
+            throw context.getRuntime().newEOFError("monitor is closed");
+        }
+
+        Ruby ruby = context.getRuntime();
+        SelectableChannel channel = (SelectableChannel)io.getChannel();
+        int newInterestOps = key.interestOps() | Nio4r.symbolToInterestOps(ruby, channel, interest);
+
+        key.interestOps(newInterestOps);
+        this.interests = Nio4r.interestOpsToSymbol(ruby, newInterestOps);
+
+        return this.interests;
+    }
+
+    @JRubyMethod(name = "remove_interest")
+    public IRubyObject removeInterest(ThreadContext context, IRubyObject interest) {
+        if(this.closed == context.getRuntime().getTrue()) {
+            throw context.getRuntime().newEOFError("monitor is closed");
+        }
+
+        Ruby ruby = context.getRuntime();
+        SelectableChannel channel = (SelectableChannel)io.getChannel();
+        int newInterestOps = key.interestOps() & ~Nio4r.symbolToInterestOps(ruby, channel, interest);
+
+        key.interestOps(newInterestOps);
+        this.interests = Nio4r.interestOpsToSymbol(ruby, newInterestOps);
+
+        return this.interests;
+    }
+
+    @JRubyMethod
+    public IRubyObject readiness(ThreadContext context) {
+        if(!key.isValid())
+          return this.interests; 
+        return Nio4r.interestOpsToSymbol(context.getRuntime(), key.readyOps());
+    }
+
+    @JRubyMethod(name = "readable?")
+    public IRubyObject isReadable(ThreadContext context) {
+        Ruby runtime  = context.getRuntime();
+        if (!this.key.isValid())
+          return runtime.getTrue();
+        int  readyOps = this.key.readyOps();
+
+        if((readyOps & SelectionKey.OP_READ) != 0 || (readyOps & SelectionKey.OP_ACCEPT) != 0) {
+            return runtime.getTrue();
+        } else {
+            return runtime.getFalse();
+        }
+    }
+
+    @JRubyMethod(name = {"writable?", "writeable?"})
+    public IRubyObject writable(ThreadContext context) {
+        Ruby runtime  = context.getRuntime();
+        if (!this.key.isValid())
+          return runtime.getTrue();
+        int  readyOps = this.key.readyOps();
+
+        if((readyOps & SelectionKey.OP_WRITE) != 0 || (readyOps & SelectionKey.OP_CONNECT) != 0) {
+            return runtime.getTrue();
+        } else {
+            return runtime.getFalse();
+        }
+    }
+
+    @JRubyMethod(name = "value")
+    public IRubyObject getValue(ThreadContext context) {
+        return this.value;
+    }
+
+    @JRubyMethod(name = "value=")
+    public IRubyObject setValue(ThreadContext context, IRubyObject obj) {
+        this.value = obj;
+        return context.nil;
+    }
+
+    @JRubyMethod
+    public IRubyObject close(ThreadContext context) {
+        return close(context, context.getRuntime().getTrue());
+    }
+
+    @JRubyMethod
+    public IRubyObject close(ThreadContext context, IRubyObject deregister) {
+        Ruby runtime = context.getRuntime();
+        this.closed = runtime.getTrue();
+
+        if(deregister == runtime.getTrue()) {
+            selector.callMethod(context, "deregister", io);
+        }
+
+        return context.nil;
+    }
+
+    @JRubyMethod(name = "closed?")
+    public IRubyObject isClosed(ThreadContext context) {
+        return this.closed;
+    }
+}

data/ext/nio4r/org/nio4r/Nio4r.java

@@ -0,0 +1,104 @@
+package org.nio4r;
+
+import java.nio.channels.SelectableChannel;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.SocketChannel;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.load.Library;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import org.nio4r.ByteBuffer;
+import org.nio4r.Monitor;
+import org.nio4r.Selector;
+
+public class Nio4r implements Library {
+    private Ruby ruby;
+
+    public void load(final Ruby ruby, boolean bln) {
+        this.ruby = ruby;
+
+        RubyModule nio = ruby.defineModule("NIO");
+
+        RubyClass selector = ruby.defineClassUnder("Selector", ruby.getObject(), new ObjectAllocator() {
+            public IRubyObject allocate(Ruby ruby, RubyClass rc) {
+                return new Selector(ruby, rc);
+            }
+        }, nio);
+
+        selector.defineAnnotatedMethods(Selector.class);
+
+        RubyClass monitor = ruby.defineClassUnder("Monitor", ruby.getObject(), new ObjectAllocator() {
+            public IRubyObject allocate(Ruby ruby, RubyClass rc) {
+                return new Monitor(ruby, rc);
+            }
+        }, nio);
+
+        monitor.defineAnnotatedMethods(Monitor.class);
+
+        RubyClass byteBuffer = ruby.defineClassUnder("ByteBuffer", ruby.getObject(), new ObjectAllocator() {
+            public IRubyObject allocate(Ruby ruby, RubyClass rc) {
+                return new ByteBuffer(ruby, rc);
+            }
+        }, nio);
+
+        byteBuffer.defineAnnotatedMethods(ByteBuffer.class);
+        byteBuffer.includeModule(ruby.getEnumerable());
+
+        ruby.defineClassUnder("OverflowError",  ruby.getIOError(), ruby.getIOError().getAllocator(), byteBuffer);
+        ruby.defineClassUnder("UnderflowError", ruby.getIOError(), ruby.getIOError().getAllocator(), byteBuffer);
+        ruby.defineClassUnder("MarkUnsetError", ruby.getIOError(), ruby.getIOError().getAllocator(), byteBuffer);
+    }
+
+    public static int symbolToInterestOps(Ruby ruby, SelectableChannel channel, IRubyObject interest) {
+        if(interest == ruby.newSymbol("r")) {
+            if((channel.validOps() & SelectionKey.OP_ACCEPT) != 0) {
+              return SelectionKey.OP_ACCEPT;
+            } else {
+              return SelectionKey.OP_READ;
+            }
+        } else if(interest == ruby.newSymbol("w")) {
+            if(channel instanceof SocketChannel && !((SocketChannel)channel).isConnected()) {
+                return SelectionKey.OP_CONNECT;
+            } else {
+                return SelectionKey.OP_WRITE;
+            }
+        } else if(interest == ruby.newSymbol("rw")) {
+            int interestOps = 0;
+
+            /* nio4r emulates the POSIX behavior, which is sloppy about allowed modes */
+            if((channel.validOps() & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0) {
+                interestOps |= symbolToInterestOps(ruby, channel, ruby.newSymbol("r"));
+            }
+
+            if((channel.validOps() & (SelectionKey.OP_WRITE | SelectionKey.OP_CONNECT)) != 0) {
+                interestOps |= symbolToInterestOps(ruby, channel, ruby.newSymbol("w"));
+            }
+
+            return interestOps;
+        } else {
+            throw ruby.newArgumentError("invalid interest type: " + interest);
+        }
+    }
+
+    public static IRubyObject interestOpsToSymbol(Ruby ruby, int interestOps) {
+        switch(interestOps) {
+            case SelectionKey.OP_READ:
+            case SelectionKey.OP_ACCEPT:
+                return ruby.newSymbol("r");
+            case SelectionKey.OP_WRITE:
+            case SelectionKey.OP_CONNECT:
+                return ruby.newSymbol("w");
+            case SelectionKey.OP_READ | SelectionKey.OP_CONNECT:
+            case SelectionKey.OP_READ | SelectionKey.OP_WRITE:
+                return ruby.newSymbol("rw");
+            case 0:
+                return ruby.getNil();
+            default:
+                throw ruby.newArgumentError("unknown interest op combination");
+        }
+    }
+}