solutious-rudy 0.5.1 → 0.6.0

data/lib/rudy/aws/ec2/instance.rb

@@ -3,28 +3,47 @@
 
 module Rudy::AWS
   class EC2::Instance < Storable
+    @@sformat = "   -> %10s; %10s; %12s; %10s; groups: %s"
     field :aki
     field :ari
     field :launch_index => Time
     field :launch_time
     field :keyname
-    field :instance_type
+    field :size
     field :ami
-    field :dns_name_private
-    field :dns_name_public
+    field :dns_private
+    field :dns_public
     field :awsid
     field :state
     field :zone
     field :reason
     field :groups => Array
     
+    # Groups aren't returned when creating an instance so this
+    # method returns an empty Array if +@groups+ is not set.
     def groups
       @groups || []
     end
     
-        
-    def to_s
+    def liner_note
+      info = self.running? ? self.dns_public : self.state
+      "%s  %s" % [self.awsid.bright, info]
+    end
+
+    def to_s(with_title=false)
       lines = []
+      lines << "%s  (%s)" % [liner_note, @groups.join(', ')]
+      #if self.running?
+      #  k, g = @keyname || 'no-keypair', self.groups.join(', ')
+      #  lines << @@sformat % %w{zone size ami keyname groups} if with_title
+      #  lines << @@sformat % [@zone, @size, @ami, k, g]
+      #end
+      lines.join($/)
+    end
+    
+    def inspect
+      lines = []
+      lines << liner_note
       field_names.each do |key|
         next unless self.respond_to?(key)
         val = self.send(key)
@@ -33,92 +52,94 @@ module Rudy::AWS
       lines.join($/)
     end
     
-    def running?
-      self.state && self.state == 'running'
-    end
-    
-    def pending?
-      self.state && self.state == 'pending'
-    end
-    
-    def terminated?
-      self.state && self.state == 'terminated'
-    end
-    
-    def shutting_down?
-      self.state && self.state == 'shutting-down'
-    end
+    def running?; self.state && self.state == 'running'; end
+    def pending?; self.state && self.state == 'pending'; end
+    def terminated?; self.state && self.state == 'terminated'; end
+    def degraded?; self.state && self.state == 'degraded'; end
+    def shutting_down?; self.state && self.state == 'shutting-down'; end
       
   end
   
   
-  class EC2
+  module EC2
     class Instances
       include Rudy::AWS::ObjectBase
+      include Rudy::AWS::EC2::Base
+      
       unless defined?(KNOWN_STATES)
-        KNOWN_STATES = [:running, :pending, :shutting_down, :terminated].freeze 
+        KNOWN_STATES = [:running, :pending, :shutting_down, :terminated, :degraded].freeze 
       end
     
       # Return an Array of Instance objects. Note: These objects will not have
       # DNS data because they will still be in pending state. The DNS info becomes
       # available once the instance enters the running state.
-      def create(ami, group='default', keypair_name=nil, user_data=nil, zone=nil)
+      #
+      # +opts+ supports the following parameters:
+      #
+      # * +:ami+          
+      # * +:group+        
+      # * +:size+          
+      # * +:keypair+      
+      # * +:address+
+      # * +:private+ true or false (default)
+      # * +:machine_data+
+      # * +:min+ count
+      # * +:max+ count
+      #
+      def create(opts={}, &each_inst)
+        raise NoAMI unless opts[:ami]
+        raise NoGroup unless opts[:group]
+        
         opts = {
-          :image_id => ami.to_s,
-          :min_count => 1,
-          :max_count => 1,
-          :key_name => keypair_name.to_s,
-          :group_id => [group].flatten,
-          :user_data => user_data,
-          :availability_zone => zone.to_s, 
-          :addressing_type => 'public',
-          :instance_type => 'm1.small',
+          :size => 'm1.small',
+          :min => 1,
+          :max => nil
+        }.merge(opts)
+        
+        old_opts = {
+          :image_id => opts[:ami].to_s,
+          :min_count => opts[:min],
+          :max_count => opts[:max] || opts[:min],
+          :key_name => (opts[:keypair] || '').to_s,
+          :group_id => [opts[:group]].flatten.compact,
+          #:user_data => opts[:machine_data],  # Error: Invalid BASE64 encoding of user data ??
+          :availability_zone => opts[:zone].to_s,
+          :addressing_type => opts[:private] ? 'private' : 'public',
+          :instance_type => opts[:size].to_s,
           :kernel_id => nil
         }
