andromeda 0.1 → 0.1.2

data/lib/andromeda/spot.rb

@@ -0,0 +1,132 @@
+module Andromeda
+
+  # A spot is a reachable destination to which data may be sent for processing.
+  # It encapsulates addressing the processing logic of a Plan into a separate,
+  # immutable Object that may be passed around freely.
+  #
+  # It is somewhat similiar/a mixture of notions such as actor address,
+  # RPC endpoint, and stack frame in other frameworks
+  #
+  # You MUST not inherit from this class
+  #
+  class Spot < Impl::ConnectorBase
+    include Impl::To_S
+
+    # @return [Plan] Plan to which this spot will deliver data events
+    attr_reader :plan
+
+    # @return [Symbol] Name of spot attribute in plan that corresponds to this spot
+    attr_reader :name
+
+    # @return [Plan, nil] Plan of calling spot if any, nil otherwise
+    attr_reader :here
+
+    # @return [Symbol, nil] Spot's destination name, or nil for plan.dest, returned by >>
+    def dest_name ; @dest end
+
+    # @param [Plan] plan Plan to which this spot will deliver data events
+    # @param [Symbol] name Name of spot attribute in plan that corresponds to this spot
+    # @param [Plan, nil] here Plan of calling Spot if any, nil otherwise
+    # @param [Symbol, nil] dest destination name use to obtain return value for >>
+    def initialize(plan, name, here, dest = nil)
+      raise ArgumentError, "#{plan} is not a Plan" unless plan.is_a? Plan
+      raise ArgumentError, "#{name} is not a Symbol" unless name.is_a? Symbol
+      unless plan.meth_spot_name?(name)
+        raise ArgumentError, "#{name} is not a known method spot name of #{plan}"
+      end
+      unless dest.nil? || dest.is_a?(Symbol)
+        raise ArgumentError, "#{dest} is neither nil nor a Symbol"
+      end
+      if !here || here.is_a?(Plan)
+        @plan = plan
+        @name = name
+        @here = here
+        @dest = dest
+      else
+        raise ArgumentError, "#{here} is neither nil nor a Plan"
+      end
+    end
+
+    def cloneable? ; true end
+    def clone_to_copy? ; false end
+    def identical_copy ; self end
+
+    # Spots compare attribute-wise and do not accept subclasses
+    #
+    # @retrun [TrueClass, FalseClass] self == other
+    def ==(other)
+      return true if self.equal? other
+      return false unless other.class.equal? Spot
+      name.eq(other.name) && plan.eq(other.plan) && here.eq(other.here) && dest.eq(other.dest)
+    end
+
+    def hash ; plan.hash ^ name.hash ^ here.hash ^ dest.hash end
+
+    def to_short_s
+      dest_ = dest_name
+      dest_ = if dest_ then " dest=:#{dest_name}" else '' end
+      here_ = here
+      if here_
+        then " plan=#{plan} name=:#{name} here=#{here_}#{dest_}"
+        else " plan=#{plan} name=:#{name}#{dest_}" end
+    end
+    alias_method :inspect, :to_s
+
+    # Post data with the associated tags_in to this's spot's plan's method spot with name name
+    # and hint that the caller requested the spot activation to be executed on track tack
+    #
+    # @param [Track] track requested target track
+    # @param [Any] data any data event
+    # @param [Hash] tags to be passed along
+    #
+    # @return [self]
+    def post_to(track, data, tags_in = {})
+      tags_in = (here.tags.identical_copy.update(tags_in) rescue tags_in) if here
+      plan.post_data self, track, data, tags_in
+      self
+    end
+
+    # @return [Spot] a fresh copy of self for which dest_name == spot_name holds
+    def via(spot_name)
+      raise ArgumentError unless spot_name.nil? || spot_name.is_a?(Symbol)
+      Spot.new plan, name, here, spot_name
+    end
+
+    # Call the spot method associated with this spot with the provided key and val
+    #
+    # Precondition is that here == plan, i.e. the caller already executes in the scope
+    # of this spot's plan
+    #
+    # @return [Any] plan.call_local name, key, val
+    def call_local(key, val)
+      plan.call_local name, key, val
+    end
+
+    # @return [self] for compatibility with plan's API
+    def entry ; self end
+
+    # @return [Spot] plan.public_spot(dest_name) if that exists, plan.dest otherwise
+    def dest
+      if dest_name
+        then plan.public_spot(dest_name)
+        else plan.dest end
+    end
+
+    def >>(target)
+      return (plan >> target) unless dest_name
+      unless plan.attr_spot_name?(dest_name)
+        raise ArgumentError, "#{dest_name} is not an attr_spot_name"
+      end
+      plan.send :"#{dest_name}=", target.entry
+      plan.public_spot(dest_name)
+    end
+
+    # @return [Spot] this spot or a modified copy of it such that here == new_calling_plan holds
+    def intern(new_calling_plan)
+      if here.equal? new_calling_plan
+        then self
+        else Spot.new plan, name, new_calling_plan, dest_name end
+    end
+  end
+
+end

