sensu-plugins-mongodb-mrtrotl 1.4.0

data/lib/pymongo/response.py

@@ -0,0 +1,109 @@
+# Copyright 2014-present MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Represent a response from the server."""
+
+
+class Response(object):
+    __slots__ = ("_data", "_address", "_request_id", "_duration", "_from_command", "_docs")
+
+    def __init__(self, data, address, request_id, duration, from_command, docs):
+        """Represent a response from the server.
+
+        :Parameters:
+          - `data`: A network response message.
+          - `address`: (host, port) of the source server.
+          - `request_id`: The request id of this operation.
+          - `duration`: The duration of the operation.
+          - `from_command`: if the response is the result of a db command.
+        """
+        self._data = data
+        self._address = address
+        self._request_id = request_id
+        self._duration = duration
+        self._from_command = from_command
+        self._docs = docs
+
+    @property
+    def data(self):
+        """Server response's raw BSON bytes."""
+        return self._data
+
+    @property
+    def address(self):
+        """(host, port) of the source server."""
+        return self._address
+
+    @property
+    def request_id(self):
+        """The request id of this operation."""
+        return self._request_id
+
+    @property
+    def duration(self):
+        """The duration of the operation."""
+        return self._duration
+
+    @property
+    def from_command(self):
+        """If the response is a result from a db command."""
+        return self._from_command
+
+    @property
+    def docs(self):
+        """The decoded document(s)."""
+        return self._docs
+
+
+class PinnedResponse(Response):
+    __slots__ = ("_socket_info", "_more_to_come")
+
+    def __init__(
+        self, data, address, socket_info, request_id, duration, from_command, docs, more_to_come
+    ):
+        """Represent a response to an exhaust cursor's initial query.
+
+        :Parameters:
+          - `data`:  A network response message.
+          - `address`: (host, port) of the source server.
+          - `socket_info`: The SocketInfo used for the initial query.
+          - `pool`: The Pool from which the SocketInfo came.
+          - `request_id`: The request id of this operation.
+          - `duration`: The duration of the operation.
+          - `from_command`: If the response is the result of a db command.
+          - `docs`: List of documents.
+          - `more_to_come`: Bool indicating whether cursor is ready to be
+            exhausted.
+        """
+        super(PinnedResponse, self).__init__(
+            data, address, request_id, duration, from_command, docs
+        )
+        self._socket_info = socket_info
+        self._more_to_come = more_to_come
+
+    @property
+    def socket_info(self):
+        """The SocketInfo used for the initial query.
+
+        The server will send batches on this socket, without waiting for
+        getMores from the client, until the result set is exhausted or there
+        is an error.
+        """
+        return self._socket_info
+
+    @property
+    def more_to_come(self):
+        """If true, server is ready to send batches on the socket until the
+        result set is exhausted or there is an error."""
+        return self._more_to_come

data/lib/pymongo/results.py

