solutious-rudy 0.4.0

data/lib/rudy/aws/s3.rb

@@ -0,0 +1,3 @@
+
+module Rudy::AWS
+end

data/lib/rudy/aws/simpledb.rb

@@ -0,0 +1,53 @@
+
+
+
+module Rudy::AWS
+
+  
+  class SimpleDB
+    class Domains 
+      include Rudy::AWS::ObjectBase
+      
+      def create(name)
+        @aws.create_domain(name)
+      end
+      
+      def destroy(name)
+        @aws.delete_domain(name)
+      end
+    
+      def list
+        @aws.list_domains
+      end
+    end
+    
+    def destroy(domain, item, attributes={})
+      @aws.delete_attributes(domain, item, attributes)
+    end
+    
+    def store(domain, item, attributes={}, replace=false)
+      @aws.put_attributes(domain, item, attributes, replace)
+    end
+    
+    def query(domain, query=nil, max=nil)
+      @aws.query(domain, query, max)
+    end
+    
+    def query_with_attributes(domain, query, max=nil)
+      items = {}
+      query(domain, query)[:items].each do |item|
+        items[item] = get_attributes(domain, item)[:attributes]
+      end
+      items
+    end
+    
+    def select(query)
+      list = @aws2.select(query) || []
+      list[0]
+    end
+    
+    def get_attributes(domain, item, attribute=nil)
+      @aws.get_attributes(domain, item, attribute)
+    end
+  end
+end

data/lib/rudy/command/addresses.rb

@@ -0,0 +1,46 @@
+
+
+
+module Rudy
+  module Command
+    class Addresses < Rudy::Command::Base
+
+
+      def associate_addresses_valid?
+        raise "You have not supplied an IP addresses" unless @argv.address
+        raise "You did not supply an instance ID" unless @argv.instanceid
+        
+        @inst = @ec2.instances.get(@argv.instanceid)
+        raise "Instance #{@inst[:aws_instance_id]} does not exist!" unless @inst
+        
+        raise "That's not an elastic IP you own!" unless @ec2.addresses.valid?(@argv.address)
+        raise "#{@argv.address} is already associated!" if @ec2.addresses.associated?(@argv.address)
+        
+        true
+      end
+      
+      def associate_addresses
+        puts "Associating #{@argv.address} to #{@inst[:aws_groups]}: #{@inst[:dns_name]}"
+        @ec2.addresses.associate(@inst[:aws_instance_id], @argv.address)
+        puts "Done!"
+        puts
+        
+        addresses
+      end
+      
+      def addresses
+        puts "Elastic IP mappings:"
+        @ec2.addresses.list.each do |address|
+          print "IP: #{address[:public_ip]} "
+          if address[:instance_id]
+            inst = @ec2.instances.get(address[:instance_id])
+            puts "%s: %s %s" % [inst[:aws_groups], inst[:aws_instance_id], inst[:dns_name]]
+          end
+        end
+        puts
+      end
+      
+    end
+  end
+end
+

data/lib/rudy/command/backups.rb

