arsenicum 0.0.1 → 0.1.0

data/lib/arsenicum/actor.rb

@@ -1,14 +0,0 @@
-module Arsenicum
-  class Actor
-    attr_reader :queue
-
-    def initialize(queue)
-      @queue = queue
-    end
-
-    def process(task)
-      task.execute
-      queue.update_message_status(task.message_id, task.successful?)
-    end
-  end
-end

data/lib/arsenicum/cli.rb

@@ -1,54 +0,0 @@
-require 'optparse'
-require 'yaml'
-
-module Arsenicum
-  class CLI
-    autoload :Rails, 'arsenicum/cli/rails'
-
-    attr_reader :configuration
-
-    def initialize(argv)
-      @configuration = option_parser.parse!(argv)
-    end
-
-    def boot
-      Arsenicum::Server.start(Arsenicum::Configuration.new(configuration))
-    end
-
-    class OptionParser
-      def initialize
-        @values = {}
-        @parser = ::OptionParser.new
-      end
-
-      def register(*args)
-        block = args.pop
-        block = block.to_proc unless block.is_a? Proc
-
-        if block.arity == 2
-          @parser.on(*args) {|v|block.call(v, @values)}
-        else
-          @parser.on(*args) {|v|@values.merge! block.call(v)}
-        end
-        self
-      end
-
-      def parse!(argv)
-        @parser.parse! argv
-        @values
-      end
-    end
-
-    private
-    def option_parser
-      OptionParser.new.
-        register("-c", "--config-file=YAML", -> v {YAML.load(File.read(v, encoding: "UTF-8"))}).
-        register("-t", "--default-concurrency=VALUE", -> v {{default_concurrency: v.to_i}}).
-        register("-q", "--queue-type=QUEUE_TYPE", -> v{{queue_type: v.to_s}}).
-        register("--queue-engine-config=CONFIGKEY_VALUE", -> v, config {
-          config[:engine_config] ||= {};(key, value) = v.split(':');config[:engine_config][key.to_sym] = value.to_s
-        })
-    end
-
-  end
-end

data/lib/arsenicum/cli/rails.rb

@@ -1,26 +0,0 @@
-module Arsenicum
-  class CLI::Rails < CLI
-    def boot
-      ENV['RACK_ENV'] = (ENV['RAILS_ENV'] ||= (configuration[:rails_env] || 'development'))
-      rootdir = ENV['RAILS_ROOT'] || configuration[:dir] || Dir.pwd
-      Dir.chdir rootdir
-
-      if configuration[:background] && !configuration[:pidfile]
-        configuration[:pidfile] = "#{rootdir}/tmp/pids/arsenicum.pid"
-      end
-
-      load File.join(rootdir, 'config/environment.rb')
-      Arsenicum::Configuration.reconfigure configuration
-      Arsenicum::Server.start
-    end
-
-    def option_parser
-      OptionParser.new.register("-e", "--environment=ENVIRONMENT", -> v { {rails_env: v} }).
-        register("-d", "--dir=DIRECTORY", -> v { {dir: v} }).
-        register("-p", "--pidfile=PID_FILE", -> v { { pidfile: v } }).
-        register("-l", "--log-file=LOG_FILE", -> v { { log_file: v } }).
-        register("-D", "--daemon", -> v { { background: true } }).
-        register("-L", "--log-level=LOG_LEVEL", -> v { {log_level: v} })
-    end
-  end
-end

data/lib/arsenicum/queue.rb

