Merging in latest boto.

boto/rds/__init__.py

 # Copyright (c) 2009 Mitch Garnaat http://garnaat.org/
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish, dis-
 # tribute, sublicense, and/or sell copies of the Software, and to permit
 # persons to whom the Software is furnished to do so, subject to the fol-
 # lowing conditions:
 #
@@ skipping 20 matching lines @@
 from boto.rds.regioninfo import RDSRegionInfo
 
 def regions():
     """
     Get all available regions for the RDS service.
 
     :rtype: list
     :return: A list of :class:`boto.rds.regioninfo.RDSRegionInfo`
     """
     return [RDSRegionInfo(name='us-east-1',
-                          endpoint='rds.amazonaws.com'),
+                          endpoint='rds.us-east-1.amazonaws.com'),
             RDSRegionInfo(name='eu-west-1',
-                          endpoint='eu-west-1.rds.amazonaws.com'),
+                          endpoint='rds.eu-west-1.amazonaws.com'),
             RDSRegionInfo(name='us-west-1',
-                          endpoint='us-west-1.rds.amazonaws.com'),
+                          endpoint='rds.us-west-1.amazonaws.com'),
+            RDSRegionInfo(name='ap-northeast-1',
+                          endpoint='rds.ap-northeast-1.amazonaws.com'),
             RDSRegionInfo(name='ap-southeast-1',
-                          endpoint='ap-southeast-1.rds.amazonaws.com')
+                          endpoint='rds.ap-southeast-1.amazonaws.com')
             ]
 
-def connect_to_region(region_name):
+def connect_to_region(region_name, **kw_params):
+    """
+    Given a valid region name, return a 
+    :class:`boto.ec2.connection.EC2Connection`.
+    Any additional parameters after the region_name are passed on to
+    the connect method of the region object.
+
+    :type: str
+    :param region_name: The name of the region to connect to.
+
+    :rtype: :class:`boto.ec2.connection.EC2Connection` or ``None``
+    :return: A connection to the given region, or None if an invalid region
+             name is given
+    """
     for region in regions():
         if region.name == region_name:
-            return region.connect()
+            return region.connect(**kw_params)
     return None
 
 #boto.set_stream_logger('rds')
 
 class RDSConnection(AWSQueryConnection):
 
     DefaultRegionName = 'us-east-1'
     DefaultRegionEndpoint = 'rds.amazonaws.com'
-    APIVersion = '2009-10-16'
+    APIVersion = '2011-04-01'
 
     def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
                  is_secure=True, port=None, proxy=None, proxy_port=None,
                  proxy_user=None, proxy_pass=None, debug=0,
                  https_connection_factory=None, region=None, path='/'):
         if not region:
             region = RDSRegionInfo(self, self.DefaultRegionName,
                                    self.DefaultRegionEndpoint)
         self.region = region
