Make accidentially private methods public

These methods were named so that they appeared
private by convention. This convention causes
trouble in the documentation where these methods
are righfully dropped. Since these methods aren't
really private in reality (they need to be overwritten
in subclasses), they were renamed, migrating their
naming from `_*` to `do_*`.

Author: cburgdorf

trinity/extensibility/plugin.py

@@ -163,18 +163,18 @@ def configure_parser(self, arg_parser: ArgumentParser, subparser: _SubParsersAct
 
     def start(self) -> None:
         """
-        Delegate to :meth:`~trinity.extensibility.plugin.BasePlugin._start` and set ``running``
+        Delegate to :meth:`~trinity.extensibility.plugin.BasePlugin.do_start` and set ``running``
         to ``True``. Broadcast a :class:`~trinity.extensibility.events.PluginStartedEvent` on the
         :class:`~lahja.eventbus.EventBus` and hence allow other plugins to act accordingly.
         """
         self.running = True
-        self._start()
+        self.do_start()
         self.event_bus.broadcast(
             PluginStartedEvent(type(self))
         )
         self.logger.info("Plugin started: %s", self.name)
 
-    def _start(self) -> None:
+    def do_start(self) -> None:
         """
         Perform the actual plugin start routine. In the case of a `BaseIsolatedPlugin` this method
         will be called in a separate process.
@@ -190,18 +190,18 @@ class BaseSyncStopPlugin(BasePlugin):
     A :class:`~trinity.extensibility.plugin.BaseSyncStopPlugin` unwinds synchronoulsy, hence blocks
     until the shutdown is done.
     """
-    def _stop(self) -> None:
+    def do_stop(self) -> None:
         """
         Stop the plugin. Should be overwritten by subclasses.
         """
         pass
 
     def stop(self) -> None:
         """
-        Delegate to :meth:`~trinity.extensibility.plugin.BaseSyncStopPlugin._stop` causing the
+        Delegate to :meth:`~trinity.extensibility.plugin.BaseSyncStopPlugin.do_stop` causing the
         plugin to stop and setting ``running`` to ``False``.
         """
-        self._stop()
+        self.do_stop()
         self.running = False
 
 
@@ -211,18 +211,18 @@ class BaseAsyncStopPlugin(BasePlugin):
     needs to be awaited.
     """
 
-    async def _stop(self) -> None:
+    async def do_stop(self) -> None:
         """
         Asynchronously stop the plugin. Should be overwritten by subclasses.
         """
         pass
 
     async def stop(self) -> None:
         """
-        Delegate to :meth:`~trinity.extensibility.plugin.BaseAsyncStopPlugin._stop` causing the
+        Delegate to :meth:`~trinity.extensibility.plugin.BaseAsyncStopPlugin.do_stop` causing the
         plugin to stop asynchronously and setting ``running`` to ``False``.
         """
-        await self._stop()
+        await self.do_stop()
         self.running = False
 
 
@@ -250,7 +250,7 @@ class BaseIsolatedPlugin(BaseSyncStopPlugin):
 
     def start(self) -> None:
         """
-        Prepare the plugin to get started and eventually call ``_start`` in a separate process.
+        Prepare the plugin to get started and eventually call ``do_start`` in a separate process.
         """
         self.running = True
         self._process = ctx.Process(
@@ -268,9 +268,9 @@ def _prepare_start(self) -> None:
         self.event_bus.broadcast(
             PluginStartedEvent(type(self))
         )
-        self._start()
+        self.do_start()
 
-    def _stop(self) -> None:
+    def do_stop(self) -> None:
         self.context.event_bus.stop()
         kill_process_gracefully(self._process, self.logger)
 
@@ -290,7 +290,7 @@ def configure_parser(self, arg_parser: ArgumentParser, subparser: _SubParsersAct
     def handle_event(self, activation_event: BaseEvent) -> None:
         self.logger.info("Debug plugin: handle_event called: %s", activation_event)
 
-    def _start(self) -> None:
+    def do_start(self) -> None:
         self.logger.info("Debug plugin: start called")
         asyncio.ensure_future(self.count_forever())
 
@@ -301,5 +301,5 @@ async def count_forever(self) -> None:
             i += 1
             await asyncio.sleep(1)
 
-    async def _stop(self) -> None:
+    async def do_stop(self) -> None:
         self.logger.info("Debug plugin: stop called")

trinity/plugins/builtin/ethstats/plugin.py

@@ -103,7 +103,7 @@ def ready(self) -> None:
 
         self.start()
 
-    def _start(self) -> None:
+    def do_start(self) -> None:
         service = EthstatsService(
             self.context,
             self.server_url,

trinity/plugins/builtin/json_rpc/plugin.py

@@ -44,7 +44,7 @@ def configure_parser(self, arg_parser: ArgumentParser, subparser: _SubParsersAct
             help="Disables the JSON-RPC Server",
         )
 
-    def _start(self) -> None:
+    def do_start(self) -> None:
         db_manager = create_db_manager(self.context.trinity_config.database_ipc_path)
         db_manager.connect()
 

trinity/plugins/builtin/light_peer_chain_bridge/plugin.py

@@ -57,12 +57,12 @@ def handle_event(self, event: ResourceAvailableEvent) -> None:
             self.chain = event.resource
             self.start()
 
-    def _start(self) -> None:
+    def do_start(self) -> None:
         chain = cast(LightDispatchChain, self.chain)
         self.handler = LightPeerChainEventBusHandler(chain._peer_chain, self.context.event_bus)
         asyncio.ensure_future(self.handler.run())
 
-    async def _stop(self) -> None:
+    async def do_stop(self) -> None:
         # This isn't really needed for the standard shutdown case as the LightPeerChain will
         # automatically shutdown whenever the `CancelToken` it was chained with is triggered.
         # It may still be useful to stop the LightPeerChain Bridge plugin individually though.

trinity/plugins/builtin/tx_pool/plugin.py

@@ -78,7 +78,7 @@ def handle_event(self, event: ResourceAvailableEvent) -> None:
         if all((self.peer_pool is not None, self.chain is not None, self.is_enabled)):
             self.start()
 
-    def _start(self) -> None:
+    def do_start(self) -> None:
         if isinstance(self.chain, BaseMainnetChain):
             validator = DefaultTransactionValidator(self.chain, BYZANTIUM_MAINNET_BLOCK)
         elif isinstance(self.chain, BaseRopstenChain):
@@ -91,7 +91,7 @@ def _start(self) -> None:
         self.tx_pool = TxPool(self.peer_pool, validator, self.cancel_token)
         asyncio.ensure_future(self.tx_pool.run())
 
-    async def _stop(self) -> None:
+    async def do_stop(self) -> None:
         # This isn't really needed for the standard shutdown case as the TxPool will automatically
         # shutdown whenever the `CancelToken` it was chained with is triggered. It may still be
         # useful to stop the TxPool plugin individually though.

trinity/plugins/builtin/tx_pool/pool.py

@@ -122,5 +122,5 @@ def _add_txs_to_bloom(self, peer: ETHPeer, txs: Iterable[BaseTransactionFields])
         for val in txs:
             self._bloom.add(self._construct_bloom_entry(peer, val))
 
-    async def _cleanup(self) -> None:
+    async def do_cleanup(self) -> None:
         self.logger.info("Stopping Tx Pool...")