data/lib/andromeda/sugar.rb

@@ -0,0 +1,41 @@
+module Andromeda
+
+  class Plan
+    def pool ; guide.pool_track.pool rescue nil end
+  end
+
+  module Guides
+
+    def self.default ; DefaultGuide.instance end
+    def self.single ; SinglePoolGuide.new end
+    def self.shared_pool ; SharedPoolGuide end
+    def self.pool ; SharedPoolGuide.new end
+    def self.local ; LocalGuide end
+    def self.shared_single ; SharedSinglePoolGuide end
+
+    class DefaultGuide < SimpleDelegator
+      include Singleton
+
+      def initialize
+        super LocalGuide.instance
+      end
+
+      def instance=(new_instance)
+        if new_instance.is_a?(Class) && new_instance.include?(Singleton)
+          new_instance = new_instance.instance
+        end
+        instance.__setobj__ new_instance
+      end
+    end
+
+  end
+
+  class DefaultLogger < SimpleDelegator
+    include Singleton
+
+    def initialize
+      super Logger.new(STDERR)
+    end
+  end
+
+end

data/lib/andromeda/sync.rb

@@ -0,0 +1,68 @@
+module Andromeda
+
+  module Sync
+
+    # Comparable to a join in join calculus, called Sync here to reserve the name Join
+    # for map_reduce.rb
+    #
+    class Sync < Plan
+
+      def initialize(config = {})
+        super config
+        @mutex = Mutex.new
+        @cv    = ConditionVariable.new
+        #  box value to keep ref after clone
+        @state = [ state_init ]
+      end
+
+      protected
+
+      def state_init ; {} end
+
+      def state_ready?(state)
+        raise RuntimeException, 'Not implemented'
+      end
+
+      def state_empty?(state, k, chunk)  ; state[k].nil? end
+      def state_updated(state, k, chunk) ; state[k] = chunk; state end
+
+      def state_chunk_key(name, state) ; chunk_key(name, state) end
+
+        def run_chunk(pool, scope, name, meth, k, chunk, &thunk)
+          @mutex.synchronize do
+            state = @state[0]
+            while true
+              if state_empty?(state, k, chunk)
+                @state[0] = (state = state_updated(state, k, chunk))
+                if state_ready?(state)
+                  @state[0] = state_init
+                cv.signal
+                new_k = state_chunk_key(name, state)
+                  return super pool, scope, name, meth, new_k, state, &thunk
+                else
+                  cv.signal
+                  return self
+                end
+              else
+                cv.wait @mutex
+              end
+            end
+          end
+        end
+    end
+
+    # Passes all input and waits for the associated scope to return to the start value
+    # (will only work if there is no concurrent modification to the associated scope)
+    class ScopeWaiter < Plan
+
+      def on_enter(k, v)
+        scope_ = current_scope
+        value_ = scope_.value
+        super k, v
+        scope_.wait_until_eq value_
+      end
+    end
+
+  end
+
+end

