Rename RPC implementation classes for better organisation (typedb#182)

## What is the goal of this PR?

Our RPC classes used the prefix "RPC", but for autocompletion purposes, it's better for that to be a suffix. So we made it a suffix.

## What are the changes implemented in this PR?

Rename RPC* to *RPC across the rpc package.

Author: Alex Walker

grakn/client.py

@@ -28,11 +28,11 @@
 from grakn.common.exception import GraknClientException  # noqa # pylint: disable=unused-import
 from grakn.concept.type.value_type import ValueType  # noqa # pylint: disable=unused-import
 from grakn.options import GraknOptions
-from grakn.rpc.cluster.address import Address
-from grakn.rpc.cluster.database_manager import _RPCDatabaseManagerCluster
-from grakn.rpc.cluster.session import _RPCSessionCluster
-from grakn.rpc.database_manager import DatabaseManager, _RPCDatabaseManager
-from grakn.rpc.session import Session, SessionType, _RPCSession
+from grakn.rpc.cluster.server_address import ServerAddress
+from grakn.rpc.cluster.database_manager import _DatabaseManagerClusterRPC
+from grakn.rpc.cluster.session import _SessionClusterRPC
+from grakn.rpc.database_manager import DatabaseManager, _DatabaseManagerRPC
+from grakn.rpc.session import Session, SessionType, _SessionRPC
 from grakn.rpc.transaction import TransactionType  # noqa # pylint: disable=unused-import
 
 
@@ -41,11 +41,11 @@ class GraknClient(ABC):
 
     @staticmethod
     def core(address=DEFAULT_ADDRESS) -> "GraknClient":
-        return _RPCGraknClient(address)
+        return _ClientRPC(address)
 
     @staticmethod
     def cluster(addresses: List[str]) -> "GraknClient":
-        return _RPCGraknClientCluster(addresses)
+        return _ClientClusterRPC(addresses)
 
     @abstractmethod
     def session(self, database: str, session_type: SessionType, options: GraknOptions = None) -> Session:
@@ -72,18 +72,18 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         pass
 
 
-class _RPCGraknClient(GraknClient):
+class _ClientRPC(GraknClient):
 
     def __init__(self, address: str):
         self._address = address
         self._channel = grpc.insecure_channel(self._address)
-        self._databases = _RPCDatabaseManager(self._channel)
+        self._databases = _DatabaseManagerRPC(self._channel)
         self._is_open = True
 
     def session(self, database: str, session_type: SessionType, options=None) -> Session:
         if not options:
             options = GraknOptions.core()
-        return _RPCSession(self, database, session_type, options)
+        return _SessionRPC(self, database, session_type, options)
 
     def databases(self):
         return self._databases
@@ -110,18 +110,18 @@ def channel(self):
 
 
 # _RPCGraknClientCluster must live in this package because of circular ref with GraknClient
-class _RPCGraknClientCluster(GraknClient):
+class _ClientClusterRPC(GraknClient):
 
     def __init__(self, addresses: List[str]):
-        self._core_clients: Dict[Address.Server, _RPCGraknClient] = {addr: _RPCGraknClient(addr.client()) for addr in self._discover_cluster(addresses)}
+        self._core_clients: Dict[ServerAddress, _ClientRPC] = {addr: _ClientRPC(addr.client()) for addr in self._discover_cluster(addresses)}
         self._grakn_cluster_grpc_stubs = {addr: GraknClusterStub(client.channel()) for (addr, client) in self._core_clients.items()}
-        self._databases = _RPCDatabaseManagerCluster({addr: client.databases() for (addr, client) in self._core_clients.items()})
+        self._databases = _DatabaseManagerClusterRPC({addr: client.databases() for (addr, client) in self._core_clients.items()})
         self._is_open = True
 
     def session(self, database: str, session_type: SessionType, options=None) -> Session:
         if not options:
             options = GraknOptions.cluster()
-        return _RPCSessionCluster(self, database, session_type, options)
+        return _SessionClusterRPC(self, database, session_type, options)
 
     def databases(self) -> DatabaseManager:
         return self._databases
@@ -140,23 +140,23 @@ def __enter__(self):
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
-    def cluster_members(self) -> Set[Address.Server]:
+    def cluster_members(self) -> Set[ServerAddress]:
         return set(self._core_clients.keys())
 
-    def core_client(self, address: Address.Server) -> _RPCGraknClient:
+    def core_client(self, address: ServerAddress) -> _ClientRPC:
         return self._core_clients.get(address)
 
-    def grakn_cluster_grpc_stub(self, address: Address.Server) -> GraknClusterStub:
+    def grakn_cluster_grpc_stub(self, address: ServerAddress) -> GraknClusterStub:
         return self._grakn_cluster_grpc_stubs.get(address)
 
-    def _discover_cluster(self, addresses: List[str]) -> Set[Address.Server]:
+    def _discover_cluster(self, addresses: List[str]) -> Set[ServerAddress]:
         for address in addresses:
             try:
-                with _RPCGraknClient(address) as client:
+                with _ClientRPC(address) as client:
                     print("Performing cluster discovery to %s..." % address)
                     grakn_cluster_stub = GraknClusterStub(client.channel())
                     res = grakn_cluster_stub.cluster_discover(cluster_proto.Cluster.Discover.Req())
-                    members = set([Address.Server.parse(srv) for srv in res.servers])
+                    members = set([ServerAddress.parse(srv) for srv in res.servers])
                     print("Discovered %s" % [str(member) for member in members])
                     return members
             except RpcError:

grakn/rpc/cluster/address.py

@@ -20,13 +20,13 @@
 from typing import Dict, List
 
 from grakn.common.exception import GraknClientException
-from grakn.rpc.cluster.address import Address
-from grakn.rpc.database_manager import DatabaseManager, _RPCDatabaseManager
+from grakn.rpc.cluster.server_address import ServerAddress
+from grakn.rpc.database_manager import DatabaseManager, _DatabaseManagerRPC
 
 
-class _RPCDatabaseManagerCluster(DatabaseManager):
+class _DatabaseManagerClusterRPC(DatabaseManager):
 
-    def __init__(self, database_managers: Dict[Address.Server, "_RPCDatabaseManager"]):
+    def __init__(self, database_managers: Dict[ServerAddress, "_DatabaseManagerRPC"]):
         assert database_managers
         self._database_managers = database_managers
 

grakn/rpc/cluster/database_manager.py

@@ -0,0 +1,107 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#
+
+from typing import Dict, Optional
+import grakn_protocol.protobuf.cluster.database_pb2 as database_proto
+
+from grakn.rpc.cluster.server_address import ServerAddress
+
+
+class ReplicaInfo:
+
+    def __init__(self, replicas: Dict["ReplicaInfo.Replica.Id", "ReplicaInfo.Replica"]):
+        assert replicas
+        self._replicas = replicas
+
+    @staticmethod
+    def of_proto(res: database_proto.Database.Discover.Res) -> "ReplicaInfo":
+        replica_map: Dict["ReplicaInfo.Replica.Id", "ReplicaInfo.Replica"] = {}
+        for replica_proto in res.replicas:
+            replica_id = ReplicaInfo.Replica.Id(ServerAddress.parse(replica_proto.address), replica_proto.database)
+            replica_map[replica_id] = ReplicaInfo.Replica.of_proto(replica_proto)
+        return ReplicaInfo(replica_map)
+
+    def primary_replica(self) -> Optional["ReplicaInfo.Replica"]:
+        primaries = [replica for replica in self._replicas.values() if replica.is_primary()]
+        return max(primaries, key=lambda r: r.term) if primaries else None
+
+    def replicas(self):
+        return self._replicas.values()
+
+    class Replica:
+
+        def __init__(self, replica_id: "ReplicaInfo.Replica.Id", term: int, is_primary: bool):
+            self._replica_id = replica_id
+            self._term = term
+            self._is_primary = is_primary
+
+        @staticmethod
+        def of_proto(replica_proto: database_proto.Database.Discover.Res.Replica) -> "ReplicaInfo.Replica":
+            return ReplicaInfo.Replica(
+                replica_id=ReplicaInfo.Replica.Id(ServerAddress.parse(replica_proto.address), replica_proto.database),
+                term=replica_proto.term,
+                is_primary=replica_proto.is_primary
+            )
+
+        def replica_id(self) -> "ReplicaInfo.Replica.Id":
+            return self._replica_id
+
+        def term(self) -> int:
+            return self._term
+
+        def is_primary(self) -> bool:
+            return self._is_primary
+
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if not other or type(self) != type(other):
+                return False
+            return self._term == other.term() and self._is_primary == other.is_primary()
+
+        def __hash__(self):
+            return hash((self._is_primary, self._term))
+
+        def __str__(self):
+            return "%s:%s:%d" % (str(self._replica_id), "P" if self._is_primary else "S", self._term)
+
+        class Id:
+
+            def __init__(self, address: ServerAddress, database: str):
+                self._address = address
+                self._database = database
+
+            def address(self) -> ServerAddress:
+                return self._address
+
+            def database(self) -> str:
+                return self._database
+
+            def __eq__(self, other):
+                if self is other:
+                    return True
+                if not other or type(self) != type(other):
+                    return False
+                return self._address == other.address() and self._database == other.database()
+
+            def __hash__(self):
+                return hash((self._address, self._database))
+
+            def __str__(self):
+                return "%s/%s" % (str(self._address), self._database)

grakn/rpc/cluster/replica_info.py

@@ -0,0 +1,59 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#
+
+
+class ServerAddress:
+
+    def __init__(self, host: str, client_port: int, server_port: int):
+        self._host = host
+        self._client_port = client_port
+        self._server_port = server_port
+
+    def host(self) -> str:
+        return self._host
+
+    def client_port(self) -> int:
+        return self._client_port
+
+    def server_port(self) -> int:
+        return self._server_port
+
+    def server(self) -> str:
+        return "%s:%d" % (self._host, self._server_port)
+
+    def client(self) -> str:
+        return "%s:%d" % (self._host, self._client_port)
+
+    def __eq__(self, other):
+        if other is self:
+            return True
+        if not other or type(self) != type(other):
+            return False
+        return self._client_port == other.client_port() and self._server_port == other.server_port() and self._host == other.host()
+
+    def __hash__(self):
+        return hash((self._host, self._client_port, self._server_port))
+
+    def __str__(self):
+        return "%s:%d:%d" % (self._host, self._client_port, self._server_port)
+
+    @staticmethod
+    def parse(address: str) -> "ServerAddress":
+        s = address.split(":")
+        return ServerAddress(host=s[0], client_port=int(s[1]), server_port=int(s[2]))