Changes:

--------

1. Pipelines

   - (TBR) disable the constraint of pushing NuGet packages to the feed
     only when source branch is master
   - (TBD) restore, build and pack the main solution explicitly
     before running unit tests
   - Use .NET Runtime 8.0.8 and UseDotNet@2 for both 6.0.317 and 8.0.400

2. General

   - change the UiPath.CoreIpc* namespace to UiPath.Ipc*
   - decomission the usage of Nito
   - start optimizing logging via LoggerMessageAttribute

3. API and behavior

   - commission the new Ipc API that doesn't rely on the fluent builder pattern
   - commission the feature that allows the optional BeforeCall
     of an IpcServer Endpoint to share its AsyncLocal context
     with the target method execution, if the BeforeCall executes
     synchronously.
     Check the ServerBeforeCall_WhenSync_ShouldShareAsyncLocalContextWithTheTargetMethodCall test for further details.
   - extensibility support for potentially any transport, including JS-DotNetWasm interop

4. Internals
   - decommission the generic variant of ServiceClient, thus greatly simplifying the flow
   - commission the ServiceClientProper and ServiceClientForCallback subclasses

Author: eduard-dumitru

src/NuGet.Config renamed to NuGet.Config

@@ -2,5 +2,6 @@
 <configuration>
   <packageSources>
     <add key="Nuget" value="https://api.nuget.org/v3/index.json" />
+    <add key="UiPath-Internal" value="https://uipath.pkgs.visualstudio.com/Public.Feeds/_packaging/UiPath-Internal/nuget/v3/index.json" />
   </packageSources>
 </configuration>

src/CI/azp-dotnet-dist.yaml

@@ -16,15 +16,15 @@ steps:
 
   - task: DotNetCoreCLI@2
     displayName: 'dotnet push to UiPath-Internal'
-    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/master'))
+    condition: succeeded()
     inputs:
       command: push
       packagesToPush: '$(Build.ArtifactStagingDirectory)/**/*.nupkg'
       publishVstsFeed: 'Public.Feeds/UiPath-Internal'
 
   - task: PublishSymbols@2
     displayName: 'Publish Symbols to UiPath Azure Artifacts Symbol Server'
-    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/master'))
+    condition: succeeded()
     inputs:
       symbolsFolder: $(Build.SourcesDirectory)
       searchPattern: '**/UiPath.CoreIpc/bin/**/UiPath.CoreIpc.pdb'

src/CI/azp-dotnet.yaml

@@ -1,4 +1,10 @@
 steps:
+  - task: DotNetCoreCLI@2
+    displayName: '$(Label_DotNet) Restore, build and pack'
+    inputs:
+      projects: '$(DotNet_SessionSolution)'
+      arguments: '--configuration $(DotNet_BuildConfiguration) -p:Version="$(FullVersion)" -p:DefineConstantsEx="CI"'
+      
   - task: DotNetCoreCLI@2
     displayName: '$(Label_DotNet) Run unit tests'
     inputs:

src/CI/azp-initialization.yaml

@@ -1,4 +1,23 @@
 steps:
+# Runtime version should match with SDK version.
+# The runtime should be the one that is contained in SDK.
+# https://dotnet.microsoft.com/en-us/download/dotnet/6.0
+  - powershell: |
+      Write-Host "##vso[task.setvariable variable=DotnetRuntimeVersion;]8.0.8"
+      Write-Host "##vso[task.setvariable variable=DOTNET_NOLOGO;]true"
+    displayName: 'Use .NET Runtime 8.0.8'
+
+  - task: UseDotNet@2
+    displayName: 'Use .NET SDK 6.0.317'
+    inputs:
+      packageType: 'sdk'
+      version: '6.0.317'
+
+  - task: UseDotNet@2
+    displayName: 'Use .NET SDK 8.0.400'
+    inputs:
+      packageType: 'sdk'
+      version: 8.0.400
 
     # Read $(Version) from the UiPath.CoreIpc.csproj file
   - powershell: |

src/CI/azp-nodejs.yaml

@@ -48,7 +48,7 @@
     inputs:
         workingDirectory: $(NodeJS_ProjectPath)
         script: 'npm test'
-
+    
   - task: PublishTestResults@2
     displayName: 'Publish Web Test Results'
     condition: succeededOrFailed()

src/CI/azp-start.yaml

@@ -10,7 +10,7 @@ variables:
   DotNet_MainProjectName: 'UiPath.CoreIpc'
   DotNet_MainProjectPath: './src/UiPath.CoreIpc/UiPath.CoreIpc.csproj'
   DotNet_ArtifactName: 'NuGet package'
-
+  
   NodeJS_DotNet_BuildConfiguration: 'Debug'
   NodeJS_ProjectPath: './src/Clients/js'
   NodeJS_ArchivePath: './src/Clients/js/dist/pack/nodejs.zip'
