rudy 0.8.5 → 0.9.0

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

@@ -1,34 +0,0 @@
-
-module Rudy; module Routines; 
-  module DependsHelper
-    include Rudy::Routines::HelperBase  # TODO: use trap_rbox_errors
-    extend self 
-    
-    def has_depends?(timing, routine)
-      (!routine.is_a?(Caesars::Hash) || routine[timing].is_a?(Caesars::Hash))
-    end
-    
-    # Returns an Array of the dependent routines for the given +timing+ (before/after)
-    def get(timing, routine)
-      return if !(routine.is_a?(Caesars::Hash) || routine[timing].is_a?(Caesars::Hash))
-      
-      # This will produce an Array containing the routines to run. The 
-      # elements are the valid routine names. 
-      # NOTE: The "timing" elements are removed from the routines hash. 
-      dependencies = []
-      routine[timing].each_pair do |n,v| 
-        next unless v.nil?  # this skips all "script" blocks
-        raise "#{timing}: #{n} is not a known routine" unless valid_routine?(n)
-        routine[timing].delete(n)
-        dependencies << n
-      end
-
-      # We need to return only the keys b/c the values are nil
-      dependencies = nil if dependencies.empty?
-      dependencies
-    end
-    
-
-  end
-  
-end; end

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

@@ -1,403 +0,0 @@
-
-
-module Rudy; module Routines; 
-  module DiskHelper
-    include Rudy::Routines::HelperBase  # TODO: use trap_rbox_errors
-    extend self
-    
-    def disks?(routine)
-      (routine.is_a?(Caesars::Hash) && routine.disks && 
-      routine.disks.is_a?(Caesars::Hash) && !routine.disks.empty?) ? true : false
-    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)
-      raise "Not a Rye::Box" unless rbox.is_a?(Rye::Box)
-      
-      @machine = machine
-      @rbox = rbox
-      
-      # We need to add mkfs since it's not enabled by default. 
-      # We add it only to this instance we're using. 
-      # We give it a funny name so we can delete it. 
-      def @rbox.rudy_mkfs(*args); cmd('mkfs', args); end
-      
-      unless disks?(routine)
-        STDERR.puts "[nothing to do]"
-        return
-      end
-
-      modified = []
-      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, ...
-        modified << disks
-      end
-      
-      # TODO: remove rudy_mkfs method
-      
-    end
-    
-    def snapshot(disks)
-      rdisk = Rudy::Disks.new
-      rback = Rudy::Backups.new
-      
-      disks.each_pair do |path, props|
-        adisk = Rudy::MetaData::Disk.new(path, props[:size], props[:device], @machine.position)
-        disk = rdisk.get(adisk.name)
-        if disk == nil
-          puts "Not found: #{adisk.name}".color(:red)
-          return
-        end
-        back = disk.backup
-        puts "Created backup: #{back.name}"
-      end
-    end
-    
-    def restore(disks)
-      rdisk = Rudy::Disks.new
-      rback = Rudy::Backups.new
-      
-      disks.each_pair do |path, props|
-        disk = Rudy::MetaData::Disk.new(path, props[:size], props[:device], @machine.position)
-        
-        olddisk = rdisk.get(disk.name)
-        back = nil
-        if olddisk && olddisk.exists?
-          olddisk.update
-          puts "Disk found: #{olddisk.name}. Skipping...".color(:red)
-          return
-        else
-          disk.fstype = props[:fstype] || 'ext3'
-          more = [:environment, props[:environment]] if props[:environment]
-          more += [:role, props[:role]] if props[:role]
-          back = (rback.list(more, nil) || []).first
-          raise "No backup found" unless back
-          puts "Found backup #{back.name} "
-        end
-        
-        unless disk.exists? # Checks the EBS volume
-          msg = "Creating volume from snapshot (#{back.awsid})... "
-          disk.create(back.size, @@global.zone, back.awsid)
-          Rudy::Utils.waiter(2, 60, STDOUT, msg) { 
-            disk.available?
-          }
-        end
-        
-        msg = "Attaching #{disk.awsid} to #{@machine.awsid}... "
-        disk.attach(@machine.awsid)
-        Rudy::Utils.waiter(2, 10, STDOUT, msg) { 
-          disk.attached?
-        }
-        
-        sleep 2
-        
-        begin
-          @rbox.mkdir(:p, disk.path)
-          
-          print "Mounting at #{disk.path}... "
-      
-          ret = @rbox.mount(:t, disk.fstype, disk.device, disk.path) 
-          print_response ret
-          if ret.exit_code > 0
-            STDERR.puts "Error creating disk".color(:red)
-            return
-          else
-            puts "done"
-          end
-          disk.mounted = true
-          disk.save
-          
-        rescue Net::SSH::AuthenticationFailed, Net::SSH::HostKeyMismatch => ex  
-          STDERR.puts "Error creating disk".color(:red)
-          STDERR.puts ex.message.color(:red)
-         rescue Rye::CommandNotFound => ex
-          puts "  CommandNotFound: #{ex.message}".color(:red)
-          
-        rescue
-          STDERR.puts "Error creating disk" .color(:red)
-          Rudy::Utils.bug
-        end
-        
-      end
-    end
-    
-    
-    def create(disks)
-      rdisk = Rudy::Disks.new
-      
-      disks.each_pair do |path, props|
-        disk = Rudy::MetaData::Disk.new(path, props[:size], props[:device], @machine.position)
-        olddisk = rdisk.get(disk.name)
-        if olddisk && olddisk.exists?
-          olddisk.update
-          puts "Disk found: #{olddisk.name}"
-          if olddisk.attached?
-            puts "In use. Skipping...".color(:red)
-            return
-          else
-            disk = olddisk
-          end
-        else
-          puts "Creating #{disk.name} "
-          disk.fstype = props[:fstype] || 'ext3'
-        end
-        
-        unless disk.exists? # Checks the EBS volume
-          msg = "Creating volume... "
-          disk.create
-          Rudy::Utils.waiter(2, 60, STDOUT, msg) { 
-            disk.available?
-          }
-        end
-        
-        msg = "Attaching #{disk.awsid} to #{@machine.awsid}... "
-        disk.attach(@machine.awsid)
-        Rudy::Utils.waiter(2, 10, STDOUT, msg) { 
-          disk.attached?
-        }
-        
-        # The device needs some time. 
-        # Otherwise mkfs returns:
-        # "No such file or directory while trying to determine filesystem size"
-        sleep 2 
-        
-        # TODO: Cleanup. See ScriptHelper
-        begin
-          if disk.raw == true
-            print "Creating #{disk.fstype} filesystem for #{disk.device}... "
-            @rbox.rudy_mkfs(:t, disk.fstype, :F, disk.device)
-            disk.raw = false
-            disk.save
-            puts "done"
-          end
-          
-          @rbox.mkdir(:p, disk.path)
-          
-          print "Mounting at #{disk.path}... "
-      
-          ret = @rbox.mount(:t, disk.fstype, disk.device, disk.path) 
-          print_response ret
-          if ret.exit_code > 0
-            STDERR.puts "Error creating disk".color(:red)
-            return
-          else
-            puts "done"
-          end
-          disk.mounted = true
-          disk.save
-          
-        rescue Net::SSH::AuthenticationFailed, Net::SSH::HostKeyMismatch => ex  
-          STDERR.puts "Error creating disk".color(:red)
-          STDERR.puts ex.message.color(:red)
-         rescue Rye::CommandNotFound => ex
-          puts "  CommandNotFound: #{ex.message}".color(:red)
-          
-        rescue
-          STDERR.puts "Error creating disk" .color(:red)
-          Rudy::Utils.bug
-        end
- 
-      end
-    end
-    
-    
-    
-    
-    def attach(disks)
-      rdisk = Rudy::Disks.new
-      
-      disks.each_pair do |path, props|
-        disk = Rudy::MetaData::Disk.new(path, props[:size], props[:device], @machine.position)
-        olddisk = rdisk.get(disk.name)
-        if olddisk && olddisk.exists?
-          disk.update
-          puts "Disk found: #{olddisk.name}"
-          if disk.attached?
-            puts "In use. Skipping...".color(:red)
-            return
-          else
-            disk = olddisk
-          end
-        else
-          puts "Creating #{disk.name} "
-        end
-        p disk
-        p [disk.exists?, disk.available?, olddisk.exists?, olddisk.available?]
-        disk.save
-        
-        unless disk.exists? # Checks the EBS volume
-          msg = "Creating volume... "
-          disk.create
-          Rudy::Utils.waiter(2, 60, STDOUT, msg) { 
-            disk.available?
-          }
-        end
-        
-        unless disk.attached?
-          msg = "Attaching #{disk.awsid} to #{@machine.awsid}... "
-          disk.attach(@machine.awsid)
-          Rudy::Utils.waiter(2, 10, STDOUT, msg) { 
-            disk.attached?
-          }
-        end
-      end
-    end
-    
-    def detach(disks, destroy=false)
-      rdisk = Rudy::Disks.new
-      disks.each_pair do |path, props|
-        adisk = Rudy::MetaData::Disk.new(path, props[:size], props[:device], @machine.position)
-        disk = rdisk.get adisk.name
-        
-        if disk == nil
-          puts "Not found: #{adisk.name}".color(:red)
-          return
-        end
-        
-        if disk.attached?
-          msg = "Detaching #{disk.awsid}..."
-          disk.detach 
-          Rudy::Utils.waiter(2, 60, STDOUT, msg) { 
-            disk.available? 
-          }
-        end
-        
-        if destroy 
-          puts "Destroying volume and metadata... "
-          disk.destroy
-        end
-        
-      end
-    end
-    
-    def mount(disks)
-      rdisk = Rudy::Disks.new
-      disks.each_pair do |path, props|
-        adisk = Rudy::MetaData::Disk.new(path, props[:size], props[:device], @machine.position)
-        disk = rdisk.get(adisk.name)
-        if disk == nil
-          puts "Not found: #{adisk.name}".color(:red)
-          return
-        end
-        
-        unless disk.attached?
-          msg = "Attaching #{disk.awsid} to #{@machine.awsid}... "
-          disk.attach(@machine.awsid)
-          Rudy::Utils.waiter(2, 10, STDOUT, msg) { 
-            disk.attached?
-          }
-        
-          sleep 2
-        end
-        
-        begin
-          @rbox.mkdir(:p, disk.path)
-          
-          print "Mounting at #{disk.path}... "
-      
-          ret = @rbox.mount(:t, disk.fstype, disk.device, disk.path) 
-          print_response ret
-          if ret.exit_code > 0
-            STDERR.puts "Error creating disk".color(:red)
-            return
-          else
-            puts "done"
-          end
-          disk.mounted = true
-          disk.save
-          
-        rescue Net::SSH::AuthenticationFailed, Net::SSH::HostKeyMismatch => ex  
-          STDERR.puts "Error creating disk".color(:red)
-          STDERR.puts ex.message.color(:red)
-         rescue Rye::CommandNotFound => ex
-          puts "  CommandNotFound: #{ex.message}".color(:red)
-          
-        rescue
-          STDERR.puts "Error creating disk" .color(:red)
-          Rudy::Utils.bug
-        end
-        
-      end
-    end
-    
-    
-    def umount(disks)
-      rdisk = Rudy::Disks.new
-      disks.each_pair do |path, props|
-        adisk = Rudy::MetaData::Disk.new(path, props[:size], props[:device], @machine.position)
-        disk = rdisk.get(adisk.name)
-        if disk == nil
-          puts "Not found: #{adisk.name}".color(:red)
-          return
-        end
-        
-        if disk.mounted?
-          print "Unmounting #{disk.path}..."
-          trap_rbox_errors { @rbox.umount(disk.path) }
-          puts " done"
-          sleep 0.5
-        end
-        
-        sleep 2
-        
-        if disk.attached?
-          msg = "Detaching #{disk.awsid}..."
-          disk.detach 
-          Rudy::Utils.waiter(2, 60, STDOUT, msg) { 
-            disk.available? 
-          }
-          sleep 0.5
-        end
-        
-        
-      end
-    end
-    alias_method :unmount, :umount
-    
-    def destroy(disks)
-      rdisk = Rudy::Disks.new
-      
-      disks.each_pair do |path, props|
-        adisk = Rudy::MetaData::Disk.new(path, props[:size], props[:device], @machine.position)
-        disk = rdisk.get(adisk.name)
-        if disk == nil
-          puts "Not found: #{adisk.name}".color(:red)
-          return
-        end
-        
-        puts "Destroying #{disk.name}"
-
-        if disk.mounted?
-          print "Unmounting #{disk.path}..."
-          trap_rbox_errors { @rbox.umount(disk.path) }
-          puts " done"
-          sleep 0.5
-        end
-        
-        if disk.attached?
-          msg = "Detaching #{disk.awsid}..."
-          disk.detach 
-          Rudy::Utils.waiter(2, 60, STDOUT, msg) { 
-            disk.available? 
-          }
-          sleep 0.5
-        end
-        
-        puts "Destroying volume and metadata... "
-        disk.destroy
-        
-      end
-    end
-    
-  end
-end;end

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

