gitlab.nvim/lua/gitlab/server.lua at develop · harrisoncramer/gitlab.nvim · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

-- This module contains the logic responsible for building and starting

-- the Golang server. The Go server is responsible for making API calls

-- to Gitlab and returning the data

local state = require("gitlab.state")

local u = require("gitlab.utils")

local client = require("gitlab.client")

local version = require("gitlab.version")

local GitlabGroup = require("gitlab.autocmd")

local M = {}

---@type vim.SystemObj?

local server_system_obj

local kill_autocmd_created = false

-- Set when the VimLeavePre autocmd kills the server, so that the server's

-- on_exit callback skips the "server exited" error notification: it would

-- otherwise fire (and might fail to render) while nvim is tearing down.

local killed_on_exit = false

-- Builds the binary if it doesn't exist, and starts the server. If the pre-existing binary has an older

-- tag than the Lua code (exposed via the /version endpoint) then shuts down the server, rebuilds it, and

-- restarts the server again.

M.build_and_start = function(callback)

if M.build(false) == false then

return

end

-- When the user provides their own binary, skip the version check and rebuild cycle.

-- The user is responsible for keeping their binary up to date.

local user_provided_binary = state.settings.server.binary_provided

M.start(function()

if user_provided_binary then

callback()

return

end

M.get_version(function(versions)

if versions.plugin_version ~= versions.binary_version then

M.shutdown(function()

if M.build(true) then

M.start(callback)

end

end)

else

callback()

end

end)

end

---Starts the Go server and call the callback provided

M.start = function(callback)

if state.settings.port ~= nil and state.settings.server.port == nil then

state.settings.server.port = state.settings.port

u.notify("The setting `port` has been renamed `server.port`", vim.log.levels.WARN)

end

local port = tonumber(state.settings.server.port) or 0

local parsed_port = nil

local callback_called = false

local go_server_settings = {

gitlab_url = state.settings.gitlab_url,

port = port,

auth_token = state.settings.auth_token,

debug = state.settings.debug,

log_path = state.settings.log_path,

connection_settings = state.settings.connection_settings,

chosen_mr_iid = state.chosen_mr_iid,

}

state.chosen_mr_iid = 0 -- Do not let this interfere with subsequent reviewer.open() calls

local settings = vim.json.encode(go_server_settings)

if not kill_autocmd_created then

kill_autocmd_created = true

vim.api.nvim_create_autocmd({ "VimLeavePre" }, {

callback = function()

if server_system_obj == nil then

return

end

killed_on_exit = true

-- Send SIGKILL rather than SIGTERM: the server is a stateless proxy to the

-- Gitlab API, and a graceful shutdown would wait for in-flight requests.

-- Use `pcall` because the handle is already closed if the process exited on

-- its own, e.g. through the /shutdown endpoint.

pcall(function()

server_system_obj:kill("sigkill")

end)

server_system_obj = nil

end,

desc = "Kill the gitlab.nvim Go server process",

group = GitlabGroup,

})

end

local ok, obj = pcall(vim.system, { state.settings.server.binary, settings }, {

-- The `stdin` param opens a pipe on the server's stdin that nvim holds open but

-- never writes to. The server exits when it sees EOF on the pipe, which is how it

-- notices that nvim is gone in the cases the VimLeavePre autocmd cannot cover:

-- SIGKILL, an OOM kill, or a crash.

stdin = true,

stdout = function(_, data)

if data == nil or parsed_port ~= nil then

return

end

for line in data:gmatch("[^\r\n]+") do

local matched = line:match("Server started on port:%s+(%d+)")

if matched ~= nil then

parsed_port = matched

vim.schedule(function()

state.settings.server.port = matched

state.go_server_running = true

if not callback_called then

callback_called = true

callback()

end

end)

break

end

end,

}, function(out)

if out.code ~= 0 and not killed_on_exit then

vim.schedule(function()

local msg = "Golang gitlab server exited: code: " .. out.code .. ", signal: " .. (out.signal or 0)

if out.stderr ~= "" then

msg = msg .. ", msg: " .. vim.trim(out.stderr)

end

u.notify(msg, vim.log.levels.ERROR)

end)

end

end)

if ok then

server_system_obj = obj

else

u.notify("Could not start gitlab.nvim binary: " .. tostring(obj), vim.log.levels.ERROR)

end

-- Builds the Go binary with the current Git tag.

M.build = function(override)

state.settings.root_path = u.get_root_path()

-- If the user provided a path to the server, don't build it.

if state.settings.server.binary_provided then

return

end

local version_issue = version.check_go_version()

if version_issue ~= nil then

return

end

-- If the user did not provide a path, we build it and place it in either the data path, or the

-- first writable path we find in the runtime.

local datapath = vim.fn.stdpath("data")

local runtimepath = vim.api.nvim_list_runtime_paths()

table.insert(runtimepath, 1, datapath)

local bin_name = u.is_windows() and "server.exe" or "server"

local bin_folder

for _, path in ipairs(runtimepath) do

local ok, err = vim.loop.fs_access(path, "w")

if err == nil and ok ~= nil and ok then

bin_folder = path .. u.path_separator .. "gitlab.nvim" .. u.path_separator .. "bin"

if vim.fn.mkdir(bin_folder, "p") == 1 then

state.settings.server.binary = bin_folder .. u.path_separator .. bin_name

break

end

if state.settings.server.binary == nil then

u.notify("Could not find a writable folder in the runtime path to save the server to.", vim.log.levels.ERROR)

return

end

if not override then

local binary_exists = vim.loop.fs_stat(state.settings.server.binary)

if binary_exists ~= nil then

return

end

local version_output = vim

.system({ "git", "describe", "--tags", "--always" }, { cwd = state.settings.root_path })

:wait()

local plugin_version = version_output.code == 0 and vim.trim(version_output.stdout) or "unknown"

local ldflags = string.format("-X main.Version=%s", plugin_version)

local res = vim

.system(

{ "go", "build", "-buildvcs=false", "-ldflags", ldflags, "-o", state.settings.server.binary },

{ cwd = state.settings.root_path .. u.path_separator .. "cmd" }

)

:wait()

if res.code ~= 0 then

u.notify(string.format("Failed to install with status code %d:\n%s", res.code, res.stderr), vim.log.levels.ERROR)

return false

end

u.notify("Installed successfully!", vim.log.levels.INFO)

return true

end

-- Shuts down the Go server and clears out all old gitlab.nvim state

M.shutdown = function(cb)

if not state.go_server_running then

vim.notify("The gitlab.nvim server is not running", vim.log.levels.ERROR)

return

end

client.send_request("/shutdown", "POST", { restart = false }, function(data)

state.go_server_running = false

state.clear_data()

if cb then

cb()

else

u.notify(data.message, vim.log.levels.INFO)

end

end)

end

---Restarts the Go server and clears out all gitlab.nvim state

M.restart = function(cb)

if not state.go_server_running then

vim.notify("The gitlab.nvim server is not running", vim.log.levels.ERROR)

return

end

client.send_request("/shutdown", "POST", { restart = true }, function(data)

state.go_server_running = false

M.start(function()

state.clear_data()

if cb then

cb()

else

u.notify(data.message, vim.log.levels.INFO)

end

end)

end

-- Runs `callback` with the version (git tag) that was baked into the binary when it was last built.

M.get_version = function(callback)

if not state.go_server_running then

u.notify("Gitlab server not running", vim.log.levels.ERROR)

return

end

local parent_dir = u.get_root_path()

local version_output = vim.system({ "git", "describe", "--tags", "--always" }, { cwd = parent_dir }):wait()

local plugin_version = version_output.code == 0 and vim.trim(version_output.stdout) or "unknown"

-- We call the "/version" endpoint here instead of through the regular send_request

-- pattern because earlier versions of the plugin may not have the endpoint. We handle

-- a 404 as an "unknown" version error.

local cmd = {

"curl",

"--noproxy",

"localhost",

"-s",

"-X",

"GET",

string.format("localhost:%s/version", state.settings.server.port),

}

local result = vim.system(cmd):wait()

local _, data = pcall(vim.json.decode, result.stdout)

local binary_version = data and data.version and data.version or "unknown"

callback({ plugin_version = plugin_version, binary_version = binary_version })

end

return M

gitlab.nvim/lua/gitlab/server.lua at develop · harrisoncramer/gitlab.nvim · GitHub

Repository navigation

Expand file tree

Breadcrumbs

server.lua

Latest commit

History

Breadcrumbs

server.lua

File metadata and controls