@@ -23,32 +23,32 @@ stages:
 - stage: Build
   displayName: '🏭 Build' 
   jobs:
-    # The following 3 jobs will run in parallel:  
-    - job:
-      displayName: '.NET on Windows'
-      pool:
+  # The following 3 jobs will run in parallel:            
+  - job:
+    displayName: '.NET on Windows'
+    pool:
         vmImage: 'windows-2022'
-      steps:
-        - template: azp-initialization.yaml
-        - template: azp-dotnet.yaml
-        - template: azp-dotnet-dist.yaml
-  
-    - job:
-      displayName: 'node.js on Windows'
-      pool:
+    steps:
+      - template: azp-initialization.yaml
+      - template: azp-dotnet.yaml
+      - template: azp-dotnet-dist.yaml
+
+  - job:
+    displayName: 'node.js on Windows'
+    pool:
         vmImage: 'windows-2022'
-      steps:
-        - template: azp-initialization.yaml
-        - template: azp-nodejs.yaml
-        - template: azp-nodejs-dist.yaml
-  
-    - job:
-      displayName: 'node.js on Ubuntu'
-      pool:
-        vmImage: 'ubuntu-20.04'
-      steps:
-        - template: azp-initialization.yaml
-        - template: azp-nodejs.yaml
+    steps:
+      - template: azp-initialization.yaml
+      - template: azp-nodejs.yaml
+      - template: azp-nodejs-dist.yaml
+
+  - job:
+    displayName: 'node.js on Ubuntu'
+    pool:
+      vmImage: 'ubuntu-20.04'
+    steps:
+      - template: azp-initialization.yaml
+      - template: azp-nodejs.yaml
 
 - stage: Publish
   displayName: 🚚 Publish

src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.30320.27
+# Visual Studio Version 17
+VisualStudioVersion = 17.10.35027.167
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UiPath.CoreIpc.NodeInterop", "UiPath.CoreIpc.NodeInterop\UiPath.CoreIpc.NodeInterop.csproj", "{B514D2A2-B8ED-4A2A-BDE7-42F74A316FBE}"
 EndProject

src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Contracts.cs

