fog-aws 0.0.5

data/lib/fog/aws/requests/iam/update_user.rb

@@ -0,0 +1,37 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+        require 'fog/aws/parsers/iam/update_user'
+
+        # Update a user
+        #
+        # ==== Parameters
+        # * user_name<~String> - Required. Name of the User to update. If you're changing the name of the User, this is the original User name.
+        # * options<~Hash>:
+        #   * new_path<~String> - New path for the User. Include this parameter only if you're changing the User's path.
+        #   * new_user_name<~String> - New name for the User. Include this parameter only if you're changing the User's name.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'RequestId'<~String> - Id of the request
+        #     * 'User'<~Hash> - Changed user info
+        #       * 'Arn'<~String> -
+        #       * 'Path'<~String> -
+        #       * 'UserId'<~String> -
+        #       * 'UserName'<~String> -
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/index.html?API_UpdateUser.html
+        #
+        def update_user(user_name, options = {})
+          request({
+            'Action'      => 'UpdateUser',
+            'UserName'    => user_name,
+            :parser       => Fog::Parsers::AWS::IAM::UpdateUser.new
+          }.merge!(options))
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/iam/upload_server_certificate.rb

@@ -0,0 +1,95 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+        require 'fog/aws/parsers/iam/upload_server_certificate'
+
+        # Uploads a server certificate entity for the AWS Account.
+        # Includes a public key certificate, a private key, and an optional certificate chain, which should all be PEM-encoded.
+        #
+        # ==== Parameters
+        # * certificate<~Hash>: The contents of the public key certificate in PEM-encoded format.
+        # * private_key<~Hash>: The contents of the private key in PEM-encoded format.
+        # * name<~Hash>: The name for the server certificate. Do not include the path in this value.
+        # * options<~Hash>:
+        #   * 'CertificateChain'<~String> - The contents of the certificate chain. Typically a concatenation of the PEM-encoded public key certificates of the chain.
+        #   * 'Path'<~String> - The path for the server certificate.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Certificate'<~Hash>:
+        #       * 'Arn'<~String> -
+        #       * 'Path'<~String> -
+        #       * 'ServerCertificateId'<~String> -
+        #       * 'ServerCertificateName'<~String> -
+        #       * 'UploadDate'<~Time>
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/index.html?API_UploadServerCertificate.html
+        #
+        def upload_server_certificate(certificate, private_key, name, options = {})
+          request({
+            'Action'                => 'UploadServerCertificate',
+            'CertificateBody'       => certificate,
+            'PrivateKey'            => private_key,
+            'ServerCertificateName' => name,
+            :parser                 => Fog::Parsers::AWS::IAM::UploadServerCertificate.new
+          }.merge!(options))
+        end
+      end
+
+      class Mock
+        def upload_server_certificate(certificate, private_key, name, options = {})
+          if certificate.nil? || certificate.empty? || private_key.nil? || private_key.empty?
+            raise Fog::AWS::IAM::ValidationError.new
+          end
+          response = Excon::Response.new
+
+          # Validate cert and key
+          begin
+            # must be an RSA private key
+            raise OpenSSL::PKey::RSAError unless private_key =~ /BEGIN RSA PRIVATE KEY/
+
+            cert = OpenSSL::X509::Certificate.new(certificate)
+            chain = OpenSSL::X509::Certificate.new(options['CertificateChain']) if options['CertificateChain']
+            key = OpenSSL::PKey::RSA.new(private_key)
+          rescue OpenSSL::X509::CertificateError, OpenSSL::PKey::RSAError => e
+            message = if e.is_a?(OpenSSL::X509::CertificateError)
+                        "Invalid Public Key Certificate."
+                      else
+                        "Invalid Private Key."
+                      end
+            raise Fog::AWS::IAM::MalformedCertificate.new(message)
+          end
+
+          unless cert.check_private_key(key)
+            raise Fog::AWS::IAM::KeyPairMismatch.new
+          end
+
+          if self.data[:server_certificates][name]
+            raise Fog::AWS::IAM::EntityAlreadyExists.new("The Server Certificate with name #{name} already exists.")
+          else
+            response.status = 200
+            path = options['Path'] || "/"
+            data = {
+              'Arn' => Fog::AWS::Mock.arn('iam', self.data[:owner_id], "server-certificate/#{name}"),
+              'Path' => path,
+              'ServerCertificateId' => Fog::AWS::IAM::Mock.server_certificate_id,
+              'ServerCertificateName' => name,
+              'UploadDate' => Time.now
+            }
+            self.data[:server_certificates][name] = data
+            response.body = {
+              'Certificate' => data,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/iam/upload_signing_certificate.rb

@@ -0,0 +1,36 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+        require 'fog/aws/parsers/iam/upload_signing_certificate'
+
+        # Upload signing certificate for user (by default detects user from access credentials)
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'UserName'<~String> - name of the user to upload certificate for (do not include path)
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Certificate'<~Hash>:
+        #       * 'CertificateId'<~String> -
+        #       * 'UserName'<~String> -
+        #       * 'CertificateBody'<~String> -
+        #       * 'Status'<~String> -
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/index.html?API_UploadSigningCertificate.html
+        #
+        def upload_signing_certificate(certificate, options = {})
+          request({
+            'Action'          => 'UploadSigningCertificate',
+            'CertificateBody' => certificate,
+            :parser           => Fog::Parsers::AWS::IAM::UploadSigningCertificate.new
+          }.merge!(options))
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/add_tags_to_resource.rb

@@ -0,0 +1,42 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        # adds tags to a database instance
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_AddTagsToResource.html
+        # ==== Parameters
+        # * rds_id <~String> - name of the RDS instance whose tags are to be retrieved
+        # * tags <~Hash> A Hash of (String) key-value pairs
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def add_tags_to_resource(rds_id, tags)
+          keys    = tags.keys.sort
+          values  = keys.map {|key| tags[key]}
+          request({
+              'Action'        => 'AddTagsToResource',
+              'ResourceName'  => "arn:aws:rds:#{@region}:#{owner_id}:db:#{rds_id}",
+              :parser         => Fog::Parsers::AWS::RDS::Base.new,
+            }.merge(Fog::AWS.indexed_param('Tags.member.%d.Key', keys)).
+              merge(Fog::AWS.indexed_param('Tags.member.%d.Value', values)))
+        end
+      end
+
+      class Mock
+        def add_tags_to_resource(rds_id, tags)
+          response = Excon::Response.new
+          if server = self.data[:servers][rds_id]
+            self.data[:tags][rds_id].merge! tags
+            response.status = 200
+            response.body = {
+              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id }
+            }
+            response
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/authorize_db_security_group_ingress.rb

