asyncio: stop using get_event_loop(). introduce ~singleton loop.

asyncio.get_event_loop() became deprecated in python3.10. (see python/cpython#83710)
```
.../electrum/electrum/daemon.py:470: DeprecationWarning: There is no current event loop
  self.asyncio_loop = asyncio.get_event_loop()
.../electrum/electrum/network.py:276: DeprecationWarning: There is no current event loop
  self.asyncio_loop = asyncio.get_event_loop()
```
Also, according to that thread, "set_event_loop() [... is] not deprecated by oversight".
So, we stop using get_event_loop() and set_event_loop() in our own code.
Note that libraries we use (such as the stdlib for python <3.10), might call get_event_loop,
which then relies on us having called set_event_loop e.g. for the GUI thread. To work around
this, a custom event loop policy providing a get_event_loop implementation is used.

Previously, we have been using a single asyncio event loop, created with
util.create_and_start_event_loop, and code in many places got a reference to this loop
using asyncio.get_event_loop().
Now, we still use a single asyncio event loop, but it is now stored as a global in
util._asyncio_event_loop (access with util.get_asyncio_loop()).

I believe these changes also fix spesmilo#5376

Author: SomberNight

electrum/commands.py

@@ -187,7 +187,7 @@ def _run(self, method, args, password_getter=None, **kwargs):
                 kwargs.pop('wallet')
 
         coro = f(*args, **kwargs)
-        fut = asyncio.run_coroutine_threadsafe(coro, asyncio.get_event_loop())
+        fut = asyncio.run_coroutine_threadsafe(coro, util.get_asyncio_loop())
         result = fut.result()
 
         if self._callback:

electrum/daemon.py

@@ -124,7 +124,7 @@ def request(config: SimpleConfig, endpoint, args=(), timeout=60):
         rpc_user, rpc_password = get_rpc_credentials(config)
         server_url = 'http://%s:%d' % (host, port)
         auth = aiohttp.BasicAuth(login=rpc_user, password=rpc_password)
-        loop = asyncio.get_event_loop()
+        loop = util.get_asyncio_loop()
         async def request_coroutine():
             if socktype == 'unix':
                 connector = aiohttp.UnixConnector(path=path)
@@ -467,7 +467,7 @@ def __init__(self, config: SimpleConfig, fd=None, *, listen_jsonrpc=True):
         if 'wallet_path' in config.cmdline_options:
             self.logger.warning("Ignoring parameter 'wallet_path' for daemon. "
                                 "Use the load_wallet command instead.")
-        self.asyncio_loop = asyncio.get_event_loop()
+        self.asyncio_loop = util.get_asyncio_loop()
         self.network = None
         if not config.get('offline'):
             self.network = Network(config, daemon=self)

electrum/exchange_rate.py

@@ -148,7 +148,7 @@ def get_historical_rates(self, ccy: str, cache_dir: str) -> None:
         if h is None:
             h = self.read_historical_rates(ccy, cache_dir)
         if h is None or h['timestamp'] < time.time() - 24*3600:
-            asyncio.get_event_loop().create_task(self.get_historical_rates_safe(ccy, cache_dir))
+            util.get_asyncio_loop().create_task(self.get_historical_rates_safe(ccy, cache_dir))
 
     def history_ccys(self) -> Sequence[str]:
         return []
@@ -471,7 +471,7 @@ async def query_all_exchanges_for_their_ccys_over_network():
                 for name, klass in exchanges.items():
                     exchange = klass(None, None)
                     await group.spawn(get_currencies_safe(name, exchange))
-    loop = asyncio.get_event_loop()
+    loop = util.get_asyncio_loop()
     try:
         loop.run_until_complete(query_all_exchanges_for_their_ccys_over_network())
     except Exception as e:

electrum/gui/kivy/main_window.py

@@ -394,7 +394,7 @@ def __init__(self, **kwargs):
         self.is_exit = False
         self.wallet = None  # type: Optional[Abstract_Wallet]
         self.pause_time = 0
-        self.asyncio_loop = asyncio.get_event_loop()
+        self.asyncio_loop = util.get_asyncio_loop()
         self.password = None
         self._use_single_password = False
         self.resume_dialog = None

electrum/lnworker.py

@@ -496,7 +496,7 @@ async def add_peer(self, connect_str: str) -> Peer:
             # Try DNS-resolving the host (if needed). This is simply so that
             # the caller gets a nice exception if it cannot be resolved.
             try:
-                await asyncio.get_event_loop().getaddrinfo(host, port)
+                await asyncio.get_running_loop().getaddrinfo(host, port)
             except socket.gaierror:
                 raise ConnStringFormatError(_('Hostname does not resolve (getaddrinfo failed)'))
             # add peer

electrum/network.py

@@ -273,7 +273,7 @@ def __init__(self, config: SimpleConfig, *, daemon: 'Daemon' = None):
             init_retry_delay_urgent=1,
         )
 
-        self.asyncio_loop = asyncio.get_event_loop()
+        self.asyncio_loop = util.get_asyncio_loop()
         assert self.asyncio_loop.is_running(), "event loop not running"
 
         assert isinstance(config, SimpleConfig), f"config should be a SimpleConfig instead of {type(config)}"
@@ -381,9 +381,11 @@ async def stop_gossip(self, *, full_shutdown: bool = False):
             self.channel_db = None
             self.path_finder = None
 
