fog-aws 0.0.5

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

@@ -0,0 +1,65 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/basic'
+
+        # 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?
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateTags.html]
+        def create_tags(resources, tags)
+          resources = [*resources]
+          for key, value in tags
+            if value.nil?
+              tags[key] = ''
+            end
+          end
+          params = {}
+          params.merge!(Fog::AWS.indexed_param('ResourceId', resources))
+          params.merge!(Fog::AWS.indexed_param('Tag.%d.Key', tags.keys))
+          params.merge!(Fog::AWS.indexed_param('Tag.%d.Value', tags.values))
+          request({
+            'Action'    => 'CreateTags',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def create_tags(resources, tags)
+          resources = [*resources]
+          tagged = tagged_resources(resources)
+
+          tags.each do |key, value|
+            self.data[:tags][key] ||= {}
+            self.data[:tags][key][value] ||= []
+            self.data[:tags][key][value] |= tagged
+
+            tagged.each do |resource|
+              self.data[:tag_sets][resource['resourceId']][key] = value
+            end
+          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/aws/requests/compute/create_volume.rb

@@ -0,0 +1,124 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/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.
+        # * options<~Hash>
+        #   * 'SnapshotId'<~String> - Optional, snapshot to create volume from
+        #   * 'VolumeType'<~String> - Optional, volume type. standard or io1, default is standard.
+        #   * 'Iops'<~Integer> - Number of IOPS the volume supports. Required if VolumeType is io1, must be between 1 and 4000.
+        #   * 'Encrypted'<~Boolean> - Optional, specifies whether the volume should be encrypted, default is false.
+        #
+        # ==== 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'<~String> - State of volume
+        #     * 'volumeId'<~String> - Reference to volume
+        #     * 'volumeType'<~String> - Type of volume
+        #     * 'iops'<~Integer> - Number of IOPS the volume supports
+        #     * 'encrypted'<~Boolean> - Indicates whether the volume will be encrypted
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateVolume.html]
+        def create_volume(availability_zone, size, options = {})
+          unless options.is_a?(Hash)
+            Fog::Logger.deprecation("create_volume with a bare snapshot_id is deprecated, use create_volume(availability_zone, size, 'SnapshotId' => snapshot_id) instead [light_black](#{caller.first})[/]")
+            options = { 'SnapshotId' => options }
+          end
+
+          request({
+            'Action'            => 'CreateVolume',
+            'AvailabilityZone'  => availability_zone,
+            'Size'              => size,
+            :parser             => Fog::Parsers::Compute::AWS::CreateVolume.new
+          }.merge(options))
+        end
+      end
+
+      class Mock
+        def create_volume(availability_zone, size, options = {})
+          unless options.is_a?(Hash)
+            Fog::Logger.deprecation("create_volume with a bare snapshot_id is deprecated, use create_volume(availability_zone, size, 'SnapshotId' => snapshot_id) instead [light_black](#{caller.first})[/]")
+            options = { 'SnapshotId' => options }
+          end
+
+          response = Excon::Response.new
+          if availability_zone && (size || options['SnapshotId'])
+            snapshot = self.data[:snapshots][options['SnapshotId']]
+            if options['SnapshotId'] && !snapshot
+              raise Fog::Compute::AWS::NotFound.new("The snapshot '#{options['SnapshotId']}' does not exist.")
+            end
+
+            if snapshot && size && size < snapshot['volumeSize']
+              raise Fog::Compute::AWS::NotFound.new("The snapshot '#{options['SnapshotId']}' has size #{snapshot['volumeSize']} which is greater than #{size}.")
+            elsif snapshot && !size
+              size = snapshot['volumeSize']
+            end
+
+            if options['VolumeType'] == 'io1'
+              iops = options['Iops']
+              if !iops
+                raise Fog::Compute::AWS::Error.new("InvalidParameterCombination => The parameter iops must be specified for io1 volumes.")
+              end
+
+              if size < 10
+                raise Fog::Compute::AWS::Error.new("InvalidParameterValue => Volume of #{size}GiB is too small; minimum is 10GiB.")
+              end
+
+              if (iops_to_size_ratio = iops.to_f / size.to_f) > 30.0
+                raise Fog::Compute::AWS::Error.new("InvalidParameterValue => Iops to volume size ratio of #{"%.1f" % iops_to_size_ratio} is too high; maximum is 30.0")
+              end
+
+              if iops < 100
+                raise Fog::Compute::AWS::Error.new("VolumeIOPSLimit => Volume iops of #{iops} is too low; minimum is 100.")
+              end
+
+              if iops > 4000
+                raise Fog::Compute::AWS::Error.new("VolumeIOPSLimit => Volume iops of #{iops} is too high; maximum is 4000.")
+              end
+            end
+
+            response.status = 200
+            volume_id = Fog::AWS::Mock.volume_id
+            data = {
+              'availabilityZone'  => availability_zone,
+              'attachmentSet'     => [],
+              'createTime'        => Time.now,
+              'iops'              => options['Iops'],
+              'encrypted'         => options['Encrypted'] || false,
+              'size'              => size,
+              'snapshotId'        => options['SnapshotId'],
+              'status'            => 'creating',
+              'volumeId'          => volume_id,
+              'volumeType'        => options['VolumeType'] || 'standard'
+            }
+            self.data[:volumes][volume_id] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data.reject {|key,value| !['availabilityZone','createTime','encrypted','size','snapshotId','status','volumeId','volumeType'].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/aws/requests/compute/create_vpc.rb

@@ -0,0 +1,94 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/create_vpc'
+
+        # Creates a VPC with the CIDR block you specify.
+        #
+        # ==== Parameters
+        # * cidrBlock<~String> - The CIDR block you want the VPC to cover (e.g., 10.0.0.0/16).
+        # * options<~Hash>:
+        #   * InstanceTenancy<~String> - The allowed tenancy of instances launched into the VPC. A value of default
+        #     means instances can be launched with any tenancy; a value of dedicated means instances must be launched with tenancy as dedicated.
+        #     please not that the documentation is incorrect instanceTenancy will not work while InstanceTenancy will
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'vpc'<~Array>:
+        # * 'vpcId'<~String> - The VPC's ID
+        # * 'state'<~String> - The current state of the VPC. ['pending', 'available']
+        # * 'cidrBlock'<~String> - The CIDR block the VPC covers.
+        # * 'dhcpOptionsId'<~String> - The ID of the set of DHCP options.
+        # * 'tagSet'<~Array>: Tags assigned to the resource.
+        # * 'key'<~String> - Tag's key
+        # * 'value'<~String> - Tag's value
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2011-07-15/APIReference/index.html?ApiReference-query-CreateVpc.html]
+        def create_vpc(cidrBlock, options = {})
+          request({
+            'Action' => 'CreateVpc',
+            'CidrBlock' => cidrBlock,
+            :parser => Fog::Parsers::Compute::AWS::CreateVpc.new
+          }.merge!(options))
+        end
+      end
+
+      class Mock
+        def create_vpc(cidrBlock)
+          Excon::Response.new.tap do |response|
+            if cidrBlock
+              response.status = 200
+              vpc_id = Fog::AWS::Mock.vpc_id
+              vpc = {
+                'vpcId'              => vpc_id,
+                'state'              => 'pending',
+                'cidrBlock'          => cidrBlock,
+                'dhcpOptionsId'      => Fog::AWS::Mock.request_id,
+                'tagSet'             => {},
+                'enableDnsSupport'   => true,
+                'enableDnsHostnames' => false,
+                'mapPublicIpOnLaunch'=> false
+              }
+              self.data[:vpcs].push(vpc)
+
+              #Creates a default route for the subnet
+              default_route = self.route_tables.new(:vpc_id => vpc_id)
+              default_route.save
+
+              # You are not able to push a main route in the normal AWS, so we are re-implementing some of the
+              # associate_route_table here in order to accomplish this.
+              route_table = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? default_route.id }
+
+              # This pushes a main route to the associationSet
+              # add_route_association(routeTableId, subnetId, main=false) is declared in assocate_route_table.rb
+              assoc = add_route_association(default_route.id, nil, true)
+              route_table["associationSet"].push(assoc)
+
+              # Create a default network ACL
+              default_nacl = self.network_acls.new(:vpc_id => vpc_id)
+              default_nacl.save
+              # Manually override since Amazon doesn't let you create a default one
+              self.data[:network_acls][default_nacl.network_acl_id]['default'] = true
+
+              response.body = {
+                'requestId' => Fog::AWS::Mock.request_id,
+                'vpcSet'    => [vpc]
+              }
+            else
+              response.status = 400
+              response.body = {
+                'Code' => 'InvalidParameterValue'
+              }
+              if cidrBlock.empty?
+                response.body['Message'] = "Invalid value '' for cidrBlock. Must be specified."
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/basic'
+        #Deletes a set of DHCP options that you specify. Amazon VPC returns an error if the set of options you specify is currently
+        #associated with a VPC. You can disassociate the set of options by associating either a new set of options or the default
+        #options with the VPC.
+        #
+        # ==== Parameters
+        # * dhcp_options_id<~String> - The ID of the DHCP options set you want to delete.
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'return'<~Boolean> - Returns true if the request succeeds.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DeleteDhcpOptions.html]
+        def delete_dhcp_options(dhcp_options_id)
+          request(
+            'Action' => 'DeleteDhcpOptions',
+            'DhcpOptionsId' => dhcp_options_id,
+            :parser => Fog::Parsers::Compute::AWS::Basic.new
+          )
+        end
+      end
+
+      class Mock
+        def delete_dhcp_options(dhcp_options_id)
+          Excon::Response.new.tap do |response|
+            if dhcp_options_id
+              response.status = 200
+              self.data[:dhcp_options].reject! { |v| v['dhcpOptionsId'] == dhcp_options_id }
+
+              response.body = {
+                'requestId' => Fog::AWS::Mock.request_id,
+                'return' => true
+              }
+            else
+              message = 'MissingParameter => '
+              message << 'The request must contain the parameter dhcp_options_id'
+              raise Fog::Compute::AWS::Error.new(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/basic'
+        #Deletes an Internet gateway from your AWS account. The gateway must not be attached to a VPC
+        #
+        # ==== Parameters
+        # * internet_gateway_id<~String> - The ID of the InternetGateway you want to delete.
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'return'<~Boolean> - Returns true if the request succeeds.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DeleteInternetGateway.html]
+        def delete_internet_gateway(internet_gateway_id)
+          request(
+            'Action' => 'DeleteInternetGateway',
+            'InternetGatewayId' => internet_gateway_id,
+            :parser => Fog::Parsers::Compute::AWS::Basic.new
+          )
+        end
+      end
+
+      class Mock
+        def delete_internet_gateway(internet_gateway_id)
+          Excon::Response.new.tap do |response|
+            if internet_gateway_id
+              response.status = 200
+              self.data[:internet_gateways].delete(internet_gateway_id)
+
+              response.body = {
+                'requestId' => Fog::AWS::Mock.request_id,
+                'return' => true
+              }
+            else
+              message = 'MissingParameter => '
+              message << 'The request must contain the parameter internet_gateway_id'
+              raise Fog::Compute::AWS::Error.new(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/basic'
+
+        # 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?
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DeleteKeyPair.html]
+        def delete_key_pair(key_name)
+          request(
+            'Action'    => 'DeleteKeyPair',
+            'KeyName'   => key_name,
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+          )
+        end
+      end
+
+      class Mock
+        def delete_key_pair(key_name)
+          response = Excon::Response.new
+          self.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

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

@@ -0,0 +1,52 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/basic'
+
+        # Deletes a network ACL.
+        #
+        # ==== Parameters
+        # * network_acl_id<~String> - The ID of the network ACL you want to delete.
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'return'<~Boolean> - Returns true if the request succeeds.
+        #
+        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-DeleteNetworkAcl.html]
+        def delete_network_acl(network_acl_id)
+          request(
+            'Action'       => 'DeleteNetworkAcl',
+            'NetworkAclId' => network_acl_id,
+            :parser        => Fog::Parsers::Compute::AWS::Basic.new
+          )
+        end
+      end
+
+      class Mock
+        def delete_network_acl(network_acl_id)
+          response = Excon::Response.new
+          if self.data[:network_acls][network_acl_id]
+
+            if self.data[:network_acls][network_acl_id]['associationSet'].any?
+              raise Fog::Compute::AWS::Error.new("ACL is in use")
+            end
+
+            self.data[:network_acls].delete(network_acl_id)
+
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
+          end
+        end
+      end
+    end
+  end
+end