feat(loop): implement timeout

Author: Jose Alvarez

README.md

@@ -50,10 +50,11 @@ null_ls.setup {
     -- define sources at setup
     sources = {my_sources},
 
-    -- options (defaults shown)
+    -- options (defaults shown, numbers in ms)
     save_after_formatting = true,
-    debounce = 250, -- ms
-    keep_alive_interval = 60000 -- ms (60 seconds)
+    debounce = 250,
+    keep_alive_interval = 60000,
+    default_timeout = 1000
 }
 
 -- register sources dynamically

lua/null-ls/builtins/formatting.lua

@@ -11,7 +11,8 @@ M.lua_format = {
         {
             command = "lua-format",
             args = {"--single-quote-to-double-quote", "-i"},
-            to_stdin = true
+            to_stdin = true,
+            timeout = 2500
         })
 }
 

lua/null-ls/builtins/test.lua

@@ -1,5 +1,6 @@
-local methods = require("null-ls.methods")
 local u = require("null-ls.utils")
+local methods = require("null-ls.methods")
+local helpers = require("null-ls.helpers")
 
 local api = vim.api
 
@@ -63,6 +64,30 @@ M.mock_code_action = {
     filetypes = {"lua"}
 }
 
+M.slow_code_action = {
+    method = methods.internal.CODE_ACTION,
+    generator = helpers.generator_factory(
+        {
+            command = "bash",
+            args = {"./test/scripts/sleep-and-echo.sh"},
+            format = "raw",
+            timeout = 100,
+            on_output = function(params, done)
+                if not params.output then return done() end
+
+                return done({
+                    {
+                        title = "Slow mock action",
+                        action = function()
+                            print("I took too long!")
+                        end
+                    }
+                })
+            end
+        }),
+    filetypes = {"lua"}
+}
+
 M.mock_diagnostics = {
     method = methods.internal.DIAGNOSTICS,
     generator = {

lua/null-ls/config.lua

@@ -6,6 +6,7 @@ local defaults = {
     debounce = 250,
     keep_alive_interval = 60000, -- 60 seconds,
     save_after_format = true,
+    default_timeout = 1000,
     _generators = {},
     _filetypes = {},
     _names = {},

lua/null-ls/helpers.lua

@@ -1,4 +1,5 @@
 local u = require("null-ls.utils")
+local c = require("null-ls.config")
 local loop = require("null-ls.loop")
 
 local validate = vim.validate
@@ -51,9 +52,10 @@ local formats = {
 
 M.generator_factory = function(opts)
     local command, args, on_output, format, to_stderr, to_stdin, ignore_errors,
-          check_exit_code = opts.command, opts.args, opts.on_output,
-                            opts.format, opts.to_stderr, opts.to_stdin,
-                            opts.ignore_errors, opts.check_exit_code
+          check_exit_code, timeout = opts.command, opts.args, opts.on_output,
+                                     opts.format, opts.to_stderr, opts.to_stdin,
+                                     opts.ignore_errors, opts.check_exit_code,
+                                     opts.timeout
 
     local _validated
     local validate_opts = function()
@@ -69,7 +71,8 @@ M.generator_factory = function(opts)
             to_stderr = {to_stderr, "boolean", true},
             to_stdin = {to_stdin, "boolean", true},
             ignore_errors = {ignore_errors, "boolean", true},
-            check_exit_code = {check_exit_code, "function", true}
+            check_exit_code = {check_exit_code, "function", true},
+            timeout = {timeout, "number", true}
         })
 
         _validated = true
@@ -113,7 +116,8 @@ M.generator_factory = function(opts)
                 input = to_stdin and get_content(params) or nil,
                 handler = wrapper,
                 bufnr = params.bufnr,
-                check_exit_code = check_exit_code
+                check_exit_code = check_exit_code,
+                timeout = timeout or c.get().default_timeout
             })
         end,
         filetypes = opts.filetypes,

lua/null-ls/loop.lua

@@ -2,6 +2,7 @@ local u = require("null-ls.utils")
 
 local api = vim.api
 local uv = vim.loop
+local wrap = vim.schedule_wrap
 
 local close_handle = function(handle)
     if handle and not handle:is_closing() then handle:close() end
@@ -24,37 +25,43 @@ local parse_args = function(args, bufnr)
     return parsed
 end
 
+local TIMEOUT_EXIT_CODE = 7451
+
 local M = {}
 
 M.spawn = function(cmd, args, opts)
-    local handler, input, bufnr, check_exit_code = opts.handler, opts.input,
-                                                   opts.bufnr,
-                                                   opts.check_exit_code
+    local handler, input, bufnr, check_exit_code, timeout = opts.handler,
+                                                            opts.input,
+                                                            opts.bufnr,
+                                                            opts.check_exit_code,
+                                                            opts.timeout
 
+    local timer
     local output, error_output, exit_ok = "", "", _G._TEST and true or nil
-    local handle_stdout = vim.schedule_wrap(
-                              function(err, chunk)
-            if err then error("stdout error: " .. err) end
-
-            if chunk then output = output .. chunk end
-            if not chunk then
-                -- wait for handler callback to check exit code
-                vim.wait(500, function() return exit_ok ~= nil end, 10)
-
-                -- convert empty strings to make nil checks easier
-                if output == "" then output = nil end
-                if error_output == "" then error_output = nil end
-
-                -- if exit code is not ok and program did not output to stderr,
-                -- assign output to error_output, so handler can process it as an error
-                if not exit_ok and not error_output then
-                    error_output = output
-                    output = nil
-                end
-
-                handler(error_output, output)
+    local handle_stdout = wrap(function(err, chunk)
+        if err then error("stdout error: " .. err) end
+
+        if chunk then output = output .. chunk end
+        if not chunk then
+            if timer then timer.stop(true) end
+
+            -- wait for handler callback to check exit code
+            vim.wait(500, function() return exit_ok ~= nil end, 10)
+
+            -- convert empty strings to make nil checks easier
+            if output == "" then output = nil end
+            if error_output == "" then error_output = nil end
+
+            -- if exit code is not ok and program did not output to stderr,
+            -- assign output to error_output, so handler can process it as an error
+            if not exit_ok and not error_output then
+                error_output = output
+                output = nil
             end
-        end)
+
+            handler(error_output, output)
+        end
+    end)
 
     local handle_stderr = function(err, chunk)
         if err then error("stderr error: " .. err) end