@@ -0,0 +1,217 @@
+# Copyright 2015-present MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Result class definitions."""
+from typing import Any, Dict, List, Optional, cast
+
+from pymongo.errors import InvalidOperation
+
+
+class _WriteResult(object):
+    """Base class for write result classes."""
+
+    __slots__ = ("__acknowledged",)
+
+    def __init__(self, acknowledged: bool) -> None:
+        self.__acknowledged = acknowledged
+
+    def _raise_if_unacknowledged(self, property_name):
+        """Raise an exception on property access if unacknowledged."""
+        if not self.__acknowledged:
+            raise InvalidOperation(
+                "A value for %s is not available when "
+                "the write is unacknowledged. Check the "
+                "acknowledged attribute to avoid this "
+                "error." % (property_name,)
+            )
+
+    @property
+    def acknowledged(self) -> bool:
+        """Is this the result of an acknowledged write operation?
+
+        The :attr:`acknowledged` attribute will be ``False`` when using
+        ``WriteConcern(w=0)``, otherwise ``True``.
+
+        .. note::
+          If the :attr:`acknowledged` attribute is ``False`` all other
+          attibutes of this class will raise
+          :class:`~pymongo.errors.InvalidOperation` when accessed. Values for
+          other attributes cannot be determined if the write operation was
+          unacknowledged.
+
+        .. seealso::
+          :class:`~pymongo.write_concern.WriteConcern`
+        """
+        return self.__acknowledged
+
+
+class InsertOneResult(_WriteResult):
+    """The return type for :meth:`~pymongo.collection.Collection.insert_one`."""
+
+    __slots__ = ("__inserted_id",)
+
+    def __init__(self, inserted_id: Any, acknowledged: bool) -> None:
+        self.__inserted_id = inserted_id
+        super(InsertOneResult, self).__init__(acknowledged)
+
+    @property
+    def inserted_id(self) -> Any:
+        """The inserted document's _id."""
+        return self.__inserted_id
+
+
+class InsertManyResult(_WriteResult):
+    """The return type for :meth:`~pymongo.collection.Collection.insert_many`."""
+
+    __slots__ = ("__inserted_ids",)
+
+    def __init__(self, inserted_ids: List[Any], acknowledged: bool) -> None:
+        self.__inserted_ids = inserted_ids
+        super(InsertManyResult, self).__init__(acknowledged)
+
+    @property
+    def inserted_ids(self) -> List:
+        """A list of _ids of the inserted documents, in the order provided.
+
+        .. note:: If ``False`` is passed for the `ordered` parameter to
+          :meth:`~pymongo.collection.Collection.insert_many` the server
+          may have inserted the documents in a different order than what
+          is presented here.
+        """
+        return self.__inserted_ids
+
+
+class UpdateResult(_WriteResult):
+    """The return type for :meth:`~pymongo.collection.Collection.update_one`,
+    :meth:`~pymongo.collection.Collection.update_many`, and
+    :meth:`~pymongo.collection.Collection.replace_one`.
+    """
+
+    __slots__ = ("__raw_result",)
+
+    def __init__(self, raw_result: Dict[str, Any], acknowledged: bool) -> None:
+        self.__raw_result = raw_result
+        super(UpdateResult, self).__init__(acknowledged)
+
+    @property
+    def raw_result(self) -> Dict[str, Any]:
+        """The raw result document returned by the server."""
+        return self.__raw_result
+
+    @property
+    def matched_count(self) -> int:
+        """The number of documents matched for this update."""
+        self._raise_if_unacknowledged("matched_count")
+        if self.upserted_id is not None:
+            return 0
+        return self.__raw_result.get("n", 0)
+
+    @property
+    def modified_count(self) -> int:
+        """The number of documents modified."""
+        self._raise_if_unacknowledged("modified_count")
+        return cast(int, self.__raw_result.get("nModified"))
+
+    @property
+    def upserted_id(self) -> Any:
+        """The _id of the inserted document if an upsert took place. Otherwise
+        ``None``.
+        """
+        self._raise_if_unacknowledged("upserted_id")
+        return self.__raw_result.get("upserted")
+
+
+class DeleteResult(_WriteResult):
+    """The return type for :meth:`~pymongo.collection.Collection.delete_one`
+    and :meth:`~pymongo.collection.Collection.delete_many`"""
+
+    __slots__ = ("__raw_result",)
+
+    def __init__(self, raw_result: Dict[str, Any], acknowledged: bool) -> None:
+        self.__raw_result = raw_result
+        super(DeleteResult, self).__init__(acknowledged)
+
+    @property
+    def raw_result(self) -> Dict[str, Any]:
+        """The raw result document returned by the server."""
+        return self.__raw_result
+
+    @property
+    def deleted_count(self) -> int:
+        """The number of documents deleted."""
+        self._raise_if_unacknowledged("deleted_count")
+        return self.__raw_result.get("n", 0)
+
+
+class BulkWriteResult(_WriteResult):
+    """An object wrapper for bulk API write results."""
+
+    __slots__ = ("__bulk_api_result",)
+
+    def __init__(self, bulk_api_result: Dict[str, Any], acknowledged: bool) -> None:
+        """Create a BulkWriteResult instance.
+
+        :Parameters:
+          - `bulk_api_result`: A result dict from the bulk API
+          - `acknowledged`: Was this write result acknowledged? If ``False``
+            then all properties of this object will raise
+            :exc:`~pymongo.errors.InvalidOperation`.
+        """
+        self.__bulk_api_result = bulk_api_result
+        super(BulkWriteResult, self).__init__(acknowledged)
+
+    @property
+    def bulk_api_result(self) -> Dict[str, Any]:
+        """The raw bulk API result."""
+        return self.__bulk_api_result
+
+    @property
+    def inserted_count(self) -> int:
+        """The number of documents inserted."""
+        self._raise_if_unacknowledged("inserted_count")
+        return cast(int, self.__bulk_api_result.get("nInserted"))
+
+    @property
+    def matched_count(self) -> int:
+        """The number of documents matched for an update."""
+        self._raise_if_unacknowledged("matched_count")
+        return cast(int, self.__bulk_api_result.get("nMatched"))
+
+    @property
+    def modified_count(self) -> int:
+        """The number of documents modified."""
+        self._raise_if_unacknowledged("modified_count")
+        return cast(int, self.__bulk_api_result.get("nModified"))
+
+    @property
+    def deleted_count(self) -> int:
+        """The number of documents deleted."""
+        self._raise_if_unacknowledged("deleted_count")
+        return cast(int, self.__bulk_api_result.get("nRemoved"))
+
+    @property
+    def upserted_count(self) -> int:
+        """The number of documents upserted."""
+        self._raise_if_unacknowledged("upserted_count")
+        return cast(int, self.__bulk_api_result.get("nUpserted"))
+
+    @property
+    def upserted_ids(self) -> Optional[Dict[int, Any]]:
+        """A map of operation index to the _id of the upserted document."""
+        self._raise_if_unacknowledged("upserted_ids")
+        if self.__bulk_api_result:
+            return dict(
+                (upsert["index"], upsert["_id"]) for upsert in self.bulk_api_result["upserted"]
+            )
+        return None

