jsierles-sprinkle 0.1.9

data/lib/sprinkle/verifiers/file.rb

@@ -0,0 +1,20 @@
+module Sprinkle
+  module Verifiers
+    # = File Verifier
+    #
+    # Contains a verifier to check the existance of a file.
+    # 
+    # == Example Usage
+    #
+    #   verify { has_file '/etc/apache2/apache2.conf' }
+    #
+    module File
+      Sprinkle::Verify.register(Sprinkle::Verifiers::File)
+      
+      # Checks to make sure <tt>path</tt> is a file on the remote server.
+      def has_file(path)
+        @commands << "test -f #{path}"
+      end
+    end
+  end
+end

data/lib/sprinkle/verifiers/process.rb

@@ -0,0 +1,21 @@
+module Sprinkle
+  module Verifiers
+    # = Process Verifier
+    #
+    # Contains a verifier to check that a process is running.
+    # 
+    # == Example Usage
+    #
+    #   verify { has_process 'httpd' }
+    #
+    module Process
+      Sprinkle::Verify.register(Sprinkle::Verifiers::Process)
+      
+      # Checks to make sure <tt>process</tt> is a process running
+      # on the remote server.
+      def has_process(process)
+        @commands << "ps aux | grep '#{process}' | grep -v grep"
+      end
+    end
+  end
+end

data/lib/sprinkle/verifiers/ruby.rb

@@ -0,0 +1,25 @@
+module Sprinkle
+  module Verifiers
+    # = Ruby Verifiers
+    #
+    # The verifiers in this module are ruby specific. 
+    module Ruby
+      Sprinkle::Verify.register(Sprinkle::Verifiers::Ruby)
+      
+      # Checks if ruby can require the <tt>files</tt> given. <tt>rubygems</tt>
+      # is always included first.
+      def ruby_can_load(*files)
+        # Always include rubygems first
+        files = files.unshift('rubygems').collect { |x| "require '#{x}'" }
+        
+        @commands << "ruby -e \"#{files.join(';')}\""
+      end
+      
+      # Checks if a gem exists by calling "sudo gem list" and grepping against it.
+      def has_gem(name, version=nil)
+        version = version.nil? ? '' : version.gsub('.', '\.')
+        @commands << "sudo gem list | grep -e '^#{name} (.*#{version}.*)$'"
+      end
+    end
+  end
+end

data/lib/sprinkle/verifiers/symlink.rb

@@ -0,0 +1,30 @@
+module Sprinkle
+  module Verifiers
+    # = Symlink Verifier
+    #
+    # Contains a verifier to check the existance of a symbolic link.
+    # 
+    # == Example Usage
+    #
+    # First, checking for the existence of a symlink:
+    #
+    #   verify { has_symlink '/usr/special/secret/pointer' }
+    #
+    # Second, checking that the symlink points to a specific place:
+    #
+    #   verify { has_symlink '/usr/special/secret/pointer', '/usr/local/realfile' }
+    module Symlink
+      Sprinkle::Verify.register(Sprinkle::Verifiers::Symlink)
+      
+      # Checks that <tt>symlink</tt> is a symbolic link. If <tt>file</tt> is 
+      # given, it checks that <tt>symlink</tt> points to <tt>file</tt>
+      def has_symlink(symlink, file = nil)
+        if file.nil?
+          @commands << "test -L #{symlink}"
+        else
+          @commands << "test '#{file}' = `readlink #{symlink}`"
+        end
+      end
+    end
+  end
+end

data/lib/sprinkle/verify.rb

