fog-aws 0.11.0 → 3.18.0

data/lib/fog/aws/requests/dns/delete_hosted_zone.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Real
         require 'fog/aws/parsers/dns/delete_hosted_zone'
 
@@ -24,7 +24,7 @@ module Fog
 
           request({
             :expects => 200,
-            :parser  => Fog::Parsers::DNS::AWS::DeleteHostedZone.new,
+            :parser  => Fog::Parsers::AWS::DNS::DeleteHostedZone.new,
             :method  => 'DELETE',
             :path    => "hostedzone/#{zone_id}"
           })
@@ -37,7 +37,7 @@ module Fog
         def delete_hosted_zone(zone_id)
           response = Excon::Response.new
           key = [zone_id, "/hostedzone/#{zone_id}"].find { |k| !self.data[:zones][k].nil? } ||
-            raise(Fog::DNS::AWS::NotFound.new("NoSuchHostedZone => A hosted zone with the specified hosted zone does not exist."))
+            raise(Fog::AWS::DNS::NotFound.new("NoSuchHostedZone => A hosted zone with the specified hosted zone does not exist."))
 
             change = {
               :id => Fog::AWS::Mock.change_id,

data/lib/fog/aws/requests/dns/get_change.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Real
         require 'fog/aws/parsers/dns/get_change'
 
@@ -23,7 +23,7 @@ module Fog
 
           request({
             :expects => 200,
-            :parser  => Fog::Parsers::DNS::AWS::GetChange.new,
+            :parser  => Fog::Parsers::AWS::DNS::GetChange.new,
             :method  => 'GET',
             :path    => "change/#{change_id}"
           })
@@ -36,7 +36,7 @@ module Fog
           # find the record with matching change_id
           # records = data[:zones].values.map{|z| z[:records].values.map{|r| r.values}}.flatten
           change = self.data[:changes][change_id] ||
-            raise(Fog::DNS::AWS::NotFound.new("NoSuchChange => Could not find resource with ID: #{change_id}"))
+            raise(Fog::AWS::DNS::NotFound.new("NoSuchChange => Could not find resource with ID: #{change_id}"))
 
           response.status = 200
           submitted_at = Time.parse(change[:submitted_at])

data/lib/fog/aws/requests/dns/get_health_check.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Real
         require 'fog/aws/parsers/dns/health_check'
 
@@ -30,7 +30,7 @@ module Fog
         def get_health_check(id)
           request({
             :expects => 200,
-            :parser  => Fog::Parsers::DNS::AWS::HealthCheck.new,
+            :parser  => Fog::Parsers::AWS::DNS::HealthCheck.new,
             :method  => 'GET',
             :path    => "healthcheck/#{id}"
           })

data/lib/fog/aws/requests/dns/get_hosted_zone.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Real
         require 'fog/aws/parsers/dns/get_hosted_zone'
 
@@ -29,7 +29,7 @@ module Fog
             :expects => 200,
             :idempotent => true,
             :method  => 'GET',
-            :parser  => Fog::Parsers::DNS::AWS::GetHostedZone.new,
+            :parser  => Fog::Parsers::AWS::DNS::GetHostedZone.new,
             :path    => "hostedzone/#{zone_id}"
           })
         end
@@ -51,7 +51,7 @@ module Fog
             }
             response
           else
-            raise Fog::DNS::AWS::NotFound.new("NoSuchHostedZone => A hosted zone with the specified hosted zone ID does not exist.")
+            raise Fog::AWS::DNS::NotFound.new("NoSuchHostedZone => A hosted zone with the specified hosted zone ID does not exist.")
           end
         end
       end

data/lib/fog/aws/requests/dns/list_health_checks.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Real
         require 'fog/aws/parsers/dns/list_health_checks'
 
@@ -26,7 +26,7 @@ module Fog
             :expects => 200,
             :method  => 'GET',
             :path    => "healthcheck",
-            :parser  => Fog::Parsers::DNS::AWS::ListHealthChecks.new
+            :parser  => Fog::Parsers::AWS::DNS::ListHealthChecks.new
           })
         end
       end

data/lib/fog/aws/requests/dns/list_hosted_zones.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Real
         require 'fog/aws/parsers/dns/list_hosted_zones'
 
