rudy 0.6.8 → 0.7.0

data/lib/rudy/routines/helper.rb

@@ -0,0 +1,50 @@
+
+
+module Rudy
+  module Routines
+    module HelperBase
+     include Rudy::Huxtable
+     
+     def execute_rbox_command(ret=nil, &command)
+       begin
+         ret = command.call
+         puts '  ' << ret.stdout.join("#{$/}  ") if !ret.stdout.empty?
+         print_response(ret)
+       rescue Rye::CommandError => ex
+         print_response(ex)
+         exit 12 unless keep_going?
+       rescue Rye::CommandNotFound => ex
+         STDERR.puts "  CommandNotFound: #{ex.message}".color(:red)
+         STDERR.puts ex.backtrace if Rudy.debug?
+         exit 12 unless keep_going?
+       end
+       
+       ret
+     end
+     
+     def keep_going?
+       Annoy.pose_question("  Keep going?\a ", /yes|y|ya|sure|you bet!/i, STDERR)
+     end
+     
+     # Returns a formatted string for printing command info
+     def command_separator(cmd, user)
+       cmd ||= ""
+       cmd, user = cmd.to_s, user.to_s
+       prompt = user == "root" ? "#" : "$"
+       ("%s%s%s %s" % [$/, user, prompt, cmd.bright])
+     end
+     
+  private 
+    def print_response(rap)
+      colour = rap.exit_code != 0 ? :red : :normal
+      [:stderr].each do |sumpin|
+        next if rap.send(sumpin).empty?
+        STDERR.puts ("  #{sumpin.upcase.to_s}  " << '-'*38).color(colour).bright
+        STDERR.puts "  " << rap.send(sumpin).join("#{$/}  ").color(colour)
+      end
+      STDERR.puts "  Exit code: #{rap.exit_code}".color(colour) if rap.exit_code != 0
+    end
+    
+    end
+  end
+end

data/lib/rudy/routines/helpers/diskhelper.rb

@@ -2,8 +2,19 @@
 
 module Rudy; module Routines; 
   module DiskHelper
+    include Rudy::Routines::HelperBase  # TODO: use execute_rbox_command
     extend self
     
+    def disks?(routine)
+      (routine.is_a?(Caesars::Hash) && routine.disks && 
+      routine.disks.is_a?(Caesars::Hash) && !routine.disks.empty?)
+    end
+    
+    def paths(routine)
+      return nil unless disks?(routine)
+      routine.disks.values.collect { |d| d.keys }.flatten
+    end
+    
     def execute(routine, machine, rbox)
       return unless routine
       raise "Not a Rudy::Machine" unless machine.is_a?(Rudy::Machine)
@@ -12,13 +23,20 @@ module Rudy; module Routines;
       @machine = machine
       @rbox = rbox
       
-      (routine.disks || {}).each_pair do |action, disks|
+      # We need to add mkfs since it's not enabled by default. 
+      # We add it only to this instance we're using. 
+      def @rbox.mkfs(*args); cmd('mkfs', args); end
+      
+      return unless disks?(routine)
+      
+      routine.disks.each_pair do |action, disks|
         unless DiskHelper.respond_to?(action)  
           STDERR.puts %Q(DiskHelper: unknown action "#{action}")
           next
         end
         send(action, disks) # create, copy, destroy, ...
       end
+      
     end
     
     def create(disks)
@@ -26,18 +44,23 @@ module Rudy; module Routines;
       
       disks.each_pair do |path, props|
         disk = Rudy::Disk.new(path, props[:size], props[:device], @machine.position)
-        #disk = rdisk.get(disk.name)
+        olddisk = rdisk.get(disk.name)
+        if olddisk && olddisk.exists?
+          puts "Disk exists: #{olddisk.name}".color(:red)
+          return
+        end
+        
         puts "Creating #{disk.name} "
         
-        print "Creating volume... "
+        msg = "Creating volume... "
         disk.create
