rudy 0.3.2 → 0.4.0

data/lib/rudy/command/base.rb

@@ -8,138 +8,229 @@ module Rudy
     class NoCred < RuntimeError; end;
     
     class Base < Drydock::Command
-      
-      attr_accessor :access_key
-      attr_accessor :secret_key
-      attr_accessor :accnt_num
-      
-      attr_accessor :ec2_cert
-      attr_accessor :ec2_private_key
-      attr_accessor :keypairs
-      
-      attr_reader :user
-      attr_reader :environment
-      attr_reader :role
-      attr_reader :position
-      
-      attr_reader :zone
-      attr_reader :region
-      
+
       attr_reader :scm
-      
+  
       attr_reader :rscripts
       attr_reader :domains
       attr_reader :machine_images
       
       attr_reader :config
       
+      
       def init
-        @access_key = ENV['AWS_ACCESS_KEY'] unless @access_key
-        @secret_key = ENV['AWS_SECRET_KEY'] unless @secret_key
-        @account_num = ENV['AWS_ACCOUNT_NUMBER'] unless @account_num
         
-        @ec2_cert        = ENV['EC2_CERT'] unless @ec2_cert
-        @ec2_private_key = ENV['EC2_PRIVATE_KEY'] unless @ec2_private_key
         
-        if ENV['RUDY_SVN_BASE']
-          @scm = Rudy::SCM::SVN.new(ENV['RUDY_SVN_BASE'])
-        end
-
-        @config = File.exists?(RUDY_CONFIG) ? Rudy::Config.from_file(RUDY_CONFIG) : Rudy::Config.new
-        
-        @region ||= DEFAULT_REGION
-        @zone ||= DEFAULT_ZONE
-        @environment ||= DEFAULT_ENVIRONMENT
-        @role ||= DEFAULT_ROLE
-        @position ||= DEFAULT_POSITION
-        
-        @user ||= DEFAULT_USER
-        
-        @keypairs = {}
-        ENV.keys.select { |key| key.match /EC2_KEYPAIR/i }.each do |key|
-          ec2, keypair, env, role, user = key.split '_' # EC2_KEYPAIR_STAGE_APP_RUDY
-          raise "#{key} is malformed." unless env && role && user
-          new_key = "#{env}-#{role}-#{user}".downcase
-          @keypairs[new_key] = ENV[key]
-        end
+        raise "PRODUCTION ACCESS IS DISABLED IN DEBUG MODE" if @global.environment == "prod" && Drydock.debug?
         
-        @rscripts = {}
-        ENV.keys.select { |key| key.match /RUDY_RSCRIPT/i }.each do |key|
-          rudy, rscript, env, role, user = key.split '_' # RUDY_RSCRIPT_STAGE_APP_ROOT
-          raise "#{key} is malformed." unless env && role && user
-          new_key = "#{env}-#{role}-#{user}".downcase
-          @rscripts[new_key] = ENV[key]
-        end
+        @global.config ||= RUDY_CONFIG_FILE
         
-        @machine_images = {}
-        ENV.keys.select { |key| key.match /EC2_AMI_/i }.each do |key|
-          ec2, ami, env, role = key.split '_' # RUDY_RSCRIPT_STAGE_APP_ROOT
-          raise "#{key} is malformed." unless env && role
-          new_key = "#{env}-#{role}".downcase
-          @machine_images[new_key] = ENV[key]
+        unless File.exists?(@global.config)
+          init_config_dir
         end
         
-        if @verbose > 1 && Drydock.debug?
-          instance_variables.each do |var|
-            puts "#{var}: #{instance_variable_get(var)}"
+        @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
+
+        check_keys
+        
+        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
         
-        if @access_key && @secret_key
-          @ec2 = Rudy::AWS::EC2.new(@access_key, @secret_key)
-          # RightAws::SdbInterface is on thin ice. No select support! Or sort!
-          @sdb = Rudy::AWS::SimpleDB.new(@access_key, @secret_key)
-          #@s3 = Rudy::AWS::SimpleDB.new(@access_key, @secret_key)
+        
+        
+        # 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 #{keypairname}!" unless has_keypair?(keypairname)
-        raise "SSH key provided but cannot be found! (#{keypairname}: #{keypairpath})" unless File.exists?(keypairpath)
+        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?
-        (@ec2_cert        && File.exists?(@ec2_cert) && 
-         @ec2_private_key && File.exists?(@ec2_private_key))
+        (@global.cert       && File.exists?(@global.cert) && 
+         @global.privatekey && File.exists?(@global.privatekey))
       end
        
       def has_keys?
-        (@access_key && @secret_key)
+        (@global.accesskey && !@global.accesskey.empty? && @global.secretkey && !@global.secretkey.empty?)
       end
       
-      def has_keypair?(name)
-        (has_keypairs? && @keypairs.has_key?(name))
+      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
       
-      def has_keypairs?
-        (!@keypairs.empty?)
+      # 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
       
-      def machine_group
-        [@environment, @role].join(RUDY_DELIM)
+      # 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
       
-      def machine_image
-        @machine_images[machine_group]
+      # +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
       
-      # TODO: fix machine_group to include zone
-      def machine_name
-        [@zone, machine_group, @position].join(RUDY_DELIM)
+      # 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 keypairname
-        [machine_group, user].join(RUDY_DELIM)
+      def machine_group
+        [@global.environment, @global.role].join(RUDY_DELIM)
       end
       
-      def keypairpath
-        return unless has_keypair?(keypairname)
-        @keypairs[keypairname]
+      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
@@ -157,77 +248,459 @@ module Rudy
       end
       
       