@@ -0,0 +1,114 @@
+module Sprinkle
+  # = Verification Methods
+  #
+  # As documented in Sprinkle::Package, you may define a block on a package
+  # which verifies that a package was installed correctly. If this verification
+  # block fails, Sprinkle will stop the script gracefully, raising the error.
+  # 
+  # In addition to checking post install if it was successfully, verification
+  # blocks are also ran before an install to see if a package is <em>already</em>
+  # installed. If this is the case, the package is skipped and Sprinkle continues
+  # with the next package. This behavior can be overriden by setting the -f flag on
+  # the sprinkle script or setting Sprinkle::OPTIONS[:force] to true if you're
+  # using sprinkle programmatically. 
+  #
+  # == An Example
+  #
+  # The following verifies that rails was installed correctly be checking to see
+  # if the 'rails' command is available on the command line:
+  #
+  #   package :rails do
+  #     gem 'rails'
+  #     
+  #     verify do
+  #       has_executable 'rails'
+  #     end
+  #   end
+  #
+  # == Available Verifiers
+  #
+  # There are a variety of available methods for use in the verification block.
+  # The standard methods are defined in the Sprinkle::Verifiers module, so see
+  # their corresponding documentation.
+  #
+  # == Custom Verifiers
+  # 
+  # If you feel that the built-in verifiers do not offer a certain aspect of
+  # verification which you need, you may create your own verifier! Simply wrap
+  # any method in a module which you want to use:
+  #
+  #   module MagicBeansVerifier
+  #     def has_magic_beans(sauce)
+  #       @commands << '[ -z "`echo $' + sauce + '`"]'
+  #     end
+  #   end
+  #
+  # The method can append as many commands as it wishes to the @commands array. 
+  # These commands will be run on the remote server and <b>MUST</b> give an
+  # exit status of 0 if successful or other if unsuccessful.
+  #
+  # To register your verifier, call the register method on Sprinkle::Verify:
+  #
+  #   Sprinle::Verify.register(MagicBeansVerifier)
+  #
+  # And now you may use it like any other verifier:
+  #
+  #   package :magic_beans do
+  #     gem 'magic_beans'
+  #     
+  #     verify { has_magic_beans('ranch') }
+  #   end
+  class Verify
+    include Sprinkle::Configurable
+    attr_accessor :package, :description, :commands #:nodoc:
+    
+    class <<self
+      # Register a verification module
+      def register(new_module)
+        class_eval { include new_module }
+      end
+    end
+    
+    def initialize(package, description = '', &block) #:nodoc:
+      raise 'Verify requires a block.' unless block
+      
+      @package = package
+      @description = description
+      @commands = []
+      @options ||= {}
+      @options[:padding] = 4
+      
+      self.instance_eval(&block)
+    end
+    
+    def process(roles, pre = false) #:nodoc:
+      assert_delivery
+      
+      description = @description.empty? ? @package.name : @description
+      
+      if logger.debug?
+        logger.debug "#{@package.name}#{description} verification sequence: #{@commands.join('; ')} for roles: #{roles}\n"
+      end
+      
+      unless Sprinkle::OPTIONS[:testing]
+        logger.info "#{" " * @options[:padding]}--> Verifying #{description}..."
+        
+        unless @delivery.process(@package.name, @commands, roles, true)
+          # Verification failed, halt sprinkling gracefully.
+          raise Sprinkle::VerificationFailed.new(@package, description)
+        end
+      end
+    end
+  end
+  
+  class VerificationFailed < Exception #:nodoc:
+    attr_accessor :package, :description
+    
+    def initialize(package, description)
+      super("Verifying #{package.name}#{description} failed.")
+      
+      @package = package
+      @description = description
+    end
+  end
+end

data/lib/sprinkle/version.rb

@@ -0,0 +1,9 @@
+module Sprinkle #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 9
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'sprinkle'
+
+module Kernel
+  def logger
+    @@__log_file__ ||= StringIO.new
+    @@__log__ = ActiveSupport::BufferedLogger.new @@__log_file__
+  end
+end

data/spec/sprinkle/actors/capistrano_spec.rb

