zoidberg 0.0.1 → 0.1.0

data/lib/zoidberg/supervisor.rb

@@ -0,0 +1,82 @@
+require 'zoidberg'
+
+module Zoidberg
+  class Supervisor
+
+    include Zoidberg::Shell
+
+    # @return [Registry] current supervision registry
+    attr_reader :registry
+
+    # Create a new supervisor
+    #
+    # @return [self]
+    def initialize
+      @registry = Registry.new
+    end
+
+    # Fetch the supervised instance or pool
+    #
+    # @param k [String, Symbol] name of supervised item
+    # @return [Object] supervised object
+    def [](k)
+      registry[k]
+    end
+
+    # Supervise an instance
+    #
+    # @param name [String, Symbol] name of item to supervise
+    # @param klass [Class] class of instance
+    # @param args [Object] initialization arguments
+    # @yieldblock initialization block
+    # @return [Object] new instance
+    def supervise_as(name, klass, *args, &block)
+      klass = supervised_class(klass)
+      registry[name] = klass.new(*args, &block)
+    end
+
+    # Supervise a pool
+    #
+    # @param klass [Class] class of instance
+    # @param args [Hash] initialization arguments
+    # @option args [String] :as name of pool
+    # @option args [Integer] :size size of pool
+    # @option args [Array<Object>] :args initialization arguments
+    # @yieldblock initialization block
+    # @return [Object] new pool
+    def pool(klass, args={}, &block)
+      name = args[:as]
+      size = args[:size].to_i
+      args = args.fetch(:args, [])
+      klass = supervised_class(klass)
+      s_pool = Pool.new(klass, *args, &block)
+      s_pool._worker_count(size > 0 ? size : 1)
+      registry[name] = s_pool
+    end
+
+    # Destroy all supervised instances prior to destruction
+    def terminate
+      registry.values.each do |item|
+        item._zoidberg_destroy!
+      end
+    end
+
+    protected
+
+    # Make a supervised class
+    #
+    # @param klass [Class]
+    # @return [Class]
+    def supervised_class(klass)
+      unless(klass.include?(Zoidberg::Supervise))
+        n_klass = Class.new(klass) do
+          include Zoidberg::Supervise
+        end
+        n_klass.class_eval("def self.name; '#{klass.name}'; end")
+        klass = n_klass
+      end
+      klass
+    end
+
+  end
+end

data/lib/zoidberg/task.rb

@@ -0,0 +1,147 @@
+require 'zoidberg'
+
+module Zoidberg
+
+  # Run a task
+  class Task
+
+    # Supported task styles
+    SUPPORTED_STYLES = [:serial, :async]
+
+    # @return [Symbol] :fiber or :thread
+    attr_reader :style
+    # @return [Object] originator of task
+    attr_reader :origin
+    # @return [Proc] block to execute
+    attr_reader :content
+    attr_reader :content_arguments
+    # @return [Thread, Fiber] underlying task container
+    attr_reader :task
+
+    # Create a new task
+    #
+    # @param task_style [Symbol]
+    # @param origin [Object] origin object of block
+    # @yield block to execute
+    # @return [self]
+    def initialize(task_style, origin, block_args=[], &block)
+      unless(SUPPORTED_STYLES.include?(task_style))
+        raise ArgumentError.new("Allowed style values: #{SUPPORTED_STYLES.map(&:inspect).join(', ')} but received: #{task_style.inspect}")
+      end
+      @style = task_style
+      @origin = origin
+      @content = block
+      @content_arguments = block_args
+      @result = nil
+      send("run_#{style}")
+    end
+
+    # @return [Object] result of task
+    def value
+      if(task.alive?)
+        @result = style == :async ? task.join : task.resume
+      end
+      @result
+    end
+
+    # Force task to stop prior to completion if still in running state
+    #
+    # @return [NilClass]
+    def halt!
+      if(style == :async)
+        task.kill
+      else
+        @task = nil
+      end
+    end
+
+    # @return [TrueClass, FalseClass] task currently waiting to run
+    def waiting?
+      task && task.alive? && task.respond_to?(:stop?) ? task.stop? : true
+    end
+
+    # @return [TrueClass, FalseClass] task is running
+    def running?
+      if(task)
+        style == :async && task.alive? && !task.stop?
+      else
+        false
+      end
+    end
+
+    # @return [TrueClass, FalseClass] task is complete
+    def complete?
+      task.nil? || !task.alive?
+    end
+
+    # @return [TrueClass, FalseClass] task complete in error state
+    def error?
+      complete? && value.is_a?(Exception)
+    end
+
+    # @return [TrueClass, FalseClass] task complete in success state
+    def success?
+      complete? && !error?
+    end
+
+    # Reliquish running state and return optional value(s)
+    #
+    # @param args [Object] values to return
+    # @return [Object, Array<Object>]
+    def cease(*args)
+      if(style == :async)
+        task[:task_args] = args
+        task.stop
+        task[:task_args]
+      else
+        Fiber.yield(*args)
+      end
+    end
+
+    # Regain running state with optional value(s)
+    # @param args [Object] values to provide
+    # @return [Object, Array<Object>]
+    def proceed(*args)
+      if(style == :serial)
+        task.resume(*args)
+      else
+        task[:task_args] = args
+        task.run
+        task[:task_args]
+      end
+    end
+
+    protected
+
+    # Create new fiber based task
+    #
+    # @return [Fiber]
+    def run_serial
+      @task = Fiber.new do
+        begin
+          self.instance_exec(*content_arguments, &content)
+        rescue Exception => e
+          origin.send(:raise, e)
+          raise
+        end
+      end
+    end
+
+    # Create new thread based task
+    #
+    # @return [Thread]
+    def run_async
+      @task = Thread.new do
+        Thread.stop
+        begin
+          self.instance_exec(*content_arguments, &content)
+        rescue Exception => e
+          origin.send(:raise, e)
+          raise
+        end
+      end
+    end
+
+  end
+
+end

