sensu-plugins-mongodb-mrtrotl 1.4.0

data/lib/pymongo/server_api.py

@@ -0,0 +1,170 @@
+# Copyright 2020-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.
+
+"""Support for MongoDB Stable API.
+
+.. _versioned-api-ref:
+
+MongoDB Stable API
+=====================
+
+Starting in MongoDB 5.0, applications can specify the server API version
+to use when creating a :class:`~pymongo.mongo_client.MongoClient`. Doing so
+ensures that the driver behaves in a manner compatible with that server API
+version, regardless of the server's actual release version.
+
+Declaring an API Version
+````````````````````````
+
+.. attention:: Stable API requires MongoDB >=5.0.
+
+To configure MongoDB Stable API, pass the ``server_api`` keyword option to
+:class:`~pymongo.mongo_client.MongoClient`::
+
+    >>> from pymongo.mongo_client import MongoClient
+    >>> from pymongo.server_api import ServerApi
+    >>>
+    >>> # Declare API version "1" for MongoClient "client"
+    >>> server_api = ServerApi('1')
+    >>> client = MongoClient(server_api=server_api)
+
+The declared API version is applied to all commands run through ``client``,
+including those sent through the generic
+:meth:`~pymongo.database.Database.command` helper.
+
+.. note:: Declaring an API version on the
+   :class:`~pymongo.mongo_client.MongoClient` **and** specifying stable
+   API options in :meth:`~pymongo.database.Database.command` command document
+   is not supported and will lead to undefined behaviour.
+
+To run any command without declaring a server API version or using a different
+API version, create a separate :class:`~pymongo.mongo_client.MongoClient`
+instance.
+
+Strict Mode
+```````````
+
+Configuring ``strict`` mode will cause the MongoDB server to reject all
+commands that are not part of the declared :attr:`ServerApi.version`. This
+includes command options and aggregation pipeline stages.
+
+For example::
+
+    >>> server_api = ServerApi('1', strict=True)
+    >>> client = MongoClient(server_api=server_api)
+    >>> client.test.command('count', 'test')
+    Traceback (most recent call last):
+    ...
+    pymongo.errors.OperationFailure: Provided apiStrict:true, but the command count is not in API Version 1, full error: {'ok': 0.0, 'errmsg': 'Provided apiStrict:true, but the command count is not in API Version 1', 'code': 323, 'codeName': 'APIStrictError'
+
+Detecting API Deprecations
+``````````````````````````
+
+The ``deprecationErrors`` option can be used to enable command failures
+when using functionality that is deprecated from the configured
+:attr:`ServerApi.version`. For example::
+
+    >>> server_api = ServerApi('1', deprecation_errors=True)
+    >>> client = MongoClient(server_api=server_api)
+
+Note that at the time of this writing, no deprecated APIs exist.
+
+Classes
+=======
+"""
+
+
+class ServerApiVersion:
+    """An enum that defines values for :attr:`ServerApi.version`.
+
+    .. versionadded:: 3.12
+    """
+
+    V1 = "1"
+    """Server API version "1"."""
+
+
+class ServerApi(object):
+    """MongoDB Stable API."""
+
+    def __init__(self, version, strict=None, deprecation_errors=None):
+        """Options to configure MongoDB Stable API.
+
+        :Parameters:
+          - `version`: The API version string. Must be one of the values in
+            :class:`ServerApiVersion`.
+          - `strict` (optional): Set to ``True`` to enable API strict mode.
+            Defaults to ``None`` which means "use the server's default".
+          - `deprecation_errors` (optional): Set to ``True`` to enable
+            deprecation errors. Defaults to ``None`` which means "use the
+            server's default".
+
+        .. versionadded:: 3.12
+        """
+        if version != ServerApiVersion.V1:
+            raise ValueError("Unknown ServerApi version: %s" % (version,))
+        if strict is not None and not isinstance(strict, bool):
+            raise TypeError(
+                "Wrong type for ServerApi strict, value must be an instance "
+                "of bool, not %s" % (type(strict),)
+            )
+        if deprecation_errors is not None and not isinstance(deprecation_errors, bool):
+            raise TypeError(
+                "Wrong type for ServerApi deprecation_errors, value must be "
+                "an instance of bool, not %s" % (type(deprecation_errors),)
+            )
+        self._version = version
+        self._strict = strict
+        self._deprecation_errors = deprecation_errors
+
+    @property
+    def version(self):
+        """The API version setting.
+
+        This value is sent to the server in the "apiVersion" field.
+        """
+        return self._version
+
+    @property
+    def strict(self):
+        """The API strict mode setting.
+
+        When set, this value is sent to the server in the "apiStrict" field.
+        """
+        return self._strict
+
+    @property
+    def deprecation_errors(self):
+        """The API deprecation errors setting.
+
+        When set, this value is sent to the server in the
+        "apiDeprecationErrors" field.
+        """
+        return self._deprecation_errors
+
+
+def _add_to_command(cmd, server_api):
+    """Internal helper which adds API versioning options to a command.
+
+    :Parameters:
+      - `cmd`: The command.
+      - `server_api` (optional): A :class:`ServerApi` or ``None``.
+    """
+    if not server_api:
+        return
+    cmd["apiVersion"] = server_api.version
+    if server_api.strict is not None:
+        cmd["apiStrict"] = server_api.strict
+    if server_api.deprecation_errors is not None:
+        cmd["apiDeprecationErrors"] = server_api.deprecation_errors

