refactor: rename peer_id: Peer variables/methods to peer: Peer

hathor/builder/builder.py

@@ -96,7 +96,7 @@ class StorageType(Enum):
 
 class BuildArtifacts(NamedTuple):
     """Artifacts created by a builder."""
-    peer_id: Peer
+    peer: Peer
     settings: HathorSettingsType
     rng: Random
     reactor: Reactor
@@ -137,7 +137,7 @@ def __init__(self) -> None:
         self._checkpoints: Optional[list[Checkpoint]] = None
         self._capabilities: Optional[list[str]] = None
 
-        self._peer_id: Optional[Peer] = None
+        self._peer: Optional[Peer] = None
         self._network: Optional[str] = None
         self._cmdline: str = ''
 
@@ -212,7 +212,7 @@ def build(self) -> BuildArtifacts:
         reactor = self._get_reactor()
         pubsub = self._get_or_create_pubsub()
 
-        peer_id = self._get_peer_id()
+        peer = self._get_peer()
 
         execution_manager = self._get_or_create_execution_manager()
         consensus_algorithm = self._get_or_create_consensus()
@@ -256,15 +256,15 @@ def build(self) -> BuildArtifacts:
             pubsub=pubsub,
             consensus_algorithm=consensus_algorithm,
             daa=daa,
-            peer_id=peer_id,
+            peer=peer,
             tx_storage=tx_storage,
             p2p_manager=p2p_manager,
             event_manager=event_manager,
             wallet=wallet,
             rng=self._rng,
             checkpoints=self._checkpoints,
             capabilities=self._capabilities,
-            environment_info=get_environment_info(self._cmdline, peer_id.id),
+            environment_info=get_environment_info(self._cmdline, peer.id),
             bit_signaling_service=bit_signaling_service,
             verification_service=verification_service,
             cpu_mining_service=cpu_mining_service,
