fibril 0.0.1 → 0.0.5

data/lib/fibril/extras.rb

@@ -0,0 +1,8 @@
+require 'fibril/control'
+require 'fibril/basic_object'
+require 'fibril/async_proxy'
+require 'fibril/fasync_proxy'
+require 'fibril/fibril_proxy'
+require 'fibril/ffuture'
+require 'fibril/non_blocking_io_wrapper'
+require 'fibril/forked_non_blocking_io_wrapper'

data/lib/fibril/fasync_proxy.rb

@@ -0,0 +1,36 @@
+require 'yaml'
+
+class Fibril::FAsyncProxy
+  attr_accessor :target
+
+  def initialize(target)
+    self.target = target
+  end
+
+  ##
+  # Execute target method within a new fork. Enqueue the current fibril
+  # to be resumed as soon as async task is finished.
+  # The result of the forked process is passed to the parent by Marshaling.
+  ##
+  def method_missing(name, *_args, &_block)
+    define_singleton_method(name){|*args, &block|
+      read, write = IO.pipe
+      waiting = Fibril.current
+      pid = fork do
+        result = target.send(name, *args, &block)
+        read.close
+        YAML.dump(result, write)
+      end
+      write.close
+      result = nil
+      Thread.new{
+        result = read.read
+        Process.wait(pid)
+        Fibril.enqueue waiting
+      }
+      Fibril.current.yield
+      YAML.load(result)
+    }
+    send(name, *_args, &_block)
+  end
+end

data/lib/fibril/ffuture.rb

@@ -0,0 +1,24 @@
+require_relative 'future'
+
+class Fibril::FFuture < Fibril::Future
+
+  ##
+  # A Forked future. Fulfils the same future api as Fibril::Future
+  # but runs the block inside a new fork instead of a new thread..
+  ##
+  def initialize(&blk)
+    read, write = IO.pipe
+    pid = fork do
+      result = blk[]
+      read.close
+      Marshal.dump(result, write)
+    end
+    write.close
+    result = nil
+    self.future_thread = Thread.new do
+      result = read.read
+      Process.wait(pid)
+      Marshal.load(result)
+    end
+  end
+end

data/lib/fibril/fibril_proxy.rb

@@ -0,0 +1,31 @@
+class Fibril::FibrilProxy
+  attr_accessor :target, :guard_names
+
+  ENUM_METHODS = %w(map each each_with_index with_index with_object detect select each_slice each_cons each_entry reverse_each)
+
+  def initialize(target, *guard_names)
+    self.target = target
+    self.guard_names = guard_names
+  end
+
+  ##
+  # Execute target method within a new fibril
+  ##
+  def method_missing(name, *args, &block)
+
+    context = target
+
+    return context.send(name).fibril(*self.guard_names) do |*elms, &blk|
+      block[*elms, &blk]
+    end if ENUM_METHODS.include?(name.to_s)
+
+
+    fibril{
+      context.send(name, *args, &block)
+    }.tap do |guard|
+      guard_names.each do |guard_name|
+        Fibril.guard.send("#{guard_name}=", guard)
+      end
+    end
+  end
+end

data/lib/fibril/forked_non_blocking_io_wrapper.rb

@@ -0,0 +1,51 @@
+require_relative 'non_blocking_io_wrapper'
+
+class Fibril::ForkedNonBlockingIOWrapper < Fibril::NonBlockingIOWrapper
+  attr_accessor :read, :write
+  require 'uri'
+
+  def initialize(*, &block)
+    read, write = IO.pipe
+    self.read, self.write = read, write
+    self.response_queue = []
+    self.fibrils = []
+    define_singleton_method(:loop, &block)
+  end
+
+  def start
+    freceive = method(:freceive)
+    block = method(:loop)
+    read, write = self.read, self.write
+    fibril{
+      fork do
+        read.close
+        block[]
+        exit(0)
+      end
+
+      write.close
+      begin
+        Fibril.current.tick
+        while message = read.gets
+          freceive[*Marshal.load(URI.unescape(message))]
+          Fibril.current.tick
+        end
+      rescue Exception => e
+        puts "Exception! : #{e}"
+        puts e.backtrace
+      end
+    }
+  end
+
+  def receive(*args)
+    self.write.puts URI.escape(Marshal.dump(args)) rescue nil
+  end
+
+  def freceive(*args)
+    if args.any?
+      ingest(*args)
+    else
+      method(:ingest)
+    end
+  end
+end

