solutious-rudy 0.8.5 → 0.9.0

data/lib/rudy/metadata/backups.rb

@@ -1,67 +0,0 @@
-
-
-module Rudy
-class Backups
-  include Rudy::MetaData
-  
-  def init
-    now = Time.now.utc
-    datetime = Rudy::MetaData::Backup.format_timestamp(now).split(Rudy::DELIM)
-    @created = now.to_i
-    @date, @time, @second = datetime
-  end
-  
-  #def create(&each_mach)
-    
-  #end
-
-
-  def destroy(&each_mach)
-    list do |backup|
-      puts "Destroying #{backup.name}"
-      backup.destroy
-    end
-  end
-
-  def list(more=[], less=[], local={}, &each_backup)
-    backups = list_as_hash(more, less, local, &each_backup)
-    backups &&= backups.values
-    backups
-  end
-
-  def list_as_hash(more=[], less=[], local={}, &each_backup)
-    more ||= []
-    more += [:rtype, 'back']
-    query = to_select(more, less, local)
-    list = @sdb.select(query) || {}
-    backups = {}
-    list.each_pair do |n,d|
-      backups[n] = Rudy::MetaData::Backup.from_hash(d)
-    end
-    backups.each_pair { |n,backup| each_backup.call(backup) } if each_backup
-    backups = nil if backups.empty?
-    backups
-  end
-
-  def get(rname=nil)
-    dhash = @sdb.get(Rudy::DOMAIN, rname)
-    return nil if dhash.nil? || dhash.empty?
-    d = Rudy::MetaData::Backup.from_hash(dhash)
-    d.update if d
-    d
-  end
-
-
-  def running?
-    !list.nil?
-    # TODO: add logic that checks whether the instances are running.
-  end
-
-  def to_select(*args)
-    query = super(*args)
-    query << " and created != '0' order by created desc"
-  end
-  
-end
-end
-

data/lib/rudy/metadata/debug.rb

@@ -1,38 +0,0 @@
-
-
-module Rudy; module MetaData
-class Debug
-  include Rudy::MetaData
-  
-  def init
-  end
-  
-  def list(more=[], less=[], local={}, &block)
-    objects = list_as_hash(more, less, local, &block)
-    objects &&= objects.values
-    objects
-  end
-
-  def list_as_hash(more=[], less=[], local={}, &block)
-    query = to_select(more, less, local)
-    list = @sdb.select(query) || {}
-    objects = {}
-    list.each_pair do |n,d|
-      objects[n] = d
-    end
-    objects.each_pair { |n,obj| block.call(obj) } if block
-    objects = nil if objects.empty?
-    objects
-  end
-  
-  
-  def to_select(more, less, local)
-    query = super(more, less, local)
-#    query << " order by created desc"
-    puts query if @@global.verbose > 0
-    query
-  end
-  
-end
-end; end
-

data/lib/rudy/metadata/disks.rb

@@ -1,67 +0,0 @@
-
-
-module Rudy
-class Disks
-  include Rudy::MetaData
-  
-  
-  def init
-    @rback = Rudy::Backups.new
-  end
-  
-  #def create(&each_mach)
-    
-  #end
-
-
-  def destroy(&each_mach)
-    #raise MachineGroupNotRunning, current_machine_group unless running?
-    #raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
-    list do |disk|
-      puts "Destroying #{disk.name}"
-      disk.destroy
-    end
-  end
-  
-  def backups
-    @rback.list()
-  end
-  
-  def list(more=[], less=[], &each_disk)
-    disks = list_as_hash(&each_disk)
-    disks &&= disks.values
-    disks
-  end
-  
-  def list_as_hash(more=[], less=[], &each_disk)
-    query = to_select([:rtype, 'disk'], less)
-    list = @sdb.select(query) || {}
-    disks = {}
-    list.each_pair do |n,d|
-      disks[n] = Rudy::MetaData::Disk.from_hash(d)
-    end
-    disks.each_pair { |n,disk| each_disk.call(disk) } if each_disk
-    disks = nil if disks.empty?
-    disks
-  end
-
-  def get(rname=nil)
-    dhash = @sdb.get(Rudy::DOMAIN, rname)
-    return nil if dhash.nil? || dhash.empty?
-    d = Rudy::MetaData::Disk.from_hash(dhash)
-    d.update if d
-    d
-  end
-
-
-  def running?
-    !list.nil?
-    # TODO: add logic that checks whether the instances are running.
-  end
-
-
-    
-  
-end
-end
-

