fog 1.25.0 → 1.41.0

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

@@ -1,47 +0,0 @@
-module Fog
-  module AWS
-    class RDS
-      class Real
-        require 'fog/aws/parsers/rds/reboot_db_instance'
-
-        # reboots a database instance
-        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_RebootDBInstance.html
-        # ==== Parameters
-        # * DBInstanceIdentifier <~String> - name of the db instance to reboot
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        def reboot_db_instance(instance_identifier)
-          request({
-            'Action'  => 'RebootDBInstance',
-            'DBInstanceIdentifier' => instance_identifier,
-            :parser   => Fog::Parsers::AWS::RDS::RebootDBInstance.new,
-          })
-        end
-      end
-
-      class Mock
-        def reboot_db_instance(instance_identifier)
-          response = Excon::Response.new
-          if server = self.data[:servers][instance_identifier]
-            if server["DBInstanceStatus"] != "available"
-              raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not available for rebooting")
-            else
-              server["DBInstanceStatus"] = 'rebooting'
-              self.data[:reboot_time] = Time.now
-              response.status = 200
-              response.body = {
-                "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
-                "RebootDBInstanceResult" => { "DBInstance" => server }
-              }
-              response
-
-            end
-          else
-            raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not found")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-module Fog
-  module AWS
-    class RDS
-      class Real
-        # removes tags from a database instance
-        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_RemoveTagsFromResource.html
-        # ==== Parameters
-        # * rds_id <~String> - name of the RDS instance whose tags are to be retrieved
-        # * keys <~Array> A list of String keys for the tags to remove
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        def remove_tags_from_resource(rds_id, keys)
-          request(
-            { 'Action'        => 'RemoveTagsFromResource',
-              'ResourceName'  => "arn:aws:rds:#{@region}:#{owner_id}:db:#{rds_id}",
-              :parser         => Fog::Parsers::AWS::RDS::Base.new,
-            }.merge(Fog::AWS.indexed_param('TagKeys.member.%d', keys))
-          )
-        end
-      end
-
-      class Mock
-        def remove_tags_from_resource(rds_id, keys)
-          response = Excon::Response.new
-          if server = self.data[:servers][rds_id]
-            keys.each {|key| self.data[:tags][rds_id].delete key}
-            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/restore_db_instance_from_db_snapshot.rb

