solutious-rudy 0.8.5 → 0.9.0

data/lib/rudy/routines/base.rb

@@ -0,0 +1,226 @@
+
+module Rudy; module Routines;
+  class Base
+    include Rudy::Huxtable
+    
+    @@run = true
+    
+    def self.run?; @@run; end
+    def self.disable_run; @@run = false; end
+    def self.enable_run; @@run = true; end
+    
+    def run?; @@run; end
+    def disable_run; @@run = false; end
+    def enable_run; @@run = true; end
+    
+      # An Array Rudy::Machines objects that will be processed
+    attr_reader :machines
+    
+    # * +name+ The name of the command specified on the command line
+    # * +option+ A Hash or OpenStruct of named command line options. 
+    #   If it's a Hash it will be converted to an OpenStruct.
+    # * +argv+ An Array of arguments
+    #
+    # +option+ and +argv+ are made available to the routine block. 
+    # 
+    #     routines do
+    #       magic do |options,argv|
+    #         ...
+    #       end
+    #     end
+    #
+    def initialize(name=nil, option={}, argv=[], *args)
+      name ||= (self.class.to_s.split(/::/)).last.downcase
+      option = OpenStruct.new(option) if option.is_a? Hash
+      @name, @option, @argv = name.to_sym, option, argv
+      a, s, r = @@global.accesskey, @@global.secretkey, @@global.region
+      @@sdb ||= Rudy::AWS::SDB.new(a, s, r)
+      
+      # Grab the routines configuration for this routine name
+      # e.g. startup, sysupdate, installdeps
+      @routine = fetch_routine_config @name 
+      
+      ld "Routine: #{@routine.inspect}"
+      
+      if @routine
+        # Removes the dependencies from the routines hash. 
+        # We run these separately from the other actions.
+        @before, @after = @routine.delete(:before), @routine.delete(:after)
+      end
+      
+      # Share one Rye::Box instance for localhost across all routines
+      @@lbox = create_rye_box @@global.localhost unless defined?(@@lbox)
+      
+      disable_run if @@global.testrun
+      
+      # We create these frozen globals for the benefit of 
+      # the local and remote routine blocks. 
+      $global = @@global.dup.freeze unless $global
+      $option = option.dup.freeze unless $option
+      
+      ## TODO: get the machine config for just the current machine group. This
+      ## probably requires Caesars to be aware of which nodes are structural.  
+      ##$config = fetch_machine_config unless $config
+      
+      init(*args) if respond_to? :init
+    end
+    
+    def raise_early_exceptions; raise "Please override"; end
+    def execute; raise "Please override"; end
+    
+    # Create an instance of Rye::Box for +hostname+. +opts+ is
+    # an optional Hash of options. See Rye::Box.initialize
+    #
+    # This method should be used throughout the Rudy::Routines 
+    # namespace rather than creating instances manually b/c it 
+    # applies some fancy pants defaults like command hooks.
+    def create_rye_box(hostname, opts={})
+      ld [:hostname, hostname, opts, caller[0]]
+      opts = {
+        :info => (@@global.verbose >= 3),  # rudy -vvv 
+        :debug => false,
+        :user => Rudy.sysinfo.user
+      }.merge opts
+      
+      box = Rye::Box.new hostname, opts
+      
+    
+      # 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. 
+      if @@global.verbose > 0
+        # This block gets called for every command method call.
+        box.pre_command_hook do |cmd, user, host, nickname|
+          print_command user, nickname, cmd
+        end
+      end
+    
+      if @@global.verbose > 1
+        # And this one gets called after each command method call.
+        box.post_command_hook do |ret|
+          print_response ret
+        end
+      end
+      
+      box.exception_hook(Rye::CommandError, &rbox_exception_handler)
+      box.exception_hook(Exception, &rbox_exception_handler)
+      
+      ## It'd better for unknown commands to be handled elsewhere
+      ## because it doesn't make sense to retry a method that doesn't exist
+      ##box.exception_hook(Rye::CommandNotFound, &rbox_exception_handler)
+    
+      box
+    end
+    
+
+    
+    # Create an instance of Rye::Set from a list of +hostnames+.
+    # +hostnames+ can contain hostnames or Rudy::Machine objects.
+    # +opts+ is an optional Hash of options. See Rye::Box.initialize
+    #
+    # NOTE: Windows machines are skipped and not added to the set. 
+    def create_rye_set(hostnames, opts={})
+      hostnames ||= []
+      
+      opts = {
+        :user => (current_machine_user).to_s,
+        :parallel => @@global.parallel
+      }.merge(opts)
+      set = Rye::Set.new current_machine_group, opts 
+      
+      opts.delete(:parallel)   # Not used by Rye::Box.new
+      
+      hostnames.each do |m| 
+        # This is a short-circuit for Windows instances. We don't support
+        # disks for windows yet and there's no SSH so routines are out of
+        # the picture too. 
+        next if (m.os || '').to_s == 'win32'
+          
+        if m.is_a?(Rudy::Machine)
+          m.refresh! if m.dns_public.nil? || m.dns_public.empty?
+          if m.dns_public.nil? || m.dns_public.empty?
+            ld "Cannot find public DNS for #{m.name} (continuing...)"
+            ##next
+          end
+          ld [:dns_public, m.dns_public, m.instid]
+          rbox = create_rye_box(m.dns_public, opts) 
+          rbox.stash = m   # Store the machine instance in the stash
+          rbox.nickname = m.name
+        else
+          # Otherwise we assume it's a hostname
+          rbox = create_rye_box(m)
+        end
+        rbox.add_key user_keypairpath(opts[:user])
+        set.add_box rbox
+      end
+      
+      ld "Machines Set: %s" % [set.empty? ? '[empty]' : set.inspect]
+      
+      set
+    end
+    
+    
+
+    
+    # Returns a formatted string for printing command info
+    def print_command(user, host, cmd)
+      #return if @@global.parallel
+      cmd ||= ""
+      cmd, user = cmd.to_s, user.to_s
+      prompt = user == "root" ? "#" : "$"
+      li ("%s@%s%s %s" % [user, host, prompt, cmd.bright])
+    end
+    
+    def print_response(rap)
+      # Non zero exit codes raise exceptions so  
+      # the erorrs have already been handled. 
+      return if rap.exit_code != 0
+      
+      if @@global.parallel
+        cmd, user = cmd.to_s, user.to_s
+        prompt = user == "root" ? "#" : "$"
+        li "%s@%s%s %s%s%s" % [rap.box.user, rap.box.nickname, prompt, rap.cmd.bright, $/, rap.stdout.inspect]
+        unless rap.stderr.empty?
+          le "#{rap.box.nickname}: " << rap.stderr.join("#{rap.box.nickname}: ")
+        end
+      else
+        li '  ' << rap.stdout.join("#{$/}  ") if !rap.stdout.empty?
+        colour = rap.exit_code != 0 ? :red : :normal
+        unless rap.stderr.empty?
+          le ("  STDERR  " << '-'*38).color(colour).bright
+          le "  " << rap.stderr.join("#{$/}    ").color(colour)
+        end
+      end
+    end
+    
+  private 
+    
+    def rbox_exception_handler
+      Proc.new do |ex, cmd, user, host, nickname|
+        print_exception(user, host, cmd, nickname, ex)
+        unless @@global.parallel
+          choice = Annoy.get_user_input('(S)kip  (R)etry  (A)bort: ', nil, 3600) || ''
+          if choice.match(/\AS/i)
+            :skip
+          elsif choice.match(/\AR/i)
+            :retry   # Tells Rye::Box#run_command to retry
+          else
+            exit 12
+          end
+        end
+      end
+    end
+    
+    def print_exception(user, host, cmd, nickname, ex)
+      prefix = @@global.parallel ? "#{nickname}: #{cmd}: " : ""
+      if ex.is_a?(Rye::CommandError)
+        le prefix << ex.message.color(:red)
+      else
+        le prefix << "#{ex.class}: #{ex.message}".color(:red)
+      end
+      le *ex.backtrace
+    end
+    
+  end
+  
+end; end;

