phpfog-fog 0.4.1

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

@@ -0,0 +1,57 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # 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<~Excon::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,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::AWS::Compute::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def associate_address(instance_id, public_ip)
+          response = Excon::Response.new
+          response.status = 200
+          instance = @data[:instances][instance_id]
+          address = @data[:addresses][public_ip]
+          if instance && address
+            address['instanceId'] = instance_id
+            instance['originalIpAddress'] = instance['ipAddress']
+            instance['ipAddress'] = public_ip
+            instance['dnsName'] = Fog::AWS::Mock.dns_name_for(public_ip)
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          elsif !instance
+            raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist")
+          elsif !address
+            raise Fog::AWS::Compute::Error.new("AuthFailure => The address '#{public_ip}' does not belong to you.")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/attach_volume'
+
+        # 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<~Excon::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,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::AWS::Compute::AttachVolume.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def attach_volume(instance_id, volume_id, device)
+          response = Excon::Response.new
+          if instance_id && volume_id && device
+            response.status = 200
+            instance = @data[:instances][instance_id]
+            volume = @data[:volumes][volume_id]
+            if instance && volume
+              data = {
+                'attachTime'  => Time.now,
+                'device'      => device,
+                'instanceId'  => instance_id,
+                'status'      => 'attaching',
+                'volumeId'    => volume_id
+              }
+              volume['attachmentSet'] = [data]
+              volume['status'] = 'attaching'
+              response.status = 200
+              response.body = {
+                'requestId' => Fog::AWS::Mock.request_id
+              }.merge!(data)
+              response
+            elsif !instance
+              raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist.")
+            elsif !volume
+              raise Fog::AWS::Compute::NotFound.new("The volume '#{volume_id}' does not exist.")
+            end
+          else
+            message = 'MissingParameter => '
+            if !instance_id
+              message << 'The request must contain the parameter instance_id'
+            elsif !volume_id
+              message << 'The request must contain the parameter volume_id'
+            else
+              message << 'The request must contain the parameter device'
+            end
+            raise Fog::AWS::Compute::Error.new(message)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # 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<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def authorize_security_group_ingress(options = {})
+          request({
+            'Action'    => 'AuthorizeSecurityGroupIngress',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def authorize_security_group_ingress(options = {})
+          response = Excon::Response.new
+          group = @data[:security_groups][options['GroupName']]
+
+          if group
+            group['ipPermissions'] ||= []
+            if options['GroupName'] && options['SourceSecurityGroupName'] && options['SourceSecurityGroupOwnerId']
+              ['tcp', 'udp'].each do |protocol|
+                group['ipPermissions'] << {
+                  'groups'      => [{'groupName' => options['GroupName'], 'userId' => @owner_id}],
+                  'fromPort'    => 1,
+                  'ipRanges'    => [],
+                  'ipProtocol'  => protocol,
+                  'toPort'      => 65535
+                }
+              end
+              group['ipPermissions'] << {
+                'groups'      => [{'groupName' => options['GroupName'], 'userId' => @owner_id}],
+                'fromPort'    => -1,
+                'ipRanges'    => [],
+                'ipProtocol'  => 'icmp',
+                'toPort'      => -1
+              }
+            else
+              group['ipPermissions'] << {
+                'groups'      => [],
+                'fromPort'    => options['FromPort'],
+                'ipRanges'    => [],
+                'ipProtocol'  => options['IpProtocol'],
+                'toPort'      => options['ToPort']
+              }
+              if options['CidrIp']
+                group['ipPermissions'].last['ipRanges'] << { 'cidrIp' => options['CidrIp'] }
+              end
+            end
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::AWS::Compute::NotFound.new("The security group '#{options['GroupName']}' does not exist")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/aws/create_image.rb

@@ -0,0 +1,64 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/create_image'
+
+        # Create a bootable EBS volume AMI
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Instance used to create image.
+        # * name<~Name> - Name to give image.
+        # * description<~Name> - Description of image.
+        # * no_reboot<~Boolean> - Optional, whether or not to reboot the image when making the snapshot
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'imageId'<~String> - The ID of the created AMI.
+        #     * 'requestId'<~String> - Id of request.
+        
+        def create_image(instance_id, name, description, no_reboot = false)
+          request(
+            'Action'            => 'CreateImage',
+            'InstanceId'        => instance_id,
+            'Name'              => name,
+            'Description'       => description,
+            'NoReboot'          => no_reboot.to_s,
+            :parser             => Fog::Parsers::AWS::Compute::CreateImage.new
+          )
+        end
+      end
+
+      class Mock
+        
+        # Usage
+        # 
+        # AWS[:compute].create_image("i-ac65ee8c", "test", "something")
+        #
+        
+        def create_image(instance_id, name, description, no_reboot = false)
+          response = Excon::Response.new
+          if instance_id && !name.empty?
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'imageId' => Fog::AWS::Mock.image_id
+            }
+          else
+            response.status = 400
+            response.body = {
+              'Code' => 'InvalidParameterValue'
+            }
+            if name.empty?
+              response.body['Message'] = "Invalid value '' for name. Must be specified."
+            end
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/create_key_pair'
+
+        # Create a new key pair
+        #
+        # ==== Parameters
+        # * key_name<~String> - Unique name for key pair.
+        #
+        # ==== Returns
+        # * response<~Excon::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,
+            :parser   => Fog::Parsers::AWS::Compute::CreateKeyPair.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_key_pair(key_name)
+          response = Excon::Response.new
+          unless @data[:key_pairs][key_name]
+            response.status = 200
+            data = {
+              'keyFingerprint'  => Fog::AWS::Mock.key_fingerprint,
+              'keyMaterial'     => Fog::AWS::Mock.key_material,
+              'keyName'         => key_name
+            }
+            @data[:key_pairs][key_name] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data)
+            response
+          else
+            raise Fog::AWS::Compute::Error.new("InvalidKeyPair.Duplicate => The keypair '#{key_name}' already exists.")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Create a new security group
+        #
+        # ==== Parameters
+        # * group_name<~String> - Name of the security group.
+        # * group_description<~String> - Description of group.
+        #
+        # ==== Returns
+        # * response<~Excon::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),
+            :parser             => Fog::Parsers::AWS::Compute::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_security_group(name, description)
+          response = Excon::Response.new
+          unless @data[:security_groups][name]
+            data = {
+              'groupDescription'  => CGI.escape(description).gsub('%20', '+'),
+              'groupName'         => CGI.escape(name).gsub('%20', '+'),
+              'ipPermissions'     => [],
+              'ownerId'           => @owner_id
+            }
+            @data[:security_groups][name] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::AWS::Compute::Error.new("InvalidGroup.Duplicate => The security group '#{name}' already exists")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/create_snapshot'
+
+        # Create a snapshot of an EBS volume and store it in S3
+        #
+        # ==== Parameters
+        # * volume_id<~String> - Id of EBS volume to snapshot
+        #
+        # ==== Returns
+        # * response<~Excon::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, description = nil)
+          request(
+            'Action'      => 'CreateSnapshot',
+            'Description' => description,
+            'VolumeId'    => volume_id,
+            :parser       => Fog::Parsers::AWS::Compute::CreateSnapshot.new
+          )
+        end
+
+      end
+
+      class Mock
+        
+        #
+        # Usage
+        #
+        # AWS[:compute].create_snapshot("vol-f7c23423", "latest snapshot")
+        #
+        
+        def create_snapshot(volume_id, description = nil)
+          response = Excon::Response.new
+          if volume = @data[:volumes][volume_id]
+            response.status = 200
+            snapshot_id = Fog::AWS::Mock.snapshot_id
+            data = {
+              'description' => description,
+              'ownerId'     => @owner_id,
+              'progress'    => nil,
+              'snapshotId'  => snapshot_id,
+              'startTime'   => Time.now,
+              'status'      => 'pending',
+              'volumeId'    => volume_id,
+              'volumeSize'  => volume['size']
+            }
+            @data[:snapshots][snapshot_id] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data)
+            @data[:snapshots][snapshot_id]['tagSet'] = {}
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/aws/create_tags.rb