@@ -0,0 +1,65 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/authorize_db_security_group_ingress'
+
+        # authorizes a db security group ingress
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/index.html?API_AuthorizeDBSecurityGroupIngress.html
+        # ==== Parameters
+        # * CIDRIP <~String> - The IP range to authorize
+        # * DBSecurityGroupName <~String> - The name for the DB Security Group.
+        # * EC2SecurityGroupName <~String> - Name of the EC2 Security Group to authorize.
+        # * EC2SecurityGroupOwnerId <~String> - AWS Account Number of the owner of the security group specified in the EC2SecurityGroupName parameter. The AWS Access Key ID is not an acceptable value.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def authorize_db_security_group_ingress(name, opts={})
+          unless opts.key?('CIDRIP') || (opts.key?('EC2SecurityGroupName') && opts.key?('EC2SecurityGroupOwnerId'))
+            raise ArgumentError, 'Must specify CIDRIP, or both EC2SecurityGroupName and EC2SecurityGroupOwnerId'
+          end
+
+          request({
+            'Action'  => 'AuthorizeDBSecurityGroupIngress',
+            :parser   => Fog::Parsers::AWS::RDS::AuthorizeDBSecurityGroupIngress.new,
+            'DBSecurityGroupName' => name
+          }.merge(opts))
+        end
+      end
+
+      class Mock
+        def authorize_db_security_group_ingress(name, opts = {})
+          unless opts.key?('CIDRIP') || (opts.key?('EC2SecurityGroupName') && opts.key?('EC2SecurityGroupOwnerId'))
+            raise ArgumentError, 'Must specify CIDRIP, or both EC2SecurityGroupName and EC2SecurityGroupOwnerId'
+          end
+
+          response = Excon::Response.new
+
+          if sec_group = self.data[:security_groups][name]
+            if opts.key?('CIDRIP')
+              if sec_group['IPRanges'].find{|h| h['CIDRIP'] == opts['CIDRIP']}
+                raise Fog::AWS::RDS::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['CIDRIP']} is alreay defined")
+              end
+              sec_group['IPRanges'] << opts.merge({"Status" => 'authorizing'})
+            else
+              if sec_group['EC2SecurityGroups'].find{|h| h['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']}
+                raise Fog::AWS::RDS::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['EC2SecurityGroupName']} is alreay defined")
+              end
+              sec_group['EC2SecurityGroups'] << opts.merge({"Status" => 'authorizing'})
+            end
+            response.status = 200
+            response.body = {
+              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+              'AuthorizeDBSecurityGroupIngressResult' => {
+                'DBSecurityGroup' => sec_group
+              }
+            }
+            response
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/create_db_instance.rb

