rudy 0.3.2 → 0.4.0

data/lib/rudy.rb

@@ -1,29 +1,57 @@
 
-require 'right_aws'
-require 'stringio'
-require 'ostruct'
-require 'yaml'
+#
+# No Ruby 1.9.1 support. Only 1.8.x for now :[
+unless RUBY_VERSION < "1.9"
+  puts "Sorry! We're using the right_aws gem and it doesn't support Ruby 1.9 (md5 error)."
+  exit 1
+end
+
+
+begin
+  require 'digest/md5'
+  require 'right_aws'
+  require 'stringio'
+  require 'ostruct'
+  require 'yaml'
+  require 'socket'
+  require 'tempfile'
+
+  require 'console'
+  require 'storable'
+
+  require 'net/ssh'
+  require 'net/ssh/gateway'
+  require 'net/ssh/multi'
+  require 'net/scp'
+  
+rescue LoadError => ex
+  puts "Problem requiring: #{ex.message}"
+  exit 1
+end
+
 
-require 'console'
-require 'storable'
 
 module Rudy #:nodoc:
-  RUDY_DOMAIN = ENV['RUDY_DOMAIN'] || "rudy_state"
-  RUDY_DELIM  = ENV['RUDY_DELIM'] || '-'
-  RUDY_CONFIG = File.join(ENV['HOME'] || ENV['USERPROFILE'], '.rudy')
+  RUDY_DOMAIN = "rudy_state"
+  RUDY_DELIM  = '-'
+  
+  RUDY_CONFIG_DIR = File.join(ENV['HOME'] || ENV['USERPROFILE'], '.rudy')
+  RUDY_CONFIG_FILE = File.join(RUDY_CONFIG_DIR, 'config')
   
-  DEFAULT_REGION = ENV['EC2_DEFAULT_REGION'] || 'us-east-1'
-  DEFAULT_ZONE = ENV['EC2_DEFAULT_ZONE'] || 'us-east-1b'
-  DEFAULT_ENVIRONMENT = ENV['EC2_DEFAULT_ENVIRONMENT'] || 'stage'
-  DEFAULT_ROLE = ENV['EC2_DEFAULT_ROLE'] || 'app'
-  DEFAULT_POSITION = ENV['EC2_DEFAULT_POSITION'] || '01'
+  DEFAULT_REGION = 'us-east-1'
+  DEFAULT_ZONE = 'us-east-1b'
+  DEFAULT_ENVIRONMENT = 'stage'
+  DEFAULT_ROLE = 'app'
+  DEFAULT_POSITION = '01'
   
-  DEFAULT_USER = ENV['EC2_DEFAULT_USER'] || 'rudy'
+  DEFAULT_USER = 'rudy'
+  
+  SUPPORTED_SCM_NAMES = [:svn, :git]
   
   module VERSION #:nodoc:
     MAJOR = 0.freeze unless defined? MAJOR
-    MINOR = 3.freeze unless defined? MINOR
-    TINY  = 2.freeze unless defined? TINY
+    MINOR = 4.freeze unless defined? MINOR
+    TINY  = 0.freeze unless defined? TINY
     def self.to_s
       [MAJOR, MINOR, TINY].join('.')
     end
@@ -41,43 +69,18 @@ module Rudy #:nodoc:
   def self.in_situ?
     File.exists?('/etc/ec2/instance-id')
   end
-  
-  class Config < Storable
-    
-    attr_accessor :path
-    
-    field :userdata => Hash
-
-    def initialize(args={:path => nil})
-      @path = args[:path] || RUDY_CONFIG
-      @userdata = {
-        'default' => {
-        }
-      }
-    end
-
-    def get(name)
-
-    end
-
-    def exists?
-      File.exists?(@path)
-    end
-  end
 end
 
 require 'rudy/aws'
+require 'rudy/config'
 require 'rudy/metadata'
-require 'rudy/scm/svn'
 require 'rudy/utils'
 require 'rudy/command/base'
 
-# Autoload Command and MetaData classes
+# Require Command, MetaData, and SCM classes
 begin
-  Dir.glob(File.join(RUDY_LIB, 'rudy', 'command', "*.rb")).each do |path|
-    require path
-  end
-  Dir.glob(File.join(RUDY_LIB, 'rudy', 'metadata', "*.rb")).each do |path|
+  # TODO: Use autoload
+  Dir.glob(File.join(RUDY_LIB, 'rudy', '{command,metadata,scm}', "*.rb")).each do |path|
     require path
   end
 rescue LoadError => ex