@@ -0,0 +1,175 @@
+
+
+
+
+module Rudy
+  module Command
+    class Backups < Rudy::Command::Base
+      
+      
+      def backup
+        criteria = [@global.zone]
+        criteria += [@global.environment, @global.role] unless @option.all
+        
+        Rudy::MetaData::Backup.list(@sdb, *criteria).each do |backup|
+          puts "%s (%s)" % [backup.name, backup.awsid]
+        end
+      end
+      
+      # Check for backups pointing to snapshots that don't exist. 
+      def sync_backup
+        unless argv.empty?
+          puts "The disk you specified will be ignored."
+          argv.clear
+        end
+        
+        criteria = [@global.zone]
+        criteria += [@global.environment, @global.role] unless @option.all
+        
+        puts "Looking for backup metadata with delinquent snapshots..."
+        to_be_deleted = {} # snap-id => backup
+        Rudy::MetaData::Backup.list(@sdb, *criteria).each do |backup|
+          to_be_deleted[backup.awsid] = backup unless @ec2.snapshots.exists?(backup.awsid)
+        end
+        
+        if to_be_deleted.empty?
+          puts "All backups are in-sync with snapshots. Nothing to do."
+          return
+        end
+        
+        puts
+        puts "These backup metadata will be deleted:"
+        to_be_deleted.each do |snap_id, backup|
+          puts "%s: %s" % [snap_id, backup.name]
+        end
+        
+        puts
+        are_you_sure?
+        
+        puts 
+        puts "Deleting..."
+        to_be_deleted.each do |snap_id, backup|
+          print " -> #{backup.name}... "
+          @sdb.destroy(RUDY_DOMAIN, backup.name)
+          puts "done"
+        end
+        
+        puts "Done!"
+      end
+      
+      def destroy_backup_valid?
+        raise "No backup specified" if argv.empty?
+        exit unless are_you_sure?(5)
+        true
+      end
+      
+      def destroy_backup
+        name = @argv.first
+        puts "Destroying #{name}"
+        begin
+          backup = Rudy::MetaData::Backup.get(@sdb, name)
+        rescue => ex
+          puts "Error deleteing backup: #{ex.message}"
+        end
+        
+        return unless backup
+        
+        begin
+          puts " -> deleting snapshot..."
+          @ec2.snapshots.destroy(backup.awsid)
+        rescue => ex
+          puts "Error deleting snapshot: #{ex.message}."
+          puts "Continuing..."
+        ensure
+          puts " -> deleting metadata..."
+          @sdb.destroy(RUDY_DOMAIN, name)
+        end
+        puts "Done."
+      end
+      
+      def create_backup
+        diskname = @argv.first
+        
+        machine = find_current_machine
+        
+        disks = Rudy::MetaData::Disk.list(@sdb, machine[:aws_availability_zone], @global.environment, @global.role, @global.position)
+        raise "The machine #{machine_name} does not have any disk metadata" if disks.empty?
+        
+        puts "Machine: #{machine_name}"
+        
+        if @option.snapshot
+          raise "You must supply a diskname when using an existing snapshot" unless diskname
+          raise "The snapshot #{@option.snapshot} does not exist" unless @ec2.snapshots.exists?(@option.snapshot)
+          disk = Rudy::MetaData::Disk.get(@sdb, diskname)
+          
+          raise "The disk #{diskname} does not exist" unless disk
+          backup = Rudy::MetaData::Backup.new
+          backup.awsid = @option.snapshot
+          backup.time_stamp
+            
+          # Populate machine infos
+          [:zone, :environment, :role, :position].each do |n|
+            backup.send("#{n}=", @global.send(n)) if @global.send(n)
+          end
+        
+          # Populate disk infos
+          [:path, :size].each do |n|
+            backup.send("#{n}=", disk.send(n)) if disk.send(n)
+          end
+          
+          
+          Rudy::MetaData::Backup.save(@sdb, backup)
+          
+          puts backup.name
+          
+        else
+          volumes = @ec2.instances.volumes(machine[:aws_instance_id])
+          raise "The machine #{machine_name} does not have any volumes attached." if volumes.empty?
+          
+          puts "#{disks.size} Disk(s) defined with #{volumes.size} Volume(s) running"
+        
+          volumes.each do |volume|
+            print "Volume #{volume[:aws_id]}... "
+            disk = Rudy::MetaData::Disk.find_from_volume(@sdb, volume[:aws_id])
+            backup = Rudy::MetaData::Backup.new
+          
+            # TODO: Look for the disk based on the machine
+            raise "No disk associated to volume #{volume[:aws_id]}" unless disk 
+          
+            backup.volume = volume[:aws_id]
+
+            # Populate machine infos
+            [:zone, :environment, :role, :position].each do |n|
+              backup.send("#{n}=", @global.send(n)) if @global.send(n)
+            end
+
+            # Populate disk infos
+            [:path, :size].each do |n|
+              backup.send("#{n}=", disk.send(n)) if disk.send(n)
+            end
+            
+            backup.time_stamp
+            
+            raise "There was a problem creating the backup metadata" unless backup.valid?
+            
+            snap = @ec2.snapshots.create(volume[:aws_id])
+          
+            if !snap || !snap.is_a?(Hash)
+              puts "There was an unknown problem creating #{backup.name}. Continuing with the next volume..."
+              next
+            end
+            
+            backup.awsid = snap[:aws_id]
+
+            Rudy::MetaData::Backup.save(@sdb, backup)
+
+            puts backup.name
+            
+          end
+        end          
+      end
+      
+      
+    end
+  end
+end

data/lib/rudy/command/base.rb

