daemon_objects 0.1.9 → 0.2.0

data/.gitignore

@@ -18,3 +18,4 @@ tmp
 *.swp
 bin
 log
+tags

data/Gemfile

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

data/README.md

@@ -5,10 +5,10 @@
 
 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.  
+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 
+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
@@ -27,7 +27,7 @@ Or install it yourself as:
 
 ## Usage
 
-DaemonObjects will create daemons based on a simple convention.  It will search a directory for files name \*Daemon.rb.  These typically 
+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
@@ -37,7 +37,7 @@ This provides the basic daemon control methods (start, stop, run and restart) to
 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, 
+A consumer needs to inherit from the consumer base and implement run.  For example,
 
     class MyConsumer < DaemonObjects::ConsumerBase
 
@@ -50,6 +50,25 @@ A consumer needs to inherit from the consumer base and implement run.  For examp
 
     end
 
+### Environment
+
+You can pass an environment argument to the consumer in two ways.  If the project is
+using Rails, it will automatically use `Rails.env`.  Otherwise, you can use the
+`DAEMON_ENV` environment variable.
+
+### Application directory
+
+Application directory can be set a number of ways.  If the project is using Rails, the
+application directory is `Rails.root`.  If the task was started with Rake, it will be
+`Rake.original_dir`.  You can also override this value by defining an `app_directory`
+method in the `DaemonBase` subclass.
+
+    class MyDaemon < DaemonObjects::Base
+      def app_directory
+        "/some/other/directory"
+      end
+    end
+
 ### Rake tasks
 
 Once you have defined the daemon, you can control it with rake tasks. To access the rake tasks,
@@ -74,22 +93,19 @@ Four commands are supported
 
 ### Amqp Support
 
-_in beta_
+DaemonObjects also has support for monitoring amqp queues.  This is done with the bunny gem.  To support this with your daemon, add `consumes_amqp` to your daemon class, one pair of daemon/consumer classes per queue you wish to support.  Queues are constructed as 'durable' by default.
 
-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",
+    class MyQueueProcessingDaemon < DaemonObjects::Base
+      consumes_amqp :endpoint     => "http://localhost:5672",
                     :queue_name   => "my_awesome_queue"
     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
+    class MyQueueProcessingConsumer < DaemonObjects::ConsumerBase
 
       handle_messages_with do |payload|
-        puts "payload"
+        puts payload
       end
 
     end
@@ -99,6 +115,8 @@ This will add the code to monitor the queue, so all you need now is code to hand
 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.
 
+If the daemon does not have access to create the log, it will log errors to /tmp/_daemon_name_.output.
+
 ### Support for third-party libraries
 
 DaemonObjects supports the following third-party libraries.  If they are required in your application, your daemon will use them.

data/daemon_objects.gemspec

@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "pry-nav"
+  spec.add_development_dependency "memory_logger", "~> 0.0.3"
 end

data/lib/daemon_objects/base.rb

@@ -17,8 +17,16 @@ class DaemonObjects::Base
     logger.info "Worker class is '#{worker_class}'"
   end
 
+  def self.app_directory
+    @app_directory ||= (defined? Rails) ? Rails.root : Rake.original_dir
+  end
+
+  def self.environment
+    @environment ||= (defined? Rails) ? Rails.env : ENV["DAEMON_ENV"]
+  end
+
   def self.pid_directory
-    (defined? Rails) ? File.join(Rails.root, "tmp/pids") : "."
+    File.join(app_directory, "tmp/pids")
   end
 
   def self.consumer_class
@@ -30,16 +38,27 @@ class DaemonObjects::Base
   end
 
   def self.get_consumer
-    consumer_class.new(logger)
+    consumer_class.new(:logger => logger, :app_directory => app_directory, :environment => environment)
+  rescue Exception => e
+    logger.error("An exception occured while instantiating the consumer #{consumer_class}.  Startup will be aborted.")
+    logger.error("Error: #{e.class}")
+    logger.error("Message: #{e.message}")
+    logger.error(e.backtrace.join("\n"))
+    Airbrake.notify(e) if defined?(Airbrake)
+    raise e
   end
 
   def self.run
-    get_consumer.run
+    begin
+      get_consumer.run
+    rescue StandardError => e
+      handle_error(e)
+    end
   end
 
   def self.after_fork
     # daemonizing closes all file handles, so this will reopen the log
-    force_logger_reset 
+    force_logger_reset
     # this seems to be enough to initialize NewRelic if it's defined
     defined?(NewRelic)
   end
@@ -50,20 +69,18 @@ class DaemonObjects::Base
 
     FileUtils.mkdir_p(pid_directory)
 
-    Daemons.run_proc(proc_name, 
+    Daemons.run_proc(proc_name,
                     { :ARGV       => ["start", "-f"],
                       :log_dir    => "/tmp",
                       :dir        => pid_directory,
                       :log_output => true}) do
-      
+
       after_fork
-      run  
+      run
     end
 
   rescue StandardError => e
-    logger.error(e.message)
-    logger.error(e.backtrace.join("\n"))
-    Airbrake.notify(e) if defined?(Airbrake)
+    handle_error(e)
   end
 
   def self.stop
@@ -75,4 +92,9 @@ class DaemonObjects::Base
     stop
   end
 
+  def self.handle_error(e)
+    logger.error(e.message)
+    logger.error(e.backtrace.join("\n"))
+    Airbrake.notify(e) if defined?(Airbrake)
+  end
 end

data/lib/daemon_objects/consumer_base.rb

@@ -6,10 +6,12 @@ class DaemonObjects::ConsumerBase
     attr_accessor :message_handler
   end
 
-  attr_accessor :logger
+  attr_reader :logger, :app_directory, :environment
 
-  def initialize(logger)
-    @logger = logger
+  def initialize(opts)
+    @logger        = opts[:logger]
+    @app_directory = opts[:app_directory]
+    @environment   = opts[:environment]
   end
 
   def run

data/lib/daemon_objects/logging.rb

@@ -5,7 +5,7 @@ module DaemonObjects::Logging
   end
 
   def log_directory
-    (defined? Rails) ? File.join(Rails.root, "log") : "log"
+    File.join(app_directory, "log")
   end
 
   def logger

data/lib/daemon_objects/tasks/daemon_objects.rake

@@ -9,20 +9,20 @@ namespace :daemon do
         "or use run to run the daemon in the foreground"
 
       [:start, :stop, :run].each do |action|
-        task action => :environment do
+        task action do
+          Rake::Task[:environment].invoke if Rake::Task.task_defined?(:environment)
 
           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]
+      task :restart => [:stop, :start]
     end
   end
 

data/lib/daemon_objects/version.rb

@@ -1,3 +1,3 @@
 module DaemonObjects
-  VERSION = "0.1.9"
+  VERSION = "0.2.0"
 end

data/spec/lib/daemon_objects/base_spec.rb

@@ -7,6 +7,80 @@ describe DaemonObjects::Base do
     end
   end
 
+  describe '#app_directory' do
+    it 'should be Rake.original_directory if Rails is not defined' do
+      Rake.stub(:original_dir).and_return("/mydir")
+      MyDaemon = Class.new(DaemonObjects::Base)
+      MyDaemon.app_directory.should == Rake.original_dir
+    end
+
+    context 'Rails' do
+      before :each do
+        Rails = Module.new do
+          def self.root
+            "/mydir"
+          end
+        end
+      end
+
+      after :each do
+        Object.send(:remove_const, :Rails)
+      end
+
+      it 'should be Rails.root is Rails is defined' do
+        MyDaemon = Class.new(DaemonObjects::Base)
+        MyDaemon.app_directory.should == Rails.root
+      end
+    end
+
+    it 'should allow app_directory to be set explicitly' do
+      MyDaemon = Class.new(DaemonObjects::Base) do
+        def app_directory
+          "."
+        end
+      end
+    end
+  end
+
+  describe '#environment' do
+    context 'Rails' do
+      before :each do
+        Rails = Module.new do
+          def self.env
+            "railsenv"
+          end
+        end
+      end
+
+      after :each do
+        Object.send(:remove_const, :Rails)
+      end
+
+      it 'should use Rails.env if Rails is defined' do
+        MyDaemon = Class.new(DaemonObjects::Base)
+        MyDaemon.environment.should == Rails.env
+      end
+    end
+
+    context 'Env variable set' do
+      before :each do
+        ENV["DAEMON_ENV"] = "daemonenv"
+      end
+      after :each do
+        ENV["DAEMON_ENV"] = nil
+      end
+      it 'should use environment variable if Rails is not defined' do
+        MyDaemon = Class.new(DaemonObjects::Base)
+        MyDaemon.environment.should == ENV["DAEMON_ENV"]
+      end
+    end
+
+    it 'should be nil if not Rails and no environment set' do
+      MyDaemon = Class.new(DaemonObjects::Base)
+      MyDaemon.environment.should be_nil
+    end
+  end
+
   describe '#extends' do
     it 'should extend logging' do
       MyDaemon = Class.new(DaemonObjects::Base)
@@ -19,11 +93,11 @@ describe DaemonObjects::Base do
       MyConsumer = Class.new(DaemonObjects::ConsumerBase)
 
       MyDaemon = Class.new(DaemonObjects::Base) do
-        self.logger = StubLogger.new
+        self.logger = MemoryLogger::Logger.new
       end
 
       MyDaemon.run
-      MyDaemon.logger.logged_output.should =~ /Starting consumer\n/
+      MyDaemon.logger.logged_output.should =~ /Starting consumer/
     end
 
   end
@@ -55,7 +129,7 @@ describe DaemonObjects::Base do
 
   describe '##consumer_class' do
     it 'should constantize a file with multiple part name' do
-      ThreePartNameConsumer = Class.new 
+      ThreePartNameConsumer = Class.new
       ThreePartNameDaemon = Class.new(DaemonObjects::Base)
       ThreePartNameDaemon.consumer_class.should == ThreePartNameConsumer
     end
@@ -68,6 +142,60 @@ describe DaemonObjects::Base do
     end
   end
 
+  describe '##get_consumer' do
+
+
+    it 'should log exceptions during consumer instantiation' do
+      TestConsumer = Class.new(DaemonObjects::ConsumerBase) do
+        def initialize(logger)
+          super
+          raise StandardError.new("Test")
+        end
+      end
+      TestDaemon = Class.new(DaemonObjects::Base) do
+        self.logger = MemoryLogger::Logger.new
+      end
+
+      expect {TestDaemon.get_consumer}.to raise_error(StandardError)
+      TestDaemon.logger.logged_output =~ /Message: Test/
+    end
+
+    let(:consumer) { MyDaemon.get_consumer }
+
+    before :each do
+      MyConsumer = Class.new(DaemonObjects::ConsumerBase)
+      MyDaemon = Class.new(DaemonObjects::Base)
+    end
+
+    after :each do
+      Object.send(:remove_const, :MyDaemon)
+      Object.send(:remove_const, :MyConsumer)
+    end
+
+    it 'should set environment' do
+      def MyDaemon.environment
+        "theenv"
+      end
+
+      consumer.environment.should == "theenv"
+    end
+
+    it 'should set app directory' do
+      def MyDaemon.app_directory
+        "thedir"
+      end
+
+      consumer.app_directory.should == "thedir"
+    end
+
+    it 'should set logger' do
+      logger = MemoryLogger::Logger.new
+      MyDaemon.stub(:logger).and_return(logger)
+
+      consumer.logger.should == logger
+    end
+  end
+
   describe 'AMQP support' do
     let(:endpoint){ }
 

data/spec/lib/daemon_objects/consumer_base_spec.rb

@@ -16,11 +16,32 @@ describe DaemonObjects::ConsumerBase do
         handle_messages_with{|p| payloads_received << p }
       end
 
-      h = Harness.new(StubLogger.new)
+      h = Harness.new(:logger => MemoryLogger::Logger.new)
       h.handle_message({:x => 1})
 
       h.payloads_received.should == [{:x => 1}]
     end
   end
+
+  describe '#initialize' do
+    let(:logger) { MemoryLogger::Logger.new }
+    let(:harness) { Class.new(DaemonObjects::ConsumerBase) }
+
+    it 'should set logger' do
+      h = harness.new(:logger => logger)
+      h.logger.should == logger
+    end
+
+    it 'should set app_directory' do
+      h = harness.new(:app_directory => 'app_dir')
+      h.app_directory.should == 'app_dir'
+    end
+
+    it 'should set environment' do
+      h = harness.new(:environment => 'environment')
+      h.environment.should == 'environment'
+    end
+  end
+
     
 end

data/spec/lib/daemon_objects/logging_spec.rb

@@ -4,12 +4,16 @@ describe DaemonObjects::Logging do
   let(:harness) do
     Class.new do
       extend DaemonObjects::Logging
+
+      def self.app_directory
+        "."
+      end
     end
   end
 
   describe '#logger' do
     it 'should create a logger at log/log_filename path' do
-      logger = StubLogger.new
+      logger = MemoryLogger::Logger.new
 
       Logger.stub(:new).
         with("#{harness.log_directory}/#{harness.log_filename}").
@@ -17,7 +21,7 @@ describe DaemonObjects::Logging do
 
       harness.logger.info("starting consumer")
 
-      logger.logged_output.should =~ /starting consumer\n$/
+      logger.logged_output.should =~ /starting consumer/
     end
   end
 
@@ -46,29 +50,8 @@ describe DaemonObjects::Logging do
 
   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
+      harness.log_directory.to_s.should == File.join(harness.app_directory, "log")
     end
-
   end
 
 

data/spec/spec_helper.rb

@@ -5,6 +5,8 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 require 'pry'
+require 'memory_logger'
+
 SPEC_PATH = File.dirname(__FILE__)
 Dir[File.join(SPEC_PATH, "support/**/*.rb")].each{|f| require f}
 
@@ -22,4 +24,5 @@ RSpec.configure do |config|
   config.order = 'random'
 end
 
+require 'rake'
 require File.join(File.dirname(__FILE__), "../lib/daemon_objects.rb")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daemon_objects
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-17 00:00:00.000000000 Z
+date: 2014-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: daemons
@@ -107,6 +107,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: memory_logger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.3
 description: ! ' A light-weight approach to creating and managing daemons in an object-oriented
   way. Supports any type of daemon, but provides additional support for consuming
   AMQP queues. '
@@ -143,7 +159,6 @@ files:
 - spec/lib/daemon_objects/runner_spec.rb
 - spec/lib/daemon_objects_spec.rb
 - spec/spec_helper.rb
-- spec/support/stub_logger.rb
 homepage: http://github.com/craigisrael/daemon_objects
 licenses:
 - MIT
@@ -178,4 +193,3 @@ test_files:
 - spec/lib/daemon_objects/runner_spec.rb
 - spec/lib/daemon_objects_spec.rb
 - spec/spec_helper.rb
-- spec/support/stub_logger.rb

data/spec/support/stub_logger.rb

@@ -1,23 +0,0 @@
-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