awsum 0.5

data/lib/awsum/ec2/parsers/volume_parser.rb

@@ -0,0 +1,77 @@
+module Awsum
+  class Ec2
+    class VolumeParser < Awsum::Parser #:nodoc:
+      def initialize(ec2)
+        @ec2 = ec2
+        @volumes = []
+        @text = nil
+        @stack = []
+      end
+
+      def tag_start(tag, attributes)
+        #Quick hack so we can use the same parser for CreateVolume which doesn't use the item tag to wrap the volume information
+        if tag == 'CreateVolumeResponse'
+          @stack << 'volumeSet'
+        end
+
+        case tag
+          when 'volumeSet'
+            @stack << 'volumeSet'
+          when 'attachmentSet'
+            @stack << 'attachmentSet'
+          when 'item', 'CreateVolumeResponse'
+            case @stack[-1]
+              when 'volumeSet'
+                @current = {}
+              when 'attachmentSet'
+            end
+        end
+        @text = ''
+      end
+
+      def text(text)
+        @text << text unless @text.nil?
+      end
+
+      def tag_end(tag)
+        case tag
+          when 'DescribeVolumesResponse'
+            #no-op
+          when 'volumeSet', 'attachmentSet'
+            @stack.pop
+          when 'item', 'CreateVolumeResponse'
+            case @stack[-1]
+              when 'volumeSet'
+                @volumes << Volume.new(
+                                @ec2,
+                                @current['volumeId'],
+                                @current['instanceId'],
+                                @current['size'].to_i,
+                                @current['status'],
+                                @current['createTime'].blank? ? nil :Time.parse(@current['createTime']),
+                                @current['snapshotId'],
+                                @current['device'],
+                                @current['attachTime'].blank? ? nil :Time.parse(@current['attachTime']),
+                                @current['availabilityZone'],
+                                @current['attachment_status']
+                              )
+            end
+          else
+            unless @text.nil? || @current.nil?
+              text = @text.strip
+              #Handle special case for attachmentSet/status
+              if @stack[-1] == 'attachmentSet' && tag == 'status'
+                @current['attachment_status'] = (text == '' ? nil : text)
+              else
+                @current[tag] = (text == '' ? nil : text)
+              end
+            end
+        end
+      end
+
+      def result
+        @volumes
+      end
+    end
+  end
+end

data/lib/awsum/ec2/region.rb