@@ -0,0 +1,132 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/create_db_instance'
+
+        # Create a db instance
+        #
+        # @param DBInstanceIdentifier [String] name of the db instance to modify
+        # @param AllocatedStorage [Integer] Storage space, in GB
+        # @param AutoMinorVersionUpgrade [Boolean] Indicates that minor version upgrades will be applied automatically to the DB Instance during the maintenance window
+        # @param AvailabilityZone [String] The availability zone to create the instance in
+        # @param BackupRetentionPeriod [Integer] 0-8 The number of days to retain automated backups.
+        # @param DBInstanceClass [String] The new compute and memory capacity of the DB Instance
+        # @param DBName [String] The name of the database to create when the DB Instance is created
+        # @param DBParameterGroupName [String] The name of the DB Parameter Group to apply to this DB Instance
+        # @param DBSecurityGroups [Array] A list of DB Security Groups to authorize on this DB Instance
+        # @param Engine [String] The name of the database engine to be used for this instance.
+        # @param EngineVersion [String] The version number of the database engine to use.
+        # @param Iops [Integer] IOPS rate
+        # @param MasterUsername [String] The db master user
+        # @param MasterUserPassword [String] The new password for the DB Instance master user
+        # @param MultiAZ [Boolean] Specifies if the DB Instance is a Multi-AZ deployment
+        # @param Port [Integer] The port number on which the database accepts connections.
+        # @param PreferredBackupWindow [String] The daily time range during which automated backups are created if automated backups are enabled
+        # @param PreferredMaintenanceWindow [String] The weekly time range (in UTC) during which system maintenance can occur, which may result in an outage
+        # @param DBSubnetGroupName [String] The name, if any, of the VPC subnet for this RDS instance
+        # @param PubliclyAcccesible [Boolean] Whether an RDS instance inside of the VPC subnet should have a public-facing endpoint
+        # @param VpcSecurityGroups [Array] A list of VPC Security Groups to authorize on this DB instance
+        # @param StorageType [string] Specifies storage type to be associated with the DB Instance.  Valid values: standard | gp2 | io1
+        #
+        # @return [Excon::Response]:
+        #   * body [Hash]:
+        #
+        # @see http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html
+        def create_db_instance(db_name, options={})
+          if security_groups = options.delete('DBSecurityGroups')
+            options.merge!(Fog::AWS.indexed_param('DBSecurityGroups.member.%d', [*security_groups]))
+          end
+
+          if vpc_security_groups = options.delete('VpcSecurityGroups')
+            options.merge!(Fog::AWS.indexed_param('VpcSecurityGroupIds.member.%d', [*vpc_security_groups]))
+          end
+
+          request({
+            'Action'  => 'CreateDBInstance',
+            'DBInstanceIdentifier' => db_name,
+            :parser   => Fog::Parsers::AWS::RDS::CreateDBInstance.new,
+          }.merge(options))
+        end
+      end
+
+      class Mock
+        def create_db_instance(db_name, options={})
+          response = Excon::Response.new
+          if self.data[:servers] and self.data[:servers][db_name]
+            # I don't know how to raise an exception that contains the excon data
+            #response.status = 400
+            #response.body = {
+            #  'Code' => 'DBInstanceAlreadyExists',
+            #  'Message' => "DB Instance already exists"
+            #}
+            #return response
+            raise Fog::AWS::RDS::IdentifierTaken.new("DBInstanceAlreadyExists #{response.body.to_s}")
+          end
+
+          # These are the required parameters according to the API
+          required_params = %w{AllocatedStorage DBInstanceClass Engine MasterUserPassword MasterUsername }
+          required_params.each do |key|
+            unless options.key?(key) and options[key] and !options[key].to_s.empty?
+              #response.status = 400
+              #response.body = {
+              #  'Code' => 'MissingParameter',
+              #  'Message' => "The request must contain the parameter #{key}"
+              #}
+              #return response
+              raise Fog::AWS::RDS::NotFound.new("The request must contain the parameter #{key}")
+            end
+          end
+
+          data =
+              {
+                 "DBInstanceIdentifier"=> db_name,
+                 "DBName" => options["DBName"],
+                 "InstanceCreateTime" => nil,
+                 "AutoMinorVersionUpgrade"=>true,
+                 "Endpoint"=>{},
+                 "ReadReplicaDBInstanceIdentifiers"=>[],
+                 "PreferredMaintenanceWindow"=>"mon:04:30-mon:05:00",
+                 "Engine"=> options["Engine"],
+                 "EngineVersion"=> options["EngineVersion"] || "5.5.12",
+                 "PendingModifiedValues"=>{"MasterUserPassword"=>"****"}, # This clears when is available
+                 "MultiAZ"=> !!options['MultiAZ'],
+                 "MasterUsername"=> options["MasterUsername"],
+                 "DBInstanceClass"=> options["DBInstanceClass"],
+                 "DBInstanceStatus"=>"creating",
+                 "BackupRetentionPeriod"=> options["BackupRetentionPeriod"] || 1,
+                 "AllocatedStorage"=> options["AllocatedStorage"],
+                 "Iops" => options["Iops"],
+                 "DBParameterGroups"=> # I think groups should be in the self.data method
+                          [{"DBParameterGroupName"=>"default.mysql5.5",
+                            "ParameterApplyStatus"=>"in-sync"}],
+                 "DBSecurityGroups"=>
+                          [{"Status"=>"active",
+                            "DBSecurityGroupName"=>"default"}],
+                 "LicenseModel"=>"general-public-license",
+                 "PreferredBackupWindow"=>"08:00-08:30",
+#                 "ReadReplicaSourceDBInstanceIdentifier" => nil,
+#                 "LatestRestorableTime" => nil,
+                 "AvailabilityZone" => options["AvailabilityZone"],
+                 "DBSubnetGroupName" => options["DBSubnetGroupName"],
+                 "PubliclyAccessible" => options["PubliclyAccessible"],
+                 "VpcSecurityGroups" => options["VpcSecurityGroups"],
+                 "StorageType" => options["StorageType"],
+             }
+
+          self.data[:servers][db_name] = data
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "CreateDBInstanceResult"=> {"DBInstance"=> data}
+          }
+          response.status = 200
+          # This values aren't showed at creating time but at available time
+          self.data[:servers][db_name]["InstanceCreateTime"] = Time.now
+          self.data[:tags] ||= {}
+          self.data[:tags][db_name] = {}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/create_db_instance_read_replica.rb