@@ -1,58 +0,0 @@
-require 'json'
-
-module Arsenicum
-  class Queue
-    DEFAULT_CONCURRENCY = 5
-
-    attr_reader :name, :concurrency, :queue_methods, :queue_classes, :logger
-
-    def initialize(name, config = {}, logger = nil)
-      @name = name
-      @concurrency = (config.delete(:concurrency) || DEFAULT_CONCURRENCY).to_i
-      @queue_methods = config.delete(:methods)
-      @queue_classes = config.delete(:classes)
-      @logger = logger || Logger.new(STDOUT)
-      configure(config)
-    end
-
-    def put(hash)
-      json = JSON(hash.merge(timestamp: (Time.now.to_f * 1000000).to_i.to_s))
-      logger.debug { "Queue Put[#{name}] values #{json}" }
-      put_to_queue(json)
-    end
-
-    ######################################################
-    #
-    # Queue must implement the methods as below:
-    #   1. put_to_queue(json): putting the actual message
-    #     into the queue backend. The argument of this
-    #     method will be the JSON string.
-    #   2. poll: polling the queue and retrieve the
-    #     message information. This method is expected to
-    #     return the message Hash. Its keys and values
-    #     are expected as below:
-    #       :message_body: the raw string that was pushed
-    #         via the :put_to_queue method.
-    #       :message_id: the identifier of this message.
-    #         This is usually used to update the status of
-    #         message on the queue backend.
-    #   3. update_message_status(message_id, successful, json):
-    #     Update the status of the message. Arguments are
-    #     as following:
-    #       message_id: The identifier of the message to
-    #         be updated. This value will be set as the
-    #         :message_id of the return value of :poll.
-    #       successful: The result of the process done.
-    #         If the process complete successfully,
-    #         this argument will be set true. Otherwise,
-    #         this will be false.
-    #       json: the message received.
-    #   4. create_queue_backend - optional
-    #     Register the queue itself on its backend.
-    #     This will be invoked from the rake task
-    #     'arsenicum:create_queues'.
-    #     Note: this method should be implemented idempotently.
-    #
-    #####################################################
-  end
-end

data/lib/arsenicum/queue_proxy.rb

@@ -1,73 +0,0 @@
-module Arsenicum
-  class QueueProxy
-    include Serialization
-
-    def self.instance
-      @instance ||= new(Arsenicum::Configuration.instance)
-    end
-
-    attr_reader :configuration
-    attr_reader :queues
-    attr_reader :default_queue
-    attr_reader :method_queue_tables
-    attr_reader :class_queue_tables
-
-    def initialize(configuration)
-      @configuration = configuration
-      queue_class = configuration.queue_class
-      @method_queue_tables = {}
-      @class_queue_tables = {}
-
-      @queues = configuration.queue_configurations.inject({}) do |h, kv|
-        (queue_name, queue_configuration) = kv
-        queue = queue_class.new(queue_name, queue_configuration.merge(configuration.engine_configuration))
-        Array(queue.queue_methods).tap(&:compact!).each do |m|
-          method_queue_tables[m] ||= queue
-        end
-        Array(queue.queue_classes).tap(&:compact!).each do |m|
-          class_queue_tables[m] ||= queue
-        end
-        h[queue_name] = queue
-
-        h
-      end
-      @default_queue = queues[:default]
-    end
-
-    def async(target, method, *arguments)
-      values = {
-        target: prepare_serialization(target),
-        method_name: method,
-        arguments: arguments.map{|arg|prepare_serialization(arg)},
-      }
-      specify_queue(target, method).
-        tap{|q|logger.debug { "Queue #{q.name}: Param #{values.inspect}" }}.
-        put(values)
-    end
-
-    def logger
-      configuration.logger
-    end
-
-    private
-    def specify_queue(target, method)
-      if target.is_a?(Module)
-        conjunction = '.'
-        klass = target
-      else
-        conjunction = '#'
-        klass = target.class
-      end
-      method_signature = [target.class.name, method].join conjunction
-      if queue = method_queue_tables[method_signature]
-        return queue
-      end
-      klass_signature = target.class.name
-      if queue = class_queue_tables[klass_signature]
-        return queue
-      end
-
-      return default_queue
-    end
-  end
-end

data/lib/arsenicum/rake_tasks.rake

