hotot 0.0.0

data/lib/hotot/class_attribute_accessors.rb

@@ -0,0 +1,20 @@
+module Hotot
+  module ClassAttributeAccessors
+  
+    def cattr_reader(*syms)
+      syms.each do |sym|
+        raise NameError.new("invalid class attribute name: #{sym}") unless sym =~ /^[_A-Za-z]\w*$/
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+                unless defined? @@#{sym}
+                  @@#{sym} = nil
+                end
+
+                def self.#{sym}
+                  @@#{sym}
+                end
+              EOS
+      end
+    end
+    
+  end
+end

data/lib/hotot/configurable.rb

@@ -0,0 +1,23 @@
+require 'erb'
+require 'yaml'
+
+module Hotot
+  module Configurable
+
+    private
+
+    def load_config(config_file = nil)
+      if config_file && config_file.file?
+        YAML.load(ERB.new(config_file.read).result)
+      elsif defined?(::Rails)
+        config_file = ::Rails.root.join('config/hotot.yml')
+        if config_file.file?
+          YAML.load(ERB.new(config_file.read).result)
+        else
+          nil
+        end
+      end
+    end
+    
+  end
+end

data/lib/hotot/message/base.rb

@@ -0,0 +1,42 @@
+require 'time'
+require 'json' unless defined?(::Rails)
+
+module Hotot
+  module Message
+    class Base
+    
+      # Use rails default json if it exists
+      if defined?(::Rails)
+        include ActiveModel::Serializers::JSON
+      else
+        define_method :to_json do
+          self.as_json.to_json
+        end
+      end
+    
+      attr_reader :metadata
+
+      def initialize(routing_key=nil)
+        raise StandardError, "routing_key cannot be nil" if routing_key.nil?
+        @metadata = {:host => Socket.gethostbyname(Socket.gethostname).first,
+                     :app => Hotot.app_name, # configure this...
+                     :key => routing_key,
+                     :created => DateTime.now.new_offset(0).to_time.utc.iso8601}
+      end
+
+      def routing_key
+        @metadata[:key]
+      end
+
+      def as_json(options={})
+        hash = {:metadata => {:host => @metadata[:host],
+                              :app => @metadata[:app],
+                              :key => @metadata[:key],
+                              :created => @metadata[:created]}}
+        hash
+      end
+      
+      
+    end
+  end
+end

data/lib/hotot/message_producer.rb

@@ -0,0 +1,9 @@
+module Hotot
+  module MessageProducer
+    # Produces a message to the underlying exchange using an synchronous connection
+    def produce_synchronously(message)
+      SynchronousConnection.produce(message)
+    end
+    alias :produce :produce_synchronously
+  end
+end

data/lib/hotot/synchronous_connection.rb

@@ -0,0 +1,106 @@
+require 'bunny'
+require_relative 'configurable'
+require_relative 'class_attribute_accessors'
+
+module Hotot
+  class SynchronousConnection
+    extend Configurable
+    extend ClassAttributeAccessors
+
+    cattr_reader :bunny, :exchange
+
+    @@setup = false
+    @@connected = false
+
+    def self.setup(config = nil, env = (defined?(::Rails) ? Rails.env : nil) )
+      if !self.setup?
+        @@config = load_config(config)
+        @@env_config = @@config[env]
+        raise StandardError, "Env #{env} not found in config" if @@env_config.nil?
+        
+        # symbolize the keys, which Bunny expects
+        @@env_config.keys.each {|key| @@env_config[(key.to_sym rescue key) || key] = @@env_config.delete(key) }
+        raise StandardError, "'exchange' key not found in config" if !@@env_config.has_key?(:exchange)
+        
+        @@bunny = Bunny.new(@@env_config)
+        @@setup = true
+      end
+    end
+
+    # Whether the underlying connection has been set up
+    def self.setup?
+      @@setup
+    end
+    
+    def self.subscribe(routing_key, &block)
+      q = @@bunny.queue.bind(@@env_config[:exchange], :routing_key => routing_key)
+
+      q.subscribe do |delivery_info, metadata, payload|
+        block.call delivery_info, metadata, payload
+      end
+      
+    end
+
+    # Establish a connection to the underlying exchange
+    def self.connect
+      raise StandardError, "AMQP not setup. Call setup before calling connect" if !self.setup?
+      @@bunny.start
+      
+      # use defualt channel for exchange
+      @@exchange = @@bunny.exchange(@@env_config[:exchange], :type => :topic, :durable => true)
+      @@connected = true
+    end
+
+    # Disconnect from the underlying exchange
+    def self.disconnect
+      begin
+        @@bunny.stop
+      rescue
+        # if this is being called because the underlying connection went bad
+        # calling stop will raise an error. that's ok....
+      ensure
+        @@connected = false
+      end
+    end
+
+    # Re-connects to the underlying exchange
+    def self.reconnect
+      self.disconnect
+      @@setup = false
+      @@bunny = Bunny.new(@@env_config)
+      @@setup = true
+      self.connect
+    end
+
+    # Whether the underlying connection has been established
+    def self.connected?
+      @@connected
+    end
+
+    # Produces a message to the underlying exchange
+    def self.produce(message)
+      if !self.setup? || !self.connected?
+        Hotot.logger.error "AMQP not setup or connected. Call setup and connect before calling produce"
+      else
+        begin
+          @@exchange.publish(message.to_json, :routing_key => message.routing_key, :mandatory => false, :immediate => false, :persistent => true, :content_type => "application/json")
+        rescue Bunny::ServerDownError
+          # the connection went south, try to reconnect and try one more time
+          begin
+            self.reconnect
+            @@exchange.publish(message.to_json, :routing_key => message.routing_key, :mandatory => false, :immediate => false, :persistent => true, :content_type => "application/json")
+          rescue => err
+            Hotot.logger.error "Unexpected error producing AMQP messsage: (#{message.to_json})"
+            Hotot.logger.error "#{err.message}"
+            Hotot.logger.error err.backtrace.join("\n")
+          end
+        rescue => err
+          Hotot.logger.error "Unexpected error producing AMQP messsage: (#{message.to_json})"
+          Hotot.logger.error "#{err.message}"
+          Hotot.logger.error err.backtrace.join("\n")
+        end
+      end
+    end
+    
+  end #SynchronousConnection
+end #Hotot

