acception-subscriber 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 77f56d09784b6c9d77a986455b5f18f8a0ae55e7
+  data.tar.gz: 46026ce3b88d330b1aaf6d89027ba948365f71e3
+SHA512:
+  metadata.gz: caa67f69a4f6f13b3dfd5904e2aada8ebb9adfb5c38f0959df561871128c1d7012ea37aa4eb3cb6f2e172293132945ac914537aa1834ecbed0373ef3c61cb034
+  data.tar.gz: b6d0c9e860e241b3c7c08f275a7460b1547500e5aaea1412087b58ebb130fe2223d7860e8f8650be9c5be676890f58305303f4d335edc75fc12f28ed3489c6b6

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.ruby-gemset

@@ -0,0 +1 @@
+acception-subscriber

data/.ruby-version

@@ -0,0 +1 @@
+2.1.0

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+source 'http://dev.staging.iberon.com/gemserver'
+
+# Specify your gem's dependencies in replication-subscriber.gemspec
+gemspec
+
+group :development do
+  gem 'rake-iberon', '~> 1', require: false
+end
+
+#gem 'acception-client', path: '../acception-client'

data/LICENSE.txt

@@ -0,0 +1,3 @@
+Copyright (c) 2014 Iberon, LLC
+
+No license granted

data/README.md

