philotic 0.0.1

data/lib/philotic/config.rb

@@ -0,0 +1,79 @@
+require 'yaml'
+require 'json'
+require 'singleton'
+require 'forwardable'
+
+module Philotic
+  module Config
+    extend self
+
+    ENV_PREFIX = 'PHILOTIC'
+
+    DEFAULT_DISABLE_PUBLISH = false
+
+
+    DEFAULT_RABBIT_HOST = 'localhost'
+    DEFAULT_RABBIT_PORT = 5672
+    DEFAULT_RABBIT_USER = 'guest'
+    DEFAULT_RABBIT_PASSWORD = 'guest'
+    DEFAULT_RABBIT_VHOST = '/'
+    DEFAULT_EXCHANGE_NAME = 'philotic.headers'
+    DEFAULT_CONNECTION_FAILED_HANDLER = Proc.new { |settings| Philotic.logger.error "RabbitMQ connection failure; host:#{rabbit_host}" }
+    DEFAULT_CONNECTION_LOSS_HANDLER = Proc.new { |conn, settings| Philotic.logger.warn "RabbitMQ connection loss; host:#{rabbit_host}"; conn.reconnect(false, 2) }
+    DEFAULT_MESSAGE_RETURN_HANDLER = Proc.new { |basic_return, metadata, payload| Philotic.logger.warn "Philotic message #{JSON.parse payload} was returned! reply_code = #{basic_return.reply_code}, reply_text = #{basic_return.reply_text} headers = #{metadata.properties}"; }
+    DEFAULT_TIMEOUT = 2
+
+    DEFAULT_ROUTING_KEY = nil
+    DEFAULT_PERSISTENT = true
+    # DEFAULT_IMMEDIATE = false
+    DEFAULT_MANDATORY = true
+    DEFAULT_CONTENT_TYPE = nil
+    DEFAULT_CONTENT_ENCODING = nil
+    DEFAULT_PRIORITY = nil
+    DEFAULT_MESSAGE_ID = nil
+    DEFAULT_CORRELATION_ID = nil
+    DEFAULT_REPLY_TO = nil
+    DEFAULT_TYPE = nil
+    DEFAULT_USER_ID = nil
+    DEFAULT_APP_ID = nil
+    DEFAULT_TIMESTAMP = nil
+    DEFAULT_EXPIRATION = nil
+
+    def defaults
+      @defaults ||= Hash[Config.constants.select { |c| c.to_s.start_with? 'DEFAULT_' }.collect do |c|
+        key = c.slice(8..-1).downcase.to_sym
+
+        env_key = "#{ENV_PREFIX}_#{key}".upcase
+
+        [key, ENV[env_key] || Config.const_get(c)]
+      end
+      ]
+    end
+
+    Config.constants.each do |c|
+      if c.to_s.start_with? 'DEFAULT_'
+        attr_symbol = c.slice(8..-1).downcase.to_sym
+        attr_writer attr_symbol
+        class_eval %Q{
+          def #{attr_symbol}
+            @#{attr_symbol} ||= defaults[:#{attr_symbol}]
+          end
+        }
+      end
+    end
+
+    def load(config)
+      Philotic.logger # ensure the logger can be created, so we crash early if it can't
+
+      config.each do |k, v|
+        mutator = "#{k}="
+        send(mutator, v) if respond_to? mutator
+      end
+    end
+
+    def load_file(filename, env = 'development')
+      config = YAML.load_file(filename)
+      load(config[env])
+    end
+  end
+end

data/lib/philotic/connection.rb

@@ -0,0 +1,83 @@
+require 'singleton'
+require 'json'
+require 'amqp'
+require "amqp/extensions/rabbitmq"
+require 'amqp/utilities/event_loop_helper'
+
+module Philotic
+  module Connection
+    extend self
+    attr_reader :connection
+
+    def config
+      Philotic::Config
+    end
+
+    def connect! &block
+      if connected?
+        Philotic.logger.info "already connected to RabbitMQ; host:#{config.rabbit_host}"
+        block.call if block
+        return
+      end
+
+      AMQP::Utilities::EventLoopHelper.run do
+        connection_settings = {
+            host: config.rabbit_host,
+            port: config.rabbit_port,
+            user: config.rabbit_user,
+            password: config.rabbit_password,
+            vhost: config.rabbit_vhost,
+            timeout: config.timeout,
+            on_tcp_connection_failure: config.connection_failed_handler,
+        }
+
+        AMQP.start(connection_settings, logging: true) do |connection, connect_ok|
+          @connection = connection
+
+          if connected?
+            Philotic.logger.info "connected to RabbitMQ; host:#{config.rabbit_host}"
+          else
+            Philotic.logger.warn "failed connected to RabbitMQ; host:#{config.rabbit_host}"
+          end
+
+
+          AMQP.channel.auto_recovery = true
+
+          @connection.on_tcp_connection_loss do |cl, settings|
+            config.method(:connection_loss_handler).call.call(cl, settings)
+          end
+
+          @connection.after_recovery do |conn, settings|
+            Philotic.logger.info "Connection recovered, now connected to #{config.rabbit_host}"
+          end
+
+          setup_exchange_handler!
+          block.call if block
+
+        end #AMQP.start
+      end
+    end
+
+    def close &block
+      if connected?
+        connection.close &block
+      else
+        block.call
+      end
+    end
+
+    def connected?
+      connection && connection.connected?
+    end
+
+    def exchange
+      AMQP.channel.headers(config.exchange_name, durable: true)
+    end
+
+    def setup_exchange_handler!
+      exchange.on_return do |basic_return, metadata, payload|
+        config.method(:message_return_handler).call.call(basic_return, metadata, payload)
+      end
+    end
+  end
+end

