rudy 0.3.2 → 0.4.0

data/lib/rudy/command/config.rb

@@ -0,0 +1,77 @@
+
+
+module Rudy
+  module Command
+    class Config < Rudy::Command::Base
+      
+      # We force the Command::Base#print_header to be quiet
+      def print_header
+        @global.quiet = true
+        super
+      end
+      
+      
+      # Display configuration from the local user data file (~/.rudy/config).
+      # This config contains user data which is sent to each EC2 when 
+      # it's created. 
+      #
+      # The primary purpose of this command is to give other apps a way
+      # to check various configuration values. (This is mostly useful for
+      # debugging and checking configuration on an instance itself).
+      #
+      # It will return the most specific configuration available. If the 
+      # attribute isn'e found it will check each parent for the same attribute. 
+      # i.e. if [prod][app][ami] is not available, it will check [prod][ami]
+      # and then [ami]. 
+      #
+      #     # Display the value for a specific machine.
+      #     $ rudy -e prod -r db config param-name
+      #
+      #     # Display all configuration
+      #     $ rudy config --all
+      #
+      def config
+        return if @config.nil? 
+        puts "Config: #{@config.paths}" if @global.verbose > 0
+        
+        which = @option.defaults ? @global.user : machine_name
+        puts "Machine: #{which}" if @global.verbose > 0
+        puts "User: #{@global.user}" if @global.verbose > 0
+        
+        return if @config.empty?
+        
+        # We need to check whether we're running on a human's computer
+        # or within EC2 (we call that running "in-situ"). The userdata
+        # available when running in-situ is in a different format.
+        if Rudy.in_situ?
+          
+          
+        else
+          
+          if @option.all
+            y @config.machines.to_hash
+            y @config.routines.to_hash
+          elsif @option.defaults
+            y @config.defaults.to_hash
+          else
+            env, rol, usr, att = @global.environment, @global.role, @global.user, @argv.name
+            val = @config.machines.find_deferred(env, rol, usr, att) || ''
+            puts (val.is_a?(String)) ? val : val.to_hash.to_yaml
+          end
+          
+          #name = @argv.first
+          #if name && @config.userdata.has_key?(which) 
+          #  value = @config.userdata[which][name.to_s]
+          #  puts value if value
+          #elsif @option.all
+          #  puts @config.to_yaml
+          #else
+          #  value = @config.userdata[which] 
+          #  puts value.to_yaml if value
+          #end
+        end
+        
+      end
+    end
+  end
+end

data/lib/rudy/command/deploy.rb

@@ -0,0 +1,12 @@
+
+
+
+
+module Rudy
+  module Command
+    class Deploy < Rudy::Command::Base
+      
+    end
+  end
+end
+  

data/lib/rudy/command/disks.rb

@@ -4,240 +4,210 @@ module Rudy
   module Command
     class Disks < Rudy::Command::Base
       
-      def print_backups
-        criteria = [@zone]
-        criteria += [@environment, @role] unless @all
-        
-        Rudy::MetaData::Backup.list(@sdb, *criteria).each do |backup|
-          puts "%s (%s)" % [backup.name, backup.awsid]
+      def disk
+        criteria = [@global.zone]
+        criteria += [@global.environment, @global.role] unless @option.all
+        Rudy::MetaData::Disk.list(@sdb, *criteria).each do |disk|
+          backups = Rudy::MetaData::Backup.for_disk(@sdb, disk, 2)
+          print_disk(disk, backups)
         end
       end
+
+      def create_disk_valid?
+        raise "No filesystem path specified" unless @option.path
+        raise "No size specified" unless @option.size
+        @instances = @ec2.instances.list(machine_group)
+        raise "There are no instances running in #{machine_group}" if !@instances || @instances.empty?
+        true
+      end
       
-      # Check for backups pointing to snapshots that don't exist. 
-      def sync_backups
-        criteria = [@zone]
-        criteria += [@environment, @role] unless @all
+      def create_disk
+        puts "Creating #{@option.path} for #{machine_group}"
+        switch_user("root")
+        exit unless are_you_sure?(2) 
+        machine = @instances.values.first # NOTE: DANGER! Should handle position.
         
-        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)
+        disk = Rudy::MetaData::Disk.new
+        [:region, :zone, :environment, :role, :position].each do |n|
+          disk.send("#{n}=", @global.send(n)) if @global.send(n)
         end
-        
-        if to_be_deleted.empty?
-          puts "All backups are in-sync with snapshots. Nothing to do."
-          return
+        [:path, :device, :size].each do |n|
+          disk.send("#{n}=", @option.send(n)) if @option.send(n)
         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
+        raise "Not enough info was provided to define a disk (#{disk.name})" unless disk.valid?
+        raise "The device #{disk.device} is already in use on that machine" if Rudy::MetaData::Disk.is_defined?(@sdb, disk)
+        # TODO: Check disk path
+        puts "Creating disk metadata for #{disk.name}"
         