data/lib/pymongo/saslprep.py

@@ -0,0 +1,113 @@
+# Copyright 2016-present MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""An implementation of RFC4013 SASLprep."""
+from typing import Any, Optional
+
+try:
+    import stringprep
+except ImportError:
+    HAVE_STRINGPREP = False
+
+    def saslprep(data: Any, prohibit_unassigned_code_points: Optional[bool] = True) -> str:
+        """SASLprep dummy"""
+        if isinstance(data, str):
+            raise TypeError(
+                "The stringprep module is not available. Usernames and "
+                "passwords must be instances of bytes."
+            )
+        return data
+
+else:
+    HAVE_STRINGPREP = True
+    import unicodedata
+
+    # RFC4013 section 2.3 prohibited output.
+    _PROHIBITED = (
+        # A strict reading of RFC 4013 requires table c12 here, but
+        # characters from it are mapped to SPACE in the Map step. Can
+        # normalization reintroduce them somehow?
+        stringprep.in_table_c12,
+        stringprep.in_table_c21_c22,
+        stringprep.in_table_c3,
+        stringprep.in_table_c4,
+        stringprep.in_table_c5,
+        stringprep.in_table_c6,
+        stringprep.in_table_c7,
+        stringprep.in_table_c8,
+        stringprep.in_table_c9,
+    )
+
+    def saslprep(data: Any, prohibit_unassigned_code_points: Optional[bool] = True) -> str:
+        """An implementation of RFC4013 SASLprep.
+
+        :Parameters:
+          - `data`: The string to SASLprep. Unicode strings
+            (:class:`str`) are supported. Byte strings
+            (:class:`bytes`) are ignored.
+          - `prohibit_unassigned_code_points`: True / False. RFC 3454
+            and RFCs for various SASL mechanisms distinguish between
+            `queries` (unassigned code points allowed) and
+            `stored strings` (unassigned code points prohibited). Defaults
+            to ``True`` (unassigned code points are prohibited).
+
+        :Returns:
+        The SASLprep'ed version of `data`.
+        """
+        prohibited: Any
+
+        if not isinstance(data, str):
+            return data
+
+        if prohibit_unassigned_code_points:
+            prohibited = _PROHIBITED + (stringprep.in_table_a1,)
+        else:
+            prohibited = _PROHIBITED
+
+        # RFC3454 section 2, step 1 - Map
+        # RFC4013 section 2.1 mappings
+        # Map Non-ASCII space characters to SPACE (U+0020). Map
+        # commonly mapped to nothing characters to, well, nothing.
+        in_table_c12 = stringprep.in_table_c12
+        in_table_b1 = stringprep.in_table_b1
+        data = "".join(
+            ["\u0020" if in_table_c12(elt) else elt for elt in data if not in_table_b1(elt)]
+        )
+
+        # RFC3454 section 2, step 2 - Normalize
+        # RFC4013 section 2.2 normalization
+        data = unicodedata.ucd_3_2_0.normalize("NFKC", data)
+
+        in_table_d1 = stringprep.in_table_d1
+        if in_table_d1(data[0]):
+            if not in_table_d1(data[-1]):
+                # RFC3454, Section 6, #3. If a string contains any
+                # RandALCat character, the first and last characters
+                # MUST be RandALCat characters.
+                raise ValueError("SASLprep: failed bidirectional check")
+            # RFC3454, Section 6, #2. If a string contains any RandALCat
+            # character, it MUST NOT contain any LCat character.
+            prohibited = prohibited + (stringprep.in_table_d2,)
+        else:
+            # RFC3454, Section 6, #3. Following the logic of #3, if
+            # the first character is not a RandALCat, no other character
+            # can be either.
+            prohibited = prohibited + (in_table_d1,)
+
+        # RFC3454 section 2, step 3 and 4 - Prohibit and check bidi
+        for char in data:
+            if any(in_table(char) for in_table in prohibited):
+                raise ValueError("SASLprep: failed prohibited character check")
+
+        return data

