andromeda 0.1 → 0.1.2

data/lib/andromeda/impl/to_s.rb

@@ -0,0 +1,48 @@
+module Andromeda
+
+  module Impl
+
+    module To_S
+
+      def to_s(short = false)
+        if short
+          to_short_s
+        else
+          super_str  = super()
+          class_name = self.class.name.split('::')[-1]
+          obj_id     = object_id.to_s(16)
+          "\#<#{class_name}:0x#{obj_id}#{to_s(true)}>"
+        end
+      end
+
+      def to_short_s ; '' end
+
+      def self.short_s(v = value)
+        return ":#{v}" if v.is_a?(Symbol)
+        return "'#{v}'" if v.is_a?(String)
+        return 'nil' unless v
+        "#{v}"
+      end
+
+    end
+
+    # Shared base class of Spot and Impl::PrePlan
+    class ConnectorBase
+      # @return [Spot] entry.intern nil
+      def start ; entry.intern(nil) end
+
+      # post_to nil, data, tags_in
+      #
+      # @return [self]
+      def post(data, tags_in = {}) ; post_to nil, data, tags_in end
+
+      alias_method :<<, :post
+
+      # post_to LocalTrack.instance, data, tags_in
+      #
+      # @return [self]
+      def post_local(data, tags_in = {}) ; post_to Guides::LocalTrack.instance, data, tags_in end
+    end
+
+  end
+end

data/lib/andromeda/impl/xor_id.rb

@@ -0,0 +1,89 @@
+module Andromeda
+
+  module Impl
+
+    # Generator for random xorable ids (used for markers)
+    class XorId
+      include To_S
+
+      protected
+
+      def initialize(len, random = true, init_data = nil)
+        raise ArgumentError unless len.kind_of?(Fixnum)
+        raise ArgumentError unless len >= 0
+
+        @data = if init_data
+          init_data
+        else
+          if random
+            then len.times.map { Id.rnd_byte }
+            else len.times.map { 0 } end
+        end
+      end
+
+      public
+
+      def clone_to_copy? ; false end
+      def identical_copy ; self end
+
+      def length ; @data.length end
+      def zero? ; each { |b| return false unless b == 0 } ; true end
+
+      def [](key) ; @data[key] end
+
+      def same_length?(obj) ; self.length == obj.length end
+
+      def each ; this = self ; 0.upto(length-1).each { |i| yield this[i] } end
+      def each_with_index ; this = self ; 0.upto(length-1).each { |i| yield i, this[i] } end
+
+      # Compare self to b
+      # @param [Id] b
+      def ==(b)
+        return true if self.equal? b
+        return false if b.nil?
+        return false unless b.class.equal? self.class
+        return false unless same_length? b
+        zip_bytes(b) { |i, j| return false if i != j }
+        true
+      end
+
+      def hash ; @data.hash end
+
+      # xor self and b's ids component-wise
+      # @param [Array<Fixnum>] b
+      # @return [Id]
+      def xor(b)
+        r = []
+        zip_bytes(b) { |i,j| r << (i ^ j) }
+        Id.new r.length, false, r
+      end
+
+      def to_short_s
+        r = ''
+        each { |b| r << Id.two_char_hex_str(b.to_s(16)) }
+        r
+      end
+
+      def inspect ; to_s end
+
+      private
+
+      def zip_bytes(b)
+        a = self
+        0.upto(length-1).each { |i| yield a[i], b[i] }
+      end
+
+      def self.rnd_byte ; Random.rand(256) end
+
+      def self.two_char_hex_str(s)
+        case s.length
+          when 0 then '00'
+          when 1 then "0#{s}"
+          else s
+        end
+      end
+    end
+
+  end
+
+end

data/lib/andromeda/kit.rb