@@ -0,0 +1,77 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/create_db_instance_read_replica'
+
+        # create a read replica db instance
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_CreateDBInstanceReadReplica.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - name of the db instance to create
+        # * SourceDBInstanceIdentifier <~String> - name of the db instance that will be the source. Must have backup retention on
+        # * AutoMinorVersionUpgrade <~Boolean> Indicates that minor version upgrades will be applied automatically to the DB Instance during the maintenance window
+        # * AvailabilityZone <~String> The availability zone to create the instance in
+        # * DBInstanceClass <~String> The new compute and memory capacity of the DB Instance
+        # * Port <~Integer> The port number on which the database accepts connections.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def create_db_instance_read_replica(instance_identifier, source_identifier, options={})
+          request({
+            'Action'  => 'CreateDBInstanceReadReplica',
+            'DBInstanceIdentifier' => instance_identifier,
+            'SourceDBInstanceIdentifier' => source_identifier,
+            :parser   => Fog::Parsers::AWS::RDS::CreateDBInstanceReadReplica.new,
+          }.merge(options))
+        end
+      end
+
+      class Mock
+        def create_db_instance_read_replica(instance_identifier, source_identifier, options={})
+          # TODO: throw error when instance_identifier already exists,
+          # or source_identifier doesn't exist
+
+          source = self.data[:servers][source_identifier]
+          data = {
+            'AllocatedStorage' => source['AllocatedStorage'],
+            'AutoMinorVersionUpgrade' => options.key?('AutoMinorVersionUpgrade') ? options['AutoMinorVersionUpgrade'] : true,
+            'AvailabilityZone' => options['AvailabilityZone'],
+            'DBInstanceClass' => options['DBInstanceClass'] || 'db.m1.small',
+            'DBInstanceIdentifier' => instance_identifier,
+            'DBInstanceStatus' => 'creating',
+            'DBName' => source['DBName'],
+            'DBParameterGroups' => source['DBParameterGroups'],
+            'DBSecurityGroups' => source['DBSecurityGroups'],
+            'Endpoint' => {},
+            'Engine' => source['Engine'],
+            'EngineVersion' => options['EngineVersion'] || '5.5.12',
+            'InstanceCreateTime' => nil,
+            'Iops' => source['Iops'],
+            'LatestRestorableTime' => nil,
+            'LicenseModel' => 'general-public-license',
+            'MasterUsername' => source['MasterUsername'],
+            'MultiAZ' => false,
+            'PendingModifiedValues' => {},
+            'PreferredBackupWindow'=> '08:00-08:30',
+            'PreferredMaintenanceWindow'=> "mon:04:30-mon:05:00",
+            'ReadReplicaDBInstanceIdentifiers'=> [],
+            'ReadReplicaSourceDBInstanceIdentifier'=> source_identifier
+          }
+          self.data[:servers][instance_identifier] = data
+          self.data[:servers][source_identifier]['ReadReplicaDBInstanceIdentifiers'] << instance_identifier
+
+          response = Excon::Response.new
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "CreateDBInstanceReadReplicaResult"=> {"DBInstance"=> data}
+          }
+          response.status = 200
+          # This values aren't showed at creating time but at available time
+          self.data[:servers][instance_identifier]["InstanceCreateTime"] = Time.now
+
+          response
+        end
+      end
+    end
+  end
+end