data/lib/hotot/version.rb

@@ -0,0 +1,5 @@
+module Hotot
+
+  VERSION = '0.0.0'
+
+end

data/lib/hotot.rb

@@ -0,0 +1,27 @@
+require 'logger'
+
+module Hotot
+
+  require_relative 'hotot/synchronous_connection'
+  require_relative 'hotot/message_producer'
+  require_relative 'hotot/message/base'
+  
+  def self.logger=(logger)
+    @logger = logger
+  end
+  
+  def self.logger
+    @logger ||= Logger.new($stdout).tap do |log|
+      log.progname = 'Hotot'
+    end
+  end
+  
+  def self.app_name=(app_name)
+    @app_name = app_name
+  end
+  
+  def self.app_name
+    @app_name ||= "Hotot"
+  end
+  
+end

data/spec/hotot/configurable_spec.rb

@@ -0,0 +1,34 @@
+require 'minitest_helper'
+
+module MyConfig
+  extend Hotot::Configurable
+  
+  def self.setup(config)
+    load_config(config)
+  end
+  
+end
+
+describe "Hotot::Configurable" do
+  
+  it "Configurable should receive load_config" do
+    MyConfig.stub :load_config, true do
+      MyConfig.setup "config"
+      assert_send [MyConfig, :load_config, nil]
+    end
+  end
+  
+  before do 
+    @config_file = Pathname.new File.expand_path("../../fixtures/hotot.yml", __FILE__)
+    @config = MyConfig.setup @config_file
+  end
+  
+  it "loads config file" do
+    test_config = @config['test']
+    test_config['host'].must_equal 'localhost'
+    test_config['vhost'].must_equal '/'
+    test_config['exchange'].must_equal 'heyook.topic'
+  end
+  
+end
+

data/spec/hotot/message/base_spec.rb

@@ -0,0 +1,40 @@
+require 'minitest_helper'
+
+describe "Hotot::Message::Base" do
+  
+  describe "default base" do
+    
+    before do
+      @base = Hotot::Message::Base.new("rkey")
+      @hash = @base.as_json
+    end
+  
+    it "sets metadata" do
+      metadata = @hash[:metadata]
+      metadata[:app].must_equal "Hotot"
+      metadata[:key].must_equal "rkey"
+      metadata[:host].wont_be :empty?
+      metadata[:created].wont_be :empty?
+    end
+    
+    it "respond to to_json" do
+      assert_respond_to @base, :to_json
+    end
+    
+    it "converts to json" do
+      json = @base.to_json
+      metadata = (JSON.parse json)['metadata']
+      
+      metadata['app'].must_equal "Hotot"
+      metadata['key'].must_equal "rkey"
+      metadata['host'].wont_be :empty?
+      metadata['created'].wont_be :empty?
+    end
+    
+    it "gets routing_key" do
+      @base.routing_key.must_equal "rkey"
+    end
+  
+  end
+
+end

data/spec/hotot/message_producer_spec.rb