@@ -0,0 +1,172 @@
+module Andromeda
+
+	module Kit
+
+		module Transf
+			attr_accessor :filter
+			attr_accessor :mapper
+
+			def deliver_data(name, meth, key, val, tags_in)
+				if signal_name?(name)
+					super name, meth, key, val, tags_in
+				else
+					filter_ = filter
+					mapper_ = mapper
+					if !(filter_ && filter_.call(val))
+						super name, meth, key, (if mapper_ then mapper_.call(val) else val end), tags_in
+					end
+				end
+			end
+		end
+
+		class Tee < Plan
+			attr_accessor :level
+			attr_accessor :other
+			attr_accessor :delay
+
+			def initialize(config = {})
+				config = { nick: config } unless config.is_a? Hash || config.is_a?(Spot)
+				config = { other: config } unless config.is_a? Hash
+				super config
+
+				@level ||= :info
+			end
+
+			def initialize_copy(other)
+				@level = other.level.identical_copy
+				@delay = other.delay.identical_copy
+			end
+
+			def on_enter(key, val)
+				log_   = log
+				level_ = level
+				sleep delay.to_i if delay
+				if log_ && level_
+					cur_name = current_name
+					key_str  = Andromeda::Impl::To_S.short_s key
+					val_str  = Andromeda::Impl::To_S.short_s val
+					log_str  = "#{to_s}.#{cur_name}(#{key_str}, #{val_str})"
+					tags.each_pair { |k, v|	log_str << " #{k}=#{Andromeda::Impl::To_S.short_s(v)}" }
+					log_str << " tid=0x#{Thread.current.object_id.to_s(16)}"
+					log_.send level, log_str
+				end
+				other_ = other
+				other_ << val if other_
+				super key, val
+			end
+		end
+
+		class Targeting < Plan
+			attr_accessor :targets
+
+			def initialize(config = {})
+				super config
+				@targets ||= {}
+			end
+
+			def target_values ; t = targets ; t.values rescue t end
+		end
+
+		class Broadc < Targeting
+			def on_enter(key, val)
+				target_values { |t| intern(t) << val rescue nil }
+			end
+		end
+
+		class Switch < Targeting
+			def on_enter(key, val)
+				(intern(key) rescue exit) << val rescue nil
+			end
+		end
+
+		class SinglePlan < Plan
+	    def init_guide ; Guides::SinglePoolGuide.new end
+		end
+
+		class InlineKeyRouter < SinglePlan
+			def key_spot(name, key) ; key end
+		end
+
+		class Gatherer < SinglePlan
+			include Transf
+		end
+
+		class Reducer < Gatherer
+			attr_accessor :state
+			attr_accessor :reducer
+
+			attr_spot :new_state
+
+			def on_enter(key, val)
+				reducer_ = reducer
+
+				state_   = state
+				new_     = reducer_.call state_, key, val
+				unless new_ == state_
+					state = new_
+					new_state << state if new_state
+				end
+			end
+		end
+
+		class FileReader < Plan
+			attr_reader :path
+			attr_reader :mode
+
+			def initialize(config = {})
+				super config
+				@mode ||= init_mode
+			end
+
+			def data_tag(name, key, val, tags_in)
+				tags_out         = super
+				tags_out[:first] = val.first rescue 0
+				tags_out[:last]  = val.last rescue -1
+				tags_out
+			end
+
+			def init_mode ; 'r' end
+
+			protected
+
+			def on_enter(key, val)
+				file = File.open path, mode
+				begin
+						file.seek tags[:first]
+						tags[:last] = file.size - 1 if tags[:last] < 0
+						tags[:num]  = tags[:last] - tags[:first]
+						if block_given? then yield file else super key, val end
+				ensure
+					file.close
+				end
+			end
+
+		end
+
+		class FileChunker < FileReader
+			attr_reader :num_chunks
+
+			def initialize(config = {})
+				super config
+				@num_chunks ||= Guides::PoolGuide.num_procs
+			end
+
+			def on_enter(key, val)
+				num_c = num_chunks
+				super key, val do |f|
+					fst = tags[:first]
+					lst = tags[:last]
+					sz  = tags[:num] / num_c rescue 1
+					sz  = 1 if sz < 0
+					while fst <= lst
+						nxt = fst + sz
+						nxt = lst if nxt > lst
+						exit << Range.new(fst, nxt)
+						fst = nxt + 1
+					end
+				end
+			end
+		end
+
+	end
+end

data/lib/andromeda/map_reduce.rb

@@ -0,0 +1,3 @@
+module Andromeda
+	# unimplemented
+end

data/lib/andromeda/plan.rb