@@ -93,7 +96,7 @@ end
 #    end
 #
 def capture(stream)
-  raise "We can only capture STDOUT or STDERR" unless stream == :stdout || stream == :stderr
+  #raise "We can only capture STDOUT or STDERR" unless stream == :stdout || stream == :stderr
   
   # I'm using this to trap the annoying right_aws "peer certificate" warning.
   # TODO: discover source of annoying right_aws warning and give it a hiding.
@@ -110,7 +113,19 @@ def capture(stream)
 end
 
 
+def write_to_file(filename, content, type)
+  type = (type == :append) ? 'a' : 'w'
+  f = File.open(filename,type)
+  f.puts content
+  f.close
+end
+
 def are_you_sure?(len=3)
+  if Drydock.debug?
+    puts 'DEBUG: skipping "are you sure" check'
+    return true 
+  end
+  
   if STDIN.tty? # Only ask a question if there's a human 
     challenge = strand len
     STDOUT.print "Are you sure? To continue type \"#{challenge}\": "
@@ -137,26 +152,27 @@ def strand( len=8, safe=true )
    newpass
 end
 
-def sh(command, chdir=false)
+def sh(command, chdir=false, verbose=false)
   prevdir = Dir.pwd
   Dir.chdir chdir if chdir
-  puts command if @verbose > 0
+  puts command if verbose
   system(command)
   Dir.chdir prevdir if chdir
 end
 
-# TODO: Net::SSH
-def ssh(host, keypair, user, command=false, chdir=false, verbose=false, printonly=false)
-  puts "CONNECTING TO #{host}..."
+def ssh_command(host, keypair, user, command=false, printonly=false, verbose=false)
+  #puts "CONNECTING TO #{host}..."
   cmd = "ssh -q -i #{keypair} #{user}@#{host} "
-  command = "cd #{chdir} && #{command}" if chdir 
   cmd += " '#{command}'" if command
   puts cmd if verbose
-  printonly ? (puts cmd) : system(cmd)
+  return cmd if printonly
+  # backticks returns STDOUT
+  # exec replaces current process (it's just like running ssh)
+  (command) ? `#{cmd}` : Kernel.exec(cmd)
 end
 
 
-def scp(host, keypair, user, paths, to_path, to_local=false, verbose=false, printonly=false)
+def scp_command(host, keypair, user, paths, to_path, to_local=false, verbose=false, printonly=false)
   
   paths = [paths] unless paths.is_a?(Array)
   from_paths = ""