data/lib/philotic/dummy_event.rb

@@ -0,0 +1,8 @@
+module Philotic
+  class DummyEvent < Event
+    attr_payload :subject
+    attr_payload :message
+    attr_routable :gender
+    attr_routable :available
+  end
+end

data/lib/philotic/event.rb

@@ -0,0 +1,69 @@
+require 'philotic/connection'
+
+module Philotic
+  class Event
+    include Philotic::Routable
+
+    def self.inherited(sub)
+      Philotic::PHILOTIC_HEADERS.each do |header|
+        sub.attr_routable header
+      end
+      self.attr_routable_readers.dup.each do |routable|
+        sub.attr_routable routable
+      end
+
+      self.attr_payload_readers.dup.each do |payload|
+        sub.attr_payload payload
+      end
+    end
+
+    self.inherited(self)
+
+    Philotic::MESSAGE_OPTIONS.each do |message_option|
+      attr_reader message_option
+      define_method :"#{message_option}=" do |val|
+        instance_variable_set(:"@#{message_option}", val)
+        self.message_metadata[message_option] = val
+      end
+    end
+
+    def connection
+      Philotic::Connection.instance
+    end
+
+    def set_routables_or_payloads(type, attrs)
+      attrs.each do |key, value|
+        if self.respond_to?(:"#{key}=")
+          send(:"#{key}=", value)
+        elsif self.class == Philotic::Event
+          self.class.send("attr_#{type}_readers").concat([key])
+          self.class.send("attr_#{type}_writers").concat([:"#{key}="])
+
+          setter = Proc.new do |v|
+            instance_variable_set(:"@#{key}", v)
+          end
+          getter = Proc.new do
+            instance_variable_get(:"@#{key}")
+          end
+          self.class.send :define_method, :"#{key}=", setter
+          self.send(:"#{key}=", value)
+          self.class.send :define_method, :"#{key}", getter
+        end
+      end
+    end
+
+    def initialize(routables={}, payloads=nil)
+      payloads ||= {}
+      self.timestamp = Time.now.to_i
+      self.philotic_firehose = true
+
+      # dynamically insert any passed in routables into both attr_routable
+      # and attr_payload
+      # result:  ability to arbitrarily send a easily routable hash
+      # over into the bus
+      set_routables_or_payloads(:routable, routables)
+      set_routables_or_payloads(:payload, payloads)
+      self
+    end
+  end
+end

data/lib/philotic/publisher.rb

@@ -0,0 +1,58 @@
+require 'philotic/connection'
+module Philotic
+  module Publisher
+    extend self
+
+    def config
+      Philotic::Config
+    end
+
+    def publish(event, &block)
+      message_metadata = {headers: event.headers}
+      message_metadata.merge!(event.message_metadata) if event.message_metadata
+      raw_publish(event.payload, message_metadata, &block)
+    end
+
+    def raw_publish(payload, message_metadata = {}, &block)
+
+      if Philotic.connected?
+        _raw_publish payload, message_metadata, &block
+      else
+        Philotic.connect! do
+          _raw_publish payload, message_metadata, &block
+        end
+      end
+    end
+
+    private
+    def _raw_publish(payload, message_metadata = {}, &block)
+
+      publish_defaults = {}
+      Philotic::MESSAGE_OPTIONS.each do |key|
+        publish_defaults[key] = config.send(key.to_s)
+      end
+      message_metadata = publish_defaults.merge message_metadata
+      message_metadata[:headers] ||= {}
+      message_metadata[:headers] = {philotic_firehose: true}.merge(message_metadata[:headers])
+
+
+      payload.each { |k, v| payload[k] = v.utc if v.is_a? ActiveSupport::TimeWithZone }
+
+      callback = Proc.new do
+        Philotic.log_event_published(:debug, message_metadata, payload, 'published event')
+        block.call if block
+      end
+
+      if config.disable_publish
+        EventMachine.next_tick(&callback)
+        return
+      end
+
+      unless Philotic::Connection.connected?
+        Philotic.log_event_published(:error, message_metadata, payload, 'unable to publish event, not connected to amqp broker')
+        return
+      end
+      Thread.new { Philotic::Connection.exchange.publish(payload.to_json, message_metadata, &callback) }
+    end
+  end
+end

data/lib/philotic/routable.rb

