arsenicum 0.2.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a97f7f6c419ed5ba11e0b4cc8ec0551af8400e5e
-  data.tar.gz: 6b3fdcf89f6ff38246d0486fc556ce181d3407c2
+  metadata.gz: 227759f26fc6a576603f6ea5454a801b952c61e5
+  data.tar.gz: c6ce1168091c355e7a2258a1f181c28c18899121
 SHA512:
-  metadata.gz: 2ec82a578e2770bac8bc5c10c125ad4681a648a6da7d331d79abb877417ea1549e3047f699042045bc3997f2116f4aa317b93fd45138d0e151ba32c4b2213772
-  data.tar.gz: 948332737fc834471d3330ab0f2572f9fcb6e2a38e5cd53f2550e36021e065ad16f93e59c548f8ee24c9090bab9ecd52410ef9e91a16332db5b98d50aad0bb68
+  metadata.gz: de846aa8417608539d5d28a85cb66a8c3f6737d25300474d6adf6fa339185de70b9a115c8ec509ce864b1dfa013da41f5e253055de17eb0a9792b1cda5b9e59c
+  data.tar.gz: 928123fa45f80afb3ae8f98117b3b00da665f42017e77f46d80279f7aba28c801d770e23f8768a365eb61ea668e0d94c0d7c97f6d23143b8efde10ba6b5d31b3

data/lib/arsenicum/cli.rb

@@ -1,3 +1,5 @@
+require 'optparse'
+
 class Arsenicum::CLI
   autoload  :RailsCLI, 'arsenicum/cli/rails_cli'
 

data/lib/arsenicum/core/io_helper.rb

@@ -1,34 +1,71 @@
 module Arsenicum::Core::IOHelper
-  def write_string(io, string)
-    string_to_write = string.dup
-    string_to_write.force_encoding 'BINARY'
+  TYPE_INT    = "\xa0".force_encoding(Encoding::BINARY).freeze
+  TYPE_STRING = "\xfc".force_encoding(Encoding::BINARY).freeze
 
-    io.write [string.length].pack('N').force_encoding 'BINARY'
-    io.write string
-  end
+  def write_message(io, *items)
+    buffer = StringIO.new
+    buffer.set_encoding Encoding::BINARY
+    buffer.seek 4# length of integer.
 
-  def read_string(io, encoding: 'UTF-8')
-    bytes_for_length = read_from io, 4
-    length = bytes_for_length.unpack('N').first
-    return if length == 0
+    items.each do |item|
+      case item
+        when Fixnum
+          buffer.write  TYPE_INT
+          buffer.write [item].pack('N')
+        when String, Symbol
+          item = item.to_s.force_encoding Encoding::BINARY
+          buffer.write  TYPE_STRING
+          length = item.length
+          buffer.write int2bin(length)
+          buffer.write  item
+      end
+    end
+    buffer.seek   0
+    buffer.write  int2bin(buffer.length - 4)
 
-    read_from(io, length).tap{|s|s.force_encoding encoding}
+    io.write      buffer.string
   end
 
-  def write_code(io, integer_value)
-    value = [integer_value].pack('C')
-    io.write value
-  end
+  def read_message(io, encoding: Encoding::UTF_8)
+    bytes_for_length = read_from io, 4
+    length = bin2int(bytes_for_length)
+    return [] if length == 0
+
+    bytes = read_from(io, length)
+    ptr = 0
 
-  def read_code(io)
-    string = read_from io, 1
-    string.unpack('C').first
+    result = []
+    while ptr < bytes.length
+      type_byte = bytes[ptr]
+      ptr += 1
+      case type_byte
+        when TYPE_INT
+          result << bin2int(bytes[ptr...ptr + 4])
+          ptr += 4
+        when TYPE_STRING
+          length = bin2int(bytes[ptr...ptr + 4])
+          ptr += 4
+          next result << '' if length == 0
+          result << bytes[ptr...ptr + length].force_encoding(encoding)
+          ptr += length
+      end
+    end
+    result
   end
 
   private
   def read_from(io, length)
     bytes = io.read length
     raise Arsenicum::IO::EOFException unless bytes
