api: allow to require protocol version and features

Allow to set required_protocol_version and required_protocol_features on
connection initialization to ensure that a Tarantool server provides
expected features. The approach is similar to go-tarantool [1]. We do
not check client protocol version and features, similar to the core
Tarantool [1, 2].

1. tarantool/go-tarantool#226
2. tarantool/tarantool#7953

Closes #267

Author: DifferentialOrange

tarantool/connection.py

@@ -65,6 +65,9 @@
     IPROTO_FEATURE_TRANSACTIONS,
     IPROTO_FEATURE_ERROR_EXTENSION,
     IPROTO_FEATURE_WATCHERS,
+    IPROTO_FEATURE_PAGINATION,
+    IPROTO_FEATURE_SPACE_AND_INDEX_NAMES,
+    IPROTO_FEATURE_WATCH_ONCE,
     IPROTO_CHUNK,
     AUTH_TYPE_CHAP_SHA1,
     AUTH_TYPE_PAP_SHA256,
@@ -607,7 +610,9 @@ def __init__(self, host, port,
                  packer_factory=default_packer_factory,
                  unpacker_factory=default_unpacker_factory,
                  auth_type=None,
-                 fetch_schema=True):
+                 fetch_schema=True,
+                 required_protocol_version=None,
+                 required_protocol_features=None):
         """
         :param host: Server hostname or IP address. Use ``None`` for
             Unix sockets.
@@ -776,6 +781,14 @@ def __init__(self, host, port,
             :meth:`~tarantool.Connection.space`.
         :type fetch_schema: :obj:`bool`, optional
 
+        :param required_protocol_version: Minimal protocol version that
+            should be supported by Tarantool server.
+        :type required_protocol_version: :obj:`int` or :obj:`None`, optional
+
+        :param required_protocol_features: List of protocol features that
+            should be supported by Tarantool server.
+        :type required_protocol_version: :obj:`list` or :obj:`None`, optional
+
         :raise: :exc:`~tarantool.error.ConfigurationError`,
             :meth:`~tarantool.Connection.connect` exceptions
 
@@ -830,6 +843,9 @@ def __init__(self, host, port,
             IPROTO_FEATURE_TRANSACTIONS: False,
             IPROTO_FEATURE_ERROR_EXTENSION: False,
             IPROTO_FEATURE_WATCHERS: False,
+            IPROTO_FEATURE_PAGINATION: False,
+            IPROTO_FEATURE_SPACE_AND_INDEX_NAMES: False,
+            IPROTO_FEATURE_WATCH_ONCE: False,
         }
         self._packer_factory_impl = packer_factory
         self._unpacker_factory_impl = unpacker_factory
@@ -838,6 +854,8 @@ def __init__(self, host, port,
         self.version_id = None
         self.uuid = None
         self._salt = None
+        self.required_protocol_version = required_protocol_version
+        self.required_protocol_features = copy(required_protocol_features)
 
         if connect_now:
             self.connect()
@@ -2080,6 +2098,20 @@ def _check_features(self):
         self.server_protocol_version = server_protocol_version
         self.server_features = copy(server_features)
 
+        if self.required_protocol_version is not None:
+            if server_protocol_version is None or \
+               server_protocol_version < self.required_protocol_version:
+                raise ConfigurationError(f'Server protocol version is {server_protocol_version}, '
+                                         f'protocol version {self.required_protocol_version} '
+                                         'is required')
+
+        if self.required_protocol_features is not None:
+            failed_features = [val for val in self.required_protocol_features
+                               if val not in server_features]
+            if len(failed_features) > 0:
+                str_features = ', '.join([str(v) for v in failed_features])
+                raise ConfigurationError(f'Server missing protocol features with id {str_features}')
+
         if server_protocol_version is not None:
             self._protocol_version = min(server_protocol_version,
                                          CONNECTOR_IPROTO_VERSION)

test/suites/lib/skip.py

@@ -277,3 +277,19 @@ def skip_or_run_constraints_test(func):
 
     return skip_or_run_test_tarantool(func, '2.10.0',
                                       'does not support schema constraints')
+
+
+def skip_or_run_iproto_basic_features_test(func):
+    """
+    Decorator to skip or run tests related to iproto ID requests,
+    protocol version and features.
+
+    Tarantool supports iproto ID requests only since 2.10.0 version.
+    Protocol version is 3 for Tarantool 2.10.0,
+    IPROTO_FEATURE_STREAMS, IPROTO_FEATURE_TRANSACTIONS
+    and IPROTO_FEATURE_ERROR_EXTENSION are supported in Tarantool 2.10.0.
+    See https://github.com/tarantool/tarantool/issues/6253
+    """
+
+    return skip_or_run_test_tarantool(func, '2.10.0',
+                                      'does not support iproto ID and iproto basic features')

test/suites/test_protocol.py

@@ -15,10 +15,15 @@
     IPROTO_FEATURE_TRANSACTIONS,
     IPROTO_FEATURE_ERROR_EXTENSION,
     IPROTO_FEATURE_WATCHERS,
+    IPROTO_FEATURE_PAGINATION,
+    IPROTO_FEATURE_SPACE_AND_INDEX_NAMES,
+    IPROTO_FEATURE_WATCH_ONCE,
 )
+from tarantool.error import NetworkError
 from tarantool.utils import greeting_decode, version_id
 
 from .lib.tarantool_server import TarantoolServer
+from .lib.skip import skip_or_run_iproto_basic_features_test
 
 
 class TestSuiteProtocol(unittest.TestCase):
@@ -91,6 +96,35 @@ def test_04_protocol(self):
         self.assertEqual(self.con._features[IPROTO_FEATURE_STREAMS], False)
         self.assertEqual(self.con._features[IPROTO_FEATURE_TRANSACTIONS], False)
         self.assertEqual(self.con._features[IPROTO_FEATURE_WATCHERS], False)
+        self.assertEqual(self.con._features[IPROTO_FEATURE_PAGINATION], False)
+        self.assertEqual(self.con._features[IPROTO_FEATURE_SPACE_AND_INDEX_NAMES], False)
+        self.assertEqual(self.con._features[IPROTO_FEATURE_WATCH_ONCE], False)
+
+    @skip_or_run_iproto_basic_features_test
+    def test_protocol_requirement(self):
+        try:
+            c = tarantool.Connection(self.srv.host, self.srv.args['primary'],
+                                     required_protocol_version=3,
+                                     required_protocol_features=[IPROTO_FEATURE_STREAMS,
+                                                                 IPROTO_FEATURE_TRANSACTIONS,
+                                                                 IPROTO_FEATURE_ERROR_EXTENSION])
+            c.close()
+        except Exception as exc:  # pylint: disable=bad-option-value,broad-exception-caught,broad-except
+            self.fail(f'Connection create have raised Exception: {repr(exc)}')
+
+    def test_protocol_version_requirement_fail(self):
+        with self.assertRaisesRegex(NetworkError,  # ConfigurationError is wrapped in NetworkError
+                                    'protocol version 100500 is required'):
+            c = tarantool.Connection(self.srv.host, self.srv.args['primary'],
+                                     required_protocol_version=100500)
+            c.close()
+
+    def test_protocol_features_requirement_fail(self):
+        with self.assertRaisesRegex(NetworkError,  # ConfigurationError is wrapped in NetworkError
+                                    'Server missing protocol features with id 100500, 500100'):
+            c = tarantool.Connection(self.srv.host, self.srv.args['primary'],
+                                 required_protocol_features=[100500, 500100])
+            c.close()
 
     @classmethod
     def tearDownClass(cls):