sprinkle 0.4.2 → 0.5.0.rc1

data/lib/sprinkle/installers/zypper.rb

@@ -13,25 +13,14 @@ module Sprinkle
     #     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:
+    # You may also specify multiple packages as an argument list or array:
     #
     #   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
+    class Zypper < PackageInstaller
+      
+      auto_api
 
       protected
 

data/lib/sprinkle/package.rb

@@ -106,128 +106,84 @@ module Sprinkle
     end
 
     class Package #:nodoc:
-      include ArbitraryOptions
-      attr_accessor :name, :provides, :installers, :dependencies, :recommends, :verifications
+      # include ArbitraryOptions
+      attr_accessor :name, :provides, :installers, :verifications
+      attr_accessor :args, :opts
 
       def initialize(name, metadata = {}, &block)
         raise 'No package name supplied' unless name
 
         @name = name
+        @metadata = metadata
         @provides = metadata[:provides]
         @dependencies = []
         @recommends = []
         @optional = []
         @verifications = []
         @installers = []
+        @block = block
+        # this should probably not be done twice
         self.instance_eval &block
       end
-      def add_user(username, options={},  &block)
-        @installers << Sprinkle::Installers::User.new(self, username, options, &block)
-      end
-
-      def add_group(group, options={},  &block)
-        @installers << Sprinkle::Installers::Group.new(self, group, 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)
+      def description(s=nil)
+        s ? @description = s : @description
       end
       
-      def opensolaris_pkg(*names, &block)
-        @installers << Sprinkle::Installers::OpensolarisPkg.new(self, *names, &block)
+      def version(s=nil)
+        s ? @version = s : @version
       end
       
-      def bsd_port(port, &block)
-        @installers << Sprinkle::Installers::BsdPort.new(self, port, &block)
+      def instance(*args)
+        p=Package.new(name, @metadata) {}
+        p.opts = args.extract_options!
+        p.args = args
+        p.instance_variable_set("@block", @block)
+        p.instance_eval &@block
+        p
       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)
+      def sudo?
+        @use_sudo
       end
       
-      def brew(*names, &block)
-        @installers << Sprinkle::Installers::Brew.new(self, *names, &block)
+      def use_sudo(flag=true)
+        @use_sudo = flag
       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)
+            
+      def args
+        @args || []
       end
       
-      def binary(source, options = {}, &block)
-        @installers << Sprinkle::Installers::Binary.new(self, source, options, &block)
+      def opts
+        @opts || {}
       end
       
-      def rake(name, options = {}, &block)
-        @installers << Sprinkle::Installers::Rake.new(self, name, options, &block)
-      end    
-      
-      def thor(name, options = {}, &block)
-        @installers << Sprinkle::Installers::Thor.new(self, name, options, &block)
-      end  
-     
-      def noop(&block)
-        @installers << Sprinkle::Installers::Runner.new(self, "echo noop", &block)
+      class ContextError < StandardError #:nodoc:
       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)
+      def get(x)
+        raise ContextError, "Cannot call get inside a package, must be inside an Installer block"
       end
       
-      def transfer(source, destination, options = {}, &block)
-        @installers << Sprinkle::Installers::Transfer.new(self, source, destination, options, &block)
+      def noop(&block)
+        install Sprinkle::Installers::Runner.new(self, "echo noop", &block)
       end
-
-			def runner(cmd, &block)
-				@installers << Sprinkle::Installers::Runner.new(self, cmd, &block)
-			end
-
+                  
+      # meta installer
+      # TODO - fix to be atomic
+      def push_file(file, options ={}, &block)
+        raise "need content" unless options[:content]
+        runner "#{"sudo " if sudo?}rm -f #{file}"
+        push_text options[:content], file, options, &block
+      end
+                  
       def verify(description = '', &block)
         @verifications << Sprinkle::Verify.new(self, description, &block)
       end  
