
Redshift
********


boto.redshift
=============

boto.redshift.connect_to_region(region_name, **kw_params)

boto.redshift.regions()

   Get all available regions for the AWS Redshift service.

   Return type:
      list

   Returns:
      A list of "boto.regioninfo.RegionInfo"


boto.redshift.layer1
====================

class class boto.redshift.layer1.RedshiftConnection(**kwargs)

   Amazon Redshift **Overview** This is an interface reference for
   Amazon Redshift. It contains documentation for one of the
   programming or command line interfaces you can use to manage Amazon
   Redshift clusters. Note that Amazon Redshift is asynchronous, which
   means that some interfaces may require techniques, such as polling
   or asynchronous callback handlers, to determine when a command has
   been applied. In this reference, the parameter descriptions
   indicate whether a change is applied immediately, on the next
   instance reboot, or during the next maintenance window. For a
   summary of the Amazon Redshift cluster management interfaces, go to
   >>`<<Using the Amazon Redshift Management Interfaces >>`<<_.

   Amazon Redshift manages all the work of setting up, operating, and
   scaling a data warehouse: provisioning capacity, monitoring and
   backing up the cluster, and applying patches and upgrades to the
   Amazon Redshift engine. You can focus on using your data to acquire
   new insights for your business and customers.

   If you are a first-time user of Amazon Redshift, we recommend that
   you begin by reading the The >>`Amazon Redshift Getting Started
   Guide`_<<

   If you are a database developer, the >>`Amazon Redshift Database
   Developer Guide`_<< explains how to design, build, query, and
   maintain the databases that make up your data warehouse.

   APIVersion = '2012-12-01'

   DefaultRegionEndpoint = 'redshift.us-east-1.amazonaws.com'

   DefaultRegionName = 'us-east-1'

   ResponseError

      alias of "JSONResponseError"

   authorize_cluster_security_group_ingress(cluster_security_group_name, cidrip=None, ec2_security_group_name=None, ec2_security_group_owner_id=None)

      Adds an inbound (ingress) rule to an Amazon Redshift security
      group. Depending on whether the application accessing your
      cluster is running on the Internet or an EC2 instance, you can
      authorize inbound access to either a Classless Interdomain
      Routing (CIDR) IP address range or an EC2 security group. You
      can add as many as 20 ingress rules to an Amazon Redshift
      security group. The EC2 security group must be defined in the
      AWS region where the cluster resides. For an overview of CIDR
      blocks, see the Wikipedia article on >>`Classless Inter-Domain
      Routing`_<<.

      You must also associate the security group with a cluster so
      that clients running on these IP addresses or the EC2 instance
      are authorized to connect to the cluster. For information about
      managing security groups, go to >>`Working with Security
      Groups`_<< in the Amazon Redshift Management Guide .

      Parameters:
         * **cluster_security_group_name** (*string*) -- The name of
           the security group to which the ingress rule is added.

         * **cidrip** (*string*) -- The IP range to be added the
           Amazon Redshift security group.

         * **ec2_security_group_name** (*string*) -- The EC2 security
           group to be added the Amazon Redshift security group.

         * **ec2_security_group_owner_id** (*string*) -- The AWS
           account number of the owner of the security group specified
           by the EC2SecurityGroupName parameter. The AWS Access Key
           ID is not an acceptable value.

      Example: *111122223333*

   authorize_snapshot_access(snapshot_identifier, account_with_restore_access, snapshot_cluster_identifier=None)

      Authorizes the specified AWS customer account to restore the
      specified snapshot.

      For more information about working with snapshots, go to
      >>`Amazon Redshift Snapshots`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         * **snapshot_identifier** (*string*) -- The identifier of the
           snapshot the account is authorized to restore.

         * **snapshot_cluster_identifier** (*string*) -- The
           identifier of the cluster the snapshot was created from.
           This parameter is required if your IAM user has a policy
           containing a snapshot resource element that specifies
           anything other than * for the cluster name.

         * **account_with_restore_access** (*string*) -- The
           identifier of the AWS customer account authorized to
           restore the specified snapshot.

   copy_cluster_snapshot(source_snapshot_identifier, target_snapshot_identifier, source_snapshot_cluster_identifier=None)

      Copies the specified automated cluster snapshot to a new manual
      cluster snapshot. The source must be an automated snapshot and
      it must be in the available state.

      When you delete a cluster, Amazon Redshift deletes any automated
      snapshots of the cluster. Also, when the retention period of the
      snapshot expires, Amazon Redshift automatically deletes it. If
      you want to keep an automated snapshot for a longer period, you
      can make a manual copy of the snapshot. Manual snapshots are
      retained until you delete them.

      For more information about working with snapshots, go to
      >>`Amazon Redshift Snapshots`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         **source_snapshot_identifier** (*string*) --

      The identifier for the source snapshot.

      Constraints:

      * Must be the identifier for a valid automated snapshot whose
        state is
           "available".

      Parameters:
         **source_snapshot_cluster_identifier** (*string*) --

      The identifier of the cluster the source snapshot was created
      from.
         This parameter is required if your IAM user has a policy
         containing a snapshot resource element that specifies
         anything other than * for the cluster name.

      Constraints:

      * Must be the identifier for a valid cluster.

      Parameters:
         **target_snapshot_identifier** (*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.

   create_cluster(cluster_identifier, node_type, master_username, master_user_password, db_name=None, cluster_type=None, cluster_security_groups=None, vpc_security_group_ids=None, cluster_subnet_group_name=None, availability_zone=None, preferred_maintenance_window=None, cluster_parameter_group_name=None, automated_snapshot_retention_period=None, port=None, cluster_version=None, allow_version_upgrade=None, number_of_nodes=None, publicly_accessible=None, encrypted=None, hsm_client_certificate_identifier=None, hsm_configuration_identifier=None, elastic_ip=None)

      Creates a new cluster. To create the cluster in virtual private
      cloud (VPC), you must provide cluster subnet group name. If you
      don't provide a cluster subnet group name or the cluster
      security group parameter, Amazon Redshift creates a non-VPC
      cluster, it associates the default cluster security group with
      the cluster. For more information about managing clusters, go to
      >>`Amazon Redshift Clusters`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         **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. For more information, go to >>`Create a
         Database`_<< in the Amazon Redshift Database Developer Guide.

      Default: *dev*

      Constraints:

      * Must contain 1 to 64 alphanumeric characters.

      * Must contain only lowercase letters.

      * Cannot be a word that is reserved by the service. A list of
        reserved
           words can be found in >>`Reserved Words`_<< in the Amazon
           Redshift Database Developer Guide.

      Parameters:
         **cluster_identifier** (*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. The identifier also appears in the Amazon Redshift
         console.

      Constraints:

      * Must contain from 1 to 63 alphanumeric characters or hyphens.

      * Alphabetic characters must be lowercase.

      * First character must be a letter.

      * Cannot end with a hyphen or contain two consecutive hyphens.

      * Must be unique for all clusters within an AWS account.

      Example: *myexamplecluster*

      Parameters:
         **cluster_type** (*string*) -- The 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*

      Parameters:
         **node_type** (*string*) -- The node type to be provisioned
         for the cluster. For information about node types, go to `
         Working with Clusters`_ in the Amazon Redshift Management
         Guide .

      Valid Values: *dw.hs1.xlarge* | *dw.hs1.8xlarge*.

      Parameters:
         **master_username** (*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. A list of reserved words can be
        found in
           >>`Reserved Words`_<< in the Amazon Redshift Database
           Developer Guide.

      Parameters:
         **master_user_password** (*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.

      * Can be any printable ASCII character (ASCII code 33 to 126)
        except '
           (single quote), " (double quote), , /, @, or space.

      Parameters:
         **cluster_security_groups** (*list*) -- A list of security
         groups to be associated with this cluster.

      Default: The default cluster security group for Amazon Redshift.

      Parameters:
         **vpc_security_group_ids** (*list*) -- 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.

      Parameters:
         **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).

      Parameters:
         **availability_zone** (*string*) -- The EC2 Availability Zone
         (AZ) in which you want Amazon Redshift to provision the
         cluster. For example, if you have several EC2 instances
         running in a specific Availability Zone, then you might want
         the cluster to be provisioned in the same zone in order to
         decrease network latency.

      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.

      Parameters:
         **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. The
         following list shows the time blocks for each region from
         which the default maintenance windows are assigned.

      * **US-East (Northern Virginia) Region:** 03:00-11:00 UTC

      * **US-West (Oregon) Region** 06:00-14:00 UTC

      Valid Days: Mon | Tue | Wed | Thu | Fri | Sat | Sun

      Constraints: Minimum 30-minute window.

      Parameters:
         **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.
      For
         information about the default parameter group, go to
         >>`Working with Amazon Redshift Parameter Groups`_<<

      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.

      Parameters:
         **automated_snapshot_retention_period** (*integer*) -- The
         number of days that automated snapshots are retained. If the
         value is 0, automated snapshots are disabled. Even if
         automated snapshots are disabled, you can still create manual
         snapshots when you want with CreateClusterSnapshot.

      Default: *1*

      Constraints: Must be a value from 0 to 35.

      Parameters:
         **port** (*integer*) -- The port number on which the cluster
         accepts incoming connections.

      The cluster is accessible only via the JDBC and ODBC connection
         strings. Part of the connection string requires the port on
         which the cluster will listen for incoming connections.

      Default: *5439*

      Valid Values: *1150-65535*

      Parameters:
         **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*

      Parameters:
         **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.

      When a new version of the Amazon Redshift engine is released,
      you can
         request that the service automatically apply upgrades during
         the maintenance window to the Amazon Redshift engine that is
         running on your cluster.

      Default: *True*

      Parameters:
         **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*.

      For information about determining how many nodes you need, go to
      `
         Working with Clusters`_ in the Amazon Redshift Management
         Guide .

      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.

      Parameters:
         * **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

      Parameters:
         * **hsm_client_certificate_identifier** (*string*) --
           Specifies the name of the HSM client certificate the Amazon
           Redshift cluster uses to retrieve the data encryption keys
           stored in an HSM.

         * **hsm_configuration_identifier** (*string*) -- Specifies
           the name of the HSM configuration that contains the
           information the Amazon Redshift cluster can use to retrieve
           and store keys in an HSM.

         * **elastic_ip** (*string*) -- The Elastic IP (EIP) address
           for the cluster.

      Constraints: The cluster must be provisioned in EC2-VPC and
      publicly-
         accessible through an Internet gateway. For more information
         about provisioning clusters in EC2-VPC, go to >>`Supported
         Platforms to Launch Your Cluster`_<< in the Amazon Redshift
         Management Guide.

   create_cluster_parameter_group(parameter_group_name, parameter_group_family, description)

      Creates an Amazon Redshift parameter group.

      Creating parameter groups is independent of creating clusters.
      You can associate a cluster with a parameter group when you
      create the cluster. You can also associate an existing cluster
      with a parameter group after the cluster is created by using
      ModifyCluster.

      Parameters in the parameter group define specific behavior that
      applies to the databases you create on the cluster. For more
      information about managing parameter groups, go to >>`Amazon
      Redshift Parameter Groups`_<< in the Amazon Redshift Management
      Guide .

      Parameters:
         **parameter_group_name** (*string*) --

      The name of the 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.

      * Must be unique withing your AWS account.

      This value is stored as a lower-case string.

      Parameters:
         **parameter_group_family** (*string*) -- The Amazon Redshift
         engine version to which the cluster parameter group applies.
         The cluster engine version determines the set of parameters.

      To get a list of valid parameter group family names, you can
      call
         DescribeClusterParameterGroups. By default, Amazon Redshift
         returns a list of all the parameter groups that are owned by
         your AWS account, including the default parameter groups for
         each Amazon Redshift engine version. The parameter group
         family names associated with the default parameter groups
         provide you the valid values. For example, a valid family
         name is "redshift-1.0".

      Parameters:
         **description** (*string*) -- A description of the parameter
         group.

   create_cluster_security_group(cluster_security_group_name, description)

      Creates a new Amazon Redshift security group. You use security
      groups to control access to non-VPC clusters.

      For information about managing security groups, go to`Amazon
      Redshift Cluster Security Groups`_ in the Amazon Redshift
      Management Guide .

      Parameters:
         **cluster_security_group_name** (*string*) -- The name for
         the security group. Amazon Redshift stores the value as a
         lowercase string.

      Constraints:

      * Must contain no more than 255 alphanumeric characters or
        hyphens.

      * Must not be "Default".

      * Must be unique for all security groups that are created by
        your AWS
           account.

      Example: *examplesecuritygroup*

      Parameters:
         **description** (*string*) -- A description for the security
         group.

   create_cluster_snapshot(snapshot_identifier, cluster_identifier)

      Creates a manual snapshot of the specified cluster. The cluster
      must be in the "available" state.

      For more information about working with snapshots, go to
      >>`Amazon Redshift Snapshots`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         **snapshot_identifier** (*string*) -- A unique identifier for
         the snapshot that you are requesting. This identifier must be
         unique for all snapshots within the AWS account.

      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

      Example: *my-snapshot-id*

      Parameters:
         **cluster_identifier** (*string*) -- The cluster identifier
         for which you want a snapshot.

   create_cluster_subnet_group(cluster_subnet_group_name, description, subnet_ids)

      Creates a new Amazon Redshift subnet group. You must provide a
      list of one or more subnets in your existing Amazon Virtual
      Private Cloud (Amazon VPC) when creating Amazon Redshift subnet
      group.

      For information about subnet groups, go to`Amazon Redshift
      Cluster Subnet Groups`_ in the Amazon Redshift Management Guide
      .

      Parameters:
         **cluster_subnet_group_name** (*string*) -- The name for the
         subnet group. Amazon Redshift stores the value as a lowercase
         string.

      Constraints:

      * Must contain no more than 255 alphanumeric characters or
        hyphens.

      * Must not be "Default".

      * Must be unique for all subnet groups that are created by your
        AWS
           account.

      Example: *examplesubnetgroup*

      Parameters:
         * **description** (*string*) -- A description for the subnet
           group.

         * **subnet_ids** (*list*) -- An array of VPC subnet IDs. A
           maximum of 20 subnets can be modified in a single request.

   create_event_subscription(subscription_name, sns_topic_arn, source_type=None, source_ids=None, event_categories=None, severity=None, enabled=None)

      Creates an Amazon Redshift event notification subscription. This
      action requires an ARN (Amazon Resource Name) of an Amazon SNS
      topic created by either the Amazon Redshift console, the Amazon
      SNS console, or the Amazon SNS API. To obtain an ARN with Amazon
      SNS, you must create a topic in Amazon SNS and subscribe to the
      topic. The ARN is displayed in the SNS console.

      You can specify the source type, and lists of Amazon Redshift
      source IDs, event categories, and event severities.
      Notifications will be sent for all events you want that match
      those criteria. For example, you can specify source type =
      cluster, source ID = my-cluster-1 and mycluster2, event
      categories = Availability, Backup, and severity = ERROR. The
      subsription will only send notifications for those ERROR events
      in the Availability and Backup categores for the specified
      clusters.

      If you specify both the source type and source IDs, such as
      source type = cluster and source identifier = my-cluster-1,
      notifiactions will be sent for all the cluster events for my-
      cluster-1. If you specify a source type but do not specify a
      source identifier, you will receive notice of the events for the
      objects of that type in your AWS account. If you do not specify
      either the SourceType nor the SourceIdentifier, you will be
      notified of events generated from all Amazon Redshift sources
      belonging to your AWS account. You must specify a source type if
      you specify a source ID.

      Parameters:
         **subscription_name** (*string*) --

      The name of the event subscription to be created.

      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.

      Parameters:
         * **sns_topic_arn** (*string*) -- The Amazon Resource Name
           (ARN) of the Amazon SNS topic used to transmit the event
           notifications. The ARN is created by Amazon SNS when you
           create a topic and subscribe to it.

         * **source_type** (*string*) -- The type of source that will
           be generating the events. For example, if you want to be
           notified of events generated by a cluster, you would set
           this parameter to cluster. If this value is not specified,
           events are returned for all Amazon Redshift objects in your
           AWS account. You must specify a source type in order to
           specify source IDs.

      Valid values: cluster, cluster-parameter-group, cluster-
      security-group,
         and cluster-snapshot.

      Parameters:
         **source_ids** (*list*) -- A list of one or more identifiers
         of Amazon Redshift source objects. All of the objects must be
         of the same type as was specified in the source type
         parameter. The event subscription will return only events
         generated by the specified objects. If not specified, then
         events are returned for all objects within the source type
         specified.

      Example: my-cluster-1, my-cluster-2

      Example: my-snapshot-20131010

      Parameters:
         **event_categories** (*list*) -- Specifies the Amazon
         Redshift event categories to be published by the event
         notification subscription.

      Values: Configuration, Management, Monitoring, Security

      Parameters:
         **severity** (*string*) -- Specifies the Amazon Redshift
         event severity to be published by the event notification
         subscription.

      Values: ERROR, INFO

      Parameters:
         **enabled** (*boolean*) -- A Boolean value; set to *True* to
         activate the subscription, set to *False* to create the
         subscription but not active it.

   create_hsm_client_certificate(hsm_client_certificate_identifier)

      Creates an HSM client certificate that an Amazon Redshift
      cluster will use to connect to the client's HSM in order to
      store and retrieve the keys used to encrypt the cluster
      databases.

      The command returns a public key, which you must store in the
      HSM. After creating the HSM certificate, you must create an
      Amazon Redshift HSM configuration that provides a cluster the
      information needed to store and retrieve database encryption
      keys in the HSM. For more information, go to aLinkToHSMTopic in
      the Amazon Redshift Management Guide.

      Parameters:
         **hsm_client_certificate_identifier** (*string*) -- The
         identifier to be assigned to the new HSM client certificate
         that the cluster will use to connect to the HSM to retrieve
         the database encryption keys.

   create_hsm_configuration(hsm_configuration_identifier, description, hsm_ip_address, hsm_partition_name, hsm_partition_password, hsm_server_public_certificate)

      Creates an HSM configuration that contains the information
      required by an Amazon Redshift cluster to store and retrieve
      database encryption keys in a Hardware Storeage Module (HSM).
      After creating the HSM configuration, you can specify it as a
      parameter when creating a cluster. The cluster will then store
      its encryption keys in the HSM.

      Before creating an HSM configuration, you must have first
      created an HSM client certificate. For more information, go to
      aLinkToHSMTopic in the Amazon Redshift Management Guide.

      Parameters:
         * **hsm_configuration_identifier** (*string*) -- The
           identifier to be assigned to the new Amazon Redshift HSM
           configuration.

         * **description** (*string*) -- A text description of the HSM
           configuration to be created.

         * **hsm_ip_address** (*string*) -- The IP address that the
           Amazon Redshift cluster must use to access the HSM.

         * **hsm_partition_name** (*string*) -- The name of the
           partition in the HSM where the Amazon Redshift clusters
           will store their database encryption keys.

         * **hsm_partition_password** (*string*) -- The password
           required to access the HSM partition.

         * **hsm_server_public_certificate** (*string*) -- The public
           key used to access the HSM client certificate, which was
           created by calling the Amazon Redshift create HSM
           certificate command.

   delete_cluster(cluster_identifier, skip_final_cluster_snapshot=None, final_cluster_snapshot_identifier=None)

      Deletes a previously provisioned cluster. A successful response
      from the web service indicates that the request was received
      correctly. If a final cluster snapshot is requested the status
      of the cluster will be "final-snapshot" while the snapshot is
      being taken, then it's "deleting" once Amazon Redshift begins
      deleting the cluster. Use DescribeClusters to monitor the status
      of the deletion. The delete operation cannot be canceled or
      reverted once submitted. For more information about managing
      clusters, go to >>`Amazon Redshift Clusters`_<< in the Amazon
      Redshift Management Guide .

      Parameters:
         **cluster_identifier** (*string*) --

      The identifier of the cluster to be deleted.

      Constraints:

      * Must contain lowercase characters.

      * Must contain from 1 to 63 alphanumeric characters or hyphens.

      * First character must be a letter.

      * Cannot end with a hyphen or contain two consecutive hyphens.

      Parameters:
         **skip_final_cluster_snapshot** (*boolean*) -- Determines
         whether a final snapshot of the cluster is created before
         Amazon Redshift deletes the cluster. If *True*, a final
         cluster snapshot is not created. If *False*, a final cluster
         snapshot is created before the cluster is deleted.

      The FinalClusterSnapshotIdentifier parameter must be specified
      if
         SkipFinalClusterSnapshot is *False*.

      Default: *False*

      Parameters:
         **final_cluster_snapshot_identifier** (*string*) --

      The identifier of the final snapshot that is to be created
      immediately
         before deleting the cluster. If this parameter is provided,
         SkipFinalClusterSnapshot must be *False*.

      Constraints:

      * Must be 1 to 255 alphanumeric characters.

      * First character must be a letter.

      * Cannot end with a hyphen or contain two consecutive hyphens.

   delete_cluster_parameter_group(parameter_group_name)

      Deletes a specified Amazon Redshift parameter group. You cannot
      delete a parameter group if it is associated with a cluster.

      Parameters:
         **parameter_group_name** (*string*) --

      The name of the parameter group to be deleted.

      Constraints:

      * Must be the name of an existing cluster parameter group.

      * Cannot delete a default cluster parameter group.

   delete_cluster_security_group(cluster_security_group_name)

      Deletes an Amazon Redshift security group. You cannot delete a
      security group that is associated with any clusters. You cannot
      delete the default security group. For information about
      managing security groups, go to`Amazon Redshift Cluster Security
      Groups`_ in the Amazon Redshift Management Guide .

      Parameters:
         **cluster_security_group_name** (*string*) -- The name of the
         cluster security group to be deleted.

   delete_cluster_snapshot(snapshot_identifier, snapshot_cluster_identifier=None)

      Deletes the specified manual snapshot. The snapshot must be in
      the "available" state, with no other users authorized to access
      the snapshot.

      Unlike automated snapshots, manual snapshots are retained even
      after you delete your cluster. Amazon Redshift does not delete
      your manual snapshots. You must delete manual snapshot
      explicitly to avoid getting charged. If other accounts are
      authorized to access the snapshot, you must revoke all of the
      authorizations before you can delete the snapshot.

      Parameters:
         **snapshot_identifier** (*string*) -- The unique identifier
         of the manual snapshot to be deleted.

      Constraints: Must be the name of an existing snapshot that is in
      the
         *available* state.

      Parameters:
         **snapshot_cluster_identifier** (*string*) -- The unique
         identifier of the cluster the snapshot was created from. This
         parameter is required if your IAM user has a policy
         containing a snapshot resource element that specifies
         anything other than * for the cluster name.

      Constraints: Must be the name of valid cluster.

   delete_cluster_subnet_group(cluster_subnet_group_name)

      Deletes the specified cluster subnet group.

      Parameters:
         **cluster_subnet_group_name** (*string*) -- The name of the
         cluster subnet group name to be deleted.

   delete_event_subscription(subscription_name)

      Deletes an Amazon Redshift event notification subscription.

      Parameters:
         **subscription_name** (*string*) -- The name of the Amazon
         Redshift event notification subscription to be deleted.

   delete_hsm_client_certificate(hsm_client_certificate_identifier)

      Deletes the specified HSM client certificate.

      Parameters:
         **hsm_client_certificate_identifier** (*string*) -- The
         identifier of the HSM client certificate to be deleted.

   delete_hsm_configuration(hsm_configuration_identifier)

      Deletes the specified Amazon Redshift HSM configuration.

      Parameters:
         **hsm_configuration_identifier** (*string*) -- The identifier
         of the Amazon Redshift HSM configuration to be deleted.

   describe_cluster_parameter_groups(parameter_group_name=None, max_records=None, marker=None)

      Returns a list of Amazon Redshift parameter groups, including
      parameter groups you created and the default parameter group.
      For each parameter group, the response includes the parameter
      group name, description, and parameter group family name. You
      can optionally specify a name to retrieve the description of a
      specific parameter group.

      For more information about managing parameter groups, go to
      >>`Amazon Redshift Parameter Groups`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         * **parameter_group_name** (*string*) -- The name of a
           specific parameter group for which to return details. By
           default, details about all parameter groups and the default
           parameter group are returned.

         * **max_records** (*integer*) -- The maximum number of
           parameter group records to include in the response. If more
           records exist than the specified *MaxRecords* value, the
           response includes a marker that you can use in a subsequent
           DescribeClusterParameterGroups request to retrieve the next
           set of records.

      Default: *100*

      Constraints: Value must be at least 20 and no more than 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned by a
         previous DescribeClusterParameterGroups request to indicate
         the first parameter group that the current request will
         return.

   describe_cluster_parameters(parameter_group_name, source=None, max_records=None, marker=None)

      Returns a detailed list of parameters contained within the
      specified Amazon Redshift parameter group. For each parameter
      the response includes information such as parameter name,
      description, data type, value, whether the parameter value is
      modifiable, and so on.

      You can specify source filter to retrieve parameters of only
      specific type. For example, to retrieve parameters that were
      modified by a user action such as from
      ModifyClusterParameterGroup, you can specify source equal to
      user .

      For more information about managing parameter groups, go to
      >>`Amazon Redshift Parameter Groups`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         * **parameter_group_name** (*string*) -- The name of a
           cluster parameter group for which to return details.

         * **source** (*string*) -- The parameter types to return.
           Specify *user* to show parameters that are different form
           the default. Similarly, specify *engine-default* to show
           parameters that are the same as the default parameter
           group.

      Default: All parameter types returned.

      Valid Values: *user* | *engine-default*

      Parameters:
         **max_records** (*integer*) -- The maximum number of records
         to include in the response. If more records exist than the
         specified *MaxRecords* value, response includes a marker that
         you can specify in your subsequent request to retrieve
         remaining result.

      Default: *100*

      Constraints: Value must be at least 20 and no more than 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned from a
         previous **DescribeClusterParameters** request. If this
         parameter is specified, the response includes only records
         beyond the specified marker, up to the value specified by
         *MaxRecords*.

   describe_cluster_security_groups(cluster_security_group_name=None, max_records=None, marker=None)

      Returns information about Amazon Redshift security groups. If
      the name of a security group is specified, the response will
      contain only information about only that security group.

      For information about managing security groups, go to`Amazon
      Redshift Cluster Security Groups`_ in the Amazon Redshift
      Management Guide .

      Parameters:
         **cluster_security_group_name** (*string*) -- The name of a
         cluster security group for which you are requesting details.
         You can specify either the **Marker** parameter or a
         **ClusterSecurityGroupName** parameter, but not both.

      Example: *securitygroup1*

      Parameters:
         **max_records** (*integer*) -- The maximum number of records
         to be included in the response. If more records exist than
         the specified *MaxRecords* value, a marker is included in the
         response, which you can use in a subsequent
         DescribeClusterSecurityGroups request.

      Default: *100*

      Constraints: Value must be at least 20 and no more than 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned by a
         previous DescribeClusterSecurityGroups request to indicate
         the first security group that the current request will
         return. You can specify either the **Marker** parameter or a
         **ClusterSecurityGroupName** parameter, but not both.

   describe_cluster_snapshots(cluster_identifier=None, snapshot_identifier=None, snapshot_type=None, start_time=None, end_time=None, max_records=None, marker=None, owner_account=None)

      Returns one or more snapshot objects, which contain metadata
      about your cluster snapshots. By default, this operation returns
      information about all snapshots of all clusters that are owned
      by you AWS customer account. No information is returned for
      snapshots owned by inactive AWS customer accounts.

      Parameters:
         * **cluster_identifier** (*string*) -- The identifier of the
           cluster for which information about snapshots is requested.

         * **snapshot_identifier** (*string*) -- The snapshot
           identifier of the snapshot about which to return
           information.

         * **snapshot_type** (*string*) -- The type of snapshots for
           which you are requesting information. By default, snapshots
           of all types are returned.

      Valid Values: *automated* | *manual*

      Parameters:
         **start_time** (*timestamp*) -- A value that requests only
         snapshots created at or after the specified time. The time
         value is specified in ISO 8601 format. For more information
         about ISO 8601, go to the >>`ISO8601 Wikipedia page.`_<<

      Example: *2012-07-16T18:00:00Z*

      Parameters:
         **end_time** (*timestamp*) -- A time value that requests only
         snapshots created at or before the specified time. The time
         value is specified in ISO 8601 format. For more information
         about ISO 8601, go to the >>`ISO8601 Wikipedia page.`_<<

      Example: *2012-07-16T18:00:00Z*

      Parameters:
         **max_records** (*integer*) -- The maximum number of snapshot
         records to include in the response. If more records exist
         than the specified *MaxRecords* value, the response returns a
         marker that you can use in a subsequent
         DescribeClusterSnapshots request in order to retrieve the
         next set of snapshot records.

      Default: *100*

      Constraints: Must be at least 20 and no more than 100.

      Parameters:
         * **marker** (*string*) -- An optional marker returned by a
           previous DescribeClusterSnapshots request to indicate the
           first snapshot that the request will return.

         * **owner_account** (*string*) -- The AWS customer account
           used to create or copy the snapshot. Use this field to
           filter the results to snapshots owned by a particular
           account. To describe snapshots you own, either specify your
           AWS customer account, or do not specify the parameter.

   describe_cluster_subnet_groups(cluster_subnet_group_name=None, max_records=None, marker=None)

      Returns one or more cluster subnet group objects, which contain
      metadata about your cluster subnet groups. By default, this
      operation returns information about all cluster subnet groups
      that are defined in you AWS account.

      Parameters:
         * **cluster_subnet_group_name** (*string*) -- The name of the
           cluster subnet group for which information is requested.

         * **max_records** (*integer*) -- The maximum number of
           cluster subnet group records to include in the response. If
           more records exist than the specified *MaxRecords* value,
           the response returns a marker that you can use in a
           subsequent DescribeClusterSubnetGroups request in order to
           retrieve the next set of cluster subnet group records.

      Default: 100

      Constraints: Must be at least 20 and no more than 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned by a
         previous DescribeClusterSubnetGroups request to indicate the
         first cluster subnet group that the current request will
         return.

   describe_cluster_versions(cluster_version=None, cluster_parameter_group_family=None, max_records=None, marker=None)

      Returns descriptions of the available Amazon Redshift cluster
      versions. You can call this operation even before creating any
      clusters to learn more about the Amazon Redshift versions. For
      more information about managing clusters, go to >>`Amazon
      Redshift Clusters`_<< in the Amazon Redshift Management Guide

      Parameters:
         **cluster_version** (*string*) -- The specific cluster
         version to return.

      Example: *1.0*

      Parameters:
         **cluster_parameter_group_family** (*string*) --

      The name of a specific cluster parameter group family to return
      details
         for.

      Constraints:

      * Must be 1 to 255 alphanumeric characters

      * First character must be a letter

      * Cannot end with a hyphen or contain two consecutive hyphens

      Parameters:
         **max_records** (*integer*) -- The maximum number of records
         to include in the response. If more than the *MaxRecords*
         value is available, a marker is included in the response so
         that the following results can be retrieved.

      Default: *100*

      Constraints: Value must be at least 20 and no more than 100.

      Parameters:
         **marker** (*string*) -- The marker returned from a previous
         request. If this parameter is specified, the response
         includes records beyond the marker only, up to *MaxRecords*.

   describe_clusters(cluster_identifier=None, max_records=None, marker=None)

      Returns properties of provisioned clusters including general
      cluster properties, cluster database properties, maintenance and
      backup properties, and security and access properties. This
      operation supports pagination. For more information about
      managing clusters, go to >>`Amazon Redshift Clusters`_<< in the
      Amazon Redshift Management Guide .

      Parameters:
         **cluster_identifier** (*string*) -- The unique identifier of
         a cluster whose properties you are requesting. This parameter
         isn't case sensitive.

      The default is that all clusters defined for an account are
      returned.

      Parameters:
         **max_records** (*integer*) -- The maximum number of records
         that the response can include. If more records exist than the
         specified *MaxRecords* value, a *marker* is included in the
         response that can be used in a new **DescribeClusters**
         request to continue listing results.

      Default: *100*

      Constraints: Value must be at least 20 and no more than 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned by a
         previous **DescribeClusters** request to indicate the first
         cluster that the current **DescribeClusters** request will
         return.

      You can specify either a **Marker** parameter or a
         **ClusterIdentifier** parameter in a **DescribeClusters**
         request, but not both.

   describe_default_cluster_parameters(parameter_group_family, max_records=None, marker=None)

      Returns a list of parameter settings for the specified parameter
      group family.

      For more information about managing parameter groups, go to
      >>`Amazon Redshift Parameter Groups`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         * **parameter_group_family** (*string*) -- The name of the
           cluster parameter group family.

         * **max_records** (*integer*) -- The maximum number of
           records to include in the response. If more records exist
           than the specified *MaxRecords* value, a marker is included
           in the response so that the remaining results may be
           retrieved.

      Default: *100*

      Constraints: Value must be at least 20 and no more than 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned from a
         previous **DescribeDefaultClusterParameters** request. If
         this parameter is specified, the response includes only
         records beyond the marker, up to the value specified by
         *MaxRecords*.

   describe_event_categories(source_type=None)

      Displays a list of event categories for all event source types,
      or for a specified source type. For a list of the event
      categories and source types, go to >>`Amazon Redshift Event
      Notifications`_<<.

      Parameters:
         **source_type** (*string*) -- The source type, such as
         cluster or parameter group, to which the described event
         categories apply.

      Valid values: cluster, snapshot, parameter group, and security
      group.

   describe_event_subscriptions(subscription_name=None, max_records=None, marker=None)

      Lists descriptions of all the Amazon Redshift event
      notifications subscription for a customer account. If you
      specify a subscription name, lists the description for that
      subscription.

      Parameters:
         * **subscription_name** (*string*) -- The name of the Amazon
           Redshift event notification subscription to be described.

         * **max_records** (*integer*) -- The maximum number of
           records to include in the response. If more records exist
           than the specified MaxRecords value, a pagination token
           called a marker is included in the response so that the
           remaining results can be retrieved.

      Default: 100

      Constraints: minimum 20, maximum 100

      Parameters:
         **marker** (*string*) -- An optional pagination token
         provided by a previous DescribeOrderableClusterOptions
         request. If this parameter is specified, the response
         includes only records beyond the marker, up to the value
         specified by MaxRecords.

   describe_events(source_identifier=None, source_type=None, start_time=None, end_time=None, duration=None, max_records=None, marker=None)

      Returns events related to clusters, security groups, snapshots,
      and parameter groups for the past 14 days. Events specific to a
      particular cluster, security group, snapshot or parameter group
      can be obtained by providing the name as a parameter. By
      default, the past hour of events are returned.

      Parameters:
         **source_identifier** (*string*) --

      The identifier of the event source for which events will be
      returned.
         If this parameter is not specified, then all sources are
         included in the response.

      Constraints:

      If SourceIdentifier is supplied, SourceType must also be
      provided.

      * Specify a cluster identifier when SourceType is *cluster*.

      * Specify a cluster security group name when SourceType is
        >>`<<cluster-
           security-group`.

      * Specify a cluster parameter group name when SourceType is
        >>`<<cluster-
           parameter-group`.

      * Specify a cluster snapshot identifier when SourceType is
        >>`<<cluster-
           snapshot`.

      Parameters:
         **source_type** (*string*) --

      The event source to retrieve events for. If no value is
      specified, all
         events are returned.

      Constraints:

      If SourceType is supplied, SourceIdentifier must also be
      provided.

      * Specify *cluster* when SourceIdentifier is a cluster
        identifier.

      * Specify *cluster-security-group* when SourceIdentifier is a
        cluster
           security group name.

      * Specify *cluster-parameter-group* when SourceIdentifier is a
        cluster
           parameter group name.

      * Specify *cluster-snapshot* when SourceIdentifier is a cluster
           snapshot identifier.

      Parameters:
         **start_time** (*timestamp*) -- The beginning of the time
         interval to retrieve events for, specified in ISO 8601
         format. For more information about ISO 8601, go to the
         >>`ISO8601 Wikipedia page.`_<<

      Example: *2009-07-08T18:00Z*

      Parameters:
         **end_time** (*timestamp*) -- The end of the time interval
         for which to retrieve events, specified in ISO 8601 format.
         For more information about ISO 8601, go to the >>`ISO8601
         Wikipedia page.`_<<

      Example: *2009-07-08T18:00Z*

      Parameters:
         **duration** (*integer*) -- The number of minutes prior to
         the time of the request for which to retrieve events. For
         example, if the request is sent at 18:00 and you specify a
         duration of 60, then only events which have occurred after
         17:00 will be returned.

      Default: *60*

      Parameters:
         **max_records** (*integer*) -- The maximum number of records
         to include in the response. If more records exist than the
         specified *MaxRecords* value, a marker is included in the
         response so that the remaining results may be retrieved.

      Default: *100*

      Constraints: Value must be at least 20 and no more than 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned from a
         previous **DescribeEvents** request. If this parameter is
         specified, the response includes only records beyond the
         marker, up to the value specified by *MaxRecords*.

   describe_hsm_client_certificates(hsm_client_certificate_identifier=None, max_records=None, marker=None)

      Returns information about the specified HSM client certificate.
      If no certificate ID is specified, returns information about all
      the HSM certificates owned by your AWS customer account.

      Parameters:
         * **hsm_client_certificate_identifier** (*string*) -- The
           identifier of a specific HSM client certificate for which
           you want information. If no identifier is specified,
           information is returned for all HSM client certificates
           associated with Amazon Redshift clusters owned by your AWS
           customer account.

         * **max_records** (*integer*) -- The maximum number of
           records to include in the response. If more records exist
           than the specified *MaxRecords* value, a marker is included
           in the response so that the remaining results may be
           retrieved.

      Default: *100*

      Constraints: minimum 20, maximum 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned from a
         previous **DescribeOrderableClusterOptions** request. If this
         parameter is specified, the response includes only records
         beyond the marker, up to the value specified by *MaxRecords*.

   describe_hsm_configurations(hsm_configuration_identifier=None, max_records=None, marker=None)

      Returns information about the specified Amazon Redshift HSM
      configuration. If no configuration ID is specified, returns
      information about all the HSM configurations owned by your AWS
      customer account.

      Parameters:
         * **hsm_configuration_identifier** (*string*) -- The
           identifier of a specific Amazon Redshift HSM configuration
           to be described. If no identifier is specified, information
           is returned for all HSM configurations owned by your AWS
           customer account.

         * **max_records** (*integer*) -- The maximum number of
           records to include in the response. If more records exist
           than the specified *MaxRecords* value, a marker is included
           in the response so that the remaining results may be
           retrieved.

      Default: *100*

      Constraints: minimum 20, maximum 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned from a
         previous **DescribeOrderableClusterOptions** request. If this
         parameter is specified, the response includes only records
         beyond the marker, up to the value specified by *MaxRecords*.

   describe_logging_status(cluster_identifier)

      Describes whether information, such as queries and connection
      attempts, is being logged for the specified Amazon Redshift
      cluster.

      Parameters:
         **cluster_identifier** (*string*) -- The identifier of the
         cluster to get the logging status from.

      Example: *examplecluster*

   describe_orderable_cluster_options(cluster_version=None, node_type=None, max_records=None, marker=None)

      Returns a list of orderable cluster options. Before you create a
      new cluster you can use this operation to find what options are
      available, such as the EC2 Availability Zones (AZ) in the
      specific AWS region that you can specify, and the node types you
      can request. The node types differ by available storage, memory,
      CPU and price. With the cost involved you might want to obtain a
      list of cluster options in the specific region and specify
      values when creating a cluster. For more information about
      managing clusters, go to >>`Amazon Redshift Clusters`_<< in the
      Amazon Redshift Management Guide

      Parameters:
         **cluster_version** (*string*) -- The version filter value.
         Specify this parameter to show only the available offerings
         matching the specified version.

      Default: All versions.

      Constraints: Must be one of the version returned from
         DescribeClusterVersions.

      Parameters:
         * **node_type** (*string*) -- The node type filter value.
           Specify this parameter to show only the available offerings
           matching the specified node type.

         * **max_records** (*integer*) -- The maximum number of
           records to include in the response. If more records exist
           than the specified *MaxRecords* value, a marker is included
           in the response so that the remaining results may be
           retrieved.

      Default: *100*

      Constraints: minimum 20, maximum 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned from a
         previous **DescribeOrderableClusterOptions** request. If this
         parameter is specified, the response includes only records
         beyond the marker, up to the value specified by *MaxRecords*.

   describe_reserved_node_offerings(reserved_node_offering_id=None, max_records=None, marker=None)

      Returns a list of the available reserved node offerings by
      Amazon Redshift with their descriptions including the node type,
      the fixed and recurring costs of reserving the node and duration
      the node will be reserved for you. These descriptions help you
      determine which reserve node offering you want to purchase. You
      then use the unique offering ID in you call to
      PurchaseReservedNodeOffering to reserve one or more nodes for
      your Amazon Redshift cluster.

      For more information about managing parameter groups, go to
      >>`Purchasing Reserved Nodes`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         * **reserved_node_offering_id** (*string*) -- The unique
           identifier for the offering.

         * **max_records** (*integer*) -- The maximum number of
           records to include in the response. If more records exist
           than the specified *MaxRecords* value, a marker is included
           in the response so that the remaining results may be
           retrieved.

      Default: *100*

      Constraints: minimum 20, maximum 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned by a
         previous DescribeReservedNodeOfferings request to indicate
         the first offering that the request will return.

      You can specify either a **Marker** parameter or a
         **ClusterIdentifier** parameter in a DescribeClusters
         request, but not both.

   describe_reserved_nodes(reserved_node_id=None, max_records=None, marker=None)

      Returns the descriptions of the reserved nodes.

      Parameters:
         * **reserved_node_id** (*string*) -- Identifier for the node
           reservation.

         * **max_records** (*integer*) -- The maximum number of
           records to include in the response. If more records exist
           than the specified *MaxRecords* value, a marker is included
           in the response so that the remaining results may be
           retrieved.

      Default: *100*

      Constraints: minimum 20, maximum 100.

      Parameters:
         **marker** (*string*) -- An optional marker returned by a
         previous DescribeReservedNodes request to indicate the first
         parameter group that the current request will return.

   describe_resize(cluster_identifier)

      Returns information about the last resize operation for the
      specified cluster. If no resize operation has ever been
      initiated for the specified cluster, a *HTTP 404* error is
      returned. If a resize operation was initiated and completed, the
      status of the resize remains as *SUCCEEDED* until the next
      resize.

      A resize operation can be requested using ModifyCluster and
      specifying a different number or type of nodes for the cluster.

      Parameters:
         **cluster_identifier** (*string*) -- The unique identifier of
         a cluster whose resize progress you are requesting. This
         parameter isn't case- sensitive.

      By default, resize operations for all clusters defined for an
      AWS
         account are returned.

   disable_logging(cluster_identifier)

      Stops logging information, such as queries and connection
      attempts, for the specified Amazon Redshift cluster.

      Parameters:
         **cluster_identifier** (*string*) -- The identifier of the
         cluster on which logging is to be stopped.

      Example: *examplecluster*

   disable_snapshot_copy(cluster_identifier)

      Disables the automatic copying of snapshots from one region to
      another region for a specified cluster.

      Parameters:
         **cluster_identifier** (*string*) -- The unique identifier of
         the source cluster that you want to disable copying of
         snapshots to a destination region.

      Constraints: Must be the valid name of an existing cluster that
      has
         cross-region snapshot copy enabled.

   enable_logging(cluster_identifier, bucket_name, s3_key_prefix=None)

      Starts logging information, such as queries and connection
      attempts, for the specified Amazon Redshift cluster.

      Parameters:
         **cluster_identifier** (*string*) -- The identifier of the
         cluster on which logging is to be started.

      Example: *examplecluster*

      Parameters:
         **bucket_name** (*string*) --

      The name of an existing S3 bucket where the log files are to be
      stored.

      Constraints:

      * Must be in the same region as the cluster

      * The cluster must have read bucket and put object permissions

      Parameters:
         **s3_key_prefix** (*string*) --

      The prefix applied to the log file names.

      Constraints:

      * Cannot exceed 512 characters

      * Cannot contain spaces( ), double quotes ("), single quotes
        ('), a
              backslash (), or control characters. The hexadecimal
              codes for invalid characters are:

           * x00 to x20

           * x22

           * x27

           * x5c

           * x7f or larger

   enable_snapshot_copy(cluster_identifier, destination_region, retention_period=None)

      Enables the automatic copy of snapshots from one region to
      another region for a specified cluster.

      Parameters:
         **cluster_identifier** (*string*) -- The unique identifier of
         the source cluster to copy snapshots from.

      Constraints: Must be the valid name of an existing cluster that
      does
         not already have cross-region snapshot copy enabled.

      Parameters:
         **destination_region** (*string*) -- The destination region
         that you want to copy snapshots to.

      Constraints: Must be the name of a valid region. For more
      information,
         see >>`Regions and Endpoints`_<< in the Amazon Web Services
         General Reference.

      Parameters:
         **retention_period** (*integer*) -- The number of days to
         retain automated snapshots in the destination region after
         they are copied from the source region.

      Default: 7.

      Constraints: Must be at least 1 and no more than 35.

   modify_cluster(cluster_identifier, cluster_type=None, node_type=None, number_of_nodes=None, cluster_security_groups=None, vpc_security_group_ids=None, master_user_password=None, cluster_parameter_group_name=None, automated_snapshot_retention_period=None, preferred_maintenance_window=None, cluster_version=None, allow_version_upgrade=None, hsm_client_certificate_identifier=None, hsm_configuration_identifier=None)

      Modifies the settings for a cluster. For example, you can add
      another security or parameter group, update the preferred
      maintenance window, or change the master user password.
      Resetting a cluster password or modifying the security groups
      associated with a cluster do not need a reboot. However,
      modifying parameter group requires a reboot for parameters to
      take effect. For more information about managing clusters, go to
      >>`Amazon Redshift Clusters`_<< in the Amazon Redshift
      Management Guide

      You can also change node type and the number of nodes to scale
      up or down the cluster. When resizing a cluster, you must
      specify both the number of nodes and the node type even if one
      of the parameters does not change. If you specify the same
      number of nodes and node type that are already configured for
      the cluster, an error is returned.

      Parameters:
         **cluster_identifier** (*string*) -- The unique identifier of
         the cluster to be modified.

      Example: *examplecluster*

      Parameters:
         **cluster_type** (*string*) -- The new cluster type.

      When you submit your cluster resize request, your existing
      cluster goes
         into a read-only mode. After Amazon Redshift provisions a new
         cluster based on your resize requirements, there will be
         outage for a period while the old cluster is deleted and your
         connection is switched to the new cluster. You can use
         DescribeResize to track the progress of the resize request.

      Valid Values: ` multi-node | single-node `

      Parameters:
         **node_type** (*string*) -- The new node type of the cluster.
         If you specify a new node type, you must also specify the
         number of nodes parameter also.

      When you submit your request to resize a cluster, Amazon
      Redshift sets
         access permissions for the cluster to read-only. After Amazon
         Redshift provisions a new cluster according to your resize
         requirements, there will be a temporary outage while the old
         cluster is deleted and your connection is switched to the new
         cluster. When the new connection is complete, the original
         access permissions for the cluster are restored. You can use
         the DescribeResize to track the progress of the resize
         request.

      Valid Values: ` dw.hs1.xlarge` | *dw.hs1.8xlarge*

      Parameters:
         **number_of_nodes** (*integer*) -- The new number of nodes of
         the cluster. If you specify a new number of nodes, you must
         also specify the node type parameter also.

      When you submit your request to resize a cluster, Amazon
      Redshift sets
         access permissions for the cluster to read-only. After Amazon
         Redshift provisions a new cluster according to your resize
         requirements, there will be a temporary outage while the old
         cluster is deleted and your connection is switched to the new
         cluster. When the new connection is complete, the original
         access permissions for the cluster are restored. You can use
         DescribeResize to track the progress of the resize request.

      Valid Values: Integer greater than *0*.

      Parameters:
         **cluster_security_groups** (*list*) --

      A list of cluster security groups to be authorized on this
      cluster.
         This change is asynchronously applied as soon as possible.

      Security groups currently associated with the cluster and not in
      the
         list of groups to apply, will be revoked from the cluster.

      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

      Parameters:
         * **vpc_security_group_ids** (*list*) -- A list of Virtual
           Private Cloud (VPC) security groups to be associated with
           the cluster.

         * **master_user_password** (*string*) --

      The new password for the cluster master user. This change is
         asynchronously applied as soon as possible. Between the time
         of the request and the completion of the request, the
         *MasterUserPassword* element exists in the
         *PendingModifiedValues* element of the operation response.

      Operations never return the password, so this operation provides
      a way
         to regain access to the master user account for a cluster if
         the password is lost.

      Default: Uses existing setting.

      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.

      * Can be any printable ASCII character (ASCII code 33 to 126)
        except '
           (single quote), " (double quote), , /, @, or space.

      Parameters:
         **cluster_parameter_group_name** (*string*) -- The name of
         the cluster parameter group to apply to this cluster. This
         change is applied only after the cluster is rebooted. To
         reboot a cluster use RebootCluster.

      Default: Uses existing setting.

      Constraints: The cluster parameter group must be in the same
      parameter
         group family that matches the cluster version.

      Parameters:
         **automated_snapshot_retention_period** (*integer*) -- The
         number of days that automated snapshots are retained. If the
         value is 0, automated snapshots are disabled. Even if
         automated snapshots are disabled, you can still create manual
         snapshots when you want with CreateClusterSnapshot.

      If you decrease the automated snapshot retention period from its
         current value, existing automated snapshots which fall
         outside of the new retention period will be immediately
         deleted.

      Default: Uses existing setting.

      Constraints: Must be a value from 0 to 35.

      Parameters:
         **preferred_maintenance_window** (*string*) -- The weekly
         time range (in UTC) during which system maintenance can
         occur, if necessary. If system maintenance is necessary
         during the window, it may result in an outage.

      This maintenance window change is made immediately. If the new
         maintenance window indicates the current time, there must be
         at least 120 minutes between the current time and end of the
         window in order to ensure that pending changes are applied.

      Default: Uses existing setting.

      Format: ddd:hh24:mi-ddd:hh24:mi, for example
      *wed:07:30-wed:08:00*.

      Valid Days: Mon | Tue | Wed | Thu | Fri | Sat | Sun

      Constraints: Must be at least 30 minutes.

      Parameters:
         **cluster_version** (*string*) -- The new version number of
         the Amazon Redshift engine to upgrade to.

      For major version upgrades, if a non-default cluster parameter
      group is
         currently in use, a new cluster parameter group in the
         cluster parameter group family for the new version must be
         specified. The new cluster parameter group can be the default
         for that cluster parameter group family. For more information
         about managing parameter groups, go to >>`Amazon Redshift
         Parameter Groups`_<< in the Amazon Redshift Management Guide
         .

      Example: *1.0*

      Parameters:
         **allow_version_upgrade** (*boolean*) -- If *True*, upgrades
         will be applied automatically to the cluster during the
         maintenance window.

      Default: *False*

      Parameters:
         * **hsm_client_certificate_identifier** (*string*) --
           Specifies the name of the HSM client certificate the Amazon
           Redshift cluster uses to retrieve the data encryption keys
           stored in an HSM.

         * **hsm_configuration_identifier** (*string*) -- Specifies
           the name of the HSM configuration that contains the
           information the Amazon Redshift cluster can use to retrieve
           and store keys in an HSM.

   modify_cluster_parameter_group(parameter_group_name, parameters)

      Modifies the parameters of a parameter group.

      For more information about managing parameter groups, go to
      >>`Amazon Redshift Parameter Groups`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         * **parameter_group_name** (*string*) -- The name of the
           parameter group to be modified.

         * **parameters** (*list*) -- An array of parameters to be
           modified. A maximum of 20 parameters can be modified in a
           single request.

      For each parameter to be modified, you must supply at least the
         parameter name and parameter value; other name-value pairs of
         the parameter are optional.

   modify_cluster_subnet_group(cluster_subnet_group_name, subnet_ids, description=None)

      Modifies a cluster subnet group to include the specified list of
      VPC subnets. The operation replaces the existing list of subnets
      with the new list of subnets.

      Parameters:
         * **cluster_subnet_group_name** (*string*) -- The name of the
           subnet group to be modified.

         * **description** (*string*) -- A text description of the
           subnet group to be modified.

         * **subnet_ids** (*list*) -- An array of VPC subnet IDs. A
           maximum of 20 subnets can be modified in a single request.

   modify_event_subscription(subscription_name, sns_topic_arn=None, source_type=None, source_ids=None, event_categories=None, severity=None, enabled=None)

      Modifies an existing Amazon Redshift event notification
      subscription.

      Parameters:
         * **subscription_name** (*string*) -- The name of the
           modified Amazon Redshift event notification subscription.

         * **sns_topic_arn** (*string*) -- The Amazon Resource Name
           (ARN) of the SNS topic to be used by the event notification
           subscription.

         * **source_type** (*string*) -- The type of source that will
           be generating the events. For example, if you want to be
           notified of events generated by a cluster, you would set
           this parameter to cluster. If this value is not specified,
           events are returned for all Amazon Redshift objects in your
           AWS account. You must specify a source type in order to
           specify source IDs.

      Valid values: cluster, cluster-parameter-group, cluster-
      security-group,
         and cluster-snapshot.

      Parameters:
         **source_ids** (*list*) -- A list of one or more identifiers
         of Amazon Redshift source objects. All of the objects must be
         of the same type as was specified in the source type
         parameter. The event subscription will return only events
         generated by the specified objects. If not specified, then
         events are returned for all objects within the source type
         specified.

      Example: my-cluster-1, my-cluster-2

      Example: my-snapshot-20131010

      Parameters:
         **event_categories** (*list*) -- Specifies the Amazon
         Redshift event categories to be published by the event
         notification subscription.

      Values: Configuration, Management, Monitoring, Security

      Parameters:
         **severity** (*string*) -- Specifies the Amazon Redshift
         event severity to be published by the event notification
         subscription.

      Values: ERROR, INFO

      Parameters:
         **enabled** (*boolean*) -- A Boolean value indicating if the
         subscription is enabled. *True* indicates the subscription is
         enabled

   modify_snapshot_copy_retention_period(cluster_identifier, retention_period)

      Modifies the number of days to retain automated snapshots in the
      destination region after they are copied from the source region.

      Parameters:
         **cluster_identifier** (*string*) -- The unique identifier of
         the cluster for which you want to change the retention period
         for automated snapshots that are copied to a destination
         region.

      Constraints: Must be the valid name of an existing cluster that
      has
         cross-region snapshot copy enabled.

      Parameters:
         **retention_period** (*integer*) -- The number of days to
         retain automated snapshots in the destination region after
         they are copied from the source region.

      If you decrease the retention period for automated snapshots
      that are
         copied to a destination region, Amazon Redshift will delete
         any existing automated snapshots that were copied to the
         destination region and that fall outside of the new retention
         period.

      Constraints: Must be at least 1 and no more than 35.

   purchase_reserved_node_offering(reserved_node_offering_id, node_count=None)

      Allows you to purchase reserved nodes. Amazon Redshift offers a
      predefined set of reserved node offerings. You can purchase one
      of the offerings. You can call the DescribeReservedNodeOfferings
      API to obtain the available reserved node offerings. You can
      call this API by providing a specific reserved node offering and
      the number of nodes you want to reserve.

      For more information about managing parameter groups, go to
      >>`Purchasing Reserved Nodes`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         * **reserved_node_offering_id** (*string*) -- The unique
           identifier of the reserved node offering you want to
           purchase.

         * **node_count** (*integer*) -- The number of reserved nodes
           you want to purchase.

      Default: *1*

   reboot_cluster(cluster_identifier)

      Reboots a cluster. This action is taken as soon as possible. It
      results in a momentary outage to the cluster, during which the
      cluster status is set to *rebooting*. A cluster event is created
      when the reboot is completed. Any pending cluster modifications
      (see ModifyCluster) are applied at this reboot. For more
      information about managing clusters, go to >>`Amazon Redshift
      Clusters`_<< in the Amazon Redshift Management Guide

      Parameters:
         **cluster_identifier** (*string*) -- The cluster identifier.

   reset_cluster_parameter_group(parameter_group_name, reset_all_parameters=None, parameters=None)

      Sets one or more parameters of the specified parameter group to
      their default values and sets the source values of the
      parameters to "engine-default". To reset the entire parameter
      group specify the ResetAllParameters parameter. For parameter
      changes to take effect you must reboot any associated clusters.

      Parameters:
         * **parameter_group_name** (*string*) -- The name of the
           cluster parameter group to be reset.

         * **reset_all_parameters** (*boolean*) -- If *True*, all
           parameters in the specified parameter group will be reset
           to their default values.

      Default: *True*

      Parameters:
         **parameters** (*list*) -- An array of names of parameters to
         be reset. If ResetAllParameters option is not used, then at
         least one parameter name must be supplied.

      Constraints: A maximum of 20 parameters can be reset in a single
         request.

   restore_from_cluster_snapshot(cluster_identifier, snapshot_identifier, snapshot_cluster_identifier=None, port=None, availability_zone=None, allow_version_upgrade=None, cluster_subnet_group_name=None, publicly_accessible=None, owner_account=None, hsm_client_certificate_identifier=None, hsm_configuration_identifier=None, elastic_ip=None)

      Creates a new cluster from a snapshot. Amazon Redshift creates
      the resulting cluster with the same configuration as the
      original cluster from which the snapshot was created, except
      that the new cluster is created with the default cluster
      security and parameter group. After Amazon Redshift creates the
      cluster you can use the ModifyCluster API to associate a
      different security group and different parameter group with the
      restored cluster.

      If a snapshot is taken of a cluster in VPC, you can restore it
      only in VPC. In this case, you must provide a cluster subnet
      group where you want the cluster restored. If snapshot is taken
      of a cluster outside VPC, then you can restore it only outside
      VPC.

      For more information about working with snapshots, go to
      >>`Amazon Redshift Snapshots`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         **cluster_identifier** (*string*) -- The identifier of the
         cluster that will be created from restoring the snapshot.

      Constraints:

      * Must contain from 1 to 63 alphanumeric characters or hyphens.

      * Alphabetic characters must be lowercase.

      * First character must be a letter.

      * Cannot end with a hyphen or contain two consecutive hyphens.

      * Must be unique for all clusters within an AWS account.

      Parameters:
         **snapshot_identifier** (*string*) -- The name of the
         snapshot from which to create the new cluster. This parameter
         isn't case sensitive.

      Example: *my-snapshot-id*

      Parameters:
         * **snapshot_cluster_identifier** (*string*) -- The name of
           the cluster the source snapshot was created from. This
           parameter is required if your IAM user has a policy
           containing a snapshot resource element that specifies
           anything other than * for the cluster name.

         * **port** (*integer*) -- The port number on which the
           cluster accepts connections.

      Default: The same port as the original cluster.

      Constraints: Must be between *1115* and *65535*.

      Parameters:
         **availability_zone** (*string*) -- The Amazon EC2
         Availability Zone in which to restore the cluster.

      Default: A random, system-chosen Availability Zone.

      Example: *us-east-1a*

      Parameters:
         **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*

      Parameters:
         **cluster_subnet_group_name** (*string*) -- The name of the
         subnet group where you want to cluster restored.

      A snapshot of cluster in VPC can be restored only in VPC.
      Therefore,
         you must provide subnet group name where you want the cluster
         restored.

      Parameters:
         * **publicly_accessible** (*boolean*) -- If *True*, the
           cluster can be accessed from a public network.

         * **owner_account** (*string*) -- The AWS customer account
           used to create or copy the snapshot. Required if you are
           restoring a snapshot you do not own, optional if you own
           the snapshot.

         * **hsm_client_certificate_identifier** (*string*) --
           Specifies the name of the HSM client certificate the Amazon
           Redshift cluster uses to retrieve the data encryption keys
           stored in an HSM.

         * **hsm_configuration_identifier** (*string*) -- Specifies
           the name of the HSM configuration that contains the
           information the Amazon Redshift cluster can use to retrieve
           and store keys in an HSM.

         * **elastic_ip** (*string*) -- The elastic IP (EIP) address
           for the cluster.

   revoke_cluster_security_group_ingress(cluster_security_group_name, cidrip=None, ec2_security_group_name=None, ec2_security_group_owner_id=None)

      Revokes an ingress rule in an Amazon Redshift security group for
      a previously authorized IP range or Amazon EC2 security group.
      To add an ingress rule, see
      AuthorizeClusterSecurityGroupIngress. For information about
      managing security groups, go to`Amazon Redshift Cluster Security
      Groups`_ in the Amazon Redshift Management Guide .

      Parameters:
         * **cluster_security_group_name** (*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*

   revoke_snapshot_access(snapshot_identifier, account_with_restore_access, snapshot_cluster_identifier=None)

      Removes the ability of the specified AWS customer account to
      restore the specified snapshot. If the account is currently
      restoring the snapshot, the restore will run to completion.

      For more information about working with snapshots, go to
      >>`Amazon Redshift Snapshots`_<< in the Amazon Redshift
      Management Guide .

      Parameters:
         * **snapshot_identifier** (*string*) -- The identifier of the
           snapshot that the account can no longer access.

         * **snapshot_cluster_identifier** (*string*) -- The
           identifier of the cluster the snapshot was created from.
           This parameter is required if your IAM user has a policy
           containing a snapshot resource element that specifies
           anything other than * for the cluster name.

         * **account_with_restore_access** (*string*) -- The
           identifier of the AWS customer account that can no longer
           restore the specified snapshot.

   rotate_encryption_key(cluster_identifier)

      Rotates the encryption keys for a cluster.

      Parameters:
         **cluster_identifier** (*string*) -- The unique identifier of
         the cluster that you want to rotate the encryption keys for.

      Constraints: Must be the name of valid cluster that has
      encryption
         enabled.


boto.redshift.exceptions
========================

exception exception boto.redshift.exceptions.AccessToSnapshotDenied(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.AccessToSnapshotDeniedFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.AuthorizationAlreadyExists(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.AuthorizationAlreadyExistsFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.AuthorizationNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.AuthorizationNotFoundFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.AuthorizationQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.AuthorizationQuotaExceededFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.BucketNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterAlreadyExists(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterAlreadyExistsFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterNotFoundFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterParameterGroupAlreadyExists(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterParameterGroupAlreadyExistsFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterParameterGroupNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterParameterGroupNotFoundFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterParameterGroupQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterParameterGroupQuotaExceededFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterQuotaExceededFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSecurityGroupAlreadyExists(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSecurityGroupAlreadyExistsFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSecurityGroupNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSecurityGroupNotFoundFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSecurityGroupQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSecurityGroupQuotaExceededFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSnapshotAlreadyExists(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSnapshotAlreadyExistsFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSnapshotNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSnapshotNotFoundFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSnapshotQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSnapshotQuotaExceededFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSubnetGroupAlreadyExists(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSubnetGroupAlreadyExistsFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSubnetGroupNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSubnetGroupNotFoundFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSubnetGroupQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSubnetGroupQuotaExceededFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSubnetQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ClusterSubnetQuotaExceededFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.CopyToRegionDisabled(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.EventSubscriptionQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.HsmClientCertificateAlreadyExists(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.HsmClientCertificateNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.HsmClientCertificateQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.HsmConfigurationAlreadyExists(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.HsmConfigurationNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.HsmConfigurationQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.IncompatibleOrderableOptions(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InsufficientClusterCapacity(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InsufficientClusterCapacityFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InsufficientS3BucketPolicy(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterParameterGroupState(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterParameterGroupStateFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterSecurityGroupState(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterSecurityGroupStateFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterSnapshotState(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterSnapshotStateFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterState(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterStateFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterSubnetGroupState(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterSubnetGroupStateFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterSubnetState(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidClusterSubnetStateFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidElasticIp(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidHsmClientCertificateState(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidHsmConfigurationState(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidParameterCombinationFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidRestore(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidRestoreFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidS3BucketName(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidS3KeyPrefix(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidSubnet(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidVPCNetworkState(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.InvalidVPCNetworkStateFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.NumberOfNodesPerClusterLimitExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.NumberOfNodesPerClusterLimitExceededFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.NumberOfNodesQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.NumberOfNodesQuotaExceededFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ReservedNodeAlreadyExists(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ReservedNodeAlreadyExistsFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ReservedNodeNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ReservedNodeNotFoundFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ReservedNodeOfferingNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ReservedNodeOfferingNotFoundFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ReservedNodeQuotaExceeded(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ReservedNodeQuotaExceededFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ResizeNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.ResizeNotFoundFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SNSInvalidTopic(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SNSNoAuthorization(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SNSTopicArnNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SnapshotCopyAlreadyDisabled(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SnapshotCopyAlreadyEnabled(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SnapshotCopyDisabled(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SourceNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SubnetAlreadyInUse(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SubscriptionAlreadyExist(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SubscriptionCategoryNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SubscriptionEventIdNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SubscriptionNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.SubscriptionSeverityNotFound(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.UnauthorizedOperation(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.UnauthorizedOperationFault(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.UnknownSnapshotCopyRegion(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.UnsupportedOption(status, reason, body=None, *args)

exception exception boto.redshift.exceptions.UnsupportedOptionFault(status, reason, body=None, *args)
