dhill-sprinkle 0.3.3.1

data/lib/sprinkle/installers/transfer.rb

@@ -0,0 +1,178 @@
+# Blatantly stole this from Chef
+class TemplateError < RuntimeError
+  attr_reader :original_exception, :context
+  SOURCE_CONTEXT_WINDOW = 2 unless defined? SOURCE_CONTEXT_WINDOW
+  
+  def initialize(original_exception, template, context)
+    @original_exception, @template, @context = original_exception, template, context
+  end
+  
+  def message
+    @original_exception.message
+  end
+  
+  def line_number
+    @line_number ||= $1.to_i if original_exception.backtrace.find {|line| line =~ /\(erubis\):(\d+)/ }
+  end
+  
+  def source_location
+    "on line ##{line_number}"
+  end
+  
+  def source_listing
+		return nil if line_number.nil?
+		
+    @source_listing ||= begin
+      line_index = line_number - 1
+      beginning_line = line_index <= SOURCE_CONTEXT_WINDOW ? 0 : line_index - SOURCE_CONTEXT_WINDOW
+      source_size = SOURCE_CONTEXT_WINDOW * 2 + 1
+      lines = @template.split(/\n/)
+      contextual_lines = lines[beginning_line, source_size]
+      output = []
+      contextual_lines.each_with_index do |line, index|
+        line_number = (index+beginning_line+1).to_s.rjust(3)
+        output << "#{line_number}: #{line}"
+      end
+      output.join("\n")
+    end
+  end
+  
+  def to_s
+    "\n\n#{self.class} (#{message}) #{source_location}:\n\n" +
+      "#{source_listing}\n\n  #{original_exception.backtrace.join("\n  ")}\n\n"
+  end
+end
+
+module Sprinkle
+  module Installers
+    # Beware, another strange "installer" coming your way.
+    #
+    # = File transfer installer
+    #
+    # This installer pushes files from the local disk to remote servers.
+    # 
+    # == Example Usage
+    #
+    # Installing a nginx.conf onto remote servers
+    #
+    #   package :nginx_conf do
+    #     transfer 'files/nginx.conf', '/etc/nginx.conf'
+    #   end
+    #
+    # If you user has access to 'sudo' and theres a file that requires
+    # priveledges, you can pass :sudo => true 
+    #
+    #   package :nginx_conf do
+    #     transfer 'files/nginx.conf', '/etc/nginx.conf', :sudo => true
+    #   end
+    #
+		# By default, transfers are recursive and you can move whole directories
+		# via this method. If you wish to disable recursive transfers, you can pass
+		# recursive => false, although it will not be obeyed when using the Vlad actor.
+    #
+		# If you pass the option :render => true, this tells transfer that the source file
+		# is an ERB template to be rendered locally before being transferred (you can declare
+		# variables in the package scope). When render is true, recursive is turned off. Note
+		# you can also explicitly pass locals in to render with the :locals option.
+		#   
+		#   package :nginx_conf do
+		#     nginx_port = 8080
+		#     transfer 'files/nginx.conf', '/etc/nginx.conf', :render => true
+		#   end
+		#
+		# Finally, should you need to run commands before or after the file transfer (making
+		# directories or changing permissions), you can use the pre/post :install directives
+		# and they will be run.
+    class Transfer < Installer
+      attr_accessor :source, :destination #:nodoc:
+
+      def initialize(parent, source, destination, options={}, &block) #:nodoc:
+        super parent, options, &block
+        @source = source
+        @destination = destination
+      end
+
+			def install_commands
+				nil
+			end
+			
+			def self.render_template(template, context, prefix)
+				require 'tempfile'
+				require 'erubis'
+
+				begin
+          eruby = Erubis::Eruby.new(template)
+          output = eruby.result(context)
+        rescue Object => e
+          raise TemplateError.new(e, template, context)
+        end
+
+        final_tempfile = Tempfile.new(prefix)
+        final_tempfile.print(output)
+        final_tempfile.close
+				final_tempfile
+			end
+			
+			def render_template(template, context, prefix)
+				self.class.render_template(template, context, prefix)
+			end
+			
+			def render_template_file(path, context, prefix)
+				template = File.read(path)
+				tempfile = render_template(template, context, @package.name)
+				tempfile
+			end
+			
+      def process(roles) #:nodoc:
+        assert_delivery
+
+        if logger.debug?
+          logger.debug "transfer: #{@source} -> #{@destination} for roles: #{roles}\n"
+        end
+
+        unless Sprinkle::OPTIONS[:testing]
+					pre = pre_commands(:install)
+					unless pre.empty?
+						sequence = pre; sequence = sequence.join('; ') if sequence.is_a? Array
+						logger.info "#{@package.name} pre-transfer commands: #{sequence} for roles: #{roles}\n"
+						@delivery.process @package.name, sequence, roles
+					end
+					
+					recursive = @options[:recursive]
+					
+					if options[:render]
+					  if options[:locals]
+					    context = {}
+					    options[:locals].each_pair do |k,v|
+					      if v.respond_to?(:call)
+					        context[k] = v.call
+					      else
+					        context[k] = v
+					      end
+					    end
+					  else
+					    context = binding()
+					  end
+					  
+						tempfile = render_template_file(@source, context, @package.name)
+						sourcepath = tempfile.path
+						logger.info "Rendering template #{@source} to temporary file #{sourcepath}"
+						recursive = false
+					else
+						sourcepath = @source
+					end
+					
+					logger.info "--> Transferring #{sourcepath} to #{@destination} for roles: #{roles}"
+          @delivery.transfer(@package.name, sourcepath, @destination, roles, recursive)
+					
+					post = post_commands(:install)
+					unless post.empty?
+						sequence = post; sequence = sequence.join('; ') if sequence.is_a? Array
+						logger.info "#{@package.name} post-transfer commands: #{sequence} for roles: #{roles}\n"
+						@delivery.process @package.name, sequence, roles
+					end
+        end
+      end
+    end
+  end
+end

