atom-languageclient
Version:
Integrate Language Servers with Atom
313 lines • 46.5 kB
JavaScript
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.considerAdditionalPath = exports.normalizePath = exports.normalizedProjectPathToWorkspaceFolder = exports.projectPathToWorkspaceFolder = exports.ServerManager = void 0;
const convert_1 = require("./convert");
const path = require("path");
const atom_1 = require("atom");
/** Manages the language server lifecycles and their associated objects necessary for adapting them to Atom IDE. */
class ServerManager {
constructor(_startServer, _logger, _startForEditor, _changeWatchedFileFilter, _reportBusyWhile, _languageServerName, _determineProjectPath, shutdownGracefully) {
this._startServer = _startServer;
this._logger = _logger;
this._startForEditor = _startForEditor;
this._changeWatchedFileFilter = _changeWatchedFileFilter;
this._reportBusyWhile = _reportBusyWhile;
this._languageServerName = _languageServerName;
this._determineProjectPath = _determineProjectPath;
this.shutdownGracefully = shutdownGracefully;
this._activeServers = [];
this._startingServerPromises = new Map();
this._restartCounterPerProject = new Map();
this._stoppingServers = [];
this._disposable = new atom_1.CompositeDisposable();
this._editorToServer = new Map();
this._normalizedProjectPaths = [];
this._previousNormalizedProjectPaths = undefined; // TODO we should not hold a separate cache
this._isStarted = false;
/** @deprecated Use the exported `normalizePath` function */
this.normalizePath = normalizePath;
this.updateNormalizedProjectPaths();
}
startListening() {
if (!this._isStarted) {
this._disposable = new atom_1.CompositeDisposable();
this._disposable.add(atom.textEditors.observe(this.observeTextEditors.bind(this)));
this._disposable.add(atom.project.onDidChangePaths(this.projectPathsChanged.bind(this)));
if (atom.project.onDidChangeFiles) {
this._disposable.add(atom.project.onDidChangeFiles(this.projectFilesChanged.bind(this)));
}
}
this._isStarted = true;
}
stopListening() {
if (this._isStarted) {
this._disposable.dispose();
this._isStarted = false;
}
}
observeTextEditors(editor) {
// Track grammar changes for opened editors
const listener = editor.observeGrammar((_grammar) => this._handleGrammarChange(editor));
this._disposable.add(editor.onDidDestroy(() => listener.dispose()));
// Try to see if editor can have LS connected to it
this._handleTextEditor(editor);
}
_handleTextEditor(editor) {
return __awaiter(this, void 0, void 0, function* () {
if (!this._editorToServer.has(editor)) {
// editor hasn't been processed yet, so process it by allocating LS for it if necessary
const server = yield this.getServer(editor, { shouldStart: true });
if (server != null) {
// There LS for the editor (either started now and already running)
this._editorToServer.set(editor, server);
this._disposable.add(editor.onDidDestroy(() => {
this._editorToServer.delete(editor);
this.stopUnusedServers();
}));
}
}
});
}
_handleGrammarChange(editor) {
if (this._startForEditor(editor)) {
// If editor is interesting for LS process the editor further to attempt to start LS if needed
this._handleTextEditor(editor);
}
else {
// Editor is not supported by the LS
const server = this._editorToServer.get(editor);
// If LS is running for the unsupported editor then disconnect the editor from LS and shut down LS if necessary
if (server) {
// Remove editor from the cache
this._editorToServer.delete(editor);
// Shut down LS if it's used by any other editor
this.stopUnusedServers();
}
}
}
getActiveServers() {
return this._activeServers;
}
getServer(textEditor, { shouldStart } = { shouldStart: false }) {
return __awaiter(this, void 0, void 0, function* () {
const finalProjectPath = this._determineProjectPath(textEditor);
if (finalProjectPath == null) {
// Files not yet saved have no path
return null;
}
const foundActiveServer = this._activeServers.find((s) => finalProjectPath === s.projectPath);
if (foundActiveServer) {
return foundActiveServer;
}
const startingPromise = this._startingServerPromises.get(finalProjectPath);
if (startingPromise) {
return startingPromise;
}
// TODO remove eslint-disable
// eslint-disable-next-line no-return-await
return shouldStart && this._startForEditor(textEditor) ? yield this.startServer(finalProjectPath) : null;
});
}
startServer(projectPath) {
return __awaiter(this, void 0, void 0, function* () {
this._logger.debug(`Server starting "${projectPath}"`);
const startingPromise = this._startServer(projectPath);
this._startingServerPromises.set(projectPath, startingPromise);
try {
const startedActiveServer = yield startingPromise;
this._activeServers.push(startedActiveServer);
this._startingServerPromises.delete(projectPath);
this._logger.debug(`Server started "${projectPath}" (pid ${startedActiveServer.process.pid})`);
return startedActiveServer;
}
catch (e) {
this._startingServerPromises.delete(projectPath);
throw e;
}
});
}
stopUnusedServers() {
return __awaiter(this, void 0, void 0, function* () {
const usedServers = new Set(this._editorToServer.values());
const unusedServers = this._activeServers.filter((s) => !usedServers.has(s));
if (unusedServers.length > 0) {
this._logger.debug(`Stopping ${unusedServers.length} unused servers`);
yield Promise.all(unusedServers.map((s) => this.stopServer(s)));
}
});
}
stopAllServers() {
return __awaiter(this, void 0, void 0, function* () {
for (const [projectPath, restartCounter] of this._restartCounterPerProject) {
clearTimeout(restartCounter.timerId);
this._restartCounterPerProject.delete(projectPath);
}
yield Promise.all(this._activeServers.map((s) => this.stopServer(s)));
});
}
restartAllServers() {
return __awaiter(this, void 0, void 0, function* () {
this.stopListening();
yield this.stopAllServers();
this._editorToServer = new Map();
this.startListening();
});
}
hasServerReachedRestartLimit(server) {
let restartCounter = this._restartCounterPerProject.get(server.projectPath);
if (!restartCounter) {
restartCounter = {
restarts: 0,
timerId: setTimeout(() => {
this._restartCounterPerProject.delete(server.projectPath);
}, 3 * 60 * 1000 /* 3 minutes */),
};
this._restartCounterPerProject.set(server.projectPath, restartCounter);
}
return ++restartCounter.restarts > 5;
}
stopServer(server) {
return __awaiter(this, void 0, void 0, function* () {
yield this._reportBusyWhile(`Stopping ${this._languageServerName} for ${path.basename(server.projectPath)}`, () => __awaiter(this, void 0, void 0, function* () {
this._logger.debug(`Server stopping "${server.projectPath}"`);
// Immediately remove the server to prevent further usage.
// If we re-open the file after this point, we'll get a new server.
this._activeServers.splice(this._activeServers.indexOf(server), 1);
this._stoppingServers.push(server);
server.disposable.dispose();
if (this.shutdownGracefully && server.connection.isConnected) {
yield server.connection.shutdown();
}
for (const [editor, mappedServer] of this._editorToServer) {
if (mappedServer === server) {
this._editorToServer.delete(editor);
}
}
this.exitServer(server);
this._stoppingServers.splice(this._stoppingServers.indexOf(server), 1);
}));
});
}
exitServer(server) {
const pid = server.process.pid;
try {
if (server.connection.isConnected) {
server.connection.exit();
server.connection.dispose();
}
}
finally {
server.process.kill();
}
this._logger.debug(`Server stopped "${server.projectPath}" (pid ${pid})`);
}
terminate() {
this._stoppingServers.forEach((server) => {
this._logger.debug(`Server terminating "${server.projectPath}"`);
this.exitServer(server);
});
}
updateNormalizedProjectPaths() {
this._normalizedProjectPaths = atom.project.getPaths().map(normalizePath);
}
getNormalizedProjectPaths() {
return this._normalizedProjectPaths;
}
/**
* Public: fetch the current open list of workspace folders
*
* @returns A {Promise} containing an {Array} of {lsp.WorkspaceFolder[]} or {null} if only a single file is open in the tool.
*/
getWorkspaceFolders() {
// NOTE the method must return a Promise based on the specification
const projectPaths = this.getNormalizedProjectPaths();
if (projectPaths.length === 0) {
// only a single file is open
return Promise.resolve(null);
}
else {
return Promise.resolve(projectPaths.map(normalizedProjectPathToWorkspaceFolder));
}
}
projectPathsChanged(projectPaths) {
var _a;
return __awaiter(this, void 0, void 0, function* () {
const pathsAll = projectPaths.map(normalizePath);
const previousPaths = (_a = this._previousNormalizedProjectPaths) !== null && _a !== void 0 ? _a : this.getNormalizedProjectPaths();
const pathsRemoved = previousPaths.filter((projectPath) => !pathsAll.includes(projectPath));
const pathsAdded = pathsAll.filter((projectPath) => !previousPaths.includes(projectPath));
// update cache
this._previousNormalizedProjectPaths = pathsAll;
// send didChangeWorkspaceFolders
const didChangeWorkspaceFoldersParams = {
event: {
added: pathsAdded.map(normalizedProjectPathToWorkspaceFolder),
removed: pathsRemoved.map(normalizedProjectPathToWorkspaceFolder),
},
};
for (const activeServer of this._activeServers) {
activeServer.connection.didChangeWorkspaceFolders(didChangeWorkspaceFoldersParams);
}
// stop the servers that don't have projectPath
const serversToStop = this._activeServers.filter((server) => pathsRemoved.includes(server.projectPath));
yield Promise.all(serversToStop.map((s) => this.stopServer(s)));
// update this._normalizedProjectPaths
this.updateNormalizedProjectPaths();
});
}
projectFilesChanged(fileEvents) {
if (this._activeServers.length === 0) {
return;
}
for (const activeServer of this._activeServers) {
const changes = [];
for (const fileEvent of fileEvents) {
if (fileEvent.path.startsWith(activeServer.projectPath) && this._changeWatchedFileFilter(fileEvent.path)) {
changes.push(convert_1.default.atomFileEventToLSFileEvents(fileEvent)[0]);
}
if (fileEvent.action === "renamed" &&
fileEvent.oldPath.startsWith(activeServer.projectPath) &&
this._changeWatchedFileFilter(fileEvent.oldPath)) {
changes.push(convert_1.default.atomFileEventToLSFileEvents(fileEvent)[1]);
}
}
if (changes.length > 0) {
activeServer.connection.didChangeWatchedFiles({ changes });
}
}
}
}
exports.ServerManager = ServerManager;
function projectPathToWorkspaceFolder(projectPath) {
const normalizedProjectPath = normalizePath(projectPath);
return normalizedProjectPathToWorkspaceFolder(normalizedProjectPath);
}
exports.projectPathToWorkspaceFolder = projectPathToWorkspaceFolder;
function normalizedProjectPathToWorkspaceFolder(normalizedProjectPath) {
return {
uri: convert_1.default.pathToUri(normalizedProjectPath),
name: path.basename(normalizedProjectPath),
};
}
exports.normalizedProjectPathToWorkspaceFolder = normalizedProjectPathToWorkspaceFolder;
function normalizePath(projectPath) {
return !projectPath.endsWith(path.sep) ? path.join(projectPath, path.sep) : projectPath;
}
exports.normalizePath = normalizePath;
/** Considers a path for inclusion in `additionalPaths`. */
function considerAdditionalPath(server, additionalPath) {
if (!additionalPath.startsWith(server.projectPath)) {
server.additionalPaths.add(additionalPath);
}
}
exports.considerAdditionalPath = considerAdditionalPath;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-manager.js","sourceRoot":"","sources":["../../lib/server-manager.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,uCAA+B;AAC/B,6BAA4B;AAI5B,+BAA6E;AA4B7E,mHAAmH;AACnH,MAAa,aAAa;IAWxB,YACU,YAA4D,EAC5D,OAAe,EACf,eAAgD,EAChD,wBAAuD,EACvD,gBAAiC,EACjC,mBAA2B,EAC3B,qBAAgE,EAChE,kBAA2B;QAP3B,iBAAY,GAAZ,YAAY,CAAgD;QAC5D,YAAO,GAAP,OAAO,CAAQ;QACf,oBAAe,GAAf,eAAe,CAAiC;QAChD,6BAAwB,GAAxB,wBAAwB,CAA+B;QACvD,qBAAgB,GAAhB,gBAAgB,CAAiB;QACjC,wBAAmB,GAAnB,mBAAmB,CAAQ;QAC3B,0BAAqB,GAArB,qBAAqB,CAA2C;QAChE,uBAAkB,GAAlB,kBAAkB,CAAS;QAlB7B,mBAAc,GAAmB,EAAE,CAAA;QACnC,4BAAuB,GAAuC,IAAI,GAAG,EAAE,CAAA;QACvE,8BAAyB,GAAgC,IAAI,GAAG,EAAE,CAAA;QAClE,qBAAgB,GAAmB,EAAE,CAAA;QACrC,gBAAW,GAAwB,IAAI,0BAAmB,EAAE,CAAA;QAC5D,oBAAe,GAAkC,IAAI,GAAG,EAAE,CAAA;QAC1D,4BAAuB,GAAa,EAAE,CAAA;QACtC,oCAA+B,GAAyB,SAAS,CAAA,CAAC,2CAA2C;QAC7G,eAAU,GAAG,KAAK,CAAA;QA8R1B,4DAA4D;QACrD,kBAAa,GAAG,aAAa,CAAA;QAnRlC,IAAI,CAAC,4BAA4B,EAAE,CAAA;IACrC,CAAC;IAEM,cAAc;QACnB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YACpB,IAAI,CAAC,WAAW,GAAG,IAAI,0BAAmB,EAAE,CAAA;YAC5C,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;YAClF,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;YACxF,IAAI,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE;gBACjC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;aACzF;SACF;QACD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;IACxB,CAAC;IAEM,aAAa;QAClB,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAA;YAC1B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAA;SACxB;IACH,CAAC;IAEO,kBAAkB,CAAC,MAAkB;QAC3C,2CAA2C;QAC3C,MAAM,QAAQ,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAA;QACvF,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;QACnE,mDAAmD;QACnD,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAA;IAChC,CAAC;IAEa,iBAAiB,CAAC,MAAkB;;YAChD,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;gBACrC,uFAAuF;gBACvF,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAA;gBAClE,IAAI,MAAM,IAAI,IAAI,EAAE;oBAClB,mEAAmE;oBACnE,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;oBACxC,IAAI,CAAC,WAAW,CAAC,GAAG,CAClB,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE;wBACvB,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;wBACnC,IAAI,CAAC,iBAAiB,EAAE,CAAA;oBAC1B,CAAC,CAAC,CACH,CAAA;iBACF;aACF;QACH,CAAC;KAAA;IAEO,oBAAoB,CAAC,MAAkB;QAC7C,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE;YAChC,8FAA8F;YAC9F,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAA;SAC/B;aAAM;YACL,oCAAoC;YACpC,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;YAC/C,+GAA+G;YAC/G,IAAI,MAAM,EAAE;gBACV,+BAA+B;gBAC/B,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;gBACnC,gDAAgD;gBAChD,IAAI,CAAC,iBAAiB,EAAE,CAAA;aACzB;SACF;IACH,CAAC;IAEM,gBAAgB;QACrB,OAAO,IAAI,CAAC,cAAc,CAAA;IAC5B,CAAC;IAEY,SAAS,CACpB,UAAsB,EACtB,EAAE,WAAW,KAAgC,EAAE,WAAW,EAAE,KAAK,EAAE;;YAEnE,MAAM,gBAAgB,GAAG,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAA;YAC/D,IAAI,gBAAgB,IAAI,IAAI,EAAE;gBAC5B,mCAAmC;gBACnC,OAAO,IAAI,CAAA;aACZ;YAED,MAAM,iBAAiB,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,gBAAgB,KAAK,CAAC,CAAC,WAAW,CAAC,CAAA;YAC7F,IAAI,iBAAiB,EAAE;gBACrB,OAAO,iBAAiB,CAAA;aACzB;YAED,MAAM,eAAe,GAAG,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAA;YAC1E,IAAI,eAAe,EAAE;gBACnB,OAAO,eAAe,CAAA;aACvB;YACD,6BAA6B;YAC7B,2CAA2C;YAC3C,OAAO,WAAW,IAAI,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;QAC1G,CAAC;KAAA;IAEY,WAAW,CAAC,WAAmB;;YAC1C,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,oBAAoB,WAAW,GAAG,CAAC,CAAA;YACtD,MAAM,eAAe,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,CAAA;YACtD,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,WAAW,EAAE,eAAe,CAAC,CAAA;YAC9D,IAAI;gBACF,MAAM,mBAAmB,GAAG,MAAM,eAAe,CAAA;gBACjD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAA;gBAC7C,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;gBAChD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,mBAAmB,WAAW,UAAU,mBAAmB,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC,CAAA;gBAC9F,OAAO,mBAAmB,CAAA;aAC3B;YAAC,OAAO,CAAC,EAAE;gBACV,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;gBAChD,MAAM,CAAC,CAAA;aACR;QACH,CAAC;KAAA;IAEY,iBAAiB;;YAC5B,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,CAAA;YAC1D,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;YAC5E,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC5B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,aAAa,CAAC,MAAM,iBAAiB,CAAC,CAAA;gBACrE,MAAM,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;aAChE;QACH,CAAC;KAAA;IAEY,cAAc;;YACzB,KAAK,MAAM,CAAC,WAAW,EAAE,cAAc,CAAC,IAAI,IAAI,CAAC,yBAAyB,EAAE;gBAC1E,YAAY,CAAC,cAAc,CAAC,OAAO,CAAC,CAAA;gBACpC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;aACnD;YAED,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QACvE,CAAC;KAAA;IAEY,iBAAiB;;YAC5B,IAAI,CAAC,aAAa,EAAE,CAAA;YACpB,MAAM,IAAI,CAAC,cAAc,EAAE,CAAA;YAC3B,IAAI,CAAC,eAAe,GAAG,IAAI,GAAG,EAAE,CAAA;YAChC,IAAI,CAAC,cAAc,EAAE,CAAA;QACvB,CAAC;KAAA;IAEM,4BAA4B,CAAC,MAAoB;QACtD,IAAI,cAAc,GAAG,IAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;QAE3E,IAAI,CAAC,cAAc,EAAE;YACnB,cAAc,GAAG;gBACf,QAAQ,EAAE,CAAC;gBACX,OAAO,EAAE,UAAU,CAAC,GAAG,EAAE;oBACvB,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;gBAC3D,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,eAAe,CAAC;aAClC,CAAA;YAED,IAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,EAAE,cAAc,CAAC,CAAA;SACvE;QAED,OAAO,EAAE,cAAc,CAAC,QAAQ,GAAG,CAAC,CAAA;IACtC,CAAC;IAEY,UAAU,CAAC,MAAoB;;YAC1C,MAAM,IAAI,CAAC,gBAAgB,CACzB,YAAY,IAAI,CAAC,mBAAmB,QAAQ,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,EAC/E,GAAS,EAAE;gBACT,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,oBAAoB,MAAM,CAAC,WAAW,GAAG,CAAC,CAAA;gBAC7D,0DAA0D;gBAC1D,mEAAmE;gBACnE,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAA;gBAClE,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;gBAClC,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,CAAA;gBAC3B,IAAI,IAAI,CAAC,kBAAkB,IAAI,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE;oBAC5D,MAAM,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAA;iBACnC;gBAED,KAAK,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,IAAI,IAAI,CAAC,eAAe,EAAE;oBACzD,IAAI,YAAY,KAAK,MAAM,EAAE;wBAC3B,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;qBACpC;iBACF;gBAED,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;gBACvB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAA;YACxE,CAAC,CAAA,CACF,CAAA;QACH,CAAC;KAAA;IAEM,UAAU,CAAC,MAAoB;QACpC,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAA;QAC9B,IAAI;YACF,IAAI,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE;gBACjC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,CAAA;gBACxB,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,CAAA;aAC5B;SACF;gBAAS;YACR,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,CAAA;SACtB;QACD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,mBAAmB,MAAM,CAAC,WAAW,UAAU,GAAG,GAAG,CAAC,CAAA;IAC3E,CAAC;IAEM,SAAS;QACd,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YACvC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,uBAAuB,MAAM,CAAC,WAAW,GAAG,CAAC,CAAA;YAChE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;QACzB,CAAC,CAAC,CAAA;IACJ,CAAC;IAEM,4BAA4B;QACjC,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;IAC3E,CAAC;IAEM,yBAAyB;QAC9B,OAAO,IAAI,CAAC,uBAAuB,CAAA;IACrC,CAAC;IAED;;;;OAIG;IACI,mBAAmB;QACxB,mEAAmE;QACnE,MAAM,YAAY,GAAG,IAAI,CAAC,yBAAyB,EAAE,CAAA;QACrD,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;YAC7B,6BAA6B;YAC7B,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;SAC7B;aAAM;YACL,OAAO,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,sCAAsC,CAAC,CAAC,CAAA;SACjF;IACH,CAAC;IAEY,mBAAmB,CAAC,YAAsB;;;YACrD,MAAM,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;YAEhD,MAAM,aAAa,GAAG,MAAA,IAAI,CAAC,+BAA+B,mCAAI,IAAI,CAAC,yBAAyB,EAAE,CAAA;YAC9F,MAAM,YAAY,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAA;YAC3F,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAA;YAEzF,eAAe;YACf,IAAI,CAAC,+BAA+B,GAAG,QAAQ,CAAA;YAE/C,iCAAiC;YACjC,MAAM,+BAA+B,GAAG;gBACtC,KAAK,EAAE;oBACL,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,sCAAsC,CAAC;oBAC7D,OAAO,EAAE,YAAY,CAAC,GAAG,CAAC,sCAAsC,CAAC;iBAClE;aACF,CAAA;YACD,KAAK,MAAM,YAAY,IAAI,IAAI,CAAC,cAAc,EAAE;gBAC9C,YAAY,CAAC,UAAU,CAAC,yBAAyB,CAAC,+BAA+B,CAAC,CAAA;aACnF;YAED,+CAA+C;YAC/C,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAA;YACvG,MAAM,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YAE/D,sCAAsC;YACtC,IAAI,CAAC,4BAA4B,EAAE,CAAA;;KACpC;IAEM,mBAAmB,CAAC,UAAiC;QAC1D,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE;YACpC,OAAM;SACP;QAED,KAAK,MAAM,YAAY,IAAI,IAAI,CAAC,cAAc,EAAE;YAC9C,MAAM,OAAO,GAAmB,EAAE,CAAA;YAClC,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;gBAClC,IAAI,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;oBACxG,OAAO,CAAC,IAAI,CAAC,iBAAO,CAAC,2BAA2B,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;iBAChE;gBACD,IACE,SAAS,CAAC,MAAM,KAAK,SAAS;oBAC9B,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,WAAW,CAAC;oBACtD,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,OAAO,CAAC,EAChD;oBACA,OAAO,CAAC,IAAI,CAAC,iBAAO,CAAC,2BAA2B,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;iBAChE;aACF;YACD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;gBACtB,YAAY,CAAC,UAAU,CAAC,qBAAqB,CAAC,EAAE,OAAO,EAAE,CAAC,CAAA;aAC3D;SACF;IACH,CAAC;CAIF;AAzSD,sCAySC;AAED,SAAgB,4BAA4B,CAAC,WAAmB;IAC9D,MAAM,qBAAqB,GAAG,aAAa,CAAC,WAAW,CAAC,CAAA;IACxD,OAAO,sCAAsC,CAAC,qBAAqB,CAAC,CAAA;AACtE,CAAC;AAHD,oEAGC;AAED,SAAgB,sCAAsC,CAAC,qBAA6B;IAClF,OAAO;QACL,GAAG,EAAE,iBAAO,CAAC,SAAS,CAAC,qBAAqB,CAAC;QAC7C,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,qBAAqB,CAAC;KAC3C,CAAA;AACH,CAAC;AALD,wFAKC;AAED,SAAgB,aAAa,CAAC,WAAmB;IAC/C,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAA;AACzF,CAAC;AAFD,sCAEC;AAED,2DAA2D;AAC3D,SAAgB,sBAAsB,CACpC,MAAuD,EACvD,cAAsB;IAEtB,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE;QAClD,MAAM,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;KAC3C;AACH,CAAC;AAPD,wDAOC","sourcesContent":["import Convert from \"./convert\"\nimport * as path from \"path\"\nimport * as ls from \"./languageclient\"\nimport { ChildProcess } from \"child_process\"\nimport { Logger } from \"./logger\"\nimport { CompositeDisposable, FilesystemChangeEvent, TextEditor } from \"atom\"\nimport { ReportBusyWhile } from \"./utils\"\n\nexport type MinimalLanguageServerProcess = Pick<ChildProcess, \"stdin\" | \"stdout\" | \"stderr\" | \"pid\" | \"kill\" | \"on\">\n\n/**\n * Public: Defines a language server process which is either a ChildProcess, or it is a minimal object that resembles a\n * ChildProcess. `MinimalLanguageServerProcess` is used so that language packages with alternative language server\n * process hosting strategies can return something compatible with `AutoLanguageClient.startServerProcess`.\n */\nexport type LanguageServerProcess = ChildProcess | MinimalLanguageServerProcess\n\n/** The necessary elements for a server that has started or is starting. */\nexport interface ActiveServer {\n  disposable: CompositeDisposable\n  projectPath: string\n  process: LanguageServerProcess\n  connection: ls.LanguageClientConnection\n  capabilities: ls.ServerCapabilities\n  /** Out of project directories that this server can also support. */\n  additionalPaths?: Set<string>\n}\n\ninterface RestartCounter {\n  restarts: number\n  timerId: NodeJS.Timer\n}\n\n/** Manages the language server lifecycles and their associated objects necessary for adapting them to Atom IDE. */\nexport class ServerManager {\n  private _activeServers: ActiveServer[] = []\n  private _startingServerPromises: Map<string, Promise<ActiveServer>> = new Map()\n  private _restartCounterPerProject: Map<string, RestartCounter> = new Map()\n  private _stoppingServers: ActiveServer[] = []\n  private _disposable: CompositeDisposable = new CompositeDisposable()\n  private _editorToServer: Map<TextEditor, ActiveServer> = new Map()\n  private _normalizedProjectPaths: string[] = []\n  private _previousNormalizedProjectPaths: string[] | undefined = undefined // TODO we should not hold a separate cache\n  private _isStarted = false\n\n  constructor(\n    private _startServer: (projectPath: string) => Promise<ActiveServer>,\n    private _logger: Logger,\n    private _startForEditor: (editor: TextEditor) => boolean,\n    private _changeWatchedFileFilter: (filePath: string) => boolean,\n    private _reportBusyWhile: ReportBusyWhile,\n    private _languageServerName: string,\n    private _determineProjectPath: (textEditor: TextEditor) => string | null,\n    private shutdownGracefully: boolean\n  ) {\n    this.updateNormalizedProjectPaths()\n  }\n\n  public startListening(): void {\n    if (!this._isStarted) {\n      this._disposable = new CompositeDisposable()\n      this._disposable.add(atom.textEditors.observe(this.observeTextEditors.bind(this)))\n      this._disposable.add(atom.project.onDidChangePaths(this.projectPathsChanged.bind(this)))\n      if (atom.project.onDidChangeFiles) {\n        this._disposable.add(atom.project.onDidChangeFiles(this.projectFilesChanged.bind(this)))\n      }\n    }\n    this._isStarted = true\n  }\n\n  public stopListening(): void {\n    if (this._isStarted) {\n      this._disposable.dispose()\n      this._isStarted = false\n    }\n  }\n\n  private observeTextEditors(editor: TextEditor): void {\n    // Track grammar changes for opened editors\n    const listener = editor.observeGrammar((_grammar) => this._handleGrammarChange(editor))\n    this._disposable.add(editor.onDidDestroy(() => listener.dispose()))\n    // Try to see if editor can have LS connected to it\n    this._handleTextEditor(editor)\n  }\n\n  private async _handleTextEditor(editor: TextEditor): Promise<void> {\n    if (!this._editorToServer.has(editor)) {\n      // editor hasn't been processed yet, so process it by allocating LS for it if necessary\n      const server = await this.getServer(editor, { shouldStart: true })\n      if (server != null) {\n        // There LS for the editor (either started now and already running)\n        this._editorToServer.set(editor, server)\n        this._disposable.add(\n          editor.onDidDestroy(() => {\n            this._editorToServer.delete(editor)\n            this.stopUnusedServers()\n          })\n        )\n      }\n    }\n  }\n\n  private _handleGrammarChange(editor: TextEditor) {\n    if (this._startForEditor(editor)) {\n      // If editor is interesting for LS process the editor further to attempt to start LS if needed\n      this._handleTextEditor(editor)\n    } else {\n      // Editor is not supported by the LS\n      const server = this._editorToServer.get(editor)\n      // If LS is running for the unsupported editor then disconnect the editor from LS and shut down LS if necessary\n      if (server) {\n        // Remove editor from the cache\n        this._editorToServer.delete(editor)\n        // Shut down LS if it's used by any other editor\n        this.stopUnusedServers()\n      }\n    }\n  }\n\n  public getActiveServers(): Readonly<ActiveServer[]> {\n    return this._activeServers\n  }\n\n  public async getServer(\n    textEditor: TextEditor,\n    { shouldStart }: { shouldStart?: boolean } = { shouldStart: false }\n  ): Promise<ActiveServer | null> {\n    const finalProjectPath = this._determineProjectPath(textEditor)\n    if (finalProjectPath == null) {\n      // Files not yet saved have no path\n      return null\n    }\n\n    const foundActiveServer = this._activeServers.find((s) => finalProjectPath === s.projectPath)\n    if (foundActiveServer) {\n      return foundActiveServer\n    }\n\n    const startingPromise = this._startingServerPromises.get(finalProjectPath)\n    if (startingPromise) {\n      return startingPromise\n    }\n    // TODO remove eslint-disable\n    // eslint-disable-next-line no-return-await\n    return shouldStart && this._startForEditor(textEditor) ? await this.startServer(finalProjectPath) : null\n  }\n\n  public async startServer(projectPath: string): Promise<ActiveServer> {\n    this._logger.debug(`Server starting \"${projectPath}\"`)\n    const startingPromise = this._startServer(projectPath)\n    this._startingServerPromises.set(projectPath, startingPromise)\n    try {\n      const startedActiveServer = await startingPromise\n      this._activeServers.push(startedActiveServer)\n      this._startingServerPromises.delete(projectPath)\n      this._logger.debug(`Server started \"${projectPath}\" (pid ${startedActiveServer.process.pid})`)\n      return startedActiveServer\n    } catch (e) {\n      this._startingServerPromises.delete(projectPath)\n      throw e\n    }\n  }\n\n  public async stopUnusedServers(): Promise<void> {\n    const usedServers = new Set(this._editorToServer.values())\n    const unusedServers = this._activeServers.filter((s) => !usedServers.has(s))\n    if (unusedServers.length > 0) {\n      this._logger.debug(`Stopping ${unusedServers.length} unused servers`)\n      await Promise.all(unusedServers.map((s) => this.stopServer(s)))\n    }\n  }\n\n  public async stopAllServers(): Promise<void> {\n    for (const [projectPath, restartCounter] of this._restartCounterPerProject) {\n      clearTimeout(restartCounter.timerId)\n      this._restartCounterPerProject.delete(projectPath)\n    }\n\n    await Promise.all(this._activeServers.map((s) => this.stopServer(s)))\n  }\n\n  public async restartAllServers(): Promise<void> {\n    this.stopListening()\n    await this.stopAllServers()\n    this._editorToServer = new Map()\n    this.startListening()\n  }\n\n  public hasServerReachedRestartLimit(server: ActiveServer): boolean {\n    let restartCounter = this._restartCounterPerProject.get(server.projectPath)\n\n    if (!restartCounter) {\n      restartCounter = {\n        restarts: 0,\n        timerId: setTimeout(() => {\n          this._restartCounterPerProject.delete(server.projectPath)\n        }, 3 * 60 * 1000 /* 3 minutes */),\n      }\n\n      this._restartCounterPerProject.set(server.projectPath, restartCounter)\n    }\n\n    return ++restartCounter.restarts > 5\n  }\n\n  public async stopServer(server: ActiveServer): Promise<void> {\n    await this._reportBusyWhile(\n      `Stopping ${this._languageServerName} for ${path.basename(server.projectPath)}`,\n      async () => {\n        this._logger.debug(`Server stopping \"${server.projectPath}\"`)\n        // Immediately remove the server to prevent further usage.\n        // If we re-open the file after this point, we'll get a new server.\n        this._activeServers.splice(this._activeServers.indexOf(server), 1)\n        this._stoppingServers.push(server)\n        server.disposable.dispose()\n        if (this.shutdownGracefully && server.connection.isConnected) {\n          await server.connection.shutdown()\n        }\n\n        for (const [editor, mappedServer] of this._editorToServer) {\n          if (mappedServer === server) {\n            this._editorToServer.delete(editor)\n          }\n        }\n\n        this.exitServer(server)\n        this._stoppingServers.splice(this._stoppingServers.indexOf(server), 1)\n      }\n    )\n  }\n\n  public exitServer(server: ActiveServer): void {\n    const pid = server.process.pid\n    try {\n      if (server.connection.isConnected) {\n        server.connection.exit()\n        server.connection.dispose()\n      }\n    } finally {\n      server.process.kill()\n    }\n    this._logger.debug(`Server stopped \"${server.projectPath}\" (pid ${pid})`)\n  }\n\n  public terminate(): void {\n    this._stoppingServers.forEach((server) => {\n      this._logger.debug(`Server terminating \"${server.projectPath}\"`)\n      this.exitServer(server)\n    })\n  }\n\n  public updateNormalizedProjectPaths(): void {\n    this._normalizedProjectPaths = atom.project.getPaths().map(normalizePath)\n  }\n\n  public getNormalizedProjectPaths(): Readonly<string[]> {\n    return this._normalizedProjectPaths\n  }\n\n  /**\n   * Public: fetch the current open list of workspace folders\n   *\n   * @returns A {Promise} containing an {Array} of {lsp.WorkspaceFolder[]} or {null} if only a single file is open in the tool.\n   */\n  public getWorkspaceFolders(): Promise<ls.WorkspaceFolder[] | null> {\n    // NOTE the method must return a Promise based on the specification\n    const projectPaths = this.getNormalizedProjectPaths()\n    if (projectPaths.length === 0) {\n      // only a single file is open\n      return Promise.resolve(null)\n    } else {\n      return Promise.resolve(projectPaths.map(normalizedProjectPathToWorkspaceFolder))\n    }\n  }\n\n  public async projectPathsChanged(projectPaths: string[]): Promise<void> {\n    const pathsAll = projectPaths.map(normalizePath)\n\n    const previousPaths = this._previousNormalizedProjectPaths ?? this.getNormalizedProjectPaths()\n    const pathsRemoved = previousPaths.filter((projectPath) => !pathsAll.includes(projectPath))\n    const pathsAdded = pathsAll.filter((projectPath) => !previousPaths.includes(projectPath))\n\n    // update cache\n    this._previousNormalizedProjectPaths = pathsAll\n\n    // send didChangeWorkspaceFolders\n    const didChangeWorkspaceFoldersParams = {\n      event: {\n        added: pathsAdded.map(normalizedProjectPathToWorkspaceFolder),\n        removed: pathsRemoved.map(normalizedProjectPathToWorkspaceFolder),\n      },\n    }\n    for (const activeServer of this._activeServers) {\n      activeServer.connection.didChangeWorkspaceFolders(didChangeWorkspaceFoldersParams)\n    }\n\n    // stop the servers that don't have projectPath\n    const serversToStop = this._activeServers.filter((server) => pathsRemoved.includes(server.projectPath))\n    await Promise.all(serversToStop.map((s) => this.stopServer(s)))\n\n    // update this._normalizedProjectPaths\n    this.updateNormalizedProjectPaths()\n  }\n\n  public projectFilesChanged(fileEvents: FilesystemChangeEvent): void {\n    if (this._activeServers.length === 0) {\n      return\n    }\n\n    for (const activeServer of this._activeServers) {\n      const changes: ls.FileEvent[] = []\n      for (const fileEvent of fileEvents) {\n        if (fileEvent.path.startsWith(activeServer.projectPath) && this._changeWatchedFileFilter(fileEvent.path)) {\n          changes.push(Convert.atomFileEventToLSFileEvents(fileEvent)[0])\n        }\n        if (\n          fileEvent.action === \"renamed\" &&\n          fileEvent.oldPath.startsWith(activeServer.projectPath) &&\n          this._changeWatchedFileFilter(fileEvent.oldPath)\n        ) {\n          changes.push(Convert.atomFileEventToLSFileEvents(fileEvent)[1])\n        }\n      }\n      if (changes.length > 0) {\n        activeServer.connection.didChangeWatchedFiles({ changes })\n      }\n    }\n  }\n\n  /** @deprecated Use the exported `normalizePath` function */\n  public normalizePath = normalizePath\n}\n\nexport function projectPathToWorkspaceFolder(projectPath: string): ls.WorkspaceFolder {\n  const normalizedProjectPath = normalizePath(projectPath)\n  return normalizedProjectPathToWorkspaceFolder(normalizedProjectPath)\n}\n\nexport function normalizedProjectPathToWorkspaceFolder(normalizedProjectPath: string): ls.WorkspaceFolder {\n  return {\n    uri: Convert.pathToUri(normalizedProjectPath),\n    name: path.basename(normalizedProjectPath),\n  }\n}\n\nexport function normalizePath(projectPath: string): string {\n  return !projectPath.endsWith(path.sep) ? path.join(projectPath, path.sep) : projectPath\n}\n\n/** Considers a path for inclusion in `additionalPaths`. */\nexport function considerAdditionalPath(\n  server: ActiveServer & { additionalPaths: Set<string> },\n  additionalPath: string\n): void {\n  if (!additionalPath.startsWith(server.projectPath)) {\n    server.additionalPaths.add(additionalPath)\n  }\n}\n"]}