sabat-rudy 0.8.0

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

@@ -0,0 +1,198 @@
+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, :script_local]
+    @@script_config_file = "rudy-config.yml"
+    
+    # TODO: refactor using this_method
+    
+    def before_local(routine, sconf, rbox)
+      execute_command(:before_local, routine, sconf, 'localhost', rbox)
+    end
+    def before_local?(routine)
+      # 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] = { 
+        Rudy.sysinfo.user.to_sym => routine.delete(:before_local) 
+      } if routine[:before_local].is_a?(Proc)
+      execute_command?(:before_local, routine)
+    end
+    def script_local(routine, sconf, rbox)
+      execute_command(:script_local, routine, sconf, 'localhost', rbox)
+    end
+    def script_local?(routine)
+      # 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[:script_local] = { 
+        Rudy.sysinfo.user.to_sym => routine.delete(:script_local) 
+      } if routine[:script_local].is_a?(Proc)
+      execute_command?(:script_local, routine)
+    end
+    
+    def after_local(routine, sconf, rbox)
+      execute_command(:after_local, routine, sconf, 'localhost', rbox)
+    end
+    def after_local?(routine)
+      routine[:after_local] = {                 # See before_local note
+        Rudy.sysinfo.user.to_sym => routine.delete(:after_local) 
+      } if routine[:after_local].is_a?(Proc)
+      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
+    
+    def script(routine, sconf, machine, rbox)
+      raise "ScriptHelper: Not a Rudy::Machine" unless machine.is_a?(Rudy::Machine)
+      execute_command(:script, routine, sconf, machine.name, rbox)
+    end
+    def script?(routine); execute_command?(:script, routine); end
+
+  
+  private  
+    
+    # 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
+      unless routine[timing].kind_of?(Hash)
+        STDERR.puts "No user supplied for #{timing} block".color(:red)
+        exit 12 unless keep_going?
+        return false
+      end
+      routine[timing].each_pair do |user,proc|
+        #p [timing, user, proc].join(', ')
+        if proc.nil? || !proc.is_a?(Proc)
+          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
+    # * +rbox+ a Rye::Box instance for the machine we're working on
+    def execute_command(timing, routine, sconf, hostname, rbox)
+      raise "ScriptHelper: Not a Rye::Box" unless rbox.is_a?(Rye::Box)
+      raise "ScriptHelper: #{timing}?" unless @@script_types.member?(timing)
+      
+      if sconf && !sconf.empty?
+        tf = Tempfile.new(@@script_config_file)
+        Rudy::Utils.write_to_file(tf.path, sconf.to_hash.to_yaml, 'w')
+      end
+      
+      # Do we need to run this again? It's called in generic_routine_runner
+      ##if execute_command?(timing, routine) # i.e. before_local?
+
+        # We need to explicitly add the rm command for rbox so we
+        # can delete the script config file when we're done. This
+        # adds the method to this instance of rbox only.
+        # We give it a funny so we can delete it knowing we're not
+        # deleting a method added somewhere else. 
+        def rbox.rudy_tmp_rm(*args); cmd('rm', args); end
+        
+        original_user = rbox.user
+        user_blocks = routine[timing] || {}
+        users = user_blocks.keys
+        # Root stuff is always run first. 
+        users.unshift(users.delete(:root)) if users.member?(:root)
+        users.each do |user|
+          proc = user_blocks[user]
+          
+          begin
+            rbox.switch_user user # does nothing if it's the same user
+            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
+          
+          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)
+          }
+          
+          begin
+            # We define hooks so we can call the script block as a batch. 
+            # We intentionally set and unset the hooks so the other commands
+            # (config file copy) don't get printed.
+            #
+            # This block gets called for every command method call.
+            rbox.pre_command_hook do |cmd, args, user|
+              puts command_separator(rbox.preview_command(cmd, args), user)
+            end
+            # And this one gets called after each command method call.
+            rbox.post_command_hook do |ret|
+              puts '  ' << ret.stdout.join("#{$/}  ") if !ret.stdout.empty?
+              print_response(ret)
+            end
+            
+            ### EXECUTE THE COMMANDS BLOCK
+            rbox.batch(&proc)
+            
+            rbox.pre_command_hook = nil
+            rbox.post_command_hook = nil
+          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
+          
+          # 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!
+          ## NOTE: I believe this was an issue with Rye. I fixed it when I was
+          ## noticing the same error in another place. It hasn't repeated. 
+          ## sleep 0.1
+          
+          rbox.cd # reset to home dir
+          rbox.rudy_tmp_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"
+      ##end
+      
+      tf.delete # delete local copy of script config
+      
+    end
+  end
+  
+end;end

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.to_s.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), rbox.user)
+      
+      # 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.to_s.empty?)
+    end
+    def authorize(routine, machine, rbox)
+      puts command_separator(:authorize_keys_remote, rbox.user)
+      execute_rbox_command { rbox.authorize_keys_remote(routine.authorize) }
+    end
+    
+    
+  end
+  
+end; end  

data/lib/rudy/routines/passthrough.rb

@@ -0,0 +1,38 @@
+
+
+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,rbox|
+        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?
+      if !@@global.offline && !rmach.running?
+        raise MachineGroupNotRunning, current_machine_group
+      end
+    end
+    
+  end
+
+end; end

data/lib/rudy/routines/reboot.rb

