Merging in latest boto.

boto/__init__.py

 # Copyright (c) 2006-2011 Mitch Garnaat http://garnaat.org/
 # Copyright (c) 2010-2011, Eucalyptus Systems, Inc.
+# Copyright (c) 2011, Nexenta Systems Inc.
 # All rights reserved.
 #
 # 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:
 #
 # The above copyright notice and this permission notice shall be included
 # in all copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
 # ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
 # SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 # IN THE SOFTWARE.
 #
-import boto
 from boto.pyami.config import Config, BotoConfigLocations
 from boto.storage_uri import BucketStorageUri, FileStorageUri
 import boto.plugin
 import os, re, sys
 import logging
 import logging.config
 from boto.exception import InvalidUriError
 
-__version__ = '2.0b4'
+__version__ = '2.1.1'
 Version = __version__ # for backware compatibility
 
 UserAgent = 'Boto/%s (%s)' % (__version__, sys.platform)
 config = Config()
 
 def init_logging():
     for file in BotoConfigLocations:
         try:
             logging.config.fileConfig(os.path.expanduser(file))
         except:
@@ skipping 58 matching lines @@
 
     :rtype: :class:`boto.s3.connection.S3Connection`
     :return: A connection to Amazon's S3
     """
     from boto.s3.connection import S3Connection
     return S3Connection(aws_access_key_id, aws_secret_access_key, **kwargs)
 
 def connect_gs(gs_access_key_id=None, gs_secret_access_key=None, **kwargs):
     """
     @type gs_access_key_id: string
-    @param gs_access_key_id: Your Google Storage Access Key ID
+    @param gs_access_key_id: Your Google Cloud Storage Access Key ID
 
     @type gs_secret_access_key: string
-    @param gs_secret_access_key: Your Google Storage Secret Access Key
+    @param gs_secret_access_key: Your Google Cloud Storage Secret Access Key
 
     @rtype: L{GSConnection<boto.gs.connection.GSConnection>}
     @return: A connection to Google's Storage service
     """
     from boto.gs.connection import GSConnection
     return GSConnection(gs_access_key_id, gs_secret_access_key, **kwargs)
 
 def connect_ec2(aws_access_key_id=None, aws_secret_access_key=None, **kwargs):
     """
     :type aws_access_key_id: string
@@ skipping 131 matching lines @@
     :rtype: :class:`boto.rds.RDSConnection`
     :return: A connection to RDS
     """
     from boto.rds import RDSConnection
     return RDSConnection(aws_access_key_id, aws_secret_access_key, **kwargs)
 
 def connect_emr(aws_access_key_id=None, aws_secret_access_key=None, **kwargs):
     """
     :type aws_access_key_id: string
     :param aws_access_key_id: Your AWS Access Key ID
-   
+
     :type aws_secret_access_key: string
     :param aws_secret_access_key: Your AWS Secret Access Key
-   
+
     :rtype: :class:`boto.emr.EmrConnection`
     :return: A connection to Elastic mapreduce
     """
     from boto.emr import EmrConnection
     return EmrConnection(aws_access_key_id, aws_secret_access_key, **kwargs)
 
 def connect_sns(aws_access_key_id=None, aws_secret_access_key=None, **kwargs):
     """
     :type aws_access_key_id: string
     :param aws_access_key_id: Your AWS Access Key ID
@@ skipping 29 matching lines @@
 
     :type aws_secret_access_key: string
     :param aws_secret_access_key: Your AWS Secret Access Key
 
     :rtype: :class:`boto.dns.Route53Connection`
     :return: A connection to Amazon's Route53 DNS Service
     """
     from boto.route53 import Route53Connection
     return Route53Connection(aws_access_key_id, aws_secret_access_key, **kwargs)
 
-def connect_euca(host, aws_access_key_id=None, aws_secret_access_key=None,
+def connect_euca(host=None, aws_access_key_id=None, aws_secret_access_key=None,
                  port=8773, path='/services/Eucalyptus', is_secure=False,
                  **kwargs):
     """
     Connect to a Eucalyptus service.
 
     :type host: string
     :param host: the host name or ip address of the Eucalyptus server
-    
+
     :type aws_access_key_id: string
     :param aws_access_key_id: Your AWS Access Key ID
 
     :type aws_secret_access_key: string
     :param aws_secret_access_key: Your AWS Secret Access Key
 
     :rtype: :class:`boto.ec2.connection.EC2Connection`
     :return: A connection to Eucalyptus server
     """
     from boto.ec2 import EC2Connection
     from boto.ec2.regioninfo import RegionInfo
 
+    # Check for values in boto config, if not supplied as args
+    if not aws_access_key_id:
+        aws_access_key_id = config.get('Credentials',
+                                       'euca_access_key_id',
+                                       None)
+    if not aws_secret_access_key:
+        aws_secret_access_key = config.get('Credentials',
+                                           'euca_secret_access_key',
+                                           None)
+    if not host:
+        host = config.get('Boto', 'eucalyptus_host', None)
+
     reg = RegionInfo(name='eucalyptus', endpoint=host)
     return EC2Connection(aws_access_key_id, aws_secret_access_key,
                          region=reg, port=port, path=path,
                          is_secure=is_secure, **kwargs)
 
-def connect_walrus(host, aws_access_key_id=None, aws_secret_access_key=None,
+def connect_walrus(host=None, aws_access_key_id=None, aws_secret_access_key=None,
                    port=8773, path='/services/Walrus', is_secure=False,
                    **kwargs):
     """
     Connect to a Walrus service.
 
     :type host: string
     :param host: the host name or ip address of the Walrus server