@@ -181,6 +197,13 @@ def scp(host, keypair, user, paths, to_path, to_local=false, verbose=false, prin
 end
 
 
+# Returns +str+ with the average leading indentation removed. 
+# Useful for keeping inline codeblocks spaced with code. 
+def without_indent(str)
+  lines = str.split($/)
+  lspaces = (lines.inject(0) {|total,line| total += (line.scan(/^\s+/).first || '').size } / lines.size) + 1
+  lines.collect { |line| line.gsub(/^\s{#{lspaces}}/, '') }.join($/)
+end
 
 
 

data/lib/rudy/aws/ec2.rb

@@ -57,7 +57,16 @@ module Rudy::AWS
     class Volumes
       include Rudy::AWS::ObjectBase
       
-      
+      # [{:aws_device=>"/dev/sdr",
+      # :aws_attachment_status=>"attached",
+      # :snapshot_id=>nil,
+      # :aws_id=>"vol-6811f601",
+      # :aws_attached_at=>Wed Mar 11 07:06:44 UTC 2009,
+      # :aws_status=>"in-use",
+      # :aws_instance_id=>"i-0b2ab662",
+      # :aws_created_at=>Tue Mar 10 18:55:18 UTC 2009,
+      # :zone=>"us-east-1b",
+      # :aws_size=>10}]
       def list
         list = @aws.describe_volumes() || []
         list.select { |v| v[:aws_status] != "deleting" }
@@ -86,7 +95,29 @@ module Rudy::AWS
         false
       end
       
+      def get(vol_id)
+        list = @aws.describe_volumes(vol_id) || []
+        list.first
+      end
+      
+      def deleting?(vol_id)
+        return false unless vol_id
+        vol = get(vol_id)
+        (vol && vol[:aws_status] == "deleting")
+      end
       
+      def available?(vol_id)
+        return false unless vol_id
+        vol = get(vol_id)
+        (vol && vol[:aws_status] == "available")
+      end
+      
+      def attached?(vol_id)
+        return false unless vol_id
+        vol = get(vol_id)
+        (vol && vol[:aws_status] == "in-use")
+      end
+        
     end
     
     class Instances
@@ -95,11 +126,15 @@ module Rudy::AWS
       def destroy(*list)
         begin
           @aws.terminate_instances(list.flatten)
-        rescue RightAws::AwsError => ex
-          raise UnknownInstance.new
+        #rescue RightAws::AwsError => ex
+        #  raise UnknownInstance.new
         end
       end
       
+      def restart(*list)
+        @aws.reboot_instances(list.flatten)
+      end
+      
       def attached_volume?(id, device)
         list = volumes(id)
         list.each do |v|
@@ -113,6 +148,10 @@ module Rudy::AWS
         list.select { |v| v[:aws_status] != "deleting" && v[:aws_instance_id] === id }
       end
       
+      def device_volume(id, device)
+        volumes.select { |v| v[:aws_device] === device }
+      end
+      
       def create(ami, group, keypair_name, user_data, zone)
         @aws.run_instances(ami, 1, 1, [group], keypair_name, user_data, 'public', nil, nil, nil, zone)
       end
@@ -121,6 +160,24 @@ module Rudy::AWS
       # that matches +filter+. 
       # Returns a hash. The keys are instance IDs and the values are a hash
       # of attributes associated to that instance. 
+      # {:aws_state_code=>"16",
+      # :private_dns_name=>"domU-12-31-38-00-51-F1.compute-1.internal",
+      # :aws_instance_type=>"m1.small",
+      # :aws_reason=>"",
+      # :ami_launch_index=>"0",
+      # :aws_owner=>"207436219441",
+      # :aws_launch_time=>"2009-03-11T06:55:00.000Z",
+      # :aws_kernel_id=>"aki-a71cf9ce",
+      # :ssh_key_name=>"rilli-sexytime",
+      # :aws_reservation_id=>"r-66f5710f",
+      # :aws_state=>"running",
+      # :aws_ramdisk_id=>"ari-a51cf9cc",
+      # :aws_instance_id=>"i-0b2ab662",
+      # :aws_groups=>["rudydev-app"],
+      # :aws_availability_zone=>"us-east-1b",
+      # :aws_image_id=>"ami-daca2db3",
+      # :aws_product_codes=>[],
+      # :dns_name=>"ec2-67-202-9-30.compute-1.amazonaws.com"}
       def list(filter='.')
         filter = filter.to_s.downcase.tr('_|-', '.') # treat dashes, underscores as one
         # Returns an array of hashes with the following keys:
@@ -138,6 +195,7 @@ module Rudy::AWS
       end
       
       def get(inst_id)
+        # This is ridiculous. Send inst_id to describe volumes
         instance = {}
         list.each_pair do |id, hash|
           next unless inst_id == id
@@ -178,8 +236,8 @@ module Rudy::AWS
       
       # Create a new EC2 security group
       # Returns true/false whether successful
-      def create(name, desc='')
-        @aws.create_security_group(name, desc)
+      def create(name, desc=nil)
+        @aws.create_security_group(name, desc || "Group #{name}")
       end
       
       # Delete an EC2 security group

data/lib/rudy/command/addresses.rb

@@ -4,25 +4,31 @@
 module Rudy
   module Command
     class Addresses < Rudy::Command::Base
-      
-      def associate_address(address)
-        raise "You did not supply an instance ID" unless instance
-        inst = @ec2.instances.get(instance)
-        raise "Instance #{inst[:aws_instance_id]} is not running!" unless inst
+
+
+      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 "You have not supplied an IP addresses" unless address
-        raise "That's not an elastic IP you own!" unless @ec2.addresses.valid?(address)
-        raise "#{address} is already associated!" if @ec2.addresses.associated?(address)
+        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)
         
-        puts "Associating #{address} to #{inst[:aws_groups]}: #{inst[:dns_name]}"
-        @ec2.addresses.associate(inst[:aws_instance_id], 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
         
-        print_addresses
+        addresses
       end
       
-      def print_addresses
+      def addresses
         puts "Elastic IP mappings:"
         @ec2.addresses.list.each do |address|
           print "IP: #{address[:public_ip]} "
@@ -34,7 +40,6 @@ module Rudy
         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