rudy 0.4.0 → 0.6.0

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

@@ -0,0 +1,434 @@
+
+
+
+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 :size
+    field :ami
+    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 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)
+        lines << sprintf(" %22s: %s", key, (val.is_a?(Array) ? val.join(', ') : val))
+      end
+      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 degraded?; self.state && self.state == 'degraded'; end
+    def shutting_down?; self.state && self.state == 'shutting-down'; end
+      
+  end
+  
+  
+  module EC2
+    class Instances
+      include Rudy::AWS::ObjectBase
+      include Rudy::AWS::EC2::Base
+      
+      unless defined?(KNOWN_STATES)
+        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.
+      #
+      # +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 = {
+          :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
+        }
+        #p opts[:machine_data]
+        #exit
+        
+        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=[], &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({}) {
+          @ec2.reboot_instances(:instance_id => inst_ids)
+        }
+        response['return'] == 'true'
+      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({}) {
+          @ec2.terminate_instances(:instance_id => inst_ids)
+        }
+      
+        #instancesSet: 
+        #  item: 
+        #  - instanceId: i-ebdcb882
+        #    shutdownState: 
+        #      code: "48"
+        #      name: terminated
+        #    previousState: 
+        #      code: "48"
+        #      name: terminated
+      
+        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
+        success
+      end
+    
+      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, &each_inst)
+        instances = list_group(group, :running, &each_inst) || []
+        inst_ids = objects_to_instance_ids(instances)
+        destroy(inst_ids, :skip_check)
+      end
+    
+      # * +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=[], &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
+      end
+    
+      # * +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=[], &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
+      end
+    
+    
+      # * +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=[], &each_inst)
+        instances = list_as_hash(state, inst_ids)
+        # Remove instances that are not in the specified 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
+    
+      # * +state+ is an optional instance state. If specified, must be 
+      # 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. 
+      # * +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)
+        state = :'shutting-down' if state == :shutting_down # EC2 uses a dash
+
+        # If we got Instance objects, we want just the IDs.
+        # This method always returns an Array.
+        inst_ids = objects_to_instance_ids(inst_ids)
+      
+        response = execute_request({}) {
+          @ec2.describe_instances(:instance_id => inst_ids)
+        }
+      
+        # requestId: c16878ac-28e4-4859-9878-ef93af45789c
+        # reservationSet: 
+        #   item: 
+        #   - reservationId: r-e493148d
+        #     groupSet: 
+        #       item: 
+        #       - groupId: default
+        #     instancesSet: 
+        #       item:
+        return nil unless response['reservationSet'].is_a?(Hash)  # No instances 
+      
+        resids = []
+        instances = {}
+        response['reservationSet']['item'].each do |res|      
+          resids << res['reservationId']
+          groups = res['groupSet']['item'].collect { |g| g['groupId'] }
+          # And each reservation can have 1 or more instances
+          next unless res['instancesSet'].is_a?(Hash)
+          res['instancesSet']['item'].each do |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
+    
+      # System console output. 
+      #
+      # * +inst_id+ instance ID (String) or Instance object.
+      #
+      # NOTE: Amazon sends the console outputs as a Base64 encoded string.
+      # This method DOES NOT decode in order to remain compliant with the 
+      # data formats returned by Amazon. 
+      #
+      # You can decode it like this:
+      #
+      #      require 'base64'
+      #      Base64.decode64(output)
+      #
+      def console(inst_id, &each_inst)
+        inst_ids = objects_to_instance_ids([inst_id])
+        response = execute_request({}) { 
+          @ec2.get_console_output(:instance_id => inst_ids.first)
+        }
+        response['output']
+      end
+      
+      def attached_volume?(id, device)
+        list = volumes(id)
+        list.each do |v|
+          return true if v.device == device
+        end
+        false
+      end
+    
+      def volumes(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)
+        volumes(id).select { |v| v.device === device }
+      end
+    
+      # +inst_id+ is an instance ID
+      # 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) 
+        inst &&= inst.first
+        inst
+      end
+      
+      def any?(state=:any, inst_ids=[])
+        !list(state, inst_ids).nil?
+      end
+      
+      def exists?(inst_ids)
+        any?(:any, inst_ids)
+      end
+      
+      def any_group?(group=nil, state=:any)
+        ret = list_group(group, state)
+        !ret.nil?
+      end
+        
+      def running?(inst_ids)
+        compare_instance_lists(list(:running, inst_ids), inst_ids)
+      end
+      def pending?(inst_ids)
+        compare_instance_lists(list(:pending, inst_ids), inst_ids)
+      end
+      def terminated?(inst_ids)
+        compare_instance_lists(list(:terminated, inst_ids), inst_ids)
+      end
+      def shutting_down?(inst_ids)
+        compare_instance_lists(list(:shutting_down, inst_ids), inst_ids)
+      end
+      
+      def unavailable?(inst_ids)
+        instances = list(:any, inst_ids) || []
+        instances.reject! { |inst| 
+          (inst.state == "shutting-down" || 
+           inst.state == "pending" || 
+           inst.state == "terminated") 
+        }
+        compare_instance_lists(instances, inst_ids)
+      end
+    
+      #
+      # +h+ is a hash of instance properties in the format returned
+      # by EC2::Base#describe_instances:
+      #   
+      #       kernelId: aki-9b00e5f2
+      #       amiLaunchIndex: "0"
+      #       keyName: solutious-default
+      #       launchTime: "2009-03-14T12:48:15.000Z"
+      #       instanceType: m1.small
+      #       imageId: ami-0734d36e
+      #       privateDnsName: 
+      #       reason: 
+      #       placement: 
+      #         availabilityZone: us-east-1b
+      #       dnsName: 
+      #       instanceId: i-cdaa34a4
+      #       instanceState: 
+      #         name: pending
+      #         code: "0"
+      #
+      # Returns an Instance object.
+      def self.from_hash(h)
+        inst = Rudy::AWS::EC2::Instance.new
+        inst.aki = h['kernelId']
+        inst.ami = h['imageId']
+        inst.launch_time = h['launchTime']
+        inst.keyname = h['keyName']
+        inst.launch_index = h['amiLaunchIndex']
+        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']
+        inst.state = h['instanceState']['name']
+        inst
+      end
+    
+      # Is +state+ a known EC2 machine instance state? See: KNOWN_STATES
+      def self.known_state?(state)
+        return false unless state
+        state &&= state.to_sym
+        state = :shutting_down if state == :'shutting-down'
+        KNOWN_STATES.member?(state)
+      end
+
+    private
+  
+    
+      # Find out whether two lists of instance IDs (or Rudy::AWS::EC2::Instance objects)
+      # contain the same instances regardless of order. 
+      #
+      # *+listA+ An Array of instance IDs (Strings) or Rudy::AWS::EC2::Instance objects
+      # *+listB+ Another Array of instance IDs (Strings) or Rudy::AWS::EC2::Instance objects
+      # Returns true if:
+      # * both listA and listB are Arrays
+      # * listA and listB contain the same number of items
+      # * all items in listA are in listB
+      # * all items in listB are in listA
+      def compare_instance_lists(listA, listB)
+        listA = objects_to_instance_ids(listA)
+        listB = objects_to_instance_ids(listB)
+        return false if listA.empty? || listB.empty?
+        return false unless listA.size == listB.size
+        (listA - listB).empty? && (listB - listA).empty? 
+      end
+    
+      # * +inst_ids+ an Array of instance IDs (Strings) or Instance objects.
+      # Note: This method removes nil values and always returns an Array.
+      # Returns an Array of instances IDs. 
+      def objects_to_instance_ids(inst_ids)
+        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::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
+        end
+        inst_ids
+      end
+  
+    end
+  end
+end
+

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