data/lib/sprinkle/installers/user.rb

@@ -0,0 +1,15 @@
+module Sprinkle
+  module Installers
+    class User < Installer
+      def initialize(package, username, options, &block)
+        super package, &block
+        @username=username
+        @options =options
+      end
+      protected 
+      def install_commands
+        "adduser #{@options[:flags]} #{@username}"
+      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/installers/zypper.rb

@@ -0,0 +1,43 @@
+module Sprinkle
+  module Installers
+    # = Zypper Installer
+    #
+    # Zypper is a command-line interface to ZYpp system management library.
+    # It mostly be used on Suse or OpenSuse.
+    # 
+    # == Example Usage
+    #
+    # Installing the magic_beans package via Zypper. Its all the craze these days.
+    #
+    #   package :magic_beans do
+    #     zypper 'magic_beans'
+    #   end
+    #
+    # You may also specify multiple packages as an array:
+    #
+    #   package :magic_beans do
+    #     zypper %w(magic_beans magic_sauce)
+    #   end
+    #
+    # or an argument list:
+    #
+    #   package :magic_beans do
+    #     zypper "magic_beans", "magic_sauce"
+    #   end
+    class Zypper < Installer
+      attr_accessor :packages #:nodoc:
+
+      def initialize(parent, *packages, &block) #:nodoc:
+        packages.flatten!
+        super parent, &block
+        @packages = packages
+      end
+
+      protected
+
+      def install_commands #:nodoc:
+        "zypper -n install -l -R #{@packages.join(' ')}"
+      end
+    end
+  end
+end

data/lib/sprinkle/package.rb