-
-      def pacman(*names, &block)
-        @installers << Sprinkle::Installers::Pacman.new(self, *names, &block)
-      end
       
       def process(deployment, roles)
+        logger.info "  * #{name}"
         return if meta_package?
         
         # Run a pre-test to see if the software is already installed. If so,
@@ -236,7 +192,7 @@ module Sprinkle
           begin
             process_verifications(deployment, roles, true)
             
-            logger.info "--> #{self.name} already installed for roles: #{roles}"
+            logger.info "    --> already installed for roles: #{roles}"
             return
           rescue Sprinkle::VerificationFailed => e
             # Continue
@@ -249,15 +205,16 @@ module Sprinkle
         end
         
         process_verifications(deployment, roles)
+        logger.info "    --> INSTALLED for roles: #{roles}"
       end
       
       def process_verifications(deployment, roles, pre = false)
         return if @verifications.blank?
         
         if pre
-          logger.info "--> Checking if #{self.name} is already installed for roles: #{roles}"
+          logger.debug "--> Checking if #{self.name} is already installed for roles: #{roles}"
         else
-          logger.info "--> Verifying #{self.name} was properly installed for roles: #{roles}"
+          logger.debug "--> Verifying #{self.name} was properly installed for roles: #{roles}"
         end
         
         @verifications.each do |v|
@@ -265,46 +222,61 @@ module Sprinkle
           v.process(roles)
         end
       end
-
+      
+      def dependencies
+        @dependencies.map {|a,b| a }
+      end
+      
       def requires(*packages)
-        @dependencies << packages
-        @dependencies.flatten!
+        opts = packages.extract_options!
+        packages.each do |pack|
+          @dependencies << [pack, opts]
+        end
       end
 
       def recommends(*packages)
-        @recommends << packages
-        @recommends.flatten!
+        opts = packages.extract_options!
+        packages.each do |pack|
+          @recommends << [pack, opts]
+        end
+        @recommends.map {|a,b| a }
       end
 
       def optional(*packages)
-        @optional << packages
-        @optional.flatten!
+        opts = packages.extract_options!
+        packages.each do |pack|
+          @optional << [pack, opts]
+        end
+        @optional.map {|a,b| a }
       end
 
       def tree(depth = 1, &block)
         packages = []
 
-        @recommends.each do |dep|
+        @recommends.each do |dep, config|
           package = PACKAGES[dep]
           next unless package # skip missing recommended packages as they're allowed to not exist
+          package=package.instance(config)
           block.call(self, package, depth) if block
           packages << package.tree(depth + 1, &block)
         end
 
-        @dependencies.each do |dep|
+        @dependencies.each do |dep, config|
           package = PACKAGES[dep]
           package = select_package(dep, package) if package.is_a? Array
           
           raise "Package definition not found for key: #{dep}" unless package
+          package = package.instance(config)
           block.call(self, package, depth) if block
           packages << package.tree(depth + 1, &block)
         end
 
         packages << self
 
-        @optional.each do |dep|
+        @optional.each do |dep, config|
           package = PACKAGES[dep]
           next unless package # skip missing optional packages as they're allow to not exist
+          package = package.instance(config)
           block.call(self, package, depth) if block
           packages << package.tree(depth + 1, &block)
         end
@@ -313,8 +285,19 @@ module Sprinkle
       end
 
       def to_s; @name; end
+      
+      protected
+      
+      def install(i)
+        @installers << i
+        i
+      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

data/lib/sprinkle/policy.rb

@@ -51,7 +51,7 @@ module Sprinkle
     end
 
     class Policy #:nodoc:
-      attr_reader :name, :packages
+      attr_reader :name, :roles
 
       def initialize(name, metadata = {}, &block)
         raise 'No name provided' unless name
@@ -63,23 +63,30 @@ module Sprinkle
         self.instance_eval(&block)
       end
 
-      def requires(package, options = {})
-        @packages << package
+      # def requires(package, options = {})
+      def requires(package, *args)
+        @packages << [package, args]
       end