-      
-        response = execute_request({}) { @aws.run_instances(opts) }
+        #p opts[:machine_data]
+        #exit
         
-        # reservationId: r-f393149a
-        # groupSet: 
-        #   item: 
-        #   - groupId: default
-        # requestId: a4de33de-6da1-4f43-a3f5-f987f5f1f1cf
-        # instancesSet: 
-        #   item:
-        #     ... # see Instances.from_hash
-        raise "The request failed to return instance data" unless response['instancesSet'].is_a?(Hash)
+        response = execute_request({}) { @ec2.run_instances(old_opts) }
+        return nil unless response['instancesSet'].is_a?(Hash)
         instances = response['instancesSet']['item'].collect do |inst|
           self.class.from_hash(inst)
         end
-        
+        instances.each { |inst| 
+          each_inst.call(inst) 
+        } if each_inst
         instances
       end
     
-      def restart(inst_ids=[], skip_check=false)
-        unless skip_check
-          instances = list(:running, inst_ids) || []
-          raise "No matching running instances found" if instances.empty?
-        end
-      
+      def restart(inst_ids=[], &each_inst)
+        instances = list(:running, inst_ids, &each_inst) || []
+        raise NoRunningInstances if instances.empty?
         inst_ids = objects_to_instance_ids(inst_ids)
-            
         response = execute_request({}) {
-          @aws.reboot_instances(:instance_id => inst_ids)
+          @ec2.reboot_instances(:instance_id => inst_ids)
         }
-      
         response['return'] == 'true'
       end
     
-      def destroy(inst_ids=[], skip_check=false)
-        unless skip_check
-          instances = list(:running, inst_ids) || [] 
-          raise "No matching running instances found" if instances.empty?
-        end
+      def destroy(inst_ids=[], &each_inst)
+        instances = list(:running, inst_ids, &each_inst) || [] 
+        raise NoRunningInstances if instances.empty?
       
         inst_ids = objects_to_instance_ids(inst_ids)
             
         response = execute_request({}) {
-          @aws.terminate_instances(:instance_id => inst_ids)
+          @ec2.terminate_instances(:instance_id => inst_ids)
         }
       
         #instancesSet: 
@@ -131,25 +152,24 @@ module Rudy::AWS
         #      code: "48"
         #      name: terminated
       
-        raise "The request failed to return instance data" unless response['instancesSet'].is_a?(Hash)
+        raise MalformedResponse unless response['instancesSet'].is_a?(Hash)
         instances_shutdown = []
         response['instancesSet']['item'].collect do |inst|
           next unless inst['shutdownState'].is_a?(Hash) && inst['shutdownState']['name'] == 'shutting-down'
           instances_shutdown << inst['instanceId']
         end
         success = instances_shutdown.size == inst_ids.size
-        #puts "SUC: #{success} #{instances_shutdown.size} #{inst_ids.size}"
         success
       end
     
-      def restart_group(group)
-        instances = list_group(group, :running) || []
+      def restart_group(group, &each_inst)
+        instances = list_group(group, :running, &each_inst) || []
         inst_ids = objects_to_instance_ids(instances)
         restart(inst_ids, :skip_check)
       end
     
-      def destroy_group(group)
-        instances = list_group(group, :running) || []
+      def destroy_group(group, &each_inst)
+        instances = list_group(group, :running, &each_inst) || []
         inst_ids = objects_to_instance_ids(instances)
         destroy(inst_ids, :skip_check)
       end