data/lib/fibril/future.rb

@@ -0,0 +1,24 @@
+class Fibril::Future
+  attr_accessor :future_thread
+
+  ##
+  # A future. A very thin wrapper around a thread.
+  # Can be used within `await` and `await_all` within a fibril
+  ##
+
+  def initialize(&blk)
+    self.future_thread = Thread.new(&blk)
+  end
+
+  def await
+    self.future_thread.join.value
+  end
+
+  def alive?
+    self.future_thread.alive?
+  end
+
+  def close
+    self.future_thread.kill
+  end
+end

data/lib/fibril/guard.rb

@@ -0,0 +1,123 @@
+class Fibril::Guard
+  class << self
+    attr_accessor :guard_seq
+  end
+
+  attr_accessor :fibril, :id, :break_condition, :depleted, :timeout_period, :result, :depleted_at
+
+  class NoResult;end
+
+  self.guard_seq = 0
+
+  ##
+  # Create a new guard for a given fibril and add a reference to it to this same fibril.
+  ##
+  def self.create(fibril, counter=1)
+    self.guard_seq += 1
+    guard = Fibril::Guard.new(self.guard_seq, counter, fibril)
+    fibril.guards << guard
+    return guard
+  end
+
+  def result?
+    self.result != NoResult
+  end
+
+  def depleted?
+    depleted
+  end
+  ##
+  # Continue to process fibrils until this guard is depleted.
+  ##
+  def await
+    Fibril.current.tick while !self.depleted
+  end
+
+  ##
+  # Schedule this guard to deplete the next time it is visited
+  ##
+  def cancel
+    self.break_condition = 1
+  end
+
+  ##
+  # Create a new guard object. A guard can have a break condition which is either
+  # A. A counter, guard will deplete when it has been visited this many times
+  # B. A break condition, guard will deplete when this proc/lambda returns true
+  ##
+  def initialize(id, counter, fibril)
+    self.id = id
+    self.fibril =  fibril
+    self.break_condition = counter
+    self.result = NoResult
+  end
+
+  ##
+  # Visit this guard. This is called everytime the fibril associated with this guard
+  # completes. If the guard does not deplete the fibril resets and runs again
+  ##
+  def visit(result=nil)
+    case self.break_condition
+    when Proc
+      if self.break_condition[]
+        self.deplete(result)
+      else
+        self.fibril    = self.fibril.reset(self)
+      end
+    else
+      self.break_condition -= 1
+      if self.break_condition.zero?
+        self.deplete(result)
+      else
+        unless timeout_period.zero?
+          if timeout_period > 0.1
+            async.sleep(timeout_period)
+          else
+            sleep(timeout_period)
+          end
+        end
+        self.fibril = self.fibril.reset(self)
+      end
+    end
+  end
+
+  ##
+  # Deplete the guard. The guard has served its purpose
+  ##
+  def deplete(result)
+    self.result = result
+    self.depleted = true
+    self.depleted_at = Time.now
+    Fibril.deplete_guard(self, result)
+  end
+
+  ##
+  # Loop the fibril associated with a guard either a set number of times
+  # or until a block evaluates to true
+  ##
+  def loop(break_condition=-1, timeout=0, &blck)
+    self.break_condition = block_given? ? blck : break_condition
+    self.timeout_period = timeout
+    self
+  end
+
+  ##
+  # The inverse of loop. Loop until a block evalutes to true
+  ##
+  def while(&blk)
+    loop{ !blk[] }
+  end
+
+  ##
+  # Equivalent of loop
+  ##
+  def until(*guards, &blk)
+    if block_given?
+      loop{ blk[] }
+    else
+      loop{
+        guards.map{|guard| guard.kind_of?(Symbol) ? Fibril.guard.send(guard) : guard}.all?(&:depleted?)
+      }
+    end
+  end
+end

data/lib/fibril/loop.rb

