auser-sprinkle 0.1.5

data/lib/sprinkle/extensions/arbitrary_options.rb

@@ -0,0 +1,10 @@
+module ArbitraryOptions
+  def self.included(base)
+    base.alias_method_chain :method_missing, :arbitrary_options
+  end
+  
+  def method_missing_with_arbitrary_options(sym, *args, &block)
+    self.class.dsl_accessor sym
+    send(sym, *args, &block)
+  end
+end

data/lib/sprinkle/extensions/array.rb

@@ -0,0 +1,7 @@
+class Array
+  
+  def to_task_name
+    collect(&:to_task_name).join('_')
+  end
+  
+end

data/lib/sprinkle/extensions/blank_slate.rb

@@ -0,0 +1,5 @@
+class BlankSlate
+  instance_methods.each do |m| 
+    undef_method(m) unless %w( __send__ __id__ send class inspect instance_eval instance_variables ).include?(m)
+  end
+end

data/lib/sprinkle/extensions/dsl_accessor.rb

@@ -0,0 +1,15 @@
+class Module
+  def dsl_accessor(*symbols)
+    symbols.each do |sym|
+      class_eval %{
+        def #{sym}(*val)
+          if val.empty?
+            @#{sym}
+          else
+            @#{sym} = val.size == 1 ? val[0] : val
+          end
+        end
+      }
+    end
+  end
+end

data/lib/sprinkle/extensions/string.rb

@@ -0,0 +1,10 @@
+class String
+  
+  # REVISIT: what chars shall we allow in task names?
+  def to_task_name
+    s = downcase
+    s.gsub!(/-/, '_') # all - to _ chars
+    s
+  end
+  
+end

data/lib/sprinkle/extensions/symbol.rb

@@ -0,0 +1,7 @@
+class Symbol
+  
+  def to_task_name
+    to_s.to_task_name
+  end
+  
+end

data/lib/sprinkle/installers/apt.rb

@@ -0,0 +1,25 @@
+module Sprinkle
+  module Installers
+    class Apt < Installer
+      attr_accessor :packages
+
+      def initialize(parent, *packages, &block)
+        super parent, &block
+        packages.flatten!
+        
+        options = { :dependencies_only => false }
+        options.update(packages.pop) if packages.last.is_a?(Hash)
+        
+        @command = options[:dependencies_only] ? 'build-dep' : 'install'
+        @packages = packages
+      end
+
+      protected
+
+        def install_commands
+          "DEBCONF_TERSE='yes' DEBIAN_PRIORITY='critical' DEBIAN_FRONTEND=noninteractive apt-get -qyu #{@command} #{@packages.join(' ')}"
+        end
+
+    end
+  end
+end

data/lib/sprinkle/installers/gem.rb

@@ -0,0 +1,33 @@
+module Sprinkle
+  module Installers
+    class Gem < Installer
+      attr_accessor :gem
+
+      def initialize(parent, gem, options = {}, &block)
+        super parent, options, &block
+        @gem = gem
+      end
+
+      def source(location = nil)
+        # package defines an installer called source so here we specify a method directly
+        # rather than rely on the automatic options processing since packages' method missing
+        # won't be run
+        return @options[:source] unless location
+        @options[:source] = location
+      end
+
+      protected
+
+        # rubygems 0.9.5+ installs dependencies by default, and does platform selection
+
+        def install_commands
+          cmd = "gem install #{gem}"
+          cmd << " --version '#{version}'" if version
+          cmd << " --source #{source}" if source
+          cmd << " --install-dir #{repository}" if repository
+          cmd
+        end
+
+    end
+  end
+end

data/lib/sprinkle/installers/installer.rb

