desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Represent MongoClient\'s configuration.
Take a list of (host, port) pairs and optional replica set name.'
| def __init__(self, seeds=None, replica_set_name=None, pool_class=None, pool_options=None, monitor_class=None, condition_class=None, local_threshold_ms=LOCAL_THRESHOLD_MS, server_selection_timeout=SERVER_SELECTION_TIMEOUT, heartbeat_frequency=common.HEARTBEAT_FREQUENCY):
| if (heartbeat_frequency < common.MIN_HEARTBEAT_INTERVAL):
raise ConfigurationError((('heartbeatFrequencyMS cannot be less than %d' % common.MIN_HEARTBEAT_INTERVAL) * 1000))
self._seeds = (seeds or [('localhost', 27017)])
self._replica_set_name = replica_set_name
self._pool_class =... |
'List of server addresses.'
| @property
def seeds(self):
| return self._seeds
|
'Connect directly to a single server, or use a set of servers?
True if there is one seed and no replica_set_name.'
| @property
def direct(self):
| return self._direct
|
'Initial dict of (address, ServerDescription) for all seeds.'
| def get_server_descriptions(self):
| return dict([(address, ServerDescription(address)) for address in self.seeds])
|
'The error code returned by the server, if any.'
| @property
def code(self):
| return self.__code
|
'The complete error document returned by the server.
Depending on the error that occurred, the error document
may include useful information beyond just the error
message. When connected to a mongos the error document
may contain one or more subdocuments if errors occurred
on multiple shards.'
| @property
def details(self):
| return self.__details
|
'Client for a MongoDB instance, a replica set, or a set of mongoses.
The client object is thread-safe and has connection-pooling built in.
If an operation fails because of a network error,
:class:`~pymongo.errors.ConnectionFailure` is raised and the client
reconnects in the background. Application code should handle th... | def __init__(self, host=None, port=None, document_class=dict, tz_aware=None, connect=None, **kwargs):
| if (host is None):
host = self.HOST
if isinstance(host, string_type):
host = [host]
if (port is None):
port = self.PORT
if (not isinstance(port, int)):
raise TypeError('port must be an instance of int')
seeds = set()
username = None
password ... |
'Save a set of authentication credentials.
The credentials are used to login a socket whenever one is created.
If `connect` is True, verify the credentials on the server first.'
| def _cache_credentials(self, source, credentials, connect=False):
| all_credentials = self.__all_credentials.copy()
if (source in all_credentials):
if (credentials == all_credentials[source]):
return
raise OperationFailure('Another user is already authenticated to this database. You must logout first.')
if connect... |
'Purge credentials from the authentication cache.'
| def _purge_credentials(self, source):
| self.__all_credentials.pop(source, None)
|
'Test if `index` is cached.'
| def _cached(self, dbname, coll, index):
| cache = self.__index_cache
now = datetime.datetime.utcnow()
with self.__index_cache_lock:
return ((dbname in cache) and (coll in cache[dbname]) and (index in cache[dbname][coll]) and (now < cache[dbname][coll][index]))
|
'Add an index to the index cache for ensure_index operations.'
| def _cache_index(self, dbname, collection, index, cache_for):
| now = datetime.datetime.utcnow()
expire = (datetime.timedelta(seconds=cache_for) + now)
with self.__index_cache_lock:
if (database not in self.__index_cache):
self.__index_cache[dbname] = {}
self.__index_cache[dbname][collection] = {}
self.__index_cache[dbname][co... |
'Purge an index from the index cache.
If `index_name` is None purge an entire collection.
If `collection_name` is None purge an entire database.'
| def _purge_index(self, database_name, collection_name=None, index_name=None):
| with self.__index_cache_lock:
if (not (database_name in self.__index_cache)):
return
if (collection_name is None):
del self.__index_cache[database_name]
return
if (not (collection_name in self.__index_cache[database_name])):
return
if (... |
'An attribute of the current server\'s description.
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 refere... | def _server_property(self, attr_name):
| server = self._topology.select_server(writable_server_selector)
return getattr(server.description, attr_name)
|
'The event listeners registered for this client.
See :mod:`~pymongo.monitoring` for details.'
| @property
def event_listeners(self):
| return self._event_listeners.event_listeners
|
'(host, port) of the current standalone, primary, or mongos, or None.
Accessing :attr:`address` raises :exc:`~.errors.InvalidOperation` if
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
estab... | @property
def address(self):
| 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.ReplicaSetW... |
'The (host, port) of the current primary of the replica set.
Returns ``None`` if this client is not connected to a replica set,
there is no primary, or this client was created without the
`replicaSet` option.
.. versionadded:: 3.0
MongoClient gained this property in version 3.0 when
MongoReplicaSetClient\'s functionali... | @property
def primary(self):
| return self._topology.get_primary()
|
'The secondary members known to this client.
A sequence of (host, port) pairs. Empty if this client is not
connected to a replica set, there are no visible secondaries, or this
client was created without the `replicaSet` option.
.. versionadded:: 3.0
MongoClient gained this property in version 3.0 when
MongoReplicaSetC... | @property
def secondaries(self):
| return self._topology.get_secondaries()
|
'Arbiters in the replica set.
A sequence of (host, port) pairs. Empty if this client is not
connected to a replica set, there are no arbiters, or this client was
created without the `replicaSet` option.'
| @property
def arbiters(self):
| return self._topology.get_arbiters()
|
'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. If the client is not connected, this will block until a
connection is established or raise ServerSelectionTimeoutError if no
server is available.'
| @property
def is_primary(self):
| return self._server_property('is_writable')
|
'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..'
| @property
def is_mongos(self):
| return (self._server_property('server_type') == SERVER_TYPE.Mongos)
|
'The maximum allowable number of concurrent connections to each
connected server. Requests to a server will block if there are
`maxPoolSize` outstanding connections to the requested server.
Defaults to 100. Cannot be 0.
When a server\'s pool has reached `max_pool_size`, operations for that
server block waiting for a so... | @property
def max_pool_size(self):
| return self.__options.pool_options.max_pool_size
|
'The minimum required number of concurrent connections that the pool
will maintain to each connected server. Default is 0.'
| @property
def min_pool_size(self):
| return self.__options.pool_options.min_pool_size
|
'The maximum number of milliseconds that a connection can remain
idle in the pool before being removed and replaced. Defaults to
`None` (no limit).'
| @property
def max_idle_time_ms(self):
| return self.__options.pool_options.max_idle_time_ms
|
'Set of all currently connected servers.
.. warning:: When connected to a replica set the value of :attr:`nodes`
can change over time as :class:`MongoClient`\'s view of the replica
set changes. :attr:`nodes` can also be an empty set when
:class:`MongoClient` is first instantiated and hasn\'t yet connected
to any server... | @property
def nodes(self):
| description = self._topology.description
return frozenset((s.address for s in description.known_servers))
|
'The largest BSON object the connected server accepts in bytes.
If the client is not connected, this will block until a connection is
established or raise ServerSelectionTimeoutError if no server is
available.'
| @property
def max_bson_size(self):
| return self._server_property('max_bson_size')
|
'The largest message the connected server accepts in bytes.
If the client is not connected, this will block until a connection is
established or raise ServerSelectionTimeoutError if no server is
available.'
| @property
def max_message_size(self):
| return self._server_property('max_message_size')
|
'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.'
| @property
def max_write_batch_size(self):
| return self._server_property('max_write_batch_size')
|
'The local threshold for this instance.'
| @property
def local_threshold_ms(self):
| return self.__options.local_threshold_ms
|
'The server selection timeout for this instance in seconds.'
| @property
def server_selection_timeout(self):
| return self.__options.server_selection_timeout
|
'Attempt to connect to a writable server, or return False.'
| def _is_writable(self):
| topology = self._get_topology()
try:
svr = topology.select_server(writable_server_selector)
return svr.description.is_writable
except ConnectionFailure:
return False
|
'Disconnect from MongoDB.
Close all sockets in the connection pools and stop the monitor threads.
If this instance is used again it will be automatically re-opened and
the threads restarted.'
| def close(self):
| self._process_periodic_tasks()
self._topology.close()
|
'DEPRECATED - Set this client\'s cursor manager.
Raises :class:`TypeError` if `manager_class` is not a subclass of
:class:`~pymongo.cursor_manager.CursorManager`. A cursor manager
handles closing cursors. Different managers can implement different
policies in terms of when to actually kill a cursor that has
been closed... | def set_cursor_manager(self, manager_class):
| warnings.warn('set_cursor_manager is Deprecated', DeprecationWarning, stacklevel=2)
manager = manager_class(self)
if (not isinstance(manager, CursorManager)):
raise TypeError('manager_class must be a subclass of CursorManager')
self.__cursor_manager = manager
|
'Get the internal :class:`~pymongo.topology.Topology` object.
If this client was created with "connect=False", calling _get_topology
launches the connection process in the background.'
| def _get_topology(self):
| self._topology.open()
return self._topology
|
'Send a message to MongoDB and return a Response.
:Parameters:
- `operation`: a _Query or _GetMore object.
- `read_preference` (optional): A ReadPreference.
- `exhaust` (optional): If True, the socket used stays checked out.
It is returned along with its Pool in the Response.
- `address` (optional): Optional address wh... | def _send_message_with_response(self, operation, read_preference=None, exhaust=False, address=None):
| with self.__lock:
self._kill_cursors_executor.open()
topology = self._get_topology()
if address:
server = topology.select_server_by_address(address)
if (not server):
raise AutoReconnect(('server %s:%d no longer available' % address))
else:
selector... |
'Execute an operation. Reset the server on network error.
Returns fn()\'s return value on success. On error, clears the server\'s
pool and marks the server Unknown.
Re-raises any exception thrown by fn().'
| def _reset_on_error(self, server, func, *args, **kwargs):
| try:
return func(*args, **kwargs)
except NetworkTimeout:
raise
except ConnectionFailure:
self.__reset_server(server.description.address)
raise
|
'Clear our connection pool for a server and mark it Unknown.'
| def __reset_server(self, address):
| self._topology.reset_server(address)
|
'Clear our pool for a server, mark it Unknown, and check it soon.'
| def _reset_server_and_request_check(self, address):
| self._topology.reset_server_and_request_check(address)
|
'Get a database by name.
Raises :class:`~pymongo.errors.InvalidName` if an invalid
database name is used.
:Parameters:
- `name`: the name of the database to get'
| def __getattr__(self, name):
| if name.startswith('_'):
raise AttributeError(('MongoClient has no attribute %r. To access the %s database, use client[%r].' % (name, name, name)))
return self.__getitem__(name)
|
'Get a database by name.
Raises :class:`~pymongo.errors.InvalidName` if an invalid
database name is used.
:Parameters:
- `name`: the name of the database to get'
| def __getitem__(self, name):
| return database.Database(self, name)
|
'Send a kill cursors message soon with the given id.
Raises :class:`TypeError` if `cursor_id` is not an instance of
``(int, long)``. What closing the cursor actually means
depends on this client\'s cursor manager.
This method may be called from a :class:`~pymongo.cursor.Cursor`
destructor during garbage collection, so ... | def close_cursor(self, cursor_id, address=None):
| if (not isinstance(cursor_id, integer_types)):
raise TypeError('cursor_id must be an instance of (int, long)')
if (self.__cursor_manager is not None):
self.__cursor_manager.close(cursor_id, address)
else:
self.__kill_cursors_queue.append((address, [cursor_id]))
|
'Send a kill cursors message with the given id.
What closing the cursor actually means depends on this client\'s
cursor manager. If there is none, the cursor is closed synchronously
on the current thread.'
| def _close_cursor_now(self, cursor_id, address=None):
| if (not isinstance(cursor_id, integer_types)):
raise TypeError('cursor_id must be an instance of (int, long)')
if (self.__cursor_manager is not None):
self.__cursor_manager.close(cursor_id, address)
else:
self._kill_cursors([cursor_id], address, self._get_topolog... |
'DEPRECATED - Send a kill cursors message soon with the given ids.
Raises :class:`TypeError` if `cursor_ids` is not an instance of
``list``.
:Parameters:
- `cursor_ids`: list of cursor ids to kill
- `address` (optional): (host, port) pair of the cursor\'s server.
If it is not provided, the client attempts to close the ... | def kill_cursors(self, cursor_ids, address=None):
| warnings.warn('kill_cursors is deprecated.', DeprecationWarning, stacklevel=2)
if (not isinstance(cursor_ids, list)):
raise TypeError('cursor_ids must be a list')
self.__kill_cursors_queue.append((address, cursor_ids))
|
'Send a kill cursors message with the given ids.'
| def _kill_cursors(self, cursor_ids, address, topology):
| listeners = self._event_listeners
publish = listeners.enabled_for_commands
if address:
server = topology.select_server_by_address(tuple(address))
else:
server = topology.select_server(writable_server_selector)
try:
namespace = address.namespace
(db, coll) = namespace.... |
'Process any pending kill cursors requests and
maintain connection pool parameters.'
| def _process_periodic_tasks(self):
| address_to_cursor_ids = defaultdict(list)
while True:
try:
(address, cursor_ids) = self.__kill_cursors_queue.pop()
except IndexError:
break
address_to_cursor_ids[address].extend(cursor_ids)
if address_to_cursor_ids:
topology = self._get_topology()
... |
'Get information about the MongoDB server we\'re connected to.'
| def server_info(self):
| return self.admin.command('buildinfo', read_preference=ReadPreference.PRIMARY)
|
'Get a list of the names of all databases on the connected server.'
| def database_names(self):
| return [db['name'] for db in self._database_default_options('admin').command(SON([('listDatabases', 1), ('nameOnly', True)]))['databases']]
|
'Drop a database.
Raises :class:`TypeError` if `name_or_database` is not an instance of
:class:`basestring` (:class:`str` in python 3) or
:class:`~pymongo.database.Database`.
:Parameters:
- `name_or_database`: the name of a database to drop, or a
:class:`~pymongo.database.Database` instance representing the
database to... | def drop_database(self, name_or_database):
| name = name_or_database
if isinstance(name, database.Database):
name = name.name
if (not isinstance(name, string_type)):
raise TypeError(('name_or_database must be an instance of %s or a Database' % (string_type.__name__,)))
self._purge_index(name)
with sel... |
'DEPRECATED - Get the database named in the MongoDB connection URI.
>>> uri = \'mongodb://host/my_database\'
>>> client = MongoClient(uri)
>>> db = client.get_default_database()
>>> assert db.name == \'my_database\'
>>> db = client.get_database()
>>> assert db.name == \'my_database\'
Useful in scripts where you want to... | def get_default_database(self):
| warnings.warn('get_default_database is deprecated. Use get_database instead.', DeprecationWarning, stacklevel=2)
if (self.__default_database_name is None):
raise ConfigurationError('No default database defined')
return self[self.__default_database_name]
|
'Get a :class:`~pymongo.database.Database` with the given name and
options.
Useful for creating a :class:`~pymongo.database.Database` with
different codec options, read preference, and/or write concern from
this :class:`MongoClient`.
>>> client.read_preference
Primary()
>>> db1 = client.test
>>> db1.read_preference
Pri... | def get_database(self, name=None, codec_options=None, read_preference=None, write_concern=None, read_concern=None):
| if (name is None):
if (self.__default_database_name is None):
raise ConfigurationError('No default database defined')
name = self.__default_database_name
return database.Database(self, name, codec_options, read_preference, write_concern, read_concern)
|
'Get a Database instance with the default settings.'
| def _database_default_options(self, name):
| return self.get_database(name, codec_options=DEFAULT_CODEC_OPTIONS, read_preference=ReadPreference.PRIMARY, write_concern=WriteConcern())
|
'Is this server locked? While locked, all write operations
are blocked, although read operations may still be allowed.
Use :meth:`unlock` to unlock.'
| @property
def is_locked(self):
| ops = self._database_default_options('admin').current_op()
return bool(ops.get('fsyncLock', 0))
|
'Flush all pending writes to datafiles.
:Parameters:
Optional parameters can be passed as keyword arguments:
- `lock`: If True lock the server to disallow writes.
- `async`: If True don\'t block while synchronizing.
.. warning:: `async` and `lock` can not be used together.
.. warning:: MongoDB does not support the `asy... | def fsync(self, **kwargs):
| self.admin.command('fsync', read_preference=ReadPreference.PRIMARY, **kwargs)
|
'Unlock a previously locked server.'
| def unlock(self):
| cmd = {'fsyncUnlock': 1}
with self._socket_for_writes() as sock_info:
if (sock_info.max_wire_version >= 4):
try:
sock_info.command('admin', cmd)
except OperationFailure as exc:
if (exc.code != 125):
raise
else:
... |
'The maximum allowable number of concurrent connections to each
connected server. Requests to a server will block if there are
`maxPoolSize` outstanding connections to the requested server.
Defaults to 100. Cannot be 0.
When a server\'s pool has reached `max_pool_size`, operations for that
server block waiting for a so... | @property
def max_pool_size(self):
| return self.__max_pool_size
|
'The minimum required number of concurrent connections that the pool
will maintain to each connected server. Default is 0.'
| @property
def min_pool_size(self):
| return self.__min_pool_size
|
'The maximum number of milliseconds that a connection can remain
idle in the pool before being removed and replaced. Defaults to
`None` (no limit).'
| @property
def max_idle_time_ms(self):
| return self.__max_idle_time_ms
|
'How long a connection can take to be opened before timing out.'
| @property
def connect_timeout(self):
| return self.__connect_timeout
|
'How long a send or receive on a socket can take before timing out.'
| @property
def socket_timeout(self):
| return self.__socket_timeout
|
'How long a thread will wait for a socket from the pool if the pool
has no free sockets.'
| @property
def wait_queue_timeout(self):
| return self.__wait_queue_timeout
|
'Multiplied by max_pool_size to give the number of threads allowed
to wait for a socket at one time.'
| @property
def wait_queue_multiple(self):
| return self.__wait_queue_multiple
|
'An SSLContext instance or None.'
| @property
def ssl_context(self):
| return self.__ssl_context
|
'Call ssl.match_hostname if cert_reqs is not ssl.CERT_NONE.'
| @property
def ssl_match_hostname(self):
| return self.__ssl_match_hostname
|
'Whether to send periodic messages to determine if a connection
is closed.'
| @property
def socket_keepalive(self):
| return self.__socket_keepalive
|
'An instance of pymongo.monitoring._EventListeners.'
| @property
def event_listeners(self):
| return self.__event_listeners
|
'The application name, for sending with ismaster in server handshake.'
| @property
def appname(self):
| return self.__appname
|
'A dict of metadata about the application, driver, os, and platform.'
| @property
def metadata(self):
| return self.__metadata.copy()
|
'Execute a command or raise ConnectionFailure or OperationFailure.
:Parameters:
- `dbname`: name of the database on which to run the command
- `spec`: a command document as a dict, SON, or mapping object
- `slave_ok`: whether to set the SlaveOkay wire protocol bit
- `read_preference`: a read preference
- `codec_options... | def command(self, dbname, spec, slave_ok=False, read_preference=ReadPreference.PRIMARY, codec_options=DEFAULT_CODEC_OPTIONS, check=True, allowable_errors=None, check_keys=False, read_concern=DEFAULT_READ_CONCERN, write_concern=None, parse_write_concern_error=False, collation=None):
| if ((self.max_wire_version < 4) and (not read_concern.ok_for_legacy)):
raise ConfigurationError(('read concern level of %s is not valid with a max wire version of %d.' % (read_concern.level, self.max_wire_version)))
if (not ((write_concern is None) or write_conc... |
'Send a raw BSON message or raise ConnectionFailure.
If a network exception is raised, the socket is closed.'
| def send_message(self, message, max_doc_size):
| if ((self.max_bson_size is not None) and (max_doc_size > self.max_bson_size)):
raise DocumentTooLarge(('BSON document too large (%d bytes) - the connected server supports BSON document sizes up to %d bytes.' % (max_doc_size, self.max_bson_size)))
try:
... |
'Receive a raw BSON message or raise ConnectionFailure.
If any exception is raised, the socket is closed.'
| def receive_message(self, operation, request_id):
| try:
return receive_message(self.sock, operation, request_id, self.max_message_size)
except BaseException as error:
self._raise_connection_failure(error)
|
'Send OP_INSERT, etc., optionally returning response as a dict.
Can raise ConnectionFailure or OperationFailure.
:Parameters:
- `request_id`: an int.
- `msg`: bytes, an OP_INSERT, OP_UPDATE, or OP_DELETE message,
perhaps with a getlasterror command appended.
- `max_doc_size`: size in bytes of the largest document in `m... | def legacy_write(self, request_id, msg, max_doc_size, with_last_error):
| if ((not with_last_error) and (not self.is_writable)):
raise NotMasterError('not master')
self.send_message(msg, max_doc_size)
if with_last_error:
response = self.receive_message(1, request_id)
return helpers._check_gle_response(response)
|
'Send "insert" etc. command, returning response as a dict.
Can raise ConnectionFailure or OperationFailure.
:Parameters:
- `request_id`: an int.
- `msg`: bytes, the command message.'
| def write_command(self, request_id, msg):
| self.send_message(msg, 0)
response = helpers._unpack_response(self.receive_message(1, request_id))
assert (response['number_returned'] == 1)
result = response['data'][0]
helpers._check_command_response(result)
return result
|
'Update this socket\'s authentication.
Log in or out to bring this socket\'s credentials up to date with
those provided. Can raise ConnectionFailure or OperationFailure.
:Parameters:
- `all_credentials`: dict, maps auth source to MongoCredential.'
| def check_auth(self, all_credentials):
| if (all_credentials or self.authset):
cached = set(itervalues(all_credentials))
authset = self.authset.copy()
for credentials in (authset - cached):
auth.logout(credentials.source, self)
self.authset.discard(credentials)
for credentials in (cached - authset):
... |
'Log in to the server and store these credentials in `authset`.
Can raise ConnectionFailure or OperationFailure.
:Parameters:
- `credentials`: A MongoCredential.'
| def authenticate(self, credentials):
| auth.authenticate(credentials, self)
self.authset.add(credentials)
|
':Parameters:
- `address`: a (hostname, port) tuple
- `options`: a PoolOptions instance
- `handshake`: whether to call ismaster for each new SocketInfo'
| def __init__(self, address, options, handshake=True):
| self._check_interval_seconds = 1
self.sockets = set()
self.lock = threading.Lock()
self.active_sockets = 0
self.pool_id = 0
self.pid = os.getpid()
self.address = address
self.opts = options
self.handshake = handshake
if ((self.opts.wait_queue_multiple is None) or (self.opts.max_p... |
'Connect to Mongo and return a new SocketInfo.
Can raise ConnectionFailure or CertificateError.
Note that the pool does not keep a reference to the socket -- you
must call return_socket() when you\'re done with it.'
| def connect(self):
| sock = None
try:
sock = _configured_socket(self.address, self.opts)
if self.handshake:
cmd = SON([('ismaster', 1), ('client', self.opts.metadata)])
ismaster = IsMaster(command(sock, 'admin', cmd, False, False, ReadPreference.PRIMARY, DEFAULT_CODEC_OPTIONS))
else:
... |
'Get a socket from the pool. Use with a "with" statement.
Returns a :class:`SocketInfo` object wrapping a connected
:class:`socket.socket`.
This method should always be used in a with-statement::
with pool.get_socket(credentials, checkout) as socket_info:
socket_info.send_message(msg)
data = socket_info.receive_message... | @contextlib.contextmanager
def get_socket(self, all_credentials, checkout=False):
| sock_info = self._get_socket_no_auth()
try:
sock_info.check_auth(all_credentials)
(yield sock_info)
except:
self.return_socket(sock_info)
raise
else:
if (not checkout):
self.return_socket(sock_info)
|
'Get or create a SocketInfo. Can raise ConnectionFailure.'
| def _get_socket_no_auth(self):
| if (self.pid != os.getpid()):
self.reset()
if (not self._socket_semaphore.acquire(True, self.opts.wait_queue_timeout)):
self._raise_wait_queue_timeout()
with self.lock:
self.active_sockets += 1
try:
try:
with self.lock:
sock_info = self.sockets... |
'Return the socket to the pool, or if it\'s closed discard it.'
| def return_socket(self, sock_info):
| if (self.pid != os.getpid()):
self.reset()
elif (sock_info.pool_id != self.pool_id):
sock_info.close()
elif (not sock_info.closed):
sock_info.last_checkin = _time()
with self.lock:
self.sockets.add(sock_info)
self._socket_semaphore.release()
with self.lock... |
'This side-effecty function checks if this socket has been idle for
for longer than the max idle time, or if the socket has been closed by
some external network error, and if so, attempts to create a new
socket. If this connection attempt fails we raise the
ConnectionFailure.
Checking sockets lets us avoid seeing *some... | def _check(self, sock_info):
| idle_time_seconds = (_time() - sock_info.last_checkin)
if ((self.opts.max_idle_time_ms is not None) and ((idle_time_seconds * 1000) > self.opts.max_idle_time_ms)):
sock_info.close()
return self.connect()
if ((self._check_interval_seconds is not None) and ((0 == self._check_interval_seconds) ... |
'The document representation of this write concern.
.. note::
:class:`WriteConcern` is immutable. Mutating the value of
:attr:`document` does not mutate this :class:`WriteConcern`.'
| @property
def document(self):
| return self.__document.copy()
|
'If ``True`` write operations will wait for acknowledgement before
returning.'
| @property
def acknowledged(self):
| return self.__acknowledged
|
'Return a find command document for this query.
Should be called *after* get_message.'
| def as_command(self):
| if ('$explain' in self.spec):
self.name = 'explain'
return (_gen_explain_command(self.coll, self.spec, self.fields, self.ntoskip, self.limit, self.batch_size, self.flags, self.read_concern), self.db)
return (_gen_find_command(self.coll, self.spec, self.fields, self.ntoskip, self.limit, self.batc... |
'Get a query message, possibly setting the slaveOk bit.'
| def get_message(self, set_slave_ok, is_mongos, use_cmd=False):
| if set_slave_ok:
flags = (self.flags | 4)
else:
flags = self.flags
ns = (_UJOIN % (self.db, self.coll))
spec = self.spec
if use_cmd:
ns = (_UJOIN % (self.db, '$cmd'))
spec = self.as_command()[0]
ntoreturn = (-1)
else:
ntoreturn = (((self.batch_size... |
'Return a getMore command document for this query.'
| def as_command(self):
| return (_gen_get_more_command(self.cursor_id, self.coll, self.ntoreturn, self.max_await_time_ms), self.db)
|
'Get a getmore message.'
| def get_message(self, dummy0, dummy1, use_cmd=False):
| ns = (_UJOIN % (self.db, self.coll))
if use_cmd:
ns = (_UJOIN % (self.db, '$cmd'))
spec = self.as_command()[0]
return query(0, ns, 0, (-1), spec, None, self.codec_options)
return get_more(ns, self.ntoreturn, self.cursor_id)
|
'The namespace this cursor.'
| @property
def namespace(self):
| return self.__namespace
|
'A proxy for SockInfo.max_bson_size.'
| @property
def max_bson_size(self):
| return self.sock_info.max_bson_size
|
'A proxy for SockInfo.max_message_size.'
| @property
def max_message_size(self):
| return self.sock_info.max_message_size
|
'A proxy for SockInfo.max_write_batch_size.'
| @property
def max_write_batch_size(self):
| return self.sock_info.max_write_batch_size
|
'A proxy for SocketInfo.legacy_write that handles event publishing.'
| def legacy_write(self, request_id, msg, max_doc_size, acknowledged, docs):
| if self.publish:
duration = (datetime.datetime.now() - self.start_time)
cmd = self._start(request_id, docs)
start = datetime.datetime.now()
try:
result = self.sock_info.legacy_write(request_id, msg, max_doc_size, acknowledged)
if self.publish:
duration = ((dat... |
'A proxy for SocketInfo.write_command that handles event publishing.'
| def write_command(self, request_id, msg, docs):
| if self.publish:
duration = (datetime.datetime.now() - self.start_time)
self._start(request_id, docs)
start = datetime.datetime.now()
try:
reply = self.sock_info.write_command(request_id, msg)
if self.publish:
duration = ((datetime.datetime.now() - start) + du... |
'Publish a CommandStartedEvent.'
| def _start(self, request_id, docs):
| cmd = self.command.copy()
cmd[self.field] = docs
self.listeners.publish_command_start(cmd, self.db_name, request_id, self.sock_info.address, self.op_id)
return cmd
|
'Publish a CommandSucceededEvent.'
| def _succeed(self, request_id, reply, duration):
| self.listeners.publish_command_success(duration, reply, self.name, request_id, self.sock_info.address, self.op_id)
|
'Publish a CommandFailedEvent.'
| def _fail(self, request_id, failure, duration):
| self.listeners.publish_command_failure(duration, failure, self.name, request_id, self.sock_info.address, self.op_id)
|
'The read concern level.'
| @property
def level(self):
| return self.__level
|
'Return ``True`` if this read concern is compatible with
old wire protocol versions.'
| @property
def ok_for_legacy(self):
| return ((self.level is None) or (self.level == 'local'))
|
'The document representation of this read concern.
.. note::
:class:`ReadConcern` is immutable. Mutating the value of
:attr:`document` does not mutate this :class:`ReadConcern`.'
| @property
def document(self):
| doc = {}
if self.__level:
doc['level'] = self.level
return doc
|
'Class to monitor a MongoDB server on a background thread.
Pass an initial ServerDescription, a Topology, a Pool, and
TopologySettings.
The Topology is weakly referenced. The Pool must be exclusive to this
Monitor.'
| def __init__(self, server_description, topology, pool, topology_settings):
| self._server_description = server_description
self._pool = pool
self._settings = topology_settings
self._avg_round_trip_time = MovingAverage()
self._listeners = self._settings._pool_options.event_listeners
pub = (self._listeners is not None)
self._publish = (pub and self._listeners.enabled_f... |
'Start monitoring, or restart after a fork.
Multiple calls have no effect.'
| def open(self):
| self._executor.open()
|
'Close and stop monitoring.
open() restarts the monitor after closing.'
| def close(self):
| self._executor.close()
self._pool.reset()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.