sprinkle 0.4.2 → 0.5.0.rc1

data/bin/sprinkle

@@ -20,7 +20,10 @@ ARGV.each do |arg|
   ENV[$1] = $2 if arg =~ /^(\w+)=(.*)$/
 end
 
+require File.dirname(__FILE__) + '/../lib/sprinkle/version'
+
 parser = OptionParser.new do |opts|
+  opts.version = Sprinkle::Version
   opts.banner = <<BANNER
 Sprinkle
 ========
@@ -44,6 +47,8 @@ BANNER
   opts.separator ""
   opts.on("-s", "--script=PATH", String,
           "Path to a sprinkle script to run") { |v| OPTIONS[:path] = v }
+  opts.on("--only [ROLE]", String,
+          "Only run sprinkle policies for the specified role") { |v| OPTIONS[:only_role] = v }
   opts.on("-t", "--test",
           "Process but don't perform any actions") { |v| OPTIONS[:testing] = v }
   opts.on("-v", "--verbose",
@@ -61,6 +66,12 @@ BANNER
   end
 end
 
+def only_role(options)
+  role=OPTIONS[:only_role]
+  Sprinkle::OPTIONS[:only_role] = role
+  puts "Only running policies for :#{role}"
+end
+
 def force_mode(options)
   Sprinkle::OPTIONS[:force] = OPTIONS[:force] || false
 end
@@ -78,7 +89,8 @@ def verbosity(options)
 end
 
 def log_level(options)
-  Object.logger.level = ActiveSupport::BufferedLogger::Severity::DEBUG if options[:verbose]
+  severity = ActiveSupport::BufferedLogger::Severity
+  Object.logger.level = options[:verbose] ? severity::DEBUG : severity::INFO
 end
 
 require File.dirname(__FILE__) + '/../lib/sprinkle'
@@ -91,5 +103,6 @@ operation_mode(OPTIONS)
 powder_cloud(OPTIONS)
 log_level(OPTIONS)
 verbosity(OPTIONS)
+only_role(OPTIONS)
 
 Sprinkle::Script.sprinkle File.read(powder), powder

data/lib/sprinkle.rb

@@ -1,5 +1,5 @@
 require 'rubygems'
-require 'active_support'
+require 'active_support/all'
 
 # Use active supports auto load mechanism
 require 'active_support/version'
@@ -14,10 +14,14 @@ end
 #ActiveSupport::Dependencies::RAILS_DEFAULT_LOGGER = Logger.new($stdout)
 #ActiveSupport::Dependencies.log_activity = true
 
+require File.dirname(__FILE__) + "/sprinkle/version.rb"
+
 # 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 }
+# Load up the installers so they can register themselves
+Dir[File.dirname(__FILE__) + '/sprinkle/installers/*.rb'].each { |e| require e }
 
 # Configuration options
 module Sprinkle

data/lib/sprinkle/actors/actors.rb

@@ -6,12 +6,27 @@
 #++
 
 module Sprinkle
-  # An actor is a method of command delivery to a remote machine. It is the
-  # layer between sprinkle and the SSH connection to run commands. This gives
-  # you the flexibility to define custom actors, for whatever purpose you need.
+  # An actor is a method of command delivery to a remote machine. Actors are the
+  # layer setting between Sprinkle and the systems you and wanting to apply
+  # policies to.  
   #
-  # 99% of the time, however, the two built-in actors Sprinkle::Actors::Capistrano
-  # and Sprinkle::Actors::Vlad will be enough.
+  # Sprinkle ships with actors for Capistrano, Vlad, localhost and pure SSH.
+  # 99% of the time these should be sufficient but you can always write your 
+  # own actor otherwise. 
+  #
+  # == Writing an actor
+  #
+  # Actors must provide only 3 methods:
+  # 
+  # * install (installer, roles, options)
+  # * verify (verifier, roles, options)
+  # * transfer (source, destination, roles, options)
+  #
+  # Hopefully these methods are kind of fairly obvious.  They should return true
+  # to indicate success and false to indicate failure.
+  # The actual commands you need to execute can be retrived from 
+  # +installer.install_sequence+ and +verifier.commands+.  
+  
   module Actors
   end
 end

data/lib/sprinkle/actors/capistrano.rb

@@ -2,16 +2,15 @@ require 'capistrano/cli'
 
 module Sprinkle
   module Actors
-    # = Capistrano Delivery Method
+    # The Capistrano actor uses Capistrano to define your roles and deliver 
+    # commands to your remote servers.  You'll need the capistrano gem installed.
     #
-    # Capistrano is one of the delivery method options available out of the
-    # box with Sprinkle. If you have the capistrano gem install, you may use
-    # this delivery. The only configuration option available, and which is 
-    # mandatory to include is +recipes+. An example:
+    # The only configuration option is to specify a recipe.
     #
     #   deployment do
     #     delivery :capistrano do
-    #       recipes 'deploy'
+    #       recipe 'deploy'
+    #       recipe 'more'
     #     end
     #   end
     #
@@ -47,52 +46,79 @@ module Sprinkle
       #
       #   deployment do
       #     delivery :capistrano do
-      #       recipes 'deploy'
-      #       recipes 'magic_beans'
+      #       recipe 'deploy'
+      #       recipes 'magic_beans', 'normal_beans'
       #     end
       #   end
-      def recipes(script)
+      def recipe(scripts)
         @loaded_recipes ||= []
-        @config.load script
-        @loaded_recipes << script
+        Array(scripts).each do |script|
+          @config.load script
+          @loaded_recipes << script        
+        end
       end
-
-      def process(name, commands, roles, suppress_and_return_failures = false) #:nodoc:
+      
+      def recipes(scripts) #:nodoc:
+        recipe(scripts)
+      end
+      
+      def install(installer, roles, opts = {}) #:nodoc:
+        @installer = installer
+        process(installer.package.name, installer.install_sequence, roles, opts)
+      rescue ::Capistrano::CommandError => e
+        raise_error(e)
+      ensure
+        @installer = nil
+      end
+      
+      def verify(verifier, roles, opts = {}) #:nodoc:
+        process(verifier.package.name, verifier.commands, roles, 
+          :suppress_and_return_failures => true)
+      end
+            
+      def process(name, commands, roles, opts = {}) #:nodoc:
+        inst=@installer
+        @log_recorder = log_recorder = Sprinkle::Utility::LogRecorder.new
         define_task(name, roles) do
           via = fetch(:run_method, :sudo)
           commands.each do |command|
-            invoke_command command, :via => via
+            if command == :TRANSFER
+              opts.reverse_merge!(:recursive => true)
+              upload inst.sourcepath, inst.destination, :via => :scp, 
+                :recursive => opts[:recursive]
+            elsif command == :RECONNECT
+              teardown_connections_to(sessions.keys)
+            else
+              # this reset the log
+              log_recorder.reset command
+              invoke_command(command, {:via => via}) do |c,s,d| 
+                # record the stream and data
+                log_recorder.log(s, d)
+              end
+            end
           end
         end
-        
-        begin
-          run(name)
-          return true
-        rescue ::Capistrano::CommandError => e
-          return false if suppress_and_return_failures
-          
-          # Reraise error if we're not suppressing it
-          raise
-        end
+        run_task(name, opts)
       end
-
-      def transfer(name, source, destination, roles, recursive = true, suppress_and_return_failures = false)
-        define_task(name, roles) do
-          upload source, destination, :via => :scp, :recursive => recursive
+			
+      private
+            
+        def raise_error(e)
+          details={:command => @log_recorder.command, :code => "??", 
+            :message => e.message,
+            :hosts => e.hosts,
+            :error => @log_recorder.err, :stdout => @log_recorder.out}
+          raise Sprinkle::Errors::RemoteCommandFailure.new(@installer, details, e)
         end
-        
-        begin
-          run(name)
+      
+        def run_task(task, opts={})
+          run(task)
           return true
         rescue ::Capistrano::CommandError => e
-          return false if suppress_and_return_failures
-          
+          return false if opts[:suppress_and_return_failures]
           # Reraise error if we're not suppressing it
           raise
         end
-      end
-			
-      private
 
         # REVISIT: can we set the description somehow?
         def define_task(name, roles, &block)

data/lib/sprinkle/actors/dummy.rb

@@ -0,0 +1,127 @@
+require 'capistrano/cli'
+require 'pp'
+
+module Sprinkle
+  module Actors
+    # = Capistrano Delivery Method
+    #
+    # Capistrano is one of the delivery method options available out of the
+    # box with Sprinkle. If you have the capistrano gem install, you may use
+    # this delivery. The only configuration option available, and which is 
+    # mandatory to include is +recipes+. An example:
+    #
+    #   deployment do
+    #     delivery :capistrano do
+    #       recipes 'deploy'
+    #     end
+    #   end
+    #
+    # Recipes is given a list of files which capistrano will include and load.
+    # These recipes are mainly to set variables such as :user, :password, and to 
+    # set the app domain which will be sprinkled. 
+    class Dummy #:nodoc:
+      attr_accessor :config, :loaded_recipes #:nodoc:
+
+      def initialize(&block) #:nodoc:
+        # @config.set(:_sprinkle_actor, self)
+        @roles={}
+        self.instance_eval &block
+      end
+
+      # Defines a recipe file which will be included by capistrano. Use these
+      # recipe files to set capistrano specific configurations. Default recipe
+      # included is "deploy." But if any other recipe is specified, it will
+      # include that instead. Multiple recipes may be specified through multiple
+      # recipes calls, an example:
+      #
+      #   deployment do
+      #     delivery :capistrano do
+      #       recipes 'deploy'
+      #       recipes 'magic_beans'
+      #     end
+      #   end
+      # def recipes(script)
+      # end
+      
+      def role(role, server, opts={})
+        @roles[role]||=[]
+        @roles[role] << [ server, opts ]
+      end
+      
+      def install(installer, roles, opts={})
+        if per_host=opts.delete(:per_host)
+          servers_per_role(roles).each do |server|
+            installer.reconfigure_for(server)
+            installer.announce
+            process(installer.package.name, installer.install_sequence, server, opts)
+          end
+        else
+          process(installer.package, installer.install_sequence, roles, opts)
+        end
+      end
+      
+      def verify(verifier, roles, opts = {})
+        process(verifier.package.name, verifier.commands, roles, opts = {})
+      end
+      
+      def servers_per_role(role)
+        @roles[role]
+      end
+
+      def process(name, commands, roles, opts = {}) #:nodoc:
+        # puts "PROCESS: #{name} on #{roles}"
+        pp commands
+        # return false if suppress_and_return_failures
+        true
+      end
+
+      def transfer(name, source, destination, roles, recursive = true, suppress_and_return_failures = false)
+        
+      end
+			
+      private
+
+        # REVISIT: can we set the description somehow?
+        def define_task(name, roles, &block)
+          @config.task task_sym(name), :roles => roles, &block
+        end
+
+        def run(task)
+          @config.send task_sym(task)
+        end
+
+        def task_sym(name)
+          "install_#{name.to_task_name}".to_sym
+        end
+    end
+  end
+end
+
+
+=begin
+
+# channel: the SSH channel object used for this response
+# stream: either :err or :out, for stderr or stdout responses
+# output: the text that the server is sending, might be in chunks
+run "apt-get update" do |channel, stream, output|
+   if output =~ /Are you sure?/
+     answer = Capistrano::CLI.ui.ask("Are you sure: ")
+     channel.send_data(answer + "\n")
+   else
+     # allow the default callback to be processed
+     Capistrano::Configuration.default_io_proc.call[channel, stream, output]
+   end
+ end
+
+
+
+ You can tell subversion to use a different username+password by
+ setting a couple variables:
+    set :svn_username, "my svn username"
+    set :svn_password, "my svn password"
+ If you don't want to set the password explicitly in your recipe like
+ that, you can make capistrano prompt you for it like this:
+    set(:svn_password) { Capistrano::CLI.password_prompt("Subversion
+ password: ") }
+ - Jamis
+=end

data/lib/sprinkle/actors/local.rb

@@ -1,37 +1,79 @@
+require 'open4'
+
 module Sprinkle
   module Actors
-    # = Local Delivery Method
+    # The local actor executes all commands on your local system, as opposed to other 
+    # implementations that generally run commands on a remote system over the
+    # network.
     #
-    # This actor implementation performs any given commands on your local system, as
-    # opposed to other implementations that generally run commands on a remote system
-    # via the network.
-    #
-    # This is useful if you'd like to use Sprinkle to provision your local machine. 
-    # To enable this actor, in your Sprinkle script specify the :local delivery mechanism. 
+    # This could be useful if you'd like to use Sprinkle to provision your 
+    # local machine.  To enable this actor, in your Sprinkle script specify 
+    # the :local delivery mechanism. 
     #
     #   deployment do
     #     delivery :local
     #   end
     #
-    # Note, your local machine will be assumed to be a member of all roles when applying policies
-    #
+    # Note: The local actor completely ignores roles and behaves as if your
+    # local system was a member of all roles defined.
     class Local
       
-      def process(name, commands, roles, suppress_and_return_failures = false) #:nodoc:
+      class LocalCommandError < StandardError; end
+      
+      def install(installer, roles, opts = {}) #:nodoc:
+        # all local installer cares about is the commands
+        @installer = installer
+        process(installer.package.name, installer.install_sequence, roles)
+      rescue LocalCommandError => e
+        raise_error(e)
+      ensure
+        @installer = nil
+      end
+      
+      def verify(verifier, roles, opts = {}) #:nodoc:
+        process(verifier.package.name, verifier.commands, roles, :suppress_and_return_failures => true)
+      end
+      
+    protected
+      
+      def process(name, commands, roles, opts = {}) #:nodoc:
+        @log_recorder = Sprinkle::Utility::LogRecorder.new
         commands.each do |command|
-          system command
-          return false if $?.to_i != 0
+          if command == :RECONNECT
+            return true
+          elsif command == :TRANSFER
+            res = transfer(@installer.sourcepath, @installer.destination, roles,
+              :recursive => @installer.options[:recursive])
+            raise LocalCommandError if res != 0
+          else
+            res = run_command command
+            raise LocalCommandError if res != 0 and not opts[:suppress_and_return_failures]
+          end
         end
         return true
       end
       
-			def transfer(name, source, destination, roles, recursive = true, suppress_and_return_failures = false)
-				if recursive
-					flags = "-R "
-				end
+      def run_command(cmd)
+        @log_recorder.reset cmd
+        pid, stdin, out, err = Open4.popen4(cmd)
+        ignored, status = Process::waitpid2 pid
+        @log_recorder.log :err, err.read
+        @log_recorder.log :out, out.read
+        @log_recorder.code = status.to_i
+      end
+      
+      def raise_error(e)
+        raise Sprinkle::Errors::RemoteCommandFailure.new(@installer, @log_recorder.hash, e)
+      end
+      
+      def transfer(source, destination, roles, opts ={}) #:nodoc:
+			  opts.reverse_merge!(:recursive => true)
+				flags = "-R " if opts[:recursive]
 				
-				system "cp #{flags}#{source} #{destination}"
+				run_command "cp #{flags}#{source} #{destination}"
 			end
+      
+      
     end
   end
 end