-        Rudy::Utils.waiter(2, 60, STDOUT, "done", nil) { 
+        Rudy::Utils.waiter(2, 60, STDOUT, msg) { 
           disk.available?
         }
         
-        print "Attaching #{disk.awsid} to #{@machine.awsid}... "
+        msg = "Attaching #{disk.awsid} to #{@machine.awsid}... "
         disk.attach(@machine.awsid)
-        Rudy::Utils.waiter(2, 60, STDOUT, "done", nil) { 
+        Rudy::Utils.waiter(2, 10, STDOUT, msg) { 
           disk.attached?
         }
         
@@ -46,15 +69,19 @@ module Rudy; module Routines;
         # "No such file or directory while trying to determine filesystem size"
         sleep 2 
         
+        # TODO: Cleanup. See ScriptHelper
         begin
           print "Creating ext3 filesystem for #{disk.device}... "
-          @rbox.mkfs(:t, "ext3", :F, disk.device)
-          @rbox.mkdir(:p, disk.path)
-          puts "done"
+          execute_rbox_command { 
+            
+            @rbox.mkfs(:t, "ext3", :F, disk.device)
+            @rbox.mkdir(:p, disk.path)
+            puts "done"
         
-          print "Mounting at #{disk.path}... "
+            print "Mounting at #{disk.path}... "
         
-          @rbox.mount(:t, 'ext3', disk.device, disk.path)
+            @rbox.mount(:t, 'ext3', disk.device, disk.path)
+          }
           disk.mounted = true
           disk.save
         rescue Net::SSH::AuthenticationFailed, Net::SSH::HostKeyMismatch => ex  
@@ -85,24 +112,23 @@ module Rudy; module Routines;
         puts "Destroying #{disk.name}"
 
         if disk.mounted?
-          print "Unmounting #{disk.path}... "
-          @rbox.umount(disk.path)
+          print "Unmounting #{disk.path}..."
+          execute_rbox_command { @rbox.umount(disk.path) }
+          puts " done"
           sleep 0.5
-          puts "done"
         end
         
         if disk.attached?
-          print "Detaching #{disk.awsid}... "
+          msg = "Detaching #{disk.awsid}..."
           disk.detach 
-          Rudy::Utils.waiter(2, 60, STDOUT, 'done', nil) { 
+          Rudy::Utils.waiter(2, 60, STDOUT, msg) { 
             disk.available? 
           }
           sleep 0.5
         end
         
-        print "Destroying metadata... "
+        puts "Destroying metadata... "
         disk.destroy
-        puts "done"
         
       end
     end

data/lib/rudy/routines/helpers/scmhelper.rb

@@ -0,0 +1,39 @@
+
+module Rudy; module Routines; 
+  module SCMHelper
+    include Rudy::Routines::HelperBase
+    extend self
+    
+    # Does the routine config contain SCM routines?
+    # Raises Rudy::Error if there is malformed configuration. 
+    def scm?(routine)
+      scmnames = SUPPORTED_SCM_NAMES & routine.keys    # Find intersections.
+      return false if scmnames.empty?                  # Nothing to do. 
+      scmnames.each do |scm|                          
+        routine[scm].values.each do |p|                # Each SCM should have a
+        raise "Bad #{scm} config" if !p.kind_of?(Hash) # Hash config. Otherwise
+        end                                            # it's misconfigured.
+      end
+      true
+    end
+    
+    def create_scm_objects(routine)
+      return nil unless routine
+      scmnames = SUPPORTED_SCM_NAMES & routine.keys
+      vlist = []
+      # Look for scm config in the routine by checking all known scm types.
+      # For each one we'll create an instance of the appropriate SCM class.
+      scmnames.each do |scm|
+        routine[scm].each_pair do |user,params|
+          klass = eval "Rudy::SCM::#{scm.to_s.upcase}"
+          params[:user] = user
+          scm = klass.new(params)
+          scm.raise_early_exceptions    # Raises exceptions for obvious problems.
+          vlist << scm
+        end
+      end
+      vlist
+    end
+    
+  end
+end; end

data/lib/rudy/routines/helpers/scripthelper.rb

@@ -1,34 +1,69 @@
 require 'tempfile'
 
-
 module Rudy; module Routines; 
-  
+  #--
+  # TODO: Rename to ShellHelper
+  #++
   module ScriptHelper
+    include Rudy::Routines::HelperBase  # TODO: use execute_rbox_command
     extend self
-    
+
     @@script_types = [:after, :before, :after_local, :before_local]
     @@script_config_file = "rudy-config.yml"
     
     def before_local(routine, sconf, rbox)
+      
+      # before_local generally doesn't take a user name like the remote
+      # before block so we add it here (unless the user did specify it)
+      routine[:before_local] = { 
+        rbox.user.to_sym => routine.delete(:before_local) 
+      } unless routine.has_key?(rbox.user.to_sym) # use routine[timing].deepest_point ?
       execute_command(:before_local, routine, sconf, 'localhost', rbox)
-    end    
+    end
+    def before_local?(routine); execute_command?(:before_local, routine); end
+      
     def after_local(routine, sconf, rbox)
+      routine[:after_local] = {                 # See before_local note
+        rbox.user.to_sym => routine.delete(:after_local) 
+      } unless routine.has_key?(rbox.user.to_sym)
       execute_command(:after_local, routine, sconf, 'localhost', rbox)
     end
-  
+    def after_local?(routine); execute_command?(:after_local, routine); end
+      
+    
     def before(routine, sconf, machine, rbox)
       raise "ScriptHelper: Not a Rudy::Machine" unless machine.is_a?(Rudy::Machine)
       execute_command(:before, routine, sconf, machine.name, rbox)
     end
+    def before?(routine); execute_command?(:before, routine); end
+    
     def after(routine, sconf, machine, rbox)
       raise "ScriptHelper: Not a Rudy::Machine" unless machine.is_a?(Rudy::Machine)
       execute_command(:after, routine, sconf, machine.name, rbox)
     end
+    def after?(routine); execute_command?(:after, routine); end
     
   
   private  
     
-    # * +timing+ is one of: after, before
+    # Does the routine have the requested script type?
+    # * +timing+ is one of: after, before, after_local, before_local
+    # * +routine+ a single routine hash (startup, shutdown, etc...)
+    # Prints notice to STDERR if there's an empty conf hash
+    def execute_command?(timing, routine)
+      hasconf = (routine.is_a?(Caesars::Hash) && routine.has_key?(timing))
+      return false unless hasconf
+      routine[timing].each_pair do |user,conf|
+        if conf.empty? 
+          STDERR.puts "Empty #{timing} config for #{user}"
+        else
+          return true
+        end
+      end
+      false
+    end
+    
+    # * +timing+ is one of: after, before, after_local, before_local
     # * +routine+ a single routine hash (startup, shutdown, etc...)
     # * +sconf+ is a config hash from machines config (ignored if nil)
     # * +hostname+ machine hostname that we're working on
@@ -47,48 +82,64 @@ module Rudy; module Routines;
       # add the method on for the instance of rbox we are using. 
       def rbox.rm(*args); cmd('rm', args); end
       
-      
-      if routine.is_a?(Caesars::Hash) && routine.has_key?(timing)
-        puts "Connecting to #{hostname}"
-        begin
-          rbox.connect
-        rescue Net::SSH::AuthenticationFailed, Net::SSH::HostKeyMismatch => ex  
-          STDERR.puts "Error connecting: #{ex.message}".color(:red)
-          STDERR.puts "Skipping scripts".color(:red)
-        end
+      if execute_command?(timing, routine) # i.e. before_local?
         
         original_user = rbox.user
-        scripts = [routine[timing]].flatten
-        scripts.each do |script|
+        users = routine[timing] || {}
+        users.each_pair do |user, commands|
           
           begin
-            user, command, *args = script.to_a.flatten.compact
             rbox.switch_user user # does nothing if it's the same user
-            puts "Creating #{@@script_config_file}"
-            rbox.safe = false
-            puts rbox.echo("'#{sconf.to_hash.to_yaml}' > #{@@script_config_file}")
-            rbox.safe = true
-            rbox.chmod(600, @@script_config_file)
-            puts %Q{Running (as #{user}): #{rbox.preview_command(command, args)}}
+            rbox.connect(false)   # does nothing if already connected
+          rescue Net::SSH::AuthenticationFailed, Net::SSH::HostKeyMismatch => ex  
+            STDERR.puts "Error connecting: #{ex.message}".color(:red)
+            STDERR.puts "Skipping user #{user}".color(:red)
+            next
+          end
           
-            ret = rbox.send(command, args)
-            if ret.exit_code > 0
-              puts "  Exit code: #{ret.exit_code}".color(:red)
-              puts "  STDERR: #{ret.stderr.join("#{$/}  ")}".color(:red)
-              puts "  STDOUT: #{ret.stdout.join("#{$/}  ")}".color(:red)
-            else
-              puts '  ' << ret.stdout.join("#{$/}  ")
+          execute_rbox_command {
+            # We need to create the config file for every script, 
+            # b/c the user may change and it would not be accessible.
+            # We turn off safe mode so we can write the config file via SSH. 
+            # This will need to use SCP eventually; it is unsafe and error prone.
+            # TODO: Replace with rbox.upload. Make it safe again!
+            conf_str = StringIO.new
+            conf_str.puts sconf.to_hash.to_yaml
+            rbox.upload(conf_str, @@script_config_file)
+            rbox.chmod(600, @@script_config_file)
+          }
+        
+          commands.each_pair do |command, calls|
+            # If a command is only referred to once and it has no arguments
+            # defined, we force it through by making an array with one element.
+            calls = [[]] if calls.empty?
+            
+            # Force a CommandNotFound exception early
+            unless rbox.can?(command)
+              execute_rbox_command { rbox.send(command) }
+              next
+            end
+            
+            # Execute the command for every set of arguments
+            calls.each do |args|
+              puts command_separator(rbox.preview_command(command, args), user)
+              execute_rbox_command { ret = rbox.send(command, args) }
             end
-          rescue Rye::CommandNotFound => ex
-            puts "  CommandNotFound: #{ex.message}".color(:red)
           end
           
+          # I was gettings errors about script_config_file not existing. There
+          # might be a race condition when the rm command is called too quickly. 
+          # It's also quite possible I'm off my rocker!
+          sleep 0.1
           
-          rbox.rm(@@script_config_file)
+          rbox.cd # reset to home dir
+          #rbox.rm(@@script_config_file)
         end
+        
+        # Return the borrowed rbox instance to the user it was provided with
         rbox.switch_user original_user
       else
-        #puts "Nothing to do"
+        puts "Nothing to do"
       end
       
       tf.delete # delete local copy of script config

data/lib/rudy/routines/helpers/userhelper.rb

@@ -0,0 +1,37 @@
+
+module Rudy; module Routines; 
+  module UserHelper
+    include Rudy::Routines::HelperBase  # TODO: use execute_rbox_command
+    extend self 
+    
+    def adduser?(routine)
+      (!routine.adduser.nil? && !routine.adduser.empty?)
+    end
+    def adduser(routine, machine, rbox)
+      
+      # On Solaris, the user's home directory needs to be specified
+      # explicitly so we do it for linux too for fun. 
+      homedir = rbox.guess_user_home(routine.adduser.to_s)
+      args = [:m, :d, homedir, :s, '/bin/bash', routine.adduser.to_s]
+      puts command_separator(rbox.preview_command(:useradd, args), routine.adduser.to_s)
+      
+      # NOTE: We'll may to use platform specific code here. 
+      # Linux has adduser and useradd commands:
+      # adduser can prompt for info which we don't want. 
+      # useradd does not prompt (on Debian/Ubuntu at least). 
+      # We need to specify bash b/c the default is /bin/sh
+      execute_rbox_command { rbox.useradd(args) }
+    end
+    
+    def authorize?(routine)
+      (!routine.authorize.nil? && !routine.authorize.empty?)
+    end
+    def authorize(routine, machine, rbox)
+      puts command_separator(:authorize_keys_remote, routine.authorize)
+      execute_rbox_command { rbox.authorize_keys_remote(routine.authorize) }
+    end
+    
+    
+  end
+  
+end; end  

data/lib/rudy/routines/passthrough.rb

@@ -0,0 +1,36 @@
+
+
+module Rudy; module Routines;
+  class Passthrough < Rudy::Routines::Base
+    
+    def init(*args)
+      @routine_name = args.first
+      @routine = fetch_routine_config(@routine_name)
+    end
+    
+    # * +each_mach+ is an optional block which is executed between 
+    # disk creation and the after scripts. The will receives two 
+    # arguments: instances of Rudy::Machine and Rye::Box.
+    def execute(&each_mach)
+      routine_separator(@routine_name)
+      machines = []
+      generic_machine_runner(:list) do |machine|
+        puts $/ #, "[routine: #{@routine_name}]"
+        machines << machine
+      end
+      machines
+    end
+
+    # Called by generic_machine_runner
+    def raise_early_exceptions
+      raise Rudy::Error, "No routine name" unless @routine_name
+      raise NoRoutine, @routine_name unless @routine
+      rmach = Rudy::Machines.new
+      raise Rudy::PrivateKeyNotFound, root_keypairpath unless has_keypair?(:root)
+      raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
+      raise MachineGroupNotRunning, current_machine_group unless rmach.running?
+    end
+    
+  end
+
+end; end