@@ -1,11 +1,41 @@
+##
+# The Fibril event loop.
+# Requiring this file will execute all code between the require statement and EOF inside a fibril before exiting.
+#
+#  Ideal for scripts that need to use cooperative multitasking without having to wrap in an extra fibril simply to
+# start the loop
+#
+#
+# Note using fibril/loop is equivalent to wrapping the entire script in a Fibril do ... end.
+# E.g
+#
+#
+# require 'fibril/loop'
+# puts "in a fibril"
+#
+#
+#
+# is equivalent to:
+#
+#
+#
+# require 'fibril'
+#
+# Fibril do
+#   puts "In a fibril"
+# end
+#
+#
+#
+##
 require_relative '../fibril'
 require 'pry'
 
 call_stack = caller
-lines = IO.read(call_stack[0][/.*?(?=\:)/,0]).split("\n")
+filename   = call_stack[0][/(.*?(?=\:)):(\d+)/,1]
+linenumber = call_stack[0][/(.*?(?=\:)):(\d+)/,2].to_i
+lines = IO.read(filename).split("\n")[linenumber..-1]
 
-if %r{require.*".*?fibril/loop"} =~ lines[0].gsub("'",?").gsub(/\s+/,' ').strip
-  $LOAD_PATH << '.'
-  fibril{ eval lines[1..-1].join("\n") }
-  exit(0)
-end
+$LOAD_PATH << '.'
+fibril{ eval lines.join("\n") }
+exit(0)

data/lib/fibril/non_blocking_io_wrapper.rb

@@ -0,0 +1,60 @@
+class Fibril::NonBlockingIOWrapper
+  ##
+  # A Non block IO wrapper allows you to execute a blocking IO loop inside a separate thread
+  # and receive all inputs inside one or more Fibrils.
+  #
+  # This allows you to have multiple block IO loops operating in parallel whilst still processing all
+  # resulting messages in the main thread.
+  ##
+  attr_accessor :guard, :response_queue, :fibrils, :result
+
+  def initialize(*, &block)
+    self.response_queue = []
+    self.fibrils = []
+    define_singleton_method(:loop, &block)
+    future{
+      begin
+        loop()
+      rescue Exception => e
+        puts "Exception occurred in thead #{Thread.current} : #{e.message}"
+        puts e.backtrace
+      end
+    }
+  end
+
+  ##
+  # Receive a message from the async IO loop if a message is sent, otherwise return a reference to the ingest method
+  ##
+  def receive(*args)
+    if args.any?
+      ingest(*args)
+    else
+      method(:ingest)
+    end
+  end
+
+  ##
+  # Add the ingested message to the response queue and schedule all fibrils
+  # waiting on events to receive messages
+  ##
+  def ingest(*args)
+    begin
+      self.response_queue << args
+      self.fibrils.shift.enqueue while self.fibrils.any?
+    rescue Exception => e
+      puts "Exception occurred when ingesting from #{self} : #{e.message}"
+      puts e.backtrace
+    end
+  end
+
+  def await
+    ##
+    # Set all fibrils into waiting state until there is something in the response queue
+    ##
+    Fibril.current.yield{|f| self.fibrils << f} until self.response_queue.any?
+    ##
+    # Return values from the response queue
+    ##
+    self.response_queue.shift
+  end
+end

data/lib/fibril/tick_proxy.rb

@@ -0,0 +1,30 @@
+class Fibril::TickProxy
+  attr_accessor :target, :tick_before, :tick_after, :guard_names
+
+  def initialize(target, *guard_names, tick_before: true, tick_after: false)
+    self.target = target
+    self.guard_names = guard_names
+    self.tick_before, self.tick_after = tick_before, tick_after
+  end
+
+  ##
+  # Execute target method within a new fibril
+  ##
+  def method_missing(name, *args, &block)
+    context = target
+    decorated = ->(*args){
+      Fibril.current.tick if tick_before
+      result = block[*args]
+      Fibril.current.tick if tick_after
+      result
+    }
+    fibril{
+      context.send(name, *args, &decorated)
+    }.tap do |guard|
+      guard_names.each do |name|
+        Fibril.guard.send("#{name}=", guard)
+      end
+    end
+
+  end
+end