PYTHON-985 - MongoClient properties now block until connected

Author: aherlihy

doc/changelog.rst

@@ -1,6 +1,17 @@
 Changelog
 =========
 
+Changes in Version 3.2
+----------------------
+
+Version 3.2 implements the new server features introduced in MongoDB 3.2.
+
+Highlights include:
+
+- Certain MongoClient properties block until a connection is established or
+ raise ServerSelectionTimeoutError if no server is available. See
+ :class:`~pymongo.MongoClient` for details.
+
 Changes in Version 3.1.1
 ------------------------
 

pymongo/mongo_client.py

@@ -480,22 +480,21 @@ def _purge_index(self, database_name,
  if index_name in self.__index_cache[database_name][collection_name]:
  del self.__index_cache[database_name][collection_name][index_name]
 
- def _server_property(self, attr_name, default=None):
+ def _server_property(self, attr_name):
  """An attribute of the current server's description.
 
- Returns "default" while there is no current server, primary, or mongos.
+ If the client is not connected, this will block until a connection is
+ established or raise ServerSelectionTimeoutError if no server is
+ available.
 
  Not threadsafe if used multiple times in a single method, since
  the server may change. In such cases, store a local reference to a
  ServerDescription first, then use its properties.
  """
- try:
- server = self._topology.select_server(
- writable_server_selector, server_selection_timeout=0)
+ server = self._topology.select_server(
+ writable_server_selector)
 
- return getattr(server.description, attr_name)
- except ConnectionFailure:
- return default
+ return getattr(server.description, attr_name)
 
  @property
  def event_listeners(self):
@@ -513,15 +512,21 @@ def address(self):
  the client is load-balancing among mongoses, since there is no single
  address. Use :attr:`nodes` instead.
 
+ If the client is not connected, this will block until a connection is
+ established or raise ServerSelectionTimeoutError if no server is
+ available.
+
  .. versionadded:: 3.0
  """
- try:
- return self._topology.get_direct_or_primary()
- except InvalidOperation:
- # Only one case where Topology throws InvalidOperation.
+ topology_type = self._topology._description.topology_type
+ if topology_type == TOPOLOGY_TYPE.Sharded:
  raise InvalidOperation(
  'Cannot use "address" property when load balancing among'
  ' mongoses, use "nodes" instead.')
+ if topology_type not in (TOPOLOGY_TYPE.ReplicaSetWithPrimary,
+ TOPOLOGY_TYPE.Single):
+ return None
+ return self._server_property('address')
 
  @property
  def primary(self):
@@ -563,16 +568,20 @@ def arbiters(self):
 
  @property
  def is_primary(self):
- """If this client if connected to a server that can accept writes.
+ """If this client is connected to a server that can accept writes.
 
  True if the current server is a standalone, mongos, or the primary of
- a replica set.
+ a replica set. If the client is not connected, this will block until a
+ connection is established or raise ServerSelectionTimeoutError if no
+ server is available.
  """
- return self._server_property('is_writable', False)
+ return self._server_property('is_writable')
 
  @property
  def is_mongos(self):
- """If this client is connected to mongos.
+ """If this client is connected to mongos. If the client is not
+ connected, this will block until a connection is established or raise
+ ServerSelectionTimeoutError if no server is available..
  """
  return self._server_property('server_type') == SERVER_TYPE.Mongos
 
@@ -605,28 +614,34 @@ def nodes(self):
  def max_bson_size(self):
  """The largest BSON object the connected server accepts in bytes.
 
- Defaults to 16MB if not connected to a server.
+ If the client is not connected, this will block until a connection is
+ established or raise ServerSelectionTimeoutError if no server is
+ available.
  """
- return self._server_property('max_bson_size', common.MAX_BSON_SIZE)
+ return self._server_property('max_bson_size')
 
  @property
  def max_message_size(self):
  """The largest message the connected server accepts in bytes.
 
- Defaults to 32MB if not connected to a server.
+ If the client is not connected, this will block until a connection is
+ established or raise ServerSelectionTimeoutError if no server is
+ available.
  """
- return self._server_property(
- 'max_message_size', common.MAX_MESSAGE_SIZE)
+ return self._server_property('max_message_size')
 
  @property
  def max_write_batch_size(self):
  """The maxWriteBatchSize reported by the server.
 
+ If the client is not connected, this will block until a connection is
+ established or raise ServerSelectionTimeoutError if no server is
+ available.
+
  Returns a default value when connected to server versions prior to
  MongoDB 2.6.
  """
- return self._server_property(
- 'max_write_batch_size', common.MAX_WRITE_BATCH_SIZE)
+ return self._server_property('max_write_batch_size')
 
  @property
  def local_threshold_ms(self):

pymongo/topology.py

@@ -218,22 +218,6 @@ def _get_replica_set_members(self, selector):
  descriptions = selector(self._description.known_servers)
  return set([d.address for d in descriptions])
 
- def get_direct_or_primary(self):
- """Return the address of a connected primary or standalone, or None.
-
- Raise InvalidOperation for Sharded topologies.
- """
- # Implemented here in Topology instead of MongoClient, so it can lock.
- with self._lock:
- topology_type = self._description.topology_type
- if topology_type == TOPOLOGY_TYPE.Sharded:
- raise InvalidOperation()
- if topology_type not in (TOPOLOGY_TYPE.ReplicaSetWithPrimary,
- TOPOLOGY_TYPE.Single):
- return None
- descriptions = writable_server_selector(
- self._description.known_servers)
- return descriptions[0].address if descriptions else None
 
  def get_secondaries(self):
  """Return set of secondary addresses."""

test/test_client.py

@@ -206,19 +206,23 @@ def test_constants(self):
 
  def test_init_disconnected(self):
  c = rs_or_single_client(connect=False)
-
+ # is_primary causes client to block until connected
  self.assertIsInstance(c.is_primary, bool)
+
+ c = rs_or_single_client(connect=False)
  self.assertIsInstance(c.is_mongos, bool)
+ c = rs_or_single_client(connect=False)
  self.assertIsInstance(c.max_pool_size, int)
  self.assertIsInstance(c.nodes, frozenset)
 
+ c = rs_or_single_client(connect=False)
  self.assertEqual(c.codec_options, CodecOptions())
  self.assertIsInstance(c.max_bson_size, int)
- self.assertIsInstance(c.max_write_batch_size, int)
+ c = rs_or_single_client(connect=False)
  self.assertFalse(c.primary)
  self.assertFalse(c.secondaries)
-
- c.pymongo_test.command('ismaster') # Auto-connect.
+ c = rs_or_single_client(connect=False)
+ self.assertIsInstance(c.max_write_batch_size, int)
 
  if client_context.is_rs:
  # The primary's host and port are from the replica set config.
@@ -1058,14 +1062,9 @@ def test(collection):
  lazy_client_trial(reset, find_one, test, self._get_client)
 
  def test_max_bson_size(self):
- # Client should have sane defaults before connecting, and should update
- # its configuration once connected.
  c = self._get_client()
- self.assertEqual(16 * (1024 ** 2), c.max_bson_size)
- self.assertEqual(2 * c.max_bson_size, c.max_message_size)
 
- # Make the client connect, so that it sets its max_bson_size and
- # max_message_size attributes.
+ # max_bson_size will cause the client to connect.
  ismaster = c.db.command('ismaster')
  self.assertEqual(ismaster['maxBsonObjectSize'], c.max_bson_size)
  if 'maxMessageSizeBytes' in ismaster:

test/test_replica_set_client.py

@@ -368,10 +368,6 @@ def test_max_write_batch_size(self):
  c.set_max_write_batch_size('a:1', 1)
  c.set_max_write_batch_size('b:2', 2)
 
- # Starts with default max batch size.
- self.assertEqual(1000, c.max_write_batch_size)
- c.db.command('ismaster') # Connect.
-
  # Uses primary's max batch size.
  self.assertEqual(c.max_write_batch_size, 1)