@@ -0,0 +1,104 @@
+
+module Rudy::AWS
+  module EC2
+    
+    class KeyPair < Storable
+      
+      field :name
+      field :fingerprint
+      field :private_key  
+      
+      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
+        return unless @private_key
+        k = Rye::Key.new(@private_key)
+        k.public_key.to_ssh2
+      end
+
+    end
+    
+    class KeyPairs
+      include Rudy::AWS::ObjectBase
+      include Rudy::AWS::EC2::Base
+      
+      def create(name)
+        raise "No name provided" unless 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 = @ec2.delete_keypair(:key_name => name)
+        (ret && ret['return'] == 'true') # BUG? Always returns true
+      end
+      
+      def list(*names)
+        keypairs = list_as_hash(names)
+        keypairs &&= keypairs.values
+        keypairs
+      end
+      
+      def list_as_hash(*names)
+        names = names.flatten
+        klist = @ec2.describe_keypairs(:key_name => names)
+        return unless klist['keySet'].is_a?(Hash)
+        keypairs = {}
+        klist['keySet']['item'].each do |oldkp| 
+          kp = self.class.from_hash(oldkp)
+          keypairs[kp.name] = kp
+        end
+        keypairs
+      end
+      
+      def self.from_hash(h)
+        # keyName: test-c5g4v3pe
+        # keyFingerprint: 65:d0:ce:e7:6a:b0:88:4a:9c:c7:2d:b8:33:0c:fd:3b:c8:0f:0a:3c
+        # keyMaterial: |-
+        #   -----BEGIN RSA PRIVATE KEY-----
+        # 
+        keypair = Rudy::AWS::EC2::KeyPair.new
+        keypair.fingerprint = h['keyFingerprint']
+        keypair.name = h['keyName']
+        keypair.private_key = h['keyMaterial']
+        keypair
+      end
+      
+      def any?
+        keypairs = list || []
+        !keypairs.empty?
+      end
+      
+      def get(name)
+        keypairs = list(name) || []
+        return if keypairs.empty?
+        keypairs.first
+      end
+      
+      def exists?(name)
+        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
+
+