data/lib/zoidberg/timer.rb

@@ -0,0 +1,230 @@
+require 'zoidberg'
+
+module Zoidberg
+
+  # Simple timer class
+  class Timer
+
+    class Action
+
+      # @return [TrueClass, FalseClass]
+      attr_reader :recur
+      # @return [Proc] action to run
+      attr_reader :action
+      # @return [Numeric]
+      attr_reader :interval
+      # @return [Float]
+      attr_reader :last_run
+
+      # Create a new action
+      #
+      # @param args [Hash]
+      # @option args [Numeric] :interval
+      # @option args [TrueClass, FalseClass] :recur
+      # @return [self]
+      def initialize(args={}, &block)
+        unless(block)
+          raise ArgumentError.new 'Action is required. Block must be provided!'
+        end
+        @action = block
+        @recur = args.fetch(:recur, false)
+        @interval = args.fetch(:interval, 5)
+        @last_run = Time.now.to_f
+        @cancel = false
+      end
+
+      # Cancel the action
+      #
+      # @return [TrueClass]
+      def cancel
+        @recur = false
+        @cancel = true
+      end
+
+      # @return [TrueClass, FalseClass]
+      def cancelled?
+        @cancel
+      end
+
+      # Run the action
+      #
+      # @return [self]
+      def run!
+        @last_run = Time.now.to_f
+        action.call
+        @last_run = Time.now.to_f
+        self
+      end
+
+    end
+
+    include Zoidberg::SoftShell
+
+    # Custom exception used to wakeup timer
+    class Wakeup < StandardError; end
+
+    # @return [Mutex]
+    attr_reader :notify_locker
+    # @return [Array<Action>] items to run
+    attr_reader :to_run
+    # @return [TrueClass, FalseClass] timer is paused
+    attr_reader :paused
+
+    # Create a new timer
+    #
+    # @return [self]
+    def initialize
+      @to_run = []
+      @notify_locker = Mutex.new
+      @paused = false
+      @thread = Thread.new{ run! }
+    end
+
+    # Run recurring action at given interval
+    #
+    # @param interval [Numeric]
+    # @yield action to run
+    # @return [Action]
+    def every(interval, &block)
+      action = Action.new({
+          :interval => interval,
+          :recur => true
+        },
+        &block
+      )
+      to_run.push(action)
+      reset
+      action
+    end
+
+    # Run action after given interval
+    #
+    # @param interval [Numeric]
+    # @yield action to run
+    # @return [Action]
+    def after(interval, &block)
+      action = Action.new(
+        {:interval => interval},
+        &block
+      )
+      to_run.push(action)
+      reset
+      action
+    end
+
+    # Pause the timer to prevent any actions from being run
+    #
+    # @return [self]
+    def pause
+      unless(@paused)
+        @paused = true
+        reset
+      end
+      current_self
+    end
+
+    # Resume a paused timer
+    #
+    # @return [self]
+    def resume
+      if(@paused)
+        @paused = false
+        reset
+      end
+      current_self
+    end
+
+    # Remove all actions from the timer
+    #
+    # @return [self]
+    def cancel
+      to_run.clear
+      reset
+      current_self
+    end
+
+    # Reset the timer
+    #
+    # @param wakeup [TrueClass, FalseClass] wakeup the timer thread
+    # @return [self]
+    def reset(wakeup=true)
+      if(wakeup)
+        notify_locker.synchronize do
+          to_run.sort_by! do |item|
+            (item.interval + item.last_run) - Time.now.to_f
+          end
+          @thread.raise Wakeup.new
+        end
+      else
+        to_run.sort_by! do |item|
+          (item.interval + item.last_run) - Time.now.to_f
+        end
+      end
+      current_self
+    end
+
+    # @return [Numeric, NilClass] interval to next action
+    def next_interval
+      unless(to_run.empty? || paused)
+        item = to_run.first
+        result = (item.last_run + item.interval) - Time.now.to_f
+        result < 0 ? 0 : result
+      end
+    end
+
+    # Run any actions that are ready
+    #
+    # @return [self]
+    def run_ready
+      items = to_run.find_all do |item|
+        ((item.interval + item.last_run) - Time.now.to_f) <= 0
+      end
+      to_run.delete_if do |item|
+        items.include?(item)
+      end
+      items.map do |item|
+        begin
+          item.run! unless item.cancelled?
+        rescue DeadException
+          item.cancel
+        rescue => e
+          Zoidberg.logger.error "<#{self}> Timed action generated an error: #{e.class.name} - #{e}"
+        end
+        item if item.recur
+      end.compact.each do |item|
+        to_run << item
+      end
+      current_self
+    end
+
+    protected
+
+    # Run the timer loop
+    def run!
+      loop do
+        begin
+          interval = nil
+          # TODO: update with select for better subsecond support
+          notify_locker.synchronize do
+            interval = next_interval
+          end
+          sleep interval
+          notify_locker.synchronize do
+            run_ready
+            reset(false)
+          end
+        rescue Wakeup
+          Zoidberg.logger.debug "<#{self}> Received wakeup notification. Rechecking sleep interval!"
+        rescue DeadException
+          raise
+        rescue => e
+          Zoidberg.logger.error "<#{self}> Unexpected error in runner: #{e.class.name} - #{e}"
+          Zoidberg.logger.debug "<#{self}> #{e.class.name}: #{e}\n#{e.backtrace.join("\n")}"
+          current_self.raise e
+        end
+      end
+    end
+
+  end
+
+end

