sprinkle 0.1.5 → 0.1.6

data/lib/sprinkle/installers/rake.rb

@@ -1,14 +1,27 @@
 module Sprinkle
   module Installers
+    # = Rake Installer
+    #
+    # This installer runs a rake command.
+    # 
+    # == Example Usage
+    #
+    # The following example runs the command "rake spec" on
+    # the remote server.
+    #
+    #   package :spec do
+    #     rake 'spec'
+    #   end
+    # 
     class Rake < Installer
-      def initialize(parent, commands = [], &block)
+      def initialize(parent, commands = [], &block) #:nodoc:
         super parent, &block
         @commands = commands
       end
 
       protected
 
-        def install_commands
+        def install_commands #:nodoc:
           "rake #{@commands.join(' ')}"
         end
 

data/lib/sprinkle/installers/rpm.rb

@@ -1,9 +1,26 @@
 module Sprinkle
   module Installers
+    # = RPM Package Installer
+    #
+    # The RPM package installer installs RPM packages.
+    # 
+    # == Example Usage
+    #
+    # Installing the magic_beans RPM. Its all the craze these days.
+    #
+    #   package :magic_beans do
+    #     rpm 'magic_beans'
+    #   end
+    #
+    # You may also specify multiple rpms as an array:
+    #
+    #   package :magic_beans do
+    #     rpm %w(magic_beans magic_sauce)
+    #   end
     class Rpm < Installer
-      attr_accessor :packages
+      attr_accessor :packages #:nodoc:
 
-      def initialize(parent, packages, &block)
+      def initialize(parent, packages, &block) #:nodoc:
         super parent, &block
         packages = [packages] unless packages.is_a? Array
         @packages = packages
@@ -11,7 +28,7 @@ module Sprinkle
 
       protected
 
-        def install_commands
+        def install_commands #:nodoc:
           "rpm -Uvh #{@packages.join(' ')}"
         end
 

data/lib/sprinkle/installers/source.rb

@@ -1,16 +1,72 @@
 module Sprinkle
   module Installers
+    # = Source Package Installer
+    #
+    # The source package installer installs software from source.
+    # It handles downloading, extracting, configuring, building, 
+    # and installing software. 
+    #
+    # == Configuration Options
+    #
+    # The source installer has many configuration options:
+    # * <b>prefix</b> - The prefix directory that is configured to.
+    # * <b>archives</b> - The location all the files are downloaded to.
+    # * <b>builds</b> - The directory the package is extracted to to configure and install
+    #
+    # == Pre/Post Hooks
+    #
+    # The source installer defines a myriad of new stages which can be hooked into:
+    # * <b>prepare</b> - Prepare is the stage which all the prefix, archives, and build directories are made.
+    # * <b>download</b> - Download is the stage which the software package is downloaded.
+    # * <b>extract</b> - Extract is the stage which the software package is extracted.
+    # * <b>configure</b> - Configure is the stage which the ./configure script is run.
+    # * <b>build</b> - Build is the stage in which `make` is called.
+    # * <b>install</b> - Install is the stage which `make install` is called.
+    # 
+    # == Example Usage
+    #
+    # First, a simple package, no configuration:
+    #
+    #   package :magic_beans do
+    #     source 'http://magicbeansland.com/latest-1.1.1.tar.gz'
+    #   end
+    #
+    # Second, specifying exactly where I want my files:
+    #
+    #   package :magic_beans do
+    #     source 'http://magicbeansland.com/latest-1.1.1.tar.gz' do
+    #       prefix    '/usr/local'
+    #       archives  '/tmp'
+    #       builds    '/tmp/builds'
+    #     end
+    #   end
+    #
+    # Third, specifying some hooks:
+    #
+    #   package :magic_beans do
+    #     source 'http://magicbeansland.com/latest-1.1.1.tar.gz' do
+    #       prefix    '/usr/local'
+    #       
+    #       pre :prepare { 'echo "Here we go folks."' }
+    #       post :extract { 'echo "I believe..."' }
+    #       pre :build { 'echo "Cross your fingers!"' }
+    #     end
+    #   end
+    #
+    # As you can see, setting options is as simple as creating a
+    # block and calling the option as a method with the value as 
+    # its parameter.
     class Source < Installer
-      attr_accessor :source
+      attr_accessor :source #:nodoc:
 
-      def initialize(parent, source, options = {}, &block)
+      def initialize(parent, source, options = {}, &block) #:nodoc:
         @source = source
         super parent, options, &block
       end
 
       protected
 
