andromeda 0.1 → 0.1.2

data/lib/andromeda/commando.rb

@@ -1,106 +0,0 @@
-module Andromeda
-
-	class CommandoBase < Base
-		attr_reader :file
-		attr_reader :path
-	end
-
-	class Commando
-		attr_reader :cmd
-		attr_reader :data
-		attr_reader :time
-
-		def initialize(cmd, data = {})
-			raise ArgumentError unless cmd.kind_of?(Symbol)
-			@cmd  = cmd
-			@data = data
-			@time = Time.now.to_i
-		end
-
-		def to_hash
-			{ :cmd => cmd, :data => data, :time => time }
-		end
-	end
-
-	class CommandoWriter < CommandoBase
-
-		def initialize(config = {})
-			super config
-			@mode ||= 'a+'
-			@file   = File.open path, @mode
-		end
-
-		def on_enter(c)
-			if c == :close
-				file.sync
-				file.fsync rescue nil
-				file.close
-			else
-				c = c.to_hash if c.kind_of?(Commando)				
-				cmd  = c[:cmd]
-				raise ArgumentError, "invalid commando" unless cmd.kind_of?(Symbol)
-				data = c[:data]
-				str  = if data then data.to_json else '' end
-				len  = str.length
-				len += 1 unless str.end_with?('\n')
-				tim  = c[:time] if c[:time]
-				tim  = Time.now unless tim
-				tim  = tim.to_i unless tim.kind_of?(Fixnum)
-				file.write ">>> ANDROMEDA_COMMANDO :#{cmd} TIME #{tim} LEN #{len.to_i} START\n"
-				file.write(str) if data
-				if str.end_with?('\n')
-					file.write "<<< ANDROMEDA_COMMANDO :#{cmd} END\n"
-				else
-					file.write "\n<<< ANDROMEDA_COMMANDO :#{cmd} END\n"
-				end
-			end
-		end
-	end
-
-	class CommandoParser < CommandoBase
-
-		def initialize(config = {})
-			super config
-			@file = File.open path, 'r'
-		end
-
-		def on_enter(c)
-			parser        = dest(:parse)
-			start_matcher = />>> ANDROMEDA_COMMANDO :(\w+) TIME (\d+) LEN (\d+) START/
-			end_matcher   = /<<< ANDROMEDA_COMMANDO :(\w+) END/
-			while (line = file.gets)
-				line  = line.chomp
-				match = start_matcher.match line
-				if match
-					cmd = match[1].to_sym
-					tim = match[2].to_i
-					len = match[3].to_i
-					buf = if len == 0 then '' else file.gets end
-					while buf.length < len
-						log.debug line
-						buf << line
-					end
-					line  = file.gets.chomp
-					match = end_matcher.match line
-					if match
-						end_cmd = match[1].to_sym
-						raise ArgumentError, "command name mismatch between START ('#{cmd}') and END ('#{end_cmd}')" unless cmd == end_cmd
-						raise ArgumentError, "length mismatch" unless len == buf.length
-						h = { :cmd => end_cmd, :data => buf, :time => tim }
-						parser << h
-					else
-						raise ArgumentError, "garbage commando end: '#{line}'"
-					end
-				else
-					raise ArgumentError, "garbage commando start: '#{line}'"
-				end
-			end
-		end
-
-		def on_parse(c)
-			data = c[:data]
-			c[:data] = if data.chomp == '' then nil else JSON::parse(data) end
-			emit << c rescue nil
-		end
-	end
-end

data/lib/andromeda/helpers.rb

@@ -1,134 +0,0 @@
-module Andromeda
-
-
-	class Join < Base
-
-		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_key(chunk) ;  chunk end
-		def state_complete?(state) ; state end
-		def state_updatable?(state, chunk) ;  state[state_key(chunk)] == nil end
-		def state_update(state, chunk) ; state[state_key(chunk)] = chunk end
-
-	    def run(pool, scope, meth, chunk, &thunk)
-	    	@mutex.synchronize {
-	    		state = @state[0]
-	    		while true
-	    			if state_updatable?(state, chunk)
-	    				@state[0] = (state = state_update(state, chunk))
-	    				if state_complete?(state)
-	    					super pool, scope, meth, state, &thunk
-	    					@state[0] = state_init
-	    				end
-						cv.signal
-						return
-	    			else
-	    				cv.wait
-	    			end
-	    		end
-	    	}
-	    end
-
-	end
-
-	class Transf < Base
-		attr_accessor :filter
-		attr_accessor :mapper
-		attr_accessor :reducer
-
-		def output(c)
-			filter_  = filter
-			mapper_  = mapper
-			reducer_ = reducer
-			if !filter_ || filter_.call(c)
-				c = if mapper_ then mapper_.call c else [c] end
-				c = reducer_.call c if reducer_
-				yield c
-			end
-		end
-
-		def on_enter(c)
-			output(c) { |o| super o } 
-		end
-	end
-
-	class Tee < Transf
-		attr_accessor :level
-
-		def init_pool_config ; :local end
-
-		def initialize(config = {})
-			super config
-			@level ||= :info
-		end
-
-		def on_enter(c)
-			log_   = log
-			level_ = level
-			log_.send level, "#{c}" if log_ && level_
-			super c
-		end
-	end
-
-	class Targeting < Transf
-		attr_accessor :targets
-
-		def initialize(config = {})
-			super config
-			@targets ||= {}
-		end
-
-		def target_values
-			t = targets
-			if t.kind_of?(Hash)	then t.values else t end
-		end
-
-		def switch_target(c)
-			switch_ = switch
-			switch_ = switch_.call(c) if switch_
-			targets[switch_]
-		end
-	end
-
-	class Broadc < Targeting
-		def on_enter(c)
-			output(c) do |o|
-				target_values { |t| intern(t) << o rescue nil }
-			end
-		end		
-	end
-
-	class Switch < Targeting
-		attr_accessor :switch
-
-		def on_enter(c)
-			target_ = intern(switch_target c) rescue emit
-			output(c) { |o| target_ << o }
-		end
-	end
-
-	class Router < Targeting
-		def on_enter(c)
-			target_ = intern(switch_target c[0]) rescue emit
-			output(c[1]) { |o| target_ << o }
-		end
-	end
-
-	class FifoBase < Base
-		def init_pool_config ; :fifo end
-	end
-
-	class LocalBase < Base
-		def init_pool_config ; :local end
-	end
-
-end