@@ -0,0 +1,75 @@
+
+
+module Rudy; module Routines;
+  class Reboot < Rudy::Routines::Base
+    
+    def init(*args)
+      @routine = fetch_routine_config(:reboot)
+    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(:reboot)
+      unless @routine
+        STDERR.puts "[this is a generic reboot routine]"
+        @routine = {}
+      end
+      machines = []
+      generic_machine_runner(:list) do |machine,rbox|
+        puts $/, "Rebooting...", $/
+        rbox.disconnect
+        machine.restart
+        sleep 4
+        msg = preliminary_separator("Checking if instance is running...")
+        Rudy::Utils.waiter(3, 120, STDOUT, msg, 0) {
+          machine.running?
+        } 
+      
+        # Add instance info to machine and save it. This is really important
+        # for the initial startup so the metadata is updated right away. But
+        # it's also important to call here because if a routine was executed
+        # and an unexpected exception occurs before this update is executed
+        # the machine metadata won't contain the DNS information. Calling it
+        # here ensure that the metadata is always up-to-date. 
+        machine.update 
+        
+        sleep 4
+        
+        msg = preliminary_separator("Waiting for SSH daemon...")
+        Rudy::Utils.waiter(3, 120, STDOUT, msg, 0) {
+          Rudy::Utils.service_available?(machine.dns_public, 22)
+        }
+        
+        # NOTE: THIS IS INCOMPLETE
+        
+        sleep 1  # Avoid IOError: closed stream on SSH
+        
+      
+        if Rudy::Routines::DiskHelper.disks?(@routine)         # disk
+          puts task_separator("DISKS")
+          if rbox.ostype == "sunos"
+            puts "Sorry, Solaris is not supported yet!"
+          else
+            Rudy::Routines::DiskHelper.execute(@routine, machine, rbox)
+          end    
+        end
+
+        machines << machine
+      end
+      machines
+    end
+
+    # Called by generic_machine_runner
+    def raise_early_exceptions
+      rmach = Rudy::Machines.new
+      # There's no keypair check here because Rudy::Machines will attempt 
+      # to create one.
+      raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
+      raise MachineGroupNotRunning, current_machine_group unless rmach.running?
+    end
+    
+  end
+
+end; end

data/lib/rudy/routines/release.rb

@@ -0,0 +1,50 @@
+
+
+module Rudy; module Routines;
+  class Release < Rudy::Routines::Base
+    
+    def init(*args)
+      @routine_name = args.first || :release # :release or :rerelease
+      @routine = fetch_routine_config(@routine_name)
+    end
+    
+    def execute()
+      routine_separator(@routine_name)
+
+      vlist = []
+      
+      # Some early version control system failing
+      if Rudy::Routines::SCMHelper.scm?(@routine)
+        vlist = Rudy::Routines::SCMHelper.create_scm_objects(@routine)
+        puts task_separator("CREATING RELEASE TAG#{'S' if vlist.size > 1}")
+        vlist.each do |scm|
+          scm.create_release(Rudy.sysinfo.user)
+          puts scm.liner_note
+        end
+      end
+      
+      machines = []
+      generic_machine_runner(:list) do |machine,rbox|
+        vlist.each do |scm|
+          puts task_separator("CREATING REMOTE #{scm.engine.to_s.upcase} CHECKOUT")
+          scm.create_remote_checkout(rbox)
+        end
+        machines << machine
+      end
+      
+      machines
+    end
+    
+    # Called by generic_machine_runner
+    def raise_early_exceptions
+      raise NoRoutine, :release 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

data/lib/rudy/routines/shutdown.rb

@@ -0,0 +1,33 @@
+
+
+module Rudy; module Routines;
+  class Shutdown < Rudy::Routines::Base
+    
+    def init(*args)
+      @routine = fetch_routine_config(:shutdown)
+    end
+    
+    def execute
+      routine_separator(:shutdown)
+      unless @routine
+        STDERR.puts "[this is a generic shutdown routine]"
+        @routine = {}
+      end
+      machines = []
+      generic_machine_runner(:destroy) do |machine,rbox|
+        puts $/, "Shutting down...", $/
+        machines << machine
+      end
+      machines
+    end
+
+    # Called by generic_machine_runner
+    def raise_early_exceptions
+      rmach = Rudy::Machines.new
+      raise Rudy::PrivateKeyNotFound, root_keypairpath unless has_keypair?(:root)
+      raise MachineGroupNotRunning, current_machine_group unless rmach.running?
+    end
+    
+  end
+
+end; end

data/lib/rudy/routines/startup.rb

@@ -0,0 +1,36 @@
+
+
+module Rudy; module Routines;
+  class Startup < Rudy::Routines::Base
+    
+    def init(*args)
+      @routine = fetch_routine_config(:startup)
+    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.
+    # Returns an Array of Rudy::Machine objects
+    def execute(&each_mach)
+      routine_separator(:startup)
+      unless @routine
+        STDERR.puts "[this is a generic startup routine]"
+        @routine = {}
+      end
+      machines = generic_machine_runner(:create) 
+      machines
+    end
+
+    # Called by generic_machine_runner
+    def raise_early_exceptions
+      rmach = Rudy::Machines.new
+      # There's no keypair check here because Rudy::Machines will create one 
+      raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
+      # We don't check @@global.offline b/c we can't create EC2 instances
+      # without an internet connection. Use passthrough for routine tests.
+      raise MachineGroupAlreadyRunning, current_machine_group if rmach.running?
+    end
+    
+  end
+
+end; end