-        def install_sequence
+        def install_sequence #:nodoc:
           prepare + download + extract + configure + build + install
         end
 
@@ -20,7 +76,7 @@ module Sprinkle
           end
         end
 
-        def prepare_commands
+        def prepare_commands #:nodoc:
           raise 'No installation area defined' unless @options[:prefix]
           raise 'No build area defined' unless @options[:builds]
           raise 'No source download area defined' unless @options[:archives]
@@ -30,15 +86,15 @@ module Sprinkle
             "mkdir -p #{@options[:archives]}" ]
         end
 
-        def download_commands
+        def download_commands #:nodoc:
           [ "wget -cq --directory-prefix='#{@options[:archives]}' #{@source}" ]
         end
 
-        def extract_commands
+        def extract_commands #:nodoc:
           [ "bash -c 'cd #{@options[:builds]} && #{extract_command} #{@options[:archives]}/#{archive_name}'" ]
         end
 
-        def configure_commands
+        def configure_commands #:nodoc:
           return [] if custom_install?
 
           command = "bash -c 'cd #{build_dir} && ./configure --prefix=#{@options[:prefix]} "
@@ -53,38 +109,40 @@ module Sprinkle
           [ command << " > #{@package.name}-configure.log 2>&1'" ]
         end
 
-        def build_commands
+        def build_commands #:nodoc:
           return [] if custom_install?
           [ "bash -c 'cd #{build_dir} && make > #{@package.name}-build.log 2>&1'" ]
         end
 
-        def install_commands
+        def install_commands #:nodoc:
           return custom_install_commands if custom_install?
           [ "bash -c 'cd #{build_dir} && make install > #{@package.name}-install.log 2>&1'" ]
         end
 
-        def custom_install?
+        def custom_install? #:nodoc:
           !! @options[:custom_install]
         end
 
         # REVISIT: must be better processing of custom install commands somehow? use splat operator?
-        def custom_install_commands
+        def custom_install_commands #:nodoc:
           dress @options[:custom_install], :install
         end
 
       protected
 
+        # dress is overriden from the base Sprinkle::Installers::Installer class so that the command changes
+        # directory to the build directory first. Also, the result of the command is logged.
         def dress(commands, stage)
           commands.collect { |command| "bash -c 'cd #{build_dir} && #{command} >> #{@package.name}-#{stage}.log 2>&1'" }
         end
 
       private
 
-        def create_options(key, prefix)
+        def create_options(key, prefix) #:nodoc:
           @options[key].inject(' ') { |m, option| m << "#{prefix}-#{option} "; m }
         end
 
-        def extract_command
+        def extract_command #:nodoc:
           case @source
           when /(tar.gz)|(tgz)$/
             'tar xzf'
@@ -99,17 +157,17 @@ module Sprinkle
           end
         end
 
-        def archive_name
+        def archive_name #:nodoc:
           name = @source.split('/').last
           raise "Unable to determine archive name for source: #{source}, please update code knowledge" unless name
           name
         end
 
-        def build_dir
+        def build_dir #:nodoc:
           "#{@options[:builds]}/#{options[:custom_dir] || base_dir}"
         end
 
-        def base_dir
+        def base_dir #:nodoc:
           if @source.split('/').last =~ /(.*)\.(tar\.gz|tgz|tar\.bz2|tb2)/
             return $1
           end

data/lib/sprinkle/package.rb

@@ -1,4 +1,96 @@
 module Sprinkle
