deadly_serious 1.0.2 → 2.0.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c84a9aa66532d1b19c770ebb1d226855c073fd03
-  data.tar.gz: 9390c5043f135abd7c6a7c02d713853770cc51f8
+  metadata.gz: 78ea6f0fb905d3b08feef450651add4e28b7ed69
+  data.tar.gz: 3bfb8bba7ca19b826ed1cfdefbb81cde2453eb33
 SHA512:
-  metadata.gz: 2e70c78e33a1ccbdab49e4bca8dff082f63bcae6f3ee57d0586bd46c2b1cf1ad3212e9d881f25b543ee334dcaa34f74810c4f6fc03a1ac9a2406e850f6d670d8
-  data.tar.gz: a7aede2aa595009185a0752906d9958925fd50cc367d5835fb566b49fc41ce1d84f0f2fd03accba0c6ec68eb57d0df85db83dcb96d2123b8f1bd906729805ca8
+  metadata.gz: 83cccbcf342d6e331f8bb050157446fef59a680e5968a8d00a1b21323d976d20f301a5844e899f1031d4cc1d0e049a04b47f7c11eef5214a58f1f552e8f05c6b
+  data.tar.gz: 3afb1d45bfc69a4721fb981949bb63e1b02f7a3765a417b8fe9eb2ad5adb9d60a4d81f51e3194d45a61466ebfd02e8040b5666e21768c4e10aca365b527901f2

data/Guardfile

@@ -1,5 +1,5 @@
-guard :rspec, { all_on_start: true, keep: true, all_after_pass: true, run_all: { cmd: 'rspec -f progress' } } do
-  watch(%r{^spec/.+_spec\.rb$})
+guard :rspec, cmd: 'bundle exec rspec', all_on_start: true, keep: true, all_after_pass: true, run_all: { cmd: 'bundle exec rspec -f progress' } do
+watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
   watch('lib/deadly_serious.rb')  { "spec" }

data/deadly_serious.gemspec

@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'oj', '~> 2.0'
   spec.add_dependency 'multi_json', '~> 1.0'
+  spec.add_dependency 'rbczmq', '~> 1.7', '>= 1.7.9'
 end

data/lib/deadly_serious.rb

@@ -1,17 +1,18 @@
 require 'multi_json'
 require 'fileutils'
-require 'shellwords'
+require 'rb-inotify'
+require 'rbczmq'
 require 'deadly_serious/version'
-require 'deadly_serious/engine/open_io'
+require 'deadly_serious/engine/file_monitor'
 require 'deadly_serious/engine/json_io'
 require 'deadly_serious/engine/channel'
 require 'deadly_serious/engine/auto_pipe'
 require 'deadly_serious/engine/commands'
-require 'deadly_serious/engine/pipeline'
 
-Dir[File.dirname(__FILE__) + '/deadly_serious/engine/*.rb'].each do |file|
-  require File.dirname(file) + '/' + File.basename(file, File.extname(file))
-end
+require 'deadly_serious/engine/config'
+require 'deadly_serious/engine/ruby_object_container'
+require 'deadly_serious/engine/so_command_container'
+require 'deadly_serious/engine/pipeline'
 
 # Loading all predefined processes
 Dir[File.join(File.dirname(__FILE__), 'deadly_serious', 'processes', '*.rb')].each do |file|

data/lib/deadly_serious/engine/auto_pipe.rb

@@ -1,39 +1,51 @@
 class DeadlySerious::Engine::AutoPipe
-  TEMPLATE = '%s.connection.%04d'
+  TEMPLATE = 'pipe.%s'
 
-  def initialize
-    @net_id = 0
-    @connection_stack = []
-    @counter = Hash.new { |h, k| h[k.to_sym] = 0}
-  end
+  class Counter
+    TEMPLATE = '%04d'
 
-  def on_subnet
-    @net_id += 1
-    @connection_stack << sprintf('%04d', @net_id)
-    yield
-  ensure
-    @connection_stack.pop
-  end
+    def initialize
+      @counter = 0
+    end
+
+    def next
+      @counter += 1
+      last
+    end
+
+    def last
+      format(TEMPLATE, @counter)
+    end
 
-  def net_id
-    (@connection_stack.last || 'top').to_sym
+    def zero?
+      @counter == 0
+    end
   end
 
-  def counter
-    @counter[net_id]
+  def initialize
+    @counters = [Counter.new]
   end
 
   def next
-    advance_counter
+    current_counter.next
     last
   end
 
   def last
