solutious-rudy 0.4.0 → 0.5.0

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

@@ -0,0 +1,241 @@
+
+module Rudy::AWS
+  
+  class EC2::Group < Storable
+    class Rule < Storable
+      field :ports => Range          # Port range
+      field :protocol => String
+      def to_s
+        if self.ports.first == self.ports.last
+          "%s(%s)" % [self.protocol, self.ports.last]
+        else
+          "%s(%s..%s)" % [self.protocol, self.ports.first, self.ports.last]
+        end
+      end
+    end     
+  end
+  
+  class EC2::Group < Storable
+    field :name => String
+    field :description => String
+    field :owner_id => String
+    field :addresses => Hash         # key: address/mask, value Array of Rule object
+    field :groups => Hash            # key: group, value Array of Rule object
+    
+    # Print info about a security group
+    #
+    # * +group+ is a Rudy::AWS::EC2::Group object
+    def to_s
+      lines = ["%12s: %s" % ['GROUP', self.name.bright]]
+      
+      (self.addresses || {}).each_pair do |address,rules|
+        lines << "%6s %s:  %s" % ['', address.to_s, rules.collect { |p| p.to_s}.join(', ')]
+      end
+      
+      (self.groups || {}).each_pair do |group,rules|
+        lines << "%6s %s:  %s" % ['', group, rules.collect { |p| p.to_s}.join(', ') ]
+      end
+      
+      lines.join($/)
+    end
+    
+    # * +ipaddress+ is a String, ipaddress/mask/protocol
+    # * +rule+ is a Rule object
+    def add_address(ipaddress, rule)
+      return false unless rule.is_a?(Rule)
+      @addresses ||= {}
+      (@addresses[ipaddress] ||= []) << rule
+      rule
+    end
+    
+    # * +group+ is a String, accountnum:group
+    # * +rule+ is a Rule object
+    def add_group(group, rule)
+      return false unless rule.is_a?(Rule)
+      @groups ||= {}
+      (@groups[group] ||= []) << rule
+    end
+    
+  end
+  
+  
+  
+  class EC2
+    class Groups
+      include Rudy::AWS::ObjectBase
+  
+      def list(group_names=[])
+        group_names ||= []
+        groups = list_as_hash(group_names)
+        groups &&= groups.values
+        groups
+      end
+      
+      # * +group_names+ is a list of security group names to look for. If it's empty, all groups
+      # associated to the account will be returned.
+      #
+      # Returns an Array of Rudy::AWS::EC2::Group objects
+      def list_as_hash(group_names=[])
+        group_names ||= []
+        glist = @aws.describe_security_groups(:group_name => group_names) || {}
+        return unless glist['securityGroupInfo'].is_a?(Hash)
+        groups = {}
+        glist['securityGroupInfo']['item'].each do |oldg| 
+          g = Groups.from_hash(oldg)
+          groups[g.name] = g
+        end
+        groups
+      end
+      
+      def any?
+        groups = list || []
+        !groups.empty?
+      end
+      
+      # Create a new EC2 security group
+      # Returns true/false whether successful
+      def create(name, desc=nil)
+        ret = @aws.create_security_group(:group_name => name, :group_description => desc || "Group #{name}")
+        return false unless (ret && ret['return'] == 'true')
+        get(name)
+      end
+    
+      # Delete an EC2 security group
+      # Returns true/false whether successful
+      def destroy(name)
+        ret = @aws.delete_security_group(:group_name => name)
+        (ret && ret['return'] == 'true')
+      end
+    
+      # * +name+ a string
+      def get(name)
+        (list([name]) || []).first
+      end
+    
+      # +group+ a Rudy::AWS::EC2::Group object
+      #def save(group)
+      #  
+      #end
+    
+      def modify_rules(meth, name, from_port, to_port, protocol='tcp', ipa='0.0.0.0/0')
+        opts = {
+          :group_name => name,
+          :ip_protocol => protocol,
+          :from_port => from_port,
+          :to_port => to_port,
+          :cidr_ip => ipa
+        }
+        
+        ret = @aws.send("#{meth}_security_group_ingress", opts)
+        (ret && ret['return'] == 'true')
+      end
+      private :modify_rules
+    
+      def modify_group_rules(meth, name, gname=nil, gowner=nil)
+        opts = {
+          :group_name => name,
+          :source_security_group_name => gname,
+          :source_security_group_owner_id => gowner
+        }
+        ret = @aws.send("#{meth}_security_group_ingress", opts)
+        (ret && ret['return'] == 'true')
+      end
+      private :modify_group_rules
+      
+      # Authorize a port/protocol for a specific IP address
+      def authorize(*args)
+        modify_rules(:authorize, *args)
+      end
+      alias :authorise :authorize
+      
+      def authorize_group(*args)
+        modify_group_rules(:authorize, *args)
+      end
+      alias :authorise_group :authorize_group
+      
+      def revoke_group(*args)
+        modify_group_rules(:revoke, *args)
+      end
+      
+      # Revoke a port/protocol for a specific IP address
+      # Takes the same arguments as authorize
+      def revoke(*args)
+        modify_rules(:revoke, *args)
+      end
+      
+    
+      # Does the security group +name+ exist?
+      def exists?(name)
+        begin
+          g = list([name.to_s])
+        rescue ::EC2::InvalidGroupNotFound
+          return false 
+        end
+      
+        !g.empty?
+      end
+    
+    
+    
+    
+      # * +ghash+ is an EC2::Base Security Group Hash. This is the format
+      # returned by EC2::Base#describe_security_groups
+      #
+      #      groupName: stage-app
+      #      groupDescription: 
+      #      ownerId: "207436219441"
+      #      ipPermissions: 
+      #        item: 
+      #        - ipRanges: 
+      #            item: 
+      #            - cidrIp: 216.19.182.83/32
+      #            - cidrIp: 24.5.71.201/32
+      #            - cidrIp: 75.157.176.202/32
+      #            - cidrIp: 84.28.52.172/32
+      #            - cidrIp: 87.212.145.201/32
+      #            - cidrIp: 96.49.129.178/32
+      #          groups: 
+      #            item: 
+      #            - groupName: default
+      #              userId: "207436219441"
+      #            - groupName: stage-app
+      #              userId: "207436219441"  
+      #          fromPort: "22"
+      #          toPort: "22"
+      #          ipProtocol: tcp
+      #
+      # Returns a Rudy::AWS::EC2::Group object
+      def self.from_hash(ghash)
+        newg = Rudy::AWS::EC2::Group.new
+        newg.name = ghash['groupName']
+        newg.description = ghash['groupDescription']
+        newg.owner_id = ghash['ownerId']
+        newg.addresses = {}
+        newg.groups = {}
+        
+        return newg unless ghash['ipPermissions'].is_a?(Hash)
+        
+        ghash['ipPermissions']['item'].each do |oldp|
+          newp = Rudy::AWS::EC2::Group::Rule.new
+          newp.ports = Range.new(oldp['fromPort'], oldp['toPort'])
+          newp.protocol = oldp['ipProtocol']
+          if oldp['groups'].is_a?(Hash)
+            oldp['groups']['item'].each do |oldpg|
+              name = [oldpg['userId'], oldpg['groupName']].join(':')   # account_num:name
+              newg.add_group(name, newp)
+            end
+          end
+          if oldp['ipRanges'].is_a?(Hash)
+            oldp['ipRanges']['item'].each do |olda|
+              name = "#{olda['cidrIp']}/#{oldp['ipProtocol']}"
+              newg.add_address(name, newp)   # ipaddress/mask/protocol
+            end
+          end
+        end
+        newg
+      end
+    
+    end
+  end
+
+end

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

