skein 0.3.0

data/lib/skein/client/publisher.rb

@@ -0,0 +1,14 @@
+class Skein::Client::Publisher < Skein::Connected
+  # == Instance Methods =====================================================
+
+  def initialize(queue_name, connection: nil, context: nil)
+    super(connection: connection, context: context)
+
+    @queue = self.channel.topic(queue_name)
+  end
+
+  def publish!(message, routing_key = nil)
+    @queue.publish(JSON.dump(message), routing_key: routing_key)
+  end
+  alias_method :<<, :publish!
+end

data/lib/skein/client/rpc.rb

@@ -0,0 +1,96 @@
+require 'securerandom'
+require 'fiber'
+
+class Skein::Client::RPC < Skein::Connected
+  # == Constants ============================================================
+
+  QUEUE_NAME_DEFAULT = 'skein_rpc'.freeze
+
+  # == Properties ===========================================================
+
+  # == Instance Methods =====================================================
+
+  def initialize(queue_name = nil, connection: nil, context: nil)
+    super(connection: connection, context: context)
+
+    @rpc_queue = self.channel.queue(queue_name || QUEUE_NAME_DEFAULT, durable: true)
+    @response_queue = self.channel.queue(@ident, durable: true, header: true, auto_delete: true)
+
+    @callback = { }
+
+    @consumer = @response_queue.subscribe do |metadata, payload, extra|
+      # FIX: Deal with mixup between Bunny and MarchHare
+      # puts [metadata,payload,extra].inspect
+
+      # puts [metadata,payload,extra].map(&:class).inspect
+
+      if (extra)
+        payload = extra
+      elsif (!payload)
+        payload = metadata
+      end
+
+      begin
+        response = JSON.load(payload)
+
+        if (callback = @callback.delete(response['id']))
+          case (callback)
+          when Queue
+            callback << response['result']
+          when Proc
+            callback.call
+          end
+        end
+      rescue => e
+        # FIX: Error handling
+        puts e.inspect
+      end
+    end
+  end
+
+  def close
+    @consumer and @consumer.cancel
+    @consumer = nil
+
+    super
+  end
+
+  def method_missing(name, *args)
+    name = name.to_s
+
+    blocking = !name.sub!(/!\z/, '')
+
+    message_id = SecureRandom.uuid
+    request = JSON.dump(
+      method: name,
+      params: args,
+      id: message_id
+    )
+
+    @channel.default_exchange.publish(
+      request,
+      routing_key: @rpc_queue.name,
+      reply_to: blocking ? @ident : nil,
+      message_id: message_id
+    )
+
+    if (block_given?)
+      @callback[message_id] =
+        if (defined?(EventMachine))
+          EventMachine.next_tick do
+            yield
+          end
+        else
+          lambda do
+            yield
+          end
+        end
+    elsif (blocking)
+      queue = Queue.new
+
+      @callback[message_id] = queue
+
+      queue.pop
+    end
+  end
+end

data/lib/skein/client/subscriber.rb

@@ -0,0 +1,25 @@
+class Skein::Client::Subscriber < Skein::Connected
+  # == Instance Methods =====================================================
+
+  def initialize(queue_name, routing_key = nil, connection: nil, context: nil)
+    super(connection: connection, context: context)
+
+    @queue = self.channel.topic(queue_name)
+    @subscribe_queue = self.channel.queue('', exclusive: true)
+
+    @subscribe_queue.bind(@queue, routing_key: routing_key)
+  end
+
+  def listen
+    case (@subscribe_queue.class.to_s.split(/::/)[0])
+    when 'Bunny'
+      @subscribe_queue.subscribe(block: true) do |delivery_info, properties, payload|
+        yield(JSON.load(payload), delivery_info, properties)
+      end
+    when 'MarchHare'
+      @subscribe_queue.subscribe(block: true) do |metadata, payload|
+        yield(JSON.load(payload), metadata)
+      end
+    end
+  end
+end

data/lib/skein/client/worker.rb