data/lib/pymongo/server.py

@@ -0,0 +1,247 @@
+# Copyright 2014-present MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+
+"""Communicate with one MongoDB server in a topology."""
+
+from datetime import datetime
+
+from bson import _decode_all_selective
+from pymongo.errors import NotPrimaryError, OperationFailure
+from pymongo.helpers import _check_command_response
+from pymongo.message import _convert_exception, _OpMsg
+from pymongo.response import PinnedResponse, Response
+
+_CURSOR_DOC_FIELDS = {"cursor": {"firstBatch": 1, "nextBatch": 1}}
+
+
+class Server(object):
+    def __init__(
+        self, server_description, pool, monitor, topology_id=None, listeners=None, events=None
+    ):
+        """Represent one MongoDB server."""
+        self._description = server_description
+        self._pool = pool
+        self._monitor = monitor
+        self._topology_id = topology_id
+        self._publish = listeners is not None and listeners.enabled_for_server
+        self._listener = listeners
+        self._events = None
+        if self._publish:
+            self._events = events()
+
+    def open(self):
+        """Start monitoring, or restart after a fork.
+
+        Multiple calls have no effect.
+        """
+        if not self._pool.opts.load_balanced:
+            self._monitor.open()
+
+    def reset(self, service_id=None):
+        """Clear the connection pool."""
+        self.pool.reset(service_id)
+
+    def close(self):
+        """Clear the connection pool and stop the monitor.
+
+        Reconnect with open().
+        """
+        if self._publish:
+            assert self._listener is not None
+            assert self._events is not None
+            self._events.put(
+                (
+                    self._listener.publish_server_closed,
+                    (self._description.address, self._topology_id),
+                )
+            )
+        self._monitor.close()
+        self._pool.reset_without_pause()
+
+    def request_check(self):
+        """Check the server's state soon."""
+        self._monitor.request_check()
+
+    def run_operation(self, sock_info, operation, read_preference, listeners, unpack_res):
+        """Run a _Query or _GetMore operation and return a Response object.
+
+        This method is used only to run _Query/_GetMore operations from
+        cursors.
+        Can raise ConnectionFailure, OperationFailure, etc.
+
+        :Parameters:
+          - `sock_info`: A SocketInfo instance.
+          - `operation`: A _Query or _GetMore object.
+          - `set_secondary_okay`: Pass to operation.get_message.
+          - `listeners`: Instance of _EventListeners or None.
+          - `unpack_res`: A callable that decodes the wire protocol response.
+        """
+        duration = None
+        publish = listeners.enabled_for_commands
+        if publish:
+            start = datetime.now()
+
+        use_cmd = operation.use_command(sock_info)
+        more_to_come = operation.sock_mgr and operation.sock_mgr.more_to_come
+        if more_to_come:
+            request_id = 0
+        else:
+            message = operation.get_message(read_preference, sock_info, use_cmd)
+            request_id, data, max_doc_size = self._split_message(message)
+
+        if publish:
+            cmd, dbn = operation.as_command(sock_info)
+            listeners.publish_command_start(
+                cmd, dbn, request_id, sock_info.address, service_id=sock_info.service_id
+            )
+            start = datetime.now()
+
+        try:
+            if more_to_come:
+                reply = sock_info.receive_message(None)
+            else:
+                sock_info.send_message(data, max_doc_size)
+                reply = sock_info.receive_message(request_id)
+
+            # Unpack and check for command errors.
+            if use_cmd:
+                user_fields = _CURSOR_DOC_FIELDS
+                legacy_response = False
+            else:
+                user_fields = None
+                legacy_response = True
+            docs = unpack_res(
+                reply,
+                operation.cursor_id,
+                operation.codec_options,
+                legacy_response=legacy_response,
+                user_fields=user_fields,
+            )
+            if use_cmd:
+                first = docs[0]
+                operation.client._process_response(first, operation.session)
+                _check_command_response(first, sock_info.max_wire_version)
+        except Exception as exc:
+            if publish:
+                duration = datetime.now() - start
+                if isinstance(exc, (NotPrimaryError, OperationFailure)):
+                    failure = exc.details
+                else:
+                    failure = _convert_exception(exc)
+                listeners.publish_command_failure(
+                    duration,
+                    failure,
+                    operation.name,
+                    request_id,
+                    sock_info.address,
+                    service_id=sock_info.service_id,
+                )
+            raise
+
+        if publish:
+            duration = datetime.now() - start
+            # Must publish in find / getMore / explain command response
+            # format.
+            if use_cmd:
+                res = docs[0]
+            elif operation.name == "explain":
+                res = docs[0] if docs else {}
+            else:
+                res = {"cursor": {"id": reply.cursor_id, "ns": operation.namespace()}, "ok": 1}
+                if operation.name == "find":
+                    res["cursor"]["firstBatch"] = docs
+                else:
+                    res["cursor"]["nextBatch"] = docs
+            listeners.publish_command_success(
+                duration,
+                res,
+                operation.name,
+                request_id,
+                sock_info.address,
+                service_id=sock_info.service_id,
+            )
+
+        # Decrypt response.
+        client = operation.client
+        if client and client._encrypter:
+            if use_cmd:
+                decrypted = client._encrypter.decrypt(reply.raw_command_response())
+                docs = _decode_all_selective(decrypted, operation.codec_options, user_fields)
+
+        response: Response
+
+        if client._should_pin_cursor(operation.session) or operation.exhaust:
+            sock_info.pin_cursor()
+            if isinstance(reply, _OpMsg):
+                # In OP_MSG, the server keeps sending only if the
+                # more_to_come flag is set.
+                more_to_come = reply.more_to_come
+            else:
+                # In OP_REPLY, the server keeps sending until cursor_id is 0.
+                more_to_come = bool(operation.exhaust and reply.cursor_id)
+            if operation.sock_mgr:
+                operation.sock_mgr.update_exhaust(more_to_come)
+            response = PinnedResponse(
+                data=reply,
+                address=self._description.address,
+                socket_info=sock_info,
+                duration=duration,
+                request_id=request_id,
+                from_command=use_cmd,
+                docs=docs,
+                more_to_come=more_to_come,
+            )
+        else:
+            response = Response(
+                data=reply,
+                address=self._description.address,
+                duration=duration,
+                request_id=request_id,
+                from_command=use_cmd,
+                docs=docs,
+            )
+
+        return response
+
+    def get_socket(self, handler=None):
+        return self.pool.get_socket(handler)
+
+    @property
+    def description(self):
+        return self._description
+
+    @description.setter
+    def description(self, server_description):
+        assert server_description.address == self._description.address
+        self._description = server_description
+
+    @property
+    def pool(self):
+        return self._pool
+
+    def _split_message(self, message):
+        """Return request_id, data, max_doc_size.
+
+        :Parameters:
+          - `message`: (request_id, data, max_doc_size) or (request_id, data)
+        """
+        if len(message) == 3:
+            return message
+        else:
+            # get_more and kill_cursors messages don't include BSON documents.
+            request_id, data = message
+            return request_id, data, 0
+
+    def __repr__(self):
+        return "<%s %r>" % (self.__class__.__name__, self._description)