daemon_objects 0.1.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp
+bin
+log

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm: 1.9.3
+script: bundle exec rake spec

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in daemon_objects.gemspec
+gemspec
+
+group :test do
+  gem 'pry-nav'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Craig Israel
+
+MIT License
+
+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,115 @@
+# DaemonObjects
+[![Build Status](https://travis-ci.org/craigisrael/daemon_objects.png)](https://travis-ci.org/craigisrael/daemon_objects)
+[![Code Climate](https://codeclimate.com/github/craigisrael/daemon_objects.png)](https://codeclimate.com/github/craigisrael/daemon_objects)
+
+Daemon Objects is designed to simplify using daemons in your ruby applications.  Under the hood, it uses the
+[daemons](http://daemons.rubyforge.org) gem, which is a mature and tested solution.  But, it adds support for managing via rake tasks,
+error handling and instrumentation.  
+
+The [daemons](http://daemons.rubyforge.org) gem also is intended to be used to daemonize a ruby script.  DaemonObjects provides an 
+object-oriented framework for developing daemons.  This allows the application developer to focus on the specific behavior of the daemon 
+instead of the infrastructure of daemon management.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'daemon_objects'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install daemon_objects
+
+## Usage
+
+DaemonObjects will create daemons based on a simple convention.  It will search a directory for files name \*Daemon.rb.  These typically 
+will just inherit from the base Daemon class.
+
+    class MyDaemon < DaemonObjects::Base; end
+
+This provides the basic daemon control methods (start, stop, run and restart) to your daemon.
+
+To add behavior to your daemon, you will need a consumer.  DaemonObjects will load the consumer using the name of the daemon and
+will search in the same directory for it.  For example, if your daemon is name MyDaemon, the consumer should be named MyConsumer.
+
+A consumer needs to inherit from the consumer base and implement run.  For example, 
+
+    class MyConsumer < DaemonObjects::ConsumerBase
+
+      def run
+        loop do
+          "I'm looping"
+          sleep 5
+        end
+      end
+
+    end
+
+### Rake tasks
+
+Once you have defined the daemon, you can control it with rake tasks. To access the rake tasks,
+you will need to include the daemon\_objects railtie in config/application.rb.
+
+    require 'daemon_objects/railtie'
+
+Rake tasks are created using the daemon file name.  The rake syntax is:
+
+    rake daemon:<daemon_file_name>:<command>
+
+For example, to start the MyDaemon daemon:
+
+    rake daemon:my_daemon:start
+
+Four commands are supported
+
+* start   - Starts the daemon
+* stop    - Stops the daemon
+* restart - Stops and then starts the daemon
+* run     - Runs the daemon synchronously
+
+### Amqp Support
+
+_in beta_
+
+DaemonObjects also has support for monitoring an amqp queue.  This is done with the amqp gem.  To support this
+with your daemon, add `supports_amqp` to your daemon class.
+
+    class MyQueueProcessingDaemon < Daemon::Base
+      supports_amqp :endpoint     => "http://localhost:5672",
+                    :queue_name   => "my_awesome_queue",
+                    :worker_class => MyAmqpWorker
+    end
+
+This will add the code to monitor the queue, so all you need now is code to handle the messages.
+
+    class MyQueueProcessingConsumer < Daemon::ConsumerBase
+
+      handle_messages_with do |payload|
+        puts "payload"
+      end
+
+    end
+
+### Logging
+
+DaemonObjects will create a new log file for your daemon using the pattern _daemon\_file\_name_\_daemon.log.  In a rails project,
+this will be created in the log directory of your application.
+
+### Support for third-party libraries
+
+DaemonObjects supports the following third-party libraries.  If they are required in your application, your daemon will use them.
+
+* [Airbrake](http://airbrake.io) - any errors that occur in the daemon will be reported to Airbrake.
+* [NewRelic](http://newrelic.com) - amqp daemons will have instrument the handle\_message method and report to New Relic.
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+
+desc "Run rspec spec for those accustomed to the rake task"
+task :spec do
+  sh 'rspec spec'
+end

data/daemon_objects.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'daemon_objects/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "daemon_objects"
+  spec.version       = DaemonObjects::VERSION
+  spec.authors       = ["Craig Israel"]
+  spec.email         = ["craig@theisraels.net"]
+  spec.description   = %q{ Object-oriented daemons}
+  spec.summary       = %q{ Daemon objects provides an object-based interface to daemons}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency "daemons", "~> 1.1"
+  spec.add_dependency "activesupport", "~> 3.2"
+  spec.add_dependency "amqp", "~> 0.9"
+  spec.add_dependency "rake"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry-nav"
+end

data/lib/daemon_objects/amqp_support.rb

@@ -0,0 +1,34 @@
+module DaemonObjects::AmqpSupport
+  attr_accessor :endpoint, :queue, :prefetch, :worker_class
+
+  def arguments
+    @arguments ||= {}
+  end
+
+  def run
+    logger.info "Preparing to start the AMQP watcher."
+
+    AMQP.start(endpoint) do |connection, open_ok|
+      logger.info "Starting up the AMQP watcher."
+
+      channel  = AMQP::Channel.new(connection)
+      channel.prefetch(1) if prefetch
+
+      worker   = worker_class.new(
+        channel, 
+        get_consumer, 
+        {
+          :queue_name => queue,
+          :arguments  => arguments
+        })
+
+      worker.start
+
+      Signal.trap("INT") do
+        logger.info "Exiting process"
+        connection.close { EventMachine.stop } 
+      end
+
+    end
+  end
+end

data/lib/daemon_objects/base.rb

@@ -0,0 +1,75 @@
+require 'daemon_objects/logging'
+
+class DaemonObjects::Base
+  extend DaemonObjects::Logging
+
+  def self.consumes_amqp(opts={})
+    extend DaemonObjects::AmqpSupport
+    self.endpoint = opts.delete(:endpoint)
+    self.queue    = opts.delete(:queue_name)
+    self.arguments["x-message-ttl"] = opts.delete(:ttl) if opts[:ttl]
+    self.prefetch = opts.delete(:prefetch)
+    self.worker_class = opts.delete(:worker_class)
+
+    logger.info "Configured to consume queue [#{queue}] at endpoint [#{endpoint}]"
+  end
+
+  def self.pid_directory
+    (defined? Rails) ? File.join(Rails.root, "tmp/pids") : "."
+  end
+
+  def self.consumer_class
+    @consumer_class ||= "#{self.to_s.gsub("Daemon", "")}Consumer".constantize
+  end
+
+  def self.proc_name
+    @proc_name ||= self.to_s.underscore
+  end
+
+  def self.get_consumer
+    consumer_class.new(logger)
+  end
+
+  def self.run
+    get_consumer.run
+  end
+
+  def self.after_fork
+    # daemonizing closes all file handles, so this will reopen the log
+    force_logger_reset 
+    # this seems to be enough to initialize NewRelic if it's defined
+    defined?(NewRelic)
+  end
+
+  def self.start
+    # connection will get severed on fork, so disconnect first
+    ActiveRecord::Base.connection.disconnect! if defined?(ActiveRecord::Base)
+
+    FileUtils.mkdir_p(pid_directory)
+
+    Daemons.run_proc(proc_name, 
+                    { :ARGV       => ["start", "-f"],
+                      :log_dir    => "/tmp",
+                      :dir        => pid_directory,
+                      :log_output => true}) do
+      
+      after_fork
+      run  
+    end
+
+  rescue StandardError => e
+    logger.error(e.message)
+    logger.error(e.backtrace.join("\n"))
+    Airbrake.notify(e) if defined?(Airbrake)
+  end
+
+  def self.stop
+    Daemons.run_proc(proc_name, { :ARGV => [ "stop", "-f" ], :dir => pid_directory})
+  end
+
+  def self.restart
+    start
+    stop
+  end
+
+end

data/lib/daemon_objects/consumer_base.rb

@@ -0,0 +1,35 @@
+class DaemonObjects::ConsumerBase
+
+  include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation if defined?(::NewRelic)
+
+  class << self 
+    attr_accessor :message_handler
+  end
+
+  attr_accessor :logger
+
+  def initialize(logger)
+    @logger = logger
+  end
+
+  def run
+    logger.info("Starting consumer")
+  end
+
+  def handle_message(payload)
+    logger.info("Handling message #{payload}")
+    handle_message_impl(payload)
+    logger.info("Completed handling message")
+  rescue StandardError => e
+    logger.error("#{e.class}:  #{e.message}")
+    logger.error(e.backtrace.join("\n"))
+    Airbrake.notify(e) if defined?(Airbrake)
+  end
+
+  def self.handle_messages_with(&block)
+    raise StandardError.new("Provided block must take at least one argument - 'payload'") if block.arity < 1
+    define_method(:handle_message_impl, &block) 
+  end
+
+  add_transaction_tracer :handle_message, :category => :task if defined?(::NewRelic)
+end

data/lib/daemon_objects/loader.rb

@@ -0,0 +1,31 @@
+module DaemonObjects
+  ROOT = File.join(File.dirname(__FILE__))
+
+  DAEMON_FILE_ENDING = "_daemon.rb"
+
+  class << self 
+    attr_accessor :daemon_path
+
+    def daemon_path
+      @daemon_path ||= File.join(Rake.application.original_dir, "lib/daemons")
+    end
+
+    def daemons
+      @daemons ||= get_daemons
+    end
+
+    def get_daemon_name(path)
+      file = Pathname(path).basename.to_s
+      file.gsub!(/#{DAEMON_FILE_ENDING}$/, "")
+    end
+
+    private
+    
+    def get_daemons
+      paths = Dir["#{daemon_path}/*#{DAEMON_FILE_ENDING}"]
+      warn "No daemons found at #{daemon_path}" if paths.empty?
+      paths.map{|p| get_daemon_name(p) }
+    end
+
+  end
+end

data/lib/daemon_objects/logging.rb

@@ -0,0 +1,31 @@
+module DaemonObjects::Logging
+
+  def log_filename
+    "#{to_s.underscore}.log"
+  end
+
+  def log_directory
+    (defined? Rails) ? File.join(Rails.root, "log") : "log"
+  end
+
+  def logger
+    @logger ||= create_logger
+  end
+
+  def create_logger
+    FileUtils.mkdir_p log_directory
+    logger = ::Logger.new(File.join(log_directory, log_filename))
+    logger.formatter = ::Logger::Formatter.new
+    logger
+  end
+
+  def logger=(value)
+    @logger = value
+  end
+
+  def force_logger_reset
+    @logger = nil
+    Rails.logger = logger if defined?(Rails)
+  end
+
+end

data/lib/daemon_objects/railtie.rb

@@ -0,0 +1,6 @@
+class Railtie < Rails::Railtie
+  rake_tasks do
+    require "daemon_objects/loader"
+    load File.join(File.dirname(__FILE__), "tasks/daemon_objects.rake")
+  end
+end if defined?(Rails)

data/lib/daemon_objects/tasks/daemon_objects.rake

@@ -0,0 +1,41 @@
+namespace :daemon do
+
+  # create tasks for each daemon to start/stop/restart/run
+  DaemonObjects.daemons.each do |daemon|
+
+    namespace daemon do
+      description = "#{daemon.to_s.gsub("_", " ")} daemon"
+      desc "starts the #{description}; can substitute stop or restart for start, " +
+        "or use run to run the daemon in the foreground"
+
+      [:start, :stop, :run].each do |action|
+        task action => :environment do
+
+          require "daemon_objects"
+          require "#{DaemonObjects.daemon_path}/#{daemon}_daemon.rb"
+          require "#{DaemonObjects.daemon_path}/#{daemon}_consumer.rb"
+
+
+          puts "#{description} #{action}"
+          daemon_class = "#{daemon}_daemon".camelcase.constantize
+          daemon_class.send(action)
+        end
+      end
+
+      task :restart => [:environment, :stop, :start]
+    end
+  end
+
+  namespace :all do
+
+    desc 'start all daemons'
+    task :start => DaemonObjects.daemons.map{|d| "daemon:#{d}:start"}
+
+    desc 'stop all daemons'
+    task :stop => DaemonObjects.daemons.map{|d| "daemon:#{d}:stop"}
+
+    desc 'restart all daemons'
+    task :restart => [:stop, :start]
+  end
+
+end

data/lib/daemon_objects/version.rb

@@ -0,0 +1,3 @@
+module DaemonObjects
+  VERSION = "0.1.0"
+end

data/lib/daemon_objects.rb

@@ -0,0 +1,14 @@
+require "daemon_objects/version"
+require 'active_support/core_ext/string'
+require 'daemons'
+require 'amqp'
+require 'logger'
+
+module DaemonObjects; end
+
+require 'daemon_objects/loader'
+require 'daemon_objects/base'
+require 'daemon_objects/consumer_base'
+require 'daemon_objects/amqp_support'
+require 'daemon_objects/railtie'
+

data/spec/lib/daemon_objects/base_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe DaemonObjects::Base do
+  after :each do
+    [ :MyDaemon, :ThreePartNameDaemon, :MyConsumer].each do |sym|
+      Object.send(:remove_const, sym) if Object.const_defined?(sym)
+    end
+  end
+
+  describe '#extends' do
+    it 'should extend logging' do
+      MyDaemon = Class.new(DaemonObjects::Base)
+      MyDaemon.singleton_class.included_modules.should include(DaemonObjects::Logging)
+    end
+  end
+
+  describe '#run' do
+    it 'should create new consumer' do
+      MyConsumer = Class.new(DaemonObjects::ConsumerBase)
+
+      MyDaemon = Class.new(DaemonObjects::Base) do
+        self.logger = StubLogger.new
+      end
+
+      MyDaemon.run
+      MyDaemon.logger.logged_output.should =~ /Starting consumer\n/
+    end
+
+  end
+
+  describe '#start' do
+    it 'should call daemon run_proc' do
+      MyDaemon = Class.new(DaemonObjects::Base)
+      Daemons.should_receive(:run_proc).
+        with(MyDaemon.proc_name,
+             { :ARGV       => ['start', '-f'],
+               :log_dir    => "/tmp",
+               :dir        => MyDaemon.pid_directory,
+               :log_output => true
+              } )
+      MyDaemon.start
+    end
+  end
+
+  describe '#stop' do
+    it 'should call daemon stop_proc' do
+      MyDaemon = Class.new(DaemonObjects::Base)
+      Daemons.should_receive(:run_proc).
+        with(MyDaemon.proc_name,
+             { :ARGV => ['stop', '-f'],
+              :dir   => MyDaemon.pid_directory})
+      MyDaemon.stop
+    end
+  end
+
+  describe '##consumer_class' do
+    it 'should constantize a file with multiple part name' do
+      ThreePartNameConsumer = Class.new 
+      ThreePartNameDaemon = Class.new(DaemonObjects::Base)
+      ThreePartNameDaemon.consumer_class.should == ThreePartNameConsumer
+    end
+  end
+
+  describe '##proc_name' do
+    it 'should underscore class to get daemon name' do
+      ThreePartNameDaemon = Class.new(DaemonObjects::Base)
+      ThreePartNameDaemon.proc_name.should == "three_part_name_daemon"
+    end
+  end
+
+  describe 'AMQP support' do
+    let(:endpoint){ }
+
+    before :each do
+      MyWorker = Class.new do
+        def initialize(*args); end
+        def run; end
+      end
+    end
+
+    after :each do
+      Object.send( :remove_const, :MyWorker) if defined?(MyWorker)
+    end
+
+    it 'should start AMQP if daemon is an amqp consumer' do
+      MyConsumer = Class.new(DaemonObjects::ConsumerBase)
+      MyDaemon = Class.new(DaemonObjects::Base) do
+        consumes_amqp :endpoint   => 'amqp://localhost:4567',
+                      :queue_name => 'queue',
+                      :worker_class => MyWorker
+      end
+
+      AMQP.should_receive(:start).with('amqp://localhost:4567').and_return(true)
+      MyDaemon.run
+    end
+
+    it 'should not start AMQP if daemon is not an amqp consumer' do
+      MyConsumer = Class.new(DaemonObjects::ConsumerBase)
+      MyDaemon = Class.new(DaemonObjects::Base)
+
+      AMQP.should_not_receive(:start)
+      MyDaemon.run
+
+    end
+
+    it 'should start a worker' do
+      MyConsumer = Class.new(DaemonObjects::ConsumerBase)
+      MyDaemon = Class.new(DaemonObjects::Base) do
+        consumes_amqp :endpoint   => 'amqp://localhost:4567',
+                      :queue_name => 'queue',
+                      :worker_class => MyWorker
+      end
+
+      def AMQP.start(endpoint)
+        yield "connection", "open"
+      end
+
+      channel = double(AMQP::Channel)
+      AMQP::Channel.stub(:new).and_return(channel)
+      channel.should_not_receive(:prefetch)
+
+      worker  = MyWorker.new
+      consumer = MyDaemon.get_consumer
+      MyDaemon.stub(:get_consumer).and_return(consumer)
+
+      MyWorker.should_receive(:new).
+        with(channel, consumer, {
+              :queue_name => 'queue',
+              :arguments  => {}
+        }).
+        and_return(worker)
+      worker.should_receive(:start)
+
+      MyDaemon.run
+    end
+
+    it 'should use prefetch value when available' do
+      MyConsumer = Class.new(DaemonObjects::ConsumerBase)
+      MyDaemon = Class.new(DaemonObjects::Base) do
+        consumes_amqp :endpoint     => 'amqp://localhost:4567',
+                      :queue_name   => 'queue',
+                      :prefetch     => 1,
+                      :worker_class => MyWorker
+      end
+
+      def AMQP.start(endpoint)
+        yield "connection", "open"
+      end
+
+      channel = double(AMQP::Channel)
+      channel.should_receive(:prefetch).with(1)
+
+      AMQP::Channel.stub(:new).and_return(channel)
+
+      worker  = MyWorker.new
+      consumer = MyDaemon.get_consumer
+      MyDaemon.stub(:get_consumer).and_return(consumer)
+
+      MyWorker.should_receive(:new).
+        with(channel, consumer, {
+              :queue_name => 'queue',
+              :arguments  => {}
+        }).
+        and_return(worker)
+      worker.should_receive(:start)
+
+      MyDaemon.run
+    end
+  end
+
+end
+
+

data/spec/lib/daemon_objects/consumer_base_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe DaemonObjects::ConsumerBase do
+  describe '#handle_message' do
+    after :each do
+      Object.send(:remove_const, :Harness)
+    end
+
+    it 'should call the configured message handler' do
+
+      Harness = Class.new(DaemonObjects::ConsumerBase) do
+        def payloads_received
+          @payloads_received ||= []
+        end
+
+        handle_messages_with{|p| payloads_received << p }
+      end
+
+      h = Harness.new(StubLogger.new)
+      h.handle_message({:x => 1})
+
+      h.payloads_received.should == [{:x => 1}]
+    end
+  end
+    
+end

data/spec/lib/daemon_objects/logging_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe DaemonObjects::Logging do
+  let(:harness) do
+    Class.new do
+      extend DaemonObjects::Logging
+    end
+  end
+
+  describe '#logger' do
+    it 'should create a logger at log/log_filename path' do
+      logger = StubLogger.new
+
+      Logger.stub(:new).
+        with("#{harness.log_directory}/#{harness.log_filename}").
+        and_return(logger)
+
+      harness.logger.info("starting consumer")
+
+      logger.logged_output.should =~ /starting consumer\n$/
+    end
+  end
+
+  describe '#create_logger' do
+    it 'should create a logger with timestamp formatting' do
+      logger = harness.logger
+      logger.formatter.class.should == ::Logger::Formatter
+    end
+  end
+
+  describe '#log_filename' do
+    before :each do
+      MyDaemon = Class.new do
+        extend DaemonObjects::Logging
+      end
+    end
+
+    after :each do
+      Object.send(:remove_const, :MyDaemon)
+    end
+
+    it 'should underscore name for log file' do
+      MyDaemon.log_filename.should == "my_daemon.log"
+    end
+  end
+
+  describe '#log_directory' do
+    it "should use 'log' for default log path" do
+      harness.log_directory.to_s.should == "log"
+    end
+
+    context 'with rails' do
+      before :each do
+        unless defined?(Rails)
+          module Rails
+            def self.root
+              "/root"
+            end
+          end
+        end
+      end
+
+      after :each do
+        Object.send(:remove_const, :Rails)
+      end
+
+      it 'should use Rails log path when Rails is defined' do
+        harness.log_directory.to_s.should == File.join(Rails.root, "log")
+      end
+    end
+
+  end
+
+
+end

data/spec/lib/daemon_objects_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe DaemonObjects do
+  describe '#daemons' do
+    it 'should get daemons from daemon_path' do
+      DaemonObjects.daemon_path = File.join(FIXTURES_PATH, "daemon_path_spec")
+      DaemonObjects.daemons.sort.should == ["daemon_one", "daemon_two"]
+    end
+  end
+
+  describe '#get_daemon_name' do
+    it 'should parse out path and Daemon.rb' do
+      path = File.join(FIXTURES_PATH, "daemon_path_spec/daemon_one_daemon.rb")
+      DaemonObjects.get_daemon_name(path).should == "daemon_one"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'pry'
+SPEC_PATH = File.dirname(__FILE__)
+Dir[File.join(SPEC_PATH, "support/**/*.rb")].each{|f| require f}
+
+FIXTURES_PATH = File.join(SPEC_PATH, "fixtures")
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+require File.join(File.dirname(__FILE__), "../lib/daemon_objects.rb")

data/spec/support/stub_logger.rb

@@ -0,0 +1,23 @@
+class StubLogger
+
+  attr_accessor :logger
+
+  def method_missing(sym, *args, &block)
+    logger.send(sym, *args, &block)
+  end
+
+  def initialize
+    @io = StringIO.new
+
+    require 'logger'
+    @logger = Logger.new(@io)
+  end
+
+  def logged_output
+    @io.string
+  end
+
+  def messages
+    logged_output.split("\n")
+  end
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: daemon_objects
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Craig Israel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: amqp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! ' Object-oriented daemons'
+email:
+- craig@theisraels.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- daemon_objects.gemspec
+- lib/daemon_objects.rb
+- lib/daemon_objects/amqp_support.rb
+- lib/daemon_objects/base.rb
+- lib/daemon_objects/consumer_base.rb
+- lib/daemon_objects/loader.rb
+- lib/daemon_objects/logging.rb
+- lib/daemon_objects/railtie.rb
+- lib/daemon_objects/tasks/daemon_objects.rake
+- lib/daemon_objects/version.rb
+- spec/fixtures/daemon_path_spec/daemon_one_daemon.rb
+- spec/fixtures/daemon_path_spec/daemon_two_daemon.rb
+- spec/lib/daemon_objects/base_spec.rb
+- spec/lib/daemon_objects/consumer_base_spec.rb
+- spec/lib/daemon_objects/logging_spec.rb
+- spec/lib/daemon_objects_spec.rb
+- spec/spec_helper.rb
+- spec/support/stub_logger.rb
+homepage: ''
+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: Daemon objects provides an object-based interface to daemons
+test_files:
+- spec/fixtures/daemon_path_spec/daemon_one_daemon.rb
+- spec/fixtures/daemon_path_spec/daemon_two_daemon.rb
+- spec/lib/daemon_objects/base_spec.rb
+- spec/lib/daemon_objects/consumer_base_spec.rb
+- spec/lib/daemon_objects/logging_spec.rb
+- spec/lib/daemon_objects_spec.rb
+- spec/spec_helper.rb
+- spec/support/stub_logger.rb