-    sprintf(TEMPLATE, net_id, counter)
+    return nil if current_counter.zero?
+    format(TEMPLATE, @counters.map(&:last).join('.'))
+  end
+
+  def on_subnet
+    @counters << Counter.new
+    yield
+  ensure
+    @counters.pop
   end
 
   private
-  def advance_counter
-    @counter[net_id] += 1
+
+  def current_counter
+    @counters.last
   end
 end

data/lib/deadly_serious/engine/channel.rb

@@ -1,140 +1,25 @@
-require 'socket'
-require 'deadly_serious/engine/lazy_io'
+require 'deadly_serious/engine/channel/socket_channel'
+require 'deadly_serious/engine/channel/file_channel'
+require 'deadly_serious/engine/channel/pipe_channel'
 
 module DeadlySerious
   module Engine
-    # Fake class, it's actually a factory ¬¬
-    module Channel
-      def self.new(name)
-        matcher = name.match(/^(>)?(.*?)(?:(:)(\d{1,5}))?$/)
-        if matcher[1] == '>'
-          FileChannel.new(matcher[2], @data_dir)
-        elsif matcher[3] == ':'
-          SocketChannel.new(matcher[2], matcher[4].to_i)
-        else
-          PipeChannel.new(matcher[2], @pipe_dir)
-        end
-      end
-
-      def self.config(data_dir, pipe_dir, preserve_pipe_dir)
-        @data_dir = data_dir
-        @pipe_dir = pipe_dir
-        @preserve_pipe_dir = preserve_pipe_dir
-      end
-
-      def self.setup
-        FileUtils.mkdir_p(@pipe_dir) unless File.exist?(@pipe_dir)
-      end
-
-      def self.teardown
-        if !@preserve_pipe_dir && File.exist?(@pipe_dir)
-          FileUtils.rm_r(@pipe_dir, force: true, secure: true)
-        end
-      end
-
-      def self.create_pipe(pipe_name)
-        new(pipe_name).create
-      end
-    end
 
-    class FileChannel
-      attr_reader :io_name
-
-      def initialize(name, directory)
-        if name =~ /^\//
-          # Absolute file path
-          @io_name = name
-        else
-          # relative file path (relative to data_dir)
-          @io_name = File.join(directory, name)
-        end
-      end
-
-      def create
-        `touch '#{@io_name}'` unless File.exist?(@io_name)
-        @io_name
-      end
-
-      def open_reader
-        fail %(File "#{@io_name}" not found) unless File.exist?(@io_name)
-        open(@io_name, 'r')
-      end
-
-      def open_writer
-        fail %(File "#{@io_name}" not found) unless File.exist?(@io_name)
-        open(@io_name, 'w')
-      end
-
-      def io
-        LazyIo.new(self)
-      end
-    end
+    CHANNELS = [SocketChannel, FileChannel, PipeChannel]
 
-    class PipeChannel
-      attr_reader :io_name
-
-      def initialize(name, directory)
-        if name =~ /^\//
-          # Absolute pipe path
-          @io_name = name
-        else
-          # relative pipe path (relative to pipe_dir)
-          @io_name = File.join(directory, name)
-        end
-      end
-
-      def create
-        `mkfifo '#{@io_name}'` unless File.exist?(@io_name)
-        @io_name
-      end
-
-      def open_reader
-        fail %(Pipe "#{@io_name}" not found) unless File.exist?(@io_name)
-        open(@io_name, 'r')
-      end
-
-      def open_writer
-        fail %(Pipe "#{@io_name}" not found) unless File.exist?(@io_name)
-        open(@io_name, 'w')
-      end
-
-      def io
-        LazyIo.new(self)
-      end
-    end
-
-    class SocketChannel
-      def initialize(host, port)
-        @host, @port = host, port
-        @retry_counter = 3
-      end
-
-      def io_name
-        "#{@host}@#{@port}"
-      end
-
-      def create
-        # Do nothing
-      end
-
-      def open_reader
-        TCPSocket.new(@host, @port)
-      rescue Exception => e
-        @retry_counter -= 1
-        if @retry_counter > 0
-          sleep 1 and retry
-        else
-          raise e
-        end
-      end
-
-      def open_writer
-        server = TCPServer.new(@port)
-        server.accept
+    # Fake class, it's actually a factory ¬¬
+    #
+    # name = '>xxx'     # File
+    # name = 'xxx'      # Pipe
+    # name = 'xxx:999'  # Socket
+    # name = '!xxx:999' # 0MQueue
+    module Channel
+      def self.new(name, config)
+        of_type(name).new(name, config)
       end
 
