fog 0.0.3

data/lib/fog/aws/parsers/simpledb/get_attributes.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Parsers
+    module AWS
+      module SimpleDB
+
+        class GetAttributes < Fog::Parsers::AWS::SimpleDB::Basic
+
+          def reset
+            @attribute = nil
+            @response = { 'Attributes' => {} }
+          end
+
+          def end_element(name)
+            case name
+            when 'Attribute'
+              @attribute = nil
+            when 'BoxUsage'
+              response[name] = @value.to_f
+            when 'Name'
+              @attribute = @value
+              response['Attributes'][@attribute] = []
+            when 'RequestId'
+              response[name] = @value
+            when 'Value'
+              response['Attributes'][@attribute] << sdb_decode(@value)
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/simpledb/list_domains.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Parsers
+    module AWS
+      module SimpleDB
+
+        class ListDomains < Fog::Parsers::AWS::SimpleDB::Basic
+
+          def reset
+            @response = { 'Domains' => [] }
+          end
+
+          def end_element(name)
+            case(name)
+            when 'BoxUsage'
+              response[name] = @value.to_f
+            when 'DomainName'
+              response['Domains'] << @value
+            when 'NextToken', 'RequestId'
+              response[name] = @value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/simpledb/select.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Parsers
+    module AWS
+      module SimpleDB
+
+        class Select < Fog::Parsers::AWS::SimpleDB::Basic
+
+          def reset
+            @item_name = @attribute_name = nil
+            @response = { 'Items' => {} }
+          end
+
+          def end_element(name)
+            case name
+            when 'BoxUsage'
+              response[name] = @value.to_f
+            when 'Item'
+              @item_name = @attribute_name = nil
+            when 'Name'
+              if @item_name.nil? 
+                @item_name = @value
+                response['Items'][@item_name] = {}
+              else
+                @attribute_name = @value
+                response['Items'][@item_name][@attribute_name] = []
+              end
+            when 'NextToken', 'RequestId'
+              response[name] = @value
+            when 'Value'
+              response['Items'][@item_name][@attribute_name] << sdb_decode(@value)
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ec2/allocate_address.rb