@@ -0,0 +1,21 @@
+# Acception::Subscriber
+
+A RabbitMQ subscriber that pushes messages to Acception's API.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'acception-subscriber'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install acception-subscriber
+
+## Usage
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/acception-subscriber.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acception/subscriber/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "acception-subscriber"
+  spec.version       = Acception::Subscriber::VERSION
+  spec.authors       = ["C. Jason Harrelson"]
+  spec.email         = ["cjharrelson@iberon.com"]
+  spec.summary       = %q{A RabbitMQ subscriber that pushes messages to Acception's API.}
+  spec.description   = %q{A RabbitMQ subscriber that pushes messages to Acception's API.  See README for more details.}
+  spec.homepage      = "https://gitlab.staging.iberon.com/common/acception-subscriber"
+  spec.license       = ""
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "acception-client", ">= 1.2"
+  spec.add_dependency "bunny", "~> 1"
+  spec.add_dependency "celluloid", "~> 0"
+  spec.add_dependency "multi_json", "~> 1"
+  spec.add_dependency "oj", "~> 2"
+  spec.add_dependency "trollop", "~> 2"
+  spec.add_dependency "yell", "~> 1"
+
+end

data/bin/acception-sub

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'acception/subscriber/cli'
+$0 = Acception::Subscriber::APP_ID
+Acception::Subscriber::Cli.new( ARGV ).run

data/lib/acception-subscriber.rb

@@ -0,0 +1 @@
+require 'acception/subscriber'

data/lib/acception/subscriber.rb

@@ -0,0 +1,39 @@
+require 'ansi'
+require "acception/client"
+require "acception/subscriber/version"
+
+module Acception
+  module Subscriber
+
+    autoload :Configuration,  'acception/subscriber/configuration'
+    autoload :Logging,        'acception/subscriber/logging'
+    autoload :MessageHandler, 'acception/subscriber/message_handler'
+    autoload :Server,         'acception/subscriber/server'
+    autoload :ServerDaemon,   'acception/subscriber/server_daemon'
+    autoload :ServerLogging,  'acception/subscriber/server_logging'
+
+    APP_ID            = "acception-sub"
+    APP_NAME          = "Acception Subscriber"
+    COMPANY           = "Iberon, LLC"
+    INT               = "INT"
+    TERM              = "TERM"
+    VERSION_COPYRIGHT = "v#{VERSION} \u00A9#{Time.now.year} #{COMPANY}"
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.configuration=( configuration )
+      @configuration = configuration
+    end
+
+    def self.configure
+      yield( configuration ) if block_given?
+    end
+
+    class << self
+      attr_accessor :logger
+    end
+
+  end
+end

data/lib/acception/subscriber/cli.rb

@@ -0,0 +1,132 @@
+require 'rubygems'
+require 'acception/subscriber'
+require 'trollop'
+require 'yell'
+
+module Acception
+  module Subscriber
+    class Cli
+
+      attr_reader :cmd,
+                  :options
+
+      SUB_COMMANDS = %w(
+        restart
+        start
+        status
+        stop
+      )
+
+      DEFAULT_CONFIG_PATH = "/etc/ncite/#{APP_ID}.conf"
+      DEFAULT_LOG_PATH = "/var/log/ncite/#{APP_ID}.log"
+      DEFAULT_PID_PATH = "/var/run/ncite/#{APP_ID}.pid"
+
+      DEFAULT_NUMBER_OF_THREADS = 1
+
+      def initialize( args )
+        Trollop::options do
+          version VERSION_COPYRIGHT
+          banner <<-EOS
+  #{APP_NAME} #{VERSION_COPYRIGHT}
+
+  Usage:
+    #{APP_ID} [command] [options]
+
+    commands:
+  #{SUB_COMMANDS.map { |sub_cmd| "    #{sub_cmd}" }.join( "\n" )}
+
+    (For help with a command: #{APP_ID} [command] -h)
+
+  options:
+        EOS
+          stop_on SUB_COMMANDS
+        end
+
+        # Get the sub-command and its options
+        #
+        @cmd = ARGV.shift || ''
+        @options = case( cmd )
+          when "restart"
+            Trollop::options do
+              opt :config, "The path for the config file", :type => String, :short => '-c', :default => DEFAULT_CONFIG_PATH
+              opt :log_level, "The log level", :type => String, :default => 'info'
+              opt :log_level, "The log level", :type => String, :default => 'info', :short => '-o'
+              opt :log, "The path for the log file", :type => String, :short => '-l', :default => DEFAULT_LOG_PATH
+              opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
+              opt :threads, "The number of threads", :type => Integer, :default => DEFAULT_NUMBER_OF_THREADS, :short => '-t'
+            end
+          when "start"
+            Trollop::options do
+              opt :config, "The path for the config file", :type => String, :short => '-c', :default => DEFAULT_CONFIG_PATH
+              opt :interactive, "Execute the server in interactive mode", :short => '-i'
+              opt :log_level, "The log level", :type => String, :default => 'info', :short => '-o'
+              opt :log, "The path for the log file", :type => String, :short => '-l', :default => DEFAULT_LOG_PATH
+              opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
+              opt :threads, "The number of threads", :type => Integer, :default => DEFAULT_NUMBER_OF_THREADS, :short => '-t'
+            end
+          when "status"
+            Trollop::options do
+              opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
+            end
+          when "stop"
+            Trollop::options do
+              opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
+            end
+          else
+            Trollop::die "unknown command #{cmd.inspect}"
+          end
+
+        if cmd == 'start'
+          unless options[:interactive]
+            Trollop::die( :config, "is required when running as daemon" ) unless options[:config]
+            Trollop::die( :log, "is required when running as daemon" ) unless options[:log]
+            Trollop::die( :pid, "is required when running as daemon" ) unless options[:pid]
+          end
+        end
+
+        if %w(restart status stop).include?( cmd )
+          Trollop::die( :pid, "is required" ) unless options[:pid]
+        end
+      end
+
+      def run
+        send( cmd )
+      end
+
+    protected
+
+      def start
+        if options[:interactive]
+          start_interactive
+        else
+          start_daemon
+        end
+      end
+
+      def start_interactive
+        server = Acception::Subscriber::Server.new( options.merge( log: nil ))
+        server.start
+      end
+
+      def start_daemon
+        server = Acception::Subscriber::ServerDaemon.new( options )
+        server.start
+      end
+
+      def stop
+        server = Acception::Subscriber::ServerDaemon.new( options )
+        server.stop
+      end
+
+      def restart
+        stop
+        start_daemon
+      end
+
+      def status
+        Acception::Subscriber::ServerDaemon.new( options ).status
+      end
+
+    end
+  end
+end

data/lib/acception/subscriber/configuration.rb

@@ -0,0 +1,48 @@
+require 'oj'
+
+module Acception
+  module Subscriber
+    class Configuration
+
+      def self.attributes
+        %w(
+          acception_auth_token
+          acception_url
+          host_uri
+          queue
+        )
+      end
+
+      attr_accessor( *attributes )
+
+      def self.from_file( file_path )
+        options = Oj.load( File.read( file_path ))
+        Acception::Subscriber.configuration = Configuration.new
+
+        attributes.each do |c|
+          if options[c]
+            Acception::Subscriber.configuration.send( :"#{c}=", options[c] )
+          end
+        end
+      end
+
+      def acception_auth_token
+        @acception_auth_token || "00-6TKIMQF4NZA"
+      end
+
+      def acception_url
+        @acception_url || "http://localhost:3004"
+      end
+
+      def host_uri
+        @host_uri || "amqp://guest:guest@127.0.0.1:5672"
+      end
+
+      def queue
+        #@queue || "error-repo"
+        @queue || "error"
+      end
+
+    end
+  end
+end

data/lib/acception/subscriber/logging.rb

@@ -0,0 +1,23 @@
+module Acception
+  module Subscriber
+    module Logging
+
+      %w(
+        debug
+        error
+        fatal
+        info
+        warn
+      ).each do |level|
+
+        define_method level do |*messages|
+          messages.each do |message|
+            Acception::Subscriber.logger.send level, message
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/acception/subscriber/message_handler.rb

@@ -0,0 +1,119 @@
+require 'celluloid/autostart'
+require 'oj'
+
+module Acception
+  module Subscriber
+    class MessageHandler
+
+      include Celluloid
+      include Logging
+
+      BLANK             = '<<blank>>'
+      ERROR             = 'error'
+      LICENSE_VIOLATION = 'license-violation'
+      REQUEUE           = true
+
+      def call( options )
+        channel       = options[:channel]
+        delivery_info = options[:delivery_info]
+        payload       = options[:payload]
+        metadata      = options[:metadata]
+        headers       = metadata[:headers]
+
+        debug ANSI.cyan { 'HEADERS' } + " #{headers}"
+        debug ANSI.yellow { 'PAYLOAD' } + " #{payload}"
+
+        case resolve_type( payload )
+          when ERROR
+            handle_error( headers )
+          when LICENSE_VIOLATION
+            handle_license_violation( headers )
+          else
+        end
+
+        channel.acknowledge delivery_info.delivery_tag
+      rescue => e
+        debug ANSI.red { "NACK" } + " #{e.message}"
+        debug ANSI.red { "NACK" } + " #{e.backtrace}"
+        #channel.nack delivery_info.delivery_tag
+      end
+
+    protected
+
+      def handle_error( headers )
+        exception = headers['exception']
+        acception = Acception::Client::OpenMessages::Create.new( message_type: Acception::MessageType::ERROR,
+                                                                 application: (headers['application'] || BLANK),
+                                                                 environment: (headers['environment'] || BLANK),
+                                                                 occurred_at: (headers['occurred_at'] || BLANK),
+                                                                 message: (exception['message'] || BLANK),
+                                                                 request_headers: (headers['request_headers'] || BLANK),
+                                                                 request_parameters: (headers['request_parameters'] || BLANK),
+                                                                 session: (headers['session'] || BLANK),
+                                                                 type: (exception['class'] || BLANK),
+                                                                 stack: (exception['backtrace'] || BLANK) )
+        acception.call
+      end
+
+      def handle_license_violation( headers )
+        acception = Acception::Client::OpenMessages::Create.new( message_type: Acception::MessageType::LICENSE_VIOLATION,
+                                                                 application: headers['application'],
+                                                                 occurred_at: headers['occurred_at'],
+                                                                 variables: [
+                                                                   {
+                                                                     name: 'license-violation-type',
+                                                                     content: (headers['type'] || BLANK),
+                                                                     content_type: 'text/plain'
+                                                                   },
+                                                                   {
+                                                                     name: 'license-content',
+                                                                     content: (headers['content'] || BLANK),
+                                                                     content_type: 'application/base64'
+                                                                   },
+                                                                   {
+                                                                     name: 'nonce',
+                                                                     content: (headers['nonce'] || BLANK),
+                                                                     content_type: 'application/base64'
+                                                                   },
+                                                                   {
+                                                                     name: 'site-private-key',
+                                                                     content: (headers['site_private_key'] || BLANK),
+                                                                     content_type: 'application/base64'
+                                                                   },
+                                                                   {
+                                                                     name: 'iberon-public-key',
+                                                                     content: (headers['iiberon_public_key'] || BLANK),
+                                                                     content_type: 'application/base64'
+                                                                   }
+                                                                 ])
+        acception.call
+      end
+
+      def resolve_type( payload )
+        return ERROR             if payload == ERROR
+        return LICENSE_VIOLATION if payload == LICENSE_VIOLATION
+        return nil
+      end
+
+      #def handle_error( channel, payload, e )
+        #error( ANSI.red { e.message + " | " + e.backtrace.inspect } )
+        #error_queue( channel ).publish( payload, headers: { application: Acception::Subscriber::APP_ID,
+                                                            #exception_message: e.message,
+                                                            #exception_class: e.class.name,
+                                                            #exception_backtrace: e.backtrace } )
+      #rescue => ex
+        #error( ANSI.red { ex.message + " | " + ex.backtrace.inspect } )
+      #end
+
+      #def requeue( channel, delivery_info, e=nil )
+        #debug ANSI.yellow { 'REQUEUE ' + e.message }
+        #channel.reject delivery_info.delivery_tag, REQUEUE
+      #end
+
+      def config
+        Acception::Subscriber.configuration
+      end
+
+    end
+  end
+end

data/lib/acception/subscriber/publish_error.rb

@@ -0,0 +1,7 @@
+module Acception
+  module Subscriber
+    class PublishError < RuntimeError
+
+    end
+  end
+end

data/lib/acception/subscriber/server.rb

@@ -0,0 +1,118 @@
+require 'bunny'
+require 'celluloid'
+
+module Acception
+  module Subscriber
+    class Server
+
+      include ServerLogging
+      include Logging
+
+      attr_reader :message_consumer,
+                  :options
+
+      def initialize( options )
+        @options = options
+
+        configure_server
+      end
+
+      def start
+        log_startup
+        run
+
+        trap( INT ) { finalize; exit }
+        sleep
+      end
+
+    protected
+
+      def finalize
+        info "SHUTTING DOWN"
+        message_consumer.cancel
+        mq.close
+      end
+
+      def mq
+        @mq ||= Bunny.new( host_uri ).tap do |bunny|
+          bunny.start
+        end
+      end
+
+      def channel
+        @channel ||= mq.create_channel
+      end
+
+      def queue
+        @queue ||= channel.queue( config.queue,
+                                  durable: true )
+      end
+
+      def pool
+        @pool ||= MessageHandler.pool( size: options[:threads] )
+      end
+
+      def run
+        if options[:threads] == 1
+          Celluloid::Actor[:message_handler] = MessageHandler.new
+        end
+
+        @message_consumer = queue.subscribe( manual_ack: true ) do |delivery_info, metadata, payload|
+          debug ANSI.magenta { "LISTENER RECEIVED #{payload}" }
+
+          if options[:threads] > 1
+            pool.async.call( payload: payload,
+                             delivery_info: delivery_info,
+                             metadata: metadata,
+                             channel: channel )
+          else
+            message_handler.call( payload: payload,
+                                  delivery_info: delivery_info,
+                                  metadata: metadata,
+                                  channel: channel )
+          end
+        end
+      end
+
+      def message_handler
+        Celluloid::Actor[:message_handler]
+      end
+
+      def host_uri
+        config.host_uri
+      end
+
+      def config
+        Acception::Subscriber.configuration
+      end
+
+      def configure_server
+        load_configuration
+        configure_acception
+        initialize_loggers
+      end
+
+      def load_configuration
+        if File.exists?( options[:config] )
+          options[:config_loaded] = true
+          Configuration.from_file( options[:config] )
+        end
+      end
+
+      def configure_acception
+        Acception::Client.configure do |c|
+          c.authentication_token       = config.acception_auth_token
+          c.base_url                   = config.acception_url
+          #c.graceful_errors_map        = ServiceErrorHandling::GRACEFUL_ERRORS_MAP
+          c.logger                     = Acception::Subscriber.logger
+          #c.log_level                  = options.fetch( :log_level, :info ).to_sym
+          c.open_timeout_in_seconds    = 10
+          c.read_timeout_in_seconds    = 20
+          #c.retry_attempts             = configatron.iols.retry_attempts.to_i || 1
+          #c.retry_sleep                = configatron.iols.retry_sleep || false
+        end
+      end
+
+    end
+  end
+end

data/lib/acception/subscriber/server_daemon.rb

@@ -0,0 +1,146 @@
+require 'rubygems'
+require 'fileutils'
+require 'timeout'
+
+module Acception
+  module Subscriber
+    class ServerDaemon
+
+      attr_reader :name,
+                  :options,
+                  :pid,
+                  :pid_path,
+                  :script,
+                  :timeout
+
+      def initialize( options )
+        @options  = options
+        @name     = options[:name] || APP_NAME
+        @pid_path = options[:pid] || '.'
+        @pid      = get_pid
+        @timeout  = options[:timeout] || 10
+      end
+
+      def start
+        abort "Process already running!" if process_exists?
+
+        pid = fork do
+          exit if fork
+          Process.setsid
+          exit if fork
+          store_pid( Process.pid )
+          File.umask 0000
+          redirect_output!
+          run
+        end
+
+        Process.waitpid( pid )
+      end
+
+      def run
+        Server.new( options ).start
+      end
+
+      def stop
+        kill_process
+        FileUtils.rm pid_path
+      end
+
+      def status
+        out = "#{APP_NAME} "
+        if process_exists?
+          out << "process running with PID: #{pid}"
+        else
+          out << "process does not exist"
+        end
+        $stdout.puts out
+      end
+
+     protected
+
+      #def create_pid( pid )
+      def store_pid( pid )
+        File.open( pid_path, 'w' ) do |f|
+          f.puts pid
+        end
+      rescue => e
+        $stderr.puts "Unable to open #{pid_path} for writing:\n\t(#{e.class}) #{e.message}"
+        exit!
+      end
+
+      def get_pid
+        return nil unless File.exists?( pid_path )
+        pid = nil
+        File.open( @pid_path, 'r' ) do |f|
+          pid = f.readline.to_s.gsub( /[^0-9]/, '' )
+        end
+        pid.to_i
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def remove_pidfile
+        File.unlink( pid_path )
+      rescue => e
+        $stderr.puts "Unable to unlink #{pid_path}:\n\t(#{e.class}) #{e.message}"
+        exit
+      end
+
+      def kill_process
+        abort "#{APP_NAME} process is not running" unless process_exists?
+        $stdout.write "Attempting to stop #{APP_NAME} process #{pid}..."
+        Process.kill INT, pid
+        iteration_num = 0
+        while process_exists? && iteration_num < 10
+          sleep 1
+          $stdout.write "."
+          iteration_num += 1
+        end
+        if process_exists?
+          $stderr.puts "\nFailed to stop #{APP_NAME} process #{pid}"
+        else
+          $stdout.puts "\nSuccessfuly stopped #{APP_NAME} process #{pid}"
+        end
+      rescue Errno::EPERM
+        $stderr.puts "No permission to query #{pid}!";
+      end
+
+      def process_exists?
+        return false unless pid
+        Process.kill( 0, pid )
+        true
+      rescue Errno::ESRCH, TypeError # "PID is NOT running or is zombied
+        false
+      rescue Errno::EPERM
+        $stderr.puts "No permission to query #{pid}!";
+        false
+      end
+
+      def redirect_output!
+        if log_path = options[:log]
+          #puts "redirecting to log"
+          # if the log directory doesn't exist, create it
+          FileUtils.mkdir_p( File.dirname( log_path ), :mode => 0755 )
+          # touch the log file to create it
+          FileUtils.touch( log_path )
+          # Set permissions on the log file
+          File.chmod( 0644, log_path )
+          # Reopen $stdout (NOT +STDOUT+) to start writing to the log file
+          $stdout.reopen( log_path, 'a' )
+          # Redirect $stderr to $stdout
+          $stderr.reopen $stdout
+          $stdout.sync = true
+        else
+          #puts "redirecting to /dev/null"
+          # We're not bothering to sync if we're dumping to /dev/null
+          # because /dev/null doesn't care about buffered output
+          $stdin.reopen '/dev/null'
+          $stdout.reopen '/dev/null', 'a'
+          $stderr.reopen $stdout
+        end
+        log_path = options[:log] ? options[:log] : '/dev/null'
+      end
+
+    end
+  end
+end

data/lib/acception/subscriber/server_logging.rb

@@ -0,0 +1,81 @@
+require 'yell'
+
+# Provides logging services for the base server.
+#
+module Acception
+  module Subscriber
+    module ServerLogging
+
+    protected
+
+      def initialize_loggers
+        Acception::Subscriber.logger = Yell.new do |l|
+          l.level = log_level
+          l.adapter $stdout, :level => [:debug, :info, :warn]
+          l.adapter $stderr, :level => [:error, :fatal]
+        end
+
+        #Celluloid.logger = Yell.new do |l|
+          #l.level = :info
+          #l.adapter :file, File.join( File.dirname( options[:log] ), "#{APP_ID}-celluloid.log" )
+        #end
+      end
+
+      def log_startup
+        start_banner( options ).each do |line|
+          Acception::Subscriber.logger.info line
+        end
+      end
+
+      def start_banner( options )
+        [
+          "",
+          "***",
+          "* #{APP_NAME} started",
+          "*",
+          "* #{VERSION_COPYRIGHT}",
+          "*",
+          "* Configuration:",
+          (options[:config_loaded] ? "*   file: #{options[:config]}" : nil),
+          Acception::Subscriber::Configuration.attributes.map { |a| "*   #{a}: #{config_value( a )}" },
+          "*",
+          "***",
+        ].flatten.reject( &:nil? )
+      end
+
+      def log_level
+        options.fetch( :log_level, :info ).to_sym
+      end
+
+
+      def config_value( key )
+        value = Acception::Subscriber.configuration.send( key )
+
+        return value unless value.is_a?( Hash )
+
+        return redacted_hash( value )
+      end
+
+      def redacted_hash( hash )
+        redacted_hash = {}
+
+        hash.keys.
+             collect( &:to_s ).
+             grep( /#{redacted_keys}/i ).
+             each do |blacklisted_key|
+          value = hash[blacklisted_key]
+          redacted_hash[blacklisted_key] = value.nil? ? nil : '[REDACTED]'
+        end
+
+        hash.merge( redacted_hash )
+      end
+
+      def redacted_keys
+        %w(
+          password
+        ).join( '|' )
+      end
+
+    end
+  end
+end

data/lib/acception/subscriber/version.rb

@@ -0,0 +1,7 @@
+module Acception
+  module Subscriber
+
+    VERSION = "1.0.0"
+
+  end
+end

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: acception-subscriber
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- C. Jason Harrelson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: acception-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: yell
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: A RabbitMQ subscriber that pushes messages to Acception's API.  See README
+  for more details.
+email:
+- cjharrelson@iberon.com
+executables:
+- acception-sub
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- acception-subscriber.gemspec
+- bin/acception-sub
+- lib/acception-subscriber.rb
+- lib/acception/subscriber.rb
+- lib/acception/subscriber/cli.rb
+- lib/acception/subscriber/configuration.rb
+- lib/acception/subscriber/logging.rb
+- lib/acception/subscriber/message_handler.rb
+- lib/acception/subscriber/publish_error.rb
+- lib/acception/subscriber/server.rb
+- lib/acception/subscriber/server_daemon.rb
+- lib/acception/subscriber/server_logging.rb
+- lib/acception/subscriber/version.rb
+homepage: https://gitlab.staging.iberon.com/common/acception-subscriber
+licenses:
+- ''
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: A RabbitMQ subscriber that pushes messages to Acception's API.
+test_files: []