Using a fallback connection in Bucket

gcloud/storage/__init__.py

@@ -51,6 +51,7 @@
 from gcloud.storage.api import get_all_buckets
 from gcloud.storage.api import get_bucket
 from gcloud.storage.api import lookup_bucket
+from gcloud.storage.batch import Batch
 from gcloud.storage.blob import Blob
 from gcloud.storage.bucket import Bucket
 from gcloud.storage.connection import Connection
@@ -82,7 +83,7 @@ def set_default_bucket(bucket=None):
  bucket_name = os.getenv(_BUCKET_ENV_VAR_NAME)
  connection = get_default_connection()
 
- if bucket_name is not None and connection is not None:
+ if bucket_name is not None:
  bucket = Bucket(bucket_name, connection=connection)
 
  if bucket is not None:

gcloud/storage/api.py

@@ -46,14 +46,11 @@ def lookup_bucket(bucket_name, connection=None):
  :type connection: :class:`gcloud.storage.connection.Connection` or
  ``NoneType``
  :param connection: Optional. The connection to use when sending requests.
- If not provided, falls back to default.
+ If not provided, Bucket() will fall back to default.
 
  :rtype: :class:`gcloud.storage.bucket.Bucket`
  :returns: The bucket matching the name provided or None if not found.
  """
- if connection is None:
- connection = get_default_connection()
-
  try:
  return get_bucket(bucket_name, connection=connection)
  except NotFound:
@@ -79,13 +76,12 @@ def get_all_buckets(project=None, connection=None):
  :type connection: :class:`gcloud.storage.connection.Connection` or
  ``NoneType``
  :param connection: Optional. The connection to use when sending requests.
- If not provided, falls back to default.
+ If not provided, _BucketIterator() will fall back to
+ default.
 
  :rtype: iterable of :class:`gcloud.storage.bucket.Bucket` objects.
  :returns: All buckets belonging to this project.
  """
- if connection is None:
- connection = get_default_connection()
  if project is None:
  project = get_default_project()
  extra_params = {'project': project}
@@ -116,15 +112,11 @@ def get_bucket(bucket_name, connection=None):
  :type connection: :class:`gcloud.storage.connection.Connection` or
  ``NoneType``
  :param connection: Optional. The connection to use when sending requests.
- If not provided, falls back to default.
+ If not provided, Bucket() will fall back to default.
 
  :rtype: :class:`gcloud.storage.bucket.Bucket`
  :returns: The bucket matching the name provided.
- :raises: :class:`gcloud.exceptions.NotFound`
  """
- if connection is None:
- connection = get_default_connection()
-
  bucket = Bucket(bucket_name, connection=connection)
  bucket._reload_properties()
  return bucket
@@ -143,6 +135,9 @@ def create_bucket(bucket_name, project=None, connection=None):
 
  This implements "storage.buckets.insert".
 
+ If the bucket already exists, will raise
+ :class:`gcloud.exceptions.Conflict`.
+
  :type project: string
  :param project: Optional. The project to use when creating bucket.
  If not provided, falls back to default.
@@ -153,25 +148,13 @@ def create_bucket(bucket_name, project=None, connection=None):
  :type connection: :class:`gcloud.storage.connection.Connection` or
  ``NoneType``
  :param connection: Optional. The connection to use when sending requests.
- If not provided, falls back to default.
+ If not provided, Bucket() will fall back to default.
 
  :rtype: :class:`gcloud.storage.bucket.Bucket`
  :returns: The newly created bucket.
- :raises: :class:`gcloud.exceptions.Conflict` if
- there is a confict (bucket already exists, invalid name, etc.)
  """
- if connection is None:
- connection = get_default_connection()
- if project is None:
- project = get_default_project()
-
- query_params = {'project': project}
- response = connection.api_request(method='POST', path='/b',
- query_params=query_params,
- data={'name': bucket_name})
- name = response.get('name')
- bucket = Bucket(name, connection=connection)
- bucket._properties = response
+ bucket = Bucket(bucket_name, connection=connection)
+ bucket.create(project)
  return bucket
 
 