-        AWSQueryConnection.__init__(self, aws_access_key_id, aws_secret_access_key,
-                                    is_secure, port, proxy, proxy_port, proxy_user,
-                                    proxy_pass, self.region.endpoint, debug,
+        AWSQueryConnection.__init__(self, aws_access_key_id,
+                                    aws_secret_access_key,
+                                    is_secure, port, proxy, proxy_port,
+                                    proxy_user, proxy_pass,
+                                    self.region.endpoint, debug,
                                     https_connection_factory, path)
 
     def _required_auth_capability(self):
         return ['rds']
 
     # DB Instance methods
 
     def get_all_dbinstances(self, instance_id=None, max_records=None,
                             marker=None):
         """
         Retrieve all the DBInstances in your account.
 
         :type instance_id: str
-        :param instance_id: DB Instance identifier.  If supplied, only information
-                            this instance will be returned.  Otherwise, info
-                            about all DB Instances will be returned.
+        :param instance_id: DB Instance identifier.  If supplied, only
+                            information this instance will be returned.
+                            Otherwise, info about all DB Instances will
+                            be returned.
 
         :type max_records: int
         :param max_records: The maximum number of records to be returned.
                             If more results are available, a MoreToken will
                             be returned in the response that can be used to
                             retrieve additional records.  Default is 100.
 
         :type marker: str
         :param marker: The marker provided by a previous request.
 
         :rtype: list
         :return: A list of :class:`boto.rds.dbinstance.DBInstance`
         """
         params = {}
         if instance_id:
             params['DBInstanceIdentifier'] = instance_id
         if max_records:
             params['MaxRecords'] = max_records
         if marker:
             params['Marker'] = marker
-        return self.get_list('DescribeDBInstances', params, [('DBInstance', DBInstance)])
+        return self.get_list('DescribeDBInstances', params,
+                             [('DBInstance', DBInstance)])
 
     def create_dbinstance(self, id, allocated_storage, instance_class,
                           master_username, master_password, port=3306,
                           engine='MySQL5.1', db_name=None, param_group=None,
                           security_groups=None, availability_zone=None,
                           preferred_maintenance_window=None,
                           backup_retention_period=None,
                           preferred_backup_window=None,
                           multi_az=False,
                           engine_version=None,
                           auto_minor_version_upgrade=True):
         """
         Create a new DBInstance.
 
         :type id: str
         :param id: Unique identifier for the new instance.
                    Must contain 1-63 alphanumeric characters.
                    First character must be a letter.
                    May not end with a hyphen or contain two consecutive hyphens
 
         :type allocated_storage: int
         :param allocated_storage: Initially allocated storage size, in GBs.
                                   Valid values are [5-1024]
 
         :type instance_class: str
-        :param instance_class: The compute and memory capacity of the DBInstance.
-
-                               Valid values are:
+        :param instance_class: The compute and memory capacity of
+                               the DBInstance. Valid values are:
 
                                * db.m1.small
                                * db.m1.large
                                * db.m1.xlarge
                                * db.m2.xlarge
                                * db.m2.2xlarge
                                * db.m2.4xlarge
 
         :type engine: str
         :param engine: Name of database engine. Must be MySQL5.1 for now.
@@ skipping 78 matching lines @@
             for group in security_groups:
                 if isinstance(group, DBSecurityGroup):
                     l.append(group.name)
                 else:
                     l.append(group)
             self.build_list_params(params, l, 'DBSecurityGroups.member')
         if availability_zone:
             params['AvailabilityZone'] = availability_zone
         if preferred_maintenance_window:
             params['PreferredMaintenanceWindow'] = preferred_maintenance_window
-        if backup_retention_period:
+        if backup_retention_period is not None:
             params['BackupRetentionPeriod'] = backup_retention_period
         if preferred_backup_window:
             params['PreferredBackupWindow'] = preferred_backup_window
         if multi_az:
             params['MultiAZ'] = 'true'
         if engine_version:
             params['EngineVersion'] = engine_version
         if auto_minor_version_upgrade is False:
             params['AutoMinorVersionUpgrade'] = 'false'
 
@@ skipping 150 matching lines @@
                     l.append(group)
             self.build_list_params(params, l, 'DBSecurityGroups.member')
         if preferred_maintenance_window:
             params['PreferredMaintenanceWindow'] = preferred_maintenance_window
         if master_password:
             params['MasterUserPassword'] = master_password
         if allocated_storage:
             params['AllocatedStorage'] = allocated_storage
         if instance_class:
             params['DBInstanceClass'] = instance_class
-        if backup_retention_period:
+        if backup_retention_period is not None:
             params['BackupRetentionPeriod'] = backup_retention_period
         if preferred_backup_window:
             params['PreferredBackupWindow'] = preferred_backup_window
         if multi_az:
             params['MultiAZ'] = 'true'
         if apply_immediately:
             params['ApplyImmediately'] = 'true'
 
         return self.get_object('ModifyDBInstance', params, DBInstance)
 
     def delete_dbinstance(self, id, skip_final_snapshot=False,
                           final_snapshot_id=''):
         """
         Delete an existing DBInstance.
 
         :type id: str
         :param id: Unique identifier for the new instance.
 
         :type skip_final_snapshot: bool
         :param skip_final_snapshot: This parameter determines whether a final
                                     db snapshot is created before the instance
-                                    is deleted.  If True, no snapshot is created.
-                                    If False, a snapshot is created before
-                                    deleting the instance.
+                                    is deleted.  If True, no snapshot
+                                    is created.  If False, a snapshot
+                                    is created before deleting the instance.
 
         :type final_snapshot_id: str
         :param final_snapshot_id: If a final snapshot is requested, this
                                   is the identifier used for that snapshot.
 
         :rtype: :class:`boto.rds.dbinstance.DBInstance`
         :return: The deleted db instance.
         """
         params = {'DBInstanceIdentifier' : id}
         if skip_final_snapshot:
@@ skipping 117 matching lines @@
         :type parameters: list of :class:`boto.rds.parametergroup.Parameter`
         :param parameters: The new parameters
 
         :rtype: :class:`boto.rds.parametergroup.ParameterGroup`
         :return: The newly created ParameterGroup
         """
         params = {'DBParameterGroupName': name}
         for i in range(0, len(parameters)):
             parameter = parameters[i]
             parameter.merge(params, i+1)
-        return self.get_list('ModifyDBParameterGroup', params, ParameterGroup)
+        return self.get_list('ModifyDBParameterGroup', params,
+                             ParameterGroup, verb='POST')
 
-    def reset_parameter_group(self, name, reset_all_params=False, parameters=None):
+    def reset_parameter_group(self, name, reset_all_params=False,
+                              parameters=None):
         """
         Resets some or all of the parameters of a ParameterGroup to the
         default value
 
         :type key_name: string
         :param key_name: The name of the ParameterGroup to reset
 
         :type parameters: list of :class:`boto.rds.parametergroup.Parameter`
-        :param parameters: The parameters to reset.  If not supplied, all parameters
-                           will be reset.
+        :param parameters: The parameters to reset.  If not supplied,
+                           all parameters will be reset.
         """
         params = {'DBParameterGroupName':name}
         if reset_all_params:
             params['ResetAllParameters'] = 'true'
         else:
             params['ResetAllParameters'] = 'false'
             for i in range(0, len(parameters)):
                 parameter = parameters[i]
                 parameter.merge(params, i+1)
         return self.get_status('ResetDBParameterGroup', params)
@@ skipping 10 matching lines @@
 
     # DBSecurityGroup methods
 
     def get_all_dbsecurity_groups(self, groupname=None, max_records=None,
                                   marker=None):
         """
         Get all security groups associated with your account in a region.
 
         :type groupnames: list
         :param groupnames: A list of the names of security groups to retrieve.
-                           If not provided, all security groups will be returned.
+                           If not provided, all security groups will
+                           be returned.
 
         :type max_records: int
         :param max_records: The maximum number of records to be returned.
                             If more results are available, a MoreToken will
                             be returned in the response that can be used to
                             retrieve additional records.  Default is 100.
 
         :type marker: str
         :param marker: The marker provided by a previous request.
 
@@ skipping 21 matching lines @@
 
         :type description: string
         :param description: The description of the new security group
 
         :rtype: :class:`boto.rds.dbsecuritygroup.DBSecurityGroup`
         :return: The newly created DBSecurityGroup
         """
         params = {'DBSecurityGroupName':name}
         if description:
             params['DBSecurityGroupDescription'] = description
-        group = self.get_object('CreateDBSecurityGroup', params, DBSecurityGroup)
+        group = self.get_object('CreateDBSecurityGroup', params,
+                                DBSecurityGroup)
         group.name = name
         group.description = description
         return group
 
     def delete_dbsecurity_group(self, name):
         """
         Delete a DBSecurityGroup from your account.
 
         :type key_name: string
         :param key_name: The name of the DBSecurityGroup to delete
         """
         params = {'DBSecurityGroupName':name}
         return self.get_status('DeleteDBSecurityGroup', params)
 
     def authorize_dbsecurity_group(self, group_name, cidr_ip=None,
                                    ec2_security_group_name=None,
                                    ec2_security_group_owner_id=None):
         """
         Add a new rule to an existing security group.
         You need to pass in either src_security_group_name and
         src_security_group_owner_id OR a CIDR block but not both.
 
         :type group_name: string
         :param group_name: The name of the security group you are adding
                            the rule to.
 
         :type ec2_security_group_name: string
-        :param ec2_security_group_name: The name of the EC2 security group you are
-                                        granting access to.
+        :param ec2_security_group_name: The name of the EC2 security group
+                                        you are granting access to.
 
         :type ec2_security_group_owner_id: string
-        :param ec2_security_group_owner_id: The ID of the owner of the EC2 security
-                                            group you are granting access to.
+        :param ec2_security_group_owner_id: The ID of the owner of the EC2
+                                            security group you are granting
+                                            access to.
 
         :type cidr_ip: string
         :param cidr_ip: The CIDR block you are providing access to.
                         See http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing
 
         :rtype: bool
         :return: True if successful.
         """
         params = {'DBSecurityGroupName':group_name}
         if ec2_security_group_name:
             params['EC2SecurityGroupName'] = ec2_security_group_name
         if ec2_security_group_owner_id:
             params['EC2SecurityGroupOwnerId'] = ec2_security_group_owner_id
         if cidr_ip:
             params['CIDRIP'] = urllib.quote(cidr_ip)
-        return self.get_object('AuthorizeDBSecurityGroupIngress', params, DBSecurityGroup)
+        return self.get_object('AuthorizeDBSecurityGroupIngress', params,
+                               DBSecurityGroup)
 
     def revoke_dbsecurity_group(self, group_name, ec2_security_group_name=None,
                                 ec2_security_group_owner_id=None, cidr_ip=None):
         """
         Remove an existing rule from an existing security group.
         You need to pass in either ec2_security_group_name and
         ec2_security_group_owner_id OR a CIDR block.
 
         :type group_name: string
         :param group_name: The name of the security group you are removing
                            the rule from.
 
         :type ec2_security_group_name: string
-        :param ec2_security_group_name: The name of the EC2 security group from which
-                                        you are removing access.
+        :param ec2_security_group_name: The name of the EC2 security group
+                                        from which you are removing access.
 
         :type ec2_security_group_owner_id: string
-        :param ec2_security_group_owner_id: The ID of the owner of the EC2 security
-                                            from which you are removing access.
+        :param ec2_security_group_owner_id: The ID of the owner of the EC2
+                                            security from which you are
+                                            removing access.
 
         :type cidr_ip: string
         :param cidr_ip: The CIDR block from which you are removing access.
                         See http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing
 
         :rtype: bool
         :return: True if successful.
         """
         params = {'DBSecurityGroupName':group_name}
         if ec2_security_group_name:
             params['EC2SecurityGroupName'] = ec2_security_group_name
         if ec2_security_group_owner_id:
             params['EC2SecurityGroupOwnerId'] = ec2_security_group_owner_id
         if cidr_ip:
             params['CIDRIP'] = cidr_ip
-        return self.get_object('RevokeDBSecurityGroupIngress', params, DBSecurityGroup)
+        return self.get_object('RevokeDBSecurityGroupIngress', params,
+                               DBSecurityGroup)
 
     # For backwards compatibility.  This method was improperly named
     # in previous versions.  I have renamed it to match the others.
     revoke_security_group = revoke_dbsecurity_group
 
     # DBSnapshot methods
 
     def get_all_dbsnapshots(self, snapshot_id=None, instance_id=None,
                             max_records=None, marker=None):
         """
@@ skipping 69 matching lines @@
         Create a new DBInstance from a DB snapshot.
 
         :type identifier: string
         :param identifier: The identifier for the DBSnapshot
 
         :type instance_id: string
         :param instance_id: The source identifier for the RDS instance from
                               which the snapshot is created.
 
         :type instance_class: str
-        :param instance_class: The compute and memory capacity of the DBInstance.
-                               Valid values are:
+        :param instance_class: The compute and memory capacity of the
+                               DBInstance.  Valid values are:
                                db.m1.small | db.m1.large | db.m1.xlarge |
                                db.m2.2xlarge | db.m2.4xlarge
 
         :type port: int
         :param port: Port number on which database accepts connections.
                      Valid values [1115-65535].  Defaults to 3306.
 
         :type availability_zone: str
         :param availability_zone: Name of the availability zone to place
                                   DBInstance into.
@@ skipping 30 matching lines @@
 
         :type use_latest: bool
         :param use_latest: If True, the latest snapshot availabile will
                            be used.
 
         :type restore_time: datetime
         :param restore_time: The date and time to restore from.  Only
                              used if use_latest is False.
 
         :type instance_class: str
-        :param instance_class: The compute and memory capacity of the DBInstance.
-                               Valid values are:
+        :param instance_class: The compute and memory capacity of the
+                               DBInstance.  Valid values are:
                                db.m1.small | db.m1.large | db.m1.xlarge |
                                db.m2.2xlarge | db.m2.4xlarge
 
         :type port: int
         :param port: Port number on which database accepts connections.
                      Valid values [1115-65535].  Defaults to 3306.
 
         :type availability_zone: str
         :param availability_zone: Name of the availability zone to place
                                   DBInstance into.
@@ skipping 69 matching lines @@
             params['StartTime'] = start_time.isoformat()
         if end_time:
             params['EndTime'] = end_time.isoformat()
         if max_records:
             params['MaxRecords'] = max_records
         if marker:
             params['Marker'] = marker
         return self.get_list('DescribeEvents', params, [('Event', Event)])