-    def run_from_another_thread(self, coro, *, timeout=None):
-        assert util.get_running_loop() != self.asyncio_loop, 'must not be called from network thread'
-        fut = asyncio.run_coroutine_threadsafe(coro, self.asyncio_loop)
+    @classmethod
+    def run_from_another_thread(cls, coro, *, timeout=None):
+        loop = util.get_asyncio_loop()
+        assert util.get_running_loop() != loop, 'must not be called from asyncio thread'
+        fut = asyncio.run_coroutine_threadsafe(coro, loop)
         return fut.result(timeout)
 
     @staticmethod
@@ -1321,7 +1323,7 @@ def send_http_on_proxy(cls, method, url, **kwargs):
             assert util.get_running_loop() != network.asyncio_loop
             loop = network.asyncio_loop
         else:
-            loop = asyncio.get_event_loop()
+            loop = util.get_asyncio_loop()
         coro = asyncio.run_coroutine_threadsafe(cls._send_http_on_proxy(method, url, **kwargs), loop)
         # note: _send_http_on_proxy has its own timeout, so no timeout here:
         return coro.result()

electrum/sql_db.py

@@ -26,7 +26,6 @@ class SqlDB(Logger):
     def __init__(self, asyncio_loop: asyncio.BaseEventLoop, path, commit_interval=None):
         Logger.__init__(self)
         self.asyncio_loop = asyncio_loop
-        asyncio.set_event_loop(asyncio_loop)
         self.stopping = False
         self.stopped_event = asyncio.Event()
         self.path = path

electrum/tests/test_lnpeer.py

@@ -15,6 +15,7 @@
 import electrum
 import electrum.trampoline
 from electrum import bitcoin
+from electrum import util
 from electrum import constants
 from electrum.network import Network
 from electrum.ecc import ECPrivkey
@@ -62,7 +63,7 @@ def __init__(self, tx_queue):
         user_config = {}
         user_dir = tempfile.mkdtemp(prefix="electrum-lnpeer-test-")
         self.config = simple_config.SimpleConfig(user_config, read_user_dir_function=lambda: user_dir)
-        self.asyncio_loop = asyncio.get_event_loop()
+        self.asyncio_loop = util.get_asyncio_loop()
         self.channel_db = ChannelDB(self)
         self.channel_db.data_loaded.set()
         self.path_finder = LNPathFinder(self.channel_db)
@@ -1361,4 +1362,4 @@ async def f():
 
 
 def run(coro):
-    return asyncio.run_coroutine_threadsafe(coro, loop=asyncio.get_event_loop()).result()
+    return asyncio.run_coroutine_threadsafe(coro, loop=util.get_asyncio_loop()).result()

electrum/tests/test_lnrouter.py

@@ -4,6 +4,7 @@
 import shutil
 import asyncio
 
+from electrum import util
 from electrum.util import bh2u, bfh, create_and_start_event_loop
 from electrum.lnutil import ShortChannelID
 from electrum.lnonion import (OnionHopsDataSingle, new_onion_packet,
@@ -64,7 +65,7 @@ def prepare_graph(self):
         """
         class fake_network:
             config = self.config
-            asyncio_loop = asyncio.get_event_loop()
+            asyncio_loop = util.get_asyncio_loop()
             trigger_callback = lambda *args: None
             register_callback = lambda *args: None
             interface = None

electrum/tests/test_lntransport.py

@@ -1,5 +1,6 @@
 import asyncio
 
+from electrum import util
 from electrum.ecc import ECPrivkey
 from electrum.lnutil import LNPeerAddr
 from electrum.lntransport import LNResponderTransport, LNTransport
@@ -11,6 +12,15 @@
 
 class TestLNTransport(ElectrumTestCase):
 
+    def setUp(self):
+        super().setUp()
+        self.asyncio_loop, self._stop_loop, self._loop_thread = util.create_and_start_event_loop()
+
+    def tearDown(self):
+        self.asyncio_loop.call_soon_threadsafe(self._stop_loop.set_result, 1)
+        self._loop_thread.join(timeout=1)
+        super().tearDown()
+
     @needs_test_with_all_chacha20_implementations
     def test_responder(self):
         # local static
@@ -38,11 +48,11 @@ async def read(self, num_bytes):
                     assert num_bytes == 66
                     return bytes.fromhex('00b9e3a702e93e3a9948c2ed6e5fd7590a6e1c3a0344cfc9d5b57357049aa22355361aa02e55a8fc28fef5bd6d71ad0c38228dc68b1c466263b47fdf31e560e139ba')
         transport = LNResponderTransport(ls_priv, Reader(), Writer())
-        asyncio.get_event_loop().run_until_complete(transport.handshake(epriv=e_priv))
+        asyncio.run_coroutine_threadsafe(
+            transport.handshake(epriv=e_priv), self.asyncio_loop).result()
 
     @needs_test_with_all_chacha20_implementations
     def test_loop(self):
-        loop = asyncio.get_event_loop()
         responder_shaked = asyncio.Event()
         server_shaked = asyncio.Event()
         responder_key = ECPrivkey.generate_random_key()
@@ -96,4 +106,4 @@ async def f():
                 server.close()
                 await server.wait_closed()
 
-        loop.run_until_complete(f())
+        asyncio.run_coroutine_threadsafe(f(), self.asyncio_loop).result()