@@ -0,0 +1,78 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Adds tags to resources
+        #
+        # ==== Parameters
+        # * resources<~String> - One or more resources to tag
+        # * tags<~String> - hash of key value tag pairs to assign
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def create_tags(resources, tags)
+          resources = [*resources]
+          for key, value in tags
+            if value.nil?
+              tags[key] = ''
+            end
+          end
+          params = {}
+          params.merge!(AWS.indexed_param('ResourceId', resources))
+          params.merge!(AWS.indexed_param('Tag.%d.Key', tags.keys))
+          params.merge!(AWS.indexed_param('Tag.%d.Value', tags.values))
+          request({
+            'Action'            => 'CreateTags',
+            :parser             => Fog::Parsers::AWS::Compute::Basic.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def create_tags(resources, tags)
+          resources = [*resources]
+
+          tagged = resources.map do |resource_id|
+            type = case resource_id
+            when /^ami\-[a-z0-9]{8}$/i
+              'image'
+            when /^i\-[a-z0-9]{8}$/i
+              'instance'
+            when /^snap\-[a-z0-9]{8}$/i
+              'snapshot'
+            when /^vol\-[a-z0-9]{8}$/i
+              'volume'
+            end
+            if type && @data[:"#{type}s"][resource_id]
+              { 'resourceId' => resource_id, 'resourceType' => type }
+            else
+              raise(Fog::Service::NotFound.new("The #{type} ID '#{resource_id}' does not exist"))
+            end
+          end
+
+          tags.each do |key, value|
+            @data[:tags][key] ||= {}
+            @data[:tags][key][value] ||= []
+            @data[:tags][key][value] = @data[:tags][key][value] & tagged
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'return'    => true
+          }
+          response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/compute/requests/aws/create_volume.rb

@@ -0,0 +1,74 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/create_volume'
+
+        # Create an EBS volume
+        #
+        # ==== Parameters
+        # * availability_zone<~String> - availability zone to create volume in
+        # * size<~Integer> - Size in GiBs for volume.  Must be between 1 and 1024.
+        # * snapshot_id<~String> - Optional, snapshot to create volume from
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'availabilityZone'<~String> - Availability zone for volume
+        #     * 'createTime'<~Time> - Timestamp for creation
+        #     * 'size'<~Integer> - Size in GiBs for volume
+        #     * 'snapshotId'<~String> - Snapshot volume was created from, if any
+        #     * 'status's<~String> - State of volume
+        #     * 'volumeId'<~String> - Reference to volume
+        def create_volume(availability_zone, size, snapshot_id = nil)
+          request(
+            'Action'            => 'CreateVolume',
+            'AvailabilityZone'  => availability_zone,
+            'Size'              => size,
+            'SnapshotId'        => snapshot_id,
+            :parser             => Fog::Parsers::AWS::Compute::CreateVolume.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_volume(availability_zone, size, snapshot_id = nil)
+          response = Excon::Response.new
+          if availability_zone && size
+            response.status = 200
+            volume_id = Fog::AWS::Mock.volume_id
+            data = {
+              'availabilityZone'  => availability_zone,
+              'attachmentSet'     => [],
+              'createTime'        => Time.now,
+              'size'              => size,
+              'snapshotId'        => snapshot_id,
+              'status'            => 'creating',
+              'tagSet'            => {},
+              'volumeId'          => volume_id
+            }
+            @data[:volumes][volume_id] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data.reject {|key,value| !['availabilityZone','createTime','size','snapshotId','status','volumeId'].include?(key) })
+          else
+            response.status = 400
+            response.body = {
+              'Code' => 'MissingParameter'
+            }
+            unless availability_zone
+              response.body['Message'] = 'The request must contain the parameter availability_zone'
+            else
+              response.body['Message'] = 'The request must contain the parameter size'
+            end
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/aws/delete_key_pair.rb

@@ -0,0 +1,43 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Delete a key pair that you own
+        #
+        # ==== Parameters
+        # * key_name<~String> - Name of the key pair.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> id of request
+        #     * 'return'<~Boolean> - success?
+        def delete_key_pair(key_name)
+          request(
+            'Action'    => 'DeleteKeyPair',
+            'KeyName'   => key_name,
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def delete_key_pair(key_name)
+          response = Excon::Response.new
+          @data[:key_pairs].delete(key_name)
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'return'    => true
+          }
+          response
+        end
+
+      end
+    end
+  end
+end