@@ -0,0 +1,130 @@
+module Andromeda
+
+  class Plan < Impl::ProtoPlan
+
+    meth_spot :enter
+    attr_spot :errors
+
+    signal_spot :errors
+
+    attr_accessor :log
+    attr_accessor :marker
+    attr_accessor :nick
+
+    attr_accessor :error_level
+
+    attr_accessor :trace_enter
+    attr_accessor :trace_exit
+
+
+    def initialize(config = {})
+      super config
+      @trace_enter ||= init_trace_hash :enter
+      @trace_exit  ||= init_trace_hash :emit
+      @error_level ||= :error
+    end
+
+    def initialize_copy(other)
+      super other
+      @trace_enter = other.trace_enter.identical_copy
+      @trace_exit  = other.trace_exit.identical_copy
+      @error_level = other.error_level.identical_copy
+      @nick        = other.nick.identical_copy
+    end
+
+    def tap ; yield self end
+
+    def log ; @log = DefaultLogger.instance end
+    def mark ; @mark = Id.zero unless @mark ; @mark end
+
+    def on_enter(k, v)
+      exit_ = exit
+      exit_ << v if exit_
+    end
+
+    def to_short_s
+      super_ = super()
+      nick_  = nick
+      if nick_
+        then "#{super_} aka: #{Impl::To_S.short_s(nick_)}"
+        else super_ end
+    end
+
+    protected
+
+    def transport_data name, track, meth, key, val, tags_in
+      scope       = tags_in[:scope]
+      enter_level = trace_level trace_enter, name
+      exit_level  = trace_level trace_exit, name
+      details     = { name: name, plan: self, track: track, key: key, val: val }
+      track.follow(scope) do
+        begin
+          trace :enter, enter_level, name, details if enter_level
+          deliver_data name, meth, key, val, tags_in
+          trace :exit, exit_level, name, details if exit_level
+        rescue Exception => e
+          uncaught_exception name, key, val, e
+        end
+      end
+    end
+
+    def init_trace_hash(kind) ; {} end
+
+    def trace_level(h, name) ; if h.is_a?(Symbol) then h else (h[name] rescue nil) end end
+
+    def trace(kind, level, name, details)
+      log.send level, InfoMsg.str("TRACE :#{kind} :#{name}", details) if log
+    end
+
+    def deliver_data(name, meth, k, v, tags_in)
+      update_mark
+      tags.update tags_in
+      meth.call k, v
+    end
+
+    def signal_error(e)
+      errors_ = errors
+      errors_ << e if errors_
+    end
+
+    def signal_uncaught(e)
+      log.send error_level, e rescue nil
+      signal_error e
+    end
+
+    def reset_mark(new_mark)
+      tags[:mark] = if new_mark then new_mark else Id.zero end
+    end
+
+    def mark ; tags[:mark] end
+
+    def check_mark
+      mark_ = mark
+      raise RuntimeError, 'Invalid mark' if mark_ && !mark_.zero?
+    end
+
+    def update_mark
+      marker_ = marker
+      if marker_ && !marker_.zero?
+        mark_ = mark
+        if mark_
+          then reset_mark mark_.xor(marker_)
+          else reset_mark mark_ end
+      end
+    end
+
+    def uncaught_exception(name, key, value, e)
+      begin
+        details = { name: name, key: key, val: value, cause: e }
+        info    = InfoMsg.str 'Uncaught exception', details
+        err     = ExecError.new(info)
+        err.set_backtrace e.backtrace
+        signal_uncaught e
+      rescue Exception => e2
+        details[:cause] = e2
+        log.error InfoMsg.str('Failure handling uncaught exception', details) rescue nil
+      end
+    end
+  end
+
+end

data/lib/andromeda/pool_guide.rb

@@ -0,0 +1,70 @@
+module Andromeda
+
+  module Guides
+
+    class PoolGuide < Guide
+      attr_reader :max_procs
+      attr_reader :pool_track
+
+      # @return [Fixnum] number of processors as determined by Facter
+      def self.num_procs
+        @num_procs = Facter.sp_number_processors.strip.to_i unless defined?(@num_procs)
+        @num_procs
+      end
+
+      def initialize(num_procs = nil)
+        num_procs  = PoolGuide.num_procs unless num_procs
+        raise ArgumentError unless num_procs.is_a?(Fixnum)
+        raise ArgumentError unless num_procs > 0
+        @max_procs  = num_procs
+        @pool_track = PoolTrack.new ThreadPool.new(@max_procs)
+      end
+
+      def track(spot, label, suggested_track = nil)
+        return suggested_track if suggested_track
+        return @pool_track
+      end
+
+      def pack(plan, track, was_suggested = false)
+        return plan if plan.frozen?
+        return plan.identical_copy if was_suggested
+        if max_procs > 1 then plan.identical_copy else plan end
+      end
+    end
+
+    class PoolTrack
+      include DispatchingTrack
+
+      attr_reader :pool
+
+      def initialize(pool)
+        @pool = pool
+      end
+
+      protected
+
+      def process(&thunk)
+        # DefaultLogger.instance.info ":enter #{pool.inspect}"
+        pool.process &thunk
+        # DefaultLogger.instance.info ":exit #{pool.inspect}"
+      end
+    end
+
+    class SharedPoolGuide < PoolGuide
+      include Singleton
+
+      def initialize
+        super PoolGuide.num_procs
+      end
+    end
+
+    class SinglePoolGuide < PoolGuide
+      def initialize ; super 1 end
+    end
+
+    class SharedSinglePoolGuide < SinglePoolGuide
+      include Singleton
+    end
+
+  end
+end