data/lib/andromeda/version.rb

@@ -1,3 +1,3 @@
 module Andromeda
-  VERSION = '0.1'
+  VERSION = '0.1.2'
 end

data/yard_extensions/andromeda.rb

@@ -0,0 +1,28 @@
+require 'yard'
+
+class MethSpotHandler < YARD::Handlers::Ruby::AttributeHandler
+  handles method_call(:meth_spot)
+  namespace_only
+
+  def process
+    push_state(:scope => :class) { super }
+  end
+end
+
+class AttrSpotHandler < YARD::Handlers::Ruby::AttributeHandler
+  handles method_call(:attr_spot)
+  namespace_only
+
+  def process
+    push_state(:scope => :class) { super }
+  end
+end
+
+class SignalSpotHandler < YARD::Handlers::Ruby::AttributeHandler
+  handles method_call(:signal_spot)
+  namespace_only
+
+  def process
+    push_state(:scope => :class) { super }
+  end
+end

metadata

@@ -1,18 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: andromeda
 version: !ruby/object:Gem::Version
-  version: '0.1'
   prerelease: 
+  version: 0.1.2
 platform: ruby
 authors:
 - Stefan Plantikow
 autorequire: 
 bindir: script
 cert_chain: []
-date: 2012-04-24 00:00:00.000000000 Z
+date: 2012-05-01 00:00:00.000000000 Z
 dependencies: []
-description: Ultra light weight multicore stream processing framework based on a dataflow
-  DSL
+description: Andromeda is a light weight framework for complex event processing on
+  multicore architectures. Andromeda users construct networks of plans that are interconnected
+  via endpoint spots, describe how plans are scheduled onto threads, and process data
+  by feeding data events to the resulting structure.
 email: stefanp@moviepilot.com
 executables: []
 extensions: []
@@ -21,22 +23,38 @@ files:
 - .gitignore
 - .rvmrc
 - AUTHORS
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
+- ROADMAP.md
 - Rakefile
 - andromeda.gemspec
 - lib/andromeda.rb
-- lib/andromeda/andromeda.rb
-- lib/andromeda/commando.rb
-- lib/andromeda/helpers.rb
+- lib/andromeda/atom.rb
+- lib/andromeda/cmd.rb
+- lib/andromeda/common.rb
+- lib/andromeda/copy_clone.rb
+- lib/andromeda/error.rb
+- lib/andromeda/guide.rb
+- lib/andromeda/guide_track.rb
 - lib/andromeda/id.rb
-- lib/andromeda/join.rb
-- lib/andromeda/pools.rb
-- lib/andromeda/scope.rb
+- lib/andromeda/impl/atom.rb
+- lib/andromeda/impl/class_attr.rb
+- lib/andromeda/impl/proto_plan.rb
+- lib/andromeda/impl/to_s.rb
+- lib/andromeda/impl/xor_id.rb
+- lib/andromeda/kit.rb
+- lib/andromeda/map_reduce.rb
+- lib/andromeda/plan.rb
+- lib/andromeda/pool_guide.rb
+- lib/andromeda/spot.rb
+- lib/andromeda/sugar.rb
+- lib/andromeda/sync.rb
 - lib/andromeda/version.rb
 - spec/spec_helper.rb
+- yard_extensions/andromeda.rb
 homepage: https://github.com/moviepilot/andromeda
 licenses:
 - PUBLIC DOMAIN WITHOUT ANY WARRANTY
@@ -58,11 +76,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: andromeda
-rubygems_version: 1.8.17
+rubygems_version: 1.8.12
 signing_key: 
 specification_version: 3
-summary: Ultra light weight multicore stream processing framework based on a dataflow
-  DSL
+summary: light weght framework for complex event processing based on a dataflow DSL
 test_files:
 - spec/spec_helper.rb
 has_rdoc: 

data/lib/andromeda/andromeda.rb

