ed-precompiled_nio4r 2.7.4-x86_64-linux

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");
+        }
+    }
+}

data/ext/nio4r/org/nio4r/Selector.java

@@ -0,0 +1,297 @@
+package org.nio4r;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.HashMap;
+import java.io.IOException;
+import java.nio.channels.Channel;
+import java.nio.channels.SelectableChannel;
+import java.nio.channels.SelectionKey;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyIO;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.io.OpenFile;
+
+public class Selector extends RubyObject {
+    private static final long serialVersionUID = -14562818539414873L;
+    private transient java.nio.channels.Selector selector;
+    private HashMap<SelectableChannel,SelectionKey> cancelledKeys;
+    private volatile boolean wakeupFired;
+
+    public Selector(final Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    @JRubyMethod(meta = true)
+    public static IRubyObject backends(ThreadContext context, IRubyObject self) {
+        return context.runtime.newArray(context.runtime.newSymbol("java"));
+    }
+
+    @JRubyMethod
+    public IRubyObject initialize(ThreadContext context) {
+        initialize(context, context.runtime.newSymbol("java"));
+        return context.nil;
+    }
+
+    @JRubyMethod
+    public IRubyObject initialize(ThreadContext context, IRubyObject backend) {
+        if(backend != context.runtime.newSymbol("java") && !backend.isNil()) {
+            throw context.runtime.newArgumentError(":java is the only supported backend");
+        }
+
+        this.cancelledKeys = new HashMap<SelectableChannel,SelectionKey>();
+        this.wakeupFired = false;
+
+        try {
+            this.selector = java.nio.channels.Selector.open();
+        } catch(IOException ie) {
+            throw context.runtime.newIOError(ie.getLocalizedMessage());
+        }
+
+        return context.nil;
+    }
+
+    @JRubyMethod
+    public IRubyObject backend(ThreadContext context) {
+        return context.runtime.newSymbol("java");
+    }
+
+    @JRubyMethod
+    public IRubyObject close(ThreadContext context) {
+        try {
+            this.selector.close();
+        } catch(IOException ie) {
+            throw context.runtime.newIOError(ie.getLocalizedMessage());
+        }
+
+        return context.nil;
+    }
+
+    @JRubyMethod(name = "closed?")
+    public IRubyObject isClosed(ThreadContext context) {
+        Ruby runtime = context.getRuntime();
+        return this.selector.isOpen() ? runtime.getFalse() : runtime.getTrue();
+    }
+
+    @JRubyMethod(name = "empty?")
+    public IRubyObject isEmpty(ThreadContext context) {
+        Ruby runtime = context.getRuntime();
+        return this.selector.keys().isEmpty() ? runtime.getTrue() : runtime.getFalse();
+    }
+
+    @JRubyMethod
+    public IRubyObject register(ThreadContext context, IRubyObject io, IRubyObject interests) {
+        Ruby runtime = context.getRuntime();
+        Channel rawChannel = RubyIO.convertToIO(context, io).getChannel();
+
+        if(!this.selector.isOpen()) {
+            throw context.getRuntime().newIOError("selector is closed");
+        }
+
+        if(!(rawChannel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("not a selectable IO object");
+        }
+
+        SelectableChannel channel = (SelectableChannel)rawChannel;
+
+        try {
+            channel.configureBlocking(false);
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+
+        int interestOps = Nio4r.symbolToInterestOps(runtime, channel, interests);
+        SelectionKey key;
+
+        key = this.cancelledKeys.remove(channel);
+
+        if(key != null) {
+            key.interestOps(interestOps);
+        } else {
+            try {
+                key = channel.register(this.selector, interestOps);
+            } catch(java.lang.IllegalArgumentException ia) {
+                throw runtime.newArgumentError("mode not supported for this object: " + interests);
+            } catch(java.nio.channels.ClosedChannelException cce) {
+                throw context.runtime.newIOError(cce.getLocalizedMessage());
+            }
+        }
+
+        RubyClass monitorClass = runtime.getModule("NIO").getClass("Monitor");
+        Monitor monitor = (Monitor)monitorClass.newInstance(context, io, interests, this, null);
+        monitor.setSelectionKey(key);
+
+        return monitor;
+    }
+
+    @JRubyMethod
+    public IRubyObject deregister(ThreadContext context, IRubyObject io) {
+        Ruby runtime = context.getRuntime();
+        OpenFile file = RubyIO.convertToIO(context, io).getOpenFileInitialized();
+        if (file.fd() == null)
+            return context.nil;
+        Channel rawChannel = file.channel();
+
+        if(!(rawChannel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("not a selectable IO object");
+        }
+
+        SelectableChannel channel = (SelectableChannel)rawChannel;
+        SelectionKey key = channel.keyFor(this.selector);
+
+        if(key == null)
+            return context.nil;
+
+        Monitor monitor = (Monitor)key.attachment();
+        monitor.close(context, runtime.getFalse());
+        cancelledKeys.put(channel, key);
+
+        return monitor;
+    }
+
+    @JRubyMethod(name = "registered?")
+    public IRubyObject isRegistered(ThreadContext context, IRubyObject io) {
+        Ruby runtime = context.getRuntime();
+        Channel rawChannel = RubyIO.convertToIO(context, io).getChannel();
+
+        if(!(rawChannel instanceof SelectableChannel)) {
+            throw runtime.newArgumentError("not a selectable IO object");
+        }
+
+        SelectableChannel channel = (SelectableChannel)rawChannel;
+        SelectionKey key = channel.keyFor(this.selector);
+
+        if(key == null)
+            return context.nil;
+
+
+        if(((Monitor)key.attachment()).isClosed(context) == runtime.getTrue()) {
+            return runtime.getFalse();
+        } else {
+            return runtime.getTrue();
+        }
+    }
+
+    @JRubyMethod
+    public synchronized IRubyObject select(ThreadContext context, Block block) {
+        return select(context, context.nil, block);
+    }
+
+    @JRubyMethod
+    public synchronized IRubyObject select(ThreadContext context, IRubyObject timeout, Block block) {
+        Ruby runtime = context.getRuntime();
+
+        if(!this.selector.isOpen()) {
+            throw context.getRuntime().newIOError("selector is closed");
+        }
+
+        this.wakeupFired = false;
+        int ready = doSelect(runtime, context, timeout);
+
+        /* Timeout */
+        if(ready <= 0 && !this.wakeupFired) {
+            return context.nil;
+        }
+
+        RubyArray<?> array = null;
+
+        if(!block.isGiven()) {
+            array = runtime.newArray(this.selector.selectedKeys().size());
+        }
+
+        Iterator<SelectionKey> selectedKeys = this.selector.selectedKeys().iterator();
+        while(selectedKeys.hasNext()) {
+            SelectionKey key = selectedKeys.next();
+            processKey(key);
+
+            selectedKeys.remove();
+
+            if(block.isGiven()) {
+                block.call(context, (IRubyObject)key.attachment());
+            } else {
+                array.add(key.attachment());
+            }
+        }
+
+        if(block.isGiven()) {
+            return RubyNumeric.int2fix(runtime, ready);
+        } else {
+            return array;
+        }
+    }
+
+    /* Run the selector */
+    private int doSelect(Ruby runtime, ThreadContext context, IRubyObject timeout) {
+        int result;
+
+        cancelKeys();
+        try {
+            context.getThread().beforeBlockingCall(context);
+            if(timeout.isNil()) {
+                result = this.selector.select();
+            } else {
+                double t = RubyNumeric.num2dbl(timeout);
+                if(t == 0) {
+                    result = this.selector.selectNow();
+                } else if(t < 0) {
+                    throw runtime.newArgumentError("time interval must be positive");
+                } else {
+                    long timeoutMilliSeconds = (long)(t * 1000);
+                    if(timeoutMilliSeconds == 0) {
+                      result = this.selector.selectNow();
+                    } else {
+                      result = this.selector.select(timeoutMilliSeconds);
+                    }
+                }
+            }
+            context.getThread().afterBlockingCall();
+            return result;
+        } catch(IOException ie) {
+            throw runtime.newIOError(ie.getLocalizedMessage());
+        }
+    }
+
+    /* Flush our internal buffer of cancelled keys */
+    private void cancelKeys() {
+        Iterator<Map.Entry<SelectableChannel, SelectionKey>> cancelledKeys = this.cancelledKeys.entrySet().iterator();
+        while(cancelledKeys.hasNext()) {
+            Map.Entry<SelectableChannel, SelectionKey> entry = cancelledKeys.next();
+            SelectionKey key = entry.getValue();
+            key.cancel();
+            cancelledKeys.remove();
+        }
+    }
+
+    // Remove connect interest from connected sockets
+    // See: http://stackoverflow.com/questions/204186/java-nio-select-returns-without-selected-keys-why
+    private void processKey(SelectionKey key) {
+        if(key.isValid() && (key.readyOps() & SelectionKey.OP_CONNECT) != 0) {
+            int interestOps = key.interestOps();
+
+            interestOps &= ~SelectionKey.OP_CONNECT;
+            interestOps |=  SelectionKey.OP_WRITE;
+
+            key.interestOps(interestOps);
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject wakeup(ThreadContext context) {
+        if(!this.selector.isOpen()) {
+            throw context.getRuntime().newIOError("selector is closed");
+        }
+
+        this.wakeupFired = true;
+        this.selector.wakeup();
+
+        return context.nil;
+    }
+}