@@ -1,24 +0,0 @@
-require 'arsenicum'
-require 'yaml'
-
-namespace :arsenicum do
-  desc 'Create queues defined in the configuration file. Specify configuration with CONFIG=config_file_path.'
-  task :create_queues do
-    config_file = ENV['CONFIG'] || 'config/arsenicum.yml'
-    yaml = YAML.load(Erubis::Eruby.new(File.read(config_file, encoding: 'UTF-8')).result)
-    config_values =
-      if ENV['CONFIG_KEY']
-        ENV['CONFIG_KEY'].split('.').inject(yaml) do |values, key|
-          values[key]
-        end
-      else
-        yaml
-      end
-
-    config = Arsenicum::Configuration.new(config_values)
-    queue_class = config.queue_class
-    raise Arsenicum::MisconfigurationError, "class #{queue_class.name} doesn't support create_queue" unless queue_class.instance_methods.include?(:create_queue_backend)
-
-    config.create_queues.each(&:create_queue_backend)
-  end
-end

data/lib/arsenicum/serialization.rb

@@ -1,110 +0,0 @@
-require 'date'
-require 'time'
-
-module Arsenicum
-  module Serialization
-    DATE_FORMAT = "%Y-%m-%d".freeze
-    DATE_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S %Z %z".freeze
-
-    def prepare_serialization(value)
-      hash_value = prepare_serialization_specific(value) || prepare_serialization_default(value)
-    end
-
-    def prepare_serialization_specific(value)
-      case value
-      when Integer, Float, String, TrueClass, FalseClass, NilClass
-        {
-          type: :raw,
-          value: value.inspect,
-        }
-      when Date
-        {
-          type: 'date',
-          value: value.strftime(DATE_FORMAT),
-        }
-      when DateTime, Time
-        {
-          type: 'time',
-          value: value.strftime(DATE_TIME_FORMAT),
-        }
-      when Class
-        {
-          type: :class,
-          value: value.name,
-        }
-      when Array
-        {
-          type: :array,
-          values: value.map{|v|serialize(v)},
-        }
-      when Hash
-        {
-          type: :hash,
-          values: value.inject({}){|h, kv|(k,v)=kv;h[k.to_s]=serialize(v);h},
-        }
-      end
-    end
-
-    def prepare_serialization_default(value)
-      {
-        type: 'marshal',
-        value: Marshal.dump(value).unpack('H*').first,
-      }
-    end
-
-    module_function :prepare_serialization_specific, :prepare_serialization_default, :prepare_serialization
-
-    module WithActiveRecord
-      def self.included(base)
-        base.module_eval do
-          alias_method :prepare_serialization_specific_original, :prepare_serialization_specific
-
-          def prepare_serialization_specific(value)
-            prepare_serialization_specific_original(value) || prepare_serialization_active_record(value)
-          end
-
-          private
-          def prepare_serialization_active_record(value)
-            return {
-              type: :active_record,
-              class: value.class.name,
-              id: value.id,
-            } if value.is_a? ActiveRecord::Base
-          end
-
-          module_function :prepare_serialization_specific_original, :prepare_serialization_active_record
-        end
-      end
-    end
-
-    include(WithActiveRecord) if defined? ::ActiveRecord::Base
-
-    def restore(value)
-      case value['type']
-      when 'raw'
-        eval value['value']
-      when 'date'
-        Date.strptime(value['value'], DATE_FORMAT)
-      when 'time'
-        Time.strptime(value['value'], DATE_TIME_FORMAT)
-      when 'class'
-        Module.const_get value['value'].to_sym
-      when 'active_record'
-        klass = const_get value['class'].to_sym
-        klass.find value['id']
-      when 'array'
-        value['values'].map do |value|
-          restore(value)
-        end
-      when 'hash'
-        value['values'].inject({}) do |h, key_value|
-          (key, value) = key_value
-          h[key.to_sym] = restore(key_value)
-          h
-        end
-      else
-        Marshal.restore [value['value']].pack('H*')
-      end
-    end
-  end
-end

