solutious-rudy 0.7.3 → 0.7.4

data/lib/rudy/{disks.rb → metadata/disk.rb}

@@ -1,6 +1,4 @@
-
-
-module Rudy
+module Rudy::MetaData
 class Disk < Storable
   include Rudy::MetaData::ObjectBase
   
@@ -28,6 +26,8 @@ class Disk < Storable
   field :fstype
   field :mounted
   
+  field :created
+  
   def init(path=nil, size=nil, device=nil, position=nil)
     @path, @size, @device = path, size, device
     @rtype = 'disk'
@@ -37,6 +37,11 @@ class Disk < Storable
     @role = @@global.role
     @position = position || @@global.position
     @mounted = false
+    
+    now = Time.now.utc
+    datetime = Backup.format_timestamp(now).split(Rudy::DELIM)
+    @created = now.to_i
+    
     postprocess
   end
   
@@ -45,15 +50,14 @@ class Disk < Storable
     @mounted = true if @mounted == "true"
   end
   
-  def liner_note
-    info = @awsid && !@awsid.empty? ? @awsid : 'no volume'
-    "%s  %s" % [self.name.bright, info]
-  end
-  
   def to_s(with_titles=true)
     update
     mtd = @mounted == true ? "mounted" : @status
-    "%s; %3sGB; %s; %s" % [liner_note, @size, @device, mtd]
+    if @size && @device
+      "%s; %3sGB; %s; %s" % [liner_note, @size, @device, mtd]
+    else
+      liner_note
+    end
   end
   
   def inspect
@@ -74,17 +78,35 @@ class Disk < Storable
     super("disk", @zone, @environment, @role, @position, *dirs)
   end
   
-
-  
-  def create(snapshot=nil)
-    raise "#{name} is already running" if exists?
-    vol = @rvol.create(@size, @zone, snapshot) 
+  def create(size=nil, zone=nil, snapshot=nil)
+    raise "#{name} already exists" if exists?
+    vol = @rvol.create(size || @size, zone || @zone, snapshot) 
     @awsid = vol.awsid
     @raw = true
     self.save
     self
   end
   
+  def backup
+    raise "No volume to backup" unless @awsid
+    bup = Rudy::MetaData::Backup.new(@awsid, @path, @position)
+    bup.size = @size || 1
+    bup.fstype = @fstype || 'ext3'
+    bup.create
+  end
+  
+  def list_backups
+    rback = Rudy::Backups.new
+    props = {
+      :environment => @environment, 
+      :role => @role,
+      :zone => @zone,
+      :region => @region,
+      :position => @position
+    }
+    rback.list([], [], props)
+  end
+  
   def attach(instid)
     raise "No volume id" unless exists?
     vol = @rvol.attach(@awsid, instid, @device)
@@ -150,61 +172,6 @@ class Disk < Storable
       @rvol.send(state, @awsid) rescue false # deleting?, available?, etc...
     end
   end
-end
-
-class Disks
-  include Rudy::MetaData
-  
-    
-  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 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::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::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/disks.rb

@@ -0,0 +1,67 @@
+
+
+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