@@ -187,6 +170,11 @@ class _BucketIterator(Iterator):
  """
 
  def __init__(self, connection, extra_params=None):
+ # If an implicit connection was intended, we pass along `None` to the
+ # Bucket() constructor as well.
+ self._ctor_connection = connection
+ if connection is None:
+ connection = get_default_connection()
  super(_BucketIterator, self).__init__(connection=connection, path='/b',
  extra_params=extra_params)
 
@@ -198,6 +186,6 @@ def get_items_from_response(self, response):
  """
  for item in response.get('items', []):
  name = item.get('name')
- bucket = Bucket(name, connection=self.connection)
+ bucket = Bucket(name, connection=self._ctor_connection)
  bucket._properties = item
  yield bucket

gcloud/storage/batch.py

@@ -155,6 +155,11 @@ def finish(self):
  self._responses = list(_unpack_batch_response(response, content))
  return self._responses
 
+ @staticmethod
+ def current():
+ """Return the topmost batch, or None."""
+ return _BATCHES.top
+
  def __enter__(self):
  _BATCHES.push(self)
  return self

gcloud/storage/bucket.py

@@ -36,12 +36,15 @@
 import os
 import six
 
+from gcloud._helpers import get_default_project
 from gcloud.exceptions import NotFound
 from gcloud.storage._helpers import _PropertyMixin
 from gcloud.storage._helpers import _scalar_property
+from gcloud.storage import _implicit_environ
 from gcloud.storage.acl import BucketACL
 from gcloud.storage.acl import DefaultObjectACL
 from gcloud.storage.iterator import Iterator
+from gcloud.storage.batch import Batch
 from gcloud.storage.blob import Blob
 
 
@@ -125,6 +128,34 @@ def exists(self):
  except NotFound:
  return False
 
+ def create(self, project=None):
+ """Creates current bucket.
+
+ If the bucket already exists, will raise
+ :class:`gcloud.exceptions.Conflict`.
+
+ This implements "storage.buckets.insert".
+
+ :type project: string
+ :param project: Optional. The project to use when creating bucket.
+ If not provided, falls back to default.
+
+ :rtype: :class:`gcloud.storage.bucket.Bucket`
+ :returns: The newly created bucket.
+ :raises: :class:`EnvironmentError` if the project is not given and
+ can't be inferred.
+ """
+ if project is None:
+ project = get_default_project()
+ if project is None:
+ raise EnvironmentError('Project could not be inferred '
+ 'from environment.')
+
+ query_params = {'project': project}
+ self._properties = self.connection.api_request(
+ method='POST', path='/b', query_params=query_params,
+ data={'name': self.name})
+
  @property
  def acl(self):
  """Create our ACL on demand."""