data/lib/rudy/routines/handlers/base.rb

@@ -0,0 +1,48 @@
+
+
+module Rudy; module Routines; module Handlers; 
+  module Base
+   include Rudy::Huxtable
+   
+   def trap_rbox_errors(ret=nil, &command)
+     begin
+       ret = command.call if command
+       return unless ret.is_a?(Rye::Rap)
+       puts '  ' << ret.stdout.join("#{$/}  ") if !ret.stdout.empty?
+       print_response(ret)
+     rescue IOError => ex
+       STDERR.puts "  Connection Error (#{ex.message})".color(:red)
+       choice = Annoy.get_user_input('(S)kip  (A)bort: ', nil, 3600) || ''
+        if choice.match(/\AS/i)
+          return
+        #elsif choice.match(/\AR/i)
+        #  retry
+        else
+          exit 12
+        end
+     end
+     
+     ret
+   end
+   
+   def keep_going?
+     Annoy.pose_question("  Keep going?\a ", /yes|y|ya|sure|you bet!/i, STDERR)
+   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
+        STDERR.puts(("  #{sumpin.to_s.upcase}  " << '-'*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; end
+

data/lib/rudy/routines/handlers/depends.rb

@@ -0,0 +1,49 @@
+
+module Rudy; module Routines; module Handlers;
+  module Depends
+    include Rudy::Routines::Handlers::Base 
+    extend self 
+    
+    ## NOTE: Dependencies don't use Rudy::Routines.add_handler but we
+    ## define them ehere anyway so raise_early_exceptions passes. 
+    Rudy::Routines.add_handler :before,  self
+    Rudy::Routines.add_handler :after, self
+    
+    def raise_early_exceptions(type, depends, rset, lbox, argv=nil)
+      unless depends.kind_of? Array
+        raise Rudy::Error, "#{type} must be a kind of Array (#{depends.class})" 
+      end
+      raise Rudy::Routines::EmptyDepends, type if depends.nil? || depends.empty?
+      depends.flatten.compact.each do |name|
+        raise Rudy::Routines::NoRoutine, name unless valid_routine?(name)
+      end
+    end
+    
+    # A simple wrapper for executing a routine.
+    #
+    # * +routine_name+ should be a Symbol representing a routine
+    #   available to the current machine group.
+    #
+    # This method finds the handler for the given routine,
+    # creates an instance, calls raise_early_exceptions,
+    # and finally executes the routine.
+    def execute(routine_name)
+      routine_obj = Rudy::Routines.get_routine routine_name
+      ld "Executing dependency: #{routine_name} (#{routine_obj})"
+      routine = routine_obj.new routine_name
+      routine.raise_early_exceptions
+      routine.execute
+    end
+    
+    # Calls execute for each routine name in +depends+ (an Array).
+    # Does nothing if given an empty Array or nil.
+    def execute_all(depends)
+      return if depends.nil? || depends.empty?
+      depends = depends.flatten.compact
+      ld "Found depenencies: #{depends.join(', ')}"
+      depends.each { |routine| execute(routine) }
+    end
+    
+  end
+  
+end; end; end

data/lib/rudy/routines/handlers/disks.rb

@@ -0,0 +1,239 @@
+
+module Rudy::Routines::Handlers;
+  module Disks
+    include Rudy::Routines::Handlers::Base
+    extend self
+    
+    ACTIONS = [:create, :destroy, :archive, :mount, :restore,
+               :attach, :detach, :mount, :umount].freeze
+    
+    Rudy::Routines.add_handler :disks, self
+    
+    def raise_early_exceptions(type, batch, rset, lbox, argv=nil)
+      
+    end
+    
+    def disks?(routine)
+      (routine.kind_of?(Hash) && routine.disks && 
+      routine.disks.kind_of?(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(type, routine, rset, lbox, argv=nil)
+      original_user = rset.user
+      rset.add_key user_keypairpath('root')
+      rset.switch_user 'root'
+      
+      # We need to add mkfs since it's not enabled by default. 
+      # We prepend the command with rudy_ so we can delete it. 
+      Rye::Cmd.add_command(:rudy_mkfs, 'mkfs')
+      
+      routine.each_pair do |action, disks|
+        unless respond_to?(action.to_sym)  
+          Rudy::Huxtable.le %Q(DiskHelper: unknown action "#{action}")
+          next
+        end
+        # A quick hack to take advantage of the threading in Rye::Set.
+        # The action method does not run in the context of a Rye::Box
+        # object so we need to send rset as an argument. 
+        rset.batch do
+          disks.each_pair do |path, props|
+            # self contains the current instance of Rye::Box. 
+            disk = Rudy::Disk.new(self.stash.position, path, props)
+            Rudy::Routines::Handlers::Disks.send(action, self, disk)
+          end
+        end
+
+      end
+      
+      Rye::Cmd.remove_command(:rudy_mkfs)
+      
+      rset.switch_user original_user
+    end
+    
+    
+    def create(rbox, disk)
+      if disk.exists?
+        puts "Disk found: #{disk.name}"
+        disk.refresh!          
+      end
+      
+      unless @@global.force
+        raise Rudy::Disks::AlreadyAttached, disk.name if disk.volume_attached?
+      end
+      
+      unless disk.volume_exists?
+        msg = "Creating volume... "
+        disk.create
+        Rudy::Utils.waiter(2, 60, STDOUT, msg) { 
+          disk.volume_available?
+        }
+      end
+      
+      attach rbox, disk unless disk.volume_attached?
+      format rbox, disk if disk.raw?
+      mount rbox, disk unless disk.mounted?
+
+      disk.save :replace
+    end
+    
+    
+    
+    def detach(rbox, disk)
+      
+      raise Rudy::Metadata::UnknownObject, disk.name unless disk.exists?
+      disk.refresh!
+      
+      raise Rudy::Disks::NotAttached, disk.name if !disk.volume_attached?
+      
+      umount rbox, disk if disk.mounted?
+      raise Rudy::Disks::InUse, disk.name if disk.mounted?
+
+      msg = "Detaching #{disk.volid}..."
+      disk.volume_detach 
+      Rudy::Utils.waiter(2, 60, STDOUT, msg) { 
+        disk.volume_available? 
+      }
+
+    end
+    
+    def attach(rbox, disk)
+      
+      raise Rudy::Metadata::UnknownObject, disk.name unless disk.exists?
+      disk.refresh!
+      
+      raise Rudy::Disks::AlreadyAttached, disk.name if disk.volume_attached?
+      
+      msg = "Attaching #{disk.volid} to #{rbox.stash.instid}... "
+      disk.volume_attach(rbox.stash.instid)
+      Rudy::Utils.waiter(2, 10, STDOUT, msg) { 
+        disk.volume_attached?
+      }
+
+    end
+    
+    def mount(rbox, disk)
+      
+      raise Rudy::Metadata::UnknownObject, disk.name unless disk.exists?
+      disk.refresh!
+      attach rbox, disk unless disk.volume_attached?
+      
+      unless @@global.force
+        raise Rudy::Disks::NotAttached, disk.name if !disk.volume_attached?
+        raise Rudy::Disks::NotFormatted, disk.name if disk.raw?
+        raise Rudy::Disks::AlreadyMounted, disk.name if disk.mounted?
+      end
+      
+      rbox.mkdir(:p, disk.path)
+      
+      puts "Mounting at #{disk.path}... "
+  
+      rbox.mount(:t, disk.fstype, disk.device, disk.path) 
+      disk.mounted = true
+      disk.save :replace
+      sleep 1
+    end
+    
+    
+    def umount(rbox, disk)
+      raise Rudy::Metadata::UnknownObject, disk.name unless disk.exists?
+      disk.refresh!
+      
+      raise Rudy::Disks::NotAttached, disk.name if !disk.volume_attached?
+      raise Rudy::Disks::NotMounted, disk.name if !disk.mounted?
+      
+      puts "Unmounting #{disk.path}... "
+      rbox.umount(disk.path)
+      disk.mounted = false
+      disk.save :replace
+      sleep 2
+    end
+    alias_method :unmount, :umount
+    
+    def format(rbox, disk)
+      raise Rudy::Metadata::UnknownObject, disk.name unless disk.exists?
+      disk.refresh!
+      
+      attach rbox, disk unless disk.volume_attached?
+      
+      raise Rudy::Disks::NotAttached, disk.name if !disk.volume_attached?
+      
+      unless @@global.force
+        raise Rudy::Disks::AlreadyFormatted, disk.name if !disk.raw?
+      end
+      
+      disk.fstype = 'ext3' if disk.fstype.nil? || disk.fstype.empty?
+      
+      puts "Creating #{disk.fstype} filesystem for #{disk.device}... "
+      rbox.rudy_mkfs(:t, disk.fstype, :F, disk.device)
+      disk.raw = false
+      disk.save :replace
+    end
+    
+    def destroy(rbox, disk)
+      raise Rudy::Metadata::UnknownObject, disk.name unless disk.exists?
+      disk.refresh!
+        
+      umount rbox, disk if disk.mounted?
+      detach rbox, disk if disk.volume_attached?
+      
+      unless @@global.force
+        raise Rudy::Disks::InUse, disk.name if disk.volume_attached?
+      end
+      
+      puts "Destroying #{disk.name}"
+      disk.destroy
+    end
+    
+    def archive(rbox, disk)
+      raise Rudy::Metadata::UnknownObject, disk.name unless disk.exists?
+      disk.refresh!
+      
+      raise Rudy::Disks::NotAttached, disk.name if !disk.volume_attached?
+      
+      back = disk.archive
+      puts "Created backup: #{back.name}"
+    end
+    
+    def restore(rbox, disk)
+      
+      if disk.exists?
+        puts "Disk found: #{disk.name}"
+        disk.refresh!       
+      end
+      
+      unless @@global.force
+        raise Rudy::Disks::AlreadyAttached, disk.name if disk.volume_attached?
+      end
+      
+      latest_backup = disk.backups.last
+      disk.size, disk.fstype = latest_backup.size, latest_backup.fstype
+      
+      puts "Backup found: #{latest_backup.name}"
+      
+      unless disk.volume_exists?
+        msg = "Creating volume... "
+        disk.create latest_backup.size, latest_backup.zone, latest_backup.snapid
+        Rudy::Utils.waiter(2, 60, STDOUT, msg) { 
+          disk.volume_available?
+        }
+        
+      end
+      disk.raw = false
+      
+      attach rbox, disk unless disk.volume_attached?
+      #format rbox, disk if disk.raw?
+      mount rbox, disk unless disk.mounted?
+      
+      disk.save :replace
+
+    end
+    
+    
+  end
+end