lachlan-sprinkle 0.0.1

data/lib/sprinkle/installers/rake.rb

@@ -0,0 +1,37 @@
+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
+    # 
+    # Specify a Rakefile with the :rakefile option.
+    #
+    #   package :spec, :rakefile => "/var/setup/Rakefile" do
+    #     rake 'spec'
+    #   end
+     
+    class Rake < Installer
+      def initialize(parent, commands, options = {}, &block) #:nodoc:
+        super parent, options, &block
+        @commands = commands.to_a
+      end
+
+      protected
+
+        def install_commands #:nodoc:
+          file = @options[:rakefile] ? "-f #{@options[:rakefile]} " : ""
+          "rake #{file}#{@commands.join(' ')}"
+        end
+
+    end
+  end
+end

data/lib/sprinkle/installers/rpm.rb

@@ -0,0 +1,37 @@
+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 #:nodoc:
+
+      def initialize(parent, packages, &block) #:nodoc:
+        super parent, &block
+        packages = [packages] unless packages.is_a? Array
+        @packages = packages
+      end
+
+      protected
+
+        def install_commands #:nodoc:
+          "rpm -Uvh #{@packages.join(' ')}"
+        end
+
+    end
+  end
+end

data/lib/sprinkle/installers/script.rb

@@ -0,0 +1,38 @@
+module Sprinkle
+  module Installers
+    # = Script Installer
+    #
+    # The Script installer runs a script file to install software
+    #
+    # == Example Usage
+    #
+    #   package :magic_beans do
+    #     script '/some/path/to/install/script/for/magic_beans'
+    #   end
+    class Script < Installer
+      attr_accessor :script_file, :script_path #:nodoc:
+      @@command_delimiter = (RUBY_PLATFORM =~ /win32/ ? ' & ' : '; ')
+
+      def initialize(parent, name, options={}, &block) #:nodoc:
+        super parent, options, &block
+        @script_path, @script_file = File.split name
+      end
+
+      protected
+
+        def install_commands #:nodoc:
+          commands = []
+          commands << "pushd \"#{@script_path}\"" if @script_path
+          
+          command = @script_file
+          command += ' > NUL' if RUBY_PLATFORM =~ /win32/ and not logger.debug?
+          commands << command
+
+          commands << "popd" if @script_path
+
+          commands.join(@@command_delimiter)
+        end
+
+      end
+  end
+end

data/lib/sprinkle/installers/source.rb

@@ -0,0 +1,179 @@
+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 #:nodoc:
+
+      def initialize(parent, source, options = {}, &block) #:nodoc:
+        @source = source
+        super parent, options, &block
+      end
+
+      protected
+
+        def install_sequence #:nodoc:
+          prepare + download + extract + configure + build + install
+        end
+
+        %w( prepare download extract configure build install ).each do |stage|
+          define_method stage do
+            pre_commands(stage.to_sym) + self.send("#{stage}_commands") + post_commands(stage.to_sym)
+          end
+        end
+
+        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]
+
+          [ "mkdir -p #{@options[:prefix]}",
+            "mkdir -p #{@options[:builds]}",
+            "mkdir -p #{@options[:archives]}" ]
+        end
+
+        def download_commands #:nodoc:
+          [ "wget -cq --directory-prefix='#{@options[:archives]}' #{@source}" ]
+        end
+
+        def extract_commands #:nodoc:
+          [ "bash -c 'cd #{@options[:builds]} && #{extract_command} #{@options[:archives]}/#{archive_name}'" ]
+        end
+
+        def configure_commands #:nodoc:
+          return [] if custom_install?
+
+          command = "bash -c 'cd #{build_dir} && ./configure --prefix=#{@options[:prefix]} "
+
+          extras = {
+            :enable  => '--enable', :disable => '--disable',
+            :with    => '--with',   :without => '--without'
+          }
+
+          extras.inject(command) { |m, (k, v)| m << create_options(k, v) if options[k]; m }
+
+          [ command << " > #{@package.name}-configure.log 2>&1'" ]
+        end
+
+        def build_commands #:nodoc:
+          return [] if custom_install?
+          [ "bash -c 'cd #{build_dir} && make > #{@package.name}-build.log 2>&1'" ]
+        end
+
+        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? #:nodoc:
+          !! @options[:custom_install]
+        end
+
+        # REVISIT: must be better processing of custom install commands somehow? use splat operator?
+        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) #:nodoc:
+          @options[key].inject(' ') { |m, option| m << "#{prefix}-#{option} "; m }
+        end
+
+        def extract_command #:nodoc:
+          case @source
+          when /(tar.gz)|(tgz)$/
+            'tar xzf'
+          when /(tar.bz2)|(tb2)$/
+            'tar xjf'
+          when /tar$/
+            'tar xf'
+          when /zip$/
+            'unzip'
+          else
+            raise "Unknown source archive format: #{archive_name}"
+          end
+        end
+
+        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 #:nodoc:
+          "#{@options[:builds]}/#{options[:custom_dir] || base_dir}"
+        end
+
+        def base_dir #:nodoc:
+          if @source.split('/').last =~ /(.*)\.(tar\.gz|tgz|tar\.bz2|tb2)/
+            return $1
+          end
+          raise "Unknown base path for source archive: #{@source}, please update code knowledge"
+        end
+        
+    end
+  end
+end