@@ -1,225 +0,0 @@
-# TODO
-#  - Turn into separate gem
-#  - Write Tests
-#  - Write fusor for synchronization (extra class that blocks until ready to submit)
-#  - Write docs, add yard support for documenting bases, attrs, etc.
-#  - Make nice slideshow and become very famous and rich. yay!
-module Andromeda
-
-  module Internal
-    class Transplanting
-      attr_reader :orig
-
-      def initialize(init_opts = nil)
-        @opts = init_opts
-        @orig = self
-      end
-
-      protected
-
-      def transplant(new_opts = nil)
-        return self if @opts == new_opts
-        obj = self.clone
-        obj.instance_variable_set '@opts', new_opts
-        obj
-      end
-    end
-  end
-
-  class Dest < Internal::Transplanting
-    attr_reader :base
-    attr_reader :meth
-
-    def initialize(base, meth, init_opts = nil)
-      super init_opts
-      raise ArgumentError, "'#{meth}' is not a symbol" unless meth.kind_of?(Symbol)
-      raise ArgumentError, "'#{base}' is not a base" unless base.kind_of?(Base)
-      raise NoMethodError, "'#{base}' does not respond to '#{meth}'" unless base.respond_to?(meth)
-      @base  = base
-      @meth  = meth
-    end
-
-    def <<(chunk, opts = {}) ; submit chunk, opts ; self end
-    def submit(chunk, opts = {}) ; submit_to nil, chunk, opts end
-    def submit_now(chunk, opts = {}) ; submit_to :local, chunk, opts end
-
-    def submit_to(target_pool, chunk, opts = {})
-      if @opts
-        new_opts = @opts.clone
-        opts.each { |k, v| new_opts[k] = v }
-      else
-        new_opts = opts
-      end
-      new_opts[:scope] ||= Scope.new
-      new_opts[:mark]  ||= Id.zero
-      base.transplant(new_opts).process target_pool, new_opts[:scope], self.meth, chunk
-      new_opts
-    end
-
-    def entry ; self end
-  end
-
-  class Base < Internal::Transplanting
-    attr_reader :id
-    attr_reader :opts
-
-    attr_accessor :log
-    attr_accessor :mark
-    attr_accessor :emit
-    attr_accessor :pool
-
-    attr_reader :trace_enter
-    attr_reader :trace_exit
-
-    def initialize(config = {})
-      super config[:init_opts]
-      @id = Id.gen
-      set_from_config init_from_config, config      
-      @trace_enter ||= init_trace_hash :enter
-      @trace_exit  ||= init_trace_hash :emit
-      @pool        ||= init_pool_config
-    end 
-
-    def trace=(new_trace)
-      raise ArgumentError, "'#{new_trace}' is not a Hash" unless new_trace.kind_of?(Hash)
-      @trace = new_trace
-    end
-
-    def init_trace_hash(kind) ; {} end
-    def init_pool_config ; nil end
-    def init_from_config ; [:readers, :writers] end
-
-    def log ; @log = Logger.new(STDERR) unless @log ; @log end
-    def mark ; @mark = Id.zero unless @mark ; @mark end
-
-    def on_enter(c)
-      emit << c rescue nil
-    end   
-
-    # @param [nil, :local, :spawn, :single, :fifo, :default, :global, #process, #process_base] pool_descr 
-    #     If nil, uses self.pool as pool_descr and continues. If that is nil, too, defaults to :local.
-    #     If #process_base, uses target_pool.process_base(meth) as pool_descr and continues.
-    #     If pool_descr is :spawn, uses SpawnPool.default_pool
-    #     If pool_descr is :single, uses PoolSupport.new_single_pool
-    #     If pool_descr is :fifo, uses PoolSupport.new_fifo_pool
-    #     If pool_descr is :global, uses the globally shared PoolSupport.global_pool
-    #     If pool_descr is :default uses PoolSupport.new_default_pool
-    #     Finally, if #process, runs by calling #process.  If :local, runs in current thread. 
-    #     Otherwise, the behaviour is undefined.
-    def process(pool_descr, scope, meth, chunk)
-      this = self
-      run target_pool(pool_descr, meth), scope, meth, chunk  do
-        begin
-          enter_level = trace_enter[meth]
-          exit_level  = trace_exit[meth]
-          trace :enter, enter_level, meth, chunk if enter_level
-          send meth, chunk
-          trace :exit, exit_level, meth, chunk if exit_level
-        rescue Exception => e
-          handle_exception meth, chunk, e
-        ensure
-          scope.leave if scope
-        end
-      end
-    end
-
-    def check_mark
-      mark = @opts[:mark]
-      raise RuntimeError, 'invalid mark' if mark && !mark.zero?
-    end
-
-    def intern(dest) ; dest.transplant(opts) end
-
-    def dest(name)
-      result = if self.respond_to?(name)
-        then intern self.send(name)
-        else Dest.new self, "on_#{name}".to_sym, opts  end
-      raise ArgumentError, "unknown or invalid dest: '#{name}'" unless result.kind_of?(Dest)
-      result
-    end
-
-    def trace(kind, level, method, chunk) 
-      log_ = log     
-      log_.send level, "TRACE #{id.to_s} :#{kind} :#{method} chunk: '#{chunk}'" if log_
-    end
-
-    protected
-
-    def set_from_config(what, config = {})
-      init_readers = what.include? :readers
-      init_writers = what.include? :writers
-      config.each_pair do |k, v|
-        k = k.to_sym rescue nil
-        if init_writers
-          writer = "#{k}=".to_sym rescue nil
-          if writer &&  self.respond_to?(writer)
-            then self.send writer, v 
-            else instance_variable_set "@#{k}", v if init_readers && self.respond_to?(k) end
-        else
-          instance_variable_set "@#{k}", v if init_readers && self.respond_to?(k)  
-        end
-      end
-    end
-
-    def mark_opts
-      if @mark && !@mark.zero?
-        if @opts[:mark]
-          then @opts[:mark] = @opts[:mark].xor(mark)
-          else @opts[:mark] = mark end
-      end
-    end
-
-    def run(pool, scope, meth, chunk, &thunk)
-      scope.enter
-      begin
-        if pool && pool.respond_to?(:process)
-          then pool.process(&thunk)
-          else thunk.call end
-      rescue Exception => e
-        handle_exception meth, chunk, e
-        scope.leave if scope
-      end
-      self
-    end
-
-    def target_pool(pool_descr, meth)
-      pool_descr = pool unless pool_descr
-      case pool_descr
-          when nil then :local
-          when :local then :local
-          when :spawn then SpawnPool.default_pool
-          when :global then  PoolSupport.global_pool
-          when :default then PoolSupport.new_default_pool
-          when :single then PoolSupport.new_single_pool
-          when :fifo then PoolSupport.new_fifo_pool 
-          else 
-             if pool_descr.respond_to(:process_base) 
-              then pool_descr.process_base(meth) 
-              else pool_descr end
-      end
-    end
-
-    def handle_exception(meth, chunk, e)
-      if log
-        trace = ''
-        e.backtrace.each { |s| trace << "\n    #{s}" }
-        log.error "Caught '#{e}' when processing chunk: '#{chunk}' via meth: '#{meth}' with backtrace: '#{trace}'"
-      end
-    end
-
-    public
-
-    def >>(dest) ; self.emit = dest.entry end
-
-    def drop ; self.emit = nil end
-
-    def entry ; dest(:enter) end
-    alias_method :exit, :emit
-
-    def <<(chunk, opts = {}) ; entry.<< chunk, opts end
-    def submit(chunk, opts = {}) ; entry.submit chunk, opts end
-    def submit_now(chunk, opts = {}) ; entry.submit_now chunk, opts end
-    def submit_to(target_pool, chunk, opts = {}) ; entry.submit_to target_pool, chunk, opts end
-  end
-end
-