-      def do_dirty_disk_volume_deeds(disk, machine)
-        puts "-"*30
-        puts "Disk: #{disk.name} (path: #{disk.path}, device: #{disk.device})"
-        puts 
+      def wait_for_machine(id)
+        
+        print "Waiting for #{id} to become available"
+        STDOUT.flush
         
-        if @ec2.instances.attached_volume?(machine[:aws_instance_id], disk.device)
-          raise "#{disk.device} is already in use on #{machine[:aws_instance_id]}! (Try umounting it)"
+        while @ec2.instances.pending?(id)
+          sleep 2
+          print '.'
+          STDOUT.flush
         end
         
-        if !disk.awsid || (disk.awsid && !@ec2.volumes.exists?(disk.awsid))
-          disk = Rudy::MetaData::Disk.update_volume(@sdb, @ec2, disk, machine)
+        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)
         
-        raise "Unknown error creating volume! #{disk.awsid}" unless disk && disk.awsid
+        puts "Running #{action.to_s.capitalize} DISK routines".att(:bright)
         
-        puts "Attaching #{disk.awsid} to #{machine[:aws_instance_id]}"
-        @ec2.volumes.attach(machine[:aws_instance_id], disk.awsid, disk.device)
-        sleep 2
+        disks = @config.machines.find_deferred(@global.environment, @global.role, :disks)
+        routines = @config.routines.find(@global.environment, @global.role, action, :disks)
         
-        @user = "root"
+        unless routines
+          puts "No #{action} disk routines for #{machine_group}"
+          return
+        end
         
-        if disk.raw_volume
-          puts "Creating the filesystem (mkfs.ext3 -F #{disk.device})"
-          capture(:stdout) do
-            ssh machine[:dns_name], keypairpath, user, "mkfs.ext3 -F #{disk.device}"
+        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
           
-          puts "Saving disk metadata"
-          disk.raw_volume = false
-          Rudy::MetaData::Disk.save(@sdb, disk)
+          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
           
-          sleep 2
-        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
         
-        puts "Mounting #{disk.device} to #{disk.path}"
-        capture(:stdout) do
-          ssh machine[:dns_name], keypairpath, user, "mkdir -p #{disk.path} && mount -t ext3 #{disk.device} #{disk.path}"
-        end
-        sleep 1
         
+          
+          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|
+          puts "Machine Group: #{machine_group}"
+          puts "Hostname: #{machine[:dns_name]}"
+          
+          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}"
-        now_utc = Time.now.utc
+        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 = instance_variable_get("@#{n}")
-          criteria << "#{n.to_s.color :normal}:#{val.color :bright}"
+          val = @global.send(n)
+          next unless val
+          criteria << "#{n.to_s.slice(0,1).att :normal}:#{val.att :bright}"
         end
-        puts '%s -- %s' % [title, criteria.join(", ")]
-        puts 'UTC: %s' % now_utc.strftime("%Y-%m-%d %H:%M:%S") 
-        puts
-        
-        if (@environment == "prod") 
-          msg = %q(=======================================================
-=======================================================
-!!!!!!!!!   YOU ARE PLAYING WITH PRODUCTION   !!!!!!!!!
-=======================================================
-=======================================================)
-          puts msg.color(:bright, :red, :bg_white), $/  unless @quiet
+        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.color(:bright, :blue, :bg_white), $/ unless @quiet
+          puts msg.colour(:blue).bgcolour(:white).att(:bright), $/ unless @global.quiet
         end
         
       end
@@ -236,19 +709,10 @@ module Rudy
         
       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
-        machine_list = @ec2.instances.list(machine_group)
-        machine = machine_list.values.first  # NOTE: Only one machine per group, for now...
-        raise "There's no machine running in #{machine_group}" unless machine
-        raise "The primary machine in #{machine_group} is not in a running state" unless machine[:aws_state] == 'running'
 
-        machine
-      end
 
       
-      def group_metadata(env=@environment, role=@role)
+      def group_metadata(env=@global.environment, role=@global.role)
         query = "['environment' = '#{env}'] intersection ['role' = '#{role}']"
         @sdb.query_with_attributes(RUDY_DOMAIN, query)
       end
@@ -258,7 +722,7 @@ module Rudy
         # +inst+ is a hash
         def print_instance(inst)
           puts '-'*60
-          puts "Instance: #{inst[:aws_instance_id]} (AMI: #{inst[:aws_image_id]})"
+          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
@@ -268,7 +732,7 @@ module Rudy
         
         def print_image(img)
           puts '-'*60
-          puts "Image: #{img[:aws_id]}"
+          puts "Image: #{img[:aws_id].att(:bright)}"
           img.each_pair do |key, value|
              printf(" %22s: %s#{$/}", key, value) if value
            end
@@ -277,7 +741,7 @@ module Rudy
         
         def print_disk(disk, backups=[])
           puts '-'*60
-          puts "Disk: #{disk.name}"
+          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
@@ -286,7 +750,7 @@ module Rudy
         
         def print_volume(vol, disk)
           puts '-'*60
-          puts "Volume: #{vol[:aws_id]} (disk: #{disk.name})"
+          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
@@ -297,7 +761,7 @@ module Rudy
         # +group+ is an OpenStruct
         def print_group(group)
           puts '-'*60
-          puts "%12s: %s" % ['GROUP', group[:aws_group_name]]
+          puts "%12s: %s" % ['GROUP', group[:aws_group_name].att(:bright)]
           puts 
           
           group_ip = {}
@@ -317,7 +781,61 @@ module Rudy
           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
+                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
+end
+
+