data/lib/sprinkle/installers/yum.rb

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

data/lib/sprinkle/package.rb

@@ -0,0 +1,280 @@
+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 = {}
+
+    def package(name, metadata = {}, &block)
+      package = Package.new(name, metadata, &block)
+      PACKAGES[name] = package
+
+      if package.provides
+        (PACKAGES[package.provides] ||= []) << package
+      end
+
+      package
+    end
+
+    class Package #:nodoc:
+      include ArbitraryOptions
+      attr_accessor :name, :provides, :installer, :dependencies, :recommends, :verifications
+
+      def initialize(name, metadata = {}, &block)
+        raise 'No package name supplied' unless name
+
+        @name = name
+        @provides = metadata[:provides]
+        @dependencies = []
+        @recommends = []
+        @verifications = []
+        self.instance_eval &block
+      end
+
+      def freebsd_pkg(*names, &block)
+        @installer = Sprinkle::Installers::FreebsdPkg.new(self, *names, &block)
+      end
+      
+      def openbsd_pkg(*names, &block)
+        @installer = Sprinkle::Installers::OpenbsdPkg.new(self, *names, &block)
+      end
+      
+      def opensolaris_pkg(*names, &block)
+        @installer = Sprinkle::Installers::OpensolarisPkg.new(self, *names, &block)
+      end
+      
+      def bsd_port(port, &block)
+        @installer = Sprinkle::Installers::BsdPort.new(self, port, &block)
+      end
+      
+      def mac_port(port, &block)
+        @installer = Sprinkle::Installers::MacPort.new(self, port, &block)
+      end
+
+      def apt(*names, &block)
+        @installer = Sprinkle::Installers::Apt.new(self, *names, &block)
+      end
+
+      def deb(*names, &block)
+        @installer = Sprinkle::Installers::Deb.new(self, *names, &block)
+      end
+
+      def rpm(*names, &block)
+        @installer = Sprinkle::Installers::Rpm.new(self, *names, &block)
+      end
+
+      def yum(*names, &block)
+        @installer = Sprinkle::Installers::Yum.new(self, *names, &block)
+      end
+
+      def gem(name, options = {}, &block)
+        @recommends << :rubygems
+        @installer = Sprinkle::Installers::Gem.new(self, name, options, &block)
+      end
+
+      def source(source, options = {}, &block)
+        @recommends << :build_essential # Ubuntu/Debian
+        @installer = Sprinkle::Installers::Source.new(self, source, options, &block)
+      end
+      
+      def rake(name, options = {}, &block)
+        @installer = Sprinkle::Installers::Rake.new(self, name, options, &block)        
+      end
+      
+      def push_text(text, path, options = {}, &block)
+        @installer = Sprinkle::Installers::PushText.new(self, text, path, options, &block)
+      end
+
+      def script(name, options = {}, &block)
+        @installer = Sprinkle::Installers::Script.new(self, name, 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 "--> 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)
+        return if @verifications.blank?
+        
+        if pre
+          logger.info "\n#{self.name}"
+          logger.debug "--> Checking if already installed for roles: #{roles}"
+        else
+          logger.info "--> Verifying if properly installed for roles: #{roles}"
+        end
+        
+        @verifications.each do |v|
+          v.defaults(deployment)
+          v.process(roles)
+        end
+      end
+
+      def requires(*packages)
+        @dependencies << packages
+        @dependencies.flatten!
+      end
+
+      def recommends(*packages)
+        @recommends << packages
+        @recommends.flatten!
+      end
+
+      def tree(depth = 1, &block)
+        packages = []
+
+        @recommends.each do |dep|
+          package = PACKAGES[dep]
+          next unless package # skip missing recommended packages as they can be optional
+          block.call(self, package, depth) if block
+          packages << package.tree(depth + 1, &block)
+        end
+
+        @dependencies.each do |dep|
+          package = PACKAGES[dep]
+          package = select_package(dep, package) if package.is_a? Array
+          
+          raise "Package definition not found for key: #{dep}" unless package
+          block.call(self, package, depth) if block
+          packages << package.tree(depth + 1, &block)
+        end
+
+        packages << self
+      end
+
+      def to_s; @name; end
+
+      private
+
+        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 meta_package?
+          @installer == nil
+        end
+    end
+  end
+end