-    bytes
+    bytes.force_encoding Encoding::BINARY
   end
+
+  def int2bin(number)
+    [number].pack('N')
+  end
+
+  def bin2int(bytes)
+    bytes.unpack('N').first
+  end
+
 end

data/lib/arsenicum/core/worker.rb

@@ -4,8 +4,19 @@ class Arsenicum::Core::Worker
   include Arsenicum::Core::Commands
   include Arsenicum::Core::IOHelper
 
-  attr_reader :pid, :in_parent, :out_parent, :thread,
-              :in_child,  :out_child, :active, :broker, :serializer,  :formatter, :index
+  RESULT_SUCCESS  = 0
+  RESULT_FAILURE  = 0x80
+
+  CONTROL_STOP    = 0xFF
+  CONTROL_PING    = 0x30
+
+  attr_reader :pid,
+              :in_parent,       :out_parent,      :in_child,      :out_child,
+              :ctrl_in_parent,  :ctrl_out_parent, :ctrl_in_child, :ctrl_out_child,
+              :work_at,
+              :thread,
+              :active, :broker, :serializer,  :formatter, :index,
+              :state
   alias_method :active?, :active
 
   def initialize(broker, index, worker_configuration)
@@ -14,55 +25,21 @@ class Arsenicum::Core::Worker
     @serializer = worker_configuration[:serializer]
     @formatter  = worker_configuration[:formatter]
     @thread     = InvokerThread.new(self)
+    @work_at    = :parent
+    @state      = :parent
   end
 
   def run
-    (@in_parent, @out_child) = open_binary_pipes
-    (@in_child, @out_parent) = open_binary_pipes
+    (@in_parent, @out_child)            = open_binary_pipes
+    (@in_child, @out_parent)            = open_binary_pipes
+    (@ctrl_in_parent, @ctrl_out_child)  = open_binary_pipes
+    (@ctrl_in_child,  @ctrl_out_parent) = open_binary_pipes
 
-    @pid = fork do
-      $0 = "arsenicum[worker][#{index}]"
-      [in_parent, out_parent].each(&:close)
+    @pid = fork &method(:run_in_child)
+    return unless @pid
 