-        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!"
+        puts "Creating volume... (#{disk.size}GB in #{@global.zone})"
+        volume = @ec2.volumes.create(@global.zone, disk.size)
+        sleep 3
+        
+        disk.awsid = volume[:aws_id]
+        disk.raw_volume = true    # This value is not saved. 
+        Rudy::MetaData::Disk.save(@sdb, disk)
+        
+        execute_attach_disk(disk, machine)
+        
+        print_disk(disk)
       end
       
       
-      def destroy_backup(name)
-        puts "Destroying #{name}"
-        begin
-          backup = Rudy::MetaData::Backup.get(@sdb, name)
-        rescue => ex
-          puts "Error deleteing backup: #{ex.message}"
-        end
-        
-        return unless backup
+      def destroy_disk_valid?
+        raise "No disk specified" if argv.empty?
         
-        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)
+        if @argv.diskname =~ /^disk-/          
+          @disk = Rudy::MetaData::Disk.get(@sdb, @argv.diskname)
+        else
+          disk = Rudy::MetaData::Disk.new
+          [:zone, :environment, :role, :position].each do |n|
+            disk.send("#{n}=", @global.send(n)) if @global.send(n)
+          end
+          disk.path = @argv.diskname
+          @disk = Rudy::MetaData::Disk.get(@sdb, disk.name)
         end
-        puts "Done."
+
+        raise "No such disk: #{@argv.diskname}" unless @disk
+        raise "The disk is in another machine environment" unless @global.environment.to_s == @disk.environment.to_s
+        raise "The disk is in another machine role" unless @global.role.to_s == @disk.role.to_s
+        @instances = @ec2.instances.list(machine_group)
+        true
       end
       
-      def create_backup(diskname=nil)
-        machine = find_current_machine
+      def destroy_disk
+        puts "Destroying #{@disk.name} and #{@disk.awsid}"
+        switch_user("root")
+        exit unless are_you_sure?(5)
         
-        disks = Rudy::MetaData::Disk.list(@sdb, machine[:aws_availability_zone], @environment, @role, @position)
-        raise "The machine #{machine_name} does not have any disk metadata" if disks.empty?
+        machine = @instances.values.first # NOTE: DANGER! Should handle position. 
         
-        puts "Machine: #{machine_name}"
+        execute_unattach_disk(@disk, machine)
+        execute_destroy_disk(@disk, machine)
         
-        if @snapshot
-          raise "You must supply a diskname when using an existing snapshot" unless diskname
-          raise "The snapshot #{@snapshot} does not exist" unless @ec2.snapshots.exists?(@snapshot)
-          disk = Rudy::MetaData::Disk.get(@sdb, diskname)
-          
-          raise "The disk #{diskname} does not exist" unless disk
-          backup = Rudy::MetaData::Backup.new
-          backup.awsid = @snapshot
-          backup.time_stamp
-            
-          # Populate machine infos
-          [:zone, :environment, :role, :position].each do |n|
-            val = instance_variable_get("@#{n}")
-            backup.send("#{n}=", val) if val
-          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.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]
-          
-            snap = @ec2.snapshots.create(volume[:aws_id])
-          
-            backup.awsid = snap[: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.time_stamp
+        puts "Done."
+      end
 
-            # Populate machine infos
-            [:zone, :environment, :role, :position].each do |n|
-              val = instance_variable_get("@#{n}")
-              backup.send("#{n}=", val) if val
-            end
+      def attach_disk_valid?
+        destroy_disk_valid?
+        raise "There are no instances running in #{machine_group}" if !@instances || @instances.empty?
+        true
+      end
+      
+      def attach_disk
+        puts "Attaching #{name}"
+        switch_user("root")
+        are_you_sure?(4)
+  
+        machine = @instances.values.first  # AK! Assumes single machine
+        
+        execute_attach_disk(@disk, machine)
 
-            # Populate disk infos
-            [:path, :size].each do |n|
-              backup.send("#{n}=", disk.send(n)) if disk.send(n)
-            end
+        puts
+        ssh_command machine[:dns_name], keypairpath, @global.user, "df -h" # Display current mounts
+        puts 
 
+        puts "Done!"
+      end
 
-            Rudy::MetaData::Backup.save(@sdb, backup)
 
-            puts backup.name
-            
-          end
 
-        end
 
-          
+       def unattach_disk_valid?
+         destroy_disk_valid?
+         true
+       end
 
+       def unattach_disk
+         puts "Unattaching #{@disk.name} from #{machine_group}"
+         switch_user("root")
+         are_you_sure?(4)
+         
+         machine = @instances.values.first
+
+         execute_unattach_disk(@disk, machine)
+
+         puts "Done!"
+       end
+
+
+
+      def execute_unattach_disk(disk, machine)
+        begin
           
-      end
-      
-      
-      def create_disk
-        disk = Rudy::MetaData::Disk.new
-        [:environment, :role, :position, :path, :device, :size].each do |n|
-          val = instance_variable_get("@#{n}")
-          disk.send("#{n}=", val) if val
+          if machine
+            puts "Unmounting #{disk.path}...".att(:bright)
+            ssh_command machine[:dns_name], keypairpath, global.user, "umount #{disk.path}"
+            sleep 1
+          end
+          
+          if @ec2.volumes.attached?(disk.awsid)
+            puts "Unattaching #{disk.awsid}".att(:bright)
+            @ec2.volumes.detach(disk.awsid)
+            sleep 5
+          end
+          
+        rescue => ex
+          puts "Error while unattaching volume #{disk.awsid}: #{ex.message}"
+          puts ex.backtrace if Drydock.debug?
         end
-        
-        raise "Not enough info was provided to define a disk (#{disk.name})" unless disk.valid?
-        raise "The device #{disk.device} is already in use on that machine" if Rudy::MetaData::Disk.is_defined?(@sdb, disk)
-        puts "Creating disk metadata for #{disk.name}"
-        
-        Rudy::MetaData::Disk.save(@sdb, disk)
-        
-        print_disks
       end
       
-      
-      def print_disks
-        criteria = [@zone]
-        criteria += [@environment, @role] unless @all
-        
-        Rudy::MetaData::Disk.list(@sdb, *criteria).each do |disk|
-          backups = Rudy::MetaData::Backup.for_disk(@sdb, disk, 2)
-          print_disk(disk, backups)
+      def execute_destroy_disk(disk, machine)
+        begin
+          
+          if disk
+            
+            if disk.awsid && @ec2.volumes.available?(disk.awsid)
+              puts "Destroying #{disk.path} (#{disk.awsid})".att(:bright)
+              @ec2.volumes.destroy(disk.awsid)
+            end
+            
+          end
           
+        rescue => ex
+          puts "Error while destroying volume #{disk.awsid}: #{ex.message}"
+          puts ex.backtrace if Drydock.debug?
+        ensure
+          puts "Deleteing metadata for #{disk.name}".att(:bright)
+          Rudy::MetaData::Disk.destroy(@sdb, disk)
         end
-
       end
       
-      def unattach_disk(name)
-        puts "Looking for #{name}"
-        disk = Rudy::MetaData::Disk.get(@sdb, name)
-        instances = @ec2.instances.list(machine_group)
-        @user = "root"
-        check_keys
-        raise "That is not a valid disk" unless disk
-        raise "There are no instances running in #{machine_group}" if !instances || instances.empty?
-        raise "The disk has no attached volume " unless disk.awsid
-        
-        machine = instances.values.first
-        
-        puts "Unmounting #{disk.path}..."
-        ssh machine[:dns_name], keypairpath, user, "umount #{disk.path}"
-        sleep 1
-        
-        puts "Detaching #{disk.awsid}"
-        @ec2.volumes.detach(disk.awsid)
-        
-        Rudy::MetaData::Backup.for_disk(@sdb, disk, 2)
-        
-        puts "Done!"
-      end
-      
-      def attach_disk(name)
-        puts "Looking for #{name}"
-        disk = Rudy::MetaData::Disk.get(@sdb, name)
-        instances = @ec2.instances.list(machine_group)
-        raise "There are no instances running in #{machine_group}" if !instances || instances.empty?
-        instance_id = instances.keys.first # <--- TODO: This is bad!
-        machine = instances.values.first
-        
-        do_dirty_disk_volume_deeds(disk, machine)
-        
-        
-        puts
-        ssh machine[:dns_name], keypairpath, user, "df -h" # Display current mounts
-        puts 
-        
-        puts "Done!"
+      def execute_attach_disk(disk, machine)
+        begin
+          unless @ec2.instances.attached_volume?(machine[:aws_instance_id], disk.device)
+            puts "Attaching #{disk.awsid} to #{machine[:aws_instance_id]}".att(:bright)
+            @ec2.volumes.attach(machine[:aws_instance_id], disk.awsid, disk.device)
+            sleep 3
+          end
+          
+          if disk.raw_volume
+            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 1
+          end
+          
+          puts "Mounting #{disk.path} to #{disk.device}".att(:bright)
+          ssh_command machine[:dns_name], keypairpath, @global.user, "mkdir -p #{disk.path} && mount -t ext3 #{disk.device} #{disk.path}"
+
+          sleep 1
+        rescue => ex
+          puts "There was an error attaching #{disk.name}: #{ex.message}"
+          puts ex.backtrace if Drydock.debug?
+        end
       end
       
-      def destroy_disk(name)
-        puts "Destroying #{name}"
-        @sdb.destroy(RUDY_DOMAIN, name)
-        puts "Done."
-      end
-
     end
   end
 end
 
+
+__END__
+
+    
+
+
+