data/lib/pymongo/server_description.py

@@ -0,0 +1,285 @@
+# 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 one server the driver is connected to."""
+
+import time
+from typing import Any, Dict, Mapping, Optional, Set, Tuple
+
+from bson import EPOCH_NAIVE
+from bson.objectid import ObjectId
+from pymongo.hello import Hello
+from pymongo.server_type import SERVER_TYPE
+from pymongo.typings import _Address
+
+
+class ServerDescription(object):
+    """Immutable representation of one server.
+
+    :Parameters:
+      - `address`: A (host, port) pair
+      - `hello`: Optional Hello instance
+      - `round_trip_time`: Optional float
+      - `error`: Optional, the last error attempting to connect to the server
+    """
+
+    __slots__ = (
+        "_address",
+        "_server_type",
+        "_all_hosts",
+        "_tags",
+        "_replica_set_name",
+        "_primary",
+        "_max_bson_size",
+        "_max_message_size",
+        "_max_write_batch_size",
+        "_min_wire_version",
+        "_max_wire_version",
+        "_round_trip_time",
+        "_me",
+        "_is_writable",
+        "_is_readable",
+        "_ls_timeout_minutes",
+        "_error",
+        "_set_version",
+        "_election_id",
+        "_cluster_time",
+        "_last_write_date",
+        "_last_update_time",
+        "_topology_version",
+    )
+
+    def __init__(
+        self,
+        address: _Address,
+        hello: Optional[Hello] = None,
+        round_trip_time: Optional[float] = None,
+        error: Optional[Exception] = None,
+    ) -> None:
+        self._address = address
+        if not hello:
+            hello = Hello({})
+
+        self._server_type = hello.server_type
+        self._all_hosts = hello.all_hosts
+        self._tags = hello.tags
+        self._replica_set_name = hello.replica_set_name
+        self._primary = hello.primary
+        self._max_bson_size = hello.max_bson_size
+        self._max_message_size = hello.max_message_size
+        self._max_write_batch_size = hello.max_write_batch_size
+        self._min_wire_version = hello.min_wire_version
+        self._max_wire_version = hello.max_wire_version
+        self._set_version = hello.set_version
+        self._election_id = hello.election_id
+        self._cluster_time = hello.cluster_time
+        self._is_writable = hello.is_writable
+        self._is_readable = hello.is_readable
+        self._ls_timeout_minutes = hello.logical_session_timeout_minutes
+        self._round_trip_time = round_trip_time
+        self._me = hello.me
+        self._last_update_time = time.monotonic()
+        self._error = error
+        self._topology_version = hello.topology_version
+        if error:
+            details = getattr(error, "details", None)
+            if isinstance(details, dict):
+                self._topology_version = details.get("topologyVersion")
+
+        self._last_write_date: Optional[float]
+        if hello.last_write_date:
+            # Convert from datetime to seconds.
+            delta = hello.last_write_date - EPOCH_NAIVE
+            self._last_write_date = delta.total_seconds()
+        else:
+            self._last_write_date = None
+
+    @property
+    def address(self) -> _Address:
+        """The address (host, port) of this server."""
+        return self._address
+
+    @property
+    def server_type(self) -> int:
+        """The type of this server."""
+        return self._server_type
+
+    @property
+    def server_type_name(self) -> str:
+        """The server type as a human readable string.
+
+        .. versionadded:: 3.4
+        """
+        return SERVER_TYPE._fields[self._server_type]
+
+    @property
+    def all_hosts(self) -> Set[Tuple[str, int]]:
+        """List of hosts, passives, and arbiters known to this server."""
+        return self._all_hosts
+
+    @property
+    def tags(self) -> Mapping[str, Any]:
+        return self._tags
+
+    @property
+    def replica_set_name(self) -> Optional[str]:
+        """Replica set name or None."""
+        return self._replica_set_name
+
+    @property
+    def primary(self) -> Optional[Tuple[str, int]]:
+        """This server's opinion about who the primary is, or None."""
+        return self._primary
+
+    @property
+    def max_bson_size(self) -> int:
+        return self._max_bson_size
+
+    @property
+    def max_message_size(self) -> int:
+        return self._max_message_size
+
+    @property
+    def max_write_batch_size(self) -> int:
+        return self._max_write_batch_size
+
+    @property
+    def min_wire_version(self) -> int:
+        return self._min_wire_version
+
+    @property
+    def max_wire_version(self) -> int:
+        return self._max_wire_version
+
+    @property
+    def set_version(self) -> Optional[int]:
+        return self._set_version
+
+    @property
+    def election_id(self) -> Optional[ObjectId]:
+        return self._election_id
+
+    @property
+    def cluster_time(self) -> Optional[Mapping[str, Any]]:
+        return self._cluster_time
+
+    @property
+    def election_tuple(self) -> Tuple[Optional[int], Optional[ObjectId]]:
+        return self._set_version, self._election_id
+
+    @property
+    def me(self) -> Optional[Tuple[str, int]]:
+        return self._me
+
+    @property
+    def logical_session_timeout_minutes(self) -> Optional[int]:
+        return self._ls_timeout_minutes
+
+    @property
+    def last_write_date(self) -> Optional[float]:
+        return self._last_write_date
+
+    @property
+    def last_update_time(self) -> float:
+        return self._last_update_time
+
+    @property
+    def round_trip_time(self) -> Optional[float]:
+        """The current average latency or None."""
+        # This override is for unittesting only!
+        if self._address in self._host_to_round_trip_time:
+            return self._host_to_round_trip_time[self._address]
+
+        return self._round_trip_time
+
+    @property
+    def error(self) -> Optional[Exception]:
+        """The last error attempting to connect to the server, or None."""
+        return self._error
+
+    @property
+    def is_writable(self) -> bool:
+        return self._is_writable
+
+    @property
+    def is_readable(self) -> bool:
+        return self._is_readable
+
+    @property
+    def mongos(self) -> bool:
+        return self._server_type == SERVER_TYPE.Mongos
+
+    @property
+    def is_server_type_known(self) -> bool:
+        return self.server_type != SERVER_TYPE.Unknown
+
+    @property
+    def retryable_writes_supported(self) -> bool:
+        """Checks if this server supports retryable writes."""
+        return (
+            self._ls_timeout_minutes is not None
+            and self._server_type in (SERVER_TYPE.Mongos, SERVER_TYPE.RSPrimary)
+        ) or self._server_type == SERVER_TYPE.LoadBalancer
+
+    @property
+    def retryable_reads_supported(self) -> bool:
+        """Checks if this server supports retryable writes."""
+        return self._max_wire_version >= 6
+
+    @property
+    def topology_version(self) -> Optional[Mapping[str, Any]]:
+        return self._topology_version
+
+    def to_unknown(self, error: Optional[Exception] = None) -> "ServerDescription":
+        unknown = ServerDescription(self.address, error=error)
+        unknown._topology_version = self.topology_version
+        return unknown
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, ServerDescription):
+            return (
+                (self._address == other.address)
+                and (self._server_type == other.server_type)
+                and (self._min_wire_version == other.min_wire_version)
+                and (self._max_wire_version == other.max_wire_version)
+                and (self._me == other.me)
+                and (self._all_hosts == other.all_hosts)
+                and (self._tags == other.tags)
+                and (self._replica_set_name == other.replica_set_name)
+                and (self._set_version == other.set_version)
+                and (self._election_id == other.election_id)
+                and (self._primary == other.primary)
+                and (self._ls_timeout_minutes == other.logical_session_timeout_minutes)
+                and (self._error == other.error)
+            )
+
+        return NotImplemented
+
+    def __ne__(self, other: Any) -> bool:
+        return not self == other
+
+    def __repr__(self):
+        errmsg = ""
+        if self.error:
+            errmsg = ", error=%r" % (self.error,)
+        return "<%s %s server_type: %s, rtt: %s%s>" % (
+            self.__class__.__name__,
+            self.address,
+            self.server_type_name,
+            self.round_trip_time,
+            errmsg,
+        )
+
+    # For unittesting only. Use under no circumstances!
+    _host_to_round_trip_time: Dict = {}