@@ -2,7 +2,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace UiPath.CoreIpc.NodeInterop;
+namespace UiPath.Ipc.NodeInterop;
 
 internal static class Contracts
 {

src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Program.cs

@@ -7,14 +7,15 @@
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
-using UiPath.CoreIpc.NamedPipe;
-using UiPath.CoreIpc.WebSockets;
+using UiPath.Ipc.Transport.NamedPipe;
+using UiPath.Ipc.Transport.WebSocket;
 
-namespace UiPath.CoreIpc.NodeInterop;
+namespace UiPath.Ipc.NodeInterop;
 
 using static Contracts;
 using static ServiceImpls;
 using static Signalling;
+using static UiPath.Ipc.NodeInterop.Extensions;
 
 class Program
 {
@@ -61,6 +62,11 @@ static async Task<int> Main(
 
     static async Task MainCore(string? pipeName, string? webSocketUrl, int? maybeSecondsPowerOnDelay)
     {
+        if (pipeName is null && webSocketUrl is null)
+        {
+            throw new ArgumentException($"At least one of {nameof(pipeName)} or {nameof(webSocketUrl)} must be specified.");
+        }
+
         if (maybeSecondsPowerOnDelay is { } secondsPowerOnDelay)
         {
             await Task.Delay(TimeSpan.FromSeconds(secondsPowerOnDelay));
@@ -71,34 +77,41 @@ static async Task MainCore(string? pipeName, string? webSocketUrl, int? maybeSec
 
         var sp = services
             .AddLogging()
-            .AddIpc()
             .AddSingleton<IAlgebra, Algebra>()
             .AddSingleton<ICalculus, Calculus>()
             .AddSingleton<IBrittleService, BrittleService>()
             .AddSingleton<IEnvironmentVariableGetter, EnvironmentVariableGetter>()
             .AddSingleton<IDtoService, DtoService>()
             .BuildServiceProvider();
 
-        var serviceHost = new ServiceHostBuilder(sp)
-            .UseNamedPipesAndOrWebSockets(pipeName, webSocketUrl)
-            .AddEndpoint<IAlgebra, IArithmetic>()
-            .AddEndpoint<ICalculus>()
-            .AddEndpoint<IBrittleService>()
-            .AddEndpoint<IEnvironmentVariableGetter>()
-            .AddEndpoint<IDtoService>()
-            .Build();
-
         var thread = new AsyncContextThread();
         thread.Context.SynchronizationContext.Send(_ => Thread.CurrentThread.Name = "GuiThread", null);
-        var sched = thread.Context.Scheduler;
+        var scheduler = thread.Context.Scheduler;
+
+        var ipcServer = new IpcServer()
+        {
+            Endpoints = new()
+            {
+                typeof(IAlgebra),
+                typeof(ICalculus),
+                typeof(IBrittleService),
+                typeof(IEnvironmentVariableGetter),
+                typeof(IDtoService)
+            },
+            Listeners = [
+                ..EnumerateListeners(pipeName, webSocketUrl)
+            ],
+            ServiceProvider = sp,
+            Scheduler = scheduler
+        };
+        ipcServer.Start();
 
         _ = Task.Run(async () =>
         {
             try
             {
                 await using var sp = new ServiceCollection()
                     .AddLogging()
-                    .AddIpc()
                     .BuildServiceProvider();
 
                 var callback = new Arithmetic();
@@ -107,25 +120,51 @@ IEnumerable<Task> EnumeratePings()
                 {
                     if (webSocketUrl is not null)
                     {
-                        yield return new WebSocketClientBuilder<IAlgebra, IArithmetic>(uri: new(webSocketUrl), sp)
-                            .RequestTimeout(TimeSpan.FromHours(5))
-                            .CallbackInstance(callback)
-                            .Build()
-                            .Ping();
+                        yield return new IpcClient
+                        {
+                            Config = new()
+                            {
+                                ServiceProvider = sp,
+                                RequestTimeout = TimeSpan.FromHours(5),
+                                Callbacks = new()
+                                {
+                                    { typeof(IArithmetic), callback }
+                                },
+                            },
+                            Transport = new WebSocketTransport
+                            {
+                                Uri = new(webSocketUrl),
+                            }
+                        }
+                        .GetProxy<IAlgebra>()
+                        .Ping();
                     }
 
                     if (pipeName is not null)
                     {
-                        yield return new NamedPipeClientBuilder<IAlgebra, IArithmetic>(pipeName, sp)
-                            .RequestTimeout(TimeSpan.FromHours(5))
-                            .CallbackInstance(callback)
-                            .Build()
-                            .Ping();
+                        yield return new IpcClient
+                        {
+                            Config = new()
+                            {
+                                ServiceProvider = sp,
+                                RequestTimeout = TimeSpan.FromHours(5),
+                                Callbacks = new()
+                                {
+                                    { typeof(IArithmetic), callback }
+                                }
+                            },
+                            Transport = new NamedPipeTransport()
+                            {
+                                PipeName = pipeName,
+                            }
+                        }
+                        .GetProxy<IAlgebra>()
+                        .Ping();
                     }
                 }
 
                 await Task.WhenAll(EnumeratePings());
-                
+
                 Send(SignalKind.ReadyToConnect);
             }
             catch (Exception ex)
@@ -135,7 +174,29 @@ IEnumerable<Task> EnumeratePings()
             }
         });
 
-        await serviceHost.RunAsync(sched);
+        await ipcServer.WaitForStop();
+
+        IEnumerable<ListenerConfig> EnumerateListeners(string? pipeName, string? webSocketUrl)
+        {
+            if (pipeName is not null)
+            {
+                yield return new NamedPipeListener() { PipeName = pipeName };
+            }
+
+            if (webSocketUrl is not null)
+            {
+                string url = CurateWebSocketUrl(webSocketUrl);
+                var accept = new HttpSysWebSocketsListener(url).Accept;
+                yield return new WebSocketListener() { Accept = accept };
+            }
+
+            static string CurateWebSocketUrl(string raw)
+            {
+                var builder = new UriBuilder(raw);
+                builder.Scheme = "http";
+                return builder.ToString();
+            }
+        }
     }
 
     private class Arithmetic : IArithmetic
@@ -148,37 +209,6 @@ private class Arithmetic : IArithmetic
 
 internal static class Extensions
 {
-    public static ServiceHostBuilder UseNamedPipesAndOrWebSockets(this ServiceHostBuilder builder, string? pipeName, string? webSocketUrl)
-    {
-        if (pipeName is null && webSocketUrl is null)
-        {
-            throw new ArgumentOutOfRangeException();
-        }                
-
-        if (pipeName is not null)
-        {
-            builder = builder.UseNamedPipes(new NamedPipeSettings(pipeName));
-        }
-
-        if (webSocketUrl is not null)
-        {
-            string url = CurateWebSocketUrl(webSocketUrl);
-            var accept = new HttpSysWebSocketsListener(url).Accept;
-            WebSocketSettings settings = new(accept);
-
-            builder = builder.UseWebSockets(settings);
-        }
-
-        return builder;
-    }
-
-    private static string CurateWebSocketUrl(string raw)
-    {
-        var builder = new UriBuilder(raw);
-        builder.Scheme = "http";
-        return builder.ToString();
-    }
-
     public class HttpSysWebSocketsListener : IDisposable
     {
         HttpListener _httpListener = new();

src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/ServiceImpls.cs

@@ -3,7 +3,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace UiPath.CoreIpc.NodeInterop;
+namespace UiPath.Ipc.NodeInterop;
 
 using static Contracts;