@@ -1,197 +0,0 @@
-require 'tempfile'
-
-module Rudy; module Routines; 
-  #--
-  # TODO: Rename to ShellHelper
-  #++
-  module ScriptHelper
-    include Rudy::Routines::HelperBase  # TODO: use trap_rbox_errors
-    extend self
-
-    @@script_types = [:after, :before, :after_local, :before_local, :script, :script_local]
-    
-    
-    # TODO: refactor using this_method
-    
-    def before_local(routine, sconf, rbox, option=nil, argv=nil)
-      execute_command(:before_local, routine, sconf, 'localhost', rbox, option, argv)
-    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, option=nil, argv=nil)
-      execute_command(:script_local, routine, sconf, 'localhost', rbox, option, argv)
-    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, option=nil, argv=nil)
-      execute_command(:after_local, routine, sconf, 'localhost', rbox, option, argv)
-    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, option=nil, argv=nil)
-      raise "ScriptHelper: Not a Rudy::Machine" unless machine.is_a?(Rudy::Machine)
-      execute_command(:before, routine, sconf, machine.name, rbox, option, argv)
-    end
-    def before?(routine); execute_command?(:before, routine); end
-    
-    def after(routine, sconf, machine, rbox, option=nil, argv=nil)
-      raise "ScriptHelper: Not a Rudy::Machine" unless machine.is_a?(Rudy::Machine)
-      execute_command(:after, routine, sconf, machine.name, rbox, option, argv)
-    end
-    def after?(routine); execute_command?(:after, routine); end
-    
-    def script(routine, sconf, machine, rbox, option=nil, argv=nil)
-      raise "ScriptHelper: Not a Rudy::Machine" unless machine.is_a?(Rudy::Machine)
-      execute_command(:script, routine, sconf, machine.name, rbox, option, argv)
-    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)
-        choice = Annoy.get_user_input('(S)kip (A)bort: ') || ''
-         if choice.match(/\AS/i)
-           return
-         else
-           exit 12
-         end
-        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, option=nil, argv=nil)
-      raise "ScriptHelper: Not a Rye::Box" unless rbox.is_a?(Rye::Box)
-      raise "ScriptHelper: #{timing}?" unless @@script_types.member?(timing)
-      
-      # 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
-          
-          begin
-            # We define hooks so we can still print each command and its output
-            # when running the command blocks. NOTE: We only print this in
-            # verbosity mode. We intentionally set and unset the hooks 
-            # so the other commands (config file copy) don't get printed.
-            if @@global.verbose > 0
-              # This block gets called for every command method call.
-              rbox.pre_command_hook do |cmd, args, user, host|
-                puts command_separator(rbox.preview_command(cmd, args), user, host)
-              end
-            end
-            if @@global.verbose > 1
-              # 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
-            end
-            
-            ### EXECUTE THE COMMANDS BLOCK
-            rbox.batch(option, argv, &proc)
-            
-          rescue Rye::CommandError => ex
-            print_response(ex)
-            choice = Annoy.get_user_input('(S)kip  (R)etry  (A)bort: ') || ''
-             if choice.match(/\AS/i)
-               return
-             elsif choice.match(/\AR/i)
-               retry
-             else
-               exit 12
-             end
-          rescue Rye::CommandNotFound => ex
-            STDERR.puts "  CommandNotFound: #{ex.message}".color(:red)
-            STDERR.puts ex.backtrace if Rudy.debug?
-            choice = Annoy.get_user_input('(S)kip  (R)etry  (A)bort: ') || ''
-             if choice.match(/\AS/i)
-               return
-             elsif choice.match(/\AR/i)
-               retry
-             else
-               exit 12
-             end
-          ensure
-            rbox.pre_command_hook = nil
-            rbox.post_command_hook = nil
-            rbox.enable_safe_mode  # In case it was disabled
-          end
-          
-          rbox.cd # reset to home dir
-        end
-        
-        # Return the borrowed rbox instance to the user it was provided with
-        rbox.switch_user original_user
-      
-      ##else
-      ##  puts "Nothing to do"
-      ##end
-      
-      
-    end
-  end
-  
-end;end