lightio 0.1.0.pre → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64cfa9cd4f221073198b6f2e2beba25830ee2e46
-  data.tar.gz: 53e310d65402475c686b263bec4ed269ce342020
+  metadata.gz: 0b2408fef926bf934a659bdd99bb75218c0bb940
+  data.tar.gz: 21c19305f235b572a8131a8d8059b0038701c79e
 SHA512:
-  metadata.gz: '0199c278d56bfad9eb43e23f4e65eec9bac6a9ac9fbbcd7a85232fd4133e8af0f6a76641a962cc26981c36dcd2de61b61cce98d25e9991e9cab96f224eb83db0'
-  data.tar.gz: 157c3c8a07ee0e6fe2bdc5e3a78a4b6dac6c1c11181db416275d90704b01e9f46e83156923e2badf9c07a92203292c59d5c6626d0770c6dda96f64e2252b9226
+  metadata.gz: 3f11ea750958ac0d3c64c4db0ec97c5e1025ada8d1354f7e858f956b0e8e7aacd64fd0983831c9421039dd70c939bc4df466de24888587527962bf095257eb8c
+  data.tar.gz: 00db900dd4891ab01d6dc971e769d8863e64751e2ccf7a70d936413049316ec956c9ca3c5d3db62a30db87f143f0987d36160c8056f589a5e3e39df3484cba91

data/.travis.yml

@@ -1,5 +1,18 @@
 sudo: false
 language: ruby
 rvm:
+  - jruby-9.1.15.0 # latest stable
+  - 2.2.7
+  - 2.3.4
   - 2.4.1
-before_install: gem install bundler -v 1.16.0
+  - ruby-head
+
+env:
+  global:
+    - JRUBY_OPTS="--dev -J-Djruby.launch.inproc=true -J-Xmx1024M"
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-9.1.15.0
+  fast_finish: true

data/Gemfile.lock

@@ -2,7 +2,7 @@ PATH
   remote: .
   specs:
     lightio (0.1.0.pre)