@@ -0,0 +1,106 @@
+require 'active_support/all'
+require 'active_record'
+
+module Philotic
+  module Routable
+    def self.included(base)
+      base.send :include, ActiveRecord::Validations
+      base.send :include, ActiveRecord::Callbacks
+      base.validates :philotic_firehose, :philotic_product, :philotic_component, :philotic_event_type, presence: true
+
+      base.extend ClassMethods
+    end
+
+    def payload
+      attribute_hash = {}
+      self.class.attr_payload_readers.each do |attr|
+        attr = attr.to_sym
+        attribute_hash[attr] = send(attr)
+      end
+      attribute_hash
+    end
+
+    def headers
+      attribute_hash = {}
+      self.class.attr_routable_readers.each do |attr|
+        attr = attr.to_sym
+        attribute_hash[attr] = send(attr)
+      end
+      attribute_hash
+    end
+
+    def attributes
+      attribute_hash = {}
+      (self.class.attr_payload_readers + self.class.attr_routable_readers).each do |attr|
+        attr = attr.to_sym
+        attribute_hash[attr] = send(attr)
+      end
+      attribute_hash
+    end
+
+    def message_metadata
+      @message_metadata ||= {}
+    end
+
+    def message_metadata= options
+      @message_metadata ||= {}
+      @message_metadata.merge! options
+    end
+
+    def publish &block
+      Philotic::Publisher.publish(self, &block)
+    end
+
+    module ClassMethods
+      def attr_payload_reader *names
+        attr_payload_readers.concat(names)
+        attr_reader(*names)
+      end
+
+      def attr_payload_readers
+        @attr_payload_readers ||= []
+      end
+
+      def attr_payload_writer *names
+        attr_payload_writers.concat names
+        attr_writer(*names)
+      end
+
+      def attr_payload_writers
+        @attr_payload_writers ||= []
+      end
+
+      def attr_payload *names
+        names -= attr_payload_readers
+        attr_payload_readers.concat(names)
+        attr_payload_writers.concat(names)
+        attr_accessor(*names)
+      end
+
+      def attr_routable_reader *names
+        attr_routable_reader.concat(names)
+        attr_reader(*names)
+      end
+
+      def attr_routable_readers
+        @attr_routable_readers ||= []
+      end
+
+      def attr_routable_writers
+        @attr_routable_writers ||= []
+      end
+
+      def attr_routable_writer *names
+        attr_routable_writers.concat names
+        attr_writer(*names)
+      end
+
+      def attr_routable *names
+        names -= attr_routable_readers
+        attr_routable_readers.concat(names)
+        attr_routable_writers.concat(names)
+        attr_accessor(*names)
+      end
+    end
+  end
+end

data/lib/philotic/subscriber.rb

@@ -0,0 +1,67 @@
+module Philotic
+  class Subscriber
+    def self.subscribe(options = {}, subscribe_options = Philotic::DEFAULT_SUBSCRIBE_OPTIONS, &block)
+      if Philotic.connected?
+        _subscribe(options, subscribe_options, &block)
+      else
+        Philotic.connect! do
+          _subscribe(options, subscribe_options, &block)
+        end
+      end
+    end
+
+    def self.subscribe_to_any_of(options = {}, &block)
+      arguments = options[:arguments] || {}
+      queue_options = options[:queue_options] || {}
+
+      arguments['x-match'] = 'any'
+
+      self.subscribe(options, &block)
+    end
+
+    def self.subscribe_to_all_of(options = {}, &block)
+      arguments = options[:arguments] || {}
+      queue_options = options[:queue_options] || {}
+
+      arguments['x-match'] = 'all'
+
+      self.subscribe(options, &block)
+    end
+
+    private
+    def self._subscribe(options = {}, subscribe_options = Philotic::DEFAULT_SUBSCRIBE_OPTIONS, &block)
+      @@exchange = Philotic::Connection.exchange
+
+      if options.is_a? String
+        queue_name = options
+        queue_options = Philotic::DEFAULT_NAMED_QUEUE_OPTIONS
+      else
+        queue_name = options[:queue_name] || ""
+
+        queue_options = Philotic::DEFAULT_ANONYMOUS_QUEUE_OPTIONS.merge(options[:queue_options] || {})
+        subscribe_options = subscribe_options.merge(options[:subscribe_options]) if options[:subscribe_options]
+        arguments = options[:arguments] || options
+        arguments['x-match'] ||= 'all'
+      end
+
+      queue_options[:auto_delete] ||= true if queue_name == ""
+
+      callback = Proc.new do |metadata, payload|
+        hash_payload = JSON.parse payload
+
+        event = {
+            payload: hash_payload,
+            headers: metadata.attributes[:headers],
+            attributes: metadata.attributes[:headers] ? hash_payload.merge(metadata.attributes[:headers]) : hash_payload
+        }
+        block.call(metadata, event)
+      end
+      q = AMQP.channel.queue(queue_name, queue_options)
+
+      q.bind(@@exchange, arguments: arguments) if arguments
+
+      q.subscribe(subscribe_options, &callback)
+
+    end
+  end
+end