@@ -0,0 +1,51 @@
+require 'json'
+
+class Skein::Client::Worker < Skein::Connected
+  # == Instance Methods =====================================================
+
+  def initialize(queue_name, connection: nil, context: nil)
+    super(connection: connection, context: context)
+
+    lock do
+      queue = self.channel.queue(queue_name, durable: true)
+
+      @handler = Skein::Handler.for(self)
+
+      @subscriber = Skein::Client::Subscriber.new(queue_name, connection: self.connection)
+
+      @thread = Thread.new do
+        @subscriber.listen do |payload, delivery_tag, reply_to|
+          @handler.handle(payload) do |reply_json|
+            channel.acknowledge(delivery_tag, true)
+
+            if (reply_to)
+              channel.default_exchange.publish(
+                reply_json,
+                routing_key: reply_to
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def close
+    @thread.kill
+    @thread.join
+
+    super
+  end
+
+  def join
+    @thread and @thread.join
+  end
+
+  def async?
+    # Define this method as `true` in any subclass that requires async
+    # callback-style delegation.
+    false
+  end
+
+protected
+end

data/lib/skein/config.rb

@@ -0,0 +1,87 @@
+require 'ostruct'
+require 'yaml'
+
+class Skein::Config < OpenStruct
+  # == Constants ============================================================
+
+  CONFIG_PATH_DEFAULT = 'config/skein.yml'.freeze
+
+  ENV_DEFAULT = 'development'.freeze
+
+  DRIVERS = {
+    bunny: 'Bunny',
+    march_hare: 'MarchHare'
+  }.freeze
+
+  DRIVER_PLATFORM_DEFAULT = Hash.new(:bunny).merge(
+    "java" => :march_hare
+  ).freeze
+
+  DRIVER_DEFAULT = (
+    DRIVERS.find do |name, const|
+      const_defined?(const)
+    end || [ ]
+  )[0] || DRIVER_PLATFORM_DEFAULT[RUBY_PLATFORM]
+
+  DEFAULTS = {
+    host: '127.0.0.1',
+    port: 5672,
+    username: 'guest',
+    password: 'guest',
+    driver: DRIVER_DEFAULT,
+    namespace: nil
+  }.freeze
+
+  # == Class Methods ========================================================
+
+  def self.root
+    if (defined?(Rails))
+      Rails.root
+    else
+      Dir.pwd
+    end
+  end
+
+  def self.env
+    if (defined?(Rails))
+      Rails.env.to_s
+    else
+      ENV['RAILS_ENV'] || ENV_DEFAULT
+    end
+  end
+
+  def self.path
+    File.expand_path(CONFIG_PATH_DEFAULT, self.root)
+  end
+
+  def self.exist?
+    File.exist?(self.path)
+  end
+
+  # == Instance Methods =====================================================
+
+  def initialize(options = nil)
+    config_path = nil
+
+    case (options)
+    when String
+      if (File.exist?(options))
+        config_path = options
+      end
+    when Hash
+      super(options)
+
+      return
+    when false, :default
+      # Ignore configuration file, use defaults
+    else
+      config_path = File.expand_path('config/skein.yml', self.class.root)
+    end
+
+    if (config_path and File.exist?(config_path))
+      super(DEFAULTS.merge(YAML.load_file(config_path)[self.class.env] || { }))
+    else
+      super(DEFAULTS)
+    end
+  end
+end

data/lib/skein/connected.rb

@@ -0,0 +1,52 @@
+class Skein::Connected
+  # == Properties ===========================================================
+
+  attr_reader :context
+  attr_reader :ident
+  attr_reader :connection
+  attr_reader :channel
+
+  # == Instance Methods =====================================================
+
+  def initialize(connection: nil, context: nil)
+    @mutex = Mutex.new
+    @shared_connection = !!connection
+
+    @connection = connection || Skein::RabbitMQ.connect
+    @channel = @connection.create_channel
+
+    @context = context || Skein::Context.new
+    @ident = @context.ident(self)
+  end
+
+  def lock
+    @mutex.synchronize do
+      yield
+    end
+  end
+
+  def close
+    lock do
+      begin
+        @channel and @channel.close
+
+      rescue => e
+        if (defined?(MarchHare))
+          case e
+          when MarchHare::ChannelLevelException, MarchHare::ChannelAlreadyClosed
+            # Ignored since we're finished with the channel anyway
+          else
+            raise e
+          end
+        end
+      end
+
+      @channel = nil
+
+      unless (@shared_connection)
+        @connection and @connection.close
+        @connection = nil
+      end
+    end
+  end
+end

data/lib/skein/context.rb

@@ -0,0 +1,38 @@
+class Skein::Context
+  # == Properties ===========================================================
+
+  attr_reader :hostname
+  attr_reader :process_name
+  attr_reader :process_id
+  attr_accessor :reporter
+
+  # == Class Methods ========================================================
+
+  def self.default
+    @default ||= self.new
+  end
+
+  # == Instance Methods =====================================================
+
+  def initialize(hostname: nil, process_name: nil, process_id: nil, config: nil)
+    @hostname = (hostname || Skein::Support.hostname).dup.freeze
+    @process_name = (process_name || Skein::Support.process_name).dup.freeze
+    @process_id = process_id || Skein::Support.process_id
+  end
+
+  def ident(object)
+    # FUTURE: Add pack/unpack methods for whatever format this ends up being
+    #         so the components can be extracted by another application for
+    #         diagnostic reasons.
+    '%s#%d+%s@%s' % [
+      @process_name,
+      @process_id,
+      object.object_id,
+      @hostname
+    ]
+  end
+
+  def exception!(*args)
+    @reporter and @reporter.exception!(*args)
+  end
+end

data/lib/skein/handler.rb

@@ -0,0 +1,86 @@
+class Skein::Handler
+  # == Class Methods ========================================================
+
+  def self.for(target)
+    case (target.respond_to?(:async?) and target.async?)
+    when true
+      Skein::Handler::Async.new(target)
+    else
+      Skein::Handler::Threaded.new(target)
+    end
+  end
+
+  # == Instance Methods =====================================================
+
+  def initialize(target)
+    @target = target
+  end
+
+  def handle(message_json)
+    # REFACTOR: Roll this into a module to keep it more contained.
+    # REFACTOR: Use Skein::RPC::Request
+    request =
+      begin
+        JSON.load(message_json)
+
+      rescue Object => e
+        @context.exception!(e, message_json)
+
+        return yield(JSON.dump(
+          result: nil,
+          error: '[%s] %s' % [ e.class, e ],
+          id: request['id']
+        ))
+      end
+
+    case (request)
+    when Hash
+      # Acceptable
+    else
+      return yield(JSON.dump(
+        result: nil,
+        error: 'Request does not conform to the JSON-RPC format.',
+        id: nil
+      ))
+    end
+
+    request['params'] =
+      case (params = request['params'])
+      when Array
+        params
+      when nil
+        request.key?('params') ? [ nil ] : [ ]
+      else
+        [ request['params'] ]
+      end
+
+    unless (request['method'] and request['method'].is_a?(String) and request['method'].match(/\S/))
+      return yield(JSON.dump(
+        result: nil,
+        error: 'Request does not conform to the JSON-RPC format, missing valid method.',
+        id: request['id']
+      ))
+    end
+
+    begin
+      delegate(request['method'], *request['params']) do |result, error = nil|
+        yield(JSON.dump(
+          result: result,
+          error: error,
+          id: request['id']
+        ))
+      end
+    rescue Object => e
+      @reporter and @reporter.exception!(e, message_json)
+
+      yield(JSON.dump(
+        result: nil,
+        error: '[%s] %s' % [ e.class, e ],
+        id: request['id']
+      ))
+    end
+  end
+end
+
+require_relative './handler/async'
+require_relative './handler/threaded'