arsenicum 0.0.1 → 0.1.0

data/lib/arsenicum/core/commands.rb

@@ -0,0 +1,15 @@
+module Arsenicum::Core::Commands
+  COMMAND_STOP = 0xff
+  COMMAND_TASK = 0x10
+
+  class << self
+    private
+    def code_to_string(code)
+      [code].pack('C')
+    end
+  end
+
+  COMMAND_STRING_STOP = code_to_string(COMMAND_STOP)
+  COMMAND_STRING_TASK = code_to_string(COMMAND_TASK)
+
+end

data/lib/arsenicum/core/io_helper.rb

@@ -0,0 +1,34 @@
+module Arsenicum::Core::IOHelper
+  def write_string(io, string)
+    string_to_write = string.dup
+    string_to_write.force_encoding 'BINARY'
+
+    io.write [string.length].pack('N')
+    io.write string
+  end
+
+  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
+
+    read_from(io, length).tap{|s|s.force_encoding encoding}
+  end
+
+  def write_code(io, integer_value)
+    value = [integer_value].pack('C')
+    io.write value
+  end
+
+  def read_code(io)
+    string = read_from io, 1
+    string.unpack('C').first
+  end
+
+  private
+  def read_from(io, length)
+    bytes = io.read length
+    raise Arsenicum::IO::EOFException unless bytes
+    bytes
+  end
+end

data/lib/arsenicum/core/worker.rb

@@ -0,0 +1,91 @@
+require 'weakref'
+
+class Arsenicum::Core::Worker
+  include Arsenicum::Core::Commands
+  include Arsenicum::Core::IOHelper
+
+  attr_reader :pid, :in_parent, :out_parent,
+              :in_child,  :out_child, :active, :broker, :serializer,  :formatter
+  alias_method :active?, :active
+
+  def initialize(broker, worker_configuration)
+    @broker = WeakRef.new broker # avoiding circular references.
+    @serializer = worker_configuration[:serializer]
+    @formatter  = worker_configuration[:formatter]
+  end
+
+  def run
+    (@in_parent, @out_child) = IO.pipe
+    (@in_child, @out_parent) = IO.pipe
+
+    @pid = fork do
+      [in_parent, out_parent].each(&:close)
+
+      begin
+        loop do
+          begin
+            command = read_code in_child
+            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
+            task.run      *parameters
+            write_code    out_child,  0
+          rescue Exception => e
+            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)
+    pid
+  end
+
+  def ask(task_id, *parameter)
+    write_code    out_parent, COMMAND_TASK
+    write_string  out_parent, task_id.to_s
+    write_string  out_parent, serialize(parameter)
+
+    result = read_code     in_parent
+    return if result == 0
+    raise Marshal.restore(read_string in_parent, encoding: 'BINARY')
+  end
+
+  def terminate
+    write_code    out_parent, COMMAND_STOP
+    Process.waitpid pid
+  end
+
+  private
+  def serialize(parameter)
+    serializer.serialize(formatter.format(parameter))
+  end
+
+  def deserialize(string)
+    formatter.parse(serializer.deserialize(string))
+  end
+
+  def trap_signal
+    %w(TERM INT).each do |sig|
+      Signal.trap sig do
+        exit 5
+      end
+    end
+  end
+end

data/lib/arsenicum/formatter.rb

