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) { }