phpfog-fog 0.4.1

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

@@ -0,0 +1,201 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/describe_instances'
+
+        # Describe all or specified instances
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'reservationSet'<~Array>:
+        #       * 'groupSet'<~Array> - Group names for reservation
+        #       * 'ownerId'<~String> - AWS Access Key ID of reservation owner
+        #       * 'reservationId'<~String> - Id of the reservation
+        #       * 'instancesSet'<~Array>:
+        #         * instance<~Hash>:
+        #           * 'architecture'<~String> - architecture of image in [i386, x86_64]
+        #           * 'amiLaunchIndex'<~Integer> - reference to instance in launch group
+        #           * 'blockDeviceMapping'<~Array>
+        #             * 'attachTime'<~Time> - time of volume attachment
+        #             * 'deleteOnTermination'<~Boolean> - whether or not to delete volume on termination
+        #             * 'deviceName'<~String> - specifies how volume is exposed to instance
+        #             * 'status'<~String> - status of attached volume
+        #             * 'volumeId'<~String> - Id of attached volume
+        #           * 'dnsName'<~String> - public dns name, blank until instance is running
+        #           * 'imageId'<~String> - image id of ami used to launch instance
+        #           * 'instanceId'<~String> - id of the instance
+        #           * 'instanceState'<~Hash>:
+        #             * 'code'<~Integer> - current status code
+        #             * 'name'<~String> - current status name
+        #           * 'instanceType'<~String> - type of instance
+        #           * 'ipAddress'<~String> - public ip address assigned to instance
+        #           * 'kernelId'<~String> - id of kernel used to launch instance
+        #           * 'keyName'<~String> - name of key used launch instances or blank
+        #           * 'launchTime'<~Time> - time instance was launched
+        #           * 'monitoring'<~Hash>:
+        #             * 'state'<~Boolean - state of monitoring
+        #           * 'placement'<~Hash>:
+        #             * 'availabilityZone'<~String> - Availability zone of the instance
+        #           * 'productCodes'<~Array> - Product codes for the instance
+        #           * 'privateDnsName'<~String> - private dns name, blank until instance is running
+        #           * 'privateIpAddress'<~String> - private ip address assigned to instance
+        #           * 'rootDeviceName'<~String> - specifies how the root device is exposed to the instance
+        #           * 'rootDeviceType'<~String> - root device type used by AMI in [ebs, instance-store]
+        #           * 'ramdiskId'<~String> - Id of ramdisk used to launch instance
+        #           * 'reason'<~String> - reason for most recent state transition, or blank
+        def describe_instances(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_instances with #{filters.class} param is deprecated, use describe_instances('instance-id' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'instance-id' => [*filters]}
+          end
+          params = AWS.indexed_filters(filters)
+
+          request({
+            'Action'    => 'DescribeInstances',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::DescribeInstances.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_instances(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_instances with #{filters.class} param is deprecated, use describe_instances('instance-id' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'instance-id' => [*filters]}
+          end
+
+          if filters.keys.any? {|key| key =~ /^tag/}
+            Formatador.display_line("[yellow][WARN] describe_instances tag filters are not yet mocked[/] [light_black](#{caller.first})[/]")
+            Fog::Mock.not_implemented
+          end
+
+          response = Excon::Response.new
+
+          instance_set = @data[:instances].values
+
+          aliases = {
+            'architecture'      => 'architecture',
+            'availability-zone' => 'availabilityZone',
+            'client-token'      => 'clientToken',
+            'dns-token'         => 'dnsName',
+            'group-id'          => 'groupId',
+            'image-id'          => 'imageId',
+            'instance-id'       => 'instanceId',
+            'instance-lifecycle'  => 'instanceLifecycle',
+            'instance-type'     => 'instanceType',
+            'ip-address'        => 'ipAddress',
+            'kernel-id'         => 'kernelId',
+            'key-name'          => 'key-name',
+            'launch-index'      => 'launchIndex',
+            'launch-time'       => 'launchTime',
+            'monitoring-state'  => 'monitoringState',
+            'owner-id'          => 'ownerId',
+            'placement-group-name' => 'placementGroupName',
+            'platform'          => 'platform',
+            'private-dns-name'  => 'privateDnsName',
+            'private-ip-address'  => 'privateIpAddress',
+            'product-code'      => 'productCode',
+            'ramdisk-id'        => 'ramdiskId',
+            'reason'            => 'reason',
+            'requester-id'      => 'requesterId',
+            'reservation-id'    => 'reservationId',
+            'root-device-name'  => 'rootDeviceName',
+            'root-device-type'  => 'rootDeviceType',
+            'spot-instance-request-id' => 'spotInstanceRequestId',
+            'subnet-id'         => 'subnetId',
+            'virtualization-type' => 'virtualizationType',
+            'vpc-id'            => 'vpcId'
+          }
+          block_device_mapping_aliases = {
+            'attach-time'           => 'attachTime',
+            'delete-on-termination' => 'deleteOnTermination',
+            'device-name'           => 'deviceName',
+            'status'                => 'status',
+            'volume-id'             => 'volumeId',
+          }
+          instance_state_aliases = {
+            'code' => 'code',
+            'name' => 'name'
+          }
+          state_reason_aliases = {
+            'code'    => 'code',
+            'message' => 'message'
+          }
+          for filter_key, filter_value in filters
+            if block_device_mapping_key = filter_key.split('block-device-mapping.')[1]
+              aliased_key = block_device_mapping_aliases[block_device_mapping_key]
+              instance_set = instance_set.reject{|instance| !instance['blockDeviceMapping'].detect {|block_device_mapping| [*filter_value].include?(block_device_mapping[aliased_key])}}
+            elsif instance_state_key = filter_key.split('instance-state-')[1]
+              aliased_key = instance_state_aliases[instance_state_key]
+              instance_set = instance_set.reject{|instance| ![*filter_value].include?(instance['instanceState'][aliased_key])}
+            elsif state_reason_key = filter_key.split('state-reason-')[1]
+              aliased_key = state_reason_aliases[state_reason_key]
+              instance_set = instance_set.reject{|instance| ![*filter_value].include?(instance['stateReason'][aliased_key])}
+            else
+              aliased_key = aliases[filter_key]
+              instance_set = instance_set.reject {|instance| ![*filter_value].include?(instance[aliased_key])}
+            end
+          end
+
+          response.status = 200
+          reservation_set = {}
+
+          instance_set.each do |instance|
+            case instance['instanceState']['name']
+            when 'pending'
+              if Time.now - instance['launchTime'] > Fog::Mock.delay
+                instance['ipAddress']         = Fog::AWS::Mock.ip_address
+                instance['dnsName']           = Fog::AWS::Mock.dns_name_for(instance['ipAddress'])
+                instance['privateIpAddress']  = Fog::AWS::Mock.ip_address
+                instance['privateDnsName']    = Fog::AWS::Mock.private_dns_name_for(instance['privateIpAddress'])
+                instance['instanceState']     = { 'code' => 16, 'name' => 'running' }
+              end
+            when 'rebooting'
+              instance['instanceState'] = { 'code' => 16, 'name' => 'running' }
+            when 'shutting-down'
+              if Time.now - @data[:deleted_at][instance['instanceId']] > Fog::Mock.delay * 2
+                @data[:deleted_at].delete(instance['instanceId'])
+                @data[:instances].delete(instance['instanceId'])
+              elsif Time.now - @data[:deleted_at][instance['instanceId']] > Fog::Mock.delay
+                instance['instanceState'] = { 'code' => 48, 'name' => 'terminating' }
+              end
+            when 'terminating'
+              if Time.now - @data[:deleted_at][instance['instanceId']] > Fog::Mock.delay
+                @data[:deleted_at].delete(instance['instanceId'])
+                @data[:instances].delete(instance['instanceId'])
+              end
+            end
+
+            if @data[:instances][instance['instanceId']]
+
+              reservation_set[instance['reservationId']] ||= {
+                'groupSet'      => instance['groupSet'],
+                'instancesSet'  => [],
+                'ownerId'       => instance['ownerId'],
+                'reservationId' => instance['reservationId']
+              }
+              reservation_set[instance['reservationId']]['instancesSet'] << instance.reject{|key,value| !['amiLaunchIndex', 'architecture', 'blockDeviceMapping', 'clientToken', 'dnsName', 'imageId', 'instanceId', 'instanceState', 'instanceType', 'ipAddress', 'kernelId', 'keyName', 'launchTime', 'monitoring', 'placement', 'privateDnsName', 'privateIpAddress', 'productCodes', 'ramdiskId', 'reason', 'rootDeviceType', 'stateReason', 'tagSet'].include?(key)}
+            end
+          end
+
+          response.body = {
+            'requestId'       => Fog::AWS::Mock.request_id,
+            'reservationSet' => reservation_set.values
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/describe_key_pairs'
+
+        # Describe all or specified key pairs
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'keySet'<~Array>:
+        #       * 'keyName'<~String> - Name of key
+        #       * 'keyFingerprint'<~String> - Fingerprint of key
+        def describe_key_pairs(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_key_pairs with #{filters.class} param is deprecated, use describe_key_pairs('key-name' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'key-name' => [*filters]}
+          end
+          params = AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeKeyPairs',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::DescribeKeyPairs.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_key_pairs(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_key_pairs with #{filters.class} param is deprecated, use describe_key_pairs('key-name' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'key-name' => [*filters]}
+          end
+
+          response = Excon::Response.new
+
+          key_set = @data[:key_pairs].values
+
+          aliases = {'fingerprint' => 'keyFingerprint', 'key-name' => 'keyName'}
+          for filter_key, filter_value in filters
+            aliased_key = aliases[filter_key]
+            key_set = key_set.reject{|key_pair| ![*filter_value].include?(key_pair[aliased_key])}
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'keySet'    => key_set.map do |key_pair|
+              key_pair.reject {|key,value| !['keyFingerprint', 'keyName'].include?(key)}
+            end
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/describe_regions'
+
+        # Describe all or specified regions
+        #
+        # ==== Params
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'regionInfo'<~Array>:
+        #       * 'regionName'<~String> - Name of region
+        #       * 'regionEndpoint'<~String> - Service endpoint for region
+        def describe_regions(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_regions with #{filters.class} param is deprecated, use describe_regions('region-name' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'region-name' => [*filters]}
+          end
+          params = AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeRegions',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::DescribeRegions.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_regions(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_regions with #{filters.class} param is deprecated, use describe_regions('region-name' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'region-name' => [*filters]}
+          end
+
+          response = Excon::Response.new
+          region_info = [
+            {"regionName"=>"eu-west-1", "regionEndpoint"=>"eu-west-1.ec2.amazonaws.com"},
+            {"regionName"=>"us-east-1", "regionEndpoint"=>"us-east-1.ec2.amazonaws.com"}
+          ]
+
+          aliases = {'region-name' => 'regionName', 'endpoint' => 'regionEndpoint'}
+          for filter_key, filter_value in filters
+            aliased_key = aliases[filter_key]
+            region_info = region_info.reject{|region| ![*filter_value].include?(region[aliased_key])}
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId'   => Fog::AWS::Mock.request_id,
+            'regionInfo'  => region_info
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/describe_reserved_instances'
+
+        # Describe all or specified reserved instances
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'reservedInstancesSet'<~Array>:
+        #       * 'availabilityZone'<~String> - availability zone of the instance
+        #       * 'duration'<~Integer> - duration of reservation, in seconds
+        #       * 'fixedPrice'<~Float> - purchase price of reserved instance
+        #       * 'instanceType'<~String> - type of instance
+        #       * 'instanceCount'<~Integer> - number of reserved instances
+        #       * 'productDescription'<~String> - reserved instance description
+        #       * 'reservedInstancesId'<~String> - id of the instance
+        #       * 'start'<~Time> - start time for reservation
+        #       * 'state'<~String> - state of reserved instance purchase, in .[pending-payment, active, payment-failed, retired]
+        #       * 'usagePrice"<~Float> - usage price of reserved instances, per hour
+        def describe_reserved_instances(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_reserved_instances with #{filters.class} param is deprecated, use describe_reserved_instances('reserved-instances-id' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'reserved-instances-id' => [*filters]}
+          end
+          params = AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeReservedInstances',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::DescribeReservedInstances.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_reserved_instances(filters = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/describe_security_groups'
+
+        # Describe all or specified security groups
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'securityGroupInfo'<~Array>:
+        #       * 'groupDescription'<~String> - Description of security group
+        #       * 'groupName'<~String> - Name of security group
+        #       * 'ipPermissions'<~Array>:
+        #         * 'fromPort'<~Integer> - Start of port range (or -1 for ICMP wildcard)
+        #         * 'groups'<~Array>:
+        #           * 'groupName'<~String> - Name of security group
+        #           * 'userId'<~String> - AWS User Id of account
+        #         * 'ipProtocol'<~String> - Ip protocol, must be in ['tcp', 'udp', 'icmp']
+        #         * 'ipRanges'<~Array>:
+        #           * 'cidrIp'<~String> - CIDR range
+        #         * 'toPort'<~Integer> - End of port range (or -1 for ICMP wildcard)
+        #       * 'ownerId'<~String> - AWS Access Key Id of the owner of the security group
+        def describe_security_groups(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_security_groups with #{filters.class} param is deprecated, use describe_security_groups('group-name' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'group-name' => [*filters]}
+          end
+          params = AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeSecurityGroups',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::DescribeSecurityGroups.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_security_groups(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_security_groups with #{filters.class} param is deprecated, use describe_security_groups('group-name' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'group-name' => [*filters]}
+          end
+
+          response = Excon::Response.new
+
+          security_group_info = @data[:security_groups].values
+
+          aliases = {
+            'description' => 'groupDescription',
+            'group-name'  => 'groupName',
+            'owner-id'    => 'ownerId'
+          }
+          permission_aliases = {
+            'cidr'      => 'cidrIp',
+            'from-port' => 'fromPort',
+            'protocol'  => 'ipProtocol',
+            'to-port'   => 'toPort'
+          }
+          for filter_key, filter_value in filters
+            if permission_key = filter_key.split('ip-permission.')[1]
+              if permission_key == 'group-name'
+                security_group_info = security_group_info.reject{|security_group| !security_group['ipPermissions']['groups'].detect {|group| [*filter_value].include?(group['groupName'])}}
+              elsif permission_key == 'user-id'
+                security_group_info = security_group_info.reject{|security_group| !security_group['ipPermissions']['groups'].detect {|group| [*filter_value].include?(group['userId'])}}
+              else
+                aliased_key = permission_aliases[filter_key]
+                security_group_info = security_group_info.reject{|security_group| !security_group['ipPermissions'].detect {|permission| [*filter_value].include?(permission[aliased_key])}}
+              end
+            else
+              aliased_key = aliases[filter_key]
+              security_group_info = security_group_info.reject{|security_group| ![*filter_value].include?(security_group[aliased_key])}
+            end
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId'         => Fog::AWS::Mock.request_id,
+            'securityGroupInfo' => security_group_info
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/describe_snapshots'
+
+        # Describe all or specified snapshots
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        # * options<~Hash>:
+        #   * 'Owner'<~String> - Owner of snapshot in ['self', 'amazon', account_id]
+        #   * 'RestorableBy'<~String> - Account id of user who can create volumes from this snapshot
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'snapshotSet'<~Array>:
+        #       * 'progress'<~String>: The percentage progress of the snapshot
+        #       * 'snapshotId'<~String>: Id of the snapshot
+        #       * 'startTime'<~Time>: Timestamp of when snapshot was initiated
+        #       * 'status'<~String>: Snapshot state, in ['pending', 'completed']
+        #       * 'volumeId'<~String>: Id of volume that snapshot contains
+        def describe_snapshots(filters = {}, options = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_snapshots with #{filters.class} param is deprecated, use describe_snapshots('snapshot-id' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'snapshot-id' => [*filters]}
+          end
+          unless options.empty?
+            Formatador.display_line("[yellow][WARN] describe_snapshots with a second param is deprecated, use describe_snapshots(options) instead[/] [light_black](#{caller.first})[/]")
+          end
+
+          for key in ['ExecutableBy', 'ImageId', 'Owner', 'RestorableBy']
+            if filters.has_key?(key)
+              options[key] = filters.delete(key)
+            end
+          end
+          options['RestorableBy'] ||= 'self'
+          params = AWS.indexed_filters(filters).merge!(options)
+          request({
+            'Action'    => 'DescribeSnapshots',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::DescribeSnapshots.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_snapshots(filters = {}, options = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_snapshots with #{filters.class} param is deprecated, use describe_snapshots('snapshot-id' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'snapshot-id' => [*filters]}
+          end
+          unless options.empty?
+            Formatador.display_line("[yellow][WARN] describe_snapshots with a second param is deprecated, use describe_snapshots(options) instead[/] [light_black](#{caller.first})[/]")
+          end
+
+          if filters.keys.any? {|key| key =~ /^tag/}
+            Formatador.display_line("[yellow][WARN] describe_snapshots tag filters are not yet mocked[/] [light_black](#{caller.first})[/]")
+            Fog::Mock.not_implemented
+          end
+
+          response = Excon::Response.new
+
+          snapshot_set = @data[:snapshots].values
+
+          if filters.delete('owner-alias')
+            Formatador.display_line("[yellow][WARN] describe_snapshots with owner-alias is not mocked[/] [light_black](#{caller.first})[/]")
+          end
+          if filters.delete('RestorableBy')
+            Formatador.display_line("[yellow][WARN] describe_snapshots with RestorableBy is not mocked[/] [light_black](#{caller.first})[/]")
+          end
+
+          aliases = {
+            'description' => 'description',
+            'owner-id'    => 'ownerId',
+            'progress'    => 'progress',
+            'snapshot-id' => 'snapshotId',
+            'start-time'  => 'startTime',
+            'status'      => 'status',
+            'volume-id'   => 'volumeId',
+            'volume-size' => 'volumeSize'
+          }
+          for filter_key, filter_value in filters
+            aliased_key = aliases[filter_key]
+            snapshot_set = snapshot_set.reject{|snapshot| ![*filter_value].include?(snapshot[aliased_key])}
+          end
+
+          snapshot_set.each do |snapshot|
+            case snapshot['status']
+            when 'in progress', 'pending'
+              if Time.now - snapshot['startTime'] > Fog::Mock.delay * 2
+                snapshot['progress']  = '100%'
+                snapshot['status']    = 'completed'
+              elsif Time.now - snapshot['startTime'] > Fog::Mock.delay
+                snapshot['progress']  = '50%'
+                snapshot['status']    = 'in progress'
+              else
+                snapshot['progress']  = '0%'
+                snapshot['status']    = 'in progress'
+              end
+            end
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'snapshotSet' => snapshot_set
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/aws/describe_tags'
+
+        # Describe all or specified tags
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'tagSet'<~Array>:
+        #       * 'resourceId'<~String> - id of resource tag belongs to
+        #       * 'resourceType'<~String> - type of resource tag belongs to
+        #       * 'key'<~String> - Tag's key
+        #       * 'value'<~String> - Tag's value
+        def describe_tags(filters = {})
+          params = AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeTags',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::DescribeTags.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_tags(filters = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end