👍 change denops#server#start and ...#stop to asynchronous

- Add new `denops-variable`:
  - `g:denops#server#close_timeout`
- Add new state for `denops#server#status()`:
  - `closing`
  - `closed`
- Change behavior `denops-function`:
  - `denops#server#start()` can now be called even when status is
    `closing`. In that case, the status will become `stopped` and then
    restart asynchronously.
  - `denops#server#stop()` is changed to asynchronously. It waits for
    the server to close gracefully, and force terminate if timeouted.
  - `denops#server#restart()` is changed to asynchronously. Perform the
    stop and start steps above.

Author: Milly

autoload/denops/_internal/job.vim

@@ -30,7 +30,6 @@ if has('nvim')
   function! s:stop(job) abort
     try
       call jobstop(a:job)
-      call jobwait([a:job])
     catch /^Vim\%((\a\+)\)\=:E900/
       " NOTE:
       " Vim does not raise exception even the job has already closed so fail
@@ -58,24 +57,23 @@ else
           \ 'err_cb': funcref('s:out_cb', [a:options.on_stderr, 'stderr']),
           \ 'exit_cb': funcref('s:exit_cb', [a:options.on_exit, 'exit']),
           \}
-    return job_start(a:args, l:options)
+    let l:job = job_start(a:args, l:options)
+    if l:job->job_status() !=# "run"
+      throw printf("Invalid value for argument cmd: '%s' is not executable", a:args[0])
+    endif
+    return l:job
   endfunction
 
   function! s:stop(job) abort
     call job_stop(a:job)
     call timer_start(s:KILL_TIMEOUT_MS, { -> job_stop(a:job, 'kill') })
-    " Wait until the job is actually closed
-    while job_status(a:job) ==# 'run'
-      sleep 10m
-    endwhile
-    redraw
   endfunction
 
-  function! s:out_cb(callback, event, ch, msg) abort
-    call a:callback(a:ch, a:msg, a:event)
+  function! s:out_cb(callback, event, job, msg) abort
+    call a:callback(a:job, a:msg, a:event)
   endfunction
 
-  function! s:exit_cb(callback, event, ch, status) abort
-    call a:callback(a:ch, a:status, a:event)
+  function! s:exit_cb(callback, event, job, status) abort
+    call a:callback(a:job, a:status, a:event)
   endfunction
 endif

autoload/denops/_internal/server/chan.vim

@@ -28,13 +28,13 @@ function! denops#_internal#server#chan#connect(addr, options) abort
   endif
   let l:retry_threshold = a:options.retry_threshold
   let l:retry_interval = a:options.retry_interval
-  let l:previous_exception = ''
-  for l:i in range(l:retry_threshold)
+  let l:i = 1
+  while v:true
     call denops#_internal#echo#debug(printf(
           \ 'Connecting to channel `%s` [%d/%d]',
           \ a:addr,
-          \ l:i + 1,
-          \ l:retry_threshold + 1,
+          \ l:i,
+          \ l:retry_threshold,
           \))
     try
       call s:connect(a:addr, a:options)
@@ -43,28 +43,45 @@ function! denops#_internal#server#chan#connect(addr, options) abort
       call denops#_internal#echo#debug(printf(
             \ 'Failed to connect channel `%s` [%d/%d]: %s',
             \ a:addr,
-            \ l:i + 1,
-            \ l:retry_threshold + 1,
+            \ l:i,
+            \ l:retry_threshold,
             \ v:exception,
             \))
-      let l:previous_exception = v:exception
+      if l:i >= l:retry_threshold
+        call denops#_internal#echo#error(printf(
+              \ 'Failed to connect channel `%s`: %s',
+              \ a:addr,
+              \ v:exception,
+              \))
+        return
+      endif
     endtry
     execute printf('sleep %dm', l:retry_interval)
-  endfor
-  call denops#_internal#echo#error(printf(
-        \ 'Failed to connect channel `%s`: %s',
-        \ a:addr,
-        \ l:previous_exception,
-        \))
+  endwhile
 endfunction
 
-function! denops#_internal#server#chan#close() abort
+" Args:
+"   options: {
+"     timeout: number (default: 0)
+"   }
+function! denops#_internal#server#chan#close(options) abort
   if s:chan is# v:null
     throw '[denops] Channel does not exist yet'
   endif
+  let l:options = extend({
+        \ 'timeout': 0,
+        \}, a:options)
   let s:closed_on_purpose = 1
-  call s:rpcclose(s:chan)
-  let s:chan = v:null
+  if l:options.timeout ==# 0
+    return s:force_close(l:options)
+  endif
+  if l:options.timeout > 0
+    let s:force_close_delayer = timer_start(
+          \ l:options.timeout,
+          \ { -> s:force_close(l:options) },
+          \)
+  endif
+  call denops#_internal#server#chan#notify('invoke', ['close', []])
 endfunction
 
 function! denops#_internal#server#chan#is_connected() abort
@@ -91,36 +108,56 @@ endfunction
 
 function! s:connect(addr, options) abort
   let s:closed_on_purpose = 0
-  let s:chan = s:rpcconnect(a:addr, {
-        \ 'on_close': { -> s:on_close(a:options) },
-        \})
   let s:addr = a:addr
   let s:options = a:options
+  let s:chan = s:rpcconnect(a:addr, {
+        \ 'on_close': { -> s:on_close() },
+        \})
   call denops#_internal#echo#debug(printf('Channel connected (%s)', a:addr))
   call s:rpcnotify(s:chan, 'void', [])
 endfunction
 
-function! s:on_close(options) abort
+function! s:force_close(options) abort
+  let l:chan = s:chan
+  let s:chan = v:null
+  call s:clear_force_close_delayer()
+  call denops#_internal#echo#warn(printf(
+        \ 'Channel cannot close gracefully within %d millisec, force close (%s)',
+        \ a:options.timeout,
+        \ s:addr,
+        \))
+  call s:rpcclose(l:chan)
+endfunction
+
+function! s:clear_force_close_delayer() abort
+  if exists('s:force_close_delayer')
+    call timer_stop(s:force_close_delayer)
+    unlet s:force_close_delayer
+  endif
+endfunction
+
+function! s:on_close() abort
   let s:chan = v:null
+  call s:clear_force_close_delayer()
   call denops#_internal#echo#debug(printf('Channel closed (%s)', s:addr))
   doautocmd <nomodeline> User DenopsClosed
-  if !a:options.reconnect_on_close || s:closed_on_purpose || s:exiting
+  if s:chan isnot# v:null || !s:options.reconnect_on_close || s:closed_on_purpose || s:exiting
     return
   endif
   " Reconnect
-  if s:reconnect_guard(a:options)
+  if s:reconnect_guard()
     return
   endif
   call denops#_internal#echo#warn('Channel closed. Reconnecting...')
   call timer_start(
-        \ a:options.reconnect_delay,
+        \ s:options.reconnect_delay,
         \ { -> denops#_internal#server#chan#connect(s:addr, s:options) },
         \)
 endfunction
 
-function! s:reconnect_guard(options) abort
-  let l:reconnect_threshold = a:options.reconnect_threshold
-  let l:reconnect_interval = a:options.reconnect_interval
+function! s:reconnect_guard() abort
+  let l:reconnect_threshold = s:options.reconnect_threshold
+  let l:reconnect_interval = s:options.reconnect_interval
   let s:reconnect_count = get(s:, 'reconnect_count', 0) + 1
   if s:reconnect_count >= l:reconnect_threshold
     call denops#_internal#echo#warn(printf(

autoload/denops/_internal/server/proc.vim

@@ -22,31 +22,34 @@ function! denops#_internal#server#proc#start(options) abort
   endif
   let l:retry_interval = a:options.retry_interval
   let l:retry_threshold = a:options.retry_threshold
-  let l:previous_exception = ''
-  for l:i in range(l:retry_threshold)
+  let l:i = 1
+  while v:true
     call denops#_internal#echo#debug(printf(
           \ 'Spawn server [%d/%d]',
-          \ l:i + 1,
-          \ l:retry_threshold + 1,
+          \ l:i,
+          \ l:retry_threshold,
           \))
     try
       call s:start(a:options)
       return v:true
     catch
       call denops#_internal#echo#debug(printf(
             \ 'Failed to spawn server [%d/%d]: %s',
-            \ l:i + 1,
-            \ l:retry_threshold + 1,
+            \ l:i,
+            \ l:retry_threshold,
             \ v:exception,
             \))
-      let l:previous_exception = v:exception
+      if l:i >= l:retry_threshold
+        call denops#_internal#echo#error(printf(
+              \ 'Failed to spawn server: %s',
+              \ v:exception,
+              \))
+        return
+      endif
     endtry
     execute printf('sleep %dm', l:retry_interval)
-  endfor
-  call denops#_internal#echo#error(printf(
-        \ 'Failed to spawn server: %s',
-        \ l:previous_exception,
-        \))
+    let l:i += 1
+  endwhile
 endfunction
 
 function! denops#_internal#server#proc#stop() abort
@@ -116,7 +119,7 @@ function! s:on_exit(options, status) abort
   let s:job = v:null
   call denops#_internal#echo#debug(printf('Server stopped: %s', a:status))
   execute printf('doautocmd <nomodeline> User DenopsProcessStopped:%s', a:status)
-  if !a:options.restart_on_exit || s:stopped_on_purpose || s:exiting
+  if s:job isnot# v:null || !a:options.restart_on_exit || s:stopped_on_purpose || s:exiting
     return
   endif
   " Restart