@@ -1,29 +0,0 @@
-module Fog
-  module AWS
-    class RDS
-      class Real
-        require 'fog/aws/parsers/rds/restore_db_instance_from_db_snapshot'
-
-        # Restores a DB Instance from a DB Snapshot
-        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/index.html?API_RestoreDBInstanceFromDBSnapshot.html
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        def restore_db_instance_from_db_snapshot(snapshot_id, db_name, opts={})
-          request({
-            'Action'  => 'RestoreDBInstanceFromDBSnapshot',
-            'DBSnapshotIdentifier' => snapshot_id,
-            'DBInstanceIdentifier' => db_name,
-            :parser   => Fog::Parsers::AWS::RDS::RestoreDBInstanceFromDBSnapshot.new,
-          }.merge(opts))
-        end
-      end
-
-      class Mock
-        def restore_db_instance_from_db_snapshot(snapshot_id, db_id, options={})
-          Fog::Mock.not_implemented
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-module Fog
-  module AWS
-    class RDS
-      class Real
-        require 'fog/aws/parsers/rds/restore_db_instance_to_point_in_time'
-
-        # Restores a DB Instance to a point in time
-        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/index.html?API_RestoreDBInstanceToPointInTime.html
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        def restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts={})
-          request({
-            'Action'  => 'RestoreDBInstanceToPointInTime',
-            'SourceDBInstanceIdentifier' => source_db_name,
-            'TargetDBInstanceIdentifier' => target_db_name,
-            :parser   => Fog::Parsers::AWS::RDS::RestoreDBInstanceToPointInTime.new,
-          }.merge(opts))
-        end
-      end
-
-      class Mock
-        def restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts={})
-          Fog::Mock.not_implemented
-        end
-      end
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-module Fog
-  module AWS
-    class RDS
-      class Real
-        require 'fog/aws/parsers/rds/revoke_db_security_group_ingress'
-
-        # revokes a db security group ingress
-        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/index.html?API_RevokeDBSecurityGroupIngress.html
-        # ==== Parameters
-        # * CIDRIP <~String> - The IP range to revoke
-        # * DBSecurityGroupName <~String> - The name for the DB Security Group.
-        # * EC2SecurityGroupName <~String> - Name of the EC2 Security Group to revoke.
-        # * 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 revoke_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'  => 'RevokeDBSecurityGroupIngress',
-            :parser   => Fog::Parsers::AWS::RDS::RevokeDBSecurityGroupIngress.new,
-            'DBSecurityGroupName' => name
-          }.merge(opts))
-        end
-      end
-
-      class Mock
-        def revoke_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')
-              sec_group['IPRanges'].each do |iprange|
-                iprange['Status']= 'revoking' if iprange['CIDRIP'] == opts['CIDRIP']
-              end
-            else
-              sec_group['EC2SecurityGroups'].each do |ec2_secg|
-                ec2_secg['Status']= 'revoking' if ec2_secg['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']
-              end
-            end
-            response.status = 200
-            response.body = {
-              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
-              'RevokeDBSecurityGroupIngressResult' => {
-                '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/redshift/authorize_cluster_security_group_ingress.rb

@@ -1,54 +0,0 @@
-module Fog
-  module AWS
-    class Redshift
-      class Real
-        require 'fog/aws/parsers/redshift/revoke_cluster_security_group_ingress'
-
-        # ==== Parameters
-        #
-        # @param [Hash] options
-    		# * :cluster_security_group_name - required - (String)
-    		#    The name of the security Group from which to revoke the ingress rule.
-    		# * :cidrip - (String)
-    		#    The IP range for which to revoke access. This range must be a valid Classless
-    		#    Inter-Domain Routing (CIDR) block of IP addresses. If CIDRIP is specified,
-    		#    EC2SecurityGroupName and EC2SecurityGroupOwnerId cannot be provided.
-    		# * :ec2_security_group_name - (String)
-    		#    The name of the EC2 Security Group whose access is to be revoked. If
-    		#    EC2SecurityGroupName is specified, EC2SecurityGroupOwnerId must also be
-    		#    provided and CIDRIP cannot be provided.
-    		# * :ec2_security_group_owner_id - (String)
-    		#    The 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. If EC2SecurityGroupOwnerId is specified, EC2SecurityGroupName must
-    		#    also be provided. and CIDRIP cannot be provided. Example: 111122223333
-        #
-        # ==== See Also
-        # http://docs.aws.amazon.com/redshift/latest/APIReference/API_AuthorizeClusterSecurityGroupIngress.html
-        def authorize_cluster_security_group_ingress(options = {})
-          cluster_security_group_name = options[:cluster_security_group_name]
-          cidrip                      = options[:cidrip]
-          ec2_security_group_name     = options[:ec2_security_group_name]
-          ec2_security_group_owner_id = options[:ec2_security_group_owner_id]
-
-          path = "/"
-          params = {
-            :headers    => {},
-            :path       => path,
-            :method     => :put,
-            :query      => {},
-      			:parser     => Fog::Parsers::Redshift::AWS::RevokeClusterSecurityGroupIngress.new
-          }
-
-          params[:query]['Action']                   = 'AuthorizeClusterSecurityGroupIngress'
-          params[:query]['ClusterSecurityGroupName'] = cluster_security_group_name if cluster_security_group_name
-          params[:query]['CIDRIP']					         = cidrip if cidrip
-          params[:query]['EC2SecurityGroupName']     = ec2_security_group_name if ec2_security_group_name
-          params[:query]['EC2SecurityGroupOwnerId']  = ec2_security_group_owner_id if ec2_security_group_owner_id
-
-          request(params)
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/redshift/authorize_snapshot_access.rb

@@ -1,42 +0,0 @@
-module Fog
-  module AWS
-    class Redshift
-      class Real
-        require 'fog/aws/parsers/redshift/cluster_snapshot'
-
-        # ==== Parameters
-        #
-        # @param [Hash] options
-        # * :snapshot_identifier - required - (String)
-        #    The identifier of the snapshot the account is authorized to restore.
-        # * :snapshot_cluster_identifier - (String)
-        # * :account_with_restore_access - required - (String)
-        #    The identifier of the AWS customer account authorized to restore the specified snapshot.       #
-        #
-        # ==== See Also
-        # http://docs.aws.amazon.com/redshift/latest/APIReference/API_CopyClusterSnapshot.html
-        def authorize_snapshot_access(options = {})
-          snapshot_identifier         = options[:snapshot_identifier]
-          snapshot_cluster_identifier = options[:snapshot_cluster_identifier]
-          account_with_restore_access = options[:account_with_restore_access]
-
-          path = "/"
-          params = {
-            :headers    => {},
-            :path       => path,
-            :method     => :put,
-            :query      => {},
-            :parser     => Fog::Parsers::Redshift::AWS::ClusterSnapshot.new
-          }
-
-          params[:query]['Action']                    = 'AuthorizeSnapshotAccess'
-          params[:query]['SnapshotIdentifier']        = snapshot_identifier if snapshot_identifier
-          params[:query]['SnapshotClusterIdentifier'] = snapshot_cluster_identifier if snapshot_cluster_identifier
-          params[:query]['AccountWithRestoreAccess']  = account_with_restore_access if account_with_restore_access
-
-          request(params)
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/redshift/copy_cluster_snapshot.rb

@@ -1,46 +0,0 @@
-module Fog
-  module AWS
-    class Redshift
-      class Real
-        require 'fog/aws/parsers/redshift/cluster_snapshot'
-
-        # ==== Parameters
-        #
-        # @param [Hash] options
-        # * :source_snapshot_identifier - required - (String)
-        #    The identifier for the source snapshot. Constraints: Must be the identifier for
-        #    a valid automated snapshot whose state is "available".
-        # * :source_snapshot_cluster_identifier - (String)
-        # * :target_snapshot_identifier - required - (String)
-        #    The identifier given to the new manual snapshot. Constraints: Cannot be null,
-        #    empty, or blank. Must contain from 1 to 255 alphanumeric characters or hyphens.
-        #    First character must be a letter. Cannot end with a hyphen or contain two
-        #    consecutive hyphens. Must be unique for the AWS account that is making the request.
-        #
-        # ==== See Also
-        # http://docs.aws.amazon.com/redshift/latest/APIReference/API_CopyClusterSnapshot.html
-        def copy_cluster_snapshot(options = {})
-          source_snapshot_identifier         = options[:source_snapshot_identifier]
-          source_snapshot_cluster_identifier = options[:source_snapshot_cluster_identifier]
-          target_snapshot_identifier         = options[:target_snapshot_identifier]
-
-          path = "/"
-          params = {
-            :headers    => {},
-            :path       => path,
-            :method     => :put,
-            :query      => {},
-            :parser     => Fog::Parsers::Redshift::AWS::ClusterSnapshot.new
-          }
-
-          params[:query]['Action']                          = 'CopyClusterSnapshot'
-          params[:query]['SourceSnapshotIdentifier']        = source_snapshot_identifier if source_snapshot_identifier
-          params[:query]['SourceSnapshotClusterIdentifier'] = source_snapshot_cluster_identifier if source_snapshot_cluster_identifier
-          params[:query]['TargetSnapshotIdentifier']        = target_snapshot_identifier if target_snapshot_identifier
-
-          request(params)
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/redshift/create_cluster.rb

@@ -1,148 +0,0 @@
-module Fog
-  module AWS
-    class Redshift
-      class Real
-        require 'fog/aws/parsers/redshift/cluster'
-
-        # ==== Parameters
-        #
-        # @param [Hash] options
-        # * :db_name - (String)
-        #    The name of the first database to be created when the cluster is created. To create
-        #    additional databases after the cluster is created, connect to the cluster with a SQL
-        #    client and use SQL commands to create a database. Default: dev Constraints: Must
-        #    contain 1 to 64 alphanumeric characters. Must contain only lowercase letters.
-        # * :cluster_identifier - required - (String)
-        #    A unique identifier for the cluster. You use this identifier to refer to the cluster
-        #    for any subsequent cluster operations such as deleting or modifying. Must be unique
-        #    for all clusters within an AWS account. Example: myexamplecluster
-        # * :cluster_type - (String)
-        #    Type of the cluster. When cluster type is specified as single-node, the NumberOfNodes
-        #    parameter is not required. multi-node, the NumberOfNodes parameter is required. Valid
-        #    Values: multi-node | single-node Default: multi-node
-        # * :node_type - required - (String)
-        #    The node type to be provisioned. Valid Values: dw.hs1.xlarge | dw.hs1.8xlarge.
-        # * :master_username - required - (String)
-        #    The user name associated with the master user account for the cluster that is being
-        #    created. Constraints: Must be 1 - 128 alphanumeric characters. First character must
-        #    be a letter. Cannot be a reserved word.
-        # * :master_user_password - required - (String)
-        #    The password associated with the master user account for the cluster that is being
-        #    created. Constraints: Must be between 8 and 64 characters in length. Must contain at
-        #    least one uppercase letter. Must contain at least one lowercase letter. Must contain
-        #    one number.
-        # * :cluster_security_groups - (Array<String>)
-        #    A list of security groups to be associated with this cluster. Default: The default
-        #    cluster security group for Amazon Redshift.
-        # * :vpc_security_group_ids - (Array<String>)
-        #    A list of Virtual Private Cloud (VPC) security groups to be associated with the
-        #    cluster. Default: The default VPC security group is associated with the cluster.
-        # * :cluster_subnet_group_name - (String)
-        #    The name of a cluster subnet group to be associated with this cluster. If this
-        #    parameter is not provided the resulting cluster will be deployed outside virtual
-        #    private cloud (VPC).
-        # * :availability_zone - (String)
-        #    The EC2 Availability Zone (AZ) in which you want Amazon Redshift to provision the
-        #    cluster. Default: A random, system-chosen Availability Zone in the region that is
-        #    specified by the endpoint. Example: us-east-1d Constraint: The specified
-        #    Availability Zone must be in the same region as the current endpoint.
-        # * :preferred_maintenance_window - (String)
-        #    The weekly time range (in UTC) during which automated cluster maintenance can occur.
-        #    Format: ddd:hh24:mi-ddd:hh24:mi Default: A 30-minute window selected at random from
-        #    an 8-hour block of time per region, occurring on a random day of the week.
-        #    Constraints: Minimum 30-minute window.
-        # * :cluster_parameter_group_name - (String)
-        #    The name of the parameter group to be associated with this cluster. Default: The
-        #    default Amazon Redshift cluster parameter group. Constraints: Must be 1 to 255
-        #    alphanumeric characters or hyphens. First character must be a letter. Cannot end
-        #    with a hyphen or contain two consecutive hyphens.
-        # * :automated_snapshot_retention_period - (Integer)
-        #    Number of days that automated snapshots are retained. If the value is 0, automated
-        #    snapshots are disabled.  Default: 1 Constraints: Must be a value from 0 to 35.
-        # * :port - (Integer)
-        #    The port number on which the cluster accepts incoming connections. Default: 5439
-        #    Valid Values: 1150-65535
-        # * :cluster_version - (String)
-        #    The version of the Amazon Redshift engine software that you want to deploy on the
-        #    cluster. The version selected runs on all the nodes in the cluster. Constraints:
-        #    Only version 1.0 is currently available. Example: 1.0
-        # * :allow_version_upgrade - (Boolean)
-        #    If `true` , upgrades can be applied during the maintenance window to the Amazon
-        #    Redshift engine that is running on the cluster. Default:  `true`
-        # * :number_of_nodes - (Integer)
-        #    The number of compute nodes in the cluster. This parameter is required when the
-        #    ClusterType parameter is specified as multi-node. If you don't specify this parameter,
-        #    you get a single-node cluster. When requesting a multi-node cluster, you must specify
-        #    the number of nodes that you want in the cluster. Default: 1 Constraints: Value must
-        #    be at least 1 and no more than 100.
-        # * :publicly_accessible - (Boolean)
-        #    If `true` , the cluster can be accessed from a public network.
-        # * :encrypted - (Boolean)
-        #    If `true` , the data in cluster is encrypted at rest. Default:  `false`
-
-        # ==== See Also
-        # http://docs.aws.amazon.com/redshift/latest/APIReference/API_CreateCluster.html
-        def create_cluster(options = {})
-          db_name                             = options[:db_name]
-          cluster_identifier                  = options[:cluster_identifier]
-          cluster_type                        = options[:cluster_type]
-          node_type                           = options[:node_type]
-          master_username                     = options[:master_username]
-          master_user_password                = options[:master_user_password]
-          cluster_subnet_group_name           = options[:cluster_subnet_group_name]
-          availability_zone                   = options[:availability_zone]
-          preferred_maintenance_window        = options[:preferred_maintenance_window]
-          cluster_parameter_group_name        = options[:cluster_parameter_group_name]
-          automated_snapshot_retention_period = options[:automated_snapshot_retention_period]
-          port                                = options[:port]
-          cluster_version                     = options[:cluster_version]
-          allow_version_upgrade               = options[:allow_version_upgrade]
-          number_of_nodes                     = options[:number_of_nodes]
-          publicly_accessible                 = options[:publicly_accessible]
-          encrypted                           = options[:encrypted]
-
-          path = "/"
-          params = {
-            :idempotent => true,
-            :headers    => {},
-            :path       => path,
-            :method     => :put,
-            :query      => {},
-            :parser     => Fog::Parsers::Redshift::AWS::Cluster.new
-          }
-
-          if cluster_security_groups = options.delete(:ClusterSecurityGroups)
-            params[:query].merge!(Fog::AWS.indexed_param('ClusterSecurityGroups.member.%d', [*cluster_security_groups]))
-          end
-
-          if vpc_security_group_ids = options.delete(:VpcSecurityGroupIds)
-            params[:query].merge!(Fog::AWS.indexed_param('VpcSecurityGroupIds.member.%d', [*vpc_security_group_ids]))
-          end
-
-          params[:query]['Action']                           = 'CreateCluster'
-          params[:query]['DBName']                           = db_name if db_name
-          params[:query]['ClusterIdentifier']                = cluster_identifier if cluster_identifier
-          params[:query]['ClusterType']                      = cluster_type if cluster_type
-          params[:query]['NodeType']                         = node_type if node_type
-          params[:query]['MasterUsername']                   = master_username if master_username
-          params[:query]['MasterUserPassword']               = master_user_password if master_user_password
-          params[:query]['ClusterSecurityGroups']            = cluster_security_groups if cluster_security_groups
-          params[:query]['VpcSecurityGroupIds']              = vpc_security_group_ids if vpc_security_group_ids
-          params[:query]['ClusterSubnetGroupName']           = cluster_subnet_group_name if cluster_subnet_group_name
-          params[:query]['AvailabilityZone']                 = availability_zone if availability_zone
-          params[:query]['PreferredMaintenanceWindow']       = preferred_maintenance_window if preferred_maintenance_window
-          params[:query]['ClusterParameterGroupName']        = cluster_parameter_group_name if cluster_parameter_group_name
-          params[:query]['AutomatedSnapshotRetentionPeriod'] = automated_snapshot_retention_period if automated_snapshot_retention_period
-          params[:query]['Port']                             = port if port
-          params[:query]['ClusterVersion']                   = cluster_version if cluster_version
-          params[:query]['AllowVersionUpgrade']              = allow_version_upgrade if allow_version_upgrade
-          params[:query]['NumberOfNodes']                    = number_of_nodes if number_of_nodes
-          params[:query]['PubliclyAccessible']               = publicly_accessible if publicly_accessible
-          params[:query]['Encrypted']                        = encrypted if encrypted
-
-          request(params)
-        end
-      end
-    end
-  end
-end