data/lib/andromeda/join.rb

@@ -1,48 +0,0 @@
-module Andromeda
-
-	# untested as in not at all but should would perfectly fine according to theory
-
-	class Join < Base
-
-		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
-
-		# typical usages need to override these two
-		def state_key(chunk) ; chunk end
-		def state_complete?(state)  state end
-
-		def state_updatable?(state, chunk) ;  state[state_key(chunk)] == nil end
-		def state_update(state, chunk) ; state[state_key(chunk)] = chunk; state end
-
-	    def run(pool, scope, meth, chunk, &thunk)
-	    	@mutex.synchronize do
-	    		state = @state[0]
-	    		while true
-	    			if state_updatable?(state, chunk)
-	    				@state[0] = (state = state_update(state, chunk))
-	    				if state_complete?(state)
-	    					@state[0] = state_init
-							cv.signal
-	    					return super pool, scope, meth, state, &thunk
-	    				else
-	    					cv.signal
-	    					return self
-	    				end
-	    			else
-	    				cv.wait @mutex
-	    			end
-	    		end
-	    	end
-	    end
-
-	end
-end	

data/lib/andromeda/pools.rb

@@ -1,69 +0,0 @@
-module Andromeda
-
-  # Helper class for easily obtaining a thread pool with num_processors threads
-  class PoolSupport
-    # @return [Fixnum] number of processors as determined by Facter
-    def self.num_processors ; Facter.sp_number_processors.strip.to_i end
-
-    # @return [ThreadPool] a new thread pool with num_processors threads
-    def self.new_default_pool ; ThreadPool.new self.num_processors end
-
-    # @return [ThreadPool] a globally shared thread pool with num_processors threads
-    def self.global_pool(reset = false)
-      @pool = self.new_default_pool unless @pool || reset
-      @pool
-    end
-
-    # @return [ThreadPool] of size 1
-    def self.new_single_pool ; ThreadPool.new(1) end
-
-    # @return [ThreadPool] that guarantees fifo processing of requests
-    def self.new_fifo_pool ; new_single_pool end
-  end
-
-  # Fake thread pool that spawns an unlimited number of threads
-  class SpawnPool
-    def process(&block) ; Thread.new &block end
-
-    # @return [SpawnPool] a globally shared SpawnPool instance
-    def self.default_pool
-      @pool ||= SpawnPool.new
-      @pool
-    end
-
-    # Does nothing
-    def shutdown ; end
-  end
-
-  # Caching factory for thread pools
-  class PoolFactory < Hash
-
-    attr_reader :pool_maker
-
-    # @yield [Proc] factory/maker for building thread pools for a given key
-    def initialize(&pool_maker)
-      @pool_maker = pool_maker
-    end
-
-    def [](key)
-      current = super key
-      if ! current
-        current   = pool_maker.call key
-        self[key] = current
-      end
-      current
-    end
-
-    def []=(key, value)
-      raise ArgumentError, "Not a ThreadPool" unless value.respond_to?(:process)
-      super key, value
-    end
-
-    def shutdown
-      values.each { |pool| pool.shutdown }
-    end
-
-    alias_method :process_stage, :[]
-  end
-
-end

data/lib/andromeda/scope.rb

@@ -1,38 +0,0 @@
-require 'atomic'
-
-module Andromeda
-
-	class Scope
-
-		def initialize(init_value = 0)
-			raise ArgumentError unless init_value.kind_of?(Fixnum)
-			@count = Atomic.new init_value
-		end
-
-		def value ; @count.value end
-
-		def enter(amount = 1)
-			raise ArgumentError unless amount.kind_of?(Fixnum)
-			raise ArgumentError unless amount >= 0
-			@count.update { |v| v + amount }
-		end
-
-		def leave(amount = 1)
-			raise ArgumentError unless amount >= 0
-			raise ArgumentError unless amount.kind_of?(Fixnum)
-			@count.update { |v| v - amount }
-		end
-
-		def wait_while(&test)
-			while test.call(value)
-				Thread::pass
-			end
-		end
-
-		def wait_for(val = 0)
-			raise ArgumentError unless val.kind_of?(Fixnum)
-			wait_while { |v| v != val }
-		end
-	end
-
-end