@@ -0,0 +1,127 @@
+require 'date'
+require 'time'
+
+class Arsenicum::Formatter
+  DATE_FORMAT = '%Y-%m-%d'.freeze
+  DATE_TIME_FORMAT = '%Y-%m-%dT%H:%M:%S %Z %z'.freeze
+
+  include Arsenicum::Util
+
+  def format(value)
+    format_for_embedded_classes(value) ||
+        format_by_extension(value) ||
+        format_by_default(value)
+  end
+
+  TYPE_RAW      = 'raw'.freeze
+  TYPE_DATE     = 'date'.freeze
+  TYPE_DATETIME = 'datetime'.freeze
+  TYPE_CLASS    = 'class'.freeze
+  TYPE_ARRAY    = 'array'.freeze
+  TYPE_HASH     = 'hash'.freeze
+  TYPE_ANY      = 'marshal'.freeze
+
+  def format_for_embedded_classes(value)
+    case value
+      when Integer, Float, String, TrueClass, FalseClass, NilClass, Symbol
+        {
+            type: TYPE_RAW,
+            value: value.inspect,
+        }
+      when DateTime, Time
+        {
+            type: TYPE_DATETIME,
+            value: value.strftime(DATE_TIME_FORMAT),
+        }
+      when Date
+        {
+            type: TYPE_DATE,
+            value: value.strftime(DATE_FORMAT),
+        }
+      when Class
+        {
+            type: TYPE_CLASS,
+            value: value.name,
+        }
+      when Array
+        {
+            type: TYPE_ARRAY,
+            values: value.map{|v|format(v)},
+        }
+      when Hash
+        {
+            type: TYPE_HASH,
+            values: value.inject({}){|h, kv|(k,v)=kv;h[k.to_s]=format(v);h},
+        }
+    end
+  end
+
+  def format_by_extension(value)
+    nil
+  end
+
+  def format_by_default(value)
+    {
+        type: TYPE_ANY,
+        value: Marshal.dump(value).unpack('H*').first,
+    }
+  end
+
+  def parse(value)
+    value = normalize_hash(value)
+
+    return eval value[:value] if value[:type] == TYPE_RAW
+    parse_for_embedded_classes(value) ||
+        parse_by_extension(value) ||
+        parse_by_default(value)
+  end
+
+  def parse_for_embedded_classes(value)
+    case value[:type]
+      when TYPE_DATE
+        Date.strptime(value[:value], DATE_FORMAT)
+      when TYPE_DATETIME
+        Time.strptime(value[:value], DATE_TIME_FORMAT)
+      when TYPE_CLASS
+        Module.const_get value[:value].to_sym
+      when TYPE_ARRAY
+        value[:values].map do |value|
+          parse(value)
+        end
+      when TYPE_HASH
+        value[:values].inject({}) do |h, key_value|
+          (key, value) = key_value
+          h[key.to_s.to_sym] = parse(value)
+          h
+        end
+    end
+  end
+
+  def parse_by_extension(_)
+    nil
+  end
+
+  def parse_by_default(value)
+    ::Marshal.restore [value[:value]].pack('H*')
+  end
+
+  class ActiveRecord < ::Arsenicum::Formatter
+    TYPE_ACTIVE_RECORD = 'active_record'.freeze
+
+    def format_by_extension(value)
+      return {
+          type: TYPE_ACTIVE_RECORD,
+          class: value.class.name,
+          id: value.id,
+      } if value.is_a? ActiveRecord::Base
+    end
+
+    def parse_by_extension(value)
+      if value[:type] == TYPE_ACTIVE_RECORD
+        klass = constaitize value[:class].to_sym
+        klass.find value[:id]
+      end
+    end
+  end
+
+end

data/lib/arsenicum/io.rb

@@ -0,0 +1,3 @@
+module Arsenicum::IO
+  class EOFException < StandardError;end
+end

data/lib/arsenicum/main.rb

@@ -0,0 +1,23 @@
+module Arsenicum
+  module Main
+    def run(config_file)
+      config = Arsenicum::Configuration.new
+      config_file = File.expand_path config_file
+
+      script = File.read config_file
+      config.instance_eval script, config_file, 1
+
+      File.open(config.pidfile_path, 'w:UTF-8') do |f|
+        f.puts $$
+      end
+      threads = config.queue_configurations.map{|qc|qc.build.start_async}
+
+      begin
+        threads.each(&:join)
+      rescue Interrupt
+      end
+    end
+
+    module_function :run
+  end
+end

data/lib/arsenicum/routing.rb

@@ -0,0 +1,3 @@
+module Arsenicum::Routing
+  autoload  :Default, 'arsenicum/routing/default'
+end

data/lib/arsenicum/routing/default.rb

@@ -0,0 +1,3 @@
+class Arsenicum::Routing::Default
+
+end

data/lib/arsenicum/serializer.rb

@@ -0,0 +1,3 @@
+module Arsenicum::Serializer
+  autoload  :JSON,  'arsenicum/serializer/json'
+end