data/lib/rudy/metadata/objectbase.rb

@@ -1,108 +0,0 @@
-
-
-module Rudy
-  module MetaData
-    module ObjectBase
-      include Rudy::Huxtable
-      
-      attr_accessor :sdb_domain
-      
-      def initialize(*args)
-        a, s, r = @@global.accesskey, @@global.secretkey, @@global.region
-        @sdb = Rudy::AWS::SDB.new(a, s, r)
-        @ec2inst = Rudy::AWS::EC2::Instances.new(a, s, r)
-        @rvol = Rudy::AWS::EC2::Volumes.new(a, s, r)
-        @radd = Rudy::AWS::EC2::Addresses.new(a, s, r)
-        @rsnap = Rudy::AWS::EC2::Snapshots.new(a, s, r)
-        @sdb_domain = Rudy::DOMAIN
-        init(*args)
-      end
-      
-      def init(*args); raise "Must override init"; end
-      
-      def valid?; raise "#{self.class} must override 'valid?'"; end
-      
-      def to_query(more=[], less=[])
-        Rudy::AWS::SDB.generate_query build_criteria(more, less)
-      end
-    
-      def to_select(more=[], less=[])
-        s = Rudy::AWS::SDB.generate_select ['*'], @sdb_domain, build_criteria(more, less)
-        s
-      end
-      
-      def name(identifier, zon, env, rol, pos, *other)
-        pos = pos.to_s.rjust 2, '0'
-        [identifier, zon, env, rol, pos, *other].flatten.compact.join(Rudy::DELIM)
-      end
-      
-      def save(replace=true)
-        replace = true if replace.nil?
-        @sdb ||= Rudy::AWS::SDB.new(@@global.accesskey, @@global.secretkey, @@global.region)
-        @sdb.put(@sdb_domain, name, self.to_hash, replace) # Always returns nil
-        true
-      end
-    
-      def destroy
-        @sdb ||= Rudy::AWS::SDB.new(@@global.accesskey, @@global.secretkey, @@global.region)
-        @sdb.destroy(@sdb_domain, name)
-        true
-      end
-    
-      def refresh
-        @sdb ||= Rudy::AWS::SDB.new(@@global.accesskey, @@global.secretkey, @@global.region)
-        h = @sdb.get(@sdb_domain, name) || {}
-        from_hash(h)
-      end
-      
-      def ==(other)
-        return false unless other.is_a?(self.class)
-        self.name == other.name
-      end
-      
-      # A generic default
-      def to_s
-        str = ""
-        field_names.each do |key|
-          str << sprintf(" %22s: %s#{$/}", key, self.send(key.to_sym))
-        end
-        str
-      end
-      
-      def liner_note
-        info = @awsid && !@awsid.empty? ? @awsid : "[no aws object]"
-        "%s  %s" % [self.name.bright, info]
-      end
-      
-      def inspect
-        lines = []
-        lines << liner_note
-        field_names.each do |key|
-          next unless self.respond_to?(key)
-          val = self.send(key)
-          lines << sprintf(" %22s: %s", key, (val.is_a?(Array) ? val.join(', ') : val))
-        end
-        lines.join($/)
-      end
-      
-    protected
-    
-      # Builds a zipped Array from a list of criteria.
-      # The list of criteria is made up of metadata object attributes. 
-      # The list is constructed by taking the adding +more+, and
-      # subtracting +less+ from <tt>:rtype, :region, :zone, :environment, :role, :position</tt>
-      # 
-      # Returns [[:rtype, value], [:zone, value], ...]
-      def build_criteria(more=[], less=[])
-        criteria = [:rtype, :region, :zone, :environment, :role, :position, *more].compact
-        criteria -= [*less].flatten.uniq.compact
-        values = criteria.collect do |n|
-          self.send(n.to_sym)
-        end
-        criteria.zip(values)
-      end
-      
-    end
-  end
-end
-

data/lib/rudy/routines/helper.rb

@@ -1,76 +0,0 @@
-
-
-module Rudy
-  module Routines
-    module HelperBase
-     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  (R)etry  (A)bort: ') || ''
-          if choice.match(/\AS/i)
-            return
-          elsif choice.match(/\AR/i)
-            retry
-          else
-            exit 12
-          end
-       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
-       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, host)
-       cmd ||= ""
-       cmd, user = cmd.to_s, user.to_s
-       prompt = user == "root" ? "#" : "$"
-       ("%s@%s%s %s" % [user, host, 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
-        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

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