data/lib/zoidberg/version.rb

@@ -1,3 +1,4 @@
 module Zoidberg
-  VERSION = Gem::Version.new('0.0.1')
+  # Current library version
+  VERSION = Gem::Version.new('0.1.0')
 end

data/lib/zoidberg/weak_ref.rb

@@ -0,0 +1,51 @@
+require 'zoidberg'
+
+module Zoidberg
+  # Provide weak reference to object allowing for it to be garbage
+  # collected. This is a stripped down version of the ::WeakRef class
+  class WeakRef < BasicObject
+
+    # Exception type raised when referenced object no longer exists
+    class RecycledException < ::RuntimeError
+      # @return [String] ID of referenced object casted to string
+      attr_reader :recycled_object_id
+      # Create a new exception instance
+      #
+      # @param msg [String] exception message
+      # @param recycled_object_id [String] casted object ID
+      # @return [self]
+      def initialize(msg, recycled_object_id)
+        @recycled_object_id = recycled_object_id
+        super(msg)
+      end
+    end
+
+    @@__zoidberg_map = ::ObjectSpace::WeakMap.new
+
+    # Create a new weak reference
+    #
+    # @param orig [Object] referenced object
+    # @return [self]
+    def initialize(orig)
+      @_key = orig.object_id.to_s
+      @@__zoidberg_map[@_key] = orig
+    end
+
+    def method_missing(*args, &block) # :nodoc:
+      if(@@__zoidberg_map[@_key])
+        @@__zoidberg_map[@_key].__send__(*args, &block)
+      else
+        ::Kernel.raise RecycledException.new('Instance has been recycled by the system!', @_key)
+      end
+    end
+
+  end
+
+end
+
+# jruby compat [https://github.com/jruby/jruby/pull/2520]
+if(Zoidberg::WeakRef.instance_methods.include?(:object_id))
+  class Zoidberg::WeakRef
+    undef_method :object_id
+  end
+end