-      def io
-        LazyIo.new(self)
+      def self.of_type(name)
+        CHANNELS.map { |channel| channel.of_type(name) }.compact.first
       end
     end
   end

data/lib/deadly_serious/engine/channel/file_channel.rb

@@ -0,0 +1,50 @@
+module DeadlySerious
+  module Engine
+    class FileChannel
+      include Enumerable
+
+      REGEXP = /\A>(.*?)\z/
+
+      attr_reader :io_name
+
+      def self.of_type(name)
+        self if name.match(REGEXP)
+      end
+
+      def initialize(name, config)
+        @io_name = self.class.io_name_for(name, config)
+      end
+
+      def each
+        return enum_for(:each) unless block_given?
+        open(io_name, 'r') { |file| file.each_line { |line| yield line } }
+      end
+
+      def <<(data)
+        @writer ||= open(@io_name, 'w')
+        @writer.print(data)
+        self
+      end
+
+      def flush
+        @writer.flush if @writer
+      end
+
+      def close
+        @writer.close if @writer
+      end
+
+      def self.io_name_for(name, config)
+        matcher = name.match(REGEXP)
+        file_name = matcher[1]
+        config.file_path_for(file_name)
+      end
+
+      def self.create(name, config)
+        io_name = io_name_for(name, config)
+        `touch '#{io_name}'` unless File.exist?(io_name)
+        io_name
+      end
+    end
+  end
+end

data/lib/deadly_serious/engine/channel/pipe_channel.rb

@@ -0,0 +1,59 @@
+module DeadlySerious
+  module Engine
+    class PipeChannel
+      include Enumerable
+
+      REGEXP = /\A(.*?)\z/
+
+      attr_reader :io_name
+
+      def self.of_type(name)
+        self if name.match(REGEXP)
+      end
+
+      def initialize(name, config)
+        @io_name = self.class.io_name_for(name, config)
+      end
+
+      def each
+        return enum_for(:each) unless block_given?
+        open(io_name, 'r') { |file| file.each_line { |line| yield line } }
+      end
+
+      def <<(data)
+        @writer ||= open(@io_name, File::WRONLY)
+        @writer.print(data)
+        self
+      end
+
+      def flush
+        @writer.flush if @writer
+      end
+
+      def close
+        @writer.close if @writer
+      end
+
+      def self.io_name_for(name, config)
+        matcher = name.match(REGEXP)
+        pipe_name = matcher[1]
+        config.pipe_path_for(pipe_name)
+      end
+
+      def self.create(name, config)
+        # Redirecting to /dev/null when we test the
+        # file existence. It STILL tries to create
+        # the pipe due concurrency :(
+        # Not good >_<
+        io_name = io_name_for(name, config)
+        `mkfifo '#{io_name}' 2>/dev/null` unless File.exist?(io_name)
+        io_name
+      end
+
+      private
+
+      def retries(times = 3, sleep = 0.5)
+      end
+    end
+  end
+end

data/lib/deadly_serious/engine/channel/socket/master_mind.rb

@@ -0,0 +1,42 @@
+module DeadlySerious
+  module Engine
+    class MasterMind
+      attr_reader :factory
+
+      def self.new_instance
+        pid = Process.pid
+        if @master.nil? || @master[:pid] != pid
+          @master = {pid: pid, master: self.new}
+        end
+        @master[:master]
+      end
+
+      def initialize
+        @factory = ZMQ::Context.new
+        @counter = 1
+        @minions = []
+      end
+
+      def spawn_minion
+        minion_brain = yield(@factory, @counter)
+        @counter += 1
+        Minion.new(self, minion_brain).tap { |m| @minions << m }
+      rescue ZMQ::Error => e
+        raise if e.message !~ /has been destroyed/
+        @factory = ZMQ::Context.new
+        retry
+      end
+
+      def destroy_body_of(minion)
+        @minions.delete(minion)
+        suicide if @minions.empty?
+      end
+
+      private
+
+      def suicide
+        @factory.destroy
+      end
+    end
+  end
+end

data/lib/deadly_serious/engine/channel/socket/minion.rb

@@ -0,0 +1,24 @@
+module DeadlySerious
+  module Engine
+    class Minion
+      extend Forwardable
+
+      def_delegators :@brain, :send, :recv
+
+      def initialize(mastermind, brain)
+        @mastermind = mastermind
+        @brain = brain
+      end
+
+      def send_to(destiny, msg)
+        @brain.sendm(destiny)
+        @brain.send(msg)
+      end
+
+      def explode
+        @brain.close
+        @mastermind.destroy_body_of(self)
+      end
+    end
+  end
+end