Added workspace folder tests (#279)

* Added workspace folder tests, normalized initilaize/initilaized/startup handling
* DAP doesn't support dynamic registration... whoops

Author: david-driscoll

sample/SampleServer/Program.cs

@@ -97,7 +97,7 @@ static async Task MainAsync(string[] args)
                         });
                         workDone.OnCompleted();
                     })
-                    .OnStarted(async (languageServer, result, token) => {
+                    .OnStarted(async (languageServer, token) => {
                         using var manager = await languageServer.WorkDoneManager.Create(new WorkDoneProgressBegin() { Title = "Doing some work..." });
 
                         manager.OnNext(new WorkDoneProgressReport() { Message = "doing things..." });

src/Client/LanguageClient.cs

@@ -43,6 +43,10 @@ public class LanguageClient : JsonRpcServerBase, ILanguageClient
         // private readonly IEnumerable<InitializedDelegate> _initializedDelegates;
         private readonly IEnumerable<OnLanguageClientStartedDelegate> _startedDelegates;
         private readonly IEnumerable<IOnLanguageClientStarted> _startedHandlers;
+        private readonly IEnumerable<OnLanguageClientInitializeDelegate> _initializeDelegates;
+        private readonly IEnumerable<IOnLanguageClientInitialize> _initializeHandlers;
+        private readonly IEnumerable<OnLanguageClientInitializedDelegate> _initializedDelegates;
+        private readonly IEnumerable<IOnLanguageClientInitialized> _initializedHandlers;
         private readonly IResponseRouter _responseRouter;
         private readonly ISubject<InitializeResult> _initializeComplete = new AsyncSubject<InitializeResult>();
         private readonly CompositeDisposable _disposable = new CompositeDisposable();
@@ -55,6 +59,7 @@ public class LanguageClient : JsonRpcServerBase, ILanguageClient
         private readonly ClientCapabilities _clientCapabilities;
         private readonly LanguageProtocolSettingsBag _settingsBag;
         private bool _started;
+        private readonly int? _concurrency;
 
         internal static IContainer CreateContainer(LanguageClientOptions options, IServiceProvider outerServiceProvider) =>
             JsonRpcServerContainer.Create(outerServiceProvider)
@@ -70,7 +75,9 @@ public static LanguageClient Create(Action<LanguageClientOptions> optionsAction,
             return Create(options, outerServiceProvider);
         }
 
-        public static LanguageClient Create(LanguageClientOptions options, IServiceProvider outerServiceProvider) => CreateContainer(options, outerServiceProvider).Resolve<LanguageClient>();
+        public static LanguageClient Create(LanguageClientOptions options, IServiceProvider outerServiceProvider) =>
+            CreateContainer(options, outerServiceProvider).Resolve<LanguageClient>();
+
         public static Task<LanguageClient> From(LanguageClientOptions options) => From(options, null, CancellationToken.None);
         public static Task<LanguageClient> From(Action<LanguageClientOptions> optionsAction) => From(optionsAction, null, CancellationToken.None);
         public static Task<LanguageClient> From(LanguageClientOptions options, CancellationToken cancellationToken) => From(options, null, cancellationToken);
@@ -142,8 +149,9 @@ internal LanguageClient(
             IProgressManager progressManager,
             IClientWorkDoneManager clientWorkDoneManager,
             IRegistrationManager registrationManager,
-            ILanguageClientWorkspaceFoldersManager languageClientWorkspaceFoldersManager
-        ) : base(handlerCollection, responseRouter)
+            ILanguageClientWorkspaceFoldersManager languageClientWorkspaceFoldersManager, IEnumerable<OnLanguageClientInitializeDelegate> initializeDelegates,
+            IEnumerable<IOnLanguageClientInitialize> initializeHandlers, IEnumerable<OnLanguageClientInitializedDelegate> initializedDelegates,
+            IEnumerable<IOnLanguageClientInitialized> initializedHandlers) : base(handlerCollection, responseRouter)
         {
             _connection = connection;
             _capabilities = capabilities;
@@ -165,6 +173,11 @@ ILanguageClientWorkspaceFoldersManager languageClientWorkspaceFoldersManager
             WorkDoneManager = clientWorkDoneManager;
             RegistrationManager = registrationManager;
             WorkspaceFoldersManager = languageClientWorkspaceFoldersManager;
+            _initializeDelegates = initializeDelegates;
+            _initializeHandlers = initializeHandlers;
+            _initializedDelegates = initializedDelegates;
+            _initializedHandlers = initializedHandlers;
+            _concurrency = options.Value.Concurrency;
 
             // We need to at least create Window here in case any handler does loggin in their constructor
             TextDocument = textDocumentLanguageClient;
@@ -209,34 +222,55 @@ public async Task Initialize(CancellationToken token)
                 WorkspaceFolders = new Container<WorkspaceFolder>(WorkspaceFoldersManager.CurrentWorkspaceFolders),
                 InitializationOptions = _initializationOptions
             };
+
             RegisterCapabilities(@params.Capabilities);
+
             WorkDoneManager.Initialize(@params.Capabilities.Window);
 
             ClientSettings = @params;
 
+            await LanguageProtocolEventingHelper.Run(
+                _initializeDelegates,
+                (handler, ct) => handler(this, @params, ct),
+                _initializeHandlers.Union(_collection.Select(z => z.Handler).OfType<IOnLanguageClientInitialize>()),
+                (handler, ct) => handler.OnInitialize(this, @params, ct),
+                _concurrency,
+                token
+            );
+
             _connection.Open();
             var serverParams = await this.RequestLanguageProtocolInitialize(ClientSettings, token);
             _receiver.Initialized();
 
-            var tasks =
-                _startedDelegates.Select(handler => handler(this, serverParams, token))
-                    .Concat(_startedHandlers
-                        .Union(_collection.Select(z => z.Handler).OfType<IOnLanguageClientStarted>())
-                        .Select(handler => handler.OnStarted(this, serverParams, token))
-                    )
-                    .ToArray();
-            if (tasks.Length > 0)
-            {
-                await Task.WhenAll(tasks);
-            }
-
             ServerSettings = serverParams;
+
+            await LanguageProtocolEventingHelper.Run(
+                _initializedDelegates,
+                (handler, ct) => handler(this, @params, serverParams, ct),
+                _initializedHandlers.Union(_collection.Select(z => z.Handler).OfType<IOnLanguageClientInitialized>()),
+                (handler, ct) => handler.OnInitialized(this, @params, serverParams, ct),
+                _concurrency,
+                token
+            );
+
+            // post init
+
             if (_collection.ContainsHandler(typeof(IRegisterCapabilityHandler)))
                 RegistrationManager.RegisterCapabilities(serverParams.Capabilities);
 
+            await LanguageProtocolEventingHelper.Run(
+                _startedDelegates,
+                (handler, ct) => handler(this, ct),
+                _startedHandlers.Union(_collection.Select(z => z.Handler).OfType<IOnLanguageClientStarted>()),
+                (handler, ct) => handler.OnStarted(this, ct),
+                _concurrency,
+                token
+            );
+
+            _started = true;
+
             // TODO: pull supported fields and add any static registrations to the registration manager
             this.SendLanguageProtocolInitialized(new InitializedParams());
-            _started = true;
         }
 
         private void RegisterCapabilities(ClientCapabilities capabilities)
@@ -347,14 +381,34 @@ public IDisposable Register(Action<ILanguageClientRegistry> registryAction)
             var result = manager.GetDisposable();
             if (_started)
             {
-                foreach (var item in result.OfType<LspHandlerDescriptorDisposable>())
-                foreach (var descriptor in item.Descriptors)
+                static IEnumerable<T> GetUniqueHandlers<T>(CompositeDisposable disposable)
+                {
+                    return disposable.OfType<ILspHandlerDescriptor>()
+                        .Select(z => z.Handler)
+                        .OfType<T>()
+                        .Concat(disposable.OfType<CompositeDisposable>().SelectMany(GetUniqueHandlers<T>))
+                        .Concat(disposable.OfType<LspHandlerDescriptorDisposable>().SelectMany(GetLspHandlers<T>))
+                        .Distinct();
+                }
+                static IEnumerable<T> GetLspHandlers<T>(LspHandlerDescriptorDisposable disposable)
                 {
-                    if (descriptor.Handler is IOnLanguageClientStarted clientStarted)
-                    {
-                        Observable.FromAsync((ct) => clientStarted.OnStarted(this, ServerSettings, ct)).Subscribe();
-                    }
+                    return disposable.Descriptors
+                        .Select(z => z.Handler)
+                        .OfType<T>()
+                        .Distinct();
                 }
+
+                Observable.Concat(
+                    GetUniqueHandlers<IOnLanguageClientInitialize>(result)
+                        .Select(handler => Observable.FromAsync((ct) => handler.OnInitialize(this, ClientSettings, ct)))
+                        .Merge(),
+                    GetUniqueHandlers<IOnLanguageClientInitialized>(result)
+                        .Select(handler => Observable.FromAsync((ct) => handler.OnInitialized(this, ClientSettings, ServerSettings, ct)))
+                        .Merge(),
+                    GetUniqueHandlers<IOnLanguageClientStarted>(result)
+                        .Select(handler => Observable.FromAsync((ct) => handler.OnStarted(this, ct)))
+                        .Merge()
+                ).Subscribe();
             }
 
             return result;

src/Client/LanguageClientOptionsExtensions.cs

@@ -91,8 +91,20 @@ public static LanguageClientOptions WithClientCapabilities(this LanguageClientOp
             return options;
         }
 
-        public static LanguageClientOptions OnStarted(this LanguageClientOptions options,
-            OnLanguageClientStartedDelegate @delegate)
+        public static LanguageClientOptions OnInitialize(this LanguageClientOptions options, OnLanguageClientInitializeDelegate @delegate)
+        {
+            options.Services.AddSingleton(@delegate);
+            return options;
+        }
+
+
+        public static LanguageClientOptions OnInitialized(this LanguageClientOptions options, OnLanguageClientInitializedDelegate @delegate)
+        {
+            options.Services.AddSingleton(@delegate);
+            return options;
+        }
+
+        public static LanguageClientOptions OnStarted(this LanguageClientOptions options, OnLanguageClientStartedDelegate @delegate)
         {
             options.Services.AddSingleton(@delegate);
             return options;

src/Dap.Client/DebugAdapterClient.cs

@@ -11,6 +11,7 @@
 using DryIoc;
 using MediatR;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using OmniSharp.Extensions.DebugAdapter.Protocol;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Client;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Events;
@@ -22,16 +23,23 @@
 
 namespace OmniSharp.Extensions.DebugAdapter.Client
 {
-    public class DebugAdapterClient : JsonRpcServerBase, IDebugAdapterClient, IInitializedHandler
+    public class DebugAdapterClient : JsonRpcServerBase, IDebugAdapterClient, IDebugAdapterInitializedHandler
     {
         private readonly DebugAdapterSettingsBag _settingsBag;
         private readonly DebugAdapterHandlerCollection _collection;
+        private readonly IEnumerable<OnDebugAdapterClientInitializeDelegate> _initializeDelegates;
+        private readonly IEnumerable<IOnDebugAdapterClientInitialize> _initializeHandlers;
+        private readonly IEnumerable<OnDebugAdapterClientInitializedDelegate> _initializedDelegates;
+        private readonly IEnumerable<IOnDebugAdapterClientInitialized> _initializedHandlers;
         private readonly IEnumerable<OnDebugAdapterClientStartedDelegate> _startedDelegates;
+        private readonly IEnumerable<IOnDebugAdapterClientStarted> _startedHandlers;
         private readonly CompositeDisposable _disposable = new CompositeDisposable();
         private readonly Connection _connection;
         private readonly DapReceiver _receiver;
         private readonly IServiceProvider _serviceProvider;
         private readonly ISubject<InitializedEvent> _initializedComplete = new AsyncSubject<InitializedEvent>();
+        private bool _started;
+        private readonly int? _concurrency;
 
         internal static IContainer CreateContainer(DebugAdapterClientOptions options, IServiceProvider outerServiceProvider) =>
             JsonRpcServerContainer.Create(outerServiceProvider)
@@ -69,6 +77,7 @@ public static async Task<DebugAdapterClient> From(DebugAdapterClientOptions opti
         }
 
         internal DebugAdapterClient(
+            IOptions<DebugAdapterClientOptions> options,
             InitializeRequestArguments clientSettings,
             DebugAdapterSettingsBag settingsBag,
             DebugAdapterHandlerCollection collection,
@@ -77,8 +86,12 @@ internal DebugAdapterClient(
             IResponseRouter responseRouter,
             IServiceProvider serviceProvider,
             IDebugAdapterClientProgressManager debugAdapterClientProgressManager,
-            Connection connection
-        ) : base(collection, responseRouter)
+            Connection connection,
+            IEnumerable<OnDebugAdapterClientInitializeDelegate> initializeDelegates,
+            IEnumerable<IOnDebugAdapterClientInitialize> initializeHandlers,
+            IEnumerable<OnDebugAdapterClientInitializedDelegate> initializedDelegates,
+            IEnumerable<IOnDebugAdapterClientInitialized> initializedHandlers,
+            IEnumerable<IOnDebugAdapterClientStarted> startedHandlers) : base(collection, responseRouter)
         {
             _settingsBag = settingsBag;
             ClientSettings = clientSettings;
@@ -88,33 +101,71 @@ Connection connection
             _serviceProvider = serviceProvider;
             ProgressManager = debugAdapterClientProgressManager;
             _connection = connection;
+            _initializeDelegates = initializeDelegates;
+            _initializeHandlers = initializeHandlers;
+            _initializedDelegates = initializedDelegates;
+            _initializedHandlers = initializedHandlers;
+            _startedHandlers = startedHandlers;
+            _concurrency = options.Value.Concurrency;
+
             _disposable.Add(collection.Add(this));
         }
 
         public async Task Initialize(CancellationToken token)
         {
+            await DebugAdapterEventingHelper.Run(
+                _initializeDelegates,
+                (handler, ct) => handler(this, ClientSettings, ct),
+                _initializeHandlers.Union(_collection.Select(z => z.Handler).OfType<IOnDebugAdapterClientInitialize>()),
+                (handler, ct) => handler.OnInitialize(this, ClientSettings, ct),
+                _concurrency,
+                token
+            );
+
             RegisterCapabilities(ClientSettings);
 
             _connection.Open();
-            var serverParams = await this.RequestInitialize(ClientSettings, token);
+            var serverParams = await this.RequestDebugAdapterInitialize(ClientSettings, token);
 
             ServerSettings = serverParams;
             _receiver.Initialized();
 
+            await DebugAdapterEventingHelper.Run(
+                _initializedDelegates,
+                (handler, ct) => handler(this, ClientSettings, ServerSettings, ct),
+                _initializedHandlers.Union(_collection.Select(z => z.Handler).OfType<IOnDebugAdapterClientInitialized>()),
+                (handler, ct) => handler.OnInitialized(this, ClientSettings, ServerSettings, ct),
+                _concurrency,
+                token
+            );
+
             await _initializedComplete.ToTask(token);
 
-            await _startedDelegates.Select(@delegate => Observable.FromAsync(() => @delegate(this, serverParams, token)))
-                .ToObservable()
-                .Merge()
-                .LastOrDefaultAsync()
-                .ToTask(token);
+            await DebugAdapterEventingHelper.Run(
+                _startedDelegates,
+                (handler, ct) => handler(this, ct),
+                _startedHandlers.Union(_collection.Select(z => z.Handler).OfType<IOnDebugAdapterClientStarted>()),
+                (handler, ct) => handler.OnStarted(this, ct),
+                _concurrency,
+                token
+            );
+            _started = true;
         }
 
-        Task<Unit> IRequestHandler<InitializedEvent, Unit>.Handle(InitializedEvent request, CancellationToken cancellationToken)
+        async Task<Unit> IRequestHandler<InitializedEvent, Unit>.Handle(InitializedEvent request, CancellationToken cancellationToken)
         {
+            await DebugAdapterEventingHelper.Run(
+                _initializedDelegates,
+                (handler, ct) => handler(this, ClientSettings, ServerSettings, ct),
+                _initializedHandlers.Union(_collection.Select(z => z.Handler).OfType<IOnDebugAdapterClientInitialized>()),
+                (handler, ct) => handler.OnInitialized(this, ClientSettings, ServerSettings, ct),
+                _concurrency,
+                cancellationToken
+            );
+
             _initializedComplete.OnNext(request);
             _initializedComplete.OnCompleted();
-            return Unit.Task;
+            return Unit.Value;
         }
 
         private void RegisterCapabilities(InitializeRequestArguments capabilities)

src/Dap.Client/DebugAdapterClientOptionsExtensions.cs

@@ -4,6 +4,7 @@
 using Microsoft.Extensions.Logging;
 using OmniSharp.Extensions.DebugAdapter.Protocol;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Client;
+using OmniSharp.Extensions.DebugAdapter.Protocol.Server;
 using OmniSharp.Extensions.JsonRpc;
 
 namespace OmniSharp.Extensions.DebugAdapter.Client
@@ -23,8 +24,19 @@ public static DebugAdapterClientOptions WithRequestProcessIdentifier(this DebugA
             return options;
         }
 
-        public static DebugAdapterClientOptions OnStarted(this DebugAdapterClientOptions options,
-            OnDebugAdapterClientStartedDelegate @delegate)
+        public static DebugAdapterClientOptions OnInitialize(this DebugAdapterClientOptions options, OnDebugAdapterClientInitializeDelegate @delegate)
+        {
+            options.Services.AddSingleton(@delegate);
+            return options;
+        }
+
+        public static DebugAdapterClientOptions OnInitialized(this DebugAdapterClientOptions options, OnDebugAdapterClientInitializedDelegate initializedDelegate)
+        {
+            options.Services.AddSingleton(initializedDelegate);
+            return options;
+        }
+
+        public static DebugAdapterClientOptions OnStarted(this DebugAdapterClientOptions options, OnDebugAdapterClientStartedDelegate @delegate)
         {
             options.Services.AddSingleton(@delegate);
             return options;

src/Dap.Protocol/Client/IOnDebugAdapterClientInitialize.cs

@@ -0,0 +1,16 @@
+using System.Threading;
+using System.Threading.Tasks;
+using OmniSharp.Extensions.DebugAdapter.Protocol.Requests;
+using OmniSharp.Extensions.JsonRpc;
+
+namespace OmniSharp.Extensions.DebugAdapter.Protocol.Client
+{
+    /// <summary>
+    /// Gives your class or handler an opportunity to interact with
+    /// the <see cref="InitializeRequestArguments"/> before it is sent to the server
+    /// </summary>
+    public interface IOnDebugAdapterClientInitialize : IEventingHandler
+    {
+        Task OnInitialize(IDebugAdapterClient client, InitializeRequestArguments request, CancellationToken cancellationToken);
+    }
+}