@@ -0,0 +1,74 @@
+module Sprinkle
+  module Installers
+    class Installer
+      include Sprinkle::Configurable
+      attr_accessor :delivery, :package, :options, :pre, :post
+
+      def initialize(package, options = {}, &block)
+        @package = package
+        @options = options
+        @pre = {}; @post = {}
+        self.instance_eval(&block) if block
+      end
+
+      def pre(stage, *commands)
+        @pre[stage] ||= []
+        @pre[stage] += commands
+        @pre[stage] += [yield] if block_given?
+      end
+
+      def post(stage, *commands)
+        @post[stage] ||= []
+        @post[stage] += commands
+        @post[stage] += [yield] if block_given?
+      end
+
+      def process(roles)
+        assert_delivery
+
+        if logger.debug?
+          sequence = install_sequence; sequence = sequence.join('; ') if sequence.is_a? Array
+          logger.debug "#{@package.name} install sequence: #{sequence} for roles: #{roles}\n"
+        end
+
+        unless Sprinkle::OPTIONS[:testing]
+          logger.info "--> Installing #{package.name} for roles: #{roles}"
+          @delivery.process(@package.name, install_sequence, roles)
+        end
+      end
+
+      protected
+
+        # Installation is separated into two styles that concrete derivative installer classes
+        # can implement.
+        #
+        # Simple installers that issue a single or set of commands can overwride
+        # install_commands (eg. apt, gem, rpm). Pre/post install commands are included in this
+        # style for free.
+        #
+        # More complicated installers that have different stages, and require pre/post commands
+        # within stages can override install_sequence and take complete control of the install
+        # command sequence construction (eg. source based installer).
+
+        def install_sequence
+          commands = pre_commands(:install) + [ install_commands ] + post_commands(:install)
+          commands.flatten
+        end
+
+        def install_commands
+          raise 'Concrete installers implement this to specify commands to run to install their respective packages'
+        end
+
+        def pre_commands(stage)
+          dress @pre[stage] || [], :pre
+        end
+
+        def post_commands(stage)
+          dress @post[stage] || [], :post
+        end
+
+        def dress(commands, stage); commands; end
+
+    end
+  end
+end

data/lib/sprinkle/installers/rake.rb

@@ -0,0 +1,17 @@
+module Sprinkle
+  module Installers
+    class Rake < Installer
+      def initialize(parent, commands = [], &block)
+        super parent, &block
+        @commands = commands
+      end
+
+      protected
+
+        def install_commands
+          "rake #{@commands.join(' ')}"
+        end
+
+    end
+  end
+end

data/lib/sprinkle/installers/rpm.rb

@@ -0,0 +1,20 @@
+module Sprinkle
+  module Installers
+    class Rpm < Installer
+      attr_accessor :packages
+
+      def initialize(parent, packages, &block)
+        super parent, &block
+        packages = [packages] unless packages.is_a? Array
+        @packages = packages
+      end
+
+      protected
+
+        def install_commands
+          "rpm -Uvh #{@packages.join(' ')}"
+        end
+
+    end
+  end
+end

data/lib/sprinkle/installers/source.rb

@@ -0,0 +1,121 @@
+module Sprinkle
+  module Installers
+    class Source < Installer
+      attr_accessor :source
+
+      def initialize(parent, source, options = {}, &block)
+        @source = source
+        super parent, options, &block
+      end
+
+      protected
+
+        def install_sequence
+          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
+          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
+          [ "wget -cq --directory-prefix='#{@options[:archives]}' #{@source}" ]
+        end
+
+        def extract_commands
+          [ "bash -c 'cd #{@options[:builds]} && #{extract_command} #{@options[:archives]}/#{archive_name}'" ]
+        end
+
+        def configure_commands
+          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
+          return [] if custom_install?
+          [ "bash -c 'cd #{build_dir} && make > #{@package.name}-build.log 2>&1'" ]
+        end
+
+        def install_commands
+          return custom_install_commands if custom_install?
+          [ "bash -c 'cd #{build_dir} && make install > #{@package.name}-install.log 2>&1'" ]
+        end
+
+        def custom_install?
+          !! @options[:custom_install]
+        end
+
+        # REVISIT: must be better processing of custom install commands somehow? use splat operator?
+        def custom_install_commands
+          dress @options[:custom_install], :install
+        end
+
+      protected
+
+        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)
+          @options[key].inject(' ') { |m, option| m << "#{prefix}-#{option} "; m }
+        end
+
+        def extract_command
+          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
+          name = @source.split('/').last
+          raise "Unable to determine archive name for source: #{source}, please update code knowledge" unless name
+          name
+        end
+
+        def build_dir
+          "#{@options[:builds]}/#{options[:custom_dir] || base_dir}"
+        end
+
+        def base_dir
+          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/package.rb

@@ -0,0 +1,127 @@
+module Sprinkle
+  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
+      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 apt(*names, &block)
+        @installer = Sprinkle::Installers::Apt.new(self, *names, &block)
+      end
+
+      def rpm(*names, &block)
+        @installer = Sprinkle::Installers::Rpm.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 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)
+        @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]
+          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 meta_package?
+          @installer == nil
+        end
+    end
+  end
+end