@@ -0,0 +1,839 @@
+
+module Rudy
+  class UnknownInstance < RuntimeError; end
+end
+
+module Rudy
+  module Command
+    class NoCred < RuntimeError; end;
+    
+    class Base < Drydock::Command
+
+      attr_reader :scm
+  
+      attr_reader :rscripts
+      attr_reader :domains
+      attr_reader :machine_images
+      
+      attr_reader :config
+      
+      
+      def init
+        
+        
+        raise "PRODUCTION ACCESS IS DISABLED IN DEBUG MODE" if @global.environment == "prod" && Drydock.debug?
+        
+        @global.config ||= RUDY_CONFIG_FILE
+        
+        unless File.exists?(@global.config)
+          init_config_dir
+        end
+        
+        @config = Rudy::Config.new(@global.config, {:verbose => (@global.verbose > 0)} )
+        @config.look_and_load
+        
+        raise "There is no machine group configured" if @config.machines.nil?
+        raise "There is no AWS info configured" if @config.awsinfo.nil?
+        
+        
+        @global.accesskey ||= @config.awsinfo.accesskey || ENV['AWS_ACCESS_KEY']
+        @global.secretkey ||= @config.awsinfo.secretkey || ENV['AWS_SECRET_KEY'] || ENV['AWS_SECRET_ACCESS_KEY']
+        @global.account ||= @config.awsinfo.account || ENV['AWS_ACCOUNT_NUMBER'] 
+        
+        @global.cert ||= @config.awsinfo.cert || ENV['EC2_CERT']
+        @global.privatekey ||= @config.awsinfo.privatekey || ENV['EC2_PRIVATE_KEY']
+        
+        @global.cert = File.expand_path(@global.cert || '')
+        @global.privatekey = File.expand_path(@global.privatekey || '')
+        
+        @global.region ||= @config.defaults.region || DEFAULT_REGION
+        @global.zone ||= @config.defaults.zone || DEFAULT_ZONE
+        @global.environment ||= @config.defaults.environment || DEFAULT_ENVIRONMENT
+        @global.role ||= @config.defaults.role || DEFAULT_ROLE
+        @global.position ||= @config.defaults.position || DEFAULT_POSITION
+        @global.user ||= @config.defaults.user || DEFAULT_USER
+        
+        @global.local_user = ENV['USER'] || :user
+        @global.local_hostname = Socket.gethostname || :host
+        
+        
+        if @global.verbose > 1
+          puts "GLOBALS:"
+          @global.marshal_dump.each_pair do |n,v|
+            puts "#{n}: #{v}"
+          end
+          ["machines", "routines"].each do |type|
+            puts "#{$/*2}#{type.upcase}:"
+            val = @config.send(type).find_deferred(@global.environment, @global.role)
+            puts val.to_hash.to_yaml
+          end
+          puts
+        end
+        
+        
+        
+        # TODO: enforce home directory permissions
+        #if File.exists?(RUDY_CONFIG_DIR)
+        #  puts "Checking #{check_environment} permissions..."
+        #end
+        
+        if has_keys?
+          @ec2 = Rudy::AWS::EC2.new(@global.accesskey, @global.secretkey)
+          @sdb = Rudy::AWS::SimpleDB.new(@global.accesskey, @global.secretkey)
+          #@s3 = Rudy::AWS::SimpleDB.new(@global.accesskey, @global.secretkey)
+        end
+      end
+      protected :init
+      
+      def machine_data
+        machine_data = {
+          # Give the machine an identity
+          :zone => @global.zone,
+          :environment => @global.environment,
+          :role => @global.role,
+          :position => @global.position,
+          
+          # Add hosts to the /etc/hosts file
+          :hosts => {
+            :dbmaster => "127.0.0.1",
+          }
+        } 
+        
+        machine_data.to_hash
+      end
+      
+      
+      # Raises exceptions if the requested user does 
+      # not have a valid keypair configured. (See: EC2_KEYPAIR_*)
+      def check_keys
+        raise "No SSH key provided for #{@global.user}! (check #{RUDY_CONFIG_FILE})" unless has_keypair?
+        raise "SSH key provided but cannot be found! (check #{RUDY_CONFIG_FILE})" unless File.exists?(keypairpath)
+      end  
+      
+      def has_pem_keys?
+        (@global.cert       && File.exists?(@global.cert) && 
+         @global.privatekey && File.exists?(@global.privatekey))
+      end
+       
+      def has_keys?
+        (@global.accesskey && !@global.accesskey.empty? && @global.secretkey && !@global.secretkey.empty?)
+      end
+      
+      def keypairpath(name=nil)
+        name ||= @global.user
+        raise "No default user configured" unless name
+        kp = @config.machines.find(@global.environment, @global.role, :users, name, :keypair2)
+        kp ||= @config.machines.find(@global.environment, :users, name, :keypair)
+        kp ||= @config.machines.find(:users, name, :keypair)
+        kp &&= File.expand_path(kp)
+        kp
+      end
+      def has_keypair?(name=nil)
+        kp = keypairpath(name)
+        (!kp.nil? && File.exists?(kp))
+      end
+      
+      # Opens an SSH session. 
+      # <li>+host+ the hostname to connect to. Defaults to the machine specified
+      # by @global.environment, @global.role, @global.position.</li>
+      # <li>+b+ a block to execute on the host. Receives |session|</li>
+      # 
+      #      ssh do |session|
+      #        session.exec(cmd)
+      #      end
+      #
+      # See Net::SSH
+      #
+      def ssh(host=nil, &b)
+        host ||= machine_hostname
+        raise "No host provided for SSH" unless host
+        raise "No block provided for SSH" unless b
+        
+        Net::SSH.start(host, @global.user, :keys => [keypairpath]) do |session|
+          b.call(session)
+        end
+      end
+      
+      # Secure copy. 
+      # 
+      #      scp do |scp|
+      #        # upload a file to a remote server
+      #        scp.upload! "/local/path", "/remote/path"
+      #
+      #        # upload from an in-memory buffer
+      #        scp.upload! StringIO.new("some data to upload"), "/remote/path"
+      #
+      #        # run multiple downloads in parallel
+      #        d1 = scp.download("/remote/path", "/local/path")
+      #        d2 = scp.download("/remote/path2", "/local/path2")
+      #        [d1, d2].each { |d| d.wait }
+      #      end
+      #
+      def scp(host=nil, &b)
+        host ||= machine_hostname
+        raise "No host provided for scp" unless host
+        raise "No block provided for scp" unless b
+        
+        Net::SCP.start(host, @global.user, :keys => [keypairpath]) do |scp|
+          b.call(scp)
+        end
+      end
+      
+      # +name+ the name of the remote user to use for the remainder of the command
+      # (or until switched again). If no name is provided, the user will be revert
+      # to whatever it was before the previous switch. 
+      def switch_user(name=nil)
+        if name == nil && @switch_user_previous
+          @global.user = @switch_user_previous
+        elsif @global.user != name
+          puts "Remote commands will be run as #{name} user"
+          @switch_user_previous = @global.user
+          @global.user = name
+        end
+      end
+      
+      # Returns a hash of info for the requested machine. If the requested machine
+      # is not running, it will raise an exception. 
+      def find_current_machine
+        find_machine(machine_group)
+      end
+        
+      def find_machine(group)
+        machine_list = @ec2.instances.list(group)
+        machine = machine_list.values.first  # NOTE: Only one machine per group, for now...
+        raise "There's no machine running in #{group}" unless machine
+        raise "The primary machine in #{group} is not in a running state" unless machine[:aws_state] == 'running'
+        machine
+      end
+      
+      def machine_hostname(group=nil)
+        group ||= machine_group
+        find_machine(group)[:dns_name]
+      end
+      
+      def machine_group
+        [@global.environment, @global.role].join(RUDY_DELIM)
+      end
+      
+      def machine_image
+        ami = @config.machines.find_deferred(@global.environment, @global.role, :ami)
+        raise "There is no AMI configured for #{machine_group}" unless ami
+        ami
+      end
+      
+      def machine_address
+        @config.machines.find_deferred(@global.environment, @global.role, :address)
+      end
+      
+      # TODO: fix machine_group to include zone
+      def machine_name
+        [@global.zone, machine_group, @global.position].join(RUDY_DELIM)
+      end
+
+      def instance_id?(id=nil)
+        (id && id[0,2] == "i-")
+      end
+      
+      def image_id?(id=nil)
+        (id && id[0,4] == "ami-")
+      end
+      
+      def volume_id?(id=nil)
+        (id && id[0,4] == "vol-")
+      end
+      
+      def snapshot_id?(id=nil)
+        (id && id[0,5] == "snap-")
+      end
+      
+      
+      def wait_for_machine(id)
+        
+        print "Waiting for #{id} to become available"
+        STDOUT.flush
+        
+        while @ec2.instances.pending?(id)
+          sleep 2
+          print '.'
+          STDOUT.flush
+        end
+        
+        machine = @ec2.instances.get(id)
+        
+        puts " It's up!\a\a" # with bells
+        print "Waiting for SSH daemon at #{machine[:dns_name]}"
+        STDOUT.flush
+        
+        while !Rudy::Utils.service_available?(machine[:dns_name], 22)
+          print '.'
+          STDOUT.flush
+        end
+        puts " It's up!\a\a\a"
+
+      end
+      
+      
+      def device_to_path(machine, device)
+        # /dev/sdr            10321208    154232   9642688   2% /rilli/app
+        dfoutput = ssh_command(machine[:dns_name], keypairpath, @global.user, "df #{device} | tail -1").chomp
+        dfvals = dfoutput.scan(/(#{device}).+\s(.+?)$/).flatten  # ["/dev/sdr", "/rilli/app"]
+        dfvals.last
+      end
+      
+      # +action+ is one of: :shutdown, :start, :deploy
+      # +machine+ is a right_aws machine instance hash
+      def execute_disk_routines(machines, action)
+        machines = [machines] unless machines.is_a?( Array)
+        
+        puts "Running #{action.to_s.capitalize} DISK routines".att(:bright)
+        
+        disks = @config.machines.find_deferred(@global.environment, @global.role, :disks)
+        routines = @config.routines.find(@global.environment, @global.role, action, :disks)
+        
+        unless routines
+          puts "No #{action} disk routines."
+          return
+        end
+        
+        switch_user("root")
+        
+        machines.each do |machine|
+
+          unless machine[:aws_instance_id]
+            puts "Machine given has no instance ID. Skipping disks."
+            return
+          end
+        
+          unless machine[:dns_name]
+            puts "Machine given has no DNS name. Skipping disks."
+            return
+          end
+          
+          if routines.destroy
+            disk_paths = routines.destroy.keys
+            vols = @ec2.instances.volumes(machine[:aws_instance_id]) || []
+            puts "No volumes to destroy for (#{machine[:aws_instance_id]})" if vols.empty?
+            vols.each do |vol|
+              disk = Rudy::MetaData::Disk.find_from_volume(@sdb, vol[:aws_id])
+              if disk
+                this_path = disk.path
+              else
+                puts "No disk metadata for volume #{vol[:aws_id]}. Going old school..."
+                this_path = device_to_path(machine, vol[:aws_device])
+              end
+              
+              dconf = disks[this_path]
+              
+              unless dconf
+                puts "#{this_path} is not defined for this machine. Check your machines config."
+                next
+              end
+              
+              if disk_paths.member?(this_path) 
+              
+                unless disks.has_key?(this_path)
+                  puts "#{this_path} is not defined as a machine disk. Skipping..."
+                  next
+                end
+                
+                begin
+                  puts "Unmounting #{this_path}..."
+                  ssh_command machine[:dns_name], keypairpath, @global.user, "umount #{this_path}"
+                  sleep 3
+                rescue => ex
+                  puts "Error while unmounting #{this_path}: #{ex.message}"
+                  puts ex.backtrace if Drydock.debug?
+                  puts "We'll keep going..."
+                end
+                
+                begin
+                  
+                  if @ec2.volumes.attached?(disk.awsid)
+                    puts "Detaching #{vol[:aws_id]}"
+                    @ec2.volumes.detach(vol[:aws_id])
+                    sleep 3 # TODO: replace with something like wait_for_machine
+                  end
+                  
+                  puts "Destroying #{this_path} (#{vol[:aws_id]})"
+                  if @ec2.volumes.available?(disk.awsid)
+                    @ec2.volumes.destroy(vol[:aws_id])
+                  else
+                    puts "Volume is still attached (maybe a web server of database is running?)"
+                  end
+                  
+                  if disk
+                    puts "Deleteing metadata for #{disk.name}"
+                    Rudy::MetaData::Disk.destroy(@sdb, disk)
+                  end
+                
+                rescue => ex
+                  puts "Error while detaching volume #{vol[:aws_id]}: #{ex.message}"
+                  puts ex.backtrace if Drydock.debug?
+                  puts "Continuing..."
+                end
+                
+              end
+              puts
+              
+            end
+          
+          end
+          
+          
+          if routines.mount
+            disk_paths = routines.mount.keys
+            vols = @ec2.instances.volumes(machine[:aws_instance_id]) || []
+            puts "No volumes to mount for (#{machine[:aws_instance_id]})" if vols.empty?
+            vols.each do |vol|
+              disk = Rudy::MetaData::Disk.find_from_volume(@sdb, vol[:aws_id])
+              if disk
+                this_path = disk.path
+              else
+                puts "No disk metadata for volume #{vol[:aws_id]}. Going old school..."
+                this_path = device_to_path(machine, vol[:aws_device])
+              end
+              
+              next unless disk_paths.member?(this_path)
+                
+              dconf = disks[this_path]
+              
+              unless dconf
+                puts "#{this_path} is not defined for this machine. Check your machines config."
+                next
+              end
+              
+              
+              begin
+                unless @ec2.instances.attached_volume?(machine[:aws_instance_id], vol[:aws_device])
+                  puts "Attaching #{vol[:aws_id]} to #{machine[:aws_instance_id]}".att(:bright)
+                  @ec2.volumes.attach(machine[:aws_instance_id], vol[:aws_id],vol[:aws_device])
+                  sleep 3
+                end
+
+                puts "Mounting #{this_path} to #{vol[:aws_device]}".att(:bright)
+                ssh_command machine[:dns_name], keypairpath, @global.user, "mkdir -p #{this_path} && mount -t ext3 #{vol[:aws_device]} #{this_path}"
+
+                sleep 1
+              rescue => ex
+                puts "There was an error mounting #{this_path}: #{ex.message}"
+                puts ex.backtrace if Drydock.debug?
+              end
+              puts 
+            end
+          end
+        
+        
+          
+          if routines.restore
+            
+            routines.restore.each_pair do |path,props|
+              from = props[:from] || "unknown"
+              unless from.to_s == "backup"
+                puts "Sorry! You can currently only restore from backup. Check your routines config."
+                next
+              end
+              
+              begin 
+                puts "Restoring disk for #{path}"
+                
+                dconf = disks[path]
+                
+                unless dconf
+                  puts "#{path} is not defined for this machine. Check your machines config."
+                  next
+                end
+                    
+                zon = props[:zone] || @global.zone
+                env = props[:environment] || @global.environment
+                rol = props[:role] || @global.role
+                pos = props[:position] || @global.position
+                puts "Looking for backup from #{zon}-#{env}-#{rol}-#{pos}"
+                backup = find_most_recent_backup(zon, env, rol, pos, path)
+                
+                unless backup
+                  puts "No backups found"
+                  next
+                end
+                
+                puts "Found: #{backup.name}".att(:bright)
+                
+                disk = Rudy::MetaData::Disk.new
+                disk.path = path
+                [:region, :zone, :environment, :role, :position].each do |n|
+                  disk.send("#{n}=", @global.send(n)) if @global.send(n)
+                end
+                
+                disk.device = dconf[:device]
+                size = (backup.size.to_i > dconf[:size].to_i) ? backup.size : dconf[:size]
+                disk.size = size.to_i
+                
+                
+                if Rudy::MetaData::Disk.is_defined?(@sdb, disk)
+                  puts "The disk #{disk.name} already exists."
+                  puts "You probably need to define when to destroy the disk."
+                  puts "Skipping..."
+                  next
+                end
+
+                if @ec2.instances.attached_volume?(machine[:aws_instance_id], disk.device)
+                  puts "Skipping disk for #{disk.path} (device #{disk.device} is in use)"
+                  next
+                end
+
+                # NOTE: It's important to use Caesars' hash syntax b/c the disk property
+                # "size" conflicts with Hash#size which is what we'll get if there's no 
+                # size defined. 
+                unless disk.size.kind_of?(Integer)
+                  puts "Skipping disk for #{disk.path} (size not defined)"
+                  next
+                end
+
+                if disk.path.nil?
+                  puts "Skipping disk for #{disk.path} (no path defined)"
+                  next
+                end
+
+                unless disk.valid?
+                  puts "Skipping #{disk.name} (not enough info)"
+                  next
+                end
+
+                puts "Creating volume... (from #{backup.awsid})".att(:bright)
+                volume = @ec2.volumes.create(@global.zone, disk.size, backup.awsid)
+
+                puts "Attaching #{volume[:aws_id]} to #{machine[:aws_instance_id]}".att(:bright)
+                @ec2.volumes.attach(machine[:aws_instance_id], volume[:aws_id], disk.device)
+                sleep 3
+
+                puts "Mounting #{disk.device} to #{disk.path}".att(:bright)
+                ssh_command machine[:dns_name], keypairpath, @global.user, "mkdir -p #{disk.path} && mount -t ext3 #{disk.device} #{disk.path}"
+
+                puts "Creating disk metadata for #{disk.name}"
+                disk.awsid = volume[:aws_id]
+                Rudy::MetaData::Disk.save(@sdb, disk)
+
+                sleep 1
+              rescue => ex
+                puts "There was an error creating #{path}: #{ex.message}"
+                puts ex.backtrace if Drydock.debug?
+                if disk
+                  puts "Removing metadata for #{disk.name}"
+                  Rudy::MetaData::Disk.destroy(@sdb, disk)
+                end
+              end
+              puts
+            end
+          end
+          
+          
+          
+          if routines.create
+            routines.create.each_pair do |path,props|
+        
+              begin 
+                puts "Creating disk for #{path}"
+                
+                dconf = disks[path]
+
+                unless dconf
+                  puts "#{path} is not defined for this machine. Check your machines config."
+                  next
+                end
+                
+                disk = Rudy::MetaData::Disk.new
+                disk.path = path
+                [:region, :zone, :environment, :role, :position].each do |n|
+                  disk.send("#{n}=", @global.send(n)) if @global.send(n)
+                end
+                [:device, :size].each do |n|
+                  disk.send("#{n}=", dconf[n]) if dconf.has_key?(n)
+                end
+            
+                if Rudy::MetaData::Disk.is_defined?(@sdb, disk)
+                  puts "The disk #{disk.name} already exists."
+                  puts "You probably need to define when to destroy the disk."
+                  puts "Skipping..."
+                  next
+                end
+            
+                if @ec2.instances.attached_volume?(machine[:aws_instance_id], disk.device)
+                  puts "Skipping disk for #{disk.path} (device #{disk.device} is in use)"
+                  next
+                end
+            
+                # NOTE: It's important to use Caesars' hash syntax b/c the disk property
+                # "size" conflicts with Hash#size which is what we'll get if there's no 
+                # size defined. 
+                unless disk.size.kind_of?(Integer)
+                  puts "Skipping disk for #{disk.path} (size not defined)"
+                  next
+                end
+            
+                if disk.path.nil?
+                  puts "Skipping disk for #{disk.path} (no path defined)"
+                  next
+                end
+            
+                unless disk.valid?
+                  puts "Skipping #{disk.name} (not enough info)"
+                  next
+                end
+                        
+                puts "Creating volume... (#{disk.size}GB in #{@global.zone})".att(:bright)
+                volume = @ec2.volumes.create(@global.zone, disk.size)
+            
+                puts "Attaching #{volume[:aws_id]} to #{machine[:aws_instance_id]}".att(:bright)
+                @ec2.volumes.attach(machine[:aws_instance_id], volume[:aws_id], disk.device)
+                sleep 6
+                
+                puts "Creating the filesystem (mkfs.ext3 -F #{disk.device})".att(:bright)
+                ssh_command machine[:dns_name], keypairpath, @global.user, "mkfs.ext3 -F #{disk.device}"
+                sleep 3
+                
+                puts "Mounting #{disk.device} to #{disk.path}".att(:bright)
+                ssh_command machine[:dns_name], keypairpath, @global.user, "mkdir -p #{disk.path} && mount -t ext3 #{disk.device} #{disk.path}"
+              
+                puts "Creating disk metadata for #{disk.name}"
+                disk.awsid = volume[:aws_id]
+                Rudy::MetaData::Disk.save(@sdb, disk)
+              
+                sleep 1
+              rescue => ex
+                puts "There was an error creating #{path}: #{ex.message}"
+                if disk
+                  puts "Removing metadata for #{disk.name}"
+                  Rudy::MetaData::Disk.destroy(@sdb, disk)
+                end
+              end
+              puts
+            end
+          end
+        end
+      end
+      
+      def find_most_recent_backup(zon, env, rol, pos, path)
+        criteria = [zon, env, rol, pos, path]
+        (Rudy::MetaData::Backup.list(@sdb, *criteria) || []).first
+      end
+      
+      def execute_routines(machines, action, before_or_after)
+        machines = [machines] unless machines.is_a?( Array)
+        config = @config.routines.find_deferred(@global.environment, @global.role, :config) || {}        
+        config[:global] = @global.marshal_dump
+        config[:global].reject! { |n,v| n == :cert || n == :privatekey }
+        
+        # The config file contains settings from ~/.rudy/config 
+        #
+        #     routines do 
+        #       config do
+        #       end
+        #     end
+        #
+        config_file = "#{action}-config.yaml"
+        tf = Tempfile.new(config_file)
+        write_to_file(tf.path, config.to_hash.to_yaml, 'w')
+        puts "Running #{action.to_s.capitalize} #{before_or_after.to_s.upcase} routines".att(:bright)
+        machines.each do |machine|
+          
+          rscripts = @config.routines.find_deferred(@global.environment, @global.role, action, before_or_after) || []
+          rscripts = [rscripts] unless rscripts.is_a?(Array)
+          
+          puts "No scripts defined." if !rscripts || rscripts.empty?
+          
+          rscripts.each do |rscript|
+            user, script = rscript.shift
+            
+            switch_user(user) # scp and ssh will run as this user
+        
+            puts "Transfering #{config_file}..."
+            scp do |scp|
+              scp.upload!(tf.path, "~/#{config_file}") do |ch, name, sent, total|
+                "#{name}: #{sent}/#{total}"
+              end
+            end
+            ssh do |session|
+              puts "Running #{script}...".att(:bright)
+              session.exec!("chmod 700 ~/#{config_file}")
+              session.exec!("chmod 700 #{script}")
+              puts session.exec!("#{script}")
+          
+              puts "Removing remote copy of #{config_file}..."
+              session.exec!("rm ~/#{config_file}")
+            end
+            puts $/
+          end
+        end
+        
+        tf.delete     # remove local copy of config_file
+        #switch_user   # return to the requested user
+      end
+      
+      # Print a default header to the screen for every command.
+      # +cmd+ is the name of the command current running. 
+      def print_header(cmd=nil)
+        title = "RUDY v#{Rudy::VERSION}" unless @global.quiet
+        now_utc = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+        criteria = []
+        [:zone, :environment, :role, :position].each do |n|
+          val = @global.send(n)
+          next unless val
+          criteria << "#{n.to_s.slice(0,1).att :normal}:#{val.att :bright}"
+        end
+        puts '%s -- %s UTC' % [title, now_utc] unless @global.quiet
+        puts '[%s]' % criteria.join("  ") unless @global.quiet
+        
+        puts unless @global.quiet
+        
+        if (@global.environment == "prod") 
+          msg = without_indent %q(
+          =======================================================
+          =======================================================
+          !!!!!!!!!   YOU ARE PLAYING WITH PRODUCTION   !!!!!!!!!
+          =======================================================
+          =======================================================)
+          puts msg.colour(:red).bgcolour(:white).att(:bright), $/  unless @global.quiet
+          
+        end
+        
+        if Rudy.in_situ?
+          msg = %q(============ THIS IS EC2 ============)
+          puts msg.colour(:blue).bgcolour(:white).att(:bright), $/ unless @global.quiet
+        end
+        
+      end
+      
+      def print_footer
+        
+      end
+      
+
+
+      
+      def group_metadata(env=@global.environment, role=@global.role)
+        query = "['environment' = '#{env}'] intersection ['role' = '#{role}']"
+        @sdb.query_with_attributes(RUDY_DOMAIN, query)
+      end
+      
+      private 
+        # Print info about a running instance
+        # +inst+ is a hash
+        def print_instance(inst)
+          puts '-'*60
+          puts "Instance: #{inst[:aws_instance_id].att(:bright)} (AMI: #{inst[:aws_image_id]})"
+          [:aws_state, :dns_name, :private_dns_name, :aws_availability_zone, :aws_launch_time, :ssh_key_name].each do |key|
+             printf(" %22s: %s#{$/}", key, inst[key]) if inst[key]
+           end
+          printf(" %22s: %s#{$/}", 'aws_groups', inst[:aws_groups].join(', '))
+          puts
+        end
+        
+        def print_image(img)
+          puts '-'*60
+          puts "Image: #{img[:aws_id].att(:bright)}"
+          img.each_pair do |key, value|
+             printf(" %22s: %s#{$/}", key, value) if value
+           end
+          puts
+        end
+        
+        def print_disk(disk, backups=[])
+          puts '-'*60
+          puts "Disk: #{disk.name.att(:bright)}"
+          puts disk.to_s
+          puts "#{backups.size} most recent backups:", backups.collect { |back| "#{back.nice_time} (#{back.awsid})" }
+          puts
+        end
+        
+        
+        def print_volume(vol, disk)
+          puts '-'*60
+          puts "Volume: #{vol[:aws_id].att(:bright)} (disk: #{disk.name if disk})"
+          vol.each_pair do |key, value|
+             printf(" %22s: %s#{$/}", key, value) if value
+           end
+          puts
+        end
+        
+        # Print info about a a security group
+        # +group+ is an OpenStruct
+        def print_group(group)
+          puts '-'*60
+          puts "%12s: %s" % ['GROUP', group[:aws_group_name].att(:bright)]
+          puts 
+          
+          group_ip = {}
+          group[:aws_perms].each do |perm| 
+             (group_ip[ perm[:cidr_ips] ] ||= []) << "#{perm[:protocol]}/#{perm[:from_port]}-#{perm[:to_port]}"
+          end
+           
+          puts "%22s  %s" % ["source address/mask", "protocol/ports (from, to)"]
+          
+           
+          group_ip.each_pair do |ip, perms|
+            puts "%22s  %s" % [ip, perms.shift]
+            perms.each do |perm|
+              puts "%22s  %s" % ['', perm]
+            end
+            puts
+          end
+        end
+        
+        def init_config_dir
+          unless File.exists?(RUDY_CONFIG_DIR)
+            puts "Creating #{RUDY_CONFIG_DIR}"
+            Dir.mkdir(RUDY_CONFIG_DIR, 0700)
+          end
+
+          unless File.exists?(RUDY_CONFIG_FILE)
+            puts "Creating #{RUDY_CONFIG_FILE}"
+            rudy_config = without_indent %Q{
+              # Amazon Web Services 
+              # Account access indentifiers.
+              awsinfo do
+                account ""
+                accesskey ""
+                secretkey ""
+                privatekey "~/path/2/pk-xxxx.pem"
+                cert "~/path/2/cert-xxxx.pem"
+              end
+              
+              # Machine Configuration
+              # Specify your private keys here. These can be defined globally
+              # or by environment and role like in machines.rb.
+              machines do
+                ami "ami-0734d36e"    # gentoo-m1.small-v5
+                users do
+                  root :keypair => "path/2/root-private-key"
+                end
+              end
+              
+              # Routine Configuration
+              # Define stuff here that you don't want to be stored in version control. 
+              routines do
+                config do 
+                  # ...
+                end
+              end
+
+              # Global Defaults 
+              # Define the values to use unless otherwise specified on the command-line. 
+              defaults do
+                region "us-east-1" 
+                zone "us-east-1b"
+                environment "stage"
+                role "app"
+                position "01"
+                user ENV['USER']
+              end
+            }
+            write_to_file(RUDY_CONFIG_FILE, rudy_config, 'w')
+          end
+
+          #puts "Creating SimpleDB domain called #{RUDY_DOMAIN}"
+          #@sdb.domains.create(RUDY_DOMAIN)
+        end
+    end
+  end
+end
+
+