+      
+      def packages; @packages.map {|x| x.first }; end
 
       def to_s; name; end
 
       def process(deployment)
         all = []
+        
+        logger.info "[#{name}]"
 
         cloud_info "--> Cloud hierarchy for policy #{@name}"
 
-        @packages.each do |p|
+        @packages.each do |p, args|
           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
+          # get an instance of the package and pass our config options
+          package = package.instance(*args)
 
           tree = package.tree do |parent, child, depth|
             indent = "\t" * depth; cloud_info "#{indent}Package #{parent.name} requires #{child.name}"

data/lib/sprinkle/utility/log_recorder.rb

@@ -0,0 +1,33 @@
+module Sprinkle
+  module Utility
+    class LogRecorder #:nodoc:
+      
+      attr_accessor :err, :out, :command, :code
+      
+      def initialize
+        reset
+      end
+            
+      def log(stream, data)
+        case stream
+          when :err then @err << data
+          when :out then @out << data
+        end
+      end
+      
+      # hash suitable to pass into a pretty failure details hash
+      def hash
+        {:error => err, :stdout => out, :command => command, :code => code}
+      end
+      
+      def reset(cmd=nil)
+        @command=cmd
+        @code=nil
+        @err=""
+        @out=""        
+      end
+      
+    end
+    
+  end
+end

data/lib/sprinkle/verifiers/directory.rb

@@ -9,7 +9,7 @@ module Sprinkle
       
       # Tests that the directory <tt>dir</tt> exists.
       def has_directory(dir)
-        @commands << "test -d #{dir}"
+        test "-d #{dir}"
       end
     end
   end

data/lib/sprinkle/verifiers/executable.rb

@@ -26,7 +26,7 @@ module Sprinkle
         # 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}"
+          test "-x #{path}"
         else
           @commands << "[ -n \"`echo \\`which #{path}\\``\" ]"
         end

data/lib/sprinkle/verifiers/file.rb

@@ -15,7 +15,15 @@ module Sprinkle
       
       # Checks to make sure <tt>path</tt> is a file on the remote server.
       def has_file(path)
-        @commands << "test -f #{path}"
+        test "-f #{path}"
+      end
+      
+      def no_file(path)
+        test "! -f #{path}"
+      end
+      
+      def md5_of_file(path, md5)
+        test "\"`md5sum #{path} | cut -f1 -d' '`\" = \"#{md5}\""
       end
       
       def file_contains(path, text)
@@ -26,7 +34,8 @@ module Sprinkle
       end
       def matches_local(localfile, remotefile, mode=nil)
         raise "Couldn't find local file #{localfile}" unless ::File.exists?(localfile)
-        local = `md5 #{localfile}`.split.last
+        require 'digest/md5'
+        local = Digest::MD5.hexdigest(::File.read(localfile))
         @commands << %{[ "X$(md5sum #{remotefile}|cut -d\\  -f 1)" = "X#{local}" ]}
       end
     end

data/lib/sprinkle/verifiers/package.rb

@@ -4,20 +4,8 @@ module Sprinkle
       Sprinkle::Verify.register(Sprinkle::Verifiers::Package)
 
       def has_package(*packages)
-        if packages.is_a?(Array) && packages.first.is_a?(Array)
-          packages = packages.first
-        else
-          packages = [packages] unless packages.is_a? Array
-        end
-
-        packages.each do |pak|
-          case Sprinkle::Installers::InstallPackage.installer
-            when :yum
-              @commands << "[ -n \"`yum list installed #{pak} 2> /dev/null | egrep -e \\\"#{pak}\\\"`\" ]"
-            else
-              raise "Unknown InstallPackage.installer"
-          end
-        end
+        puts "has_package and has_packages are depreciated"
+        raise "please use has_yum and friends instead"
       end
 
       alias_method :has_packages, :has_package