lachlan-sprinkle 0.0.1

data/lib/sprinkle/policy.rb

@@ -0,0 +1,125 @@
+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 = [] #: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 #:nodoc:
+      attr_reader :name, :packages
+
+      def initialize(name, metadata = {}, &block)
+        raise 'No name provided' unless name
+        raise 'No roles provided' unless metadata[:roles]
+
+        @name = name
+        @roles = metadata[:roles]
+        @packages = []
+        self.instance_eval(&block)
+      end
+
+      def requires(package, options = {})
+        @packages << package
+      end
+
+      def to_s; name; end
+
+      def process(deployment)
+        all = []
+
+        cloud_info "--> Cloud hierarchy for policy #{@name}"
+
+        @packages.each do |p|
+          cloud_info "\nPolicy #{@name} requires package #{p}"
+
+          package = Sprinkle::Package::PACKAGES[p]
+          raise "Package definition not found for key: #{p}" unless package
+          package = select_package(p, package) if package.is_a? Array # handle virtual package selection
+
+          tree = package.tree do |parent, child, depth|
+            indent = "\t" * depth; cloud_info "#{indent}Package #{parent.name} requires #{child.name}"
+          end
+
+          all << tree
+        end
+
+        normalize(all) do |package|
+          package.process(deployment, @roles)
+        end
+      end
+
+      private
+
+        def cloud_info(message)
+          logger.info(message) if Sprinkle::OPTIONS[:cloud] or logger.debug?
+        end
+
+        def select_package(name, packages)
+          if packages.size <= 1
+            package = packages.first
+          else
+            package = choose do |menu|
+              menu.prompt = "Multiple choices exist for virtual package #{name}"
+              menu.choices *packages.collect(&:to_s)
+            end
+            package = Sprinkle::Package::PACKAGES[package]
+          end
+
+          cloud_info "Selecting #{package.to_s} for virtual package #{name}"
+
+          package
+        end
+
+        def normalize(all, &block)
+          all = all.flatten.uniq
+          cloud_info "\n--> Normalized installation order for all packages: #{all.collect(&:name).join(', ')}"
+          all.each &block
+        end
+    end
+  end
+end

data/lib/sprinkle/script.rb

@@ -0,0 +1,23 @@
+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 #:nodoc:
+      @deployment.process if @deployment
+    end
+  end
+end

data/lib/sprinkle/verifiers/directory.rb

@@ -0,0 +1,24 @@
+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)
+        if RUBY_PLATFORM =~ /win32/
+          dir += "\\" unless dir[-1,1] == "\\"
+          command = "if exist \"#{dir}\" (exit 0) else (exit 1)"
+          command += ' > NUL 2>&1' unless logger.debug?
+        else
+          command = "test -d #{dir}"
+        end
+        @commands << command
+      end
+      
+    end
+  end
+end

data/lib/sprinkle/verifiers/executable.rb

@@ -0,0 +1,40 @@
+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)
+        if RUBY_PLATFORM =~ /win32/
+          raise NotImplementedError, "Win32 platform does not support checking for executables"
+        else
+          # 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
+end

data/lib/sprinkle/verifiers/file.rb

@@ -0,0 +1,38 @@
+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' }
+    #
+    #   verify { file_contains '/etc/apache2/apache2.conf', 'mod_gzip'}
+    #
+    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)
+        if RUBY_PLATFORM =~ /win32/
+          command = "if exist \"#{path}\" (if not exist \"#{path}\\\" (exit 0) else (exit 1)) else (exit 1)"
+          command += ' > NUL 2>&1' unless logger.debug?
+        else
+          command = "test -f #{path}"
+        end
+        @commands << command
+      end
+      
+      def file_contains(path, text)
+        if RUBY_PLATFORM =~ /win32/
+          command = "findstr /m /c:\"#{text}\" \"#{path}\""
+          command += ' > NUL 2>&1' unless logger.debug?
+        else
+          command = "grep '#{text}' #{path}"
+        end
+        @commands << command
+      end
+    end
+  end
+end

data/lib/sprinkle/verifiers/process.rb

@@ -0,0 +1,27 @@
+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)
+        if RUBY_PLATFORM =~ /win32/
+          command = "tasklist /fo table /nh | findstr /c:\"#{process}\""
+          command += ' > NUL 2>&1' unless logger.debug?
+        else
+          command = "ps aux | grep '#{process}' | grep -v grep"
+        end
+        @commands << command
+      end
+    end
+  end
+end

data/lib/sprinkle/verifiers/ruby.rb

@@ -0,0 +1,31 @@
+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('.', '\.')
+        if RUBY_PLATFORM =~ /win32/
+          command = "gem list | findstr /r /c:\"^#{name} (.*#{version}.*)$\""
+          command += ' > NUL 2>&1' unless logger.debug?
+        else
+          command = "sudo gem list | grep -e '^#{name} (.*#{version}.*)$'"
+        end
+        @commands << command
+      end
+    end
+  end
+end

data/lib/sprinkle/verifiers/symlink.rb

@@ -0,0 +1,34 @@
+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 RUBY_PLATFORM =~ /win32/
+          raise NotImplementedError, "Win32 platform does not support checking for symbolic links"
+        else
+          if file.nil?
+            @commands << "test -L #{symlink}"
+          else
+            @commands << "test '#{file}' = `readlink #{symlink}`"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sprinkle/verify.rb

@@ -0,0 +1,110 @@
+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:
+  #
+  #   Sprinkle::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
+      
+      logger.debug "--> Verification sequence for roles: #{roles}\n#{@commands.join("\n")}"
+      
+      unless Sprinkle::OPTIONS[:testing]
+        logger.info "--> Verifying if installed..."
+        
+        unless @delivery.process(@package.name, @commands, roles, true)
+          # Verification failed, halt sprinkling gracefully.
+          raise Sprinkle::VerificationFailed.new(@package, @commands)
+        end
+      end
+    end
+  end
+  
+  class VerificationFailed < Exception #:nodoc:
+    attr_accessor :package, :commands
+    
+    def initialize(package, commands)
+      super("Verifying #{package.name} failed: #{commands.join(RUBY_PLATFORM =~ /win32/ ? ' & ' : '; ')}")
+      
+      @package = package
+      @commands = commands
+    end
+  end
+end

data/lib/sprinkle/version.rb

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

data/lib/sprinkle.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'active_support'
+
+# Use active supports auto load mechanism
+ActiveSupport::Dependencies.load_paths << File.dirname(__FILE__)
+
+# Configure active support to log auto-loading of dependencies
+#ActiveSupport::Dependencies::RAILS_DEFAULT_LOGGER = Logger.new($stdout)
+#ActiveSupport::Dependencies.log_activity = true
+
+# Load up extensions to existing classes
+Dir[File.dirname(__FILE__) + '/sprinkle/extensions/*.rb'].each { |e| require e }
+# Load up the verifiers so they can register themselves
+Dir[File.dirname(__FILE__) + '/sprinkle/verifiers/*.rb'].each { |e| require e }
+
+# Configuration options
+module Sprinkle
+  OPTIONS = { :testing => false, :verbose => false, :force => false }
+end
+
+# Object is extended to give the package, policy, and deployment methods. To
+# read about each method, see the corresponding module which is included.
+#--
+# Define a logging target and understand packages, policies and deployment DSL
+#++
+class Object
+  include Sprinkle::Package, Sprinkle::Policy, Sprinkle::Deployment
+
+  def logger # :nodoc:
+    @@__log__ ||= ActiveSupport::BufferedLogger.new($stdout, ActiveSupport::BufferedLogger::Severity::INFO)
+  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