@@ -0,0 +1,46 @@
+
+
+module Rudy::AWS
+  class EC2
+    
+    class Images
+      include Rudy::AWS::ObjectBase
+      
+      
+      def list()
+        opts = {
+          :image_id => [],
+          :owner_id => [],
+          :executable_by => []
+        }
+        ret = @aws.describe_images_by_owner(opts) || []
+        puts ret.to_yaml
+        []
+      end
+      
+      # +id+ AMI ID to deregister (ami-XXXXXXX)
+      # Returns true when successful. Otherwise throws an exception.
+      def deregister(id)
+        opts = {
+          :image_id => id
+        }
+        ret = @aws.deregister_image(opts)
+        puts ret.to_yaml
+        true
+      end
+      
+      # +path+ the S3 path to the manifest (bucket/file.manifest.xml)
+      # Returns the AMI ID when successful, otherwise throws an exception.
+      def register(path)
+        opts = {
+          :image_location => path
+        }
+        ret = @aws.register_image(opts)
+        puts ret.to_yaml
+        true
+      end
+    end
+    
+    
+  end
+end

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

@@ -0,0 +1,407 @@
+
+
+
+module Rudy::AWS
+  class EC2::Instance < Storable
+    field :aki
+    field :ari
+    field :launch_index => Time
+    field :launch_time
+    field :keyname
+    field :instance_type
+    field :ami
+    field :dns_name_private
+    field :dns_name_public
+    field :awsid
+    field :state
+    field :zone
+    field :reason
+    field :groups => Array
+    
+    def groups
+      @groups || []
+    end
+    
+        
+    def to_s
+      lines = []
+      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 shutting_down?
+      self.state && self.state == 'shutting-down'
+    end
+      
+  end
+  
+  
+  class EC2
+    class Instances
+      include Rudy::AWS::ObjectBase
+      unless defined?(KNOWN_STATES)
+        KNOWN_STATES = [:running, :pending, :shutting_down, :terminated].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 = {
+          :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',
+          :kernel_id => nil
+        }
+      
+        response = execute_request({}) { @aws.run_instances(opts) }
+        
+        # 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)
+        instances = response['instancesSet']['item'].collect do |inst|
+          self.class.from_hash(inst)
+        end
+        
+        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
+      
+        inst_ids = objects_to_instance_ids(inst_ids)
+            
+        response = execute_request({}) {
+          @aws.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
+      
+        inst_ids = objects_to_instance_ids(inst_ids)
+            
+        response = execute_request({}) {
+          @aws.terminate_instances(:instance_id => inst_ids)
+        }
+      
+        #instancesSet: 
+        #  item: 
+        #  - instanceId: i-ebdcb882
+        #    shutdownState: 
+        #      code: "48"
+        #      name: terminated
+        #    previousState: 
+        #      code: "48"
+        #      name: terminated
+      
+        raise "The request failed to return instance data" 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) || []
+        inst_ids = objects_to_instance_ids(instances)
+        restart(inst_ids, :skip_check)
+      end
+    
+      def destroy_group(group)
+        instances = list_group(group, :running) || []
+        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=[])
+        instances = list_as_hash(state, inst_ids)
+        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=[])
+        raise "No group specified" unless group
+        instances = list_group_as_hash(group, state, inst_ids)
+        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=[])
+        raise "No group specified" unless group
+        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
+        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. 
+      def list_as_hash(state=nil, inst_ids=[])
+        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({}) {
+          @aws.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 = self.class.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 = 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_output(inst_id)
+        inst_ids = objects_to_instance_ids([inst_id])
+        response = execute_request({}) { 
+          @aws.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)
+        list = Rudy::AWS::EC2::Volumes.new(@aws).list || []
+        list.select { |v| v.status != "deleting" && 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)
+        raise "Unknown instance: #{inst_id}" unless inst
+        inst.first
+      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.instance_type = h['instanceType']
+        inst.dns_name_private = h['privateDnsName']
+        inst.dns_name_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.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