@@ -38,7 +38,7 @@ module Fog
 
           request({
             :query   => parameters,
-            :parser  => Fog::Parsers::DNS::AWS::ListHostedZones.new,
+            :parser  => Fog::Parsers::AWS::DNS::ListHostedZones.new,
             :expects => 200,
             :method  => 'GET',
             :path    => "hostedzone"

data/lib/fog/aws/requests/dns/list_resource_record_sets.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Real
         require 'fog/aws/parsers/dns/list_resource_record_sets'
 
@@ -51,7 +51,7 @@ module Fog
             :expects => 200,
             :idempotent => true,
             :method  => 'GET',
-            :parser  => Fog::Parsers::DNS::AWS::ListResourceRecordSets.new,
+            :parser  => Fog::Parsers::AWS::DNS::ListResourceRecordSets.new,
             :path    => "hostedzone/#{zone_id}/rrset",
             :query   => parameters
           })
@@ -64,7 +64,7 @@ module Fog
             tmp_records.push(record) if !record[:name].nil? && ( name.nil? || record[:name].gsub(zone[:name],"") >= name)
             record.each do |key,subr|
               if subr.is_a?(Hash) && key.is_a?(String) &&
-                key.start_with?(Fog::DNS::AWS::Mock::SET_PREFIX)
+                key.start_with?(Fog::AWS::DNS::Mock::SET_PREFIX)
                 if name.nil?
                   tmp_records.append(subr)
                 else
@@ -81,7 +81,7 @@ module Fog
           response = Excon::Response.new
 
           zone = self.data[:zones][zone_id] ||
-            raise(Fog::DNS::AWS::NotFound.new("NoSuchHostedZone => A hosted zone with the specified hosted zone ID does not exist."))
+            raise(Fog::AWS::DNS::NotFound.new("NoSuchHostedZone => A hosted zone with the specified hosted zone ID does not exist."))
 
           records = if options[:type]
                       records_type = zone[:records][options[:type]]

data/lib/fog/aws/requests/dynamodb/update_item.rb

@@ -7,15 +7,15 @@ module Fog
         #
         # ==== Parameters
         # * 'table_name'<~String> - name of table for item
-        # * 'key'<~Hash> - list of elements to be updated and their value
+        # * 'key'<~Hash> - list of Key attributes
         #   {
         #     "ForumName": {"S": "Amazon DynamoDB"},
         #     "Subject": {"S": "Maximum number of items?"}
         #   }
         #
         # * 'options'<~Hash>:
-        #   * 'KeyConditionExpression'<~String> - the condition elements need to match
-        #   * 'ExpressionAttributeValues'<~Hash> - values to be used in the key condition expression
+        #   * 'UpdateExpression'<~String> - the expression that will update the item
+        #   * 'ExpressionAttributeValues'<~Hash> - values to be used in the update expression
         #   * 'ReturnValues'<~String> - data to return in %w{ALL_NEW ALL_OLD NONE UPDATED_NEW UPDATED_OLD}, defaults to NONE
         #
         # ==== Returns
@@ -29,13 +29,14 @@ module Fog
           if deprecated_attribute_updates
             raise DeprecatedAttributeUpdates, "The `20111205` DynamoDB API is deprecated. You need to use `ExpressionAttributeValues` instead of `AttributeUpdates`."
             attribute_updates = options