@@ -68,9 +75,12 @@ M.spawn = function(cmd, args, opts)
     local stdio = {stdin, stdout, stderr}
 
     local handle
-    handle = uv.spawn(cmd, {args = parse_args(args, bufnr), stdio = stdio},
-                      vim.schedule_wrap(function(code)
-        exit_ok = check_exit_code and check_exit_code(code) or code == 0
+    local close = wrap(function(code)
+        if code == TIMEOUT_EXIT_CODE then
+            exit_ok = false
+        else
+            exit_ok = check_exit_code and check_exit_code(code) or code == 0
+        end
 
         stdout:read_stop()
         stderr:read_stop()
@@ -79,7 +89,17 @@ M.spawn = function(cmd, args, opts)
         close_handle(stdout)
         close_handle(stderr)
         close_handle(handle)
-    end))
+    end)
+
+    handle = uv.spawn(cmd, {args = parse_args(args, bufnr), stdio = stdio},
+                      close)
+    if timeout then
+        timer = M.timer(timeout, nil, true, function()
+            close(TIMEOUT_EXIT_CODE)
+            handler()
+            timer.stop(true)
+        end)
+    end
 
     uv.read_start(stdout, handle_stdout)
     uv.read_start(stderr, handle_stderr)
@@ -91,18 +111,32 @@ M.timer = function(timeout, interval, should_start, callback)
     interval = interval or 0
 
     local timer = uv.new_timer()
-    local wrapped = vim.schedule_wrap(callback)
+    local wrapped = wrap(callback)
+
     local start = function() timer:start(timeout, interval, wrapped) end
-    local stop = function() timer:stop() end
+    local close = function() close_handle(timer) end
+    local stop = function(should_close)
+        timer:stop()
+        if should_close then close() end
+    end
     local restart = function(new_timeout, new_interval)
         timer:stop()
         timer:start(new_timeout or timeout, new_interval or interval, wrapped)
     end
 
     if should_start then timer:start(timeout, interval, wrapped) end
-    return {_timer = timer, start = start, stop = stop, restart = restart}
+    return {
+        _timer = timer,
+        start = start,
+        stop = stop,
+        restart = restart,
+        close = close
+    }
 end
 
-if _G._TEST then M._parse_args = parse_args end
+if _G._TEST then
+    M._parse_args = parse_args
+    M._TIMEOUT_EXIT_CODE = TIMEOUT_EXIT_CODE
+end
 
 return M

lua/null-ls/server.lua

@@ -23,7 +23,7 @@ M.start = function()
     -- start timer to shutdown server after inactivity
     local timer
     local shutdown = function()
-        if timer then timer.stop() end
+        if timer then timer.stop(true) end
         vim.cmd("noautocmd qa!")
     end
     timer = loop.timer(default_shutdown_timeout, nil, true, shutdown)

lua/null-ls/state.lua

@@ -41,7 +41,7 @@ end
 
 M.shutdown_client = function(timeout)
     if not state.client then return end
-    if state.keep_alive_timer then state.keep_alive_timer.stop() end
+    if state.keep_alive_timer then state.keep_alive_timer.stop(true) end
 
     lsp.stop_client(state.client_id)
     vim.wait(timeout or 5000, function()

test/scripts/sleep-and-echo.sh

@@ -0,0 +1,2 @@
+sleep 0.25
+echo "done"

test/spec/e2e_spec.lua

@@ -74,6 +74,17 @@ describe("e2e", function()
 
             assert.equals(vim.tbl_count(actions[1].result), 2)
         end)
+
+        it("should handle code action timeout", function()
+            -- action calls a script that waits for 250 ms,
+            -- but action timeout is 100 ms
+            c.register(builtins._test.slow_code_action)
+
+            actions = lsp.buf_request_sync(api.nvim_get_current_buf(),
+                                           methods.lsp.CODE_ACTION)
+
+            assert.equals(vim.tbl_count(actions[1].result), 1)
+        end)
     end)
 
     describe("diagnostics", function()

test/spec/helpers_spec.lua

@@ -1,6 +1,7 @@
 local stub = require("luassert.stub")
 local loop = require("null-ls.loop")
 
+local c = require("null-ls.config")
 local test_utils = require("test.utils")
 
 describe("helpers", function()
@@ -147,6 +148,25 @@ describe("helpers", function()
                 assert.same(loop.spawn.calls[1].refs[2], {})
             end)
 
+            it("should call loop.spawn with specified timeout", function()
+                generator_args.timeout = 500
+                local generator = helpers.generator_factory(generator_args)
+
+                generator.fn({})
+
+                assert.same(loop.spawn.calls[1].refs[3].timeout, 500)
+            end)
+
+            it("should call loop.spawn with default timeout", function()
+                generator_args.timeout = nil
+                local generator = helpers.generator_factory(generator_args)
+
+                generator.fn({})
+
+                assert.same(loop.spawn.calls[1].refs[3].timeout,
+                            c.get().default_timeout)
+            end)
+
             it(
                 "should call loop.spawn with buffer content as string when to_stdin = true",
                 function()