@@ -0,0 +1,54 @@
+require 'awsum/ec2/parsers/region_parser'
+
+module Awsum
+  class Ec2
+    class Region
+      attr_reader :name, :end_point
+
+      def initialize(ec2, name, end_point) #:nodoc:
+        @ec2 = ec2
+        @name = name
+        @end_point = end_point
+      end
+
+      # List the AvailabilityZone(s) of this Region
+      def availability_zones
+        use do
+          @ec2.availability_zones
+        end
+      end
+
+      # Operate all Awsum::Ec2 methods against this Region
+      #
+      # ====Example
+      #
+      #   ec2.region('eu-west-1').use
+      #   ec2.availability_zones #Will give you all the availability zones in the eu-west-1 region
+      #
+      #   Alternative:
+      #   ec2.region('eu-west-1') do |region|
+      #     region.availability_zones
+      #   end
+      def use(&block)
+        old_host = @ec2.host
+        @ec2.host = end_point
+        if block_given?
+          block.arity < 1 ? instance_eval(&block) : block[self]
+        else
+          self
+        end
+      ensure
+        @ec2.host = old_host
+      end
+
+    private
+      #--
+      # Will pass all missing methods onto the ec2 object
+      def method_missing(method_name, *args, &block)
+        use do
+          @ec2.send(method_name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/awsum/ec2/reserved_instance.rb

@@ -0,0 +1,24 @@
+require 'awsum/ec2/parsers/purchase_reserved_instances_offering_parser'
+require 'awsum/ec2/parsers/reserved_instance_parser'
+
+module Awsum
+  class Ec2
+    class ReservedInstance
+      attr_reader :id, :instance_type, :availability_zone, :start, :duration, :fixed_price, :usage_price, :instance_count, :product_description, :state
+
+      def initialize(ec2, id, instance_type, availability_zone, start, duration, fixed_price, usage_price, instance_count, product_description, state)
+        @ec2 = ec2
+        @id = id
+        @instance_type = instance_type
+        @availability_zone = availability_zone
+        @start = start
+        @duration = duration
+        @fixed_price = fixed_price
+        @usage_price = usage_price
+        @instance_count = instance_count
+        @product_description = product_description
+        @state = state
+      end
+    end
+  end
+end

data/lib/awsum/ec2/reserved_instances_offering.rb

@@ -0,0 +1,20 @@
+require 'awsum/ec2/parsers/reserved_instances_offering_parser'
+
+module Awsum
+  class Ec2
+    class ReservedInstancesOffering
+      attr_reader :id, :instance_type, :availability_zone, :duration, :fixed_price, :usage_price, :product_description
+
+      def initialize(ec2, id, instance_type, availability_zone, duration, fixed_price, usage_price, product_description)
+        @ec2 = ec2
+        @id = id
+        @instance_type = instance_type
+        @availability_zone = availability_zone
+        @duration = duration
+        @fixed_price = fixed_price
+        @usage_price = usage_price
+        @product_description = product_description
+      end
+    end
+  end
+end

data/lib/awsum/ec2/security_group.rb

@@ -0,0 +1,74 @@
+require 'awsum/ec2/parsers/security_group_parser'
+
+module Awsum
+  class Ec2
+    class SecurityGroup
+      attr_reader :name, :description, :owner_id, :ip_permissions, :group_permissions
+
+      def initialize(ec2, name, description, owner_id, ip_permissions, group_permissions)
+        @ec2 = ec2
+        @name = name
+        @description = description
+        @owner_id = owner_id
+        @ip_permissions = ip_permissions
+        @group_permissions = group_permissions
+      end
+
+      # Authorize access for a group
+      def authorize_group(group_name, owner_id)
+        @ec2.authorize_security_group_ingress(@name, :source_security_group_name => group_name, :source_security_group_owner_id => owner_id)
+      end
+
+      # Revoke access for a group
+      def revoke_group(group_name, owner_id)
+        @ec2.revoke_security_group_ingress(@name, :source_security_group_name => group_name, :source_security_group_owner_id => owner_id)
+      end
+
+      # Authorize access for an ip address
+      def authorize_ip(from_port, to_port, protocol = 'tcp', cidr_ip = '0.0.0.0/0')
+        @ec2.authorize_security_group_ingress(@name, :ip_protocol => protocol, :from_port => from_port, :to_port => to_port, :cidr_ip => cidr_ip)
+      end
+
+      # Revoke access from an ip address
+      def revoke_ip(from_port, to_port, protocol = 'tcp', cidr_ip = '0.0.0.0/0')
+        @ec2.revoke_security_group_ingress(@name, :ip_protocol => protocol, :from_port => from_port, :to_port => to_port, :cidr_ip => cidr_ip)
+      end
+
+      # Delete this SecurityGroup
+      def delete
+        @ec2.delete_security_group(@name)
+      end
+
+    private
+      class Permission #:nodoc:
+        attr_reader :protocol, :from_port, :to_port
+
+        def initialize(protocol, from_port, to_port)
+          @protocol = protocol
+          @from_port = from_port.to_i
+          @to_port = to_port.to_i
+        end
+      end
+
+    protected
+      class IpPermission < Permission
+        attr_reader :ip
+
+        def initialize(protocol, from_port, to_port, ip)
+          super(protocol, from_port, to_port)
+          @ip = ip
+        end
+      end
+
+      class GroupPermission < Permission
+        attr_reader :group, :user_id
+
+        def initialize(protocol, from_port, to_port, group, user_id)
+          super(protocol, from_port, to_port)
+          @group = group
+          @user_id = user_id
+        end
+      end
+    end
+  end
+end

data/lib/awsum/ec2/snapshot.rb

@@ -0,0 +1,23 @@
+require 'awsum/ec2/parsers/snapshot_parser'
+
+module Awsum
+  class Ec2
+    class Snapshot
+      attr_reader :id, :volume_id, :status, :start_time, :progress
+
+      def initialize(ec2, id, volume_id, status, start_time, progress) #:nodoc:
+        @ec2 = ec2
+        @id = id
+        @volume_id = volume_id
+        @status = status
+        @start_time = start_time
+        @progress = progress
+      end
+
+      # Delete this Snapshot
+      def delete
+        @ec2.delete_snapshot id
+      end
+    end
+  end
+end

data/lib/awsum/ec2/volume.rb

@@ -0,0 +1,65 @@
+require 'awsum/ec2/parsers/volume_parser'
+
+module Awsum
+  class Ec2
+    class Volume
+      attr_reader :id, :instance_id, :size, :status, :create_time, :snapshot_id, :device, :attach_time, :availability_zone, :attachment_status
+
+      def initialize(ec2, id, instance_id, size, status, create_time, snapshot_id, device, attach_time, availability_zone, attachment_status) #:nodoc:
+        @ec2 = ec2
+        @id = id
+        @instance_id = instance_id
+        @size = size
+        @status = status
+        @create_time = create_time
+        @snapshot_id = snapshot_id
+        @device = device
+        @attach_time = attach_time
+        @availability_zone = availability_zone
+        @attachment_status = attachment_status
+      end
+
+      # Will reload the information about this Volume
+      #
+      # Useful for when a volume has just been created but is not yet available
+      #   while volume.status != 'available'
+      #     volume.reload
+      #   end
+      def reload
+        reloaded_volume = @ec2.volume id
+
+        @id = id
+        @instance_id = reloaded_volume.instance_id
+        @size = reloaded_volume.size
+        @status = reloaded_volume.status
+        @create_time = reloaded_volume.create_time
+        @snapshot_id = reloaded_volume.snapshot_id
+        @device = reloaded_volume.device
+        @attach_time = reloaded_volume.attach_time
+        @availability_zone = reloaded_volume.availability_zone
+        @attachment_status = reloaded_volume.attachment_status
+      end
+
+      # Detach this volume
+      def detach(force = false)
+        @ec2.detach_volume id, :force => force
+      end
+
+      # Delete this volume
+      def delete
+        @ec2.delete_volume id
+      end
+
+      # Creates a Snapshot of this Volume
+      def create_snapshot
+        @ec2.create_snapshot id
+      end
+
+      # Lists the Snapshot(s) of this Volume
+      def snapshots
+        snapshots = @ec2.snapshots
+        snapshots.delete_if {|s| s.volume_id != id}
+      end
+    end
+  end
+end

data/lib/awsum/error.rb

@@ -0,0 +1,53 @@
+module Awsum
+  class Error < StandardError
+    attr_reader :response_code, :code, :message, :request_id, :additional
+
+    def initialize(response)
+      @response_code = response.code
+      parser = ErrorParser.new
+      parser.parse(response.body)
+      @code = parser.code
+      @message = parser.message
+      @request_id = parser.request_id
+      @additional = parser.additional
+    end
+
+    def inspect
+      "#<Awsum::Error response_code=#{@response_code} code=#{@code} request_id=#{@request_id} message=#{@message}>"
+    end
+
+  private
+    class ErrorParser < Awsum::Parser #:nodoc:
+      attr_reader :code, :message, :request_id, :additional
+
+      def initialize
+        @additional = {}
+        @text = ""
+      end
+
+      def tag_start(tag, attributes)
+      end
+
+      def text(text)
+        @text << text unless @text.nil?
+      end
+
+      def tag_end(tag)
+        text = @text.strip
+        return if text.blank?
+
+        case tag
+          when 'Code'
+            @code = text
+          when 'Message'
+            @message = text
+          when 'RequestID', 'RequestId'
+            @request_id = text
+          else
+            @additional[tag] = text
+        end
+        @text = ''
+      end
+    end
+  end
+end

data/lib/awsum/net_fix.rb

@@ -0,0 +1,100 @@
+# Some fixes for the net/http libraries to better suppport S3
+module Net
+  class BufferedIO
+    #Increase the default read size for streaming from the socket
+    def rbuf_fill
+      timeout(@read_timeout) {
+        @rbuf << @io.sysread(1024 * 16)
+      }
+    end
+  end
+
+  class HTTPGenericRequest
+    @@local_read_size = 1024 * 16
+
+    # Added limit which can be one of :headers or :body to limit the sending of
+    # a request to either the headers or the body in order to make use of 
+    # 100-continue processing for S3
+    def exec(sock, ver, path, limit = nil)   #:nodoc: internal use only
+      if @body
+        send_request_with_body sock, ver, path, @body, limit
+      elsif @body_stream
+        send_request_with_body_stream sock, ver, path, @body_stream, limit
+      else
+        write_header sock, ver, path
+      end
+    end
+
+    private
+    
+    # Will send both headers and body unless limit is set to either 
+    # :headers or :body to restrict to one
+    def send_request_with_body(sock, ver, path, body, limit = nil)
+      self.content_length = body.length
+      delete 'Transfer-Encoding'
+      supply_default_content_type
+      write_header sock, ver, path unless limit == :body
+      sock.write body unless limit == :headers
+    end
+    
+    # Will send both headers and body unless limit is set to either 
+    # :headers or :body to restrict to one
+    #
+    # Increased the default read size for streaming from local streams to 1MB
+    def send_request_with_body_stream(sock, ver, path, f, limit = nil)
+      unless content_length() or chunked?
+        raise ArgumentError,
+            "Content-Length not given and Transfer-Encoding is not `chunked'"
+      end
+      supply_default_content_type
+      write_header sock, ver, path unless limit == :body
+      if limit != :headers
+        if chunked?
+          while s = f.read(1024 * 1024)
+            sock.write(sprintf("%x\r\n", s.length) << s << "\r\n")
+          end
+          sock.write "0\r\n\r\n"
+        else
+          while s = f.read(1024 * 1024)
+            sock.write s
+          end
+        end
+      end
+    end
+  end
+
+  class HTTP < Protocol
+    # Patched to handle 100-continue processing for S3
+    def request(req, body = nil, &block)  # :yield: +response+
+      unless started?
+        start {
+          req['connection'] ||= 'close'
+          return request(req, body, &block)
+        }
+      end
+      if proxy_user()
+        unless use_ssl?
+          req.proxy_basic_auth proxy_user(), proxy_pass()
+        end
+      end
+
+      req.set_body_internal body
+      begin_transport req
+        # Send only the headers if a 100-continue request
+        limit = ((req.is_a?(Post) || req.is_a?(Put)) && req['expect'] == '100-continue') ? :headers : nil
+        req.exec @socket, @curr_http_version, edit_path(req.path), limit
+        begin
+          res = HTTPResponse.read_new(@socket)
+          if res.is_a?(HTTPContinue) && limit && req['content-length'].to_i > 0
+            req.exec @socket, @curr_http_version, edit_path(req.path), :body
+          end
+        end while res.kind_of?(HTTPContinue)
+        res.reading_body(@socket, req.response_body_permitted?) {
+          yield res if block_given?
+        }
+      end_transport req, res
+
+      res
+    end
+  end
+end