# Dockerfile Language Server
 [](https://coveralls.io/github/rcjsuen/dockerfile-language-server-nodejs?branch=master) [](https://david-dm.org/rcjsuen/dockerfile-language-server-nodejs) [](https://opensource.org/licenses/MIT)
This is a language server for Dockerfiles powered by Node.js written in TypeScript.
To [install and run](#installation-instructions) this language server, you will need to have either [Node.js](https://nodejs.org/en/download/) or [Docker](https://www.docker.com/get-docker) installed on your computer.
**Supported features:**
- code actions
- code completion
- definition
- diagnostics
- document highlight
- document links
- document symbols
- folding ranges
- formatting
- hovers
- prepare rename
- rename
- semantic highlighting
- signature help
**Projects that use this language server:**
- [vscode-docker](https://github.com/Microsoft/vscode-docker)
- [atom-ide-docker](https://github.com/josa42/atom-ide-docker)
- [Sourcegraph](https://sourcegraph.com/)
- [Theia](https://theia-ide.org/)
- [lsp-mode](https://emacs-lsp.github.io/lsp-mode/)
This repository only contains the code necessary for launching a Dockerfile language server that conforms to the language server protocol.
The actual code for parsing a Dockerfile and offering editor features such as code completion or hovers is not contained within this repository.
The code for analyzing and processing a Dockerfile is contained in the following three libraries:
- [dockerfile-ast](https://github.com/rcjsuen/dockerfile-ast) - parses a Dockerfile
- [dockerfile-language-service](https://github.com/rcjsuen/dockerfile-language-service) - provides API functions for handling the different requests defined by the language server protocol
- [dockerfile-utils](https://github.com/rcjsuen/dockerfile-utils) - validates and formats a Dockerfile, can be run from the CLI
All of the language server protocol requests that help create a rich editing experience for the user is forwarded to the `dockerfile-language-service` library.
You can test its features [right in the browser](https://rcjsuen.github.io/dockerfile-language-service/).
This online editor is a very good representation of what is possible when this language server is connected to an editor that supports the language server protocol.
## Development Instructions
If you wish to build and compile this language server, you must first install [Node.js](https://nodejs.org/en/download/) if you have not already done so.
After you have installed Node.js and cloned the repository with Git, you may now proceed to build and compile the language server with the following commands:
```
npm install
npm run build
npm test
```
If you are planning to change the code, use `npm run watch` to get the
TypeScript files transpiled on-the-fly as they are modified.
Once the code has finished compiling, you can connect a language server
client to the server via Node IPC, stdio, or sockets.
## Installation Instructions
To install this language server onto your computer, please install the
[dockerfile-language-server-nodejs npm module](https://www.npmjs.com/package/dockerfile-language-server-nodejs).
The `-g` flag will install the npm module globally onto your computer.
```
npm install -g dockerfile-language-server-nodejs
```
After the installation has completed, you can start the language
server with the `docker-langserver` binary. You should specify
the desired method of communicating with the language server via one
of the three arguments shown below.
```
docker-langserver --node-ipc
docker-langserver --stdio
docker-langserver --socket=<port>
```
### Docker Image
The `docker-langserver` binary is also available as a Docker image under the name `rcjsuen/docker-langserver`.
## Language Server Settings
Clients may send a `workspace/didChangeConfiguration` notification to
notify the server of settings changes.
The settings object that will be included with the notification must conform
to the following specification.
```TypeScript
interface Settings {
docker: {
languageserver: {
diagnostics?: {
// string values must be equal to "ignore", "warning", or "error"
deprecatedMaintainer?: string,
directiveCasing?: string,
emptyContinuationLine?: string,
instructionCasing?: string,
instructionCmdMultiple?: string,
instructionEntrypointMultiple?: string,
instructionHealthcheckMultiple?: string,
instructionJSONInSingleQuotes?: string
},
formatter?: {
ignoreMultilineInstructions?: boolean,
}
}
}
}
```
## Communicating with the Server
### Node IPC
With the `child_process` API, you can `fork()` a new Node.js process
running the language server and communicate with it using `send(message)`
and `on('message', ...)`.
```TypeScript
import * as child_process from "child_process";
let lspProcess = child_process.fork("out/src/server.js", [ "--node-ipc" ]);
let messageId = 1;
function send(method: string, params: object) {
let message = {
jsonrpc: "2.0",
id: messageId++,
method: method,
params: params
};
lspProcess.send(message);
}
function initialize() {
send("initialize", {
rootPath: process.cwd(),
processId: process.pid,
capabilities: {
/* ... */
}
});
}
lspProcess.on('message', function (json) {
console.log(json);
});
initialize();
```
### Standard Input/Output
When writing directly to the process's stdin, the additional `Content-Length`
header must be included. Similarly, when reading from the process's stdout, the
header will be included in the response message.
```TypeScript
import * as child_process from "child_process";
let lspProcess = child_process.spawn("node", [ "out/src/server.js", "--stdio" ]);
let messageId = 1;
function send(method: string, params: object) {
let message = {
jsonrpc: "2.0",
id: messageId++,
method: method,
params: params
};
let json = JSON.stringify(message);
let headers = "Content-Length: " + json.length + "\r\n\r\n";
lspProcess.stdin.write(headers, "ASCII");
lspProcess.stdin.write(json, "UTF-8");
}
function initialize() {
send("initialize", {
rootPath: process.cwd(),
processId: process.pid,
capabilities: {
/* ... */
}
});
}
lspProcess.stdout.on("data", (message) => {
// "Content-Length: ...\r\n\r\n\" will be included here
console.log(message.toString());
});
initialize();
```
#### vscode-jsonrpc
The `StreamMessageReader` and `StreamMessageWriter` classes from the
`vscode-jsonrpc` module will handle the `Content-Length` headers for you so you
only have to worry about the actual request and response.
```TypeScript
import * as child_process from "child_process";
import { StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc";
let lspProcess = child_process.spawn("node", [ "out/src/server.js", "--stdio" ]);
let messageId = 1;
const reader = new StreamMessageReader(lspProcess.stdout);
const writer = new StreamMessageWriter(lspProcess.stdin);
function send(method: string, params: object) {
let message = {
jsonrpc: "2.0",
id: messageId++,
method: method,
params: params
};
writer.write(message);
}
function initialize() {
send("initialize", {
rootPath: process.cwd(),
processId: process.pid,
capabilities: {
/* ... */
}
});
}
reader.listen((data) => {
console.log(data);
})
initialize();
eclipse-cpp-2023-09-R-win32-x86-64.zip （2000个子文件） 
AL2.0 10KB LGPL2.1 24KB libjnidispatch.a 642KB libjnidispatch.a 599KB libjffi-1.2.a 165KB libjffi-1.2.a 143KB .api_description 212B 700E4F39BC05364B.asc 4KB
splash.bmp 400KB Native.class 49KB Structure.class 39KB NativeLibrary.class 25KB Pointer.class 22KB Function.class 19KB CallbackReference.class 17KB ApplicationWorkbenchWindowAdvisor$PostWindowCreateRunnable.class 16KB DebugExecutable.class 13KB ApplicationActionBarAdvisor.class 12KB Memory.class 11KB Structure$FFIType.class 10KB DebugAttachedExecutable.class 9KB ELFAnalyser.class 9KB ApplicationWorkbenchWindowAdvisor.class 8KB CallbackReference$DefaultCallbackProxy.class 8KB Platform.class 8KB CompilerOptionParser.class 8KB NewExecutableDialog.class 7KB CoreFileDialog.class 7KB RemoteExecutableDialog.class 7KB ReflectionUtils.class 6KB Library$Handler.class 6KB ELFAnalyser$ArmAeabiAttributesTag.class 6KB Pointer$Opaque.class 6KB ConfigGenerator.class 5KB Union.class 5KB BuildOptionsParser.class 5KB Messages.class 5KB Application.class 5KB DebugNewExecutableHandler.class 5KB IntegerType.class 4KB DefaultTypeMapper.class 4KB DebugRemoteExecutable.class 4KB ELFAnalyser$ELFSectionHeaders.class 3KB DebugRemoteExecutableHandler.class 3KB InitializeLaunchConfigurations.class 3KB NativeMappedConverter.class 3KB CallbackReference$NativeFunctionHandler.class 3KB DebugCoreFile.class 3KB StringArray.class 3KB DebugCoreFileHandler.class 3KB NativeString.class 3KB StdCallFunctionMapper.class 3KB Cleaner.class 3KB Structure$StructureSet.class 2KB DebugAttachedExecutableHandler.class 2KB ContributeHandler.class 2KB ApplicationWorkbenchWindowAdvisor$PostWindowCreateRunnable$1.class 2KB Structure$LayoutInfo.class 2KB Klass.class 2KB PointerType.class 2KB ELFAnalyser$ELFSectionHeaderEntry.class 2KB DebugNewExecutableHandler$1.class 2KB GCCCompileOptionsParser.class 2KB Cleaner$CleanerRef.class 2KB NativeLibrary$2.class 2KB LastErrorException.class 2KB RemoteExecutableDialog$6.class 2KB DockerfileLanguageServer.class 2KB ApplicationActionBarAdvisor$4.class 2KB ApplicationActionBarAdvisor$3.class 2KB ApplicationActionBarAdvisor$2.class 2KB ApplicationActionBarAdvisor$1.class 2KB Structure$FFIType$FFITypes.class 2KB ByReference.class 2KB NativeLongByReference.class 2KB RemoteExecutableDialog$2.class 2KB Native$AWT.class 2KB Cleaner$1.class 2KB NewExecutableDialog$2.class 2KB W32APIFunctionMapper.class 2KB WeakMemoryHolder.class 2KB CoreFileDialog$2.class 2KB CoreFileDialog$5.class 1KB DebugExecutable$1.class 1KB CallbackThreadInitializer.class 1KB NewExecutableInfo.class 1KB WString.class 1KB RemoteExecutableInfo.class 1KB W32APITypeMapper$1.class 1KB W32APITypeMapper$2.class 1KB ApplicationWorkbenchAdvisor.class 1KB VarArgsChecker.class 1KB Library$Handler$FunctionInfo.class 1KB ELFAnalyser$ArmAeabiAttributesTag$ParameterType.class 1KB W32APITypeMapper.class 1KB Native$3.class 1KB CoreFileInfo.class 1KB Structure$StructField.class 1KB Native$1.class 1KB ShortByReference.class 1KB共 2000 条
- 1
- 2
- 3
- 4
- 5
- 6
- 20
资源评论