@@ -284,7 +284,7 @@ def build(self) -> BuildArtifacts:
             stratum_factory = self._create_stratum_server(manager)
 
         self.artifacts = BuildArtifacts(
-            peer_id=peer_id,
+            peer=peer,
             settings=settings,
             rng=self._rng,
             reactor=reactor,
@@ -337,9 +337,9 @@ def set_capabilities(self, capabilities: list[str]) -> 'Builder':
         self._capabilities = capabilities
         return self
 
-    def set_peer_id(self, peer_id: Peer) -> 'Builder':
+    def set_peer(self, peer: Peer) -> 'Builder':
         self.check_if_can_modify()
-        self._peer_id = peer_id
+        self._peer = peer
         return self
 
     def _get_or_create_settings(self) -> HathorSettingsType:
@@ -361,10 +361,10 @@ def _get_soft_voided_tx_ids(self) -> set[bytes]:
 
         return set(settings.SOFT_VOIDED_TX_IDS)
 
-    def _get_peer_id(self) -> Peer:
-        if self._peer_id is not None:
-            return self._peer_id
-        raise ValueError('peer_id not set')
+    def _get_peer(self) -> Peer:
+        if self._peer is not None:
+            return self._peer
+        raise ValueError('peer not set')
 
     def _get_or_create_execution_manager(self) -> ExecutionManager:
         if self._execution_manager is None:
@@ -416,7 +416,7 @@ def _get_or_create_p2p_manager(self) -> ConnectionsManager:
 
         enable_ssl = True
         reactor = self._get_reactor()
-        my_peer = self._get_peer_id()
+        my_peer = self._get_peer()
 
         assert self._network is not None
 
@@ -510,12 +510,12 @@ def _get_or_create_event_storage(self) -> EventStorage:
 
     def _get_or_create_event_manager(self) -> EventManager:
         if self._event_manager is None:
-            peer_id = self._get_peer_id()
+            peer = self._get_peer()
             settings = self._get_or_create_settings()
             reactor = self._get_reactor()
             storage = self._get_or_create_event_storage()
             factory = EventWebsocketFactory(
-                peer_id=not_none(peer_id.id),
+                peer_id=not_none(peer.id),
                 network=settings.NETWORK_NAME,
                 reactor=reactor,
                 event_storage=storage,

hathor/builder/cli_builder.py

@@ -98,15 +98,15 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
         self.log = logger.new()
         self.reactor = reactor
 
-        peer_id = Peer.create_from_json_path(self._args.peer) if self._args.peer else Peer()
+        peer = Peer.create_from_json_path(self._args.peer) if self._args.peer else Peer()
         python = f'{platform.python_version()}-{platform.python_implementation()}'
 
         self.log.info(
             'hathor-core v{hathor}',
             hathor=hathor.__version__,
             pid=os.getpid(),
             genesis=get_genesis_short_hash(),
-            my_peer_id=str(peer_id.id),
+            my_peer_id=str(peer.id),
             python=python,
             platform=platform.platform(),
             settings=settings_source,
@@ -225,7 +225,7 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
 
         if self._args.x_enable_event_queue:
             self.event_ws_factory = EventWebsocketFactory(
-                peer_id=not_none(peer_id.id),
+                peer_id=not_none(peer.id),
                 network=network,
                 reactor=reactor,
                 event_storage=event_storage
@@ -307,7 +307,7 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             settings=settings,
             reactor=reactor,
             network=network,
-            my_peer=peer_id,
+            my_peer=peer,
             pubsub=pubsub,
             ssl=True,
             whitelist_only=False,
@@ -348,13 +348,13 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             pubsub=pubsub,
             consensus_algorithm=consensus_algorithm,
             daa=daa,
-            peer_id=peer_id,
+            peer=peer,
             tx_storage=tx_storage,
             p2p_manager=p2p_manager,
             event_manager=event_manager,
             wallet=self.wallet,
             checkpoints=settings.CHECKPOINTS,
-            environment_info=get_environment_info(args=str(self._args), peer_id=peer_id.id),
+            environment_info=get_environment_info(args=str(self._args), peer_id=peer.id),
             full_verification=full_verification,
             enable_event_queue=self._args.x_enable_event_queue,
             bit_signaling_service=bit_signaling_service,

hathor/cli/peer_id.py

@@ -22,7 +22,7 @@
 def main() -> None:
     from hathor.p2p.peer import Peer
 
-    peer_id = Peer()
-    data = peer_id.to_json(include_private_key=True)
+    peer = Peer()
+    data = peer.to_json(include_private_key=True)
     txt = json.dumps(data, indent=4)
     print(txt)

hathor/cli/run_node.py

@@ -219,7 +219,7 @@ def prepare(self, *, register_resources: bool = True) -> None:
 
         from hathor.builder.builder import BuildArtifacts
         self.artifacts = BuildArtifacts(
-            peer_id=self.manager.my_peer,
+            peer=self.manager.my_peer,
             settings=settings,
             rng=self.manager.rng,
             reactor=self.manager.reactor,

hathor/manager.py

@@ -96,7 +96,7 @@ def __init__(
         pubsub: PubSubManager,
         consensus_algorithm: ConsensusAlgorithm,
         daa: DifficultyAdjustmentAlgorithm,
-        peer_id: Peer,
+        peer: Peer,
         tx_storage: TransactionStorage,
         p2p_manager: ConnectionsManager,
         event_manager: EventManager,
@@ -119,7 +119,7 @@ def __init__(
     ) -> None:
         """
         :param reactor: Twisted reactor which handles the mainloop and the events.
-        :param peer_id: Id of this node.
+        :param peer: Peer object, with peer-id of this node.
         :param network: Name of the network this node participates. Usually it is either testnet or mainnet.
         :type network: string
 
@@ -163,7 +163,7 @@ def __init__(
         # Remote address, which can be different from local address.
         self.remote_address = None
 
-        self.my_peer = peer_id
+        self.my_peer = peer
         self.network = network
 
         self.is_started: bool = False
@@ -976,7 +976,7 @@ def on_new_tx(
     def has_sync_version_capability(self) -> bool:
         return self._settings.CAPABILITY_SYNC_VERSION in self.capabilities
 
-    def add_peer_to_whitelist(self, peer_id):
+    def add_peer_to_whitelist(self, peer_id: str) -> None:
         if not self._settings.ENABLE_PEER_WHITELIST:
             return
 

hathor/p2p/peer.py

@@ -440,14 +440,14 @@ def reload_entrypoints_from_source_file(self) -> None:
         if not self.source_file:
             raise Exception('Trying to reload entrypoints but no peer config file was provided.')
 
-        new_peer_id = Peer.create_from_json_path(self.source_file)
+        new_peer = Peer.create_from_json_path(self.source_file)
 
-        if new_peer_id.id != self.id:
+        if new_peer.id != self.id:
             self._log.error(
                 'Ignoring peer id file update because the peer_id does not match.',
                 current_peer_id=self.id,
-                new_peer_id=new_peer_id.id,
+                new_peer_id=new_peer.id,
             )
             return
 
-        self.entrypoints = new_peer_id.entrypoints
+        self.entrypoints = new_peer.entrypoints

hathor/simulator/simulator.py

@@ -81,7 +81,7 @@ def get_default_builder(self) -> Builder:
         """
         return Builder() \
             .set_network(self._network) \
-            .set_peer_id(Peer()) \
+            .set_peer(Peer()) \
             .set_soft_voided_tx_ids(set()) \
             .enable_full_verification() \
             .enable_sync_v1() \

tests/event/event_simulation_tester.py

@@ -34,14 +34,14 @@ class BaseEventSimulationTester(SimulatorTestCase):
     builder: Builder
 
     def _create_artifacts(self) -> None:
-        peer_id = Peer()
-        builder = self.builder.set_peer_id(peer_id) \
+        peer = Peer()
+        builder = self.builder.set_peer(peer) \
             .disable_full_verification() \
             .enable_event_queue()
         artifacts = self.simulator.create_artifacts(builder)
 
-        assert peer_id.id is not None
-        self.peer_id: str = peer_id.id
+        assert peer.id is not None
+        self.peer_id: str = peer.id
         self.manager = artifacts.manager
         self.manager.allow_mining_without_peers()
         self.settings = artifacts.settings

tests/p2p/netfilter/test_match.py

@@ -202,15 +202,15 @@ class BaseNetfilterMatchTest(unittest.TestCase):
 
     def test_match_peer_id(self) -> None:
         network = 'testnet'
-        peer_id1 = Peer()
-        peer_id2 = Peer()
-        manager1 = self.create_peer(network, peer_id=peer_id1)
-        manager2 = self.create_peer(network, peer_id=peer_id2)
+        peer1 = Peer()
+        peer2 = Peer()
+        manager1 = self.create_peer(network, peer=peer1)
+        manager2 = self.create_peer(network, peer=peer2)
 
         conn = FakeConnection(manager1, manager2)
         self.assertTrue(conn.proto2.is_state(conn.proto2.PeerState.HELLO))
 
-        matcher = NetfilterMatchPeerId(str(peer_id1.id))
+        matcher = NetfilterMatchPeerId(str(peer1.id))
         context = NetfilterContext(protocol=conn.proto2)
         self.assertFalse(matcher.match(context))
 
@@ -231,7 +231,7 @@ def test_match_peer_id(self) -> None:
         # Guarantee the to_json is working fine
         json = matcher.to_json()
         self.assertEqual(json['type'], 'NetfilterMatchPeerId')
-        self.assertEqual(json['match_params']['peer_id'], str(peer_id1.id))
+        self.assertEqual(json['match_params']['peer_id'], str(peer1.id))
 
 
 class SyncV1NetfilterMatchTest(unittest.SyncV1Params, BaseNetfilterMatchTest):

tests/p2p/test_peer_id.py

@@ -220,26 +220,26 @@ class BasePeerIdTest(unittest.TestCase):
 
     async def test_validate_entrypoint(self) -> None:
         manager = self.create_peer('testnet', unlock_wallet=False)
-        peer_id = manager.my_peer
-        peer_id.entrypoints = [Entrypoint.parse('tcp://127.0.0.1:40403')]
+        peer = manager.my_peer
+        peer.entrypoints = [Entrypoint.parse('tcp://127.0.0.1:40403')]
 
         # we consider that we are starting the connection to the peer
         protocol = manager.connections.client_factory.buildProtocol('127.0.0.1')
         protocol.entrypoint = Entrypoint.parse('tcp://127.0.0.1:40403')
-        result = await peer_id.validate_entrypoint(protocol)
+        result = await peer.validate_entrypoint(protocol)
         self.assertTrue(result)
         # if entrypoint is an URI
-        peer_id.entrypoints = [Entrypoint.parse('tcp://uri_name:40403')]
-        result = await peer_id.validate_entrypoint(protocol)
+        peer.entrypoints = [Entrypoint.parse('tcp://uri_name:40403')]
+        result = await peer.validate_entrypoint(protocol)
         self.assertTrue(result)
         # test invalid. DNS in test mode will resolve to '127.0.0.1:40403'
         protocol.entrypoint = Entrypoint.parse('tcp://45.45.45.45:40403')
-        result = await peer_id.validate_entrypoint(protocol)
+        result = await peer.validate_entrypoint(protocol)
         self.assertFalse(result)
 
         # now test when receiving the connection - i.e. the peer starts it
         protocol.entrypoint = None
-        peer_id.entrypoints = [Entrypoint.parse('tcp://127.0.0.1:40403')]
+        peer.entrypoints = [Entrypoint.parse('tcp://127.0.0.1:40403')]
 
         from collections import namedtuple
         Peer = namedtuple('Peer', 'host')
@@ -248,11 +248,11 @@ class FakeTransport:
             def getPeer(self) -> Peer:
                 return Peer(host='127.0.0.1')
         protocol.transport = FakeTransport()
-        result = await peer_id.validate_entrypoint(protocol)
+        result = await peer.validate_entrypoint(protocol)
         self.assertTrue(result)
         # if entrypoint is an URI
-        peer_id.entrypoints = [Entrypoint.parse('tcp://uri_name:40403')]
-        result = await peer_id.validate_entrypoint(protocol)
+        peer.entrypoints = [Entrypoint.parse('tcp://uri_name:40403')]
+        result = await peer.validate_entrypoint(protocol)
         self.assertTrue(result)