+  # = Packages
+  #
+  # A package defines one or more things to provision onto the server.
+  # There is a lot of flexibility in a way a package is defined but
+  # let me give you a basic example:
+  #
+  #   package :ruby do
+  #     description 'Ruby MRI'
+  #     version '1.8.6'
+  #     apt 'ruby'
+  #
+  #     verify { has_executable 'ruby' }
+  #   end
+  #
+  # The above would define a package named 'ruby' and give it a description
+  # and explicitly say its version. It is installed via apt and to verify
+  # the installation was successful sprinkle will check for the executable
+  # 'ruby' being availble. Pretty simple, right?
+  #
+  # <b>Note:</b> Defining a package does not INSTALL it. To install a
+  # package, you must require it in a Sprinkle::Policy block. 
+  #
+  # == Pre-Requirements
+  #
+  # Most packages have some sort of pre-requisites in order to be installed.
+  # Sprinkle allows you to define the requirements of the package, which
+  # will be installed before the package itself. An example below:
+  #
+  #   package :rubygems do
+  #     source 'http://rubyforge.org/rubygems.tgz'
+  #     requires :ruby
+  #   end
+  #
+  # In this case, when rubygems is being installed, Sprinkle will first
+  # provision the server with Ruby to make sure the requirements are met.
+  # In turn, if ruby has requirements, it installs those first, and so on.
+  #
+  # == Verifications
+  #
+  # Most of the time its important to know whether the software you're 
+  # attempting to install was installed successfully or not. For this,
+  # Sprinkle provides verifications. Verifications are one or more blocks
+  # which define rules with which Sprinkle can check if it installed
+  # the package successfully. If these verification blocks fail, then 
+  # Sprinkle will gracefully stop the entire process. An example below:
+  #
+  #   package :rubygems do
+  #     source 'http://rubyforge.org/rubygems.tgz'
+  #     requires :ruby
+  #
+  #     verify { has_executable 'gem' }
+  #   end
+  #
+  # In addition to verifying an installation was successfully, by default
+  # Sprinkle runs these verifications <em>before</em> the installation to
+  # check if the package is already installed. If the verifications pass
+  # before installing the package, it skips the package. To override this
+  # behavior, set the -f flag on the sprinkle script or set the
+  # :force option to true in Sprinkle::OPTIONS
+  #
+  # For more information on verifications and to see all the available
+  # verifications, see Sprinkle::Verify
+  #
+  # == Virtual Packages
+  #
+  # Sometimes, there are multiple packages available for a single task. An
+  # example is a database package. It can contain mySQL, postgres, or sqlite!
+  # This is where virtual packages come in handy. They are defined as follows:
+  #
+  #   package :sqlite3, :provides => :database do
+  #     apt 'sqlite3'
+  #   end
+  #
+  # The :provides option allows you to reference this package either by :sqlite3
+  # or by :database. But whereas the package name is unique, multiple packages may
+  # share the same provision. If this is the case, when running Sprinkle, the 
+  # script will ask you which provision you want to install. At this time, you
+  # can only install one. 
+  #
+  # == Meta-Packages
+  #
+  # A package doesn't require an installer. If you want to define a package which
+  # merely encompasses other packages, that is fine too. Example:
+  #
+  #   package :meta do
+  #     requires :magic_beans
+  #     requires :magic_sauce
+  #   end
+  #
+  #--
+  # FIXME: Should probably document recommendations.
+  #++
   module Package
     PACKAGES = {}
 
@@ -13,9 +105,9 @@ module Sprinkle
       package
     end
 
-    class Package
+    class Package #:nodoc:
       include ArbitraryOptions
-      attr_accessor :name, :provides, :installer, :dependencies, :recommends
+      attr_accessor :name, :provides, :installer, :dependencies, :recommends, :verifications
 
       def initialize(name, metadata = {}, &block)
         raise 'No package name supplied' unless name
@@ -24,6 +116,7 @@ module Sprinkle
         @provides = metadata[:provides]
         @dependencies = []
         @recommends = []
+        @verifications = []
         self.instance_eval &block
       end
 
@@ -44,12 +137,44 @@ module Sprinkle
         @recommends << :build_essential # Ubuntu/Debian
         @installer = Sprinkle::Installers::Source.new(self, source, options, &block)
       end
+      
+      def verify(description = '', &block)
+        @verifications << Sprinkle::Verify.new(self, description, &block)
+      end
 
       def process(deployment, roles)
         return if meta_package?
+        
+        # Run a pre-test to see if the software is already installed. If so,
+        # we can skip it, unless we have the force option turned on!
+        unless @verifications.empty? || Sprinkle::OPTIONS[:force]
+          begin
+            process_verifications(deployment, roles, true)
+            
+            logger.info "--> #{self.name} already installed for roles: #{roles}"
+            return
+          rescue Sprinkle::VerificationFailed => e
+            # Continue
+          end
+        end
 
         @installer.defaults(deployment)
         @installer.process(roles)
+        
+        process_verifications(deployment, roles)
+      end
+      
+      def process_verifications(deployment, roles, pre = false)
+        if pre
+          logger.info "--> Checking if #{self.name} is already installed for roles: #{roles}"
+        else
+          logger.info "--> Verifying #{self.name} was properly installed for roles: #{roles}"
+        end
+        
+        @verifications.each do |v|
+          v.defaults(deployment)
+          v.process(roles)
+        end
       end
 
       def requires(*packages)

data/lib/sprinkle/policy.rb

@@ -1,16 +1,56 @@
 require 'highline/import'
 
 module Sprinkle