data/lib/arsenicum/serializer/json.rb

@@ -0,0 +1,11 @@
+require 'multi_json'
+
+class Arsenicum::Serializer::JSON
+  def serialize(hash)
+    MultiJson.encode(hash)
+  end
+
+  def deserialize(string)
+    MultiJson.decode(string)
+  end
+end

data/lib/arsenicum/task.rb

@@ -1,53 +1,13 @@
-require 'json'
+class Arsenicum::Task
+  attr_reader :id
 
-module Arsenicum
-  class Task
-    include Serialization
-
-    attr_reader :target, :method, :arguments, :timestamp, :message_id, :exception
-
-    def self.parse(raw_message, message_id)
-      message_content = JSON(raw_message)
-
-      timestamp = message_content['timestamp']
-      method = message_content['method_name'].to_sym
-
-      target = restore(message_content['target'])
-      arguments = message_content['arguments'].nil? ? [] :
-        message_content['arguments'].map{|arg|restore(arg)}
-
-      new(target, method, arguments, timestamp, message_id)
-    end
-
-    def initialize(target, method, arguments, timestamp, message_id)
-      @target     = target
-      @method     = method
-      @arguments  = arguments
-      @timestamp  = timestamp
-      @message_id = message_id
-    end
-
-    def prepare_serialization
-      {
-        target: prepare_serialization(target),
-        timestamp: (Time.now.to_f * 1000000).to_i,
-        method_name: method_name,
-        arguments: arguments.nil? ? nil : arguments.map{|arg|prepare_serialization(arg)},
-      }
-    end
-
-    def serialize
-      JSON(prepare_serialization)
-    end
-
-    def execute!
-      target.__send__ method, *arguments
-    rescue Exception => e
-      @exception = e
-    end
+  def initialize(id)
+    @id = id
+  end
 
-    def successful?
-      !exception
-    end
+  def run(*parameters)
+    # Originally do nothing. This will be overridden in the derived classes.
   end
-end
+
+  autoload  :ClassDispatcher, 'arsenicum/task/class_dispatcher'
+end

data/lib/arsenicum/task/class_dispatcher.rb

@@ -0,0 +1,15 @@
+class Arsenicum::Task::ClassDispatcher < Arsenicum::Task
+  attr_reader :target_class,  :target_method
+  private     :target_class,  :target_method
+
+  def initialize(id, options)
+    super(id)
+    @target_class   = options.delete :type
+    @target_method  = options.delete :target
+  end
+
+  def run(*parameters)
+    target_class.new.__send__ target_method, *parameters
+  end
+
+end

data/lib/arsenicum/util.rb

@@ -0,0 +1,48 @@
+module Arsenicum
+  module Util
+    def self.included(base)
+      mod = self
+      base.module_eval{extend mod}
+    end
+
+    def normalize_hash(values)
+      values.inject({}) do |h, kv|
+        (key, value) = kv
+        value = normalize_hash(value) if value.is_a? Hash
+        h.tap{|i|i.merge!(key.to_sym => value)}
+      end
+    end
+
+    def camelcase(stringlike, upcase_first = true)
+      stringlike.to_s.dup.tap do |s|
+        s.gsub!(/_([a-z])/){$1.upcase}
+        s.gsub!(/^([a-z])/){$1.upcase} if upcase_first
+      end.to_sym
+    end
+
+    def classify(stringlike)
+      stringlike.to_s.split(/\/+/).map do |s|
+        camelcase(s)
+      end.join('::')
+    end
+
+    def underscore(stringlike)
+      stringlike.to_s.dup.tap do |s|
+        s.gsub!(/^([A-Z])/){$1.tap(&:downcase!)}
+        s.gsub!(/([A-Z])/){'_' << $1.tap(&:downcase!)}
+      end
+    end
+
+    def constantize(klass, inside: Kernel)
+      if klass.to_s.start_with?('::')
+        klass = klass.to_s[2..-1].to_sym
+        inside = Kernel
+      end
+      klass.to_s.split('::').inject(inside) do |parent, const|
+        parent.const_get const.to_sym
+      end
+    end
+
+    extend self
+  end
+end