@@ -0,0 +1,326 @@
+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, :installers, :dependencies, :recommends, :verifications
+
+      def initialize(name, metadata = {}, &block)
+        raise 'No package name supplied' unless name
+
+        @name = name
+        @provides = metadata[:provides]
+        @dependencies = []
+        @recommends = []
+        @optional = []
+        @verifications = []
+        @installers = []
+        self.instance_eval &block
+      end
+      def add_user(username, options={},  &block)
+        @installers<<Sprinkle::Installers::User.new(self, username, options, &block)
+      end
+
+      def freebsd_pkg(*names, &block)
+        @installers << Sprinkle::Installers::FreebsdPkg.new(self, *names, &block)
+      end
+      
+      def freebsd_portinstall(port, &block)
+        @installers << Sprinkle::Installers::FreebsdPortinstall.new(self, port, &block)
+      end
+
+      def openbsd_pkg(*names, &block)
+        @installers << Sprinkle::Installers::OpenbsdPkg.new(self, *names, &block)
+      end
+      
+      def opensolaris_pkg(*names, &block)
+        @installers << Sprinkle::Installers::OpensolarisPkg.new(self, *names, &block)
+      end
+      
+      def bsd_port(port, &block)
+        @installers << Sprinkle::Installers::BsdPort.new(self, port, &block)
+      end
+      
+      def mac_port(port, &block)
+        @installers << Sprinkle::Installers::MacPort.new(self, port, &block)
+      end
+
+      def apt(*names, &block)
+        @installers << Sprinkle::Installers::Apt.new(self, *names, &block)
+      end
+
+      def deb(*names, &block)
+        @installers << Sprinkle::Installers::Deb.new(self, *names, &block)
+      end
+
+      def rpm(*names, &block)
+        @installers << Sprinkle::Installers::Rpm.new(self, *names, &block)
+      end
+
+      def yum(*names, &block)
+        @installers << Sprinkle::Installers::Yum.new(self, *names, &block)
+      end
+
+      def zypper(*names, &block)
+        @installers << Sprinkle::Installers::Zypper.new(self, *names, &block)
+      end
+
+      def gem(name, options = {}, &block)
+        @recommends << :rubygems
+        @installers << Sprinkle::Installers::Gem.new(self, name, options, &block)
+      end
+
+      def source(source, options = {}, &block)
+        @recommends << :build_essential # Ubuntu/Debian
+        @installers << Sprinkle::Installers::Source.new(self, source, options, &block)
+      end
+      
+      def binary(source, options = {}, &block)
+        @installers << Sprinkle::Installers::Binary.new(self, source, options, &block)
+      end
+      
+      def rake(name, options = {}, &block)
+        @installers << Sprinkle::Installers::Rake.new(self, name, options, &block)
+      end    
+      
+      def noop(&block)
+        @installers << Sprinkle::Installers::Noop.new(self, name, options, &block)
+      end
+      
+      def push_text(text, path, options = {}, &block)
+        @installers << Sprinkle::Installers::PushText.new(self, text, path, options, &block)
+      end
+
+      def replace_text(regex, text, path, options={}, &block)
+        @installers << Sprinkle::Installers::ReplaceText.new(self, regex, text, path, options, &block)
+      end
+      
+      def transfer(source, destination, options = {}, &block)
+        @installers << Sprinkle::Installers::Transfer.new(self, source, destination, options, &block)
+      end
+
+			def runner(cmd)
+				@installers << Sprinkle::Installers::Runner.new(self, cmd)
+			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
+
+        @installers.each do |installer|
+          installer.defaults(deployment)
+          installer.process(roles)
+        end
+        
+        process_verifications(deployment, roles)
+      end
+      
+      def process_verifications(deployment, roles, pre = false)
+    	# DWH 20110407 - output command sent to server for better status and debugging
+        puts "\n======================= #{self.name} =======================\n\n"
+        return if @verifications.blank?
+        
+        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 optional(*packages)
+        @optional << packages
+        @optional.flatten!
+      end
+
+      def tree(depth = 1, &block)
+        packages = []
+
+        @recommends.each do |dep|
+          package = PACKAGES[dep]
+          next unless package # skip missing recommended packages as they're allowed to not exist
+          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
+
+        @optional.each do |dep|
+          package = PACKAGES[dep]
+          next unless package # skip missing optional packages as they're allow to not exist
+          block.call(self, package, depth) if block
+          packages << package.tree(depth + 1, &block)
+        end
+
+        packages
+      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?
+          @installers.blank?
+        end
+    end
+  end
+end