internal LanguageServer(
Connection connection,
IResponseRouter responseRouter,
IOptions <LanguageServerOptions> options,
ILanguageServerConfiguration configuration,
ServerInfo serverInfo,
ILspServerReceiver receiver,
ISerializer serializer,
IServiceProvider serviceProvider,
ISupportedCapabilities supportedCapabilities,
TextDocumentIdentifiers textDocumentIdentifiers,
IEnumerable <OnLanguageServerInitializeDelegate> initializeDelegates,
IEnumerable <OnLanguageServerInitializedDelegate> initializedDelegates,
IEnumerable <OnLanguageServerStartedDelegate> startedDelegates,
IEnumerable <IOnLanguageServerStarted> startedHandlers,
IServerWorkDoneManager serverWorkDoneManager,
ITextDocumentLanguageServer textDocumentLanguageServer,
IClientLanguageServer clientLanguageServer,
IGeneralLanguageServer generalLanguageServer,
IWindowLanguageServer windowLanguageServer,
IWorkspaceLanguageServer workspaceLanguageServer,
LanguageProtocolSettingsBag languageProtocolSettingsBag,
SharedHandlerCollection handlerCollection,
IProgressManager progressManager,
ILanguageServerWorkspaceFolderManager workspaceFolderManager, IEnumerable <IOnLanguageServerInitialize> initializeHandlers,
IEnumerable <IOnLanguageServerInitialized> initializedHandlers
) : base(handlerCollection, responseRouter)
{
Configuration = configuration;
_connection = connection;
_serverInfo = serverInfo;
_serverReceiver = receiver;
_serializer = serializer;
_supportedCapabilities = supportedCapabilities;
_textDocumentIdentifiers = textDocumentIdentifiers;
_initializeDelegates = initializeDelegates;
_initializedDelegates = initializedDelegates;
_startedDelegates = startedDelegates;
_startedHandlers = startedHandlers;
WorkDoneManager = serverWorkDoneManager;
_settingsBag = languageProtocolSettingsBag;
Services = serviceProvider;
_collection = handlerCollection;
// We need to at least create Window here in case any handler does logging in their constructor
TextDocument = textDocumentLanguageServer;
Client = clientLanguageServer;
General = generalLanguageServer;
Window = windowLanguageServer;
Workspace = workspaceLanguageServer;
ProgressManager = progressManager;
WorkspaceFolderManager = workspaceFolderManager;
_initializeHandlers = initializeHandlers;
_initializedHandlers = initializedHandlers;
_concurrency = options.Value.Concurrency;
_disposable.Add(_collection.Add(this));
}
public void Initialized(IResponseRouter router, ISerializer serializer,
WindowClientCapabilities windowClientCapabilities)
{
_router = router;
_serializer = serializer;
_supported = windowClientCapabilities.WorkDoneProgress.IsSupported &&
windowClientCapabilities.WorkDoneProgress.Value;
}
public static Task CreateProgress(this IResponseRouter mediator, ProgressToken token,
CancellationToken cancellationToken)
{
return(mediator.SendRequest(new WorkDoneProgressCreateParams()
{
Token = token
}, cancellationToken));
}
public DebugAdapterProtocolProxy(
IResponseRouter requestRouter, IResolverContext resolverContext, IDebugAdapterProtocolSettings debugAdapterProtocolSettings
)
{
_responseRouter = requestRouter;
ResolverContext = resolverContext;
_debugAdapterProtocolSettings = debugAdapterProtocolSettings;
}
public LanguageProtocolProxy(
IResponseRouter requestRouter, IServiceProvider serviceProvider, IProgressManager progressManager, ILanguageProtocolSettings languageProtocolSettings
)
{
ProgressManager = progressManager;
_responseRouter = requestRouter;
_serviceProvider = serviceProvider;
_languageProtocolSettings = languageProtocolSettings;
}
public LanguageProtocolProxy(
IResponseRouter requestRouter, IResolverContext resolverContext, IProgressManager progressManager, ILanguageProtocolSettings languageProtocolSettings
)
{
ProgressManager = progressManager;
_responseRouter = requestRouter;
ResolverContext = resolverContext;
_languageProtocolSettings = languageProtocolSettings;
}
private static IObserver <T> CreateWorker <T>(
ProgressToken token,
IResponseRouter router,
ISerializer serializer,
IDisposable disposable)
{
return(Observer.Create <T>(
value => router.SendProgress(token.Create(value, serializer.JsonSerializer)),
error => { disposable.Dispose(); },
disposable.Dispose));
}
public Connection(
PipeReader input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestRouter <IHandlerDescriptor?> requestRouter,
IResponseRouter responseRouter,
RequestInvoker requestInvoker,
ILoggerFactory loggerFactory,
OnUnhandledExceptionHandler onUnhandledException,
CreateResponseExceptionHandler?getException = null
) =>
public static async Task RegisterCapability(this IResponseRouter mediator, RegistrationParams @params)
{
try
{
await mediator.SendRequest(Client.ClientNames.RegisterCapability, @params);
}
catch (Exception e)
{
// VsCode today does not implement LSP properly.
await mediator.SendRequest("client/registerFeature", @params);
}
}
public static ProgressObserver <T> Create <T>(
ProgressToken token, IResponseRouter router,
ISerializer serializer,
CancellationToken cancellationToken)
{
var observer = new Subject <WorkDoneProgress>();
var disposable = new CompositeDisposable {
observer
};
return(new ProgressObserver <T>(token, CreateWorker <T>(token, router, serializer, disposable),
CancellationTokenSource.CreateLinkedTokenSource(cancellationToken)));
}
public ProgressObserver(
ProgressToken token,
IResponseRouter responseRouter,
ISerializer serializer,
CancellationToken cancellationToken,
Action disposal)
{
_responseRouter = responseRouter;
_serializer = serializer;
_disposal = disposal;
ProgressToken = token;
CancellationToken = cancellationToken;
_completionSource = new TaskCompletionSource <System.Reactive.Unit>();
}
public Connection(
PipeReader input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor> requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory,
OnUnhandledExceptionHandler onUnhandledException,
TimeSpan requestTimeout,
bool supportContentModified,
int concurrency,
CreateResponseExceptionHandler getException = null
) =>
internal JsonRpcServer(
IOptions <JsonRpcServerOptions> options,
Connection connection,
IHandlersManager handlerCollection,
IResponseRouter responseRouter,
IServiceProvider serviceProvider
) : base(handlerCollection, responseRouter)
{
_connection = connection;
_disposable = options.Value.CompositeDisposable;
_disposable.Add(_connection);
if (serviceProvider is IDisposable disposable)
{
_disposable.Add(disposable);
}
}
internal LanguageServer(Stream input, IOutputHandler output, LspReciever reciever, IRequestProcessIdentifier requestProcessIdentifier, ILoggerFactory loggerFactory)
{
// TODO: This might not be the best
loggerFactory.AddProvider(new LanguageServerLoggerProvider(this));
_reciever = reciever;
_loggerFactory = loggerFactory;
_requestRouter = new LspRequestRouter(_collection, loggerFactory);
_responseRouter = new ResponseRouter(output);
_connection = new Connection(input, output, reciever, requestProcessIdentifier, _requestRouter, _responseRouter, loggerFactory);
_exitHandler = new ExitHandler(_shutdownHandler);
_disposable.Add(
AddHandlers(this, _shutdownHandler, _exitHandler, new CancelRequestHandler(_requestRouter))
);
}
public static ProgressObserver <WorkDoneProgressReport> CreateWorkDoneProgress(
ProgressToken token,
IResponseRouter router,
ISerializer serializer,
WorkDoneProgressBegin begin,
Func <Exception, WorkDoneProgressEnd> onError,
Func <WorkDoneProgressEnd> onComplete,
CancellationToken cancellationToken)
{
var disposable = new CompositeDisposable();
var worker = CreateWorker <WorkDoneProgress>(token, router, serializer, onError, onComplete, disposable);
worker.OnNext(begin);
return(new ProgressObserver <WorkDoneProgressReport>(token, worker,
CancellationTokenSource.CreateLinkedTokenSource(cancellationToken)));
}
public ProgressObserver(
IResponseRouter router,
ProgressStartEvent begin,
Func <Exception, ProgressEndEvent> onError,
Func <ProgressEndEvent> onComplete,
CancellationToken cancellationToken
)
{
ProgressId = begin.ProgressId;
_router = router;
_onError = onError;
_onComplete = onComplete;
_disposable = new CompositeDisposable {
Disposable.Create(OnCompleted)
};
cancellationToken.Register(Dispose);
_router.SendNotification(begin);
}
public static ProgressObserver <WorkDoneProgressReport> CreateWorkDoneProgress(
IResponseRouter router,
ISerializer serializer,
WorkDoneProgressBegin begin, Func <Exception, WorkDoneProgressEnd> onError,
Func <WorkDoneProgressEnd> onComplete,
CancellationToken cancellationToken)
{
var token = new ProgressToken(Guid.NewGuid().ToString());
var earlyEvents = new AsyncSubject <List <WorkDoneProgress> >();
var observer = new Subject <WorkDoneProgress>();
var disposable = new CompositeDisposable {
observer, earlyEvents
};
var worker = CreateWorker <WorkDoneProgress>(token, router, serializer, onError, onComplete, disposable);
disposable.Add(
observer
.Scan(new List <WorkDoneProgress>()
{
begin
}, (acc, v) =>
{
acc.Add(v);
return(acc);
})
.Subscribe(earlyEvents.OnNext)
);
disposable.Add(
Observable.FromAsync(ct => router.CreateProgress(token, ct))
.Subscribe(_ => { }, e => { }, () => { earlyEvents.OnCompleted(); })
);
disposable.Add(
earlyEvents
.SelectMany(z => z)
.Concat(observer)
.Subscribe(worker)
);
return(new ProgressObserver <WorkDoneProgressReport>(token, observer,
CancellationTokenSource.CreateLinkedTokenSource(cancellationToken)));
}
public WorkDoneObserver(
ProgressToken progressToken,
IResponseRouter router,
ISerializer serializer,
WorkDoneProgressBegin begin,
Func <Exception, WorkDoneProgressEnd> onError,
Func <WorkDoneProgressEnd> onComplete,
CancellationToken cancellationToken)
{
_progressToken = progressToken;
_router = router;
_serializer = serializer;
_onError = onError;
_onComplete = onComplete;
_disposable = new CompositeDisposable {
Disposable.Create(OnCompleted)
};
cancellationToken.Register(Dispose);
OnNext(begin);
}
public Connection(
Stream input,
IOutputHandler outputHandler,
IReciever reciever,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory)
{
_requestRouter = requestRouter;
_inputHandler = new InputHandler(
input,
outputHandler,
reciever,
requestProcessIdentifier,
requestRouter,
responseRouter,
loggerFactory
);
}
internal DebugAdapterClient(
IOptions <DebugAdapterClientOptions> options,
InitializeRequestArguments clientSettings,
DebugAdapterSettingsBag settingsBag,
DebugAdapterHandlerCollection collection,
IEnumerable <OnDebugAdapterClientStartedDelegate> onClientStartedDelegates,
DapReceiver receiver,
IResponseRouter responseRouter,
IServiceProvider serviceProvider,
IDebugAdapterClientProgressManager debugAdapterClientProgressManager,
Connection connection,
IEnumerable <OnDebugAdapterClientInitializeDelegate> initializeDelegates,
IEnumerable <IOnDebugAdapterClientInitialize> initializeHandlers,
IEnumerable <OnDebugAdapterClientInitializedDelegate> initializedDelegates,
IEnumerable <IOnDebugAdapterClientInitialized> initializedHandlers,
IEnumerable <IOnDebugAdapterClientStarted> startedHandlers,
InstanceHasStarted instanceHasStarted,
IScheduler scheduler
) : base(collection, responseRouter)
{
_settingsBag = settingsBag;
ClientSettings = clientSettings;
_collection = collection;
_startedDelegates = onClientStartedDelegates;
_receiver = receiver;
_serviceProvider = serviceProvider;
ProgressManager = debugAdapterClientProgressManager;
_connection = connection;
_initializeDelegates = initializeDelegates;
_initializeHandlers = initializeHandlers;
_initializedDelegates = initializedDelegates;
_initializedHandlers = initializedHandlers;
_startedHandlers = startedHandlers;
_instanceHasStarted = instanceHasStarted;
_scheduler = scheduler;
_concurrency = options.Value.Concurrency;
_disposable.Add(collection.Add(this));
}
private InputHandler NewHandler(
PipeReader inputStream,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestRouter <IHandlerDescriptor?> requestRouter,
ILoggerFactory loggerFactory,
IResponseRouter responseRouter,
RequestInvoker requestInvoker
)
{
return(new InputHandler(
inputStream,
outputHandler,
receiver,
requestRouter,
responseRouter,
requestInvoker,
loggerFactory,
_unhandledException,
null
));
}
internal DebugAdapterServer(
IOptions <DebugAdapterServerOptions> options,
Capabilities capabilities,
DebugAdapterSettingsBag settingsBag,
DapReceiver receiver,
DebugAdapterHandlerCollection collection,
IEnumerable <OnDebugAdapterServerInitializeDelegate> initializeDelegates,
IEnumerable <OnDebugAdapterServerInitializedDelegate> initializedDelegates,
IEnumerable <OnDebugAdapterServerStartedDelegate> onServerStartedDelegates,
IServiceProvider serviceProvider,
IResponseRouter responseRouter,
Connection connection,
IDebugAdapterServerProgressManager progressManager,
IEnumerable <IOnDebugAdapterServerInitialize> initializeHandlers,
IEnumerable <IOnDebugAdapterServerInitialized> initializedHandlers,
IEnumerable <IOnDebugAdapterServerStarted> startedHandlers,
InstanceHasStarted instanceHasStarted,
IScheduler scheduler
) : base(collection, responseRouter)
{
_capabilities = capabilities;
_settingsBag = settingsBag;
_receiver = receiver;
_collection = collection;
_initializeDelegates = initializeDelegates;
_initializedDelegates = initializedDelegates;
_startedDelegates = onServerStartedDelegates;
_serviceProvider = serviceProvider;
_connection = connection;
ProgressManager = progressManager;
_initializeHandlers = initializeHandlers;
_initializedHandlers = initializedHandlers;
_startedHandlers = startedHandlers;
_instanceHasStarted = instanceHasStarted;
_scheduler = scheduler;
_concurrency = options.Value.Concurrency;
_disposable.Add(collection.Add(this));
}
public InputHandler(
PipeReader pipeReader,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor?> requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory,
OnUnhandledExceptionHandler unhandledInputProcessException,
CreateResponseExceptionHandler?getException,
TimeSpan requestTimeout,
bool supportContentModified,
int?concurrency,
IScheduler scheduler
) : this(
pipeReader,
outputHandler,
receiver,
requestRouter,
responseRouter,
new DefaultRequestInvoker(
requestRouter,
outputHandler,
requestProcessIdentifier,
new RequestInvokerOptions(
requestTimeout,
supportContentModified,
concurrency ?? 0
),
loggerFactory,
scheduler
),
loggerFactory,
unhandledInputProcessException,
getException
)
{
}
public InputHandler(
PipeReader pipeReader,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestRouter <IHandlerDescriptor?> requestRouter,
IResponseRouter responseRouter,
RequestInvoker requestInvoker,
ILoggerFactory loggerFactory,
OnUnhandledExceptionHandler unhandledInputProcessException,
CreateResponseExceptionHandler?getException
)
{
_pipeReader = pipeReader;
_outputHandler = outputHandler;
_receiver = receiver;
_requestRouter = requestRouter;
_responseRouter = responseRouter;
_requestInvoker = requestInvoker;
_unhandledInputProcessException = unhandledInputProcessException;
_getException = getException;
_logger = loggerFactory.CreateLogger <InputHandler>();
_headersBuffer = new Memory <byte>(new byte[HeadersFinishedLength]);
_contentLengthBuffer = new Memory <byte>(new byte[ContentLengthLength]);
_contentLengthValueBuffer = new byte[20]; // Max string length of the long value
_contentLengthValueMemory =
new Memory <byte>(_contentLengthValueBuffer); // Max string length of the long value
_stopProcessing = new CancellationTokenSource();
_disposable = new CompositeDisposable
{
Disposable.Create(() => _stopProcessing.Cancel()),
_stopProcessing,
_requestInvoker,
};
_inputActive = new AsyncSubject <Unit>();
_inputQueue = new Subject <IObservable <Unit> >();
}
public Connection(
Stream input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor> requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory,
ISerializer serializer)
{
_requestRouter = requestRouter;
_inputHandler = new InputHandler(
input,
outputHandler,
receiver,
requestProcessIdentifier,
requestRouter,
responseRouter,
loggerFactory,
serializer
);
}
private InputHandler NewHandler(
PipeReader inputStream,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor?> requestRouter,
ILoggerFactory loggerFactory,
IResponseRouter responseRouter
) =>
new InputHandler(
inputStream,
outputHandler,
receiver,
requestProcessIdentifier,
requestRouter,
responseRouter,
loggerFactory,
_unhandledException,
null,
TimeSpan.FromSeconds(30),
true,
null
);
internal LanguageServer(
Stream input,
Stream output,
LspReciever reciever,
IRequestProcessIdentifier requestProcessIdentifier,
ILoggerFactory loggerFactory,
Serializer serializer,
bool addDefaultLoggingProvider)
{
var outputHandler = new OutputHandler(output, serializer);
if (addDefaultLoggingProvider)
{
loggerFactory.AddProvider(new LanguageServerLoggerProvider(this));
}
_reciever = reciever;
_loggerFactory = loggerFactory;
_serializer = serializer;
_handlerMactherCollection = new HandlerMatcherCollection
{
new TextDocumentMatcher(_loggerFactory.CreateLogger <TextDocumentMatcher>(), _collection.TextDocumentSyncHandlers),
new ExecuteCommandMatcher(_loggerFactory.CreateLogger <ExecuteCommandMatcher>()),
new ResolveCommandMatcher(_loggerFactory.CreateLogger <ResolveCommandMatcher>()),
new DocumentLinkCommandMatcher(_loggerFactory.CreateLogger <DocumentLinkCommandMatcher>())
};
_requestRouter = new LspRequestRouter(_collection, loggerFactory, _handlerMactherCollection, _serializer);
_responseRouter = new ResponseRouter(outputHandler, _serializer);
_connection = new Connection(input, outputHandler, reciever, requestProcessIdentifier, _requestRouter, _responseRouter, loggerFactory, serializer);
_exitHandler = new ExitHandler(_shutdownHandler);
_disposable.Add(
AddHandlers(this, _shutdownHandler, _exitHandler, new CancelRequestHandler(_requestRouter))
);
}
public DefaultLanguageClientFacade(
IResponseRouter requestRouter,
IResolverContext resolverContext,
IProgressManager progressManager,
ILanguageProtocolSettings languageProtocolSettings,
Lazy <ITextDocumentLanguageClient> textDocument,
Lazy <IClientLanguageClient> client,
Lazy <IGeneralLanguageClient> general,
Lazy <IWindowLanguageClient> window,
Lazy <IWorkspaceLanguageClient> workspace,
Lazy <IHandlersManager> handlersManager,
TextDocumentIdentifiers textDocumentIdentifiers,
IInsanceHasStarted instanceHasStarted
) : base(requestRouter, resolverContext, progressManager, languageProtocolSettings)
{
_textDocument = textDocument;
_client = client;
_general = general;
_window = window;
_workspace = workspace;
_handlersManager = handlersManager;
_textDocumentIdentifiers = textDocumentIdentifiers;
_instanceHasStarted = instanceHasStarted;
}
public ProgressManager(IResponseRouter router, ISerializer serializer)
{
_router = router;
_serializer = serializer;
}
public WorkspaceLanguageServer(
IResponseRouter requestRouter, IResolverContext resolverContext, IProgressManager progressManager,
ILanguageProtocolSettings languageProtocolSettings
) : base(requestRouter, resolverContext, progressManager, languageProtocolSettings)
{
}
