async_call: only use err_write when called from plugin

Author: bfredl

neovim/api/nvim.py

@@ -1,6 +1,7 @@
 """Main Nvim interface."""
 import functools
 import os
+import sys
 
 from traceback import format_exc, format_stack
 
@@ -65,9 +66,10 @@ def from_session(cls, session):
     def from_nvim(cls, nvim):
         """Create a new Nvim instance from an existing instance."""
         return cls(nvim._session, nvim.channel_id, nvim.metadata,
-                   nvim.types, nvim._decodehook)
+                   nvim.types, nvim._decodehook, nvim._err_cb)
 
-    def __init__(self, session, channel_id, metadata, types, decodehook=None):
+    def __init__(self, session, channel_id, metadata, types,
+                 decodehook=None, err_cb=None):
         """Initialize a new Nvim instance. This method is module-private."""
         self._session = session
         self.channel_id = channel_id
@@ -84,6 +86,7 @@ def __init__(self, session, channel_id, metadata, types, decodehook=None):
         self.funcs = Funcs(self)
         self.error = NvimError
         self._decodehook = decodehook
+        self._err_cb = err_cb
 
     def _from_nvim(self, obj):
         if type(obj) is ExtType:
@@ -132,7 +135,8 @@ def next_message(self):
         if msg:
             return walk(self._from_nvim, msg)
 
-    def run_loop(self, request_cb, notification_cb, setup_cb=None):
+    def run_loop(self, request_cb, notification_cb,
+                 setup_cb=None, err_cb=None):
         """Run the event loop to receive requests and notifications from Nvim.
 
         This should not be called from a plugin running in the host, which
@@ -146,6 +150,10 @@ def filter_request_cb(name, args):
         def filter_notification_cb(name, args):
             notification_cb(self._from_nvim(name), walk(self._from_nvim, args))
 
+        if err_cb is None:
+            err_cb = sys.stderr.write
+        self._err_cb = err_cb
+
         self._session.run(filter_request_cb, filter_notification_cb, setup_cb)
 
     def stop_loop(self):
@@ -155,7 +163,7 @@ def stop_loop(self):
     def with_decodehook(self, hook):
         """Initialize a new Nvim instance."""
         return Nvim(self._session, self.channel_id,
-                    self.metadata, self.types, hook)
+                    self.metadata, self.types, hook, self._err_cb)
 
     def ui_attach(self, width, height, rgb):
         """Register as a remote UI.
@@ -316,9 +324,9 @@ def handler():
                 fn(*args, **kwargs)
             except Exception as err:
                 msg = ("error caught while executing async callback:\n"
-                       "{!r}\n{}\n \nthe call was requested at\n{}"
+                       "{0!r}\n{1}\n \nthe call was requested at\n{2}"
                        .format(err, format_exc(5), call_point))
-                self.err_write(msg, async=True)
+                self._err_cb(msg)
                 raise
         self._session.threadsafe_call(handler)
 

neovim/plugin/host.py

@@ -45,11 +45,15 @@ def __init__(self, nvim):
         if IS_PYTHON3 and isinstance(self._nvim_encoding, bytes):
             self._nvim_encoding = self._nvim_encoding.decode('ascii')
 
+    def _on_async_err(self, msg):
+        self.nvim.err_write(msg, async=True)
+
     def start(self, plugins):
         """Start listening for msgpack-rpc requests and notifications."""
         self.nvim.run_loop(self._on_request,
                            self._on_notification,
-                           lambda: self._load(plugins))
+                           lambda: self._load(plugins),
+                           err_cb=self._on_async_err)
 
     def shutdown(self):
         """Shutdown the host."""
@@ -79,16 +83,16 @@ def _on_notification(self, name, args):
         if not handler:
             msg = self._missing_handler_error(name, 'notification')
             error(msg)
-            self.nvim.err_write(msg + "\n")
+            self._on_async_err(msg + "\n")
             return
 
         debug('calling notification handler for "%s", args: "%s"', name, args)
         try:
             handler(*args)
         except Exception as err:
-            msg = ("error caught in async handler '{} {}':\n{!r}\n{}"
+            msg = ("error caught in async handler '{} {}':\n{!r}\n{}\n"
                    .format(name, args, err, format_exc(5)))
-            self.nvim.err_write(msg, async=True)
+            self._on_async_err(msg + "\n")
             raise
 
     def _missing_handler_error(self, name, kind):

test/test_concurrency.py

@@ -2,18 +2,20 @@
 from test_common import vim, cleanup
 from threading import Timer
 
-
 @with_setup(setup=cleanup)
 def test_interrupt_from_another_thread():
-    session = vim.session
-    timer = Timer(0.5, lambda: vim.async_call(lambda: session.stop()))
+    timer = Timer(0.5, lambda: vim.async_call(lambda: vim.stop_loop()))
     timer.start()
     eq(vim.next_message(), None)
 
-
 @with_setup(setup=cleanup)
 def test_exception_in_threadsafe_call():
     # an exception in a threadsafe_call shouldn't crash the entire host
-    vim.session.threadsafe_call(lambda: [vim.eval("3"), undefined_variable])
-    vim.session.threadsafe_call(lambda: vim.stop_loop())
-    vim.run_loop(None, None, lambda: vim.input("<cr>"))
+    msgs = []
+    vim.async_call(lambda: [vim.eval("3"), undefined_variable])
+    timer = Timer(0.5, lambda: vim.async_call(lambda: vim.stop_loop()))
+    timer.start()
+    vim.run_loop(None, None, err_cb=msgs.append)
+    eq(len(msgs), 1)
+    msgs[0].index('NameError')
+    msgs[0].index('undefined_variable')