data/lib/arsenicum/server.rb

@@ -1,40 +0,0 @@
-module Arsenicum
-  class Server
-    attr_reader :watchdogs
-    attr_reader :config
-
-    def initialize(config)
-      @config = config
-    end
-
-    def self.start(config = Arsenicum::Configuration.instance)
-      Process.daemon(true, true) if config.background
-      File.open(config.pidfile, 'w'){|f|f.puts $$} if config.pidfile
-      new(config).start
-    end
-
-    def start
-      puts "Booting Arsenicum Server..."
-      Signal.trap(:INT, &method(:trap_interruption))
-
-      queue_class = config.queue_class
-      @watchdogs = config.create_queues.map do |queue|
-        Arsenicum::WatchDog.new(queue, config.logger)
-      end
-      @watchdogs.each(&:boot)
-
-      loop { sleep 10 }
-    end
-
-    def shutdown
-      @watchdogs.each(&:shutdown)
-      File.delete config.pidfile if config.pidfile
-      Thread.current.terminate
-    end
-
-    private
-    def trap_interruption(*)
-      shutdown
-    end
-  end
-end

data/lib/arsenicum/sqs.rb

@@ -1,5 +0,0 @@
-module Arsenicum
-  module Sqs
-    autoload :Queue,  'arsenicum/sqs/queue'
-  end
-end

data/lib/arsenicum/sqs/queue.rb

@@ -1,76 +0,0 @@
-require 'aws-sdk'
-
-module Arsenicum::Sqs
-  class Queue < Arsenicum::Queue
-    attr_reader :account
-    attr_reader :sqs
-    attr_reader :wait_timeout
-    attr_reader :failure_queue_name
-    attr_reader :queue_configuration
-
-    def configure(config)
-      @account = config.delete :account
-      @sqs = AWS::SQS.new account
-      @wait_timeout =
-        if config.delete(:long_poll)
-          nil
-        elsif timeout = config.delete(:wait_timeout)
-          timeout.to_i
-        end
-      @failure_queue_name = config.delete :failure_queue_name
-
-      @queue_configuration = config
-    end
-
-    def put_to_queue(json, named: name)
-      sqs_queue = sqs.queues.named(named.to_s)
-      sqs_queue.send_message(json)
-    end
-
-    def poll
-      sqs.queues.named(name.to_s).poll(wait_time_out: wait_timeout) do |message|
-        logger.debug { "RAW_MESSAGE #{message.inspect}" }
-        {
-          message_body: message.body,
-          message_id: message.handle,
-        }
-      end
-    end
-
-    def update_message_status(message_id, successful, json)
-      put_to_queue(json, named: failure_queue_name) unless successful
-
-      sqs_queue = sqs.named(name)
-      sqs.client.delete_message queue_url: sqs_queue.url, receipt_handle: message_id
-    end
-
-    CREATION_OPTIONS = [
-      :visibility_timeout, :maximum_message_size,
-      :delay_seconds, :message_retention_period,
-    ].freeze
-    CREATION_OPTIONS_IN_JSON = [
-      :policy,
-    ].freeze
-
-    def create_queue_backend
-      creation_options = queue_configuration.values_at(*CREATION_OPTIONS).
-        each_with_index.inject({}) do |opts, vi|
-
-        (value, i) = vi
-        opts[CREATION_OPTIONS[i]] = value if value
-        opts
-      end
-      CREATION_OPTIONS_IN_JSON.each do |opt|
-        creation_options[opt] = JSON(queue_configuration[opt]) if queue_configuration[opt]
-      end
-
-      begin
-        sqs.queues.named(name.to_s)
-        puts "Not Created Queue #{name}:Exists"
-      rescue AWS::SQS::Errors::NonExistentQueue
-        sqs.queues.create name.to_s, creation_options
-        puts "Created Queue #{name}"
-      end
-    end
-  end
-end