@@ -0,0 +1,170 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Sprinkle::Actors::Capistrano do
+
+  before do
+    @recipes = 'deploy'
+    @cap = ::Capistrano::Configuration.new
+    ::Capistrano::Configuration.stub!(:new).and_return(@cap)
+    @cap.stub!(:load).and_return
+  end
+
+  def create_cap(&block)
+    Sprinkle::Actors::Capistrano.new &block
+  end
+
+  describe 'when created' do
+
+    it 'should create a new capistrano object' do
+      ::Capistrano::Configuration.should_receive(:new).and_return(@cap)
+      create_cap
+    end
+
+    describe 'when verbose' do
+
+      before do
+        Sprinkle::OPTIONS[:verbose] = true
+      end
+
+      it 'should set verbose logging on the capistrano object' do
+        @cap = create_cap
+        @cap.config.logger.level.should == ::Capistrano::Logger::INFO
+      end
+
+    end
+
+    describe 'when not verbose' do
+
+      before do
+        Sprinkle::OPTIONS[:verbose] = false
+      end
+
+      it 'should set quiet logging on the capistrano object' do
+        @cap = create_cap
+        @cap.config.logger.level.should == ::Capistrano::Logger::IMPORTANT
+      end
+
+    end
+
+    describe 'with a block' do
+
+      before do
+        @actor = create_cap do
+          recipes 'cool gear' # default is deploy
+        end
+      end
+
+      it 'should evaluate the block against the actor instance' do
+        @actor.loaded_recipes.should include('cool gear')
+      end
+
+    end
+
+    describe 'without a block' do
+
+      it 'should automatically load the default capistrano configuration' do
+        @cap.should_receive(:load).with('deploy').and_return
+      end
+
+      after do
+        @actor = create_cap
+      end
+
+    end
+
+  end
+
+  describe 'recipes' do
+
+    it 'should add the recipe location to an internal store' do
+      @cap = create_cap do
+        recipes 'deploy'
+      end
+      @cap.loaded_recipes.should == [ @recipes ]
+    end
+
+    it 'should load the given recipe' do
+      @cap.should_receive(:load).with(@recipes).and_return
+      create_cap
+    end
+
+  end
+
+  describe 'processing commands' do
+
+    before do
+      @commands = %w( op1 op2 )
+      @roles    = %w( app )
+      @name     = 'name'
+
+      @cap = create_cap do; recipes 'deploy'; end
+      @cap.stub!(:run).and_return
+      
+      @testing_errors = false
+    end
+
+    it 'should dynamically create a capistrano task containing the commands' do
+      @cap.config.should_receive(:task).and_return
+    end
+
+    it 'should invoke capistrano task after creation' do
+      @cap.should_receive(:run).with(@name).and_return
+    end
+    
+    it 'should raise capistrano errors when suppressing parameter is not set' do
+      @testing_errors = true
+      
+      @cap.should_receive(:run).and_raise(::Capistrano::CommandError)
+      lambda { @cap.process @name, @commands, @roles }.should raise_error(::Capistrano::CommandError)
+    end
+    
+    it 'should not raise errors and instead return false when suppressing parameter is set' do
+      @testing_errors = true
+      
+      @cap.should_receive(:run).and_raise(::Capistrano::CommandError)
+      
+      value = nil
+      lambda { value = @cap.process(@name, @commands, @roles, true) }.should_not raise_error(::Capistrano::CommandError)
+      
+      value.should_not be
+    end
+
+    after do
+      @cap.process @name, @commands, @roles unless @testing_errors
+    end
+
+  end
+
+  describe 'generated task' do
+
+    before do
+      @commands = %w( op1 op2 )
+      @roles    = %w( app )
+      @name     = 'name'
+
+      @cap = create_cap do; recipes 'deploy'; end
+      @cap.config.stub!(:fetch).and_return(:sudo)
+      @cap.config.stub!(:invoke_command).and_return
+    end
+
+    it 'should use sudo to invoke commands when so configured' do
+      @cap.config.should_receive(:fetch).with(:run_method, :sudo).and_return(:sudo)
+    end
+
+    it 'should run the supplied commands' do
+      @cap.config.should_receive(:invoke_command).with('op1', :via => :sudo).ordered.and_return
+      @cap.config.should_receive(:invoke_command).with('op2', :via => :sudo).ordered.and_return
+    end
+
+    it 'should be applicable for the supplied roles' do
+      @cap.stub!(:run).and_return
+      @cap.config.should_receive(:task).with(:install_name, :roles => @roles).and_return
+    end
+
+    after do
+      @cap.process @name, @commands, @roles
+    end
+
+  end
+
+end