-            options = deprecated_attribute_updates
+            options = deprecated_attribute_updates.merge(
+              'AttributeUpdates'  => attribute_updates,
+            )
           end
 
           body = {
             'Key'               => key,
             'TableName'         => table_name,
-            'AttributeUpdates'  => attribute_updates,
           }.merge(options)
 
           request(

data/lib/fog/aws/requests/efs/create_file_system.rb

@@ -0,0 +1,63 @@
+module Fog
+  module AWS
+    class EFS
+      class Real
+        # Create a new, empty file system
+        # http://docs.aws.amazon.com/efs/latest/ug/API_CreateFileSystem.html
+        # ==== Parameters
+        # * CreationToken <~String> - String of up to 64 ASCII characters. Amazon EFS uses this to ensure idempotent creation.
+        # * PerformanceMode <~String> - (Optional) The PerformanceMode of the file system. We recommend generalPurpose performance mode for most file systems. File systems using the maxIO performance mode can scale to higher levels of aggregate throughput and operations per second with a tradeoff of slightly higher latencies for most file operations. This can't be changed after the file system has been created.
+        # * Encrypted <~Boolean> - (Optional) A Boolean value that, if true, creates an encrypted file system. When creating an encrypted file system, you have the option of specifying a CreateFileSystem:KmsKeyId for an existing AWS Key Management Service (AWS KMS) customer master key (CMK). If you don't specify a CMK, then the default CMK for Amazon EFS, /aws/elasticfilesystem, is used to protect the encrypted file system. 
+        # * KmsKeyId <~String> - (Optional) The ID of the AWS KMS CMK to be used to protect the encrypted file system. This parameter is only required if you want to use a non-default CMK. If this parameter is not specified, the default CMK for Amazon EFS is used. This ID can be in one of the following formats:
+        #   - Key ID - A unique identifier of the key, for example, 1234abcd-12ab-34cd-56ef-1234567890ab.
+        #   - ARN - An Amazon Resource Name (ARN) for the key, for example, arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab.
+        #   - Key alias - A previously created display name for a key. For example, alias/projectKey1.
+        #   - Key alias ARN - An ARN for a key alias, for example, arn:aws:kms:us-west-2:444455556666:alias/projectKey1.
+        #   If KmsKeyId is specified, the CreateFileSystem:Encrypted parameter must be set to true.
+        # ==== Returns
+        # * response<~Excon::Response>
+        #   * body<~Hash>
+        def create_file_system(creation_token, options={})
+          params = {
+            :path             => "file-systems",
+            :method           => 'POST',
+            :expects          => 201,
+            'CreationToken'   => creation_token,
+            'PerformanceMode' => options[:peformance_mode] || 'generalPurpose',
+            'Encrypted'       => options[:encrypted] || false
+          }
+          params[:kms_key_id] = options[:kms_key_id] if options.key?(:kms_key_id)
+          request(params)
+        end
+      end
+
+      class Mock
+        def create_file_system(creation_token, options={})
+          response = Excon::Response.new
+
+          id = "fs-#{Fog::Mock.random_letters(8)}"
+          file_system = {
+            "OwnerId"              => Fog::AWS::Mock.owner_id,
+            "CreationToken"        => creation_token,
+            "PerformanceMode"      => options[:performance_mode] || "generalPurpose",
+            "Encrypted"            => options[:encrypted] || false,
+            "FileSystemId"         => id,
+            "CreationTime"         => Time.now.to_i.to_f,
+            "LifeCycleState"       => "creating",
+            "NumberOfMountTargets" => 0,
+            "SizeInBytes"          => {
+              "Value"     => 1024,
+              "Timestamp" => Time.now.to_i.to_f
+            }
+          }
+          file_system[:kms_key_id] = options[:kms_key_id] if options.key?(:kms_key_id)
+
+          self.data[:file_systems][id] = file_system
+          response.body = file_system
+          response.status = 201
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/efs/create_mount_target.rb

@@ -0,0 +1,73 @@
+module Fog
+  module AWS
+    class EFS
+      class Real
+        # Create a mount target for a specified file system
+        # http://docs.aws.amazon.com/efs/latest/ug/API_CreateMountTarget.html
+        # ==== Parameters
+        # * FileSystemId <~String> - ID of the file system for which to create the mount target.
+        # * IpAddress <~String> - Valid IPv4 address within the address range of the specified subnet.
+        # * SecurityGroups <~Array> - Up to five VPC security group IDs, of the form sg-xxxxxxxx. These must be for the same VPC as subnet specified.
+        # * SubnetId <~String> - ID of the subnet to add the mount target in.
+        # ==== Returns
+        # * response<~Excon::Response>
+        #   * body<~Hash>
+        def create_mount_target(file_system_id, subnet_id, options={})
+          request({
+            :path          => "mount-targets",
+            :method        => "POST",
+            'FileSystemId' => file_system_id,
+            'SubnetId'     => subnet_id
+          }.merge(options))
+        end
+      end
+
+      class Mock
+        def create_mount_target(file_system_id, subnet_id, options={})
+          response               = Excon::Response.new
+          default_security_group = mock_compute.data[:security_groups].find do |_, sg|
+            sg['groupDescription'] == 'default_elb security group'
+          end
+          security_groups        = options["SecurityGroups"] || [default_security_group.first]
+
+          unless file_system = self.data[:file_systems][file_system_id]
+            raise Fog::AWS::EFS::NotFound.new("invalid file system ID: #{file_system_id}")
+          end
+
+          unless file_system["LifeCycleState"] == 'available'
+            # this error doesn't include a message for some reason
+            raise Fog::AWS::EFS::IncorrectFileSystemLifeCycleState.new("")
+          end
+
+          unless subnet = mock_compute.subnets.get(subnet_id)
+            raise Fog::AWS::EFS::InvalidSubnet.new("invalid subnet ID: #{subnet_id}")
+          end
+
+          security_groups.each do |group_id|
+            unless mock_compute.data[:security_groups][group_id]
+              raise Fog::AWS::EFS::NotFound.new("invalid security group ID: #{group_id}")
+            end
+          end
+
+          id = "fsmt-#{Fog::Mock.random_letters(8)}"
+
+          mount_target = {
+            'MountTargetId'      => id,
+            'FileSystemId'       => file_system_id,
+            'IpAddress'          => Fog::AWS::Mock.ip_address,
+            'OwnerId'            => Fog::AWS::Mock.owner_id,
+            'LifeCycleState'     => 'creating',
+            'NetworkInterfaceId' => "eni-#{Fog::Mock.random_hex(8)}",
+            'SubnetId'           => subnet.identity,
+          }
+
+          self.data[:mount_targets][id]   = mount_target
+          self.data[:security_groups][id] = security_groups
+
+          response.body = mount_target
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/efs/delete_file_system.rb

@@ -0,0 +1,41 @@
+module Fog
+  module AWS
+    class EFS
+      class Real
+        # Delete a file system
+        # http://docs.aws.amazon.com/efs/latest/ug/API_DeleteFileSystem.html
+        # ==== Parameters
+        # * FileSystemId <~String> - ID of the file system you want to delete.
+        # ==== Returns
+        # * response<~Excon::Response>
+        #   * body - Empty
+        #   * status - 204
+        def delete_file_system(id)
+          request({
+            :path             => "file-systems/#{id}",
+            :method           => 'DELETE',
+            :expects          => 204,
+          })
+        end
+      end
+
+      class Mock
+        def delete_file_system(id)
+          unless file_system = self.data[:file_systems][id]
+            raise Fog::AWS::EFS::NotFound.new("invalid file system ID: #{id}")
+          end
+
+          if file_system["NumberOfMountTargets"] > 0
+            raise Fog::AWS::EFS::FileSystemInUse.new("")
+          end
+
+          self.data[:file_systems].delete(id)
+
+          response = Excon::Response.new
+          response.status = 204
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/efs/delete_mount_target.rb

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class EFS
+      class Real
+        # Delete a mount target
+        # http://docs.aws.amazon.com/efs/latest/ug/API_DeleteMountTarget.html
+        # ==== Parameters
+        # * MountTargetId <~String> - ID of the mount target you want to delete
+        # ==== Returns
+        # * response<~Excon::Response>
+        #   * body - Empty
+        #   * status - 204
+        def delete_mount_target(id)
+          request(
+            :path    => "mount-targets/#{id}",
+            :method  => "DELETE",
+            :expects => 204
+          )
+        end
+      end
+
+      class Mock
+        def delete_mount_target(id)
+          response = Excon::Response.new
+
+          unless self.data[:mount_targets][id]
+            raise Fog::AWS::EFS::NotFound.new("invalid mount target ID: #{id}")
+          end
+
+          self.data[:mount_targets].delete(id)
+
+          response.status = 204
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/efs/describe_file_systems.rb

@@ -0,0 +1,62 @@
+module Fog
+  module AWS
+    class EFS
+      class Real
+        # Describe all or specified elastic file systems
+        # http://docs.aws.amazon.com/efs/latest/ug/API_DescribeFileSystems.html
+        # ==== Parameters
+        # * CreationToken <~String> - (Optional) Restricts the list to the file system with this creation token (String). You specify a creation token when you create an Amazon EFS file system.
+        # * FileSystemId <~String> - (Optional) ID of the file system whose description you want to retrieve (String).
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>
+        def describe_file_systems(options={})
+          params = {}
+          if options[:marker]
+            params['Marker'] = options[:marker]
+          end
+          if options[:max_records]
+            params['MaxRecords'] = options[:max_records]
+          end
+          if options[:id]
+            params['FileSystemId'] = options[:id]
+          end
+          if options[:creation_token]
+            params['CreationToken'] = options[:creation_token]
+          end
+
+          request({
+            :path => "file-systems"
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def describe_file_systems(options={})
+          response = Excon::Response.new
+
+          file_systems = if id = options[:id]
+                           if fs = self.data[:file_systems][id]
+                             [fs]
+                           else
+                             raise Fog::AWS::EFS::NotFound.new("invalid file system ID: #{id}")
+                           end
+                         elsif creation_token = options[:creation_token]
+                           fs = self.data[:file_systems].values.detect { |file_system| file_system["CreationToken"] == creation_token }
+                           [fs]
+                         else
+                           self.data[:file_systems].values
+                         end
+
+          file_systems.each do |file_system|
+            file_system['LifeCycleState'] = 'available'
+            self.data[:file_systems][file_system['FileSystemId']] = file_system
+          end
+
+          response.body = {"FileSystems" => file_systems}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/efs/describe_mount_target_security_groups.rb

@@ -0,0 +1,34 @@
+module Fog
+  module AWS
+    class EFS
+      class Real
+        # Describe mount target security groups
+        # http://docs.aws.amazon.com/efs/latest/ug/API_DescribeMountTargetSecurityGroups.html
+        # ==== Parameters
+        # * MountTargetId - Id of the mount target for which you want to describe security groups
+        # ==== Returns
+        # * response<~Excon::Response>
+        # * body<~Hash>
+
+        def describe_mount_target_security_groups(mount_target_id)
+          request(
+            :path => "mount-targets/#{mount_target_id}/security-groups"
+          )
+        end
+      end
+
+      class Mock
+        def describe_mount_target_security_groups(mount_target_id)
+          response = Excon::Response.new
+
+          unless self.data[:mount_targets][mount_target_id]
+            raise Fog::AWS::EFS::NotFound.new("invalid mount target ID: #{mount_target_id}")
+          end
+
+          response.body = {"SecurityGroups" => self.data[:security_groups][mount_target_id]}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/efs/describe_mount_targets.rb

@@ -0,0 +1,61 @@
+module Fog
+  module AWS
+    class EFS
+      class Real
+        # Describe all mount targets for a filesystem, or specified mount target
+        # http://docs.aws.amazon.com/efs/latest/ug/API_DescribeMountTargets.html
+        # ==== Parameters
+        # * FileSystemId<~String> - Id of file system to describe mount targets for.  Required unless MountTargetId is specified
+        # * MountTargetId<~String> - Specific mount target to describe.  Required if FileSystemId is not specified
+        # ==== Returns
+        # * response<~Excon::Response>
+        #   * body<~Hash>
+        def describe_mount_targets(options={})
+          params = {}
+          if options[:marker]
+            params['Marker'] = options[:marker]
+          end
+          if options[:max_records]
+            params['MaxRecords'] = options[:max_records]
+          end
+          if options[:id]
+            params['MountTargetId'] = options[:id]
+          end
+          if options[:file_system_id]
+            params['FileSystemId'] = options[:file_system_id]
+          end
+
+          request({
+            :path => "mount-targets"
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def describe_mount_targets(options={})
+          response = Excon::Response.new
+
+          mount_targets = if id = options[:id]
+                            if mount_target = self.data[:mount_targets][id]
+                              [mount_target]
+                            else
+                              raise Fog::AWS::EFS::NotFound.new("Mount target does not exist.")
+                            end
+                          elsif file_system_id = options[:file_system_id]
+                            self.data[:mount_targets].values.select { |mt| mt["FileSystemId"] == file_system_id }
+                          else
+                            raise Fog::AWS::EFS::Error.new("file system ID or mount target ID must be specified")
+                          end
+
+          mount_targets.each do |mount_target|
+            mount_target['LifeCycleState'] = 'available'
+            self.data[:mount_targets][mount_target["MountTargetId"]] = mount_target
+          end
+
+          response.body = {"MountTargets" => mount_targets}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/efs/modify_mount_target_security_groups.rb

@@ -0,0 +1,39 @@
+module Fog
+  module AWS
+    class EFS
+      class Real
+        def modify_mount_target_security_groups(id, security_groups)
+          request({
+            :path            => "mount-targets/#{id}/security-groups",
+            :method          => "PUT",
+            :expects         => 204,
+            'SecurityGroups' => security_groups
+          })
+        end
+      end
+
+      class Mock
+        def modify_mount_target_security_groups(id, security_groups)
+          if security_groups.nil? || security_groups.empty?
+            raise Fog::AWS::EFS::Error.new("Must provide at least one security group.")
+          end
+
+          response = Excon::Response.new
+
+          unless self.data[:mount_targets][id]
+            raise Fog::AWS::EFS::NotFound.new("invalid mount target ID: #{id}")
+          end
+
+          security_groups.each do |sg|
+            raise Fog::AWS::EFS::NotFound.new("invalid security group ID: #{sg}") unless mock_compute.data[:security_groups].values.detect { |sgd| sgd["groupId"] == sg }
+          end
+
+          self.data[:security_groups][id] = security_groups
+
+          response.status = 204
+          response
+        end
+      end
+    end
+  end
+end