data/lib/pymongo/server_selectors.py

@@ -0,0 +1,153 @@
+# Copyright 2014-2016 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.
+
+"""Criteria to select some ServerDescriptions from a TopologyDescription."""
+
+from pymongo.server_type import SERVER_TYPE
+
+
+class Selection(object):
+    """Input or output of a server selector function."""
+
+    @classmethod
+    def from_topology_description(cls, topology_description):
+        known_servers = topology_description.known_servers
+        primary = None
+        for sd in known_servers:
+            if sd.server_type == SERVER_TYPE.RSPrimary:
+                primary = sd
+                break
+
+        return Selection(
+            topology_description,
+            topology_description.known_servers,
+            topology_description.common_wire_version,
+            primary,
+        )
+
+    def __init__(self, topology_description, server_descriptions, common_wire_version, primary):
+        self.topology_description = topology_description
+        self.server_descriptions = server_descriptions
+        self.primary = primary
+        self.common_wire_version = common_wire_version
+
+    def with_server_descriptions(self, server_descriptions):
+        return Selection(
+            self.topology_description, server_descriptions, self.common_wire_version, self.primary
+        )
+
+    def secondary_with_max_last_write_date(self):
+        secondaries = secondary_server_selector(self)
+        if secondaries.server_descriptions:
+            return max(secondaries.server_descriptions, key=lambda sd: sd.last_write_date)
+
+    @property
+    def primary_selection(self):
+        primaries = [self.primary] if self.primary else []
+        return self.with_server_descriptions(primaries)
+
+    @property
+    def heartbeat_frequency(self):
+        return self.topology_description.heartbeat_frequency
+
+    @property
+    def topology_type(self):
+        return self.topology_description.topology_type
+
+    def __bool__(self):
+        return bool(self.server_descriptions)
+
+    def __getitem__(self, item):
+        return self.server_descriptions[item]
+
+
+def any_server_selector(selection):
+    return selection
+
+
+def readable_server_selector(selection):
+    return selection.with_server_descriptions(
+        [s for s in selection.server_descriptions if s.is_readable]
+    )
+
+
+def writable_server_selector(selection):
+    return selection.with_server_descriptions(
+        [s for s in selection.server_descriptions if s.is_writable]
+    )
+
+
+def secondary_server_selector(selection):
+    return selection.with_server_descriptions(
+        [s for s in selection.server_descriptions if s.server_type == SERVER_TYPE.RSSecondary]
+    )
+
+
+def arbiter_server_selector(selection):
+    return selection.with_server_descriptions(
+        [s for s in selection.server_descriptions if s.server_type == SERVER_TYPE.RSArbiter]
+    )
+
+
+def writable_preferred_server_selector(selection):
+    """Like PrimaryPreferred but doesn't use tags or latency."""
+    return writable_server_selector(selection) or secondary_server_selector(selection)
+
+
+def apply_single_tag_set(tag_set, selection):
+    """All servers matching one tag set.
+
+    A tag set is a dict. A server matches if its tags are a superset:
+    A server tagged {'a': '1', 'b': '2'} matches the tag set {'a': '1'}.
+
+    The empty tag set {} matches any server.
+    """
+
+    def tags_match(server_tags):
+        for key, value in tag_set.items():
+            if key not in server_tags or server_tags[key] != value:
+                return False
+
+        return True
+
+    return selection.with_server_descriptions(
+        [s for s in selection.server_descriptions if tags_match(s.tags)]
+    )
+
+
+def apply_tag_sets(tag_sets, selection):
+    """All servers match a list of tag sets.
+
+    tag_sets is a list of dicts. The empty tag set {} matches any server,
+    and may be provided at the end of the list as a fallback. So
+    [{'a': 'value'}, {}] expresses a preference for servers tagged
+    {'a': 'value'}, but accepts any server if none matches the first
+    preference.
+    """
+    for tag_set in tag_sets:
+        with_tag_set = apply_single_tag_set(tag_set, selection)
+        if with_tag_set:
+            return with_tag_set
+
+    return selection.with_server_descriptions([])
+
+
+def secondary_with_tags_server_selector(tag_sets, selection):
+    """All near-enough secondaries matching the tag sets."""
+    return apply_tag_sets(tag_sets, secondary_server_selector(selection))
+
+
+def member_with_tags_server_selector(tag_sets, selection):
+    """All near-enough members matching the tag sets."""
+    return apply_tag_sets(tag_sets, readable_server_selector(selection))

data/lib/pymongo/server_type.py

@@ -0,0 +1,32 @@
+# Copyright 2014-2015 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.
+
+"""Type codes for MongoDB servers."""
+
+from typing import NamedTuple
+
+
+class _ServerType(NamedTuple):
+    Unknown: int
+    Mongos: int
+    RSPrimary: int
+    RSSecondary: int
+    RSArbiter: int
+    RSOther: int
+    RSGhost: int
+    Standalone: int
+    LoadBalancer: int
+
+
+SERVER_TYPE = _ServerType(*range(9))