@@ -157,8 +177,8 @@ module Rudy::AWS
       # * +state+ is an optional instance state. If specified, must be one of: running (default), pending, terminated.
       # * +inst_ids+ is an Array of instance IDs.
       # Returns an Array of Rudy::AWS::EC2::Instance objects. 
-      def list(state=nil, inst_ids=[])
-        instances = list_as_hash(state, inst_ids)
+      def list(state=nil, inst_ids=[], &each_inst)
+        instances = list_as_hash(state, inst_ids, &each_inst)
         instances &&= instances.values
         instances = nil if instances && instances.empty? # Don't return an empty hash
         instances
@@ -167,9 +187,8 @@ module Rudy::AWS
       # * +group+ is a security group name.
       # * +state+ is an optional instance state. If specified, must be one of: running (default), pending, terminated.
       # * +inst_ids+ is an Array of instance IDs.
-      def list_group(group=nil, state=nil, inst_ids=[])
-        raise "No group specified" unless group
-        instances = list_group_as_hash(group, state, inst_ids)
+      def list_group(group=nil, state=nil, inst_ids=[], &each_inst)
+        instances = list_group_as_hash(group, state, inst_ids, &each_inst)
         instances &&= instances.values
         instances = nil if instances && instances.empty? # Don't return an empty hash
         instances
@@ -179,11 +198,13 @@ module Rudy::AWS
       # * +group+ is a security group name.
       # * +state+ is an optional instance state. If specified, must be one of: running (default), pending, terminated.
       # * +inst_ids+ is an Array of instance IDs.
-      def list_group_as_hash(group=nil, state=nil, inst_ids=[])
-        raise "No group specified" unless group
+      def list_group_as_hash(group=nil, state=nil, inst_ids=[], &each_inst)
         instances = list_as_hash(state, inst_ids)
         # Remove instances that are not in the specified group
-        instances &&= instances.reject { |id,inst| !inst.groups.member?(group) } if group
+        if instances
+          instances = instances.reject { |id,inst| !inst.groups.member?(group) } if group
+          instances.each_value { |inst| each_inst.call(inst) } if each_inst
+        end
         instances = nil if instances && instances.empty? # Don't return an empty hash
         instances
       end
@@ -192,7 +213,8 @@ module Rudy::AWS
       # one of: running (default), pending, terminated, any
       # * +inst_ids+ is an Array of instance IDs or Rudy::AWS::EC2::Instance objects.
       # Returns a Hash of Rudy::AWS::EC2::Instance objects. The key is the instance ID. 
-      def list_as_hash(state=nil, inst_ids=[])
+      # * +each_inst+ a block to execute for every instance in the list.
+      def list_as_hash(state=nil, inst_ids=[], &each_inst)
         state &&= state.to_sym
         state = nil if state == :any
         raise "Unknown state: #{state}" if state && !Instances.known_state?(state)
@@ -203,7 +225,7 @@ module Rudy::AWS
         inst_ids = objects_to_instance_ids(inst_ids)
       
         response = execute_request({}) {
-          @aws.describe_instances(:instance_id => inst_ids)
+          @ec2.describe_instances(:instance_id => inst_ids)
         }
       
         # requestId: c16878ac-28e4-4859-9878-ef93af45789c
@@ -225,14 +247,16 @@ module Rudy::AWS
           # And each reservation can have 1 or more instances
           next unless res['instancesSet'].is_a?(Hash)
           res['instancesSet']['item'].each do |props|
-            inst = self.class.from_hash(props)
+            inst = Instances.from_hash(props)
             next if state && inst.state != state.to_s
             inst.groups = groups
             #puts "STATE: #{inst.state} #{state}"
             instances[inst.awsid] = inst
           end
         end
-
+        
+        instances.each_value { |inst| each_inst.call(inst) } if each_inst
+        
         instances = nil if instances.empty? # Don't return an empty hash
         instances
       end