@@ -0,0 +1,104 @@
+
+
+module Rudy
+  module MetaData
+    module ObjectBase
+      include Rudy::Huxtable
+      
+      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)
+        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=[])
+        Rudy::AWS::SDB.generate_select ['*'], Rudy::DOMAIN, build_criteria(more, less)
+      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(Rudy::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(Rudy::DOMAIN, name)
+        true
+      end
+    
+      def refresh
+        @sdb ||= Rudy::AWS::SDB.new(@@global.accesskey, @@global.secretkey, @@global.region)
+        h = @sdb.get(Rudy::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/mixins.rb

@@ -0,0 +1,2 @@
+
+require "rudy/mixins/hash"

data/lib/rudy/routines.rb

@@ -32,45 +32,78 @@ module Rudy
       end
       
       # * +machine_action+ a method on Rudy::Machines, one of: create, destroy, list
-      # * +skipcheck+ Skip checking if machine is up and SSH is available (default: false)
-      # * +routine_action+ is an optional block which represents the action
-      # for a specific routine. For example, a startup routine will start
-      # an EC2 instance. Arguments: instances of Rudy::Machine and Rye::Box.
-      def generic_machine_runner(machine_action, skipcheck=false, &routine_action)
-        rmach = Rudy::Machines.new
-        raise "No routine supplied" unless @routine
+      # * +routine+ Override +routine+ with another routine (default: nil)
+      # * +skip_check+ Don't check that the machine is up and SSH is available (default: false)
+      # * +skip_header+ Don't print machine header (default: false)
+      # * +routine_action+ is an optional block which will be executed for each 
+      #   machine between the disk routine and after blocks. The block receives
+      #   two argument: an instance of Rudy::Machine and one of Rye::Box.
+      def generic_machine_runner(machine_action, routine=nil, skip_check=false, skip_header=false, &routine_action)
+        if @@global.offline
+          rmach = Rudy::Machines::Offline.new
+          skip_check = true
+          remote_user = Rudy.sysinfo.user
+        else
+          rmach = Rudy::Machines.new
+          remote_user = 'root'
+        end
+        
+        routine ||= @routine
+        raise "No routine supplied" unless routine
         raise "No machine action supplied" unless machine_action
         unless rmach.respond_to?(machine_action)
           raise "Unknown machine action #{machine_action}" 
         end
         
+        # Declare a couple vars so they're available outide the block
+        before_dependencies = after_dependencies = nil  
+        enjoy_every_sandwich {
+          # This gets and removes the dependencies from the routines hash. 
+          if Rudy::Routines::DependsHelper.has_depends?(:before, routine)
+            before_dependencies = Rudy::Routines::DependsHelper.get(:before, routine)
+          end
+          
+          # We grab the after ones now too, so we don't fool the ScriptHelper 
+          # later on in this routine (after keyword is used for scripts too)
+          if Rudy::Routines::DependsHelper.has_depends?(:after, routine)
+            after_dependencies = Rudy::Routines::DependsHelper.get(:after, routine)
+          end
+          
+          # This calls generic_machine_runner for every dependent before routine. 
+          execute_dependency(before_dependencies, skip_check, skip_header)
+        }
+        
+        
         lbox = Rye::Box.new('localhost')
         sconf = fetch_script_config
         
+        enjoy_every_sandwich {
+          if Rudy::Routines::ScriptHelper.before_local?(routine)  # before_local
+            # Runs "before_local" scripts of routines config. 
+            puts task_separator("LOCAL SHELL")
+            Rudy::Routines::ScriptHelper.before_local(routine, sconf, lbox)
+          end
+        }
         
-        if Rudy::Routines::ScriptHelper.before_local?(@routine)  # before_local
-          # Runs "before_local" scripts of routines config. 
-          puts task_separator("LOCAL SHELL")
-          Rudy::Routines::ScriptHelper.before_local(@routine, sconf, lbox)
-        end
-        
-        if Rudy::Routines::ScriptHelper.script_local?(@routine)  # before_local
-          # Runs "script_local" scripts of routines config. 
-          # NOTE: This is synonymous with before_local
-          puts task_separator("LOCAL SHELL")
-          Rudy::Routines::ScriptHelper.script_local(@routine, sconf, lbox)
-        end
+        enjoy_every_sandwich {
+          if Rudy::Routines::ScriptHelper.script_local?(routine)  # script_local
+            # Runs "script_local" scripts of routines config. 
+            # NOTE: This is synonymous with before_local
+            puts task_separator("LOCAL SHELL")
+            Rudy::Routines::ScriptHelper.script_local(routine, sconf, lbox)
+          end
+        }
         
-        unless has_remote_task?(@routine)
+        unless has_remote_task?(routine)
           puts "[no remote tasks]"
           return
         end
         
         # Execute the action (create, list, destroy, restart) & apply the block to each
         rmach.send(machine_action) do |machine|
-          puts machine_separator(machine.name, machine.awsid)
+          puts machine_separator(machine.name, machine.awsid) unless skip_header
           
-          unless skipcheck
+          unless skip_check
             msg = preliminary_separator("Checking if instance is running...")
             Rudy::Utils.waiter(3, 120, STDOUT, msg, 0) {
               inst = machine.get_instance
@@ -80,7 +113,7 @@ module Rudy
             # 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 occurrs before this update is 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 
@@ -92,55 +125,70 @@ module Rudy
           end
           
           # TODO: trap rbox errors. We could get an authentication error. 
-          opts = { :keys =>  root_keypairpath, :user => 'root', :info => @@global.verbose > 0 }
+          opts = { :keys =>  root_keypairpath, :user => remote_user, :info => @@global.verbose > 0 }
           begin
             rbox = Rye::Box.new(machine.dns_public, opts)
             rbox.connect
           rescue Rye::NoHost => ex
-          
+            STDERR.puts "No host: #{ex.message}"
             exit 65
           end
-        
-          # Set the hostname if specified in the machines config. 
-          # :rudy -> change to Rudy's machine name
-          # :default -> leave the hostname as it is
-          # Anything else other than nil -> change to that value
-          # NOTE: This will set hostname every time a routine is
-          # run so we may want to make this an explicit action. 
-          hn = current_machine_hostname || :rudy
-          if hn != :default
-            hn = machine.name if hn == :rudy
-            print preliminary_separator("Setting hostame to #{hn}... ")
-            rbox.hostname(hn) 
-            puts "done"
-          end
           
-          if Rudy::Routines::UserHelper.adduser?(@routine)       # adduser
-            puts task_separator("ADD USER")
-            Rudy::Routines::UserHelper.adduser(@routine, machine, rbox)
+          unless skip_check
+            # Set the hostname if specified in the machines config. 
+            # :rudy -> change to Rudy's machine name
+            # :default -> leave the hostname as it is
+            # Anything else other than nil -> change to that value
+            # NOTE: This will set hostname every time a routine is
+            # run so we may want to make this an explicit action. 
+            enjoy_every_sandwich {
+              hn = current_machine_hostname || :rudy
+              if hn != :default
+                hn = machine.name if hn == :rudy
+                print preliminary_separator("Setting hostame to #{hn}... ")
+                rbox.hostname(hn) 
+                puts "done"
+              end
+            }
           end
           
-          if Rudy::Routines::UserHelper.authorize?(@routine)     # authorize
-            puts task_separator("AUTHORIZE USER")
-            Rudy::Routines::UserHelper.authorize(@routine, machine, rbox)
-          end
-          #puts 1
-          if Rudy::Routines::ScriptHelper.before?(@routine)      # before
-            puts task_separator("REMOTE SHELL")
-            Rudy::Routines::ScriptHelper.before(@routine, sconf, machine, rbox)
-          end
-          #puts 2
-          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
           
-          # Startup, shutdown, release, deploy, etc...
-          routine_action.call(machine, rbox) if routine_action
+          enjoy_every_sandwich {
+            if Rudy::Routines::UserHelper.adduser?(routine)       # adduser
+              puts task_separator("ADD USER")
+              Rudy::Routines::UserHelper.adduser(routine, machine, rbox)
+            end
+          }
+          
+          enjoy_every_sandwich {
+            if Rudy::Routines::UserHelper.authorize?(routine)     # authorize
+              puts task_separator("AUTHORIZE USER")
+              Rudy::Routines::UserHelper.authorize(routine, machine, rbox)
+            end
+          }
+          
+          enjoy_every_sandwich {
+            if Rudy::Routines::ScriptHelper.before?(routine)      # before
+              puts task_separator("REMOTE SHELL")
+              Rudy::Routines::ScriptHelper.before(routine, sconf, machine, rbox)
+            end
+          }
+          
+          enjoy_every_sandwich {
+            if Rudy::Routines::DiskHelper.disks?(routine)         # disk
+              puts task_separator("DISKS")
+              if rbox.ostype == "sunos"
+                puts "Sorry, Solaris disks are not supported yet!"
+              else
+                Rudy::Routines::DiskHelper.execute(routine, machine, rbox)
+              end    
+            end
+          }
+          
+          enjoy_every_sandwich {
+            # Startup, shutdown, release, deploy, etc...
+            routine_action.call(machine, rbox) if routine_action
+          }
           
           # The "after" blocks are synonymous with "script" blocks. 
           # For some routines, like startup, it makes sense to an 
@@ -149,37 +197,60 @@ module Rudy
           # definition is the entire routine so we use "script".
           # NOTE: If both after and script are supplied they will 
           # both be executed. 
-          if Rudy::Routines::ScriptHelper.script?(@routine)      # script
-            puts task_separator("REMOTE SHELL")
-            # Runs "after" scripts of routines config
-            Rudy::Routines::ScriptHelper.script(@routine, sconf, machine, rbox)
-          end
+          enjoy_every_sandwich {
+            if Rudy::Routines::ScriptHelper.script?(routine)      # script
+              puts task_separator("REMOTE SHELL")
+              # Runs "after" scripts of routines config
+              Rudy::Routines::ScriptHelper.script(routine, sconf, machine, rbox)
+            end
+          }
           
-          
-          if Rudy::Routines::ScriptHelper.after?(@routine)       # after
-            puts task_separator("REMOTE SHELL")
-            # Runs "after" scripts of routines config
-            Rudy::Routines::ScriptHelper.after(@routine, sconf, machine, rbox)
-          end
-
-          if Rudy::Routines::DiskHelper.disks?(@routine)
-            # TODO: Print only the requested disks
-            puts task_separator("INFO")
-            puts "Filesystem on #{machine.name}:"
-            puts "  " << rbox.df(:h).join("#{$/}  ")
-          end
+          enjoy_every_sandwich {
+            if Rudy::Routines::ScriptHelper.after?(routine)       # after
+              puts task_separator("REMOTE SHELL")
+              # Runs "after" scripts of routines config
+              Rudy::Routines::ScriptHelper.after(routine, sconf, machine, rbox)
+            end
+          }
           
           rbox.disconnect
         end
-
-        if Rudy::Routines::ScriptHelper.after_local?(@routine)   # after_local
-          puts task_separator("LOCAL SHELL")
-          # Runs "after_local" scripts of routines config
-          Rudy::Routines::ScriptHelper.after_local(@routine, sconf, lbox)
+        
+        enjoy_every_sandwich {
+          if Rudy::Routines::ScriptHelper.after_local?(routine)   # after_local
+            puts task_separator("LOCAL SHELL")
+            # Runs "after_local" scripts of routines config
+            Rudy::Routines::ScriptHelper.after_local(routine, sconf, lbox)
+          end
+        }
+        
+        # This calls generic_machine_runner for every dependent after routine 
+        enjoy_every_sandwich {
+          execute_dependency(after_dependencies, skip_check, skip_header)
+        }
+        
+      end
+      
+      def execute_dependency(depends, skip_check, skip_header)
+        return unless depends
+        unless depends.empty?
+          depends.each_with_index do |d, index|
+            puts task_separator("DEPENDENCY: #{d}")  
+            routine_dependency = fetch_routine_config(d)
+            unless routine_dependency
+              STDERR.puts "  Unknown routine: #{d}".color(:red)
+              next
+            end
+            # NOTE: running routines here means they do not have their own
+            # payload and they must use the list action. I think this is ok
+            # though b/c there should only be a few routines with payloads
+            # (startup, shutdown, reboot)
+            generic_machine_runner(:list, routine_dependency, skip_check, skip_header)
+          end
         end
-
       end
       
+      
       # Does the given +routine+ define any remote tasks?
       def has_remote_task?(routine)
         any = [Rudy::Routines::DiskHelper.disks?(routine),
@@ -187,7 +258,9 @@ module Rudy
                Rudy::Routines::ScriptHelper.after?(routine),
                Rudy::Routines::ScriptHelper.script?(routine),
                Rudy::Routines::UserHelper.authorize?(routine),
-               Rudy::Routines::UserHelper.adduser?(routine)]
+               Rudy::Routines::UserHelper.adduser?(routine), 
+               !@after_dependencies.nil?,
+               !@before_dependencies.nil?]
         # Throw away all false answers (and nil answers)
         any = any.compact.select { |success| success }
         !any.empty?   # Returns true if any element contains true
@@ -220,9 +293,21 @@ module Rudy
         #puts '%-40s' % [name.bright]
       end
       
+      def enjoy_every_sandwich(&bloc_party)
+        begin
+          bloc_party.call
+        rescue => ex
+          STDERR.puts "  Error: #{ex.message}".color(:red)
+          STDERR.puts ex.backtrace if Rudy.debug?
+          exit 12 unless keep_going?
+        end
+      end
+      
+       def keep_going?
+         Annoy.pose_question("  Keep going?\a ", /yes|y|ya|sure|you bet!/i, STDERR)
+       end
       
     end
-    
   end
 end