@@ -0,0 +1,20 @@
+require 'minitest_helper'
+
+class MyProducer
+  include Hotot::MessageProducer
+end
+
+describe "Hotot::MessageProducer" do
+  
+  before do 
+    @mp  = MyProducer.new
+  end
+  
+  it "SynchronousConnection should receive produce" do
+    Hotot::SynchronousConnection.stub :produce, true do
+      @mp.produce "hello rabbit"
+      assert_send [Hotot::SynchronousConnection, :produce, "hello rabbit"]
+    end
+  end
+  
+end

data/spec/hotot/synchronous_connection_spec.rb

@@ -0,0 +1,75 @@
+require 'minitest_helper'
+
+class TestMessage < Hotot::Message::Base
+  ROUTING_KEY = "heyook.message.test"
+  def initialize
+    super ROUTING_KEY
+  end
+end
+
+describe "Hotot::SynchronousConnection" do
+  
+  before do 
+    @config_file = Pathname.new File.expand_path("../../fixtures/hotot.yml", __FILE__)
+    @bunny       = Minitest::Mock.new
+    @exchange    = Minitest::Mock.new
+  end
+  
+  it "raise error if not setup yet" do
+    assert_raises(StandardError) { Hotot::SynchronousConnection.connect }
+  end
+  
+  describe "setup" do
+    
+    it "setup Hotot::SynchronousConnection" do
+      Hotot::SynchronousConnection.setup @config_file, 'test'
+      Hotot::SynchronousConnection.setup?.must_equal true
+    end
+    
+  end
+  
+  describe "connect" do
+    
+    before do
+      Hotot::SynchronousConnection.setup @config_file, 'test'
+      @bunny = Hotot::SynchronousConnection.bunny
+    end
+    
+    after do
+      Hotot::SynchronousConnection.disconnect
+    end
+    
+    it "calls start and exchange" do
+      Hotot::SynchronousConnection.connect
+      Hotot::SynchronousConnection.connected?.must_equal true
+      assert_send [@bunny, :start]
+      assert_send [@bunny, :exchange, "heyook.topic", :type => :topic, :durable => true]
+    end
+    
+    describe "publish" do
+      
+      it "let exchange to publish" do
+        Hotot::SynchronousConnection.connect
+        @exchange = Hotot::SynchronousConnection.exchange
+        
+        message = TestMessage.new
+        Hotot::SynchronousConnection.produce message
+        assert_send [@exchange, :publish, message.to_json, :routing_key => "heyook.message.test", :mandatory => false, :immediate => false, :persistent => true, :content_type => "application/json"]
+      end
+      
+    end
+      
+  end
+  
+  describe "disconnect" do
+    
+    it "disconnects and set connected to false" do
+      Bunny.stub :new, @bunny do
+        Hotot::SynchronousConnection.disconnect
+        Hotot::SynchronousConnection.connected?.must_equal false
+      end    
+    end
+    
+  end
+  
+end

data/spec/hotot_spec.rb

@@ -0,0 +1,37 @@
+require 'minitest_helper'
+
+describe Hotot do
+  
+  describe "default settings" do
+    
+    before do 
+      Hotot.logger   = nil
+      Hotot.app_name = nil
+    end
+  
+    it "uses default logger" do
+      assert_kind_of Logger, Hotot.logger
+    end
+  
+    it "uses default app name" do
+      Hotot.app_name.must_equal "Hotot"
+    end
+  
+  end
+  
+  describe "get/set settings" do
+    
+    it "sets logger" do
+      logger_klass = Object.const_set("MyLogger", Class.new )
+      Hotot.logger = logger_klass.new
+      assert_kind_of logger_klass, Hotot.logger
+    end
+  
+    it "sets app name" do
+      Hotot.app_name = "New Rabbit"
+      Hotot.app_name.must_equal "New Rabbit"
+    end
+    
+  end
+  
+end

data/spec/minitest_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+
+require "minitest/autorun"
+require "hotot"

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: hotot
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Qi He
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: ! '    Hotot is a kind of rabbit that wraps bunny gem.
+
+'
+email: qihe229@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hotot/class_attribute_accessors.rb
+- lib/hotot/configurable.rb
+- lib/hotot/message/base.rb
+- lib/hotot/message_producer.rb
+- lib/hotot/synchronous_connection.rb
+- lib/hotot/version.rb
+- lib/hotot.rb
+- spec/hotot/configurable_spec.rb
+- spec/hotot/message/base_spec.rb
+- spec/hotot/message_producer_spec.rb
+- spec/hotot/synchronous_connection_spec.rb
+- spec/hotot_spec.rb
+- spec/minitest_helper.rb
+homepage: http://github.com/he9qi/hotot
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A bunny wrapper.
+test_files:
+- spec/hotot/configurable_spec.rb
+- spec/hotot/message/base_spec.rb
+- spec/hotot/message_producer_spec.rb
+- spec/hotot/synchronous_connection_spec.rb
+- spec/hotot_spec.rb
+- spec/minitest_helper.rb