+  # = Policies
+  #
+  # A policy defines a set of packages which are required for a certain
+  # role (app, database, etc.). All policies defined will be run and all
+  # packages required by the policy will be installed. So whereas defining
+  # a Sprinkle::Package merely defines it, defining a Sprinkle::Policy 
+  # actually causes those packages to install. 
+  #
+  # == A Basic Example
+  #
+  #   policy :blog, :roles => :app do
+  #     require :webserver
+  #     require :database
+  #     require :rails
+  #   end
+  #
+  # This says that for the blog on the app role, it requires certain 
+  # packages. The :roles option is <em>exactly</em> the same as a capistrano
+  # or vlad role. A role merely defines what server the commands are run
+  # on. This way, a single Sprinkle script can provision an entire group
+  # of servers. 
+  #
+  # To define a role, put in your actor specific configuration file (recipe or
+  # script file):
+  #
+  #   role :app, "208.28.38.44"
+  #
+  # The capistrano and vlad syntax is the same for that. If you're using a
+  # custom actor, you may have to do it differently.
+  #
+  # == Multiple Policies
+  #
+  # You may specify as many policies as you'd like. If the packages you're
+  # requiring are properly defined with verification blocks, then
+  # no software will be installed twice, so you may require a webserver on
+  # multiple packages within the same role without having to wait for
+  # that package to install repeatedly.
   module Policy
-    POLICIES = []
+    POLICIES = [] #:nodoc:
 
+    # Defines a single policy. Currently the only option, which is also
+    # required, is :roles, which defines which servers a policy is
+    # used on.
     def policy(name, options = {}, &block)
       p = Policy.new(name, options, &block)
       POLICIES << p
       p
     end
 
-    class Policy
+    class Policy #:nodoc:
       attr_reader :name, :packages
 
       def initialize(name, metadata = {}, &block)

data/lib/sprinkle/script.rb

@@ -1,12 +1,22 @@
 module Sprinkle
+  # = Programmatically Run Sprinkle
+  #
+  # Sprinkle::Script gives you a way to programatically run a given
+  # sprinkle script. 
   class Script
+    # Run a given sprinkle script. This method is <b>blocking</b> so
+    # it will not return until the sprinkling is complete or fails.
+    #--
+    # FIXME: Improve documentation, possibly notify user how to tell
+    # if a sprinkling failed.
+    #++
     def self.sprinkle(script, filename = '__SCRIPT__')
       powder = new
       powder.instance_eval script, filename
       powder.sprinkle
     end
 
-    def sprinkle
+    def sprinkle #:nodoc:
       @deployment.process if @deployment
     end
   end

data/lib/sprinkle/verifiers/directory.rb

@@ -0,0 +1,16 @@
+module Sprinkle
+  module Verifiers
+    # = Directory Verifier
+    #
+    # Defines a verify which can be used to test the existence of a 
+    # directory.
+    module Directory
+      Sprinkle::Verify.register(Sprinkle::Verifiers::Directory)
+      
+      # Tests that the directory <tt>dir</tt> exists.
+      def has_directory(dir)
+        @commands << "test -d #{dir}"
+      end
+    end
+  end
+end

data/lib/sprinkle/verifiers/executable.rb

@@ -0,0 +1,36 @@
+module Sprinkle
+  module Verifiers
+    # = Executable Verifier
+    #
+    # Contains a verifier to check the existance of an executable
+    # script on your server.
+    # 
+    # == Example Usage
+    #
+    # First, absolute path to an executable:
+    #
+    #   verify { has_executable '/usr/special/secret/bin/scipt' }
+    #
+    # Second, a global executable which would be available anywhere on the
+    # command line:
+    #
+    #   verify { has_executable 'grep' }
+    module Executable
+      Sprinkle::Verify.register(Sprinkle::Verifiers::Executable)
+      
+      # Checks if <tt>path</tt> is an executable script. This verifier is "smart" because
+      # if the path contains a forward slash '/' then it assumes you're checking an 
+      # absolute path to an executable. If no '/' is in the path, it assumes you're
+      # checking for a global executable that would be available anywhere on the command line.
+      def has_executable(path)
+        # Be smart: If the path includes a forward slash, we're checking
+        # an absolute path. Otherwise, we're checking a global executable
+        if path.include?('/')
+          @commands << "test -x #{path}"
+        else
+          @commands << "[ -n \"`echo \\`which #{path}\\``\" ]"
+        end
+      end
+    end
+  end
+end

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