-      begin
-        loop do
-          begin
-            Arsenicum::Logger.debug {log_message_for '[child]to read initial command'}
-            command = read_code in_child
-            Arsenicum::Logger.debug {log_message_for '[child]Command: 0x%02x' % command}
-            break if command == COMMAND_STOP
-            task_id_string  = read_string in_child
-            content         = read_string in_child
-          rescue Arsenicum::IO::EOFException
-            # Interrupted request: No required GC.
-            break
-          end
-
-          task_id         = task_id_string.to_sym
-          task            = broker[task_id]
-
-          parameters      = deserialize content
-
-          begin
-            Arsenicum::Logger.info {log_message_for "[child]Task start"}
-            Arsenicum::Logger.info {log_message_for "[child]Parameters: #{parameters.inspect}"
-            task.run      *parameters
-            Arsenicum::Logger.info {log_message_for "[child]Task success"}
-            write_code    out_child,  0
-          rescue Exception => e
-            Arsenicum::Logger.error {log_message_for "[child]Task Failure with #{e.class.name}#{":#{e.message}" if e.message}"}
-            write_code    out_child,  1
-            write_string  out_child,  Marshal.dump(e)
-          end
-        end
-      ensure
-        [in_child, out_child].each do |io|
-          begin io.close rescue nil end
-        end
-      end
-    end
     @active = true
-    [in_child, out_child].each(&:close)
+    [in_child, out_child, ctrl_in_child, ctrl_out_child].each(&:close)
     pid
   end
 
@@ -72,32 +49,104 @@ class Arsenicum::Core::Worker
     end
   end
 
+  def ask(task_id, *parameters)
+    write_message                   out_parent, task_id,  serialize(parameters)
+    loop do
+      rs, = select([in_parent], [], [], 5)
+      break if rs
+      sleep 0.5
+    end
+
+    result, marshaled_exception = read_message  in_parent
+    return if result == RESULT_SUCCESS
+    raise Marshal.load(marshaled_exception)
+  end
+
   def ask_async(success_handler, failure_handler, task_id, *parameters)
     thread.ask success_handler, failure_handler, task_id, *parameters
   end
 
-  def ask(task_id, *parameter)
-    Arsenicum::Logger.info {log_message_for "Task ID: #{task_id}"}
+  def stop
+    write_message   ctrl_out_parent, COMMAND_STOP
+    Process.waitpid pid
+  end
+
+  private
+  def run_in_child
+    switch_state  :waiting
+    [in_parent, out_parent, ctrl_in_parent, ctrl_out_parent].each(&:close)
+    @work_at      = :child
 
-    write_code    out_parent, COMMAND_TASK
-    write_string  out_parent, task_id.to_s
-    write_string  out_parent, serialize(parameter)
+    hook_signal
 
-    Arsenicum::Logger.debug { log_message_for "Task ID: #{task_id}: Request completed. Begin waiting for the reply." }
+    begin
+      loop do
+        server_loop
+        break unless state == :waiting
+      end
+    ensure
+      [in_child, out_child, ctrl_in_child, ctrl_out_child].each do |io|
+        begin io.close rescue nil end
+      end
+    end
+  end
+
+  def switch_state(state)
+    @state  = state
+    $0      = process_name
+  end
 
-    result = read_code     in_parent
-    return if result == 0
-    raise Marshal.restore(read_string in_parent, encoding: 'BINARY')
+  def server_loop
+    begin
+      rs, = select [in_child, ctrl_in_child], [], [], 0.5
+      return unless rs
+    rescue Interrupt
+      switch_state :interrupted
+      return
+    end
+
+    rs.first == in_child ? handle_request : handle_control
+  end
+
+  def handle_request
+    switch_state  :busy
+    begin
+      task_id_string, content = read_message in_child, encoding: Encoding::UTF_8
+    rescue Arsenicum::IO::EOFException
+      # Interrupted request: No required GC.
+      return
+    end
+
+    task_id         = task_id_string.to_sym
+    task            = broker[task_id]
+    parameters      = content.length == 0 ? [] : deserialize(content)
+
+    begin
+      info message: "Task[#{task_id}] start"
+      info message: "Parameters: #{parameters.inspect}"
+
+      task.run      *parameters
+      info message: 'Task success'
+      write_message out_child,  RESULT_SUCCESS
+    rescue Exception => e
+      error message: "Task #{task_id} Failed", exception: e
+      write_message out_child,  RESULT_FAILURE, Marshal.dump(e)
+    end
   ensure
-    return_to_broker
+    switch_state  :waiting
   end
 
-  def stop
-    write_code    out_parent, COMMAND_STOP
-    Process.waitpid pid
+  def handle_control
+    begin
+      control, = read_message ctrl_in_child
+      case control
+        when CONTROL_STOP
+          thread.stop
+          switch_state  :stopped
+      end
+    end
   end
 
-  private
   def serialize(parameter)
     serializer.serialize(formatter.format(parameter))
   end
@@ -114,14 +163,37 @@ class Arsenicum::Core::Worker
     end
   end
 
+  def process_name
+    "arsenicum[Worker ##{index}] - #{state}"
+  end
+
   def return_to_broker
     broker.get_back_worker self
   end
 
+  [:debug,  :info,  :warn,  :error, :fatal].each do |level|
+    eval <<-SCRIPT, binding, __FILE__, __LINE__ + 1
+    def #{level}(message: nil, exception: nil)
+      Arsenicum::Logger.#{level} do
+        message = "[Worker #\#{index}][\#{work_at}]\#{message}" if message
+        [message, exception]
+      end
+    end
+    SCRIPT
+  end
+
   def log_message_for(message)
     "[Worker ##{object_id}]#{message}"
   end
 
+  def hook_signal
+    [:USR1, :USR2, ].each do |sig|
+      Signal.trap sig do
+        exit 1
+      end
+    end
+  end
+
   class InvokerThread < Thread
     attr_accessor :task_request
     private       :task_request,  :task_request=
@@ -138,19 +210,28 @@ class Arsenicum::Core::Worker
 
           begin
             worker.ask task_id, *parameter
+            info worker, message: "Completed processing: #{task_id}"
             success_handler.call
           rescue Exception => e
-            Arsenicum::Logger.error {log_message_for worker, "Exception: #{e.class.name}"}
+            error worker, exception: e
             failure_handler.call e
           ensure
             self.task_request = nil
+            return_to_broker
           end
         end
       end
     end
 
-    def log_message_for(worker, message)
-      "[Worker ##{worker.object_id}][thread]#{message}"
+    [:debug,  :info,  :warn,  :error, :fatal].each do |level|
+      eval <<-SCRIPT, binding, __FILE__, __LINE__ + 1
+        def #{level}(worker, message: nil, exception: nil)
+          Arsenicum::Logger.#{level} do
+            message = "[Worker #\#{worker.index}][\#{worker.work_at}][thread]\#{message}" if message
+            [message, exception]
+          end
+        end
+      SCRIPT
     end
   end
 end

data/lib/arsenicum/logger.rb

@@ -10,9 +10,9 @@ module Arsenicum::Logger
 
     [:debug, :info, :warn, :error, :fatal].each do |method|
       eval <<-METHOD, binding, __FILE__, __LINE__ + 1
-        def #{method}(*args, &block)
+        def #{method}(&block)
           return unless logger
-          logger.#{method}(*args, &block)
+          logger.#{method} &block
         end
       METHOD
     end

data/lib/arsenicum/main.rb

@@ -1,5 +1,7 @@
 module Arsenicum
   class Main
+    attr_reader :queues
+
     def run(config)
       $0 = 'arsenicum[main]'
 
@@ -18,8 +20,12 @@ module Arsenicum
 
       before_boot(config)
 
-      threads = config.queue_configurations.map{|qc|qc.build.start_async}
+      @queues = config.queue_configurations.map{|qc|qc.build}
+      threads = @queues.map(&:start_async)
       begin
+        sleep 10
+        trap_signal
+
         threads.each(&:join)
       rescue Interrupt
       end
@@ -44,6 +50,13 @@ module Arsenicum
       Arsenicum::Logger.configure config.logger_config
     end
 
+    def trap_signal
+      [:TERM, :INT,].each do |sig|
+        queues.each(&:stop)
+        exit 1
+      end
+    end
+
     autoload  :RailsMain, 'arsenicum/main/rails_main'
   end
 end

data/lib/arsenicum/queue.rb

@@ -13,18 +13,28 @@ class Arsenicum::Queue
   end
 
   def start
-    Arsenicum::Logger.info "[queue]Queue #{name} is now starting"
+    Arsenicum::Logger.info{"[queue]Queue #{name} is now starting"}
     broker.run
-    Arsenicum::Logger.info "[queue]Queue #{name} start-up completed"
+    Arsenicum::Logger.info{"[queue]Queue #{name} start-up completed"}
 
     loop do
-      (message, original_message) = pick
+      begin
+        (message, original_message) = pick
+      rescue => e
+        handle_failure e, original_message
+        next
+      end
+
       next sleep(0.5) unless message
 
       broker.delegate message, -> { handle_success(original_message) }, -> e { handle_failure(e, original_message) }
     end
   end
 
+  def stop
+    broker.stop
+  end
+
   def register(task)
     broker[task.id] = task
   end

data/lib/arsenicum/version.rb

@@ -1,3 +1,3 @@
 module Arsenicum
-  VERSION = '0.2.1.1'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arsenicum
 version: !ruby/object:Gem::Version
-  version: 0.2.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - condor