circuitry 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2399e4bc4f1e1d82e117415684b20c2920e34020
+  data.tar.gz: 9b497dde60c50e60b945ef80be7dbe07382755e8
+SHA512:
+  metadata.gz: b026a20b13d88fcfa09b7ab069578c236fca5dff3aa94f80b98e13aa4d2520b195a4c0cbed62f679211ee27cc54bb05be2f8657f6b738e63620422883b692be7
+  data.tar.gz: 6248ef0005b4c98c9aa3d50cdf977a3426b78d8f8eac8a420ed4066ae258b2128e614e1ef091e5b829ba7eea1610546ec7b27692f554e2e2572f1fe5777149c8

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.idea/
+/.ruby-gemset
+/.ruby-version
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in circuitry.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Kapost
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,183 @@
+# Circuitry
+
+Notification pub/sub and message queue processing using Amazon
+[SNS](http://aws.amazon.com/sns/) & [SQS](http://aws.amazon.com/sqs/).
+
+[![Code Climate](https://codeclimate.com/repos/55720235e30ba0148f003033/badges/697cd6b997cc25e808f3/gpa.svg)](https://codeclimate.com/repos/55720235e30ba0148f003033/feed)
+[![Test Coverage](https://codeclimate.com/repos/55720235e30ba0148f003033/badges/697cd6b997cc25e808f3/coverage.svg)](https://codeclimate.com/repos/55720235e30ba0148f003033/coverage)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'circuitry'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install circuitry
+
+## Usage
+
+Circuitry is configured via its configuration object.
+
+```ruby
+Circuitry.config do |c|
+  c.access_key = 'YOUR_AWS_ACCESS_KEY'
+  c.secret_key = 'YOUR_AWS_SECRET_KEY'
+  c.region = 'us-east-1'
+  c.logger = Rails.logger
+  c.error_handler = proc do |error|
+    HoneyBadger.notify(error)
+    HoneyBadger.flush
+  end
+end
+```
+
+Available configuration options include:
+
+* `access_key`: The AWS access key ID that has access to SNS publishing and/or
+  SQS subscribing.  *(required)*
+* `secret_key`: The AWS secret access key that has access to SNS publishing
+  and/or SQS subscribing.  *(required)*
+* `region`: The AWS region that your SNS and/or SQS account lives in.
+  *(optional, default: "us-east-1")*
+* `logger`: The logger to use for informational output, warnings, and error
+  messages.  *(optional, default: `Logger.new(STDOUT)`)*
+* `error_handler`: An object that responds to `call` with two arguments: the
+  deserialized message contents and the topic name used when publishing to SNS.
+  *(optional, default: `nil`)*
+
+### Publishing
+
+Publishing is done via the `Circuitry.publish` method.  It accepts a topic name
+the represents the SNS topic along with any non-nil object, representing the data
+to be serialized.  Whatever object is called will have its `to_json` method
+called for serialization.
+
+```ruby
+obj = { foo: 'foo', bar: 'bar' }
+Circuitry.publish('any-topic-name', obj)
+```
+
+The `publish` method also accepts options that impact instantiation of the
+`Publisher` object, which currently includes the following options.
+
+* `:async` - Whether or not publishing should occur in the background.  Please
+   refer to the [Asynchronous Support](#asynchronous-support) section for more
+   details regarding this option.  (default: false)
+
+```ruby
+obj = { foo: 'foo', bar: 'bar' }
+Circuitry.publish('my-topic-name', obj, async: true)
+```
+
+Alternatively, if your options hash will remain unchanged, you can build a single
+`Publisher` object to use for all publishing.
+
+```ruby
+options = { ... }
+publisher = Circuitry::Publisher.new(options)
+publisher.publish('my-topic-name', obj)
+```
+
+### Subscribing
+
+Subscribing is done via the `Circuitry.subscribe` method.  It accepts an SQS queue
+URL and takes a block for processing each message.  This method performs
+synchronously by default, and as such does not return.
+
+```ruby
+Circuitry.subscribe('https://sqs.REGION.amazonaws.com/ACCOUNT-ID/QUEUE-NAME') do |message, topic_name|
+  puts "Received #{topic_name} message: #{message.inspect}"
+end
+```
+
+The `subscribe` method also accepts options that impact instantiation of the
+`Subscriber` object, which currently includes the following options.
+
+* `:async` - Whether or not subscribing should occur in the background.  Please
+   refer to the [Asynchronous Support](#asynchronous-support) section for more
+   details regarding this option.  (default: false)
+* `:wait_time` - The number of seconds to wait for messages while connected to
+  SQS.  Anything above 0 results in long-polling, while 0 results in
+  short-polling.  (default: 10)
+* `:batch_size` - The number of messages to retrieve in a single SQS request.
+  (default: 10)
+
+```ruby
+Circuitry.subscribe('https://...', async: true, wait_time: 60, batch_size: 20) do |message, topic_name|
+  # ...
+end
+```
+
+Alternatively, if your options hash will remain unchanged, you can build a single
+`Subscriber` object to use for all subscribing.
+
+```ruby
+options = { ... }
+subscriber = Circuitry::Subscriber.new(options)
+subscriber.subscribe('https://...') do |message, topic_name|
+  # ...
+end
+```
+
+### Asynchronous Support
+
+Publishing or subscribing asynchronously occurs by forking a child process.  That
+child is then detached so that your application does not need to worry about
+waiting for the process to finish.
+
+There are two important notes regarding forking in general as it relates to
+asynchronous support:
+
+1. Forking is not supported on all platforms (e.g.: Windows and NetBSD 4),
+   requiring that your implementation use synchronous requests in such
+   circumstances.  You can determine if asynchronous requests will work by
+   calling `Circuitry.platform_supports_async?`.
+
+2. Forking results in resources being copied from the parent process to the child
+   process.  In order to prevent database connection errors and the like, you
+   should properly handle closing and reopening resources before and after
+   forking, respectively.  For example, if you are using Rails with Unicorn, you
+   may need to add the following code to your `unicorn.rb` configuration:
+
+        before_fork do |server, worker|
+          if defined?(ActiveRecord::Base)
+            ActiveRecord::Base.connection.disconnect!
+          end
+        end
+
+        after_fork do |server, worker|
+          if defined?(ActiveRecord::Base)
+            ActiveRecord::Base.establish_connection(
+              Rails.application.config.database_configuration[Rails.env]
+            )
+          end
+        end
+
+   Refer to your adapter's documentation to determine how resources are handled
+   with regards to forking.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release` to create a git tag for the version, push git commits
+and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/kapost/circuitry/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "circuitry"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/circle.yml

@@ -0,0 +1,3 @@
+dependencies:
+  pre:
+    - gem install bundler -v 1.8.9

data/circuitry.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'circuitry/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'circuitry'
+  spec.version       = Circuitry::VERSION
+  spec.authors       = ['Matt Huggins']
+  spec.email         = ['matt.huggins@kapost.com']
+
+  spec.summary       = %q{Kapost notification pub/sub and message queue processing.}
+  spec.description   = %q{Amazon SNS publishing and SQS queue processing.}
+  spec.homepage      = 'https://github.com/kapost/circuitry'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'fog-aws', '~> 0.4'
+  spec.add_dependency 'virtus', '~> 1.0'
+
+  spec.add_development_dependency 'pry-nav'
+  spec.add_development_dependency 'bundler', '~> 1.8'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.2'
+  spec.add_development_dependency 'rspec-its', '~> 1.2'
+  spec.add_development_dependency 'codeclimate-test-reporter'
+end

data/lib/circuitry.rb

@@ -0,0 +1,24 @@
+require 'circuitry/version'
+require 'circuitry/configuration'
+require 'circuitry/publisher'
+require 'circuitry/subscriber'
+
+module Circuitry
+  def self.config(&block)
+    @config ||= Configuration.new
+    block.call(@config) if block_given?
+    @config
+  end
+
+  def self.publish(topic_name, object, options = {})
+    Publisher.new(options).publish(topic_name, object)
+  end
+
+  def self.subscribe(queue, options = {}, &block)
+    Subscriber.new(queue, options).subscribe(&block)
+  end
+
+  def self.platform_supports_async?
+    Process.respond_to?(:fork)
+  end
+end

data/lib/circuitry/concerns/async.rb

@@ -0,0 +1,18 @@
+module Circuitry
+  class NotSupportedError < StandardError; end
+
+  module Concerns
+    module Async
+      def process_asynchronously(&block)
+        raise NotSupportedError, 'Your platform does not support forking' unless platform_supports_async?
+
+        pid = fork(&block)
+        Process.detach(pid)
+      end
+
+      def platform_supports_async?
+        Circuitry.platform_supports_async?
+      end
+    end
+  end
+end

data/lib/circuitry/configuration.rb

@@ -0,0 +1,22 @@
+require 'logger'
+require 'virtus'
+
+module Circuitry
+  class Configuration
+    include Virtus::Model
+
+    attribute :access_key, String
+    attribute :secret_key, String
+    attribute :region, String, default: 'us-east-1'
+    attribute :logger, Logger, default: Logger.new(STDERR)
+    attribute :error_handler
+
+    def aws_options
+      {
+          aws_access_key_id:     access_key,
+          aws_secret_access_key: secret_key,
+          region:                region,
+      }
+    end
+  end
+end

data/lib/circuitry/message.rb

@@ -0,0 +1,32 @@
+require 'json'
+require 'circuitry/topic'
+
+module Circuitry
+  class Message
+    attr_reader :raw
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def context
+      @context ||= JSON.parse(raw['Body'])
+    end
+
+    def body
+      @body ||= JSON.parse(context['Message'], quirks_mode: true)
+    end
+
+    def topic
+      @topic ||= Topic.new(context['TopicArn'])
+    end
+
+    def id
+      raw['MessageId']
+    end
+
+    def receipt_handle
+      raw['ReceiptHandle']
+    end
+  end
+end

data/lib/circuitry/publisher.rb

@@ -0,0 +1,60 @@
+require 'json'
+require 'circuitry/concerns/async'
+require 'circuitry/services/sns'
+require 'circuitry/topic_creator'
+
+module Circuitry
+  class PublishError < StandardError; end
+
+  class Publisher
+    include Concerns::Async
+    include Services::SNS
+
+    DEFAULT_OPTIONS = {
+        async: false,
+    }.freeze
+
+    def initialize(options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+
+      @async = !!options[:async]
+    end
+
+    def publish(topic_name, object)
+      raise ArgumentError.new('topic_name cannot be nil') if topic_name.nil?
+      raise ArgumentError.new('object cannot be nil') if object.nil?
+
+      unless can_publish?
+        logger.warn('Circuitry unable to publish: AWS configuration is not set.')
+        return
+      end
+
+      process = -> do
+        topic = TopicCreator.find_or_create(topic_name)
+        sns.publish(topic.arn, object.to_json)
+      end
+
+      if async?
+        process_asynchronously(&process)
+      else
+        process.call
+      end
+    end
+
+    def async?
+      @async
+    end
+
+    private
+
+    def logger
+      Circuitry.config.logger
+    end
+
+    def can_publish?
+      Circuitry.config.aws_options.values.all? do |value|
+        !value.nil? && !value.empty?
+      end
+    end
+  end
+end

data/lib/circuitry/services/sns.rb

@@ -0,0 +1,11 @@
+require 'fog/aws'
+
+module Circuitry
+  module Services
+    module SNS
+      def sns
+        @sns ||= Fog::AWS::SNS.new(Circuitry.config.aws_options)
+      end
+    end
+  end
+end

data/lib/circuitry/services/sqs.rb

@@ -0,0 +1,11 @@
+require 'fog/aws'
+
+module Circuitry
+  module Services
+    module SQS
+      def sqs
+        @sqs ||= Fog::AWS::SQS.new(Circuitry.config.aws_options)
+      end
+    end
+  end
+end

data/lib/circuitry/subscriber.rb

@@ -0,0 +1,116 @@
+require 'circuitry/concerns/async'
+require 'circuitry/services/sqs'
+require 'circuitry/message'
+
+module Circuitry
+  class SubscribeError < StandardError; end
+
+  class Subscriber
+    include Concerns::Async
+    include Services::SQS
+
+    attr_reader :queue, :wait_time, :batch_size, :max_retries, :failure_queue
+
+    DEFAULT_OPTIONS = {
+        async: false,
+        wait_time: 10,
+        batch_size: 10,
+    }.freeze
+
+    CONNECTION_ERRORS = [
+        Excon::Errors::Forbidden,
+    ].freeze
+
+    def initialize(queue, options = {})
+      raise ArgumentError.new('queue cannot be nil') if queue.nil?
+
+      options = DEFAULT_OPTIONS.merge(options)
+
+      @queue = queue
+      @async = !!options[:async]
+      @wait_time = options[:wait_time]
+      @batch_size = options[:batch_size]
+    end
+
+    def subscribe(&block)
+      raise ArgumentError.new('block required') if block.nil?
+
+      unless can_subscribe?
+        logger.warn('Circuitry unable to subscribe: AWS configuration is not set.')
+        return
+      end
+
+      process = -> do
+        loop do
+          begin
+            receive_messages(&block)
+          rescue *CONNECTION_ERRORS => e
+            logger.error "Connection error to #{queue}: #{e}"
+            raise SubscribeError.new(e)
+          end
+        end
+      end
+
+      if async?
+        process_asynchronously(&process)
+      else
+        process.call
+      end
+    end
+
+    def async?
+      @async
+    end
+
+    private
+
+    def receive_messages(&block)
+      response = sqs.receive_message(queue, 'MaxNumberOfMessages' => batch_size, 'WaitTimeSeconds' => wait_time)
+      messages = response.body['Message']
+      return if messages.empty?
+
+      messages.each do |message|
+        process_message(message, &block)
+      end
+    end
+
+    def process_message(message, &block)
+      message = Message.new(message)
+
+      unless message.nil?
+        logger.info "Processing message #{message.id}"
+        handle_message(message, &block)
+        delete_message(message)
+      end
+    rescue => e
+      logger.error "Error processing message #{message.id}: #{e}"
+      error_handler.call(e) if error_handler
+    end
+
+    def handle_message(message, &block)
+      block.call(message.body, message.topic.name)
+    rescue => e
+      logger.error("Error handling message #{message.id}: #{e}")
+      raise e
+    end
+
+    def delete_message(message)
+      logger.info("Removing message #{message.id} from queue")
+      sqs.delete_message(queue, message.receipt_handle)
+    end
+
+    def logger
+      Circuitry.config.logger
+    end
+
+    def error_handler
+      Circuitry.config.error_handler
+    end
+
+    def can_subscribe?
+      Circuitry.config.aws_options.values.all? do |value|
+        !value.nil? && !value.empty?
+      end
+    end
+  end
+end

data/lib/circuitry/topic.rb

@@ -0,0 +1,21 @@
+module Circuitry
+  class Topic
+    attr_reader :arn
+
+    def initialize(arn)
+      @arn = arn
+    end
+
+    def name
+      arn.split(':').last
+    end
+
+    def ==(obj)
+      obj.hash == self.hash
+    end
+
+    def hash
+      [self.class, arn].hash
+    end
+  end
+end

data/lib/circuitry/topic_creator.rb

@@ -0,0 +1,28 @@
+require 'circuitry/services/sns'
+require 'circuitry/topic'
+
+module Circuitry
+  class TopicCreatorError < StandardError; end
+
+  class TopicCreator
+    include Services::SNS
+
+    attr_reader :topic_name
+
+    def self.find_or_create(topic_name)
+      new(topic_name).topic
+    end
+
+    def initialize(topic_name)
+      @topic_name = topic_name
+    end
+
+    def topic
+      return @topic if defined?(@topic)
+
+      response = sns.create_topic(topic_name)
+      arn = response.body.fetch('TopicArn') { raise TopicCreatorError.new('No TopicArn returned from SNS') }
+      @topic = Topic.new(arn)
+    end
+  end
+end

data/lib/circuitry/version.rb

@@ -0,0 +1,3 @@
+module Circuitry
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: circuitry
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Matt Huggins
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog-aws
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  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'
+description: Amazon SNS publishing and SQS queue processing.
+email:
+- matt.huggins@kapost.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- circle.yml
+- circuitry.gemspec
+- lib/circuitry.rb
+- lib/circuitry/concerns/async.rb
+- lib/circuitry/configuration.rb
+- lib/circuitry/message.rb
+- lib/circuitry/publisher.rb
+- lib/circuitry/services/sns.rb
+- lib/circuitry/services/sqs.rb
+- lib/circuitry/subscriber.rb
+- lib/circuitry/topic.rb
+- lib/circuitry/topic_creator.rb
+- lib/circuitry/version.rb
+homepage: https://github.com/kapost/circuitry
+licenses:
+- MIT
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Kapost notification pub/sub and message queue processing.
+test_files: []