@@ -0,0 +1,50 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Acquire an elastic IP address.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'publicIp'<~String> - The acquired address
+        #     * 'requestId'<~String> - Id of the request
+        def allocate_address
+          request({
+            'Action' => 'AllocateAddress'
+          }, Fog::Parsers::AWS::EC2::AllocateAddress.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def allocate_address
+          response = Fog::Response.new
+          response.status = 200
+          public_ip = Fog::AWS::Mock.ip_address
+          data ={
+            'instanceId' => '',
+            'publicIp'   => public_ip
+          }
+          Fog::AWS::EC2.data[:addresses][public_ip] = data
+          response.body = {
+            'publicIp'  => public_ip,
+            'requestId' => Fog::AWS::Mock.request_id
+          }
+          response
+        end
+
+      end
+    end
+  end
+
+end

data/lib/fog/aws/requests/ec2/associate_address.rb

@@ -0,0 +1,59 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Associate an elastic IP address with an instance
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Id of instance to associate address with
+        # * public_ip<~String> - Public ip to assign to instance
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def associate_address(instance_id, public_ip)
+          request({
+            'Action' => 'AssociateAddress',
+            'InstanceId' => instance_id,
+            'PublicIp' => public_ip
+          }, Fog::Parsers::AWS::EC2::Basic.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def associate_address(instance_id, public_ip)
+          response = Fog::Response.new
+          response.status = 200
+          instance = Fog::AWS::EC2.data[:instances][instance_id]
+          address = Fog::AWS::EC2.data[:addresses][public_ip]
+          if instance && address
+            address['instanceId'] = instance_id
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end

data/lib/fog/aws/requests/ec2/attach_volume.rb

@@ -0,0 +1,71 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Attach an Amazon EBS volume with a running instance, exposing as specified device
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Id of instance to associate volume with
+        # * volume_id<~String> - Id of amazon EBS volume to associate with instance
+        # * device<~String> - Specifies how the device is exposed to the instance (e.g. "/dev/sdh")
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'attachTime'<~Time> - Time of attachment was initiated at
+        #     * 'device'<~String> - Device as it is exposed to the instance
+        #     * 'instanceId'<~String> - Id of instance for volume
+        #     * 'requestId'<~String> - Id of request
+        #     * 'status'<~String> - Status of volume
+        #     * 'volumeId'<~String> - Reference to volume
+        def attach_volume(instance_id, volume_id, device)
+          request({
+            'Action' => 'AttachVolume',
+            'VolumeId' => volume_id,
+            'InstanceId' => instance_id,
+            'Device' => device
+          }, Fog::Parsers::AWS::EC2::AttachVolume.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def attach_volume(instance_id, volume_id, device)
+          response = Fog::Response.new
+          response.status = 200
+          instance = Fog::AWS::EC2.data[:instances][instance_id]
+          volume = Fog::AWS::EC2.data[:volumes][volume_id]
+          if instance && volume
+            data = {
+              'attachTime'  => Time.now,
+              'device'      => device,
+              'instanceId'  => instance_id,
+              'status'      => 'attaching',
+              'volumeId'    => volume_id
+            }
+            volume['attachmentSet'] << data
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data)
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end

data/lib/fog/aws/requests/ec2/authorize_security_group_ingress.rb

@@ -0,0 +1,32 @@
+module Fog
+  module AWS
+    class EC2
+
+      # Add permissions to a security group
+      #
+      # ==== Parameters
+      # * options<~Hash>:
+      #   * 'GroupName'<~String> - Name of group
+      #   * 'SourceSecurityGroupName'<~String> - Name of security group to authorize
+      #   * 'SourceSecurityGroupOwnerId'<~String> - Name of owner to authorize
+      #   or
+      #   * 'CidrIp' - CIDR range
+      #   * 'FromPort' - Start of port range (or -1 for ICMP wildcard)
+      #   * 'GroupName' - Name of group to modify
+      #   * 'IpProtocol' - Ip protocol, must be in ['tcp', 'udp', 'icmp']
+      #   * 'ToPort' - End of port range (or -1 for ICMP wildcard)
+      #
+      # === Returns
+      # * response<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'requestId'<~String> - Id of request
+      #     * 'return'<~Boolean> - success?
+      def authorize_security_group_ingress(options = {})
+        request({
+          'Action' => 'AuthorizeSecurityGroupIngress'
+        }.merge!(options), Fog::Parsers::AWS::EC2::Basic.new)
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/ec2/create_key_pair.rb

@@ -0,0 +1,60 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Create a new key pair
+        #
+        # ==== Parameters
+        # * key_name<~String> - Unique name for key pair.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'keyFingerprint'<~String> - SHA-1 digest of DER encoded private key
+        #     * 'keyMaterial'<~String> - Unencrypted encoded PEM private key
+        #     * 'keyName'<~String> - Name of key
+        #     * 'requestId'<~String> - Id of request
+        def create_key_pair(key_name)
+          request({
+            'Action' => 'CreateKeyPair',
+            'KeyName' => key_name
+          }, Fog::Parsers::AWS::EC2::CreateKeyPair.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def create_key_pair(key_name)
+          response = Fog::Response.new
+          unless Fog::AWS::EC2.data[:key_pairs][key_name]
+            response.status = 200
+            data = {
+              'keyFingerprint'  => Fog::AWS::Mock.key_fingerprint,
+              'keyMaterial'     => Fog::AWS::Mock.key_material,
+              'keyName'         => key_name
+            }
+            Fog::AWS::EC2.data[:key_pairs][key_name] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data)
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end

data/lib/fog/aws/requests/ec2/create_security_group.rb

@@ -0,0 +1,61 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Create a new security group
+        #
+        # ==== Parameters
+        # * group_name<~String> - Name of the security group.
+        # * group_description<~String> - Description of group.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def create_security_group(name, description)
+          request({
+            'Action' => 'CreateSecurityGroup',
+            'GroupName' => name,
+            'GroupDescription' => CGI.escape(description)
+          }, Fog::Parsers::AWS::EC2::Basic.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def create_security_group(name, description)
+          response = Fog::Response.new
+          unless Fog::AWS::EC2.data[:security_groups][name]
+            data = {
+              'GroupDescription'  => description,
+              'GroupName'         => name,
+              'ipPermissions'     => [],
+              'OwnerId'           => Fog::AWS::Mock.owner_id
+            }
+            Fog::AWS::EC2.data[:security_groups][name] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end

data/lib/fog/aws/requests/ec2/create_snapshot.rb

@@ -0,0 +1,65 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Create a snapshot of an EBS volume and store it in S3
+        #
+        # ==== Parameters
+        # * volume_id<~String> - Id of EBS volume to snapshot
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'progress'<~String> - The percentage progress of the snapshot
+        #     * 'requestId'<~String> - id of request
+        #     * 'snapshotId'<~String> - id of snapshot
+        #     * 'startTime'<~Time> - timestamp when snapshot was initiated
+        #     * 'status'<~String> - state of snapshot
+        #     * 'volumeId'<~String> - id of volume snapshot targets
+        def create_snapshot(volume_id)
+          request({
+            'Action' => 'CreateSnapshot',
+            'VolumeId' => volume_id
+          }, Fog::Parsers::AWS::EC2::CreateSnapshot.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def create_snapshot(volume_id)
+          response = Fog::Response.new
+          if Fog::AWS::EC2.data[:volumes][volume_id]
+            response.status = 200
+            snapshot_id = Fog::AWS::Mock.snapshot_id
+            data = {
+              'progress'    => '',
+              'snapshotId'  => snapshot_id,
+              'startTime'   => Time.now,
+              'status'      => 'pending',
+              'volumeId'    => volume_id
+            }
+            Fog::AWS::EC2.data[:snapshots][snapshot_id] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data)
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end