nio4r 1.2.1 → 2.0.0.pre

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

@@ -0,0 +1,311 @@
+package org.nio4r;
+
+import org.jruby.*;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.nio.channels.FileChannel;
+import java.util.ArrayList;
+
+/*
+created by Upekshej
+ */
+public class ByteBuffer extends RubyObject {
+
+    private java.nio.ByteBuffer byteBuffer;
+    private String currentWritePath = "";
+    private String currentReadPath = "";
+
+    private FileChannel currentWriteFileChannel;
+    private FileOutputStream fileOutputStream;
+
+    private FileInputStream currentReadChannel;
+    private FileChannel inChannel;
+
+    public ByteBuffer(final Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    @JRubyMethod
+    public IRubyObject initialize(ThreadContext context, IRubyObject value, IRubyObject offset, IRubyObject length) {
+        Ruby ruby = context.getRuntime();
+
+        if (value == ruby.getNil()) {
+            throw ruby.newTypeError("expected String or Integer for value, got NilClass");
+        }
+
+        if (value instanceof RubyString) {
+            if (offset != ruby.getNil() && length != ruby.getNil()) {
+                int arrayOffset = RubyNumeric.num2int(offset);
+                int arrayLimit = RubyNumeric.num2int(length);
+                byteBuffer = java.nio.ByteBuffer.wrap(value.asJavaString().getBytes(), arrayOffset, arrayLimit);
+            } else {
+                byteBuffer = java.nio.ByteBuffer.wrap(value.asJavaString().getBytes());
+            }
+        } else if (value instanceof RubyInteger) {
+            int allocationSize = RubyNumeric.num2int(value);
+            byteBuffer = java.nio.ByteBuffer.allocate(allocationSize);
+        } else {
+            throw ruby.newTypeError("expected String or Integer for value");
+        }
+
+        return this;
+    }
+
+    /**
+     * Currently assuming only strings will come..
+     *
+     * @param context
+     * @return
+     */
+    @JRubyMethod(name = "<<")
+    public IRubyObject put(ThreadContext context, IRubyObject str) {
+        String string = str.asJavaString();
+
+        if (byteBuffer == null) {
+            byteBuffer = java.nio.ByteBuffer.wrap(string.getBytes());
+        }
+
+        byteBuffer.put(string.getBytes());
+        return this;
+    }
+
+    //https://www.ruby-forum.com/topic/3731325
+    @JRubyMethod(name = "get")
+    public IRubyObject get(ThreadContext context) {
+        ArrayList<Byte> temp = new ArrayList<Byte>();
+
+        while (byteBuffer.hasRemaining()) {
+            temp.add(byteBuffer.get());
+        }
+
+        return JavaUtil.convertJavaToRuby(context.getRuntime(), new String(toPrimitives(temp)));
+    }
+
+    @JRubyMethod(name = "read_next")
+    public IRubyObject readNext(ThreadContext context, IRubyObject count) {
+        int c = RubyNumeric.num2int(count);
+
+        if (c < 1) {
+            throw new IllegalArgumentException();
+        }
+
+        if (c <= byteBuffer.remaining()) {
+            org.jruby.util.ByteList temp = new org.jruby.util.ByteList(c);
+
+            while (c > 0) {
+                temp.append(byteBuffer.get());
+                c = c - 1;
+            }
+
+            return context.runtime.newString(temp);
+        }
+
+        return RubyString.newEmptyString(context.runtime);
+    }
+
+    private byte[] toPrimitives(ArrayList<Byte> oBytes) {
+        byte[] bytes = new byte[oBytes.size()];
+
+        for (int i = 0; i < oBytes.size(); i++) {
+            bytes[i] = (oBytes.get(i) == null) ? " ".getBytes()[0] : oBytes.get(i);
+        }
+
+        return bytes;
+    }
+
+    @JRubyMethod(name = "write_to")
+    public IRubyObject writeTo(ThreadContext context, IRubyObject f) {
+        try {
+            File file = (File) JavaUtil.unwrapJavaObject(f);
+
+            if (!isTheSameFile(file, false)) {
+                currentWritePath = file.getAbsolutePath();
+                if (currentWriteFileChannel != null) currentWriteFileChannel.close();
+                if (fileOutputStream != null) fileOutputStream.close();
+
+                fileOutputStream = new FileOutputStream(file, true);
+                currentWriteFileChannel = fileOutputStream.getChannel();
+            }
+
+            currentWriteFileChannel.write(byteBuffer);
+        } catch (Exception e) {
+            throw new IllegalArgumentException("write error: " + e.getLocalizedMessage());
+        }
+
+        return this;
+    }
+
+    @JRubyMethod(name = "read_from")
+    public IRubyObject readFrom(ThreadContext context, IRubyObject f) {
+        try {
+            File file = (File) JavaUtil.unwrapJavaObject(f);
+
+            if (!isTheSameFile(file, true)) {
+                inChannel.close();
+                currentReadChannel.close();
+                currentReadPath = file.getAbsolutePath();
+                currentReadChannel = new FileInputStream(file);
+                inChannel = currentReadChannel.getChannel();
+            }
+
+            inChannel.read(byteBuffer);
+        } catch (Exception e) {
+            throw new IllegalArgumentException("read error: " + e.getLocalizedMessage());
+        }
+
+        return this;
+    }
+
+    private boolean isTheSameFile(File f, boolean read) {
+        if (read) {
+            return (currentReadPath == f.getAbsolutePath());
+        }
+
+        return currentWritePath == f.getAbsolutePath();
+    }
+
+    @JRubyMethod(name = "remaining")
+    public IRubyObject remainingPositions(ThreadContext context) {
+        int count = byteBuffer.remaining();
+        return context.getRuntime().newFixnum(count);
+    }
+
+    @JRubyMethod(name = "remaining?")
+    public IRubyObject hasRemaining(ThreadContext context) {
+        if (byteBuffer.hasRemaining()) {
+            return context.getRuntime().getTrue();
+        }
+
+        return context.getRuntime().getFalse();
+    }
+
+    @JRubyMethod(name = "offset?")
+    public IRubyObject getOffset(ThreadContext context) {
+        int offset = byteBuffer.arrayOffset();
+        return context.getRuntime().newFixnum(offset);
+    }
+
+    /**
+     * Check whether the two ByteBuffers are the same.
+     *
+     * @param context
+     * @param ob      : The RubyObject which needs to be check
+     * @return
+     */
+    @JRubyMethod(name = "equals?")
+    public IRubyObject equals(ThreadContext context, IRubyObject obj) {
+        Object o = JavaUtil.convertRubyToJava(obj);
+
+        if(!(o instanceof ByteBuffer)) {
+            return context.getRuntime().getFalse();
+        }
+
+        if(this.byteBuffer.equals(((ByteBuffer)o).getBuffer())) {
+            return context.getRuntime().getTrue();
+        } else {
+            return context.getRuntime().getFalse();
+        }
+    }
+
+    /**
+     * Flip capability provided by the java nio.ByteBuffer
+     * buf.put(magic);    // Prepend header
+     * in.read(buf);      // Read data into rest of buffer
+     * buf.flip();        // Flip buffer
+     * out.write(buf);    // Write header + data to channel
+     *
+     * @param context
+     * @return
+     */
+    @JRubyMethod
+    public IRubyObject flip(ThreadContext context) {
+        byteBuffer.flip();
+        return this;
+    }
+
+    /**
+     * Rewinds the buffer. Usage in java is like
+     * out.write(buf);    // Write remaining data
+     * buf.rewind();      // Rewind buffer
+     * buf.get(array);    // Copy data into array
+     *
+     * @param context
+     * @return
+     */
+    @JRubyMethod
+    public IRubyObject rewind(ThreadContext context) {
+        byteBuffer.rewind();
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject reset(ThreadContext context) {
+        byteBuffer.reset();
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject mark(ThreadContext context) {
+        byteBuffer.mark();
+        return this;
+    }
+
+    /**
+     * Removes all the content in the byteBuffer
+     *
+     * @param context
+     * @return
+     */
+    @JRubyMethod
+    public IRubyObject clear(ThreadContext context) {
+        byteBuffer.clear();
+        return this;
+    }
+
+    @JRubyMethod
+    public IRubyObject compact(ThreadContext context) {
+        byteBuffer.compact();
+        return this;
+    }
+
+    @JRubyMethod(name = "capacity")
+    public IRubyObject capacity(ThreadContext context) {
+        int cap = byteBuffer.capacity();
+        return context.getRuntime().newFixnum(cap);
+    }
+
+    @JRubyMethod
+    public IRubyObject position(ThreadContext context, IRubyObject newPosition) {
+        int position = RubyNumeric.num2int(newPosition);
+        byteBuffer.position(position);
+        return this;
+    }
+
+    @JRubyMethod(name = "limit")
+    public IRubyObject limit(ThreadContext context, IRubyObject newLimit) {
+        int limit = RubyNumeric.num2int(newLimit);
+        byteBuffer.limit(limit);
+        return this;
+    }
+
+    @JRubyMethod(name = "limit?")
+    public IRubyObject limit(ThreadContext context) {
+        int lmt = byteBuffer.limit();
+        return context.getRuntime().newFixnum(lmt);
+    }
+
+    @JRubyMethod(name = "to_s")
+    public IRubyObject to_String(ThreadContext context) {
+        return JavaUtil.convertJavaToRuby(context.getRuntime(), byteBuffer.toString());
+    }
+
+    public java.nio.ByteBuffer getBuffer() {
+        return byteBuffer;
+    }
+}

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

@@ -21,6 +21,7 @@ import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.load.Library;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.Block;
+import org.nio4r.ByteBuffer;
 
 public class Nio4r implements Library {
     private Ruby ruby;
@@ -45,6 +46,14 @@ public class Nio4r implements Library {
         }, 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);
     }
 
     public static int symbolToInterestOps(Ruby ruby, SelectableChannel channel, IRubyObject interest) {

data/ext/nio4r/selector.c

@@ -93,7 +93,9 @@ static VALUE NIO_Selector_allocate(VALUE klass)
         rb_sys_fail("pipe");
     }
 
-    if(fcntl(fds[0], F_SETFL, O_NONBLOCK) < 0) {
+    /* Use non-blocking reads/writes during wakeup, in case the buffer is full */
+    if(fcntl(fds[0], F_SETFL, O_NONBLOCK) < 0 ||
+       fcntl(fds[1], F_SETFL, O_NONBLOCK) < 0) {
         rb_sys_fail("fcntl");
     }
 

data/lib/nio/bytebuffer.rb

@@ -0,0 +1,175 @@
+module NIO
+  # rubocop:disable ClassLength
+  class ByteBuffer
+    def initialize(value, offset = nil, length = nil)
+      # value can be either STRING or INTEGER
+      fail "not a valid input" if value.nil?
+      @position = 0
+      @mark = -1
+      if value.is_a? Integer
+        @size = value
+        @byte_array = Array.new(value)
+      elsif value.is_a? String
+        @byte_array = str.bytes
+        @size = @byte_array.size
+      end
+      @limit = @size - 1
+      unless offset.nil?
+        @offset = offset
+        @position = offset
+        unless length.nil?
+          fail "Invalid Arguiments Exception" if offset + length >= value
+          @limit = offset + length
+        end
+      end
+    end
+
+    # put the provided string to the buffer
+    def <<(str)
+      temp_buffer = str.bytes
+      temp_buffer.each { |x| put_byte x }
+    end
+
+    # return the remaining number positions to read/ write
+    def remaining
+      @limit + 1 - @position
+    end
+
+    # has any space remaining
+    def remaining?
+      remaining > 0
+    end
+
+    # this method is private
+    def put_byte(byte)
+      fail "Buffer Overflowed" if @position == @size
+      @byte_array[@position] = byte
+      @position += 1
+    end
+
+    # write content in the buffer to file
+    # call flip before calling this
+    # after write operation to the
+    # buffer
+    def write_to(file)
+      @file_to_write = file unless @file_to_write.eql? file
+      file.write get if remaining?
+    end
+
+    # Fill the byteBuffer with content of the file
+    def read_from(file)
+      @file_to_read = file unless @file_to_read.eql? file
+      while (s = file.read(1)) && remaining?
+        put_byte(s)
+      end
+    end
+
+    # flip from write to read mode
+    def flip
+      # need to avoid @position being negative
+      @limit = [@position - 1, 0].max
+      @position = 0
+      @mark = -1
+    end
+
+    # rewind read mode to write mode. limit stays unchanged
+    def rewind
+      @position = 0
+      @mark = -1
+    end
+
+    # reset the position to the previously marked position
+    def reset
+      fail "Invalid Mark Exception" if @mark < 0
+      @position = @mark
+      self
+    end
+
+    # mark the current position in order to reset later
+    def mark
+      @mark = @position
+    end
+
+    # the current values are considered junk
+    def clear
+      @position = 0
+      @limit = @size - 1
+      @mark = -1
+      self
+    end
+
+    def compact
+      # compact should be allowed only if there are content remaining in the buffer
+      return self unless remaining?
+      temp = @byte_array.slice(@position, @limit)
+      # if 1 remaining the replaced range should be @byte_array[0..0]
+      @byte_array[0..remaining - 1] = temp
+      @position = remaining
+      @limit = @size - 1
+      self
+    end
+
+    # get the content of the byteBuffer. need to call rewind before calling get.
+    # return as a String
+    def get
+      return "" if @limit == 0
+      temp = @byte_array[@position..@limit].pack("c*")
+      # next position to be read. it should be always less than or equal to size-1
+      @position = [@limit + 1, @size].min
+      temp
+    end
+
+    def read_next(count)
+      fail "Illegal Argument" unless count > 0
+      fail "Less number of elements remaining" if count > remaining
+      temp = @byte_array[@position..@position + count - 1].pack("c*")
+      @position += count
+      temp
+    end
+
+    # return the offset of the buffer
+    def offset?
+      @offset
+    end
+
+    # check whether the obj is the same bytebuffer as this bytebuffer
+    def equals?(obj)
+      self == obj
+    end
+
+    # returns the capacity of the buffer. This value is fixed to the initial size
+    def capacity
+      @size
+    end
+
+    # Set the position to a different position
+    def position(new_position)
+      fail "Illegal Argument Exception" unless new_position <= @limit && new_position >= 0
+      @position = new_position
+      @mark = -1 if @mark > @position
+    end
+
+    def limit(new_limit)
+      fail "Illegal Argument Exception" if new_limit > @size || new_limit < 0
+      @limit = new_limit
+      @position = @limit if @position > @limit
+      @mark = -1 if @mark > @limit
+    end
+
+    def limit?
+      @limit
+    end
+
+    def to_s
+      # convert String in byte form to the visible string
+      temp = "ByteBuffer "
+      temp += "[pos=" + @position.to_s
+      temp += " lim =" + @limit.to_s
+      temp += " cap=" + @size.to_s
+      temp += "]"
+      temp
+    end
+
+    private :put_byte
+  end
+end

data/lib/nio/selector.rb

@@ -48,6 +48,8 @@ module NIO
 
     # Select which monitors are ready
     def select(timeout = nil)
+      selected_monitors = Set.new
+
       @lock.synchronize do
         readers = [@wakeup]
         writers = []
@@ -61,8 +63,6 @@ module NIO
         ready_readers, ready_writers = Kernel.select readers, writers, [], timeout
         return unless ready_readers # timeout or wakeup
 
-        selected_monitors = Set.new
-
         ready_readers.each do |io|
           if io == @wakeup
             # Clear all wakeup signals we've received by reading them
@@ -81,15 +81,15 @@ module NIO
           monitor.readiness = (monitor.readiness == :r) ? :rw : :w
           selected_monitors << monitor
         end
+      end
 
-        if block_given?
-          selected_monitors.each do |m|
-            yield m
-          end
-          selected_monitors.size
-        else
-          selected_monitors
+      if block_given?
+        selected_monitors.each do |m|
+          yield m
         end
+        selected_monitors.size
+      else
+        selected_monitors
       end
     end
 
@@ -101,7 +101,16 @@ module NIO
     # level-triggered behavior.
     def wakeup
       # Send the selector a signal in the form of writing data to a pipe
-      @waker.write "\0"
+      begin
+        @waker.write_nonblock "\0"
+      rescue IO::WaitWritable
+        # This indicates the wakeup pipe is full, which means the other thread
+        # has already received many wakeup calls, but not processed them yet.
+        # The other thread will completely drain this pipe when it wakes up,
+        # so it's ok to ignore this exception if it occurs: we know the other
+        # thread has already been signaled to wake up
+      end
+
       nil
     end
 

data/lib/nio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NIO
-  VERSION = "1.2.1".freeze
+  VERSION = "2.0.0.pre".freeze
 end

data/lib/nio.rb

@@ -18,6 +18,7 @@ end
 if ENV["NIO4R_PURE"] == "true" || (Gem.win_platform? && !defined?(JRUBY_VERSION))
   require "nio/monitor"
   require "nio/selector"
+  require "nio/bytebuffer"
   NIO::ENGINE = "ruby".freeze
 else
   require "nio4r_ext"

data/spec/nio/bytebuffer_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+RSpec.describe NIO::ByteBuffer do
+  describe "#Behaviour of ByteBuffer" do
+    subject { bytebuffer }
+
+    context "allocates a given size buffer" do
+      let(:bytebuffer) { NIO::ByteBuffer.new(256, nil, nil) }
+
+      before :each do
+        bytebuffer.clear
+      end
+
+      it "Checks the allocation" do
+        expect(bytebuffer.capacity).to eql(256)
+      end
+
+      it "checks remaining" do
+        expect(bytebuffer.remaining).to eql(256)
+      end
+
+      it "puts a given string to buffer" do
+        bytebuffer << "Song of Ice & Fire"
+        expect(bytebuffer.remaining).to eql(238)
+      end
+
+      it "reads the content added" do
+        bytebuffer << "Test"
+        bytebuffer << "Text"
+        bytebuffer << "Dumb"
+        bytebuffer.flip
+        expect(bytebuffer.read_next(5)).to eql "TestT"
+      end
+
+      it "rewinds the buffer" do
+      end
+
+      it "compacts the buffer" do
+        bytebuffer << "Test"
+        bytebuffer << " Text"
+        bytebuffer << "Dumb"
+        bytebuffer.flip
+        bytebuffer.read_next 5
+        bytebuffer.compact
+        bytebuffer << " RRMARTIN"
+        bytebuffer.flip
+        # expect(bytebuffer.limit?).to eql(10)
+        expect(bytebuffer.get).to eql("TextDumb RRMARTIN")
+      end
+
+      it "flips the bytebuffer" do
+        bytebuffer << "Test"
+        bytebuffer.flip
+        expect(bytebuffer.get).to eql("Test")
+      end
+
+      it "reads the next items" do
+        bytebuffer << "John Snow"
+        bytebuffer.flip
+        bytebuffer.read_next 5
+        expect(bytebuffer.read_next(4)).to eql("Snow")
+      end
+
+      it "clears the buffer" do
+        bytebuffer << "Game of Thrones"
+        bytebuffer.clear
+        expect(bytebuffer.remaining).to eql(256)
+      end
+
+      it "gets the content of the bytebuffer" do
+        bytebuffer << "Test"
+        bytebuffer.flip
+        expect(bytebuffer.get).to eql("Test")
+      end
+    end
+  end
+end