@@ -250,10 +274,10 @@ module Rudy::AWS
       #      require 'base64'
       #      Base64.decode64(output)
       #
-      def console_output(inst_id)
+      def console(inst_id, &each_inst)
         inst_ids = objects_to_instance_ids([inst_id])
         response = execute_request({}) { 
-          @aws.get_console_output(:instance_id => inst_ids.first)
+          @ec2.get_console_output(:instance_id => inst_ids.first)
         }
         response['output']
       end
@@ -267,8 +291,10 @@ module Rudy::AWS
       end
     
       def volumes(id)
-        list = Rudy::AWS::EC2::Volumes.new(@aws).list || []
-        list.select { |v| v.status != "deleting" && v.instid === id }
+        rvol = Rudy::AWS::EC2::Volumes.new
+        rvol.ec2 = @ec2 
+        rvol.list || []
+        list.select { |v| v.attached? && v.instid === id }
       end
     
       def device_volume(id, device)
@@ -279,9 +305,9 @@ module Rudy::AWS
       # Returns an Instance object
       def get(inst_id)
         inst_id = inst_id.awsid if inst_id.is_a?(Rudy::AWS::EC2::Instance)
-        inst = list(:any, inst_id)
-        raise "Unknown instance: #{inst_id}" unless inst
-        inst.first
+        inst = list(:any, inst_id) 
+        inst &&= inst.first
+        inst
       end
       
       def any?(state=:any, inst_ids=[])
@@ -348,9 +374,9 @@ module Rudy::AWS
         inst.launch_time = h['launchTime']
         inst.keyname = h['keyName']
         inst.launch_index = h['amiLaunchIndex']
-        inst.instance_type = h['instanceType']
-        inst.dns_name_private = h['privateDnsName']
-        inst.dns_name_public = h['dnsName']
+        inst.size = h['instanceType']
+        inst.dns_private = h['privateDnsName']
+        inst.dns_public = h['dnsName']
         inst.reason = h['reason']
         inst.zone = h['placement']['availabilityZone']
         inst.awsid = h['instanceId']
@@ -394,7 +420,7 @@ module Rudy::AWS
         inst_ids = [inst_ids].flatten    # Make sure it's an Array
         inst_ids = inst_ids.collect do |inst|
           next if inst.nil? || inst.to_s.empty?
-          if !inst.is_a?(Rudy::AWS::EC2::Instance) && !Rudy.is_id?(:instance, inst)
+          if !inst.is_a?(Rudy::AWS::EC2::Instance) && !Rudy::Utils.is_id?(:instance, inst)
             raise %Q("#{inst}" is not an instance ID or object)
           end
           inst.is_a?(Rudy::AWS::EC2::Instance) ? inst.awsid : inst
@@ -404,4 +430,5 @@ module Rudy::AWS
   
     end
   end
-end
+end
+

data/lib/rudy/aws/ec2/keypair.rb

@@ -1,16 +1,20 @@
-require 'rye'
 
 module Rudy::AWS
-  class EC2
+  module EC2
     
     class KeyPair < Storable
-      attr_accessor :private_key  # not a storable field
       
       field :name
       field :fingerprint
+      field :private_key  
       
-      def to_s
-        "%-20s   %s" % [self.name, self.fingerprint]
+      def liner_note
+        "%-20s   %s" % [self.name.bright, self.fingerprint]
+      end
+      
+      def to_s(titles=false)
+        str = titles ? "%-20s   %s#{$/}" % ['name', 'fingerprint'] : ""
+        str << liner_note
       end
       
       def public_key
@@ -23,17 +27,18 @@ module Rudy::AWS
     
     class KeyPairs
       include Rudy::AWS::ObjectBase
+      include Rudy::AWS::EC2::Base
       
       def create(name)
         raise "No name provided" unless name