@@ -146,7 +177,7 @@ def connection(self):
  :rtype: :class:`gcloud.storage.connection.Connection`
  :returns: The connection to use.
  """
- return self._connection
+ return _require_connection(self._connection)
 
  @staticmethod
  def path_helper(bucket_name):
@@ -746,3 +777,27 @@ def make_public(self, recursive=False, future=False):
  for blob in self:
  blob.acl.all().grant_read()
  blob.save_acl()
+
+
+def _require_connection(connection=None):
+ """Infer a connection from the environment, if not passed explicitly.
+
+ :type connection: :class:`gcloud.storage.connection.Connection`
+ :param connection: Optional.
+
+ :rtype: :class:`gcloud.storage.connection.Connection`
+ :returns: A connection based on the current environment.
+ :raises: :class:`EnvironmentError` if ``connection`` is ``None``, and
+ cannot be inferred from the environment.
+ """
+ # NOTE: We use current Batch directly since it inherits from Connection.
+ if connection is None:
+ connection = Batch.current()
+
+ if connection is None:
+ connection = _implicit_environ.get_default_connection()
+
+ if connection is None:
+ raise EnvironmentError('Connection could not be inferred.')
+
+ return connection

gcloud/storage/test_api.py

@@ -62,11 +62,15 @@ def _lookup_bucket_hit_helper(self, use_default=False):
  if use_default:
  with _monkey_defaults(connection=conn):
  bucket = self._callFUT(BLOB_NAME)
+ # In the default case, the bucket never has a connection
+ # bound to it.
+ self.assertTrue(bucket._connection is None)
  else:
  bucket = self._callFUT(BLOB_NAME, connection=conn)
+ # In the explicit case, the bucket has a connection bound to it.
+ self.assertTrue(bucket._connection is conn)
 
  self.assertTrue(isinstance(bucket, Bucket))
- self.assertTrue(bucket.connection is conn)
  self.assertEqual(bucket.name, BLOB_NAME)
  self.assertEqual(http._called_with['method'], 'GET')
  self.assertEqual(http._called_with['uri'], URI)
@@ -187,11 +191,15 @@ def _get_bucket_hit_helper(self, use_default=False):
  if use_default:
  with _monkey_defaults(connection=conn):
  bucket = self._callFUT(BLOB_NAME)
+ # In the default case, the bucket never has a connection
+ # bound to it.
+ self.assertTrue(bucket._connection is None)
  else:
  bucket = self._callFUT(BLOB_NAME, connection=conn)
+ # In the explicit case, the bucket has a connection bound to it.
+ self.assertTrue(bucket._connection is conn)
 
  self.assertTrue(isinstance(bucket, Bucket))
- self.assertTrue(bucket.connection is conn)
  self.assertEqual(bucket.name, BLOB_NAME)
  self.assertEqual(http._called_with['method'], 'GET')
  self.assertEqual(http._called_with['uri'], URI)
@@ -232,11 +240,15 @@ def _create_bucket_success_helper(self, project, use_default=False):
  with _base_monkey_defaults(project=project):
  with _monkey_defaults(connection=conn):
  bucket = self._callFUT(BLOB_NAME)
+ # In the default case, the bucket never has a connection
+ # bound to it.
+ self.assertTrue(bucket._connection is None)
  else:
  bucket = self._callFUT(BLOB_NAME, project=project, connection=conn)
+ # In the explicit case, the bucket has a connection bound to it.
+ self.assertTrue(bucket._connection is conn)
 
  self.assertTrue(isinstance(bucket, Bucket))
- self.assertTrue(bucket.connection is conn)
  self.assertEqual(bucket.name, BLOB_NAME)
  self.assertEqual(http._called_with['method'], 'POST')
  self.assertEqual(http._called_with['uri'], URI)
@@ -270,19 +282,26 @@ def test_get_items_from_response_empty(self):
  iterator = self._makeOne(connection)
  self.assertEqual(list(iterator.get_items_from_response({})), [])
 
- def test_get_items_from_response_non_empty(self):
+ def _get_items_helper(self, connection):
  from gcloud.storage.bucket import Bucket
  BLOB_NAME = 'blob-name'
  response = {'items': [{'name': BLOB_NAME}]}
- connection = object()
  iterator = self._makeOne(connection)
  buckets = list(iterator.get_items_from_response(response))
  self.assertEqual(len(buckets), 1)
  bucket = buckets[0]
  self.assertTrue(isinstance(bucket, Bucket))
- self.assertTrue(bucket.connection is connection)
+ self.assertTrue(bucket._connection is connection)
  self.assertEqual(bucket.name, BLOB_NAME)
 
+ def test_get_items_from_response_non_empty(self):
+ connection = object()
+ self._get_items_helper(connection)
+
+ def test_get_items_from_response_implicit_connection(self):
+ connection = None
+ self._get_items_helper(connection)
+
 
 class Http(object):