-      nio4r
+      nio4r (~> 2.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,8 +1,28 @@
-# Lightio
+# LightIO
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/lightio`. To experiment with that code, run `bin/console` for an interactive prompt.
 
-TODO: Delete this and the text above, and describe your gem
+[![Gem Version](https://badge.fury.io/rb/lightio.svg)](http://rubygems.org/gems/lightio)
+[![Build Status](https://travis-ci.org/jjyr/lightio.svg?branch=master)](https://travis-ci.org/jjyr/lightio)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jjyr/lightio/blob/master/LICENSE.txt)
+
+LightIO is a ruby networking library, that combines ruby fiber and IO event loop to provide both simple synchrony library interface and high performance networking IO.
+
+
+LightIO is heavily inspired by [gevent](http://www.gevent.org/).
+
+## Current Status
+
+This library is still **WIP**, *watch* or *star* this repo for further information.
+Its not recommendation to use LightIO in production now, but you can always give a try. open a issue if you have any question.
+
+Before we release a full networking framework at the version 1.0.0, there are three targets(milestones).
+
+1. Provide a bare-bone framework, include fiber based lightweight executor and a way to collebrate with ruby socket library
+2. Provide lightio networking libraries, that have the same API with ruby stdlib
+3. Implement ruby stdlib monkey patch, user can apply monkey patch and just write normal ruby code to get the power of lightio
+
+Thanks to [nio4r](https://github.com/socketry/nio4r), the first target is already achieved.
+
 
 ## Installation
 
@@ -22,7 +42,35 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+``` ruby
+require 'lightio'
+
+start = Time.now
+
+beams = 1000.times.map do
+  # LightIO::Beam is a thread-like executor, use it instead Thread
+  LightIO::Beam.new do
+    # do some io operations in beam
+    LightIO.sleep(1)
+  end
+end
+
+beams.each(&:join)
+seconds = Time.now - start
+puts "1000 beams take #{seconds - 1} seconds to create"
+```
+
+View more [examples](/examples).
+
+## Documentation
+
+See [wiki](https://github.com/jjyr/lightio/wiki) for more information
+
+[API Documentation](http://www.rubydoc.info/gems/lightio/frames)
+
+## Discussion
+
+[Discussion on Gitter](https://gitter.im/lightio-dev/Lobby?utm_source=share-link&utm_medium=link&utm_campaign=share-link)
 
 ## Development
 
@@ -32,7 +80,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/lightio. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/jjyr/lightio. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 

data/examples/beams.rb

@@ -0,0 +1,15 @@
+require 'lightio'
+
+start = Time.now
+
+beams = 1000.times.map do
+  # LightIO::Beam is a thread-like executor, use it instead Thread
+  LightIO::Beam.new do
+    # do some io operations in beam
+    LightIO.sleep(1)
+  end
+end
+
+beams.each(&:join)
+seconds = Time.now - start
+puts "1000 beams take #{seconds - 1} seconds to create"

data/examples/echo_server_with_raw_socket.rb

@@ -0,0 +1,47 @@
+# Example from https://github.com/socketry/nio4r/blob/master/examples/echo_server.rb
+# rewrite it in lightio for demonstrate
+# this example demonstrate how to use ruby 'raw' socket with LightIO
+
+require 'lightio'
+require 'socket'
+
+class EchoServer
+  def initialize(host, port)
+    @server = TCPServer.new(host, port)
+  end
+
+  def run
+    # wait server until readable
+    server_watcher = LightIO::Watchers::IO.new(@server, :r)
+    while server_watcher.wait_read
+      socket = @server.accept
+      _, port, host = socket.peeraddr
+      puts "accept connection from #{host}:#{port}"
+
+      # LightIO::Beam is lightweight executor, provide thread-like interface
+      # just start new beam for per socket
+      LightIO::Beam.new(socket) do |socket|
+        socket_watcher = LightIO::Watchers::IO.new(socket, :r)
+        begin
+          while socket_watcher.wait_read
+            echo(socket)
+          end
+        rescue EOFError
+          _, port, host = socket.peeraddr
+          puts "*** #{host}:#{port} disconnected"
+          # remove close socket watcher
+          socket_watcher.close
+          socket.close
+        end
+      end
+    end
+  end
+
+  def echo(socket)
+    data = socket.read_nonblock(4096)
+    socket.write_nonblock(data)
+  end
+end
+
+
+EchoServer.new('localhost', 3000).run if __FILE__ == $0

data/lib/lightio.rb

@@ -1,10 +1,15 @@
+# LightIO
 require 'lightio/version'
-require 'lightio/beam'
-require 'lightio/future'
-require 'lightio/ioloop'
-require 'lightio/watcher'
-require 'lightio/timer'
-require 'lightio/backend/nio'
+require 'lightio/errors'
+require 'lightio/core'
+require 'lightio/watchers'
+require 'lightio/library'
 
+# LightIO provide light-weight executor: LightIO::Beam and batch io libraries,
+# view LightIO::Core::Beam to learn how to concurrent programming with Beam,
+# view LightIO::Watchers::IO to learn how to manage 'raw' io objects,
+# Core and Library modules are included under LightIO namespace, so you can use LightIO::Beam for convenient
 module LightIO
+  include Core
+  include Library
 end

data/lib/lightio/core.rb

@@ -0,0 +1,11 @@
+# Core
+require 'lightio/core/ioloop'
+require 'lightio/core/light_fiber'
+require 'lightio/core/future'
+require 'lightio/core/beam'
+
+# LightIO::Core include core classes: Beam, IOloop, Future
+#
+# view examples for clues
+module LightIO::Core
+end

data/lib/lightio/{backend → core/backend}/nio.rb

@@ -1,6 +1,7 @@
 # use nio4r implement event loop, inspired from eventmachine/pure_ruby implement
+require 'nio'
 require 'set'
-module LightIO
+module LightIO::Core
   module Backend
 
     class Error < RuntimeError
@@ -46,12 +47,15 @@ module LightIO
       end
     end
 
+    # LightIO use NIO as default event-driving backend
     class NIO
       def initialize
         # @selector = NIO::Selector.new
         @current_loop_time = nil
         @running = false
         @timers = Timers.new
+        @callbacks = []
+        @selector = ::NIO::Selector.new
       end
 
       def run
@@ -60,11 +64,14 @@ module LightIO
         loop do
           @current_loop_time = Time.now
           run_timers
+          run_callbacks
+          handle_selectables
         end
       end
 
-      def run_timers
-        @timers.fire(@current_loop_time)
+
+      def add_callback(&blk)
+        @callbacks << blk
       end
 
       def add_timer(timer)
@@ -75,11 +82,42 @@ module LightIO
         @timers.cancel_timer(timer)
       end
 
+      def add_io_wait(io, interests, &blk)
+        monitor = @selector.register(io, interests)
+        monitor.value = blk
+        monitor
+      end
+
+      def cancel_io_wait(io)
+        @selector.deregister(io)
+      end
+
       def stop
         return unless @running
         @running = false
         raise
       end
+
+      private
+
+      def run_timers
+        @timers.fire(@current_loop_time)
+      end
+
+      def handle_selectables
+        @selector.select(0) do |monitor|
+          # invoke callback if io is ready
+          if monitor.readiness
+            monitor.value.call(monitor.io)
+          end
+        end
+      end
+
+      def run_callbacks
+        while (callback = @callbacks.shift)
+          callback.call
+        end
+      end
     end
   end
 end

data/lib/lightio/core/beam.rb

@@ -0,0 +1,133 @@
+module LightIO::Core
+  # Beam is light-weight executor, provide thread-like interface
+  #
+  # @Example:
+  #   #- initialize with block
+  #   b = Beam.new{puts "hello"}
+  #   b.join
+  #   #output: hello
+  #
+  #   b = Beam.new(1,2,3){|one, two, three| puts [one, two, three].join(",") }
+  #   b.join
+  #   #output: 1,2,3
+  #
+  #   #- use join wait beam done
+  #   b = Beam.new(){LightIO.sleep 3}
+  #   b.join
+  #   b.alive? # false
+  class Beam < LightFiber
+
+    # Create a new beam
+    #
+    # Beam is light-weight executor, provide thread-like interface
+    #
+    # Beam.new("hello"){|hello| puts hello }
+    #
+    # @param [Array]  args pass arguments to Beam block
+    # @param [Proc]  blk block to execute
+    # @return [Beam]
+    def initialize(*args, &blk)
+      raise Error, "must be called with a block" unless blk
+      super() {
+        begin
+          @value = yield(*args)
+        rescue StandardError => e
+          @error = e
+        end
+        # mark as dead
+        dead
+        # transfer back to parent(caller fiber) after schedule
+        parent.transfer
+      }
+      # schedule beam in ioloop
+      ioloop.add_callback {transfer}
+      @alive = true
+    end
+
+    def alive?
+      super && @alive
+    end
+
+    # block and wait beam return a value
+    def value
+      if alive?
+        self.parent = Beam.current
+        ioloop.transfer
+      end
+      check_and_raise_error
+      @value
+    end
+
+    # Block and wait beam dead
+    #
+    # @param [Numeric]  limit wait limit seconds if limit > 0, return nil if beam still alive, else return beam self
+    # @return [Beam, nil]
+    def join(limit=0)
+      # try directly get result
+      if !alive? || limit <= 0
+        # call value to raise error
+        value
+        return self
+      end
+
+      # set a transfer back timer
+      parent = Beam.current
+      timer = LightIO::Watchers::Timer.new(limit)
+      timer.set_callback {parent.transfer}
+      ioloop.add_timer(timer)
+      ioloop.transfer
+
+      if alive?
+        nil
+      else
+        check_and_raise_error
+        self
+      end
+    end
+
+    # Kill beam
+    #
+    # @return [Beam]
+    def kill
+      dead
+      parent.transfer if self == Beam.current
+      self
+    end
+
+    class << self
+
+      # Schedule beams
+      #
+      # normally beam should be auto scheduled, use this method to manually trigger a schedule
+      #
+      # @return [nil]
+      def pass
+        schedule = LightIO::Watchers::Schedule.new
+        IOloop.current.wait(schedule)
+      end
+    end
+
+    private
+
+    # mark beam as dead
+    def dead
+      @alive = false
+    end
+
+    # Beam transfer back to parent after schedule
+    # parent is fiber or beam who called value/join methods
+    # if not present a parent, Beam will transfer to ioloop
+    def parent=(parent)
+      @parent = parent
+    end
+
+    # get parent/ioloop to transfer back
+    def parent
+      @parent || ioloop
+    end
+
+    def check_and_raise_error
+      raise @error if @error
+    end
+  end
+end

data/lib/lightio/core/future.rb

@@ -0,0 +1,48 @@
+module LightIO::Core
+  # Provide a safe way to transfer beam/fiber control flow.
+  #
+  # @Example:
+  #   future = Future.new
+  #   # future#value will block current beam
+  #   Beam.new{future.value}
+  #   # use transfer to set value
+  #   future.transfer(1)
+  class Future
+    def initialize
+      @value = nil
+      @ioloop = IOloop.current
+      @state = :init
+    end
+
+    def done?
+      @state == :done
+    end
+
+    # Transfer and set result value
+    #
+    # use this method to set back result
+    def transfer(value=nil)
+      raise Error, "state error" if done?
+      @value = value
+      done!
+      @light_fiber.transfer if @light_fiber
+    end
+
+    # Get value
+    #
+    # this method will block current beam/fiber, until future result is set.
+    def value
+      return @value if done?
+      raise Error, 'already used' if @light_fiber
+      @light_fiber = LightFiber.current
+      @ioloop.transfer
+      @value
+    end
+
+    private
+
+    def done!
+      @state = :done
+    end
+  end
+end

data/lib/lightio/core/ioloop.rb

@@ -0,0 +1,66 @@
+require 'lightio/core/backend/nio'
+module LightIO::Core
+  # IOloop like a per-threaded EventMachine (cause fiber cannot resume cross threads)
+  #
+  # IOloop handle io waiting and schedule beams, user do not supposed to directly use this class
+  class IOloop
+
+    def initialize
+      @fiber = Fiber.new {run}
+      @backend = Backend::NIO.new
+    end
+
+    # should never invoke explicitly
+    def run
+      # start io loop and never return...
+      @backend.run
+    end
+
+    def add_timer(timer)
+      @backend.add_timer(timer)
+    end
+
+    def add_callback(&blk)
+      @backend.add_callback(&blk)
+    end
+
+    def add_io_wait(io, interests, &blk)
+      @backend.add_io_wait(io, interests, &blk)
+    end
+
+    def cancel_io_wait(io)
+      @backend.cancel_io_wait(io)
+    end
+
+    # Wait a watcher, watcher can be a timer or socket.
+    # see LightIO::Watchers module for detail
+    def wait(watcher)
+      future = Future.new
+      # add watcher to loop
+      id = Object.new
+      watcher.set_callback {future.transfer id}
+      watcher.start(self)
+      # trigger a fiber switch
+      # wait until watcher is ok
+      # then do work
+      if (result = future.value) != id
+        raise InvalidTransferError, "expect #{id}, but get #{result}"
+      end
+    end
+
+    def transfer
+      @fiber.transfer
+    end
+
+    class << self
+      # return current ioloop or create new one
+      def current
+        key = :"lightio.ioloop"
+        unless Thread.current.thread_variable?(key)
+          Thread.current.thread_variable_set(key, IOloop.new)
+        end
+        Thread.current.thread_variable_get(key)
+      end
+    end
+  end
+end

data/lib/lightio/core/light_fiber.rb

@@ -0,0 +1,15 @@
+require 'fiber'
+
+module LightIO::Core
+  # LightFiber is internal represent, we make slight extend on ruby Fiber to bind fibers to IOLoop
+  #
+  # SHOULD NOT BE USED DIRECTLY
+  class LightFiber < Fiber
+    attr_reader :ioloop
+
+    def initialize(ioloop: IOloop.current, &blk)
+      @ioloop = ioloop
+      super(&blk)
+    end
+  end
+end

data/lib/lightio/errors.rb

@@ -0,0 +1,7 @@
+module LightIO
+  class Error < RuntimeError
+  end
+
+  class InvalidTransferError < Error
+  end
+end

data/lib/lightio/library.rb

@@ -0,0 +1,14 @@
+require 'lightio/library/queue'
+require 'lightio/library/kernel_ext'
+require 'lightio/library/timeout'
+
+module LightIO
+  # Library include modules can cooperative with LightIO::Beam
+  module Library
+    # extend library modules
+    def self.included(base)
+      base.extend KernelExt
+      base.extend Timeout
+    end
+  end
+end

data/lib/lightio/library/kernel_ext.rb

@@ -0,0 +1,18 @@
+module LightIO::Library
+  module KernelExt
+    def sleep(*duration)
+      if duration.size > 1
+        raise ArgumentError, "wrong number of arguments (given #{duration.size}, expected 0..1)"
+      elsif duration.size == 0
+        LightIO::IOloop.current.transfer
+      end
+      duration = duration[0]
+      if duration.zero? && LightIO::Beam.current.respond_to?(:pass)
+        LightIO::Beam.current.pass
+        return
+      end
+      timer = LightIO::Watchers::Timer.new duration
+      LightIO::IOloop.current.wait(timer)
+    end
+  end
+end

data/lib/lightio/library/queue.rb

@@ -0,0 +1,100 @@
+module LightIO::Library
+  class Queue
+    def initialize
+      @queue = []
+      @waiters = []
+      @close = false
+    end
+
+    def close()
+      #This is a stub, used for indexing
+      @close = true
+      @waiters.each {|w| w.transfer nil}
+      self
+    end
+
+    # closed?
+    #
+    # Returns +true+ if the queue is closed.
+    def closed?()
+      @close
+    end
+
+    # push(object)
+    # enq(object)
+    # <<(object)
+    #
+    # Pushes the given +object+ to the queue.
+    def push(object)
+      raise ClosedQueueError, "queue closed" if @close
+      if @waiters.any?
+        future = LightIO::Future.new
+        LightIO::IOloop.current.add_callback {
+          @waiters.shift.transfer(object)
+          future.transfer
+        }
+        future.value
+      else
+        @queue << object
+      end
+      self
+    end
+
+    alias enq push
+    alias << push
+    # pop(non_block=false)
+    # deq(non_block=false)
+    # shift(non_block=false)
+    #
+    # Retrieves data from the queue.
+    #
+    # If the queue is empty, the calling thread is suspended until data is pushed
+    # onto the queue. If +non_block+ is true, the thread isn't suspended, and an
+    # exception is raised.
+    def pop(non_block=false)
+      if @close
+        return empty? ? nil : @queue.pop
+      end
+      if empty?
+        if non_block
+          raise ThreadError, 'queue empty'
+        else
+          future = LightIO::Future.new
+          @waiters << future
+          future.value
+        end
+      else
+        @queue.pop
+      end
+    end
+
+    alias deq pop
+    alias shift pop
+    # empty?
+    #
+    # Returns +true+ if the queue is empty.
+    def empty?()
+      @queue.empty?
+    end
+
+    # Removes all objects from the queue.
+    def clear()
+      @queue.clear
+      self
+    end
+
+    # length
+    # size
+    #
+    # Returns the length of the queue.
+    def length()
+      @queue.size
+    end
+
+    alias size length
+    # Returns the number of threads waiting on the queue.
+    def num_waiting()
+      @waiters.size
+    end
+  end
+end

data/lib/lightio/library/timeout.rb

@@ -0,0 +1,18 @@
+require 'timeout'
+module LightIO::Library
+  module Timeout
+    extend self
+    Error = ::Timeout::Error
+
+    def timeout(sec, klass=Error, &blk)
+      return yield(sec) if sec.nil? or sec.zero?
+      beam = LightIO::Beam.new(sec, &blk)
+      message = "execution expired"
+      if beam.join(sec).nil?
+        raise klass, message
+      else
+        beam.value
+      end
+    end
+  end
+end

data/lib/lightio/version.rb

@@ -1,3 +1,3 @@
-module Lightio
-  VERSION = "0.1.0.pre"
+module LightIO
+  VERSION = "0.1.0"
 end

data/lib/lightio/watchers.rb

@@ -0,0 +1,9 @@
+require 'lightio/watchers/watcher'
+require 'lightio/watchers/timer'
+require 'lightio/watchers/schedule'
+require 'lightio/watchers/io'
+
+# Watcher is a abstract struct, for libraries to interact with ioloop
+# see IOloop#wait method
+module LightIO::Watchers
+end

data/lib/lightio/watchers/io.rb

@@ -0,0 +1,110 @@
+module LightIO::Watchers
+  # LightIO::Watchers::IO provide a NIO::Monitor wrap to manage 'raw' socket / io
+  #
+  # @Example:
+  #   #- wait_read for server socket
+  #   io_watcher = LightIO::Watchers::IO.new(server_socket, :r)
+  #   loop do
+  #     io_watcher.wait_read
+  #     client_socket = server_socket.accept
+  #     # do something
+  #   end
+  #   io_watcher.close
+  class IO < Watcher
+    # Create a io watcher
+    # @param [Socket]  io An IO-able object
+    # @param [Symbol]  interests :r, :w, :rw - Is io readable? writeable? or both
+    # @return [LightIO::Watchers::IO]
+    def initialize(io, interests)
+      @io = io
+      @ioloop = LightIO::Core::IOloop.current
+      @waiting = false
+      @wait_for = nil
+      # NIO monitor
+      @monitor = @ioloop.add_io_wait(@io, interests) {callback_on_waiting}
+    end
+
+    def interests
+      @monitor.interests
+    end
+
+    # Replace current interests
+    def interests=(interests)
+      @monitor.interests = interests
+    end
+
+    # Blocking until io interests is satisfied
+    def wait_for(interests)
+      if (self.interests == :w || self.interests == :r) && interests != self.interests
+        raise ArgumentError, "IO interests is #{self.interests}, can't waiting for #{interests}"
+      end
+      @wait_for = interests
+      wait
+    end
+
+    # Blocking until io is readable
+    # @param [Numeric]  timeout return nil after timeout seconds, otherwise return self
+    # @return [LightIO::Watchers::IO, nil]
+    def wait_read(timeout=nil)
+      LightIO::Timeout.timeout(timeout) do
+        wait_for :r
+        self
+      end
+    rescue Timeout::Error
+      nil
+    end
+
+    # Blocking until io is writeable
+    # @param [Numeric]  timeout return nil after timeout seconds, otherwise return self
+    # @return [LightIO::Watchers::IO, nil]
+    def wait_write(timeout=nil)
+      LightIO::Timeout.timeout(timeout) do
+        wait_for :w
+        self
+      end
+    rescue Timeout::Error
+      nil
+    end
+
+
+    def start(ioloop)
+      # do nothing
+    end
+
+    # stop io listening
+    def close
+      @monitor.close
+    end
+
+    def close?
+      @monitor.close?
+    end
+
+    def wait
+      raise LightIO::Error, "Watchers::IO can't cross threads" if @ioloop != LightIO::Core::IOloop.current
+      raise EOFError, "can't wait closed IO watcher" if @monitor.closed?
+      @waiting = true
+      @ioloop.wait(self)
+      @waiting = false
+    end
+
+    def set_callback(&blk)
+      @callback = blk
+    end
+
+    private
+
+    def callback_on_waiting
+      # only call callback on waiting
+      callback.call if @waiting && io_is_ready?
+    end
+
+    def io_is_ready?
+      if @wait_for == :r
+        @monitor.readable?
+      elsif @wait_for == :w
+        @monitor.writeable?
+      end
+    end
+  end
+end

data/lib/lightio/watchers/schedule.rb

@@ -0,0 +1,9 @@
+module LightIO
+  module Watchers
+    class Schedule < Watcher
+      def start(ioloop)
+        ioloop.add_callback(&@callback)
+      end
+    end
+  end
+end

data/lib/lightio/watchers/timer.rb

@@ -0,0 +1,16 @@
+module LightIO
+  module Watchers
+    class Timer < Watcher
+      attr_reader :interval
+      attr_accessor :uuid
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def start(ioloop)
+        ioloop.add_timer(self)
+      end
+    end
+  end
+end

data/lib/lightio/watchers/watcher.rb

@@ -0,0 +1,16 @@
+module LightIO
+  module Watchers
+    class Watcher
+      attr_reader :callback
+
+      def set_callback(&blk)
+        raise Error, "already has callback" if @callback
+        @callback = blk
+      end
+
+      def start(backend)
+        raise
+      end
+    end
+  end
+end

data/lightio.gemspec

@@ -5,12 +5,12 @@ require "lightio/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "lightio"
-  spec.version       = Lightio::VERSION
+  spec.version       = LightIO::VERSION
   spec.authors       = ["jjy"]
   spec.email         = ["jjyruby@gmail.com"]
 
-  spec.summary       = %q{LightIO is a light weight, user-transparent asynchronous IO library}
-  spec.description   = %q{LightIO's goal is provide simple, transparent and efficient IO operation to ruby world}
+  spec.summary       = %q{LightIO is a high performance ruby networking library}
+  spec.description   = %q{LightIO combines ruby fiber and IO event loop to provide both simple synchrony library interface  and high performance networking IO}
   spec.homepage      = "https://github.com/jjyr/lightio"
   spec.license       = "MIT"
 
@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "nio4r"
+  spec.add_runtime_dependency "nio4r", "~> 2.1"
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: lightio
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre
+  version: 0.1.0
 platform: ruby
 authors:
 - jjy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-29 00:00:00.000000000 Z
+date: 2017-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -66,8 +66,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: LightIO's goal is provide simple, transparent and efficient IO operation
-  to ruby world
+description: LightIO combines ruby fiber and IO event loop to provide both simple
+  synchrony library interface  and high performance networking IO
 email:
 - jjyruby@gmail.com
 executables: []
@@ -85,14 +85,26 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/beams.rb
+- examples/echo_server_with_raw_socket.rb
 - lib/lightio.rb
-- lib/lightio/backend/nio.rb
-- lib/lightio/beam.rb
-- lib/lightio/future.rb
-- lib/lightio/ioloop.rb
-- lib/lightio/timer.rb
+- lib/lightio/core.rb
+- lib/lightio/core/backend/nio.rb
+- lib/lightio/core/beam.rb
+- lib/lightio/core/future.rb
+- lib/lightio/core/ioloop.rb
+- lib/lightio/core/light_fiber.rb
+- lib/lightio/errors.rb
+- lib/lightio/library.rb
+- lib/lightio/library/kernel_ext.rb
+- lib/lightio/library/queue.rb
+- lib/lightio/library/timeout.rb
 - lib/lightio/version.rb
-- lib/lightio/watcher.rb
+- lib/lightio/watchers.rb
+- lib/lightio/watchers/io.rb
+- lib/lightio/watchers/schedule.rb
+- lib/lightio/watchers/timer.rb
+- lib/lightio/watchers/watcher.rb
 - lightio.gemspec
 homepage: https://github.com/jjyr/lightio
 licenses:
@@ -109,13 +121,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
-summary: LightIO is a light weight, user-transparent asynchronous IO library
+summary: LightIO is a high performance ruby networking library
 test_files: []

data/lib/lightio/beam.rb

@@ -1,12 +0,0 @@
-require 'fiber'
-
-# Beam, a minimal executor unit, like thread but lightweight
-# must have a ioloop
-module LightIO
-  class Beam < Fiber
-    def initialize ioloop:, &blk
-      @ioloop = ioloop
-      super(&blk)
-    end
-  end
-end

data/lib/lightio/future.rb

@@ -1,35 +0,0 @@
-# Future, provide another way to operate Beam and Ioloop
-
-module LightIO
-  class Future
-    def initialize
-      @value = nil
-      @ioloop = IOloop.current
-      @state = :init
-    end
-
-    def done?
-      @state == :done
-    end
-
-    def done!
-      @state = :done
-    end
-
-    # transfer and set value
-    def transfer(value=nil)
-      raise Error, "state error" if done?
-      @value = value
-      done!
-      @beam.transfer if @beam
-    end
-
-    # block current beam/fiber and get value
-    def value
-      return @value if done?
-      @beam = Beam.current
-      @ioloop.transfer
-      @value
-    end
-  end
-end

data/lib/lightio/ioloop.rb

@@ -1,40 +0,0 @@
-# IOloop like a per-threaded Eventmachine (cause fiber cannot resume cross threads)
-# join, 等待 IOloop 结束
-# 在 loop 中为 waiter (future-like proxy object) 对象返回结果
-module LightIO
-  class IOloop
-    def initialize
-      @fiber = Fiber.new {run}
-      @backend = Backend::NIO.new
-    end
-
-    # should never invoke explicitly
-    def run
-      # start io loop and never return...
-      @backend.run
-    end
-
-    # wait a watcher, maybe a timer or socket
-    def wait(watcher)
-      future = Future.new
-      # add watcher to loop
-      watcher.set_callback {future.transfer}
-      watcher.register(@backend)
-      # trigger a fiber switch
-      # wait until watcher is ok
-      # then do work
-      future.value
-    end
-
-    def transfer
-      @fiber.transfer
-    end
-
-    class << self
-      # return current ioloop or create new one
-      def current
-        Thread.current[:"lightio.ioloop"] ||= IOloop.new
-      end
-    end
-  end
-end

data/lib/lightio/timer.rb

@@ -1,15 +0,0 @@
-module LightIO
-  class Timer < Watcher
-    attr_reader :interval
-    attr_accessor :uuid
-
-    def initialize(interval, &blk)
-      @interval = interval
-      @callback = blk
-    end
-
-    def register(backend)
-      backend.add_timer(self)
-    end
-  end
-end

data/lib/lightio/watcher.rb

@@ -1,14 +0,0 @@
-module LightIO
-  class Watcher
-    attr_reader :callback
-
-    def set_callback(&blk)
-      raise Error, "already has callback" if @callback
-      @callback = blk
-    end
-
-    def register(backend)
-      raise
-    end
-  end
-end