GG-26034: Renamed Affinity -> Partition Awareness (#5)

Author: isapego

.gitignore

@@ -3,3 +3,4 @@
 .pytest_cache
 pygridgain.egg-info
 ignite-log-*
+__pycache__

docs/readme.rst

@@ -140,7 +140,7 @@ Other `pytest` parameters:
 ``--timeout`` − timeout (in seconds) for each socket operation, including
 `connect`. Accepts integer or float value. Default is None (blocking mode),
 
-``--affinity-aware`` − experimental; off by default; turns on the affinity
+``--partition-aware`` − experimental; off by default; turns on the partition
 awareness: a way for the thin client to calculate a data placement for the
 given key.
 

pygridgain/cache.py

@@ -253,7 +253,7 @@ def get_best_node(
         """
         conn = self._client.random_node
 
-        if self.client.affinity_aware and key is not None:
+        if self.client.partition_aware and key is not None:
             if key_hint is None:
                 key_hint = AnyDataObject.map_python_type(key)
 

pygridgain/client.py

@@ -92,7 +92,7 @@ class Client:
     protocol_version: Optional[Tuple] = None
 
     def __init__(
-        self, compact_footer: bool = None, affinity_aware: bool = False,
+        self, compact_footer: bool = None, partition_aware: bool = False,
         **kwargs
     ):
         """
@@ -103,7 +103,7 @@ def __init__(
          Default is to use the same approach the server is using (None).
          GridGain binary protocol documentation on this topic:
          https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-schema
-        :param affinity_aware: (optional) try to calculate the exact data
+        :param partition_aware: (optional) try to calculate the exact data
          placement from the key before to issue the key operation to the
          server node:
          https://cwiki.apache.org/confluence/display/IGNITE/IEP-23%3A+Best+Effort+Affinity+for+thin+clients
@@ -114,7 +114,7 @@ def __init__(
         self._connection_args = kwargs
         self._nodes = []
         self._current_node = 0
-        self._affinity_aware = affinity_aware
+        self._partition_aware = partition_aware
         self.affinity_version = (0, 0)
 
     def get_protocol_version(self) -> Optional[Tuple]:
@@ -130,8 +130,8 @@ def get_protocol_version(self) -> Optional[Tuple]:
         return self.protocol_version
 
     @property
-    def affinity_aware(self):
-        return self._affinity_aware
+    def partition_aware(self):
+        return self._partition_aware
 
     def connect(self, *args):
         """

tests/conftest.py

@@ -81,16 +81,16 @@ def server3():
 
 @pytest.fixture(scope='module')
 def client(
-    node, timeout, affinity_aware, use_ssl, ssl_keyfile, ssl_certfile,
+    node, timeout, partition_aware, use_ssl, ssl_keyfile, ssl_certfile,
     ssl_ca_certfile, ssl_cert_reqs, ssl_ciphers, ssl_version,
     username, password,
 ):
-    yield from client0(node, timeout, affinity_aware, use_ssl, ssl_keyfile, ssl_certfile, ssl_ca_certfile,
+    yield from client0(node, timeout, partition_aware, use_ssl, ssl_keyfile, ssl_certfile, ssl_ca_certfile,
                        ssl_cert_reqs, ssl_ciphers, ssl_version, username, password)
 
 
 @pytest.fixture(scope='module')
-def client_affinity_aware(
+def client_partition_aware(
         node, timeout, use_ssl, ssl_keyfile, ssl_certfile,
         ssl_ca_certfile, ssl_cert_reqs, ssl_ciphers, ssl_version,
         username, password
@@ -100,7 +100,7 @@ def client_affinity_aware(
 
 
 @pytest.fixture(scope='module')
-def client_affinity_aware_single_server(
+def client_partition_aware_single_server(
         node, timeout, use_ssl, ssl_keyfile, ssl_certfile,
         ssl_ca_certfile, ssl_cert_reqs, ssl_ciphers, ssl_version,
         username, password
@@ -127,13 +127,13 @@ def log_init():
 
 
 def client0(
-    node, timeout, affinity_aware, use_ssl, ssl_keyfile, ssl_certfile,
+    node, timeout, partition_aware, use_ssl, ssl_keyfile, ssl_certfile,
     ssl_ca_certfile, ssl_cert_reqs, ssl_ciphers, ssl_version,
     username, password,
 ):
     client = Client(
         timeout=timeout,
-        affinity_aware=affinity_aware,
+        partition_aware=partition_aware,
         use_ssl=use_ssl,
         ssl_keyfile=ssl_keyfile,
         ssl_certfile=ssl_certfile,
@@ -175,7 +175,7 @@ def pytest_addoption(parser):
         )
     )
     parser.addoption(
-        '--affinity-aware',
+        '--partition-aware',
         action=BoolParser,
         nargs='?',
         default=False,
@@ -258,7 +258,7 @@ def pytest_generate_tests(metafunc):
                  '{host}:{port}'.format(host='127.0.0.1', port=10802),
                  '{host}:{port}'.format(host='127.0.0.1', port=10803)],
         'timeout': None,
-        'affinity_aware': False,
+        'partition_aware': False,
         'use_ssl': False,
         'ssl_keyfile': None,
         'ssl_certfile': None,

tests/test_affinity.py

@@ -27,12 +27,12 @@
 from pygridgain.datatypes.prop_codes import *
 
 
-def test_get_node_partitions(client_affinity_aware):
+def test_get_node_partitions(client_partition_aware):
 
-    conn = client_affinity_aware.random_node
+    conn = client_partition_aware.random_node
 
-    cache_1 = client_affinity_aware.get_or_create_cache('test_cache_1')
-    cache_2 = client_affinity_aware.get_or_create_cache({
+    cache_1 = client_partition_aware.get_or_create_cache('test_cache_1')
+    cache_2 = client_partition_aware.get_or_create_cache({
         PROP_NAME: 'test_cache_2',
         PROP_CACHE_KEY_CONFIGURATION: [
             {
@@ -41,9 +41,9 @@ def test_get_node_partitions(client_affinity_aware):
             }
         ],
     })
-    cache_3 = client_affinity_aware.get_or_create_cache('test_cache_3')
-    cache_4 = client_affinity_aware.get_or_create_cache('test_cache_4')
-    cache_5 = client_affinity_aware.get_or_create_cache('test_cache_5')
+    cache_3 = client_partition_aware.get_or_create_cache('test_cache_3')
+    cache_4 = client_partition_aware.get_or_create_cache('test_cache_4')
+    cache_5 = client_partition_aware.get_or_create_cache('test_cache_5')
 
     result = cache_get_node_partitions(
         conn,
@@ -115,9 +115,9 @@ def test_get_node_partitions(client_affinity_aware):
 
     ],
 )
-def test_affinity(client_affinity_aware, key, key_hint):
+def test_affinity(client_partition_aware, key, key_hint):
 
-    cache_1 = client_affinity_aware.get_or_create_cache({
+    cache_1 = client_partition_aware.get_or_create_cache({
         PROP_NAME: 'test_cache_1',
         PROP_CACHE_MODE: CacheMode.PARTITIONED,
     })
@@ -126,7 +126,7 @@ def test_affinity(client_affinity_aware, key, key_hint):
 
     best_node = cache_1.get_best_node(key, key_hint=key_hint)
 
-    for node in filter(lambda n: n.alive, client_affinity_aware._nodes):
+    for node in filter(lambda n: n.alive, client_partition_aware._nodes):
         result = cache_local_peek(
             node, cache_1.cache_id, key, key_hint=key_hint,
         )
@@ -142,9 +142,9 @@ def test_affinity(client_affinity_aware, key, key_hint):
     cache_1.destroy()
 
 
-def test_affinity_for_generic_object(client_affinity_aware):
+def test_affinity_for_generic_object(client_partition_aware):
 
-    cache_1 = client_affinity_aware.get_or_create_cache({
+    cache_1 = client_partition_aware.get_or_create_cache({
         PROP_NAME: 'test_cache_1',
         PROP_CACHE_MODE: CacheMode.PARTITIONED,
     })
@@ -166,7 +166,7 @@ class KeyClass(
 
     best_node = cache_1.get_best_node(key, key_hint=BinaryObject)
 
-    for node in filter(lambda n: n.alive, client_affinity_aware._nodes):
+    for node in filter(lambda n: n.alive, client_partition_aware._nodes):
         result = cache_local_peek(
             node, cache_1.cache_id, key, key_hint=BinaryObject,
         )
@@ -182,16 +182,16 @@ class KeyClass(
     cache_1.destroy()
 
 
-def test_affinity_for_generic_object_without_type_hints(client_affinity_aware):
+def test_affinity_for_generic_object_without_type_hints(client_partition_aware):
 
-    if client_affinity_aware.protocol_version < (1, 4, 0):
+    if client_partition_aware.protocol_version < (1, 4, 0):
         pytest.skip(
             'Best effort affinity is not supported by the protocol {}.'.format(
-                client_affinity_aware.protocol_version
+                client_partition_aware.protocol_version
             )
         )
 
-    cache_1 = client_affinity_aware.get_or_create_cache({
+    cache_1 = client_partition_aware.get_or_create_cache({
         PROP_NAME: 'test_cache_1',
         PROP_CACHE_MODE: CacheMode.PARTITIONED,
     })
@@ -213,7 +213,7 @@ class KeyClass(
 
     best_node = cache_1.get_best_node(key)
 
-    for node in filter(lambda n: n.alive, client_affinity_aware._nodes):
+    for node in filter(lambda n: n.alive, client_partition_aware._nodes):
         result = cache_local_peek(
             node, cache_1.cache_id, key
         )

tests/test_affinity_bad_servers.py

@@ -19,7 +19,7 @@
 
 
 def test_client_with_multiple_bad_servers():
-    client = Client(affinity_aware=True)
+    client = Client(partition_aware=True)
     with pytest.raises(ReconnectError) as e_info:
         client.connect([("127.0.0.1", 10900), ("127.0.0.1", 10901)])
     assert str(e_info.value) == "Can not connect."

tests/test_affinity_request_routing.py

@@ -27,9 +27,9 @@
 @pytest.mark.parametrize("key,grid_idx", [(1, 3), (2, 1), (3, 1), (4, 3), (5, 1), (6, 3), (11, 2), (13, 2), (19, 2)])
 @pytest.mark.parametrize("backups", [0, 1, 2, 3])
 def test_cache_operation_on_primitive_key_routes_request_to_primary_node(
-        request, key, grid_idx, backups, client_affinity_aware):
+        request, key, grid_idx, backups, client_partition_aware):
 
-    cache = client_affinity_aware.get_or_create_cache({
+    cache = client_partition_aware.get_or_create_cache({
         PROP_NAME: request.node.name + str(backups),
         PROP_BACKUPS_NUMBER: backups,
     })
@@ -90,7 +90,7 @@ def test_cache_operation_on_complex_key_routes_request_to_primary_node():
 @pytest.mark.parametrize("key,grid_idx", [(1, 2), (2, 1), (3, 1), (4, 2), (5, 2), (6, 3)])
 @pytest.mark.skip(reason="GG-25823: Custom key objects are not supported yet")
 def test_cache_operation_on_custom_affinity_key_routes_request_to_primary_node(
-        request, client_affinity_aware, key, grid_idx):
+        request, client_partition_aware, key, grid_idx):
     class AffinityTestType1(
         metaclass=GenericObjectMeta,
         type_name='AffinityTestType1',
@@ -110,7 +110,7 @@ class AffinityTestType1(
             },
         ],
     }
-    cache = client_affinity_aware.create_cache(cache_config)
+    cache = client_partition_aware.create_cache(cache_config)
 
     # noinspection PyArgumentList
     key_obj = AffinityTestType1(
@@ -125,7 +125,7 @@ class AffinityTestType1(
 
 
 def test_cache_operation_routed_to_new_cluster_node(request):
-    client = Client(affinity_aware=True)
+    client = Client(partition_aware=True)
     client.connect([("127.0.0.1", 10801), ("127.0.0.1", 10802), ("127.0.0.1", 10803), ("127.0.0.1", 10804)])
     cache = client.get_or_create_cache(request.node.name)
     key = 12
@@ -149,12 +149,12 @@ def check_grid_idx():
         kill_process_tree(srv.pid)
 
 
-def test_unsupported_affinity_cache_operation_routed_to_random_node(client_affinity_aware):
-    verify_random_node(client_affinity_aware.get_cache("custom-affinity"))
+def test_unsupported_affinity_cache_operation_routed_to_random_node(client_partition_aware):
+    verify_random_node(client_partition_aware.get_cache("custom-affinity"))
 
 
-def test_replicated_cache_operation_routed_to_random_node(request, client_affinity_aware):
-    cache = client_affinity_aware.get_or_create_cache({
+def test_replicated_cache_operation_routed_to_random_node(request, client_partition_aware):
+    cache = client_partition_aware.get_or_create_cache({
         PROP_NAME: request.node.name,
         PROP_CACHE_MODE: CacheMode.REPLICATED,
     })

tests/test_affinity_single_connection.py

@@ -18,8 +18,8 @@
 from tests.util import get_request_grid_idx
 
 
-def test_all_cache_operations_with_affinity_aware_client_on_single_server(request, client_affinity_aware_single_server):
-    cache = client_affinity_aware_single_server.get_or_create_cache(request.node.name)
+def test_all_cache_operations_with_partition_aware_client_on_single_server(request, client_partition_aware_single_server):
+    cache = client_partition_aware_single_server.get_or_create_cache(request.node.name)
     key = 1
     key2 = 2