-        ret = @aws.create_keypair(:key_name => name)
+        ret = @ec2.create_keypair(:key_name => name)
         self.class.from_hash(ret)
       end
       
       def destroy(name)
         name = name.name if name.is_a?(Rudy::AWS::EC2::KeyPair)
         raise "No name provided" unless name.is_a?(String)
-        ret = @aws.delete_keypair(:key_name => name)
+        ret = @ec2.delete_keypair(:key_name => name)
         (ret && ret['return'] == 'true') # BUG? Always returns true
       end
       
@@ -45,7 +50,7 @@ module Rudy::AWS
       
       def list_as_hash(*names)
         names = names.flatten
-        klist = @aws.describe_keypairs(:key_name => names)
+        klist = @ec2.describe_keypairs(:key_name => names)
         return unless klist['keySet'].is_a?(Hash)
         keypairs = {}
         klist['keySet']['item'].each do |oldkp| 
@@ -80,13 +85,20 @@ module Rudy::AWS
       end
       
       def exists?(name)
-        begin
-          kp = get(name)
-          kp.is_a?(Rudy::AWS::EC2::KeyPair)
-        rescue => ex
-          false
-        end
+        return false unless name
+        kp = get(name) rescue nil
+        !kp.nil?
+      end
+      
+    end
+    
+    class Keypairs
+      def initialize(*args)
+        raise "Oops! The correct class uses a capital 'P': Rudy::AWS::EC2::KeyPairs"
       end
     end
+    
   end
 end
+
+

data/lib/rudy/aws/ec2/snapshot.rb

@@ -1,16 +1,24 @@
 
 
 module Rudy::AWS
-  class EC2
+  module EC2
     class Snapshot < Storable
+      @@sformat = "%s <- %10s; %s"
+      
       field :awsid
       field :progress
       field :created
       field :volid
       field :status
       
-      def to_s
-        "%s:%s (%s) %s" [self.awsid, self.volid, self.created, self.status]
+      def liner_note
+        t = Time.parse(@created)
+        info = t.strftime("%Y-%m-%d %H:%M:%S")
+        "%s (%s)" % [(self.awsid || '').bright, info]
+      end
+      
+      def to_s(with_title=false)
+        @@sformat % [liner_note,  @volid, @status]
       end
       
       def completed?
@@ -21,16 +29,18 @@ module Rudy::AWS
     
     class Snapshots
       include Rudy::AWS::ObjectBase
-      
+      include Rudy::AWS::EC2::Base
 
-      def list(*snap_id)
+      def list(snap_id=[])
         snapshots = list_as_hash(snap_id)
-        snapshots &&= snapshots.values
+        if snapshots
+          snapshots = snapshots.values.sort { |a,b| a.created <=> b.created }
+        end
         snapshots
       end
-      def list_as_hash(*snap_id)
-        snap_id = snap_id.flatten
-        slist = @aws.describe_snapshots(:snapshot_id => snap_id)
+      def list_as_hash(snap_id=[])
+        snap_id = [snap_id].flatten.compact
+        slist = @ec2.describe_snapshots(:snapshot_id => snap_id)
         return unless slist['snapshotSet'].is_a?(Hash)
         snapshots = {}
         slist['snapshotSet']['item'].each do |snap| 
@@ -42,12 +52,13 @@ module Rudy::AWS
       
       def create(vol_id)
         vol_id = (vol_id.is_a?(Rudy::AWS::EC2::Volume)) ? vol_id.awsid : vol_id
-        snap = @aws.create_snapshot(:volume_id => vol_id)
-        self.class.from_hash(snap)
+        shash = @ec2.create_snapshot(:volume_id => vol_id)
+        snap = Snapshots.from_hash(shash)
+        snap
       end
       
       def destroy(snap_id)
-        ret = @aws.delete_snapshot(:snapshot_id => snap_id)
+        ret = @ec2.delete_snapshot(:snapshot_id => snap_id)
         (ret && ret['return'] == 'true') 
       end