data/lib/zoidberg.rb

@@ -1 +1,56 @@
+require 'bogo'
+require 'thread'
+require 'securerandom'
 require 'zoidberg/version'
+
+# Why not Zoidberg!?
+module Zoidberg
+  autoload :DeadException, 'zoidberg/shell'
+  autoload :Future, 'zoidberg/future'
+  autoload :Logger, 'zoidberg/logger'
+  autoload :Pool, 'zoidberg/pool'
+  autoload :Proxy, 'zoidberg/proxy'
+  autoload :Registry, 'zoidberg/registry'
+  autoload :Shell, 'zoidberg/shell'
+  autoload :SoftShell, 'zoidberg/shell'
+  autoload :HardShell, 'zoidberg/shell'
+  autoload :Signal, 'zoidberg/signal'
+  autoload :Supervise, 'zoidberg/supervise'
+  autoload :Supervisor, 'zoidberg/supervisor'
+  autoload :Task, 'zoidberg/task'
+  autoload :Timer, 'zoidberg/timer'
+  autoload :WeakRef, 'zoidberg/weak_ref'
+
+  class << self
+
+    attr_accessor :default_shell
+
+    # @return [Zoidberg::Logger]
+    def logger
+      @zoidberg_logger
+    end
+
+    # Set new default logger
+    #
+    # @param log [Zoidberg::Logger]
+    # @return [zoidberg::Logger]
+    def logger=(log)
+      unless(log.is_a?(Zoidberg::Logger))
+        raise TypeError.new "Expecting type `Zoidberg::Logger` but received type `#{log.class}`"
+      end
+      @zoidberg_logger = log
+    end
+
+    # @return [String] UUID
+    def uuid
+      SecureRandom.uuid
+    end
+
+  end
+
+end
+
+# Always enable default logger
+Zoidberg.logger = Zoidberg::Logger.new(STDERR)
+# Set default shell to soft shell
+Zoidberg.default_shell = Zoidberg::SoftShell

data/zoidberg.gemspec

@@ -11,6 +11,7 @@ Gem::Specification.new do |s|
   s.require_path = 'lib'
   s.license = 'Apache 2.0'
   s.add_runtime_dependency 'bogo'
+  s.add_runtime_dependency 'mono_logger'
   s.add_development_dependency 'pry'
   s.add_development_dependency 'minitest'
   s.files = Dir['lib/**/*'] + %w(zoidberg.gemspec README.md CHANGELOG.md CONTRIBUTING.md LICENSE)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zoidberg
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-19 00:00:00.000000000 Z
+date: 2015-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bogo
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mono_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -63,7 +77,21 @@ files:
 - LICENSE
 - README.md
 - lib/zoidberg.rb
+- lib/zoidberg/future.rb
+- lib/zoidberg/logger.rb
+- lib/zoidberg/pool.rb
+- lib/zoidberg/proxy.rb
+- lib/zoidberg/proxy/confined.rb
+- lib/zoidberg/proxy/liberated.rb
+- lib/zoidberg/registry.rb
+- lib/zoidberg/shell.rb
+- lib/zoidberg/signal.rb
+- lib/zoidberg/supervise.rb
+- lib/zoidberg/supervisor.rb
+- lib/zoidberg/task.rb
+- lib/zoidberg/timer.rb
 - lib/zoidberg/version.rb
+- lib/zoidberg/weak_ref.rb
 - zoidberg.gemspec
 homepage: https://github.com/spox/zoidberg
 licenses:
@@ -90,3 +118,4 @@ signing_key:
 specification_version: 4
 summary: Why not?
 test_files: []
+has_rdoc: