loops 2.0.0

data/spec/loop_lock_spec.rb

@@ -0,0 +1,61 @@
+require 'spec/spec_helper'
+
+describe LoopLock do
+  before :each do
+    @lock = { :entity_id => 1, :loop => 'test' }
+    LoopLock.reset!
+  end
+
+  describe '.lock' do
+    it 'should lock unlocked entities' do
+      LoopLock.lock(@lock).should be_true
+    end
+
+    it 'should create a lock record for unlocked entities' do
+      expect {
+        LoopLock.lock(@lock)
+      }.to change { LoopLock.locked?(@lock) }.from(false).to(true)
+    end
+
+    it 'should not lock an entity more than once' do
+      LoopLock.lock(@lock).should be_true
+      LoopLock.lock(@lock).should be_false
+    end
+
+    it 'should remove stale locks' do
+      @lock[:timeout] = -1 # Expired 1 second ago :-)
+      LoopLock.lock(@lock).should be_true
+      LoopLock.lock(@lock).should be_true
+    end
+  end
+
+  describe '.unlock' do
+    before :each do
+      LoopLock.lock(@lock)
+    end
+
+    it 'should remove lock records for a locked entities' do
+      expect {
+        LoopLock.unlock(@lock).should be_true
+      }.to change { LoopLock.locked?(@lock) }.from(true).to(false)
+    end
+
+    it 'should gracefully handle situations where we unlock a non-locked entities' do
+      LoopLock.reset!
+      expect {
+        LoopLock.unlock(@lock).should be_false
+      }.to_not change { LoopLock.locked?(@lock) }
+    end
+  end
+
+  describe '.locked?' do
+    it 'should return true for a locked entity' do
+      LoopLock.lock(@lock)
+      LoopLock.locked?(@lock).should be_true
+    end
+
+    it 'should return false for a non-locked entity' do
+      LoopLock.locked?(@lock).should be_false
+    end
+  end
+end

data/spec/loops/base_spec.rb

@@ -0,0 +1,92 @@
+require 'spec/spec_helper'
+
+describe Loops::Base, '#with_lock' do
+  before :each do
+    @logger = mock('Logger').as_null_object
+    @loop = Loops::Base.new(@logger, 'simple', {})
+  end
+  
+  context 'when an entity is not locked' do
+    it 'should create lock on an item' do
+      called = false
+      @loop.with_lock(1, 'rspec', 60) do
+        called = true
+        LoopLock.locked?(:loop => 'rspec', :entity_id => 1).should be_true
+      end
+      called.should be_true
+    end
+
+    it 'should release lock on an item' do
+      called = false
+      @loop.with_lock(1, 'rspec', 60) do
+        called = true
+      end
+      LoopLock.locked?(:loop => 'rspec', :entity_id => 1).should be_false
+      called.should be_true
+    end
+
+    it 'should release lock on an item in case of error' do
+      called = false
+      expect {
+        @loop.with_lock(1, 'rspec', 60) do
+          called = true
+          raise 'ouch'
+        end
+      }.to raise_error('ouch')
+      called.should be_true
+      LoopLock.locked?(:loop => 'rspec', :entity_id => 1).should be_false
+    end
+
+    it 'should pass the lock timeout' do
+      called = false
+      @loop.with_lock(1, 'rspec', 0.2) do
+        called = true
+        LoopLock.lock(:loop => 'rspec', :entity_id => 1).should be_false
+        sleep(0.2)
+        LoopLock.lock(:loop => 'rspec', :entity_id => 1).should be_true
+      end
+      called.should be_true
+    end
+
+    it 'should release the lock on an item' do
+      called = false
+      @loop.with_lock(1, 'rspec', 60) do
+        called = true
+      end
+      called.should be_true
+      LoopLock.locked?(:loop => 'rspec', :entity_id => 1).should be_false
+    end
+    
+    it 'should yield with entity_id value if block accepts the argument' do
+      called = false
+      @loop.with_lock(1, 'rspec', 60) do |entity_id|
+        called = true
+        entity_id.should == 1
+      end
+      called.should be_true
+    end
+  end
+
+  context 'when an entity is already locked' do
+    before :each do
+      LoopLock.lock(:loop => 'rspec', :entity_id => 1)
+    end
+
+    it 'should should not yield' do
+      called = false
+      @loop.with_lock(1, 'rspec', 60) do
+        called = true
+      end
+      called.should be_false
+    end
+
+    it 'should should not touch the lock object' do
+      called = false
+      @loop.with_lock(1, 'rspec', 60) do
+        called = true
+      end
+      LoopLock.locked?(:loop => 'rspec', :entity_id => 1).should be_true
+      called.should be_false
+    end
+  end
+end

data/spec/loops/cli_spec.rb

@@ -0,0 +1,156 @@
+require 'spec/spec_helper'
+
+describe Loops::CLI do
+  it 'should include Loops::CLI::Options' do
+    Loops::CLI.included_modules.should include(Loops::CLI::Options)
+  end
+
+  it 'should include Loops::CLI::Commands' do
+    Loops::CLI.included_modules.should include(Loops::CLI::Commands)
+  end
+
+  describe 'with Loops::CLI::Options included' do
+    before :each do
+      @args = [ 'list', '-f', 'none']
+    end
+
+    context 'when current directory could be detected' do
+      before :each do
+        Dir.chdir(RAILS_ROOT)
+      end
+
+      it 'should detect root directory' do
+        Loops::CLI.parse(@args)
+        Loops.root.should == Pathname.new(RAILS_ROOT).realpath
+      end
+
+      it 'should chdir to the root directory' do
+        Loops::CLI.parse(@args)
+        Dir.pwd.should == Pathname.new(RAILS_ROOT).realpath.to_s
+      end
+
+      it 'should load config from config/loops.yml by default' do
+        cli = Loops::CLI.parse(@args)
+        cli.engine.global_config['pid_file'].should == '/var/run/superloops.pid'
+      end
+
+      it 'should load config from file specified' do
+        cli = Loops::CLI.parse(@args << '-c' << 'config.yml')
+        cli.engine.global_config['pid_file'].should == 'tmp/pids/loops.pid'
+      end
+
+      it 'should initialize use app/loops as a root directory for loops by default' do
+        Loops::CLI.parse(@args)
+        Loops.loops_root.should == Pathname.new(RAILS_ROOT + '/app/loops').realpath
+      end
+
+      it 'should use specified root directory for loops' do
+        Loops::CLI.parse(@args << '-l' << '.')
+        Loops.loops_root.should == Pathname.new(RAILS_ROOT).realpath
+      end
+
+      it 'should use pid file from global config section' do
+        Loops::CLI.parse(@args)
+        Loops.pid_file.should == Pathname.new('/var/run/superloops.pid')
+      end
+
+      it 'should absolutize relative pid file path' do
+        Loops::CLI.parse(@args << '-c' << 'config.yml')
+        Loops.pid_file.should == Pathname.new(RAILS_ROOT).realpath + 'tmp/pids/loops.pid'
+      end
+
+      it 'should accept pid file from arguments' do
+        Loops::CLI.parse(@args << '-p' << 'superloop.pid')
+        Loops.pid_file.should == Pathname.new(RAILS_ROOT).realpath + 'superloop.pid'
+      end
+
+      it 'should extract command when passed' do
+        cli = Loops::CLI.parse(@args << 'list')
+        cli.options[:command].should == 'list'
+      end
+
+      it 'should extract command arguments when passed' do
+        cli = Loops::CLI.parse(@args << 'arg1' << 'arg2')
+        cli.options[:command].should == 'list'
+        cli.options[:args].should == %w(arg1 arg2)
+      end
+
+      it 'should remove all unnecessary options' do
+        cli = Loops::CLI.parse(@args << '-r' << RAILS_ROOT << '-p' << 'loop.pid' << '-c' << 'config.yml' << '-l' << '.' << '-d')
+        cli.options.keys.map(&:to_s).sort.should == %w(command args daemonize).sort
+      end
+    end
+
+    context 'when root directory passed in arguments' do
+      before :each do
+        @args << '-r' << File.dirname(__FILE__) + '/../rails'
+      end
+
+      it 'should detect root directory' do
+        Loops::CLI.parse(@args)
+        Loops.root.should == Pathname.new(RAILS_ROOT).realpath
+      end
+
+      it 'should chdir to the root directory' do
+        Loops::CLI.parse(@args)
+        Dir.pwd.should == Pathname.new(RAILS_ROOT).realpath.to_s
+      end
+    end
+
+    context 'with Rails framework' do
+      before :each do
+        @args = [ 'list', '-r', File.dirname(__FILE__) + '/../rails' ]
+        Loops::CLI.parse(@args)
+      end
+
+      it 'should load boot file' do
+        Object.const_defined?('RAILS_BOOT_LOADED').should be_true
+      end
+
+      it 'should load environment file' do
+        Object.const_defined?('RAILS_ENVIRONMENT_LOADED').should be_true
+      end
+
+      it 'should inialize default logger' do
+        Loops.default_logger.should == 'rails default logger'
+      end
+    end
+  end
+
+  describe 'with Loops::CLI::Commands included' do
+    before :each do
+      @args = [ 'list', '-f', 'none', '-r', RAILS_ROOT]
+      @cli = Loops::CLI.parse(@args)
+    end
+
+    describe 'in #find_command_possibilities' do
+      it 'should return a list of possible commands' do
+        @cli.find_command_possibilities('s').should == %w(start stats stop)
+        @cli.find_command_possibilities('sta').should == %w(start stats)
+        @cli.find_command_possibilities('star').should == %w(start)
+        @cli.find_command_possibilities('l').should == %w(list)
+        @cli.find_command_possibilities('o').should == []
+      end
+    end
+
+    describe 'in #find_command' do
+      it 'should raise InvalidCommandError when command is not found' do
+        expect {
+          @cli.find_command('o')
+        }.to raise_error(Loops::InvalidCommandError)
+      end
+
+      it 'should raise InvalidCommandError when ambiguous command matches found' do
+        expect {
+          @cli.find_command('s')
+        }.to raise_error(Loops::InvalidCommandError)
+      end
+
+      it 'should return an instance of command when everything is ok' do
+        expect {
+          @cli.find_command('star').should be_a(Loops::Commands::StartCommand)
+        }.to_not raise_error(Loops::InvalidCommandError)
+      end
+    end
+  end
+end

data/spec/loops_spec.rb

@@ -0,0 +1,20 @@
+require 'spec/spec_helper'
+
+describe Loops do
+  describe '.load_config' do
+    before :each do
+      Loops.root = RAILS_ROOT
+      @engine = Loops::Engine.new
+    end
+    
+    it 'should load and parse Loops configuration file' do
+      @engine.config.should be_an_instance_of(Hash)
+      @engine.global_config.should be_an_instance_of(Hash)
+      @engine.loops_config.should be_an_instance_of(Hash)
+    end
+
+    it 'should process ERB in config file' do
+      @engine.global_config['loops_root'].should == Pathname.new(RAILS_ROOT).realpath.to_s
+    end
+  end
+end

data/spec/rails/another_loop.rb

@@ -0,0 +1,4 @@
+class AnotherLoop < Loops::Base
+  def run
+  end
+end

data/spec/rails/app/loops/complex_loop.rb

@@ -0,0 +1,12 @@
+class ComplexLoop < Loops::Base
+  def run
+    with_period_of(1.second) do
+      if shutdown?
+        info("Shutting down!")
+        return # exit the loop
+      end
+
+      info("ping")
+    end
+  end
+end

data/spec/rails/app/loops/simple_loop.rb

@@ -0,0 +1,6 @@
+class SimpleLoop < Loops::Base
+  def run
+    info "Do not show this in log"
+    error "Woohoo! I'm in the loop log"
+  end
+end

data/spec/rails/config.yml

@@ -0,0 +1,6 @@
+global:
+  pid_file: tmp/pids/loops.pid
+
+loops:
+  another:
+    logger: logs/loops/another.log

data/spec/rails/config/boot.rb

@@ -0,0 +1 @@
+RAILS_BOOT_LOADED = true

data/spec/rails/config/environment.rb

@@ -0,0 +1,5 @@
+RAILS_ENVIRONMENT_LOADED = true
+
+require 'ostruct'
+Rails = OpenStruct.new([:logger])
+Rails.logger = 'rails default logger'

data/spec/rails/config/loops.yml

@@ -0,0 +1,13 @@
+global:
+  pid_file: /var/run/superloops.pid
+  loops_root: <%= Loops.root.to_s %>
+  colorful_logs: true
+  logger: logs/loops.log
+
+loops:
+  simple:
+    logger: logs/loops/simple.log
+    log_level: error
+
+  complex:
+    logger: logs/loops/complex.log

data/spec/spec_helper.rb

@@ -0,0 +1,110 @@
+RAILS_ROOT = File.expand_path(File.join(File.dirname(__FILE__), 'rails'))
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'loops')
+
+# Represents a lock object for a specific item.
+#
+# Usually you should use only {lock} and {unlock} methods to get
+# entity locked or unlocked correspondingly. Method {locked?} could
+# be used in test to verify lock status.
+#
+# @example Create a lock on an entity
+#   LoopLock.lock(:loop => 'upload', :entity_id => 15)
+#
+# @example Create a lock on an entity with timeout 20 minutes
+#   LoopLock.lock(:loop => 'upload', :entity_id => 15, :timeout => 20.minutes)
+#
+# @example Remove a lock from an entity
+#   LoopLock.unlock(:loop => 'upload', :entity_id => 15)
+#
+# @example Verify entity locked
+#   LoopLock.locked?(:loop => 'upload', :entity_id => 15)
+#
+class LoopLock
+  @@locks = []
+
+  # Resets all locks
+  # 
+  # Used just for testing purpose.
+  # 
+  def self.reset!
+    @@locks = []
+  end
+  
+  # Locks an entity in a specified namespace (loop).
+  #
+  # @param [Hash] params a hash of options.
+  # @option params [String, Symbol] :loop
+  #   a loop to lock an entity in. Required.
+  # @option params [Integer] :entity_id
+  #   ID of the entity to lock.
+  # @option params [Integer] :timeout (1.year)
+  #   a timeout in seconds after which lock object should be expired.
+  # @return [Boolean]
+  #   +true+ when locked successfully,
+  #   +false+ when entity is already locked.
+  #
+  # @raise ArgumentError when :entity_id or :loop parameter is missing.
+  #
+  # @example
+  #   LoopLock.lock(:loop => 'upload', :entity_id => 15, :timeout => 20.minutes)
+  #
+  def self.lock(params)
+    raise ArgumentError, 'Not enough params for a lock' unless params[:entity_id] && params[:loop]
+
+    # Remove all stale locks for this record
+    @@locks.reject! { |lock| lock[:loop] == params[:loop] && lock[:entity_id] == params[:entity_id] && lock[:timeout_at] < Time.now }
+    
+    return false if locked?(params)
+
+    # Create new lock
+    attributes = params.dup
+    timeout = attributes.delete(:timeout)
+    timeout ||= 3600 * 24
+    attributes[:timeout_at] = Time.now + timeout
+    @@locks << attributes
+    true
+  end
+
+  # Unlocks an entity in a specified namespace (loop).
+  #
+  # @param [Hash] params a hash of options.
+  # @option params [String, Symbol] :loop
+  #   a loop to lock an entity in. Required.
+  # @option params [Integer] :entity_id
+  #   ID of the entity to lock.
+  # @return [Boolean]
+  #   +true+ when unlocked successfully,
+  #   +false+ when entity was not locked before.
+  #
+  # @raise ArgumentError when :entity_id or :loop parameter is missing.
+  #
+  # @example
+  #   LoopLock.unlock(:loop => 'upload', :entity_id => 15)
+  #
+  def self.unlock(params)
+    raise ArgumentError, 'Not enough params for a lock' unless params[:entity_id] && params[:loop]
+    !!@@locks.reject! { |lock| lock[:loop] == params[:loop] && lock[:entity_id] == params[:entity_id] }
+  end
+
+  # Checks the state of an entity lock.
+  #
+  # @param [Hash] params a hash of options.
+  # @option params [String, Symbol] :loop
+  #   a loop to lock an entity in. Required.
+  # @option params [Integer] :entity_id
+  #   ID of the entity to lock.
+  # @return [Boolean]
+  #   +true+ when an entity is locked,
+  #   +false+ when an entity is not locked.
+  #
+  # @raise ArgumentError when :entity_id or :loop parameter is missing.
+  #
+  # @example
+  #   LoopLock.locked?(:loop => 'upload', :entity_id => 15)
+  #
+  def self.locked?(params)
+    raise ArgumentError, 'Not enough params for a lock' unless params[:entity_id] && params[:loop]
+    !!@@locks.index { |lock| lock[:loop] == params[:loop] && lock[:entity_id] == params[:entity_id] }
+  end
+end