-    
+
     :type aws_access_key_id: string
     :param aws_access_key_id: Your AWS Access Key ID
 
     :type aws_secret_access_key: string
     :param aws_secret_access_key: Your AWS Secret Access Key
 
     :rtype: :class:`boto.s3.connection.S3Connection`
     :return: A connection to Walrus
     """
     from boto.s3.connection import S3Connection
     from boto.s3.connection import OrdinaryCallingFormat
 
+    # Check for values in boto config, if not supplied as args
+    if not aws_access_key_id:
+        aws_access_key_id = config.get('Credentials',
+                                       'euca_access_key_id',
+                                       None)
+    if not aws_secret_access_key:
+        aws_secret_access_key = config.get('Credentials',
+                                           'euca_secret_access_key',
+                                           None)
+    if not host:
+        host = config.get('Boto', 'walrus_host', None)
+        
     return S3Connection(aws_access_key_id, aws_secret_access_key,
                         host=host, port=port, path=path,
                         calling_format=OrdinaryCallingFormat(),
                         is_secure=is_secure, **kwargs)
 
 def connect_ses(aws_access_key_id=None, aws_secret_access_key=None, **kwargs):
     """
     :type aws_access_key_id: string
     :param aws_access_key_id: Your AWS Access Key ID
 
     :type aws_secret_access_key: string
     :param aws_secret_access_key: Your AWS Secret Access Key
 
     :rtype: :class:`boto.ses.SESConnection`
     :return: A connection to Amazon's SES
     """
     from boto.ses import SESConnection
     return SESConnection(aws_access_key_id, aws_secret_access_key, **kwargs)
 
+def connect_sts(aws_access_key_id=None, aws_secret_access_key=None, **kwargs):
+    """
+    :type aws_access_key_id: string
+    :param aws_access_key_id: Your AWS Access Key ID
+
+    :type aws_secret_access_key: string
+    :param aws_secret_access_key: Your AWS Secret Access Key
+
+    :rtype: :class:`boto.sts.STSConnection`
+    :return: A connection to Amazon's STS
+    """
+    from boto.sts import STSConnection
+    return STSConnection(aws_access_key_id, aws_secret_access_key, **kwargs)
+
 def connect_ia(ia_access_key_id=None, ia_secret_access_key=None,
                is_secure=False, **kwargs):
     """
     Connect to the Internet Archive via their S3-like API.
 
     :type ia_access_key_id: string
     :param ia_access_key_id: Your IA Access Key ID.  This will also look in your
                              boto config file for an entry in the Credentials
                              section called "ia_access_key_id"
 
     :type ia_secret_access_key: string
-    :param ia_secret_access_key: Your IA Secret Access Key.  This will also look in your
-                                 boto config file for an entry in the Credentials
-                                 section called "ia_secret_access_key"
+    :param ia_secret_access_key: Your IA Secret Access Key.  This will also
+                                 look in your boto config file for an entry
+                                 in the Credentials section called
+                                 "ia_secret_access_key"
 
     :rtype: :class:`boto.s3.connection.S3Connection`
     :return: A connection to the Internet Archive
     """
     from boto.s3.connection import S3Connection
     from boto.s3.connection import OrdinaryCallingFormat
 
     access_key = config.get('Credentials', 'ia_access_key_id',
                             ia_access_key_id)
     secret_key = config.get('Credentials', 'ia_secret_access_key',
@@ skipping 89 matching lines @@
         path = uri_str
     else:
         scheme = uri_str[0:end_scheme_idx].lower()
         path = uri_str[end_scheme_idx + 3:]
 
     if scheme not in ['file', 's3', 'gs']:
         raise InvalidUriError('Unrecognized scheme "%s"' % scheme)
     if scheme == 'file':
         # For file URIs we have no bucket name, and use the complete path
         # (minus 'file://') as the object name.
-        return FileStorageUri(path, debug)
+        is_stream = False
+        if path == '-':
+            is_stream = True
+        return FileStorageUri(path, debug, is_stream)
     else:
         path_parts = path.split('/', 1)
         bucket_name = path_parts[0]
         if (validate and bucket_name and
             # Disallow buckets violating charset or not [3..255] chars total.
             (not re.match('^[a-z0-9][a-z0-9\._-]{1,253}[a-z0-9]$', bucket_name)
             # Disallow buckets with individual DNS labels longer than 63.
              or re.search('[-_a-z0-9]{64}', bucket_name))):
             raise InvalidUriError('Invalid bucket name in URI "%s"' % uri_str)
         # If enabled, ensure the bucket name is valid, to avoid possibly
@@ skipping 13 matching lines @@
     :param key: URI naming bucket + optional object.
     """
     if not isinstance(key, boto.s3.key.Key):
         raise InvalidUriError('Requested key (%s) is not a subclass of '
                               'boto.s3.key.Key' % str(type(key)))
     prov_name = key.bucket.connection.provider.get_provider_name()
     uri_str = '%s://%s/%s' % (prov_name, key.bucket.name, key.name)
     return storage_uri(uri_str)
 
 boto.plugin.load_plugins(config)