Add ability to start neovim server from a fresh terminal (fix #51), move fsock/netsock path logic to core

Author: atomicptr

crates/bridge/src/launcher.rs

@@ -1,20 +1,18 @@
+use crate::{
+    neovide,
+    plugin_config::{LauncherType, PluginConfig, SocketType},
+    utils::is_port_in_use,
+};
+use anyhow::{Context, Result, bail};
+use defold_nvim_core::{focus::focus_neovim, nvim_server, utils::classname};
 use std::{
     fs::{self},
     path::{Path, PathBuf},
     process::{Child, Command},
 };
-
-use anyhow::{Context, Result, bail};
-use defold_nvim_core::{focus::focus_neovim, utils::classname};
 use termlauncher::{Application, CustomTerminal, Terminal};
 use which::which;
 
-use crate::{
-    neovide,
-    plugin_config::{LauncherType, PluginConfig, SocketType},
-    utils::{self, is_port_in_use},
-};
-
 const ERR_NEOVIDE_NOT_FOUND: &str = "Could not find Neovide, have you installed it?";
 const ERR_TERMINAL_NOT_FOUND: &str = "Could not find any suitable terminal";
 
@@ -190,12 +188,7 @@ fn run_fsock(
     file: &str,
     line: Option<usize>,
 ) -> Result<()> {
-    let socket_file = utils::runtime_dir(
-        root_dir
-            .to_str()
-            .context("could not convert path to string")?,
-    )?
-    .join("neovim.sock");
+    let socket_file = nvim_server::fsock_path(root_dir)?;
 
     tracing::debug!("Using fsock at {socket_file:?}");
 
@@ -241,18 +234,8 @@ fn run_netsock(
     file: &str,
     line: Option<usize>,
 ) -> Result<()> {
-    let port_file = utils::runtime_dir(
-        root_dir
-            .to_str()
-            .context("could not convert path to string")?,
-    )?
-    .join("port");
-
-    let port: u16 = if port_file.exists() {
-        fs::read_to_string(&port_file)?.parse()?
-    } else {
-        utils::find_free_port()
-    };
+    let port_file = nvim_server::netsock_port_file(root_dir)?;
+    let port = nvim_server::read_or_allocate_netsock_port(root_dir)?;
 
     let socket = format!("127.0.0.1:{port}");
 
@@ -264,10 +247,8 @@ fn run_netsock(
         if let Err(err) = nvim_open_file_remote(nvim, &socket, file, line) {
             tracing::error!("Failed to communicate with neovim server: {err:?}");
 
-            let new_port = utils::find_free_port();
-            let socket = format!("127.0.0.1:{new_port}");
+            let socket = nvim_server::allocate_new_netsock_addr(root_dir)?;
             tracing::debug!("Trying to use netsock with port {socket}");
-            fs::write(port_file, new_port.to_string())?;
 
             app.args = apply_vars(&app.args, VAR_ADDRESS, &socket);
             report_process_errors(app.launch_with(launcher)?)?;

crates/bridge/src/utils.rs

@@ -1,19 +1,5 @@
-use std::{fs, net::TcpListener, path::PathBuf};
-
-use anyhow::{Context, Result};
-use defold_nvim_core::utils::project_id;
 use netstat2::{AddressFamilyFlags, ProtocolFlags, get_sockets_info};
 
-pub fn runtime_dir(root_dir: &str) -> Result<PathBuf> {
-    let dir = dirs::cache_dir()
-        .context("could not get cache dir")?
-        .join("defold.nvim")
-        .join("runtime")
-        .join(project_id(root_dir)?);
-    fs::create_dir_all(&dir)?;
-    Ok(dir)
-}
-
 pub fn is_port_in_use(port: u16) -> bool {
     let af_flags = AddressFamilyFlags::IPV4 | AddressFamilyFlags::IPV6;
     let proto_flags = ProtocolFlags::TCP | ProtocolFlags::UDP;
@@ -35,11 +21,3 @@ pub fn is_port_in_use(port: u16) -> bool {
     }
     false
 }
-
-pub fn find_free_port() -> u16 {
-    TcpListener::bind("127.0.0.1:0")
-        .expect("Failed to bind")
-        .local_addr()
-        .expect("Failed to get local addr")
-        .port()
-}

crates/core/src/lib.rs

@@ -8,6 +8,7 @@ pub mod game_project;
 pub mod github;
 pub mod mobdap;
 pub mod neovide;
+pub mod nvim_server;
 pub mod project;
 mod release_downloader;
 pub mod script_api;

crates/core/src/nvim_server.rs

@@ -0,0 +1,109 @@
+use crate::utils::project_id;
+use anyhow::{Context, Result, bail};
+use std::{
+    fs,
+    net::TcpListener,
+    path::{Path, PathBuf},
+};
+
+#[derive(Debug, Clone, Copy)]
+pub enum SocketType {
+    Fsock,
+    Netsock,
+}
+
+impl SocketType {
+    pub fn parse(value: &str) -> Result<Self> {
+        match value {
+            "fsock" => Ok(Self::Fsock),
+            "netsock" => Ok(Self::Netsock),
+            _ => bail!("Invalid socket type '{value}', expected 'fsock' or 'netsock'"),
+        }
+    }
+}
+
+#[must_use]
+pub fn default_socket_type() -> SocketType {
+    if cfg!(target_os = "linux") || cfg!(target_os = "macos") {
+        SocketType::Fsock
+    } else {
+        SocketType::Netsock
+    }
+}
+
+pub fn runtime_dir(root_dir: &Path) -> Result<PathBuf> {
+    let root_dir = root_dir
+        .to_str()
+        .context("could not convert root dir to string")?;
+
+    let dir = dirs::cache_dir()
+        .context("could not get cache dir")?
+        .join("defold.nvim")
+        .join("runtime")
+        .join(project_id(root_dir)?);
+
+    fs::create_dir_all(&dir)?;
+    Ok(dir)
+}
+
+pub fn fsock_path(root_dir: &Path) -> Result<PathBuf> {
+    Ok(runtime_dir(root_dir)?.join("neovim.sock"))
+}
+
+pub fn netsock_port_file(root_dir: &Path) -> Result<PathBuf> {
+    Ok(runtime_dir(root_dir)?.join("port"))
+}
+
+#[must_use]
+pub fn find_free_port() -> Result<u16> {
+    let listener = TcpListener::bind("127.0.0.1:0")?;
+    let port = listener.local_addr()?.port();
+    Ok(port)
+}
+
+pub fn read_or_allocate_netsock_port(root_dir: &Path) -> Result<u16> {
+    let port_file = netsock_port_file(root_dir)?;
+
+    if port_file.exists() {
+        match fs::read_to_string(&port_file) {
+            Ok(content) => {
+                if let Ok(port) = content.trim().parse::<u16>() {
+                    return Ok(port);
+                }
+            }
+            Err(err) => {
+                tracing::warn!(
+                    "Could not read netsock port file '{}': {err}",
+                    port_file.display()
+                );
+            }
+        }
+    }
+
+    allocate_new_netsock_port(root_dir)
+}
+
+pub fn allocate_new_netsock_port(root_dir: &Path) -> Result<u16> {
+    let port_file = netsock_port_file(root_dir)?;
+    let port = find_free_port()?;
+    fs::write(port_file, port.to_string())?;
+    Ok(port)
+}
+
+pub fn allocate_new_netsock_addr(root_dir: &Path) -> Result<String> {
+    let port = allocate_new_netsock_port(root_dir)?;
+    Ok(format!("127.0.0.1:{port}"))
+}
+
+pub fn resolve_server_addr(root_dir: &Path, socket_type: Option<SocketType>) -> Result<String> {
+    match socket_type.unwrap_or_else(default_socket_type) {
+        SocketType::Fsock => Ok(fsock_path(root_dir)?
+            .to_str()
+            .context("could not convert socket file to string")?
+            .to_string()),
+        SocketType::Netsock => {
+            let port = read_or_allocate_netsock_port(root_dir)?;
+            Ok(format!("127.0.0.1:{port}"))
+        }
+    }
+}

crates/sidecar/src/lib.rs

@@ -1,5 +1,5 @@
 use anyhow::Context;
-use defold_nvim_core::{bridge, editor, editor_config, mobdap, project, utils};
+use defold_nvim_core::{bridge, editor, editor_config, mobdap, nvim_server, project, utils};
 use defold_nvim_core::{focus, game_project::GameProject};
 use mlua::Value;
 use mlua::prelude::*;
@@ -91,6 +91,10 @@ fn register_exports(lua: &Lua) -> LuaResult<LuaTable> {
         lua.create_function(set_default_editor)?,
     )?;
     exports.set("find_bridge_path", lua.create_function(find_bridge_path)?)?;
+    exports.set(
+        "resolve_nvim_server_addr",
+        lua.create_function(resolve_nvim_server_addr)?,
+    )?;
     exports.set("focus_neovim", lua.create_function(focus_neovim)?)?;
     exports.set("focus_game", lua.create_function(focus_game)?)?;
     exports.set("mobdap_install", lua.create_function(mobdap_install)?)?;
@@ -180,6 +184,21 @@ fn find_bridge_path(_lua: &Lua, plugin_root: Option<String>) -> LuaResult<String
         .to_string())
 }
 
+#[instrument(level = "debug", err(Debug), skip_all)]
+fn resolve_nvim_server_addr(
+    _lua: &Lua,
+    (game_root, socket_type): (String, Option<String>),
+) -> LuaResult<String> {
+    let root = absolute(game_root)?;
+    let socket_type = socket_type
+        .as_deref()
+        .map(nvim_server::SocketType::parse)
+        .transpose()?;
+
+    let addr = nvim_server::resolve_server_addr(&root, socket_type)?;
+    Ok(addr)
+}
+
 #[instrument(level = "debug", err(Debug), skip_all)]
 fn focus_neovim(_lua: &Lua, game_root: String) -> LuaResult<()> {
     focus::focus_neovim(absolute(game_root)?)?;

lua/defold/init.lua

@@ -171,6 +171,11 @@ function M.setup(opts)
 
     vim.defer_fn(function()
         local project = require "defold.project"
+
+        if project.is_defold_project() then
+            project.ensure_nvim_server(M.config.launcher.socket_type)
+        end
+
         local port = project.editor_port()
 
         if M.config.defold.set_default_editor and port then

lua/defold/project.lua

@@ -31,6 +31,57 @@ function M.is_defold_project()
     return vim.fn.filereadable(root_dir .. "/game.project") == 1
 end
 
+---@return boolean
+local function is_server_registered(server_addr)
+    for _, addr in ipairs(vim.fn.serverlist()) do
+        if addr == server_addr then
+            return true
+        end
+    end
+
+    return false
+end
+
+---@param socket_type "fsock"|"netsock"|nil
+---@return string|nil
+function M.ensure_nvim_server(socket_type)
+    local log = require "defold.service.logger"
+
+    for _, arg in ipairs(vim.v.argv) do
+        -- if neovim was started with `--listen` flag we don't need to try to start a new server
+        if arg == "--listen" then
+            log.debug "Neovim was started with `--listen`, no need to start a server"
+            return nil
+        end
+    end
+
+    local root = M.project_root()
+    if not root then
+        return nil
+    end
+
+    local sidecar = require "defold.sidecar"
+
+    local ok_addr, addr = pcall(sidecar.resolve_nvim_server_addr, root, socket_type)
+    if not ok_addr then
+        log.error(string.format("Could not resolve Neovim server address because: %s", addr))
+        return nil
+    end
+
+    if is_server_registered(addr) then
+        log.debug(string.format("Neovim is running with server: %s", addr))
+        return addr
+    end
+
+    local ok_server, server = pcall(vim.fn.serverstart, addr)
+    if ok_server then
+        log.debug(string.format("Started new Neovim server at: %s", server))
+        return server
+    end
+
+    return nil
+end
+
 M._editor_port = nil
 
 ---Find defold editor port for current project

lua/defold/sidecar.lua

@@ -185,6 +185,7 @@ package.cpath = package.cpath
 ---@field send_command function(port: integer, cmd: string)
 ---@field set_default_editor function(port: integer, plugin_root: string, launcher_config: LauncherSettings)
 ---@field find_bridge_path function(plugin_root: string|nil): string
+---@field resolve_nvim_server_addr function(game_root: string, socket_type: "fsock"|"netsock"|nil): string
 ---@field focus_neovim function(game_root: string)
 ---@field focus_game function(game_root: string)
 ---@field mobdap_install function(): string