solutious-rudy 0.4.0 → 0.5.0

data/lib/rudy/cli/manager.rb

@@ -0,0 +1,51 @@
+
+
+module Rudy
+  module CLI
+    class Manager < Rudy::CLI::Base
+      
+      
+      # Print Rudy's metadata to STDOUT
+      def metadata
+        group_metadata.each_pair do |n,h|
+          puts n.bright
+          puts h.inspect, ""
+        end
+      end
+      
+      def destroy_metadata_valid?
+        false
+      end
+      
+      def destroy_metadata
+        @sdb.domains.destroy(RUDY_DOMAIN)
+      end
+      
+      # TODO: WHERE TO CREATE DOMAIN???????????????????????????
+      
+      def create_domain
+        puts "Creating SimpleDB Domain called #{RUDY_DOMAIN}".bright
+        rmanager = Rudy::Manager.new(:config => @config, :global => @global)
+        rmanager.create_domain(RUDY_DOMAIN)
+        doms = rmanager.domains || []
+        puts "Domains: #{doms.join(", ")}"
+      end
+      
+      def info
+        puts "Rudy Manager".bright
+        rmanager = Rudy::Manager.new(:config => @config, :global => @global)
+        doms = rmanager.domains
+        puts "Domains: #{doms.join(", ")}"
+      end
+      
+    private
+      def check_environment
+        raise "No Amazon keys provided!" unless has_keys?
+        raise "No SSH keypairs provided!" unless has_keypair?
+        true
+      end
+      
+    end
+  end
+end
+

data/lib/rudy/{command → cli}/release.rb

@@ -1,8 +1,8 @@
 
 
 module Rudy
-  module Command
-    class Release < Rudy::Command::Base
+  module CLI
+    class Release < Rudy::CLI::Base
       
       
 
@@ -61,7 +61,7 @@ module Rudy
       end
       
       def rerelease
-        puts "Updating release from working copy".att(:bright)
+        puts "Updating release from working copy".bright
 
         tag, revision = @scm.local_info
         puts "tag: #{tag}"
@@ -71,7 +71,7 @@ module Rudy
         
         if @scm
           
-          puts "Running SCM command".att(:bright)
+          puts "Running SCM command".bright
           ssh do |session|
             cmd = "svn #{@scm_params[:command]}"
             puts "#{cmd}"
@@ -91,15 +91,15 @@ module Rudy
       # <li>Executes release routines</li>
       def release
         # TODO: store metadata about release with local username and hostname
-        puts "Creating release from working copy".att(:bright)
+        puts "Creating release from working copy".bright
 
-        exit unless are_you_sure?
+        exit unless Annoy.are_you_sure?(:low)
 
         tag = @scm.create_release(@global.local_user, @option.msg)        
         puts "Done! (#{tag})"
         
         if @option.switch
-          puts "Switching working copy to new tag".att(:bright)
+          puts "Switching working copy to new tag".bright
           @scm.switch_working_copy(tag)
         end
         
@@ -107,13 +107,13 @@ module Rudy
         
         switch_user("root")
         
-        puts "Starting #{machine_group}".att(:bright)
+        puts "Starting #{machine_group}".bright
         
         instances = @ec2.instances.create(@option.image, machine_group.to_s, File.basename(keypairpath), machine_data.to_yaml, @global.zone)
         inst = instances.first
         
         if @option.address ||= machine_address
-          puts "Associating #{@option.address} to #{inst[:aws_instance_id]}".att(:bright)
+          puts "Associating #{@option.address} to #{inst[:aws_instance_id]}".bright
           @ec2.addresses.associate(inst[:aws_instance_id], @option.address)
         end
         
@@ -127,7 +127,7 @@ module Rudy
         
         if @scm
           
-          puts "Running SCM command".att(:bright)
+          puts "Running SCM command".bright
           ssh do |session|
             cmd = "svn #{@scm_params[:command]} #{tag} #{@scm_params[:path]}"
             puts "#{cmd}"

data/lib/rudy/cli/routines.rb

@@ -0,0 +1,80 @@
+
+module Rudy
+  module CLI
+    class Routines < Rudy::CLI::Base
+
+    
+    
+      def startup_valid?
+        true
+      end
+      def startup
+        puts "Starting a machine group".bright
+        opts = {}
+        opts[:ami] = @option.image if @option.image
+        opts[:group] = @option.group if @option.group
+        #exit unless Annoy.are_you_sure?
+
+        rroutine = Rudy::Routines::Startup.new(:config => @config, :global => @global)
+        instances = rroutine.startup(opts)
+
+        puts "Done!"
+      end
+
+
+
+
+      def restart_valid?
+        shutdown_valid?
+      end
+      def restart
+        puts "Restarting #{machine_group}: #{@list.keys.join(', ')}".bright
+        switch_user("root")
+        exit unless Annoy.are_you_sure?(:medium)
+
+        @list.each do |id, inst|
+          execute_routines(@list.values, :restart, :before)
+        end
+
+        puts "Restarting instances: #{@list.keys.join(', ')}".bright
+        @ec2.instances.restart @list.keys
+        sleep 10 # Wait for state to change and SSH to shutdown
+
+        @list.keys.each do |id|
+          wait_for_machine(id)
+        end
+
+        execute_disk_routines(@list.values, :restart)
+
+        @list.each do |id, inst|
+          execute_routines(@list.values, :restart, :after)
+        end
+
+        puts "Done!"
+      end
+
+
+
+
+
+      def shutdown_valid?
+        raise "Cannot specify both instance ID and group name" if @argv.awsid && @option.group
+        raise "I will not help you ruin production!" if @global.environment == "prod" # TODO: use_caution?, locked?
+        true
+      end
+      def shutdown
+        puts "Shutting down a machine group".bright
+        opts = {}
+        opts[:group] = @option.group if @option.group
+        opts[:id] = @argv.awsid if @argv.awsid
+        opts[:id] &&= [opts[:id]].flatten
+      
+        msg = opts[:id] ? "instances: #{opts[:id].join(', ')}" : (opts[:group] ? "group: #{opts[:group]}" : '')
+        puts "This command also affects the disks on these machines! (according to your routines config)"
+        #exit unless Annoy.are_you_sure?(:medium)        # TODO: Check if instances are running before this
+        
+        puts "TBD"
+      end
+    end
+  end
+end

data/lib/rudy/cli/volumes.rb

@@ -0,0 +1,121 @@
+
+
+module Rudy
+  module CLI
+    class Volumes < Rudy::CLI::Base
+      
+
+      def destroy_volume_valid?
+        raise "You must supply a volume ID. See rudy volume -h" unless @argv.volid
+        
+        @rvol = Rudy::Volumes.new(:config => @config, :global => @global)
+        
+        @volume = @rvol.get(@argv.volid)
+        
+        raise "Volume #{@argv.volid} does not exist" unless @volume
+        
+        raise "Volume #{@argv.volid} is still in-use" if @volume.in_use?
+        raise "Volume #{@argv.volid} is still attached" if @volume.attached?
+        
+        true
+      end
+      
+      def destroy_volume
+        puts "Destroy Volume".bright, $/
+        
+        puts "Destroying #{@volume.awsid}"
+        exit unless Annoy.are_you_sure?(:medium)
+        
+        ret = @rvol.destroy(@volume.awsid)
+        raise "Failed" unless ret
+        
+        vol = @rvol.get(@volume.awsid)
+        
+        puts vol.to_s
+      end
+      
+      
+      def volume_create_valid?
+        raise "You must supply a volume size. See rudy volume -h" unless @option.size
+        raise "You have no zone configured. Check #{RUDY_CONFIG_FILE}." unless @global.zone
+        true
+      end
+      def volume_create
+        puts "Create Volume".bright
+        
+        exit unless Annoy.are_you_sure?(:medium)
+        
+        rvol = Rudy::Volumes.new(:config => @config, :global => @global)
+        vol = rvol.create(@option.size, @global.zone, @option.snapshot)
+        
+        puts vol.to_s
+      end
+      
+      def volume_attach_valid?
+        raise "You must supply a volume ID. See rudy volume -h" unless @argv.volid
+        raise "You must supply an instance ID. See rudy volume -h" unless @argv.instid
+        
+        @rvol = Rudy::Volumes.new(:config => @config, :global => @global)
+        @rmach = Rudy::Instances.new(:config => @config, :global => @global)
+        raise "Volume #{@argv.volid} does not exist" unless @rvol.exists?(@argv.volid)
+        raise "Instance #{@argv.instid} does not exist" unless @rmach.exists?(@argv.instid)
+        
+        true
+      end
+      def volume_attach
+        puts "Attach Volume".bright, $/
+        
+        @option.device ||= "/dev/sdh"
+        
+        puts "Attaching #{@argv.volid} to #{@argv.instid} on #{@option.device}"
+        exit unless Annoy.are_you_sure?(:low)
+        
+        ret = @rvol.attach(@argv.volid, @argv.instid, @option.device)
+        raise "Attach failed" unless ret
+        volume = @rvol.get(@argv.volid)
+        puts volume.to_s
+      end
+      
+      def volume_detach_valid?
+        raise "You must supply a volume ID. See rudy volume -h" unless @argv.volid
+        
+        @rvol = Rudy::Volumes.new(:config => @config, :global => @global)
+        
+        @volume = @rvol.get(@argv.volid)
+        
+        raise "Volume #{@argv.volid} does not exist" unless @volume
+        
+        #raise "Volume #{@argv.volid} is in use" unless @volume.in_use?
+        raise "Volume #{@argv.volid} is not attached" unless @volume.attached?
+        
+        true
+      end
+      def volume_detach
+        puts "Detach Volume".bright, $/
+        
+        puts "Detaching #{@volume.awsid} from #{@volume.instid}"
+        exit unless Annoy.are_you_sure?(:low)
+        
+        ret = @rvol.detach(@volume.awsid)
+        raise "Detach failed" unless ret
+        volume = @rvol.get(@volume.awsid)
+        puts volume.to_s
+      end
+      
+      
+      def volume
+        puts "Volumes".bright, $/
+        
+        rvol = Rudy::Volumes.new(:config => @config, :global => @global)
+        volumes = rvol.list || []
+        volumes.each do |volume|
+          puts '-'*60
+          puts volume.to_s
+        end
+        puts "No volumes" if volumes.empty?
+      end
+      
+    end
+  end
+end
+

data/lib/rudy/command/addresses.rb

@@ -1,46 +1,69 @@
 
 
-
 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
-      
+  class Addresses
+    include Rudy::Huxtable
+    
+    def create
+      address = @@ec2.addresses.create
+      raise ErrorCreatingAddress unless address.is_a?(Rudy::AWS::EC2::Address)
+      address
+    end
+    
+    def destroy(address)
+      address = address
+      @@ec2.addresses.destroy(address)
+    end
+    
+    def assign(address, instance)
+      raise "Not an instance object" unless instance.is_a?(Rudy::AWS::EC2::Instance)
+      raise "Address not available for this account" unless @@ec2.addresses.valid?(address)
+      @@ec2.addresses.associate(instance.awsid, address)
+    end
+    
+    
+    # Lists the addresses registered with Amazon
+    def list(n=nil, &each_object)
+      n = [n].flatten.compact
+      addresses = @@ec2.addresses.list(n)
+      addresses.each { |n,kp| each_object.call(kp) } if each_object
+      addresses || []
+    end
+    
+    def get(n=nil)
+      raise "Address cannot be nil" if n.nil?
+      @@ec2.addresses.get(n)
     end
+    
+    def associated?(n=nil)
+      raise "Address cannot be nil" if n.nil?
+      @@ec2.addresses.associated?(n)
+    end
+    
+    def list_as_hash(n=nil, &each_object)
+      n &&= [n].flatten.compact
+      addresses = @@ec2.addresses.list_as_hash(n)
+      addresses.each_pair { |n,kp| each_object.call(kp) } if each_object
+      addresses || {}
+    end
+    
+    def exists?(n=nil)
+      n ||= name(n)
+      @@ec2.addresses.exists?(n)
+    end
+    
+    def any?(n=nil)
+      n ||= name(n)
+      @@ec2.addresses.any?    
+    end
+    
   end
+  
 end
 
+
+module Rudy
+  class Addresses 
+    class ErrorCreatingAddress < RuntimeError; end
+  end
+end

data/lib/rudy/command/backups.rb

@@ -1,175 +1,65 @@
 
 
+module Rudy
+  class Backups
+    
+  end
+end
 
 
-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__
+
+
+# From Rudy::MetaData::Backup
+
+def Backup.for_disk(sdb, disk, max=50)
+  list = Backup.list(sdb, disk.zone, disk.environment, disk.role, disk.position, disk.path) || []
+  list[0..(max-1)]
+end
+
+def Backup.get(sdb, name)
+  object = sdb.get_attributes(RUDY_DOMAIN, name)
+  raise "Object #{name} does not exist!" unless object.has_key?(:attributes) && !object[:attributes].empty?
+  self.from_hash(object[:attributes])
+end
+
+def Backup.save(sdb, obj, replace = :replace)
+  sdb.store(RUDY_DOMAIN, obj.name, obj.to_hash, replace)
+end
+
+def Backup.list(sdb, zon, env=nil, rol=nil, pos=nil, path=nil, date=nil)
+  query = "select * from #{RUDY_DOMAIN} where "
+  query << "rtype = '#{rtype}' "
+  query << " and zone = '#{zon}'" if zon
+  query << " and environment = '#{env}'" if env
+  query << " and role = '#{rol}'" if rol
+  query << " and position = '#{pos}'" if pos
+  query << " and path = '#{path}'" if path
+  query << " and date = '#{date}'" if date
+  query << " and unixtime != '0' order by unixtime desc"
+  list = []
+  sdb.select(query).each do |obj|
+    list << self.from_hash(obj)
   end
-end
+  list
+end
+
+def Backup.find_most_recent(zon, env, rol, pos, path)
+  criteria = [zon, env, rol, pos, path]
+  (Rudy::MetaData::Backup.list(@sdb, *criteria) || []).first
+end
+
+def Backup.destroy(sdb, name)
+  back = Backup.get(sdb, name) # get raises an exception if the disk doesn't exist
+  sdb.destroy(RUDY_DOMAIN, name)
+  true # wtf: RightAws::SimpleDB doesn't tell us whether it succeeds. We'll assume!
+end
+
+
+
+def Backup.is_defined?(sdb, backup)
+  query = backup.to_query()
+  puts query
+  !sdb.select(query).empty?
+end
+