diff --git a/src/NuGet.Config b/NuGet.Config similarity index 56% rename from src/NuGet.Config rename to NuGet.Config index ba6d1755..437e25e1 100644 --- a/src/NuGet.Config +++ b/NuGet.Config @@ -2,5 +2,6 @@ + \ No newline at end of file diff --git a/benchmarks/Benchmarks.sln b/benchmarks/Benchmarks.sln new file mode 100644 index 00000000..31395937 --- /dev/null +++ b/benchmarks/Benchmarks.sln @@ -0,0 +1,28 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.31903.59 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UiPath.CoreIpc", "..\src\UiPath.CoreIpc\UiPath.CoreIpc.csproj", "{6E3048EE-987B-4846-84EF-305A286092B1}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UiPath.Ipc.Benchmarks", "UiPath.Ipc.Benchmarks\UiPath.Ipc.Benchmarks.csproj", "{D12CCF62-00C5-4291-A6A8-D3321C107EE7}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {6E3048EE-987B-4846-84EF-305A286092B1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6E3048EE-987B-4846-84EF-305A286092B1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6E3048EE-987B-4846-84EF-305A286092B1}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6E3048EE-987B-4846-84EF-305A286092B1}.Release|Any CPU.Build.0 = Release|Any CPU + {D12CCF62-00C5-4291-A6A8-D3321C107EE7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D12CCF62-00C5-4291-A6A8-D3321C107EE7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D12CCF62-00C5-4291-A6A8-D3321C107EE7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D12CCF62-00C5-4291-A6A8-D3321C107EE7}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/benchmarks/UiPath.Ipc.Benchmarks/IpcBenchmark.cs b/benchmarks/UiPath.Ipc.Benchmarks/IpcBenchmark.cs new file mode 100644 index 00000000..d1da662d --- /dev/null +++ b/benchmarks/UiPath.Ipc.Benchmarks/IpcBenchmark.cs @@ -0,0 +1,41 @@ +using BenchmarkDotNet.Attributes; +using BenchmarkDotNet.Jobs; +using UiPath.Ipc.Benchmarks; + +[SimpleJob(RuntimeMoniker.Net461, baseline: true)] +[SimpleJob(RuntimeMoniker.Net80)] +[RPlotExporter] +public class IpcBenchmark +{ + private Technology _technology = null!; + private Technology.IProxy _proxy = null!; + + [Params(TechnologyId.Old, TechnologyId.New)] + public TechnologyId TechId; + + [GlobalSetup] + public async Task Setup() + { + _technology = TechId.Create(); + await _technology.Init(); + _proxy = _technology.GetProxy(); + } + + [GlobalCleanup] + public async Task Cleanup() + { + await _technology.DisposeAsync(); + } + + [Benchmark] + public async Task SimpleCall() + { + _ = await _proxy.AddFloats(1, 1); + } + + [Benchmark] + public async Task CallWithCallback() + { + _ = await _proxy.GetCallbackThreadName(); + } +} \ No newline at end of file diff --git a/benchmarks/UiPath.Ipc.Benchmarks/Program.cs b/benchmarks/UiPath.Ipc.Benchmarks/Program.cs new file mode 100644 index 00000000..9d353e5c --- /dev/null +++ b/benchmarks/UiPath.Ipc.Benchmarks/Program.cs @@ -0,0 +1,15 @@ +using BenchmarkDotNet.Running; +using UiPath.Ipc.Benchmarks; + + +// await Run(TechnologyId.New); +// BenchmarkRunner.Run(); +BenchmarkRunner.Run(); + +static async Task Run(TechnologyId techId) +{ + await using var tech = techId.Create(); + await tech.Init(); + var x = await tech.GetProxy().AddFloats(1, 1); + Console.WriteLine($"{nameof(x)} == {x}"); +} \ No newline at end of file diff --git a/benchmarks/UiPath.Ipc.Benchmarks/SchedulerBenchmark.cs b/benchmarks/UiPath.Ipc.Benchmarks/SchedulerBenchmark.cs new file mode 100644 index 00000000..7b773a86 --- /dev/null +++ b/benchmarks/UiPath.Ipc.Benchmarks/SchedulerBenchmark.cs @@ -0,0 +1,65 @@ +using BenchmarkDotNet.Attributes; +using BenchmarkDotNet.Jobs; +using Nito.AsyncEx; + +[SimpleJob(RuntimeMoniker.Net461, baseline: true)] +[SimpleJob(RuntimeMoniker.Net80)] +[RPlotExporter] +public class SchedulerBenchmark +{ + private TaskScheduler _scheduler = null!; + + [Params(SchedulerKind.ConcurrentExclusive, SchedulerKind.AsyncContextThread)] + public SchedulerKind SchedulerKind; + + [GlobalSetup] + public void Setup() + { + _scheduler = SchedulerKind.Create(); + } + + [GlobalCleanup] + public void Cleanup() + { + _scheduler = null!; + } + + [Benchmark] + public void Schedule() + { + _scheduler.RunAsync(async () => + { + }); + } +} + +public enum SchedulerKind +{ + ConcurrentExclusive, + AsyncContextThread +} + +public static class SchedulerKindExtensions +{ + public static TaskScheduler Create(this SchedulerKind schedulerKind) + { + switch (schedulerKind) + { + case SchedulerKind.ConcurrentExclusive: + return new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler; + case SchedulerKind.AsyncContextThread: + return new AsyncContextThread().Context.Scheduler; + default: + throw new ArgumentOutOfRangeException(nameof(schedulerKind)); + } + } +} + +public static class TaskExtensions +{ + public static Task RunAsync(this TaskScheduler scheduler, Func asyncAction) + => Task.Factory.StartNew(asyncAction, CancellationToken.None, TaskCreationOptions.DenyChildAttach, scheduler).Unwrap(); + + public static Task RunAsync(this TaskScheduler scheduler, Func> asyncFunc) + => Task.Factory.StartNew(asyncFunc, CancellationToken.None, TaskCreationOptions.DenyChildAttach, scheduler).Unwrap(); +} \ No newline at end of file diff --git a/benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.New.cs b/benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.New.cs new file mode 100644 index 00000000..24fa49cf --- /dev/null +++ b/benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.New.cs @@ -0,0 +1,106 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using UiPath.Ipc.Transport.NamedPipe; + +namespace UiPath.Ipc.Benchmarks; + +partial class Technology +{ + public sealed class New : Technology, IProxy + { + private const string PipeName = "BenchmarkPipeNew"; + private const int ConcurrentAccepts = 10; + private const int MaxRequestMB = 100; + + private static readonly TimeSpan ServerTimeout = TimeSpan.FromDays(1); + private static readonly TimeSpan ClientTimeout = TimeSpan.FromDays(1); + private readonly TaskScheduler _scheduler = new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler; + + private readonly ComputingCallback _computingCallback = new(); + private readonly ServiceProvider _serviceProvider; + private readonly IpcServer _server; + private readonly ClientBase _client; + private readonly IComputingService _proxy; + + public New() + { + _serviceProvider = new ServiceCollection() + .AddLogging() + .AddSingleton() + .BuildServiceProvider(); + + _server = new IpcServer + { + Endpoints = new() + { + { typeof(IComputingService) } + }, + Listeners = [ + new NamedPipeListener + { + PipeName = PipeName, + RequestTimeout = ServerTimeout, + ConcurrentAccepts = ConcurrentAccepts, + MaxReceivedMessageSizeInMegabytes = MaxRequestMB + } + ], + Scheduler = _scheduler, + ServiceProvider = _serviceProvider + }; + + _client = new NamedPipeClient + { + PipeName = PipeName, + AllowImpersonation = true, + RequestTimeout = TimeSpan.FromSeconds(5), + Scheduler = _scheduler, + Callbacks = new() + { + { typeof(IComputingCallback), _computingCallback } + } + }; + + _proxy = _client.GetProxy(); + } + + public override async Task Init() + { + _server.Start(); + _ = await GetProxy().GetCallbackThreadName(); + } + + public override async ValueTask DisposeAsync() + { + (_proxy as IpcProxy)!.Dispose(); + await _server.DisposeAsync(); + } + + public override IProxy GetProxy() => this; + + Task IProxy.AddFloats(float x, float y) => _proxy.AddFloats(x, y); + Task IProxy.GetCallbackThreadName() => _proxy.GetCallbackThreadName(TimeSpan.Zero); + + + private interface IComputingService + { + Task AddFloats(float x, float y, CancellationToken ct = default); + Task GetCallbackThreadName(TimeSpan duration, Message message = null!, CancellationToken cancellationToken = default); + } + + private sealed class ComputingService(ILogger logger) : IComputingService + { + public async Task AddFloats(float a, float b, CancellationToken ct = default) + { + logger.LogInformation($"{nameof(AddFloats)} called."); + return a + b; + } + + public async Task GetCallbackThreadName(TimeSpan duration, Message message = null!, CancellationToken cancellationToken = default) + { + await Task.Delay(duration); + return await message.GetCallback().GetThreadName(); + } + } + } +} + diff --git a/benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.Old.cs b/benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.Old.cs new file mode 100644 index 00000000..7e027603 --- /dev/null +++ b/benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.Old.cs @@ -0,0 +1,99 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using UiPath.CoreIpc; +using UiPath.CoreIpc.NamedPipe; + +namespace UiPath.Ipc.Benchmarks; + +partial class Technology +{ + public sealed class Old : Technology, IProxy + { + private const string PipeName = "BenchmarkPipeOld"; + private const int ConcurrentAccepts = 10; + private const int MaxRequestMB = 100; + + private static readonly TimeSpan ServerTimeout = TimeSpan.FromDays(1); + private static readonly TimeSpan ClientTimeout = TimeSpan.FromSeconds(1); + private readonly TaskScheduler _scheduler = new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler; + private Task? _serverRunning; + + private readonly ComputingCallback _computingCallback = new(); + private readonly ServiceProvider _serverServiceProvider; + private readonly ServiceProvider _clientServiceProvider; + private readonly ServiceHost _serviceHost; + private readonly IComputingService _proxy; + + public Old() + { + _serverServiceProvider = new ServiceCollection() + .AddIpc() + .AddLogging() + .AddSingleton() + .BuildServiceProvider(); + + _clientServiceProvider = new ServiceCollection() + .AddIpc() + .AddLogging() + .AddSingleton(_computingCallback) + .BuildServiceProvider(); + + _serviceHost = new ServiceHostBuilder(_serverServiceProvider) + .AddEndpoint() + .UseNamedPipes(new NamedPipeSettings(PipeName) + { + RequestTimeout = ServerTimeout, + ConcurrentAccepts = ConcurrentAccepts, + MaxReceivedMessageSizeInMegabytes = MaxRequestMB, + }) + .Build(); + + _proxy = new NamedPipeClientBuilder(PipeName, _clientServiceProvider) + .AllowImpersonation() + .RequestTimeout(ClientTimeout) + .TaskScheduler(_scheduler) + .CallbackInstance(_computingCallback) + .Build(); + } + + public override async Task Init() + { + _serverRunning = _serviceHost.RunAsync(_scheduler); + _ = await GetProxy().GetCallbackThreadName(); + } + + public override async ValueTask DisposeAsync() + { + (_proxy as CoreIpc.IpcProxy)!.Dispose(); + _serviceHost.Dispose(); + await (_serverRunning ?? Task.CompletedTask); + } + + public override IProxy GetProxy() => this; + + Task IProxy.AddFloats(float x, float y) => _proxy.AddFloats(x, y); + Task IProxy.GetCallbackThreadName() => _proxy.GetCallbackThreadName(TimeSpan.Zero); + + private interface IComputingService + { + Task AddFloats(float x, float y, CancellationToken ct = default); + Task GetCallbackThreadName(TimeSpan duration, CoreIpc.Message message = null!, CancellationToken cancellationToken = default); + } + + private sealed class ComputingService(ILogger logger) : IComputingService + { + public async Task AddFloats(float a, float b, CancellationToken ct = default) + { + logger.LogInformation($"{nameof(AddFloats)} called."); + return a + b; + } + + public async Task GetCallbackThreadName(TimeSpan duration, CoreIpc.Message message = null!, CancellationToken cancellationToken = default) + { + await Task.Delay(duration); + return await message.GetCallback().GetThreadName(); + } + } + } +} + diff --git a/benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.cs b/benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.cs new file mode 100644 index 00000000..a99db4f6 --- /dev/null +++ b/benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.cs @@ -0,0 +1,26 @@ +namespace UiPath.Ipc.Benchmarks; + +public abstract partial class Technology : IAsyncDisposable +{ + public abstract Task Init(); + public abstract ValueTask DisposeAsync(); + + public abstract IProxy GetProxy(); + + public interface IProxy + { + Task AddFloats(float x, float y); + Task GetCallbackThreadName(); + } + + public interface IComputingCallback + { + Task GetThreadName(); + } + + public sealed class ComputingCallback : IComputingCallback + { + public async Task GetThreadName() => Thread.CurrentThread.Name!; + } +} + diff --git a/benchmarks/UiPath.Ipc.Benchmarks/Switch/TechnologyId.cs b/benchmarks/UiPath.Ipc.Benchmarks/Switch/TechnologyId.cs new file mode 100644 index 00000000..11172685 --- /dev/null +++ b/benchmarks/UiPath.Ipc.Benchmarks/Switch/TechnologyId.cs @@ -0,0 +1,20 @@ + +namespace UiPath.Ipc.Benchmarks; + +public enum TechnologyId +{ + Old, + New +} + +public static class TechnologyIdExtensions +{ + public static Technology Create(this TechnologyId id) + => id switch + { + TechnologyId.Old => new Technology.Old(), + TechnologyId.New => new Technology.New(), + _ => throw new NotSupportedException() + }; +} + diff --git a/benchmarks/UiPath.Ipc.Benchmarks/UiPath.Ipc.Benchmarks.csproj b/benchmarks/UiPath.Ipc.Benchmarks/UiPath.Ipc.Benchmarks.csproj new file mode 100644 index 00000000..471d9092 --- /dev/null +++ b/benchmarks/UiPath.Ipc.Benchmarks/UiPath.Ipc.Benchmarks.csproj @@ -0,0 +1,23 @@ + + + + Exe + net8.0;net461 + enable + enable + latest + 1998 + + + + + + + + + + + + + + diff --git a/src/CI/azp-dotnet-dist.yaml b/src/CI/azp-dotnet-dist.yaml index bafcc806..02e66263 100644 --- a/src/CI/azp-dotnet-dist.yaml +++ b/src/CI/azp-dotnet-dist.yaml @@ -16,7 +16,7 @@ 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' @@ -24,7 +24,7 @@ steps: - 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' diff --git a/src/CI/azp-dotnet.yaml b/src/CI/azp-dotnet.yaml index 0af4fc84..515a8ea1 100644 --- a/src/CI/azp-dotnet.yaml +++ b/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: diff --git a/src/CI/azp-initialization.yaml b/src/CI/azp-initialization.yaml index 3cc0d0a3..2fd099a2 100644 --- a/src/CI/azp-initialization.yaml +++ b/src/CI/azp-initialization.yaml @@ -1,4 +1,20 @@ steps: + - powershell: | + Write-Host "##vso[task.setvariable variable=DotnetRuntimeVersion;]8.0.0" + Write-Host "##vso[task.setvariable variable=DOTNET_NOLOGO;]true" + displayName: 'Use .NET Runtime 8.0.0' + + - 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.x' + inputs: + packageType: 'sdk' + version: 8.x # Read $(Version) from the UiPath.CoreIpc.csproj file - powershell: | diff --git a/src/CI/azp-nodejs.yaml b/src/CI/azp-nodejs.yaml index 52f7d934..ee14c6bf 100644 --- a/src/CI/azp-nodejs.yaml +++ b/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() diff --git a/src/CI/azp-start.yaml b/src/CI/azp-start.yaml index d659af93..d51e5497 100644 --- a/src/CI/azp-start.yaml +++ b/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 diff --git a/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop.sln b/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop.sln index e96e6ecc..13bc8866 100644 --- a/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop.sln +++ b/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 diff --git a/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Contracts.cs b/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Contracts.cs index 0a725bab..d86c0d8e 100644 --- a/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Contracts.cs +++ b/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 { diff --git a/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Program.cs b/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Program.cs index 17f23329..bb5ed827 100644 --- a/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Program.cs +++ b/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 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,7 +77,6 @@ static async Task MainCore(string? pipeName, string? webSocketUrl, int? maybeSec var sp = services .AddLogging() - .AddIpc() .AddSingleton() .AddSingleton() .AddSingleton() @@ -79,18 +84,27 @@ static async Task MainCore(string? pipeName, string? webSocketUrl, int? maybeSec .AddSingleton() .BuildServiceProvider(); - var serviceHost = new ServiceHostBuilder(sp) - .UseNamedPipesAndOrWebSockets(pipeName, webSocketUrl) - .AddEndpoint() - .AddEndpoint() - .AddEndpoint() - .AddEndpoint() - .AddEndpoint() - .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 () => { @@ -98,7 +112,6 @@ static async Task MainCore(string? pipeName, string? webSocketUrl, int? maybeSec { await using var sp = new ServiceCollection() .AddLogging() - .AddIpc() .BuildServiceProvider(); var callback = new Arithmetic(); @@ -107,25 +120,51 @@ IEnumerable EnumeratePings() { if (webSocketUrl is not null) { - yield return new WebSocketClientBuilder(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() + .Ping(); } if (pipeName is not null) { - yield return new NamedPipeClientBuilder(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() + .Ping(); } } await Task.WhenAll(EnumeratePings()); - + Send(SignalKind.ReadyToConnect); } catch (Exception ex) @@ -135,7 +174,29 @@ IEnumerable EnumeratePings() } }); - await serviceHost.RunAsync(sched); + await ipcServer.WaitForStop(); + + IEnumerable 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(); diff --git a/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/ServiceImpls.cs b/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/ServiceImpls.cs index 0a436080..3b9706f1 100644 --- a/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/ServiceImpls.cs +++ b/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; diff --git a/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Signalling.cs b/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Signalling.cs index aba44d91..76d667f4 100644 --- a/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Signalling.cs +++ b/src/Clients/js/dotnet/UiPath.CoreIpc.NodeInterop/Signalling.cs @@ -2,7 +2,7 @@ using Newtonsoft.Json.Converters; using System; -namespace UiPath.CoreIpc.NodeInterop; +namespace UiPath.Ipc.NodeInterop; internal static class Signalling { diff --git a/src/CoreIpc.sln b/src/CoreIpc.sln index b69f1d5f..8198f5ab 100644 --- a/src/CoreIpc.sln +++ b/src/CoreIpc.sln @@ -3,41 +3,42 @@ Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.0.31919.166 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IpcSample.ConsoleServer", "IpcSample.ConsoleServer\IpcSample.ConsoleServer.csproj", "{24A3C4D2-95A2-48D9-86F2-648879EC74F4}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IpcSample.ConsoleClient", "IpcSample.ConsoleClient\IpcSample.ConsoleClient.csproj", "{8D54E62A-ECFF-4FFF-B9D1-DB343D456451}" -EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UiPath.CoreIpc", "UiPath.CoreIpc\UiPath.CoreIpc.csproj", "{58200319-1F71-4E22-894D-7E69E0CD0B57}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UiPath.CoreIpc.Tests", "UiPath.CoreIpc.Tests\UiPath.CoreIpc.Tests.csproj", "{892424AE-4D3A-4984-914E-9423BE8D0212}" -EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{676A208A-2F08-4749-A833-F8D2BCB1B147}" ProjectSection(SolutionItems) = preProject - NuGet.Config = NuGet.Config + Directory.Build.targets = Directory.Build.targets + ..\NuGet.Config = ..\NuGet.Config EndProjectSection EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Playground", "Playground\Playground.csproj", "{F0365E40-DA73-4583-A363-89CBEF68A4C6}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UiPath.CoreIpc.Http", "UiPath.CoreIpc.Http\UiPath.CoreIpc.Http.csproj", "{8776E55A-D4EB-4C3A-8FA2-29E9A1CAE469}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UiPath.Ipc.Tests", "UiPath.Ipc.Tests\UiPath.Ipc.Tests.csproj", "{E238E183-92CF-48A6-890F-C422853D6656}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution - {24A3C4D2-95A2-48D9-86F2-648879EC74F4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {24A3C4D2-95A2-48D9-86F2-648879EC74F4}.Debug|Any CPU.Build.0 = Debug|Any CPU - {24A3C4D2-95A2-48D9-86F2-648879EC74F4}.Release|Any CPU.ActiveCfg = Release|Any CPU - {24A3C4D2-95A2-48D9-86F2-648879EC74F4}.Release|Any CPU.Build.0 = Release|Any CPU - {8D54E62A-ECFF-4FFF-B9D1-DB343D456451}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {8D54E62A-ECFF-4FFF-B9D1-DB343D456451}.Debug|Any CPU.Build.0 = Debug|Any CPU - {8D54E62A-ECFF-4FFF-B9D1-DB343D456451}.Release|Any CPU.ActiveCfg = Release|Any CPU - {8D54E62A-ECFF-4FFF-B9D1-DB343D456451}.Release|Any CPU.Build.0 = Release|Any CPU {58200319-1F71-4E22-894D-7E69E0CD0B57}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {58200319-1F71-4E22-894D-7E69E0CD0B57}.Debug|Any CPU.Build.0 = Debug|Any CPU {58200319-1F71-4E22-894D-7E69E0CD0B57}.Release|Any CPU.ActiveCfg = Release|Any CPU {58200319-1F71-4E22-894D-7E69E0CD0B57}.Release|Any CPU.Build.0 = Release|Any CPU - {892424AE-4D3A-4984-914E-9423BE8D0212}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {892424AE-4D3A-4984-914E-9423BE8D0212}.Debug|Any CPU.Build.0 = Debug|Any CPU - {892424AE-4D3A-4984-914E-9423BE8D0212}.Release|Any CPU.ActiveCfg = Release|Any CPU - {892424AE-4D3A-4984-914E-9423BE8D0212}.Release|Any CPU.Build.0 = Release|Any CPU + {F0365E40-DA73-4583-A363-89CBEF68A4C6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F0365E40-DA73-4583-A363-89CBEF68A4C6}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F0365E40-DA73-4583-A363-89CBEF68A4C6}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F0365E40-DA73-4583-A363-89CBEF68A4C6}.Release|Any CPU.Build.0 = Release|Any CPU + {8776E55A-D4EB-4C3A-8FA2-29E9A1CAE469}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8776E55A-D4EB-4C3A-8FA2-29E9A1CAE469}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8776E55A-D4EB-4C3A-8FA2-29E9A1CAE469}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8776E55A-D4EB-4C3A-8FA2-29E9A1CAE469}.Release|Any CPU.Build.0 = Release|Any CPU + {E238E183-92CF-48A6-890F-C422853D6656}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E238E183-92CF-48A6-890F-C422853D6656}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E238E183-92CF-48A6-890F-C422853D6656}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E238E183-92CF-48A6-890F-C422853D6656}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/Directory.Build.targets b/src/Directory.Build.targets new file mode 100644 index 00000000..4979abb6 --- /dev/null +++ b/src/Directory.Build.targets @@ -0,0 +1,5 @@ + + + + + diff --git a/src/IpcSample.ConsoleClient/Client.cs b/src/IpcSample.ConsoleClient/Client.cs index 36515be2..b715e1cb 100644 --- a/src/IpcSample.ConsoleClient/Client.cs +++ b/src/IpcSample.ConsoleClient/Client.cs @@ -1,9 +1,9 @@ -using System.Text; +using Microsoft.Extensions.DependencyInjection; using System.Diagnostics; -using UiPath.CoreIpc.NamedPipe; -using Microsoft.Extensions.DependencyInjection; +using System.Text; +using UiPath.Ipc.BackCompat; -namespace UiPath.CoreIpc.Tests; +namespace UiPath.Ipc.Tests; class Client { @@ -32,7 +32,7 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken) var serviceProvider = ConfigureServices(); var callback = new ComputingCallback { Id = "custom made" }; var computingClientBuilder = new NamedPipeClientBuilder("test", serviceProvider) - .SerializeParametersAsObjects().CallbackInstance(callback).AllowImpersonation().RequestTimeout(TimeSpan.FromSeconds(2)); + .CallbackInstance(callback).AllowImpersonation().RequestTimeout(TimeSpan.FromSeconds(2)); var stopwatch = Stopwatch.StartNew(); int count = 0; try @@ -40,7 +40,6 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken) var computingClient = computingClientBuilder.ValidateAndBuild(); var systemClient = new NamedPipeClientBuilder("test") - .SerializeParametersAsObjects() .RequestTimeout(TimeSpan.FromSeconds(2)) .Logger(serviceProvider) .AllowImpersonation() @@ -67,7 +66,7 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken) Console.WriteLine($"[TEST 3] sum of 3 complexe number is: {result3.A}+{result3.B}i", cancellationToken); // test 4: call IPC service method without parameter or return - await systemClient.DoNothing(cancellationToken); + await systemClient.FireAndForget(cancellationToken); Console.WriteLine($"[TEST 4] invoked DoNothing()"); //((IDisposable)systemClient).Dispose(); @@ -76,7 +75,7 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken) Console.WriteLine($"[TEST 5] {text}"); // test 6: call IPC service method returning GUID - Guid generatedId = await systemClient.GetGuid(Guid.NewGuid(), cancellationToken); + Guid generatedId = await systemClient.EchoGuid(Guid.NewGuid(), cancellationToken); Console.WriteLine($"[TEST 6] generated ID is: {generatedId}"); // test 7: call IPC service method with byte array @@ -109,7 +108,7 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken) { stopwatch.Stop(); Console.WriteLine(); - Console.WriteLine("Calls per second: " + count*8 / stopwatch.Elapsed.TotalSeconds); + Console.WriteLine("Calls per second: " + count * 8 / stopwatch.Elapsed.TotalSeconds); Console.WriteLine(); } // test 10: call slow IPC service method diff --git a/src/IpcSample.ConsoleClient/IpcSample.ConsoleClient.csproj b/src/IpcSample.ConsoleClient/IpcSample.ConsoleClient.csproj index a313c304..646a29aa 100644 --- a/src/IpcSample.ConsoleClient/IpcSample.ConsoleClient.csproj +++ b/src/IpcSample.ConsoleClient/IpcSample.ConsoleClient.csproj @@ -6,10 +6,10 @@ app1.manifest latest true + enable - @@ -18,5 +18,9 @@ + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + diff --git a/src/IpcSample.ConsoleClient/SimpleClient.cs b/src/IpcSample.ConsoleClient/SimpleClient.cs new file mode 100644 index 00000000..eba71a10 --- /dev/null +++ b/src/IpcSample.ConsoleClient/SimpleClient.cs @@ -0,0 +1,66 @@ +using Microsoft.Extensions.Logging; +using UiPath.Ipc.Tests; + +namespace IpcSample.ConsoleClient; + +internal class SimpleClient +{ + + public static async Task Entry() + { + Settings pf = new() + { + ClientTransport = new ClientTransport.NamedPipes + { + PipeName = "test", + AllowImpersonation = true + }, + Logger = new Logger(new LoggerFactory()), + RequestTimeout = TimeSpan.FromSeconds(2), + Callback = new CallbackSource.Instance + { + CallbackInstance = new ComputingCallback { Id = "custom made" } + } + }; + + var cs = pf.Build(); + // ----------- + } + + class Settings + { + public required ClientTransport ClientTransport { get; init; } + public TimeSpan RequestTimeout { get; init; } = Timeout.InfiniteTimeSpan; + public required ILogger Logger { get; init; } + public CallbackSource? Callback { get; init; } + + public T Build() where T : class + { + throw null!; + } + } + + abstract class CallbackSource + { + public class Injected : CallbackSource + { + public required IServiceProvider ServiceProvider { get; init; } + public required Type CallbackType { get; init; } + } + + public class Instance : CallbackSource + { + public required object CallbackInstance { get; init; } + } + } + + abstract class ClientTransport + { + public class NamedPipes : ClientTransport + { + public required string PipeName { get; init; } + public bool AllowImpersonation { get; init; } + } + } + +} diff --git a/src/IpcSample.ConsoleClient/TcpClient.cs b/src/IpcSample.ConsoleClient/TcpClient.cs index 0768ebc6..0e5b33ed 100644 --- a/src/IpcSample.ConsoleClient/TcpClient.cs +++ b/src/IpcSample.ConsoleClient/TcpClient.cs @@ -1,10 +1,10 @@ using System.Text; using System.Diagnostics; -using UiPath.CoreIpc.Tcp; +using UiPath.Ipc.BackCompat; using Microsoft.Extensions.DependencyInjection; using System.Net; -namespace UiPath.CoreIpc.Tests; +namespace UiPath.Ipc.Tests; class TcpClient { @@ -35,7 +35,7 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken) var serviceProvider = ConfigureServices(); var callback = new ComputingCallback { Id = "custom made" }; var computingClientBuilder = new TcpClientBuilder(SystemEndPoint, serviceProvider) - .SerializeParametersAsObjects().CallbackInstance(callback)/*.EncryptAndSign("localhost")*/.RequestTimeout(TimeSpan.FromSeconds(2)); + .CallbackInstance(callback)/*.EncryptAndSign("localhost")*/.RequestTimeout(TimeSpan.FromSeconds(2)); var stopwatch = Stopwatch.StartNew(); int count = 0; try @@ -43,7 +43,6 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken) var computingClient = computingClientBuilder.ValidateAndBuild(); var systemClient = new TcpClientBuilder(SystemEndPoint) - .SerializeParametersAsObjects() //.EncryptAndSign("localhost") .RequestTimeout(TimeSpan.FromSeconds(2)) .Logger(serviceProvider) @@ -84,7 +83,7 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken) Console.WriteLine($"[TEST 5] {text}"); // test 6: call IPC service method returning GUID - Guid generatedId = await systemClient.GetGuid(Guid.NewGuid(), cancellationToken); + Guid generatedId = await systemClient.EchoGuid(Guid.NewGuid(), cancellationToken); Console.WriteLine($"[TEST 6] generated ID is: {generatedId}"); // test 7: call IPC service method with byte array diff --git a/src/IpcSample.ConsoleClient/WebSocketClient.cs b/src/IpcSample.ConsoleClient/WebSocketClient.cs index e6c93422..c9e1afbc 100644 --- a/src/IpcSample.ConsoleClient/WebSocketClient.cs +++ b/src/IpcSample.ConsoleClient/WebSocketClient.cs @@ -1,8 +1,10 @@ -using System.Text; +using Microsoft.Extensions.DependencyInjection; using System.Diagnostics; -using UiPath.CoreIpc.WebSockets; -using Microsoft.Extensions.DependencyInjection; -namespace UiPath.CoreIpc.Tests; +using System.Text; +using UiPath.Ipc.BackCompat; + +namespace UiPath.Ipc.Tests; + class WebSocketClient { static async Task _Main(string[] args) @@ -32,7 +34,7 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken) Uri uri = new("ws://localhost:1212/wsDemo/"); var serviceProvider = ConfigureServices(); var callback = new ComputingCallback { Id = "custom made" }; - var computingClientBuilder = new WebSocketClientBuilder(uri, serviceProvider).SerializeParametersAsObjects() + var computingClientBuilder = new WebSocketClientBuilder(uri, serviceProvider) .CallbackInstance(callback)/*.EncryptAndSign("localhost")*/.RequestTimeout(TimeSpan.FromSeconds(2)); var stopwatch = Stopwatch.StartNew(); int count = 0; @@ -40,7 +42,7 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken) { var computingClient = computingClientBuilder.ValidateAndBuild(); var systemClient = - new WebSocketClientBuilder(uri).SerializeParametersAsObjects() + new WebSocketClientBuilder(uri) //.EncryptAndSign("localhost") .RequestTimeout(TimeSpan.FromSeconds(2)) .Logger(serviceProvider) @@ -81,7 +83,7 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken) Console.WriteLine($"[TEST 5] {text}"); // test 6: call IPC service method returning GUID - Guid generatedId = await systemClient.GetGuid(Guid.NewGuid(), cancellationToken); + Guid generatedId = await systemClient.EchoGuid(Guid.NewGuid(), cancellationToken); Console.WriteLine($"[TEST 6] generated ID is: {generatedId}"); // test 7: call IPC service method with byte array diff --git a/src/IpcSample.ConsoleServer/Server.cs b/src/IpcSample.ConsoleServer/Server.cs index 8e9ad9e4..87e6c9ca 100644 --- a/src/IpcSample.ConsoleServer/Server.cs +++ b/src/IpcSample.ConsoleServer/Server.cs @@ -1,8 +1,9 @@ using Microsoft.Extensions.DependencyInjection; using System.Diagnostics; -using UiPath.CoreIpc.NamedPipe; +using UiPath.Ipc.BackCompat; +using UiPath.Ipc.Transport.NamedPipe; -namespace UiPath.CoreIpc.Tests; +namespace UiPath.Ipc.Tests; class Server { @@ -21,20 +22,21 @@ static async Task Main() var serviceProvider = ConfigureServices(); // build and run service host var host = new ServiceHostBuilder(serviceProvider) - .UseNamedPipes(new NamedPipeSettings("test") + .UseNamedPipes(new NamedPipeListener() { + PipeName = "test", RequestTimeout = TimeSpan.FromSeconds(2), //AccessControl = security => security.AllowCurrentUser(), }) - .AddEndpoint() + .AddEndpoint() .AddEndpoint() .ValidateAndBuild(); - await await Task.WhenAny(host.RunAsync(), Task.Run(() => + await await Task.WhenAny(host.RunAsync(), Task.Run(async () => { Console.WriteLine(typeof(int).Assembly); Console.ReadLine(); - host.Dispose(); + await host.DisposeAsync(); })); Console.WriteLine("Server stopped."); diff --git a/src/IpcSample.ConsoleServer/TcpServer.cs b/src/IpcSample.ConsoleServer/TcpServer.cs index 172a7725..a89cec24 100644 --- a/src/IpcSample.ConsoleServer/TcpServer.cs +++ b/src/IpcSample.ConsoleServer/TcpServer.cs @@ -1,9 +1,12 @@ using Microsoft.Extensions.DependencyInjection; using System.Diagnostics; -using System.Net; -using UiPath.CoreIpc.Tcp; +using UiPath.Ipc.BackCompat; +using UiPath.Ipc.Transport.Tcp; -namespace UiPath.CoreIpc.Tests; +namespace UiPath.Ipc.Tests; + +using IPEndPoint = System.Net.IPEndPoint; +using IPAddress = System.Net.IPAddress; class TcpServer { @@ -25,20 +28,21 @@ static async Task _Main() // build and run service host var data = File.ReadAllBytes(@"../../../../localhost.pfx"); var host = new ServiceHostBuilder(serviceProvider) - .UseTcp(new TcpSettings(SystemEndPoint) + .UseTcp(new TcpListener() { + EndPoint = SystemEndPoint, RequestTimeout = TimeSpan.FromSeconds(2), //Certificate = new X509Certificate(data, "1"), }) - .AddEndpoint() + .AddEndpoint() .AddEndpoint() .ValidateAndBuild(); - await await Task.WhenAny(host.RunAsync(), Task.Run(() => + await await Task.WhenAny(host.RunAsync(), Task.Run(async () => { Console.WriteLine(typeof(int).Assembly); Console.ReadLine(); - host.Dispose(); + await host.DisposeAsync(); })); Console.WriteLine("Server stopped."); diff --git a/src/IpcSample.ConsoleServer/WebSocketServer.cs b/src/IpcSample.ConsoleServer/WebSocketServer.cs index 322c1d65..8a52c013 100644 --- a/src/IpcSample.ConsoleServer/WebSocketServer.cs +++ b/src/IpcSample.ConsoleServer/WebSocketServer.cs @@ -1,9 +1,8 @@ using Microsoft.Extensions.DependencyInjection; using System.Diagnostics; -using System.Net; -using System.Net.WebSockets; -using UiPath.CoreIpc.WebSockets; -namespace UiPath.CoreIpc.Tests; +using UiPath.Ipc.BackCompat; +using UiPath.Ipc.Transport.WebSocket; +namespace UiPath.Ipc.Tests; class WebSocketServer { //private static readonly Timer _timer = new Timer(_ => @@ -23,19 +22,20 @@ static async Task _Main() // build and run service host //var data = File.ReadAllBytes(@"../../../../localhost.pfx"); var host = new ServiceHostBuilder(serviceProvider) - .UseWebSockets(new(new HttpSysWebSocketsListener("http://localhost:1212/wsDemo/").Accept) + .UseWebSockets(new WebSocketListener() { + Accept = new HttpSysWebSocketsListener("http://localhost:1212/wsDemo/").Accept, RequestTimeout = TimeSpan.FromSeconds(2), //Certificate = new X509Certificate(data, "1"), }) - .AddEndpoint() + .AddEndpoint() .AddEndpoint() .ValidateAndBuild(); - await await Task.WhenAny(host.RunAsync(), Task.Run(() => + await await Task.WhenAny(host.RunAsync(), Task.Run(async () => { Console.WriteLine(typeof(int).Assembly); Console.ReadLine(); - host.Dispose(); + await host.DisposeAsync(); })); Console.WriteLine("Server stopped."); return; diff --git a/src/Playground/Contracts.cs b/src/Playground/Contracts.cs new file mode 100644 index 00000000..dd847ede --- /dev/null +++ b/src/Playground/Contracts.cs @@ -0,0 +1,24 @@ +using UiPath.Ipc; + +namespace Playground; + +public static class Contracts +{ + public const string PipeName = "SomePipe"; + + public interface IServerOperations + { + Task Register(Message? m = null); + Task Broadcast(string text); + } + + public interface IClientOperations + { + Task Greet(string text); + } + + public interface IClientOperations2 + { + Task GetTheTime(); + } +} diff --git a/src/Playground/Impl.cs b/src/Playground/Impl.cs new file mode 100644 index 00000000..4d020920 --- /dev/null +++ b/src/Playground/Impl.cs @@ -0,0 +1,68 @@ +using System.Collections.Concurrent; +using UiPath.Ipc; + +namespace Playground; + +internal static class Impl +{ + public sealed class ClientRegistry + { + private readonly ConcurrentDictionary _clients = new(); + + public bool Add(ClientPair pair) => _clients.TryAdd(pair, value: null); + + public IReadOnlyList All() => _clients.Keys.ToArray(); + } + + public readonly record struct ClientPair(Contracts.IClientOperations Client, Contracts.IClientOperations2 Client2); + + public sealed class Server(ClientRegistry clients) : Contracts.IServerOperations + { + public async Task Register(Message? m = null) + { + var clientOps = m!.GetCallback(); + var clientOps2 = m.GetCallback(); + + var added = clients.Add(new(clientOps, clientOps2)); + + if (added) + { + Console.WriteLine("New client registered."); + } + else + { + Console.WriteLine("Client tried to register again resulting in a NOP."); + } + + return true; + } + + public async Task Broadcast(string text) + { + var pairs = clients.All(); + + foreach (var pair in pairs) + { + var time = await pair.Client2.GetTheTime(); + _ = await pair.Client.Greet($"{text} - You said the time was: {time}"); + } + + return true; + } + } + + public sealed class ClientOperations() : Contracts.IClientOperations + { + public async Task Greet(string text) + { + Console.WriteLine($"Scheduler: {TaskScheduler.Current.GetType().Name}"); + Console.WriteLine($"Server says: {text}"); + return true; + } + } + + public sealed class Client2 : Contracts.IClientOperations2 + { + public Task GetTheTime() => Task.FromResult(DateTime.Now); + } +} diff --git a/src/Playground/Playground.csproj b/src/Playground/Playground.csproj new file mode 100644 index 00000000..760afbc7 --- /dev/null +++ b/src/Playground/Playground.csproj @@ -0,0 +1,21 @@ + + + + Exe + net8.0 + enable + enable + + + + + + + + + + + + + + diff --git a/src/Playground/Program.cs b/src/Playground/Program.cs new file mode 100644 index 00000000..86bb8470 --- /dev/null +++ b/src/Playground/Program.cs @@ -0,0 +1,150 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Playground; +using UiPath.Ipc; +using UiPath.Ipc.Transport.NamedPipe; + +internal class Program +{ + private static async Task Main(string[] args) + { + using var cts = new CancellationTokenSource(); + Console.CancelKeyPress += (s, e) => + { + e.Cancel = true; + cts.Cancel(); + }; + + Uri serverUri = new("http://localhost:62234"); + Uri clientUri = new("http://localhost:62235"); + + var cancelled = Task.Delay(Timeout.InfiniteTimeSpan, cts.Token); + + var serverScheduler = new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler; + var clientScheduler = new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler; + + await using var serverSP = new ServiceCollection() + .AddSingleton() + .AddScoped() + .AddLogging(builder => builder.AddConsole()) + .BuildServiceProvider(); + + await using var clientSP = new ServiceCollection() + .AddScoped() + .AddLogging(builder => builder.AddConsole()) + .BuildServiceProvider(); + + await using var ipcServer = new IpcServer() + { + Scheduler = serverScheduler, + ServiceProvider = serverSP, + Endpoints = new() + { + typeof(Contracts.IServerOperations), // DEVINE + new EndpointSettings(typeof(Contracts.IServerOperations)) // ASTALALT + { + BeforeCall = async (callInfo, _) => + { + Console.WriteLine($"Server: {callInfo.Method.Name}"); + } + }, + typeof(Contracts.IClientOperations2) + }, + Listeners = [ + new NamedPipeListener() + { + PipeName = Contracts.PipeName, + ServerName = ".", + AccessControl = ps => + { + }, + MaxReceivedMessageSizeInMegabytes = 100, + RequestTimeout = TimeSpan.FromHours(10) + }, + //new BidirectionalHttp.ListenerConfig() + //{ + // Uri = serverUri, + // RequestTimeout = TimeSpan.FromHours(1) + //} + ] + }; + + try + { + ipcServer.Start(); // ar putea fi void, ar putea fi si Run + // await ipcServer.WaitForStart(); + } + catch (Exception ex) + { + Console.WriteLine("Failed to start."); + Console.WriteLine(ex.ToString()); + throw; + } + + var c1 = new IpcClient() + { + Config = new() + { + Callbacks = new() + { + typeof(Contracts.IClientOperations), + { typeof(Contracts.IClientOperations2), new Impl.Client2() }, + }, + ServiceProvider = clientSP, + Scheduler = clientScheduler, + }, + Transport = new NamedPipeTransport() + { + PipeName = Contracts.PipeName, + ServerName = ".", + AllowImpersonation = false, + }, + }; + + var c2 = new IpcClient() + { + Config = new() + { + ServiceProvider = clientSP, + Callbacks = new() + { + typeof(Contracts.IClientOperations), + { typeof(Contracts.IClientOperations2), new Impl.Client2() }, + }, + Scheduler = clientScheduler, + }, + Transport = new NamedPipeTransport() + { + PipeName = Contracts.PipeName, + ServerName = ".", + AllowImpersonation = false, + }, + }; + + var proxy1 = new IpcClient() + { + Config = new() + { + ServiceProvider = clientSP, + Callbacks = new() + { + typeof(Contracts.IClientOperations), + { typeof(Contracts.IClientOperations2), new Impl.Client2() }, + }, + Scheduler = clientScheduler, + }, + Transport = new NamedPipeTransport() + { + PipeName = Contracts.PipeName, + ServerName = ".", + AllowImpersonation = false, + }, + }.GetProxy(); + + + await proxy1.Register(); + await proxy1.Broadcast("Hello Bidirectional Http!"); + + await Task.WhenAny(cancelled); + } +} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Http/BidiHttpListener.cs b/src/UiPath.CoreIpc.Http/BidiHttpListener.cs new file mode 100644 index 00000000..923421bd --- /dev/null +++ b/src/UiPath.CoreIpc.Http/BidiHttpListener.cs @@ -0,0 +1,286 @@ +using Nito.AsyncEx; +using System; +using System.Buffers; +using System.Collections.Concurrent; +using System.Diagnostics.CodeAnalysis; +using System.IO.Pipelines; +using System.Net; +using System.Net.Http; +using System.Threading.Channels; + +namespace UiPath.Ipc.Http; + +using static Constants; +using IBidiHttpListenerConfig = IListenerConfig; + +public sealed partial record BidiHttpListener : ListenerConfig, IBidiHttpListenerConfig +{ + public required Uri Uri { get; init; } + + BidiHttpListenerState IBidiHttpListenerConfig.CreateListenerState(IpcServer server) + => new(server, this); + + BidiHttpServerConnectionState IBidiHttpListenerConfig.CreateConnectionState(IpcServer server, BidiHttpListenerState listenerState) + => new(server, listenerState); + + async ValueTask IBidiHttpListenerConfig.AwaitConnection(BidiHttpListenerState listenerState, BidiHttpServerConnectionState connectionState, CancellationToken ct) + { + await connectionState.WaitForConnection(ct); + return connectionState; + } + + public IEnumerable Validate() + { + throw new NotImplementedException(); + } +} + +internal sealed class BidiHttpListenerState : IAsyncDisposable +{ + private readonly IpcServer _ipcServer; + private readonly CancellationTokenSource _cts = new(); + private readonly HttpListener _httpListener; + private readonly Task _processing; + private readonly Lazy _disposing; + + private readonly ConcurrentDictionary> _connections = new(); + private readonly Channel<(Guid connectionId, Uri reverseUri)> _newConnections = Channel.CreateUnbounded<(Guid connectionId, Uri reverseUri)>(); + + public ChannelReader<(Guid connectionId, Uri reverseUri)> NewConnections => _newConnections.Reader; + public ChannelReader GetConnectionChannel(Guid connectionId) => _connections[connectionId]; + + public BidiHttpListenerState(IpcServer ipcServer, BidiHttpListener listener) + { + _ipcServer = ipcServer; + _httpListener = new HttpListener() + { + Prefixes = + { + listener.Uri.ToString() + } + }; + _processing = ProcessContexts(); + _disposing = new(DisposeCore); + } + + public ValueTask DisposeAsync() => new(_disposing.Value); + + private async Task DisposeCore() + { + _cts.Cancel(); + try + { + await _processing; + } + catch (OperationCanceledException ex) when (ex.CancellationToken == _cts.Token) + { + } + + foreach (var pair in _connections) + { + pair.Value.Writer.Complete(); + } + _cts.Dispose(); + } + + private async Task ProcessContexts() + { + await foreach (var (context, connectionId, reverseUri) in AwaitContexts()) + { + var connectionChannel = _connections.GetOrAdd(connectionId, _ => + { + _newConnections.Writer.TryWrite((connectionId, reverseUri)); + return Channel.CreateUnbounded(); + }); + + await connectionChannel.Writer.WriteAsync(context, _cts.Token); + } + + async IAsyncEnumerable<(HttpListenerContext context, Guid connectionId, Uri reverseUri)> AwaitContexts() + { + while (!_cts.Token.IsCancellationRequested) + { + var context = await _httpListener.GetContextAsync(); + + if (!TryAcceptContext(context, out var connectionId, out var reverseUri)) + { + context.Response.StatusCode = 400; + context.Response.Close(); + continue; + } + + yield return (context, connectionId, reverseUri); + } + } + + bool TryAcceptContext(HttpListenerContext context, out Guid connectionId, [NotNullWhen(returnValue: true)] out Uri? reverseUri) + { + if (!Guid.TryParse(context.Request.Headers[ConnectionIdHeader], out connectionId) || + !Uri.TryCreate(context.Request.Headers[ReverseUriHeader], UriKind.Absolute, out reverseUri)) + { + connectionId = Guid.Empty; + reverseUri = null; + return false; + } + + return true; + } + } +} + +internal sealed class BidiHttpServerConnectionState : Stream, IAsyncDisposable +{ + private readonly Pipe _pipe = new(); + + private readonly IpcServer _server; + private readonly BidiHttpListenerState _listenerState; + + private readonly CancellationTokenSource _cts = new(); + private readonly AsyncLock _lock = new(); + private (Guid connectionId, Uri reverseUri)? _connection = null; + private HttpClient? _client; + private Task? _processing = null; + private readonly Lazy _disposing; + + public BidiHttpServerConnectionState(IpcServer server, BidiHttpListenerState listenerState) + { + _server = server; + _listenerState = listenerState; + _disposing = new(DisposeCore); + } + + public +#if !NET461 + override +#endif + ValueTask DisposeAsync() => new(_disposing.Value); + + private async Task DisposeCore() + { + _cts.Cancel(); + + _client?.Dispose(); + + try + { + await (_processing ?? Task.CompletedTask); + } + catch (OperationCanceledException ex) when (ex.CancellationToken == _cts.Token) + { + // ignored + } + + _cts.Dispose(); + } + + public async Task WaitForConnection(CancellationToken ct) + { + using (await _lock.LockAsync(ct)) + { + if (_connection is not null) + { + throw new InvalidOperationException(); + } + + _connection = await _listenerState.NewConnections.ReadAsync(ct); + + _client = new() + { + BaseAddress = _connection.Value.reverseUri, + DefaultRequestHeaders = + { + { ConnectionIdHeader, _connection.Value.connectionId.ToString() } + } + }; + + _processing = ProcessContexts(_cts.Token); + } + } + + private async Task ProcessContexts(CancellationToken ct) + { + var reader = _listenerState.GetConnectionChannel(_connection!.Value.connectionId); + + while (await reader.WaitToReadAsync(ct)) + { + if (!reader.TryRead(out var context)) + { + continue; + } + await ProcessContext(context); + } + + async Task ProcessContext(HttpListenerContext context) + { + try + { + while (true) + { + var memory = _pipe.Writer.GetMemory(); + var cbRead = await context.Request.InputStream.ReadAsync(memory, ct); + if (cbRead is 0) + { + break; + } + _pipe.Writer.Advance(cbRead); + var flushResult = await _pipe.Writer.FlushAsync(ct); + if (flushResult.IsCompleted) + { + break; + } + } + } + finally + { + context.Response.StatusCode = 200; + context.Response.Close(); + } + } + } + + public override bool CanRead => true; + public override bool CanSeek => false; + public override bool CanWrite => true; + + public override async Task ReadAsync(byte[] buffer, int offset, int count, CancellationToken ct) + { + var memory = new Memory(buffer, offset, count); + var readResult = await _pipe.Reader.ReadAsync(ct); + + var take = (int)Math.Min(readResult.Buffer.Length, memory.Length); + + readResult.Buffer.Slice(start: 0, length: take).CopyTo(memory.Span); + _pipe.Reader.AdvanceTo(readResult.Buffer.GetPosition(take)); + + return take; + } + + public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken ct) + { + var memory = new ReadOnlyMemory(buffer, offset, count); + if (_client is null) + { + throw new InvalidOperationException(); + } + + HttpContent content = +#if NET461 + new ByteArrayContent(memory.ToArray()); +#else + new ReadOnlyMemoryContent(memory); +#endif + + await _client.PostAsync(requestUri: "", content, ct); + } + + public override Task FlushAsync(CancellationToken cancellationToken) + => Task.CompletedTask; + + public override void Flush() => throw new NotImplementedException(); + public override long Seek(long offset, SeekOrigin origin) => throw new NotImplementedException(); + public override void SetLength(long value) => throw new NotImplementedException(); + public override int Read(byte[] buffer, int offset, int count) => throw new NotImplementedException(); + public override void Write(byte[] buffer, int offset, int count) => throw new NotImplementedException(); + public override long Length => throw new NotImplementedException(); + public override long Position { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } +} diff --git a/src/UiPath.CoreIpc.Http/Constants.cs b/src/UiPath.CoreIpc.Http/Constants.cs new file mode 100644 index 00000000..c04e37b7 --- /dev/null +++ b/src/UiPath.CoreIpc.Http/Constants.cs @@ -0,0 +1,8 @@ +namespace UiPath.Ipc.Http; + +internal static class Constants +{ + internal const string ConnectionIdHeader = "X-UiPathIpc-ConnectionId"; + internal const string ReverseUriHeader = "X-UiPathIpc-ReverseUri"; +} + diff --git a/src/UiPath.CoreIpc.Http/GlobalUsings.cs b/src/UiPath.CoreIpc.Http/GlobalUsings.cs new file mode 100644 index 00000000..a7770972 --- /dev/null +++ b/src/UiPath.CoreIpc.Http/GlobalUsings.cs @@ -0,0 +1 @@ +global using UiPath.Ipc.Extensibility; diff --git a/src/UiPath.CoreIpc.Http/UiPath.CoreIpc.Http.csproj b/src/UiPath.CoreIpc.Http/UiPath.CoreIpc.Http.csproj new file mode 100644 index 00000000..524ffbc1 --- /dev/null +++ b/src/UiPath.CoreIpc.Http/UiPath.CoreIpc.Http.csproj @@ -0,0 +1,27 @@ + + + + net6.0;net461;net6.0-windows + enable + enable + preview + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + + diff --git a/src/UiPath.CoreIpc.Tests/ComputingTests.cs b/src/UiPath.CoreIpc.Tests/ComputingTests.cs deleted file mode 100644 index 6c562dd9..00000000 --- a/src/UiPath.CoreIpc.Tests/ComputingTests.cs +++ /dev/null @@ -1,129 +0,0 @@ -namespace UiPath.CoreIpc.Tests; - -public abstract class ComputingTests : TestBase where TBuilder : ServiceClientBuilder -{ - protected readonly ServiceHost _computingHost; - protected readonly IComputingService _computingClient; - protected readonly ComputingService _computingService; - protected readonly ComputingCallback _computingCallback; - public ComputingTests() - { - _computingCallback = new ComputingCallback { Id = Guid.NewGuid().ToString() }; - _computingService = (ComputingService)_serviceProvider.GetService(); - _computingHost = Configure(new ServiceHostBuilder(_serviceProvider)) - .AddEndpoint() - .ValidateAndBuild(); - _computingHost.RunAsync(GuiScheduler); - _computingClient = ComputingClientBuilder(GuiScheduler).SerializeParametersAsObjects().ValidateAndBuild(); - } - protected abstract TBuilder ComputingClientBuilder(TaskScheduler taskScheduler = null); - [Fact] - public async Task ReconnectWithEncrypt() - { - for (int i = 0; i < 50; i++) - { - await _computingClient.AddFloat(1, 2); - ((IpcProxy)_computingClient).CloseConnection(); - await _computingClient.AddFloat(1, 2); - } - } - - [Fact] - public async Task AddFloat() - { - var result = await _computingClient.AddFloat(1.23f, 4.56f); - result.ShouldBe(5.79f); - } - - [Fact] - public Task AddFloatConcurrently() => Task.WhenAll(Enumerable.Range(1, 100).Select(_ => AddFloat())); - - [Fact] - public async Task AddComplexNumber() - { - var result = await _computingClient.AddComplexNumber(new ComplexNumber(1f, 3f), new ComplexNumber(2f, 5f)); - result.ShouldBe(new ComplexNumber(3f, 8f)); - } - - [Fact] - public async Task ClientCancellation() - { - using (var cancellationSource = new CancellationTokenSource(10)) - { - _computingClient.Infinite(cancellationSource.Token).ShouldThrow(); - } - await AddFloat(); - } - - [Fact] - public async Task ClientTimeout() - { - var proxy = ComputingClientBuilder().SerializeParametersAsObjects().RequestTimeout(TimeSpan.FromMilliseconds(10)).ValidateAndBuild(); - proxy.Infinite().ShouldThrow().Message.ShouldBe($"{nameof(_computingClient.Infinite)} timed out."); - await proxy.GetCallbackThreadName(new Message { RequestTimeout = RequestTimeout }); - ((IDisposable)proxy).Dispose(); - ((IpcProxy)proxy).CloseConnection(); - } - - [Fact] - public async Task TimeoutPerRequest() - { - for (int i = 0; i < 20; i++) - { - var request = new SystemMessage { RequestTimeout = TimeSpan.FromTicks(10), Delay = 100 }; - Exception exception = null; - try - { - await _computingClient.SendMessage(request); - } - catch (TimeoutException ex) - { - exception = ex; - } - catch (RemoteException ex) - { - exception = ex; - ex.Is().ShouldBeTrue(); - } - exception.Message.ShouldBe($"{nameof(_computingClient.SendMessage)} timed out."); - await AddFloat(); - } - } - - [Fact] - public Task InfiniteVoid() => _computingClient.InfiniteVoid(); - - [Fact] - public async Task AddComplexNumbers() - { - var result = await _computingClient.AddComplexNumbers(new[] - { - new ComplexNumber(0.5f, 0.4f), - new ComplexNumber(0.2f, 0.1f), - new ComplexNumber(0.3f, 0.5f), - }); - result.ShouldBe(new ComplexNumber(1f, 1f)); - } - - [Fact] - public async Task GetCallbackThreadName() => (await _computingClient.GetCallbackThreadName()).ShouldBe("GuiThread"); - - [Fact] - public Task CallbackConcurrently() => Task.WhenAll(Enumerable.Range(1, 50).Select(_ => Callback())); - - [Fact] - public async Task Callback() - { - var message = new SystemMessage { Text = Guid.NewGuid().ToString() }; - var returnValue = await _computingClient.SendMessage(message); - returnValue.ShouldBe($"{Environment.UserName}_{_computingCallback.Id}_{message.Text}"); - } - - public override void Dispose() - { - ((IDisposable)_computingClient).Dispose(); - ((IpcProxy)_computingClient).CloseConnection(); - _computingHost.Dispose(); - base.Dispose(); - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/EndpointTests.cs b/src/UiPath.CoreIpc.Tests/EndpointTests.cs deleted file mode 100644 index e62db908..00000000 --- a/src/UiPath.CoreIpc.Tests/EndpointTests.cs +++ /dev/null @@ -1,141 +0,0 @@ -namespace UiPath.CoreIpc.Tests; - -public class EndpointTests : IDisposable -{ - private static TimeSpan RequestTimeout => TestBase.RequestTimeout; - private readonly ServiceHost _host; - private readonly IComputingService _computingClient; - private readonly ISystemService _systemClient; - private readonly ComputingService _computingService; - private readonly SystemService _systemService; - private readonly ComputingCallback _computingCallback; - private readonly SystemCallback _systemCallback; - private readonly IServiceProvider _serviceProvider; - public EndpointTests() - { - _computingCallback = new ComputingCallback { Id = Guid.NewGuid().ToString() }; - _systemCallback = new SystemCallback { Id = Guid.NewGuid().ToString() }; - _serviceProvider = IpcHelpers.ConfigureServices(); - _computingService = (ComputingService)_serviceProvider.GetService(); - _systemService = (SystemService)_serviceProvider.GetService(); - _host = new ServiceHostBuilder(_serviceProvider) - .UseNamedPipes(new NamedPipeSettings(PipeName) { RequestTimeout = RequestTimeout }) - .AddEndpoint() - .AddEndpoint() - .AddEndpoint() - .ValidateAndBuild(); - _host.RunAsync(); - _computingClient = ComputingClientBuilder().ValidateAndBuild(); - _systemClient = CreateSystemService(); - } - public string PipeName => nameof(EndpointTests)+GetHashCode(); - private NamedPipeClientBuilder ComputingClientBuilder(TaskScheduler taskScheduler = null) => - new NamedPipeClientBuilder(PipeName, _serviceProvider) - .AllowImpersonation() - .RequestTimeout(RequestTimeout) - .CallbackInstance(_computingCallback) - .SerializeParametersAsObjects() - .TaskScheduler(taskScheduler); - private ISystemService CreateSystemService() => SystemClientBuilder().ValidateAndBuild(); - private NamedPipeClientBuilder SystemClientBuilder() => - new NamedPipeClientBuilder(PipeName, _serviceProvider) - .CallbackInstance(_systemCallback) - .SerializeParametersAsObjects() - .RequestTimeout(RequestTimeout) - .AllowImpersonation(); - public void Dispose() - { - ((IDisposable)_computingClient).Dispose(); - ((IDisposable)_systemClient).Dispose(); - ((IpcProxy)_computingClient).CloseConnection(); - ((IpcProxy)_systemClient).CloseConnection(); - _host.Dispose(); - } - [Fact] - public Task CallbackConcurrently() => Task.WhenAll(Enumerable.Range(1, 50).Select(_ => CallbackCore())); - [Fact] - public async Task Callback() - { - for (int index = 0; index < 50; index++) - { - await CallbackCore(); - ((IpcProxy)_computingClient).CloseConnection(); - } - } - - private async Task CallbackCore() - { - var proxy = new NamedPipeClientBuilder(PipeName) - .SerializeParametersAsObjects().RequestTimeout(RequestTimeout).AllowImpersonation().ValidateAndBuild(); - var message = new SystemMessage { Text = Guid.NewGuid().ToString() }; - var computingTask = _computingClient.SendMessage(message); - var systemTask = _systemClient.SendMessage(message); - var computingBaseTask = proxy.AddFloat(1, 2); - await Task.WhenAll(computingTask, systemTask, computingBaseTask); - systemTask.Result.ShouldBe($"{Environment.UserName}_{_systemCallback.Id}_{message.Text}"); - computingTask.Result.ShouldBe($"{Environment.UserName}_{_computingCallback.Id}_{message.Text}"); - computingBaseTask.Result.ShouldBe(3); - } - - [Fact] - public async Task MissingCallback() - { - RemoteException exception = null; - try - { - await _systemClient.MissingCallback(new SystemMessage()); - } - catch (RemoteException ex) - { - exception = ex; - } - exception.Message.ShouldBe("Callback contract mismatch. Requested System.IDisposable, but it's UiPath.CoreIpc.Tests.ISystemCallback."); - exception.Is().ShouldBeTrue(); - } - [Fact] - public Task CancelServerCall() => CancelServerCallCore(10); - - async Task CancelServerCallCore(int counter) - { - for (int i = 0; i < counter; i++) - { - var request = new SystemMessage { RequestTimeout = Timeout.InfiniteTimeSpan, Delay = Timeout.Infinite }; - Task sendMessageResult; - using (var cancellationSource = new CancellationTokenSource()) - { - sendMessageResult = _systemClient.MissingCallback(request, cancellationSource.Token); - var newGuid = Guid.NewGuid(); - (await _systemClient.GetGuid(newGuid)).ShouldBe(newGuid); - await Task.Delay(1); - cancellationSource.Cancel(); - sendMessageResult.ShouldThrow(); - newGuid = Guid.NewGuid(); - (await _systemClient.GetGuid(newGuid)).ShouldBe(newGuid); - } - ((IDisposable)_systemClient).Dispose(); - } - } - - [Fact] - public async Task DuplicateCallbackProxies() - { - await _systemClient.GetThreadName(); - var proxy = CreateSystemService(); - var message = proxy.GetThreadName().ShouldThrow().Message; - message.ShouldStartWith("Duplicate callback proxy instance EndpointTests"); - message.ShouldEndWith(". Consider using a singleton callback proxy."); - } -} -public interface ISystemCallback -{ - Task GetId(Message message = null); -} -public class SystemCallback : ISystemCallback -{ - public string Id { get; set; } - public async Task GetId(Message message) - { - message.Client.ShouldBeNull(); - return Id; - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/Implementation/ComputingCallback.cs b/src/UiPath.CoreIpc.Tests/Implementation/ComputingCallback.cs deleted file mode 100644 index 7938f812..00000000 --- a/src/UiPath.CoreIpc.Tests/Implementation/ComputingCallback.cs +++ /dev/null @@ -1,18 +0,0 @@ -namespace UiPath.CoreIpc.Tests; - -public interface IComputingCallback -{ - Task GetId(Message message); - Task GetThreadName(); -} -public class ComputingCallback : IComputingCallback -{ - public string Id { get; set; } - public async Task GetId(Message message) - { - message.Client.ShouldBeNull(); - return Id; - } - - public async Task GetThreadName() => Thread.CurrentThread.Name; -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/Implementation/ComputingService.cs b/src/UiPath.CoreIpc.Tests/Implementation/ComputingService.cs deleted file mode 100644 index 908ee1f0..00000000 --- a/src/UiPath.CoreIpc.Tests/Implementation/ComputingService.cs +++ /dev/null @@ -1,136 +0,0 @@ -using Microsoft.Extensions.Logging; - -namespace UiPath.CoreIpc.Tests; - -public interface IInvalid : IDisposable -{ -} - -public interface IDuplicateMessage -{ - Task Test(Message message1, Message message2); -} - -public interface IUploadNotification -{ - Task Upload(Stream stream); -} - -public interface IDerivedStreamDownload -{ - Task Download(); -} - -public interface IDuplicateStreams -{ - Task Upload(Stream stream, Stream stream2); -} - -public interface IDerivedStreamUpload -{ - Task Upload(MemoryStream stream); -} - -public interface IMessageFirst -{ - Task Test(Message message1, int x); -} - -public interface IInvalidCancellationToken -{ - Task Test(CancellationToken token, int x); -} - -public interface IComputingServiceBase -{ - Task AddFloat(float x, float y, CancellationToken cancellationToken = default); -} -public interface IComputingService : IComputingServiceBase -{ - Task AddComplexNumber(ComplexNumber x, ComplexNumber y, CancellationToken cancellationToken = default); - Task AddComplexNumbers(IEnumerable numbers, CancellationToken cancellationToken = default); - Task SendMessage(SystemMessage message, CancellationToken cancellationToken = default); - Task Infinite(CancellationToken cancellationToken = default); - Task InfiniteVoid(CancellationToken cancellationToken = default); - Task GetCallbackThreadName(Message message = null, CancellationToken cancellationToken = default); -} - -public struct ComplexNumber -{ - public float A { get; set; } - public float B { get; set; } - - public ComplexNumber(float a, float b) - { - A = a; - B = b; - } -} - -public enum TextStyle -{ - TitleCase, - Upper -} - -public class ConvertTextArgs -{ - public TextStyle TextStyle { get; set; } = TextStyle.Upper; - - public string Text { get; set; } = string.Empty; -} - -public class ComputingService : IComputingService -{ - private readonly ILogger _logger; - - public ComputingService(ILogger logger) // inject dependencies in constructor - { - _logger = logger; - } - - public async Task AddComplexNumber(ComplexNumber x, ComplexNumber y, CancellationToken cancellationToken = default) - { - _logger.LogInformation($"{nameof(AddComplexNumber)} called."); - return new ComplexNumber(x.A + y.A, x.B + y.B); - } - - public async Task AddComplexNumbers(IEnumerable numbers, CancellationToken cancellationToken = default) - { - _logger.LogInformation($"{nameof(AddComplexNumbers)} called."); - var result = new ComplexNumber(0, 0); - foreach (ComplexNumber number in numbers) - { - result = new ComplexNumber(result.A + number.A, result.B + number.B); - } - return result; - } - - public async Task AddFloat(float x, float y, CancellationToken cancellationToken = default) - { - //Trace.WriteLine($"{nameof(AddFloat)} called."); - _logger.LogInformation($"{nameof(AddFloat)} called."); - return x + y; - } - - public async Task Infinite(CancellationToken cancellationToken = default) - { - await Task.Delay(Timeout.Infinite, cancellationToken); - return true; - } - - public Task InfiniteVoid(CancellationToken cancellationToken = default) =>Task.Delay(Timeout.Infinite, cancellationToken); - - public async Task SendMessage(SystemMessage message, CancellationToken cancellationToken = default) - { - await Task.Delay(message.Delay, cancellationToken); - var client = message.Client; - var callback = message.GetCallback(); - var clientId = await callback.GetId(message); - string returnValue = ""; - client.Impersonate(() => returnValue = client.GetUserName() + "_" + clientId + "_" + message.Text); - return returnValue; - } - - public async Task GetCallbackThreadName(Message message, CancellationToken cancellationToken = default) => await message.GetCallback().GetThreadName(); -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/Implementation/IpcHelpers.cs b/src/UiPath.CoreIpc.Tests/Implementation/IpcHelpers.cs deleted file mode 100644 index 41a9292f..00000000 --- a/src/UiPath.CoreIpc.Tests/Implementation/IpcHelpers.cs +++ /dev/null @@ -1,77 +0,0 @@ -using Microsoft.Extensions.Logging; -using System.Net; -using System.Net.WebSockets; -using UiPath.CoreIpc.Tests; - -namespace UiPath.CoreIpc; - -public static class IpcHelpers -{ - public static TInterface ValidateAndBuild(this ServiceClientBuilder builder) where TInterface : class where TDerived : ServiceClientBuilder - { -#if DEBUG - Validator.Validate(builder); -#endif - return builder.Build(); - } - public static ServiceHost ValidateAndBuild(this ServiceHostBuilder serviceHostBuilder) - { -#if DEBUG - Validator.Validate(serviceHostBuilder); -#endif - return serviceHostBuilder.Build(); - } - public static IServiceProvider ConfigureServices() => - new ServiceCollection() - .AddLogging(b => b.AddTraceSource(new SourceSwitch("", "All"))) - .AddIpc() - .AddSingleton() - .AddSingleton() - .AddSingleton() - .BuildServiceProvider(); - public static string GetUserName(this IClient client) - { - string userName = null; - client.Impersonate(() => userName = Environment.UserName); - return userName; - } - public static IServiceCollection AddIpcWithLogging(this IServiceCollection services, bool logToConsole = false) - { - services.AddLogging(builder => - { - //if (logToConsole) - //{ - // builder.AddConsole(); - //} - //foreach (var listener in Trace.Listeners.Cast().Where(l => !(l is DefaultTraceListener))) - //{ - // builder.AddTraceSource(new SourceSwitch(listener.Name, "All"), listener); - //} - }); - return services.AddIpc(); - } -} -public class HttpSysWebSocketsListener : IDisposable -{ - HttpListener _httpListener = new(); - public HttpSysWebSocketsListener(string uriPrefix) - { - _httpListener.Prefixes.Add(uriPrefix); - _httpListener.Start(); - } - public async Task Accept(CancellationToken token) - { - while (true) - { - var listenerContext = await _httpListener.GetContextAsync(); - if (listenerContext.Request.IsWebSocketRequest) - { - var webSocketContext = await listenerContext.AcceptWebSocketAsync(subProtocol: null); - return webSocketContext.WebSocket; - } - listenerContext.Response.StatusCode = 400; - listenerContext.Response.Close(); - } - } - public void Dispose() => _httpListener.Stop(); -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/Implementation/OneWayStreamWrapper.cs b/src/UiPath.CoreIpc.Tests/Implementation/OneWayStreamWrapper.cs deleted file mode 100644 index b63c41c6..00000000 --- a/src/UiPath.CoreIpc.Tests/Implementation/OneWayStreamWrapper.cs +++ /dev/null @@ -1,104 +0,0 @@ -// Copyright (c) Andrew Arnott. All rights reserved. -// Licensed under the MIT license. See LICENSE file in the project root for full license information. - -namespace UiPath.CoreIpc.Tests; - -internal class OneWayStreamWrapper : Stream -{ - private readonly Stream innerStream; - private readonly bool canRead; - private readonly bool canWrite; - - internal OneWayStreamWrapper(Stream innerStream, bool canRead = false, bool canWrite = false) - { - if (canRead == canWrite) - { - throw new ArgumentException("Exactly one operation (read or write) must be true."); - } - this.innerStream = innerStream ?? throw new ArgumentNullException(nameof(innerStream)); - this.canRead = canRead; - this.canWrite = canWrite; - } - - public override bool CanRead => this.canRead && this.innerStream.CanRead; - - public override bool CanSeek => false; - - public override bool CanWrite => this.canWrite && this.innerStream.CanWrite; - - public override long Length => throw new NotSupportedException(); - - public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); } - - public override void Flush() - { - if (this.CanWrite) - { - this.innerStream.Flush(); - } - else - { - throw new NotSupportedException(); - } - } - - public override int Read(byte[] buffer, int offset, int count) - { - if (this.CanRead) - { - return this.innerStream.Read(buffer, offset, count); - } - else - { - throw new NotSupportedException(); - } - } - - public override Task ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) - { - if (this.CanRead) - { - return this.innerStream.ReadAsync(buffer, offset, count, cancellationToken); - } - else - { - throw new NotSupportedException(); - } - } - - public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); - - public override void SetLength(long value) => throw new NotSupportedException(); - - public override void Write(byte[] buffer, int offset, int count) - { - if (this.CanWrite) - { - this.innerStream.Write(buffer, offset, count); - } - else - { - throw new NotSupportedException(); - } - } - - public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) - { - if (this.CanWrite) - { - return this.innerStream.WriteAsync(buffer, offset, count, cancellationToken); - } - else - { - throw new NotSupportedException(); - } - } - - protected override void Dispose(bool disposing) - { - if (disposing) - { - this.innerStream.Dispose(); - } - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/Implementation/SystemService.cs b/src/UiPath.CoreIpc.Tests/Implementation/SystemService.cs deleted file mode 100644 index 049f4e36..00000000 --- a/src/UiPath.CoreIpc.Tests/Implementation/SystemService.cs +++ /dev/null @@ -1,175 +0,0 @@ -using System.Globalization; -using System.Text; - -namespace UiPath.CoreIpc.Tests; - -public interface ISystemService -{ - Task DoNothing(CancellationToken cancellationToken = default); - Task VoidThreadName(CancellationToken cancellationToken = default); - Task VoidSyncThrow(CancellationToken cancellationToken = default); - Task GetThreadName(CancellationToken cancellationToken = default); - Task ConvertText(string text, TextStyle style, CancellationToken cancellationToken = default); - Task ConvertTextWithArgs(ConvertTextArgs args, CancellationToken cancellationToken = default); - Task GetGuid(Guid guid, CancellationToken cancellationToken = default); - Task ReverseBytes(byte[] input, CancellationToken cancellationToken = default); - Task SlowOperation(CancellationToken cancellationToken = default); - Task MissingCallback(SystemMessage message, CancellationToken cancellationToken = default); - Task Infinite(CancellationToken cancellationToken = default); - Task ImpersonateCaller(Message message = null, CancellationToken cancellationToken = default); - Task SendMessage(SystemMessage message, CancellationToken cancellationToken = default); - Task Upload(Stream stream, int delay = 0, CancellationToken cancellationToken = default); - Task Download(string text, CancellationToken cancellationToken = default); - Task Echo(Stream input, CancellationToken cancellationToken = default); - Task UploadNoRead(Stream memoryStream, int delay = 0, CancellationToken cancellationToken = default); -} - -public class SystemMessage : Message -{ - public string Text { get; set; } - public int Delay { get; set; } -} -public class SystemService : ISystemService -{ - public SystemService() - { - } - - public async Task Infinite(CancellationToken cancellationToken = default) - { - await Task.Delay(Timeout.Infinite, cancellationToken); - return true; - } - public async Task ConvertTextWithArgs(ConvertTextArgs args, CancellationToken cancellationToken = default) - => await ConvertText(args.Text, args.TextStyle, cancellationToken); - - public async Task ConvertText(string text, TextStyle style, CancellationToken cancellationToken = default) - { - switch (style) - { - case TextStyle.TitleCase: - return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(text); - case TextStyle.Upper: - return CultureInfo.InvariantCulture.TextInfo.ToUpper(text); - default: - return text; - } - } - - public async Task SendMessage(SystemMessage message, CancellationToken cancellationToken = default) - { - var client = message.Client; - var callback = message.GetCallback(); - var clientId = await callback.GetId(message); - string returnValue = ""; - client.Impersonate(() => returnValue = client.GetUserName() + "_" + clientId + "_" + message.Text); - return returnValue; - } - - public bool DidNothing { get; set; } - - public async Task DoNothing(CancellationToken cancellationToken = default) - { - const int Timeout = -#if CI - 100; -#else - 10; -#endif - await Task.Delay(Timeout); - DidNothing = true; - } - - public async Task GetGuid(Guid guid, CancellationToken cancellationToken = default) - { - //throw new Exception("sssss"); - return guid; - } - - public async Task ReverseBytes(byte[] input, CancellationToken cancellationToken = default) - { - return input.Reverse().ToArray(); - } - - public async Task MissingCallback(SystemMessage message, CancellationToken cancellationToken = default) - { - if (message.Delay != 0) - { - await Task.Delay(message.Delay, cancellationToken); - } - var domainName = ""; - var client = message.Client; - //client.RunAs(() => domainName = "test"); - //try - //{ - message.GetCallback(); - //} - //catch(Exception ex) - //{ - // Console.WriteLine(ex.ToString()); - //} - return client.GetUserName() +" " + domainName; - } - - public async Task SlowOperation(CancellationToken cancellationToken = default) - { - Console.WriteLine("SlowOperation " + Thread.CurrentThread.Name); - try - { - for(int i = 0; i < 5; i++) - { - await Task.Delay(1000, cancellationToken); - Console.WriteLine("SlowOperation "+Thread.CurrentThread.Name); - if(cancellationToken.IsCancellationRequested) - { - Console.WriteLine("SlowOperation Cancelled."); - return false; - } - } - } - catch(Exception ex) - { - Console.WriteLine(ex.ToString()); - } - Console.WriteLine("SlowOperation finished. "+ (cancellationToken.IsCancellationRequested ? "cancelled " : "") + Thread.CurrentThread.Name); - return true; - } - - public string ThreadName; - - public Task VoidSyncThrow(CancellationToken cancellationToken = default) => throw new NotImplementedException(); - - public async Task VoidThreadName(CancellationToken cancellationToken = default) => ThreadName = Thread.CurrentThread.Name; - - public async Task GetThreadName(CancellationToken cancellationToken = default) => Thread.CurrentThread.Name; - - public async Task ImpersonateCaller(Message message = null, CancellationToken cancellationToken = default) - { - var client = message.Client; - string returnValue = ""; - client.Impersonate(() => returnValue = client.GetUserName()); - return returnValue; - } - - public async Task Upload(Stream stream, int delay = 0, CancellationToken cancellationToken = default) - { - await Task.Delay(delay); - return await new StreamReader(stream).ReadToEndAsync(); - } - - public async Task UploadNoRead(Stream stream, int delay = 0, CancellationToken cancellationToken = default) - { - await Task.Delay(delay); - return ""; - } - - public async Task Download(string text, CancellationToken cancellationToken = default) => new MemoryStream(Encoding.UTF8.GetBytes(text)); - - public async Task Echo(Stream input, CancellationToken cancellationToken = default) - { - var result = new MemoryStream(); - await input.CopyToAsync(result); - result.Position = 0; - return result; - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/NamedPipeTests.cs b/src/UiPath.CoreIpc.Tests/NamedPipeTests.cs deleted file mode 100644 index e81f1eaa..00000000 --- a/src/UiPath.CoreIpc.Tests/NamedPipeTests.cs +++ /dev/null @@ -1,53 +0,0 @@ -using System.IO.Pipes; -using System.Security.Principal; -namespace UiPath.CoreIpc.Tests; - -public class SystemNamedPipeTests : SystemTests> -{ - string _pipeName = "system"; - protected override ServiceHostBuilder Configure(ServiceHostBuilder serviceHostBuilder) => - serviceHostBuilder.UseNamedPipes(Configure(new NamedPipeSettings(_pipeName+GetHashCode()))); - protected override NamedPipeClientBuilder CreateSystemClientBuilder() => - new NamedPipeClientBuilder(_pipeName+GetHashCode()).AllowImpersonation(); - [Fact] - public void PipeExists() - { - IOHelpers.PipeExists(System.Guid.NewGuid().ToString()).ShouldBeFalse(); - IOHelpers.PipeExists("system"+GetHashCode(), 50).ShouldBeTrue(); - } - [Fact] - public Task ServerName() => SystemClientBuilder().ValidateAndBuild().GetGuid(System.Guid.Empty); - [Fact] - public override void BeforeCallServerSide() - { - _pipeName = "beforeCall"; - base.BeforeCallServerSide(); - } -#if WINDOWS - [Fact] - public async Task PipeSecurityForWindows() - { - _pipeName = "protected"; - using var protectedService = new ServiceHostBuilder(_serviceProvider) - .UseNamedPipes(Configure(new NamedPipeSettings(_pipeName+GetHashCode()) - { - AccessControl = pipeSecurity => pipeSecurity.Deny(WellKnownSidType.WorldSid, PipeAccessRights.FullControl) - })) - .AddEndpoint() - .ValidateAndBuild(); - _ = protectedService.RunAsync(); - await CreateSystemService().DoNothing().ShouldThrowAsync(); - } -#endif -} -public class ComputingNamedPipeTests : ComputingTests> -{ - protected override ServiceHostBuilder Configure(ServiceHostBuilder serviceHostBuilder) => - serviceHostBuilder.UseNamedPipes(Configure(new NamedPipeSettings("computing" + GetHashCode()))); - protected override NamedPipeClientBuilder ComputingClientBuilder(TaskScheduler taskScheduler = null) => - new NamedPipeClientBuilder("computing" + GetHashCode(), _serviceProvider) - .AllowImpersonation() - .RequestTimeout(RequestTimeout) - .CallbackInstance(_computingCallback) - .TaskScheduler(taskScheduler); -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/NestedStreamTests.cs b/src/UiPath.CoreIpc.Tests/NestedStreamTests.cs deleted file mode 100644 index b30d6f93..00000000 --- a/src/UiPath.CoreIpc.Tests/NestedStreamTests.cs +++ /dev/null @@ -1,370 +0,0 @@ -using System.IO.Compression; - -namespace UiPath.CoreIpc.Tests; - -public class NestedStreamTests -{ - private const int DefaultNestedLength = 10; - - private MemoryStream underlyingStream; - - private NestedStream stream; - - protected static readonly TimeSpan UnexpectedTimeout = Debugger.IsAttached ? Timeout.InfiniteTimeSpan : TimeSpan.FromSeconds(10); - - private readonly CancellationTokenSource _timeoutTokenSource = new(UnexpectedTimeout); - - public NestedStreamTests() - { - var random = new Random(); - var buffer = new byte[20]; - random.NextBytes(buffer); - this.underlyingStream = new MemoryStream(buffer); - this.stream = this.underlyingStream.ReadSlice(DefaultNestedLength); - } - - protected CancellationToken TimeoutToken => Debugger.IsAttached ? CancellationToken.None : _timeoutTokenSource.Token; - - [Fact] - public void CanSeek() - { - Assert.True(this.stream.CanSeek); - this.stream.Dispose(); - Assert.False(this.stream.CanSeek); - } - - [Fact] - public void CanSeek_NonSeekableStream() - { - using var gzipStream = new GZipStream(Stream.Null, CompressionMode.Decompress); - using var stream = gzipStream.ReadSlice(10); - - Assert.False(stream.CanSeek); - stream.Dispose(); - Assert.False(stream.CanSeek); - } - - [Fact] - public void Length() - { - Assert.Equal(DefaultNestedLength, this.stream.Length); - } - - [Fact] - public void Length_NonSeekableStream() - { - using (var gzipStream = new GZipStream(Stream.Null, CompressionMode.Decompress)) - using (var stream = gzipStream.ReadSlice(10)) - { - stream.Length.ShouldBe(10); - } - } - - [Fact] - public void Position() - { - byte[] buffer = new byte[DefaultNestedLength]; - - Assert.Equal(0, this.stream.Position); - var bytesRead = this.stream.Read(buffer, 0, 5); - Assert.Equal(bytesRead, this.stream.Position); - - this.stream.Position = 0; - byte[] buffer2 = new byte[DefaultNestedLength]; - bytesRead = this.stream.Read(buffer2, 0, 5); - Assert.Equal(bytesRead, this.stream.Position); - Assert.Equal(buffer, buffer2); - } - - [Fact] - public void Position_NonSeekableStream() - { - using var nonSeekableWrapper = new OneWayStreamWrapper(this.underlyingStream, canRead: true); - using var stream = nonSeekableWrapper.ReadSlice(10); - - Assert.Equal(0, stream.Position); - Assert.Throws(() => stream.Position = 3); - Assert.Equal(0, stream.Position); - stream.ReadByte(); - Assert.Equal(1, stream.Position); - } - - [Fact] - public void IsDisposed() - { - Assert.False(stream.IsDisposed); - this.stream.Dispose(); - Assert.True(stream.IsDisposed); - } - - [Fact] - public void Dispose_IncompleteDisposesUnderylingStream() - { - this.stream.Dispose(); - Assert.False(this.underlyingStream.CanSeek); - } - - [Fact] - public void Dispose_DoesNotDisposeUnderylingStream() - { - this.stream.Read(new byte[DefaultNestedLength], 0, DefaultNestedLength); - this.stream.Dispose(); - Assert.True(this.underlyingStream.CanSeek); - // A sanity check that if it were disposed, our assertion above would fail. - this.underlyingStream.Dispose(); - Assert.False(this.underlyingStream.CanSeek); - } - - [Fact] - public void SetLength() - { - Assert.Throws(() => this.stream.SetLength(0)); - } - - [Fact] - public void Seek_Current() - { - Assert.Equal(0, this.stream.Position); - Assert.Equal(0, this.stream.Seek(0, SeekOrigin.Current)); - Assert.Equal(0, this.underlyingStream.Position); - Assert.Throws(() => this.stream.Seek(-1, SeekOrigin.Current)); - Assert.Equal(0, this.underlyingStream.Position); - - Assert.Equal(5, this.stream.Seek(5, SeekOrigin.Current)); - Assert.Equal(5, this.underlyingStream.Position); - Assert.Equal(5, this.stream.Seek(0, SeekOrigin.Current)); - Assert.Equal(5, this.underlyingStream.Position); - Assert.Equal(4, this.stream.Seek(-1, SeekOrigin.Current)); - Assert.Equal(4, this.underlyingStream.Position); - Assert.Throws(() => this.stream.Seek(-10, SeekOrigin.Current)); - Assert.Equal(4, this.underlyingStream.Position); - - Assert.Equal(0, this.stream.Seek(0, SeekOrigin.Begin)); - Assert.Equal(0, this.stream.Position); - - Assert.Equal(DefaultNestedLength + 1, this.stream.Seek(DefaultNestedLength + 1, SeekOrigin.Current)); - Assert.Equal(DefaultNestedLength + 1, this.underlyingStream.Position); - Assert.Equal((2 * DefaultNestedLength) + 1, this.stream.Seek(DefaultNestedLength, SeekOrigin.Current)); - Assert.Equal((2 * DefaultNestedLength) + 1, this.underlyingStream.Position); - Assert.Equal((2 * DefaultNestedLength) + 1, this.stream.Seek(0, SeekOrigin.Current)); - Assert.Equal((2 * DefaultNestedLength) + 1, this.underlyingStream.Position); - Assert.Equal(1, this.stream.Seek(-2 * DefaultNestedLength, SeekOrigin.Current)); - Assert.Equal(1, this.underlyingStream.Position); - - this.stream.Dispose(); - Assert.Throws(() => this.stream.Seek(0, SeekOrigin.Begin)); - } - - [Fact] - public void Sook_WithNonStartPositionInUnderlyingStream() - { - this.underlyingStream.Position = 1; - this.stream = this.underlyingStream.ReadSlice(5); - - Assert.Equal(0, this.stream.Position); - Assert.Equal(2, this.stream.Seek(2, SeekOrigin.Current)); - Assert.Equal(3, this.underlyingStream.Position); - } - - [Fact] - public void Seek_Begin() - { - Assert.Equal(0, this.stream.Position); - Assert.Throws(() => this.stream.Seek(-1, SeekOrigin.Begin)); - Assert.Equal(0, this.underlyingStream.Position); - - Assert.Equal(0, this.stream.Seek(0, SeekOrigin.Begin)); - Assert.Equal(0, this.underlyingStream.Position); - - Assert.Equal(5, this.stream.Seek(5, SeekOrigin.Begin)); - Assert.Equal(5, this.underlyingStream.Position); - - Assert.Equal(DefaultNestedLength, this.stream.Seek(DefaultNestedLength, SeekOrigin.Begin)); - Assert.Equal(DefaultNestedLength, this.underlyingStream.Position); - - Assert.Equal(DefaultNestedLength + 1, this.stream.Seek(DefaultNestedLength + 1, SeekOrigin.Begin)); - Assert.Equal(DefaultNestedLength + 1, this.underlyingStream.Position); - - this.stream.Dispose(); - Assert.Throws(() => this.stream.Seek(0, SeekOrigin.Begin)); - } - - [Fact] - public void Seek_End() - { - Assert.Equal(0, this.stream.Position); - Assert.Equal(9, this.stream.Seek(-1, SeekOrigin.End)); - Assert.Equal(9, this.underlyingStream.Position); - - Assert.Equal(DefaultNestedLength, this.stream.Seek(0, SeekOrigin.End)); - Assert.Equal(DefaultNestedLength, this.underlyingStream.Position); - - Assert.Equal(DefaultNestedLength + 5, this.stream.Seek(5, SeekOrigin.End)); - Assert.Equal(DefaultNestedLength + 5, this.underlyingStream.Position); - - Assert.Throws(() => this.stream.Seek(-20, SeekOrigin.Begin)); - Assert.Equal(DefaultNestedLength + 5, this.underlyingStream.Position); - - this.stream.Dispose(); - Assert.Throws(() => this.stream.Seek(0, SeekOrigin.End)); - } - - [Fact] - public void Flush() - { - Assert.Throws(() => this.stream.Flush()); - } - - [Fact] - public async Task FlushAsync() - { - await Assert.ThrowsAsync(() => this.stream.FlushAsync()); - } - - [Fact] - public void CanRead() - { - Assert.True(this.stream.CanRead); - this.stream.Dispose(); - Assert.False(this.stream.CanRead); - } - - [Fact] - public void CanWrite() - { - Assert.False(this.stream.CanWrite); - this.stream.Dispose(); - Assert.False(this.stream.CanWrite); - } - - [Fact] - public async Task WriteAsync_Throws() - { - await Assert.ThrowsAsync(() => this.stream.WriteAsync(new byte[1], 0, 1)); - } - - [Fact] - public void Write_Throws() - { - Assert.Throws(() => this.stream.Write(new byte[1], 0, 1)); - } - - [Fact] - public async Task ReadAsync_Empty_ReturnsZero() - { - Assert.Equal(0, await this.stream.ReadAsync(Array.Empty(), 0, 0, default)); - } - - [Fact] - public async Task Read_BeyondEndOfStream_ReturnsZero() - { - // Seek beyond the end of the stream - this.stream.Seek(1, SeekOrigin.End); - - byte[] buffer = new byte[this.underlyingStream.Length]; - - Assert.Equal(0, await this.stream.ReadAsync(buffer, 0, buffer.Length, this.TimeoutToken)); - } - - [Fact] - public async Task ReadAsync_NoMoreThanGiven() - { - byte[] buffer = new byte[this.underlyingStream.Length]; - int bytesRead = await this.stream.ReadAsync(buffer, 0, buffer.Length, this.TimeoutToken); - Assert.Equal(DefaultNestedLength, bytesRead); - - Assert.Equal(0, await this.stream.ReadAsync(buffer, bytesRead, buffer.Length - bytesRead, this.TimeoutToken)); - Assert.Equal(DefaultNestedLength, this.underlyingStream.Position); - } - - [Fact] - public void Read_NoMoreThanGiven() - { - byte[] buffer = new byte[this.underlyingStream.Length]; - int bytesRead = this.stream.Read(buffer, 0, buffer.Length); - Assert.Equal(DefaultNestedLength, bytesRead); - - Assert.Equal(0, this.stream.Read(buffer, bytesRead, buffer.Length - bytesRead)); - Assert.Equal(DefaultNestedLength, this.underlyingStream.Position); - } - - [Fact] - public void Read_Empty_ReturnsZero() - { - Assert.Equal(0, this.stream.Read(Array.Empty(), 0, 0)); - } - - [Fact] - public async Task ReadAsync_WhenLengthIsInitially0() - { - this.stream = this.underlyingStream.ReadSlice(0); - Assert.Equal(0, await this.stream.ReadAsync(new byte[1], 0, 1, this.TimeoutToken)); - } - - [Fact] - public void Read_WhenLengthIsInitially0() - { - this.stream = this.underlyingStream.ReadSlice(0); - Assert.Equal(0, this.stream.Read(new byte[1], 0, 1)); - } - - [Fact] - public void CreationDoesNotReadFromUnderlyingStream() - { - Assert.Equal(0, this.underlyingStream.Position); - } - - [Fact] - public void Read_UnderlyingStreamReturnsFewerBytesThanRequested() - { - var buffer = new byte[20]; - int firstBlockLength = DefaultNestedLength / 2; - this.underlyingStream.SetLength(firstBlockLength); - Assert.Equal(firstBlockLength, this.stream.Read(buffer, 0, buffer.Length)); - this.underlyingStream.SetLength(DefaultNestedLength * 2); - Assert.Equal(DefaultNestedLength - firstBlockLength, this.stream.Read(buffer, 0, buffer.Length)); - } - - [Fact] - public async Task ReadAsync_UnderlyingStreamReturnsFewerBytesThanRequested() - { - var buffer = new byte[20]; - int firstBlockLength = DefaultNestedLength / 2; - this.underlyingStream.SetLength(firstBlockLength); - Assert.Equal(firstBlockLength, await this.stream.ReadAsync(buffer, 0, buffer.Length)); - this.underlyingStream.SetLength(DefaultNestedLength * 2); - Assert.Equal(DefaultNestedLength - firstBlockLength, await this.stream.ReadAsync(buffer, 0, buffer.Length)); - } - - [Fact] - public void Read_ValidatesArguments() - { - var buffer = new byte[20]; - - Assert.Throws(() => this.stream.Read(null!, 0, 0)); - Assert.Throws(() => this.stream.Read(buffer, -1, buffer.Length)); - Assert.Throws(() => this.stream.Read(buffer, 0, -1)); - Assert.Throws(() => this.stream.Read(buffer, 1, buffer.Length)); - } - - [Fact] - public async Task ReadAsync_ValidatesArguments() - { - var buffer = new byte[20]; - - await Assert.ThrowsAsync(() => this.stream.ReadAsync(null!, 0, 0)); - await Assert.ThrowsAsync(() => this.stream.ReadAsync(buffer, -1, buffer.Length)); - await Assert.ThrowsAsync(() => this.stream.ReadAsync(buffer, 0, -1)); - await Assert.ThrowsAsync(() => this.stream.ReadAsync(buffer, 1, buffer.Length)); - } -} -public static class StreamExtensions -{ - /// - /// Creates a that can read no more than a given number of bytes from an underlying stream. - /// - /// The stream to read from. - /// The number of bytes to read from the parent stream. - /// A stream that ends after bytes are read. - public static NestedStream ReadSlice(this Stream stream, long length) => new(stream, length); -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/SystemTests.cs b/src/UiPath.CoreIpc.Tests/SystemTests.cs deleted file mode 100644 index e33832f4..00000000 --- a/src/UiPath.CoreIpc.Tests/SystemTests.cs +++ /dev/null @@ -1,295 +0,0 @@ -using System.Text; - -namespace UiPath.CoreIpc.Tests; - -public abstract class SystemTests : TestBase where TBuilder : ServiceClientBuilder -{ - protected ServiceHost _systemHost; - protected ISystemService _systemClient; - protected readonly SystemService _systemService; - public SystemTests() - { - _systemService = (SystemService)_serviceProvider.GetService(); - _systemHost = Configure(new ServiceHostBuilder(_serviceProvider)) - .AddEndpoint() - .ValidateAndBuild(); - _systemHost.RunAsync(GuiScheduler); - _systemClient = CreateSystemService(); - } - protected override TSettings Configure(TSettings listenerSettings) - { - base.Configure(listenerSettings); - listenerSettings.ConcurrentAccepts = 10; - listenerSettings.RequestTimeout = RequestTimeout.Subtract(TimeSpan.FromSeconds(1)); - return listenerSettings; - } - public override void Dispose() - { - ((IDisposable)_systemClient).Dispose(); - ((IpcProxy)_systemClient).CloseConnection(); - _systemHost.Dispose(); - base.Dispose(); - } - [Fact] - public async Task ConcurrentRequests() - { - var infinite = _systemClient.Infinite(); - await Guid(); - infinite.IsCompleted.ShouldBeFalse(); - } - [Fact] - public async Task OptionalMessage() - { - var returnValue = await _systemClient.ImpersonateCaller(); - returnValue.ShouldBe(Environment.UserName); - } - - [Fact] - public async Task ServerTimeout() - { - var ex = _systemClient.Infinite().ShouldThrow(); - ex.Message.ShouldBe($"{nameof(_systemClient.Infinite)} timed out."); - ex.Is().ShouldBeTrue(); - await Guid(); - } - [Fact] - public async Task Void() - { - _systemService.DidNothing = false; - await _systemClient.DoNothing(); - _systemService.DidNothing.ShouldBeFalse(); - while (!_systemService.DidNothing) - { - await Task.Delay(10); - Trace.WriteLine(this + " Void"); - } - } - - [Fact] - public async Task VoidThreadName() - { - await _systemClient.VoidThreadName(); - await _systemClient.GetThreadName(); - while (_systemService.ThreadName != "GuiThread") - { - await Task.Delay(0); - Trace.WriteLine(this + " VoidThreadName"); - } - } - - [Fact] - public async Task Enum() - { - var text = await _systemClient.ConvertText("hEllO woRd!", TextStyle.Upper); - text.ShouldBe("HELLO WORD!"); - } - - [Fact] - public async Task PropertyWithTypeDefaultValue() - { - var args = new ConvertTextArgs { Text = "hEllO woRd!", TextStyle = default }; - var text = await _systemClient.ConvertTextWithArgs(args); - text.ShouldBe("Hello Word!"); - } - - [Fact] - public async Task MaxMessageSize() - { - _systemClient.ReverseBytes(new byte[MaxReceivedMessageSizeInMegabytes * 1024 * 1024]).ShouldThrow(); - await Guid(); - } - - [Fact] - public async Task Guid() - { - var newGuid = System.Guid.NewGuid(); - var guid = await _systemClient.GetGuid(newGuid); - guid.ShouldBe(newGuid); - } - - [Fact] - public Task LargeMessage() => _systemClient.ReverseBytes(new byte[(int)(0.7 * MaxReceivedMessageSizeInMegabytes * 1024 * 1024)]); - - [Fact] - public async Task ReverseBytes() - { - var input = Encoding.UTF8.GetBytes("Test"); - var reversed = await _systemClient.ReverseBytes(input); - reversed.ShouldBe(input.Reverse()); - } - - [Fact] - public async Task MissingCallback() - { - RemoteException exception = null; - try - { - await _systemClient.MissingCallback(new SystemMessage()); - } - catch (RemoteException ex) - { - exception = ex; - } - exception.Message.ShouldBe("Callback contract mismatch. Requested System.IDisposable, but it's not configured."); - exception.Is().ShouldBeTrue(); - await Guid(); - } - - - [Fact] - public async Task VoidIsAsync() => await _systemClient.VoidSyncThrow(); - - [Fact] - public async Task GetThreadName() => (await _systemClient.GetThreadName()).ShouldBe("GuiThread"); - - [Fact] - public async Task Echo() - { - using var stream = await _systemClient.Echo(new MemoryStream(Encoding.UTF8.GetBytes("Hello world"))); - (await new StreamReader(stream).ReadToEndAsync()).ShouldBe("Hello world"); - } - - [Fact] - public async Task CancelUpload() - { - var stream = new MemoryStream(Enumerable.Range(1, 50000).Select(i=>(byte)i).ToArray()); - await _systemClient.GetThreadName(); - using (var cancellationSource = new CancellationTokenSource(5)) - { - _systemClient.Upload(stream, 20, cancellationSource.Token).ShouldThrow(); - } - } - - [Fact] - public async Task Upload() - { - (await _systemClient.Upload(new MemoryStream(Encoding.UTF8.GetBytes("Hello world")))).ShouldBe("Hello world"); - await Guid(); - } - - [Fact] - public virtual async Task UploadNoRead() - { - try - { - (await _systemClient.UploadNoRead(new MemoryStream(Encoding.UTF8.GetBytes("Hello world")))).ShouldBeEmpty(); - } - catch (IOException) { } - catch (ObjectDisposedException) { } - await Guid(); - } - - [Fact] - public Task DownloadUiThread() => Task.Factory.StartNew(Download, default, TaskCreationOptions.DenyChildAttach, GuiScheduler).Unwrap(); - [Fact] - public async Task Download() - { - using var stream = await _systemClient.Download("Hello world"); - (await new StreamReader(stream).ReadToEndAsync()).ShouldBe("Hello world"); - } - [Fact] - public async Task DownloadNoRead() - { - using (await _systemClient.Download("Hello world")) { } - await Guid(); - } - protected abstract TBuilder CreateSystemClientBuilder(); - protected TBuilder SystemClientBuilder() => CreateSystemClientBuilder().SerializeParametersAsObjects().RequestTimeout(RequestTimeout).Logger(_serviceProvider); - [Fact] - public async Task BeforeCall() - { - bool newConnection = false; - var proxy = SystemClientBuilder().BeforeCall(async (c, _) => - { - newConnection = c.NewConnection; - c.Method.ShouldBe(typeof(ISystemService).GetMethod(nameof(ISystemService.DoNothing))); - c.Arguments.Single().ShouldBe(""); // cancellation token - }).ValidateAndBuild(); - newConnection.ShouldBeFalse(); - - await proxy.DoNothing(); - newConnection.ShouldBeTrue(); - - await proxy.DoNothing(); - newConnection.ShouldBeFalse(); - var ipcProxy = (IpcProxy)proxy; - var closed = false; - ipcProxy.Connection.Closed += delegate { closed = true; }; - ipcProxy.CloseConnection(); - closed.ShouldBeTrue(); - newConnection.ShouldBeFalse(); - await proxy.DoNothing(); - newConnection.ShouldBeTrue(); - - await proxy.DoNothing(); - newConnection.ShouldBeFalse(); - ipcProxy.CloseConnection(); - } - - [Fact] - public async Task DontReconnect() - { - var proxy = SystemClientBuilder().DontReconnect().ValidateAndBuild(); - await proxy.GetGuid(System.Guid.Empty); - ((IpcProxy)proxy).CloseConnection(); - ObjectDisposedException exception = null; - try - { - await proxy.GetGuid(System.Guid.Empty); - } - catch (ObjectDisposedException ex) - { - exception = ex; - } - exception.ShouldNotBeNull(); - } - [Fact] - public Task CancelServerCall() => CancelServerCallCore(10); - protected ISystemService CreateSystemService() => SystemClientBuilder().ValidateAndBuild(); - - async Task CancelServerCallCore(int counter) - { - for (int i = 0; i < counter; i++) - { - var request = new SystemMessage { RequestTimeout = Timeout.InfiniteTimeSpan, Delay = Timeout.Infinite }; - var sendMessageResult = _systemClient.MissingCallback(request); - var newGuid = System.Guid.NewGuid(); - (await _systemClient.GetGuid(newGuid)).ShouldBe(newGuid); - await Task.Delay(1); - ((IpcProxy)_systemClient).CloseConnection(); - sendMessageResult.ShouldThrow(); - newGuid = System.Guid.NewGuid(); - (await _systemClient.GetGuid(newGuid)).ShouldBe(newGuid); - } - } - [Fact] - public async Task ClosingTheHostShouldCloseTheConnection() - { - var request = new SystemMessage { RequestTimeout = Timeout.InfiniteTimeSpan, Delay = Timeout.Infinite }; - var sendMessageResult = _systemClient.MissingCallback(request); - var newGuid = System.Guid.NewGuid(); - (await _systemClient.GetGuid(newGuid)).ShouldBe(newGuid); - await Task.Delay(1); - _systemHost.Dispose(); - sendMessageResult.ShouldThrow(); - } - [Fact] - public virtual async void BeforeCallServerSide() - { - var newGuid = System.Guid.NewGuid(); - MethodInfo method = null; - using var protectedService = Configure(new ServiceHostBuilder(_serviceProvider)) - .AddEndpoint(new EndpointSettings - { - BeforeCall = async (call, ct) => - { - method = call.Method; - call.Arguments[0].ShouldBe(newGuid); - } - }) - .ValidateAndBuild(); - _ = protectedService.RunAsync(); - await CreateSystemService().GetGuid(newGuid); - method.ShouldBe(typeof(ISystemService).GetMethod(nameof(ISystemService.GetGuid))); - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/TcpTests..cs b/src/UiPath.CoreIpc.Tests/TcpTests..cs deleted file mode 100644 index cca919c5..00000000 --- a/src/UiPath.CoreIpc.Tests/TcpTests..cs +++ /dev/null @@ -1,28 +0,0 @@ -using System.Net; -using UiPath.CoreIpc.Tcp; -namespace UiPath.CoreIpc.Tests; -public class SystemTcpTests : SystemTests> -{ - int _port = 3131 + GetCount(); - protected override ServiceHostBuilder Configure(ServiceHostBuilder serviceHostBuilder) => - serviceHostBuilder.UseTcp(Configure(new TcpSettings(GetEndPoint()))); - protected override TcpClientBuilder CreateSystemClientBuilder() => new(GetEndPoint()); - [Fact] - public override async void BeforeCallServerSide() - { - _port++; - base.BeforeCallServerSide(); - } - IPEndPoint GetEndPoint() => new(IPAddress.Loopback, _port); -} -public class ComputingTcpTests : ComputingTests> -{ - protected static readonly IPEndPoint ComputingEndPoint = new(IPAddress.Loopback, 2121+GetCount()); - protected override TcpClientBuilder ComputingClientBuilder(TaskScheduler taskScheduler = null) => - new TcpClientBuilder(ComputingEndPoint, _serviceProvider) - .RequestTimeout(RequestTimeout) - .CallbackInstance(_computingCallback) - .TaskScheduler(taskScheduler); - protected override ServiceHostBuilder Configure(ServiceHostBuilder serviceHostBuilder) => - serviceHostBuilder.UseTcp(Configure(new TcpSettings(ComputingEndPoint))); -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/TestBase.cs b/src/UiPath.CoreIpc.Tests/TestBase.cs deleted file mode 100644 index 98d75a4e..00000000 --- a/src/UiPath.CoreIpc.Tests/TestBase.cs +++ /dev/null @@ -1,39 +0,0 @@ -using Nito.AsyncEx; - -namespace UiPath.CoreIpc.Tests; - -public abstract class TestBase : IDisposable -{ - protected const int MaxReceivedMessageSizeInMegabytes = 1; - protected static int Count = -1; - public static readonly TimeSpan RequestTimeout = -#if CI - TimeSpan.FromSeconds(2) + -#endif - (Debugger.IsAttached ? TimeSpan.FromDays(1) : TimeSpan.FromSeconds(2)); - protected readonly IServiceProvider _serviceProvider; - protected readonly AsyncContext _guiThread = new AsyncContextThread().Context; - - //static TestBase() - //{ - // AppContext.SetSwitch("Switch.System.Net.DontEnableSystemDefaultTlsVersions", false); - //} - public TestBase() - { - _guiThread.SynchronizationContext.Send(() => Thread.CurrentThread.Name = "GuiThread"); - _serviceProvider = IpcHelpers.ConfigureServices(); - } - - protected static int GetCount() => Interlocked.Increment(ref Count); - - protected TaskScheduler GuiScheduler => _guiThread.Scheduler; - - public virtual void Dispose() => _guiThread.Dispose(); - protected virtual TSettings Configure(TSettings listenerSettings) where TSettings : ListenerSettings - { - listenerSettings.RequestTimeout = RequestTimeout; - listenerSettings.MaxReceivedMessageSizeInMegabytes = MaxReceivedMessageSizeInMegabytes; - return listenerSettings; - } - protected abstract ServiceHostBuilder Configure(ServiceHostBuilder serviceHostBuilder); -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/UiPath.CoreIpc.Tests.csproj b/src/UiPath.CoreIpc.Tests/UiPath.CoreIpc.Tests.csproj deleted file mode 100644 index eaf03da6..00000000 --- a/src/UiPath.CoreIpc.Tests/UiPath.CoreIpc.Tests.csproj +++ /dev/null @@ -1,30 +0,0 @@ - - - - net6.0;net461;net6.0-windows - $(NoWarn);1998 - $(DefineConstants);$(DefineConstantsEx) - latest - true - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/ValidationTests.cs b/src/UiPath.CoreIpc.Tests/ValidationTests.cs deleted file mode 100644 index a1a0197c..00000000 --- a/src/UiPath.CoreIpc.Tests/ValidationTests.cs +++ /dev/null @@ -1,48 +0,0 @@ -namespace UiPath.CoreIpc.Tests; - -public class ValidationTests -{ - class JobFailedException : Exception - { - public JobFailedException(Error error) : base("Job has failed.", new RemoteException(error)) - { - } - } - - [Fact] - public void ErrorFromRemoteException() - { - var innerError = new InvalidDataException("invalid").ToError(); - var error = new JobFailedException(innerError).ToError(); - error.Type.ShouldBe(typeof(JobFailedException).FullName); - error.Message.ShouldBe("Job has failed."); - error.InnerError.Type.ShouldBe(typeof(InvalidDataException).FullName); - error.InnerError.Message.ShouldBe("invalid"); - } - [Fact] - public void SerializeDefaultValueToString() => new IpcJsonSerializer().Serialize(new Message(0)).ShouldBe("{\"Payload\":0}"); - [Fact] - public void SerializeNullToString() => new IpcJsonSerializer().Serialize(new Message(null)).ShouldBe("{\"Payload\":null}"); -#if DEBUG - [Fact] - public void MethodsMustReturnTask() => new Action(() => new NamedPipeClientBuilder("").ValidateAndBuild()).ShouldThrow().Message.ShouldStartWith("Method does not return Task!"); - [Fact] - public void DuplicateMessageParameters() => new Action(() => new NamedPipeClientBuilder("").ValidateAndBuild()).ShouldThrow().Message.ShouldStartWith("The message must be the last parameter before the cancellation token!"); - [Fact] - public void TheMessageMustBeTheLastBeforeTheToken() => new Action(() => new NamedPipeClientBuilder("").ValidateAndBuild()).ShouldThrow().Message.ShouldStartWith("The message must be the last parameter before the cancellation token!"); - [Fact] - public void CancellationTokenMustBeLast() => new Action(() => new NamedPipeClientBuilder("").ValidateAndBuild()).ShouldThrow().Message.ShouldStartWith("The CancellationToken parameter must be the last!"); - [Fact] - public void UploadMustReturn() => new Action(() => new NamedPipeClientBuilder("").ValidateAndBuild()).ShouldThrow().Message.ShouldStartWith("Upload methods must return a value!"); - [Fact] - public void DuplicateStreams() => new Action(() => new NamedPipeClientBuilder("").ValidateAndBuild()).ShouldThrow().Message.ShouldStartWith("Only one Stream parameter is allowed!"); - [Fact] - public void UploadDerivedStream() => new Action(() => new NamedPipeClientBuilder("").ValidateAndBuild()).ShouldThrow().Message.ShouldStartWith("Stream parameters must be typed as Stream!"); - [Fact] - public void DownloadDerivedStream() => new Action(() => new NamedPipeClientBuilder("").ValidateAndBuild()).ShouldThrow().Message.ShouldStartWith("Stream parameters must be typed as Stream!"); - [Fact] - public void TheCallbackContractMustBeAnInterface() => new Action(() => new NamedPipeClientBuilder("", IpcHelpers.ConfigureServices()).ValidateAndBuild()).ShouldThrow().Message.ShouldStartWith("The contract must be an interface!"); - [Fact] - public void TheServiceContractMustBeAnInterface() => new Action(() => new ServiceHostBuilder(IpcHelpers.ConfigureServices()).AddEndpoint().ValidateAndBuild()).ShouldThrow().Message.ShouldStartWith("The contract must be an interface!"); -#endif -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc.Tests/WebSocketTests.cs b/src/UiPath.CoreIpc.Tests/WebSocketTests.cs deleted file mode 100644 index 0661160c..00000000 --- a/src/UiPath.CoreIpc.Tests/WebSocketTests.cs +++ /dev/null @@ -1,49 +0,0 @@ -using UiPath.CoreIpc.WebSockets; -namespace UiPath.CoreIpc.Tests; -public class SystemWebSocketTests : SystemTests> -{ - int _port = 1313 + GetCount(); - HttpSysWebSocketsListener _listener; - protected override ServiceHostBuilder Configure(ServiceHostBuilder serviceHostBuilder) - { - _listener = new HttpSysWebSocketsListener("http" + GetEndPoint()); - return serviceHostBuilder.UseWebSockets(Configure(new WebSocketSettings(_listener.Accept))); - } - public override void Dispose() - { - base.Dispose(); - _listener?.Dispose(); - } - protected override WebSocketClientBuilder CreateSystemClientBuilder() => new(new("ws"+GetEndPoint())); - [Fact] - public override async void BeforeCallServerSide() - { - _port++; - base.BeforeCallServerSide(); - } -#if !NET461 - [Fact(Skip = "WebSocket.State is unreliable")] - public override Task UploadNoRead() => base.UploadNoRead(); -#endif - string GetEndPoint() => $"://localhost:{_port}/"; -} -public class ComputingWebSocketsTests : ComputingTests> -{ - protected static readonly string ComputingEndPoint = $"://localhost:{1212+GetCount()}/"; - HttpSysWebSocketsListener _listener; - protected override WebSocketClientBuilder ComputingClientBuilder(TaskScheduler taskScheduler = null) => - new WebSocketClientBuilder(new("ws"+ComputingEndPoint), _serviceProvider) - .RequestTimeout(RequestTimeout) - .CallbackInstance(_computingCallback) - .TaskScheduler(taskScheduler); - protected override ServiceHostBuilder Configure(ServiceHostBuilder serviceHostBuilder) - { - _listener = new HttpSysWebSocketsListener("http" + ComputingEndPoint); - return serviceHostBuilder.UseWebSockets(Configure(new WebSocketSettings(_listener.Accept))); - } - public override void Dispose() - { - base.Dispose(); - _listener?.Dispose(); - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/CancellationTokenSourcePool.cs b/src/UiPath.CoreIpc/CancellationTokenSourcePool.cs index a6d0b3f8..0d517d86 100644 --- a/src/UiPath.CoreIpc/CancellationTokenSourcePool.cs +++ b/src/UiPath.CoreIpc/CancellationTokenSourcePool.cs @@ -1,4 +1,4 @@ -namespace UiPath.CoreIpc; +namespace UiPath.Ipc; // https://github.com/dotnet/aspnetcore/blob/main/src/Shared/CancellationTokenSourcePool.cs internal static class CancellationTokenSourcePool { diff --git a/src/UiPath.CoreIpc/Client/ClientConnectionsRegistry.cs b/src/UiPath.CoreIpc/Client/ClientConnectionsRegistry.cs deleted file mode 100644 index 14b708fc..00000000 --- a/src/UiPath.CoreIpc/Client/ClientConnectionsRegistry.cs +++ /dev/null @@ -1,98 +0,0 @@ -namespace UiPath.CoreIpc; - -static class ClientConnectionsRegistry -{ - private static readonly ConcurrentDictionary Connections = new(); - public static async Task GetOrCreate(IConnectionKey key, CancellationToken cancellationToken) - { - var clientConnection = GetOrAdd(key); - await clientConnection.Lock(cancellationToken); - try - { - // check again just in case it was removed after GetOrAdd but before entering the lock - ClientConnection newClientConnection; - while ((newClientConnection = GetOrAdd(key)) != clientConnection) - { - clientConnection.Release(); - await newClientConnection.Lock(cancellationToken); - clientConnection = newClientConnection; - } - } - catch - { - clientConnection.Release(); - throw; - } - return clientConnection; - } - private static ClientConnection GetOrAdd(IConnectionKey key) => Connections.GetOrAdd(key, key => key.CreateClientConnection()); - public static bool TryGet(IConnectionKey key, out ClientConnection connection) => Connections.TryGetValue(key, out connection); - internal static ClientConnection Remove(IConnectionKey connectionKey) - { - Connections.TryRemove(connectionKey, out var clientConnection); - return clientConnection; - } -} -interface IConnectionKey : IEquatable -{ - string SslServer { get; } - ClientConnection CreateClientConnection(); -} -abstract class ClientConnection : IDisposable -{ - readonly SemaphoreSlim _lock = new(1); - Connection _connection; - protected ClientConnection(IConnectionKey connectionKey) => ConnectionKey = connectionKey; - public abstract bool Connected { get; } - public Connection Connection - { - get => _connection; - set - { - _connection = value; - _connection.Closed += OnConnectionClosed; - } - } - public abstract Task Connect(CancellationToken cancellationToken); - private void OnConnectionClosed(object sender, EventArgs _) - { - var closedConnection = (Connection)sender; - if (!ClientConnectionsRegistry.TryGet(ConnectionKey, out var clientConnection) || clientConnection.Connection != closedConnection) - { - return; - } - if (!clientConnection.TryLock()) - { - return; - } - try - { - if (!ClientConnectionsRegistry.TryGet(ConnectionKey, out clientConnection) || clientConnection.Connection != closedConnection) - { - return; - } - var removedConnection = ClientConnectionsRegistry.Remove(ConnectionKey); - if (_connection.LogEnabled) - { - _connection.Log($"Remove connection {removedConnection}."); - } - Debug.Assert(removedConnection?.Connection == closedConnection, "Removed the wrong connection."); - } - finally - { - Release(); - } - } - public Server Server { get; set; } - protected IConnectionKey ConnectionKey { get; } - public Task Lock(CancellationToken cancellationToken = default) => _lock.WaitAsync(cancellationToken); - public void Release() => _lock.Release(); - public bool TryLock() => _lock.Wait(millisecondsTimeout: 0); - public override string ToString() => _connection?.Name ?? base.ToString(); - protected virtual void Dispose(bool disposing) => _lock.AssertDisposed(); - public void Dispose() - { - Dispose(disposing: true); - GC.SuppressFinalize(this); - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Client/FastAsyncLock.cs b/src/UiPath.CoreIpc/Client/FastAsyncLock.cs new file mode 100644 index 00000000..bfa2a64f --- /dev/null +++ b/src/UiPath.CoreIpc/Client/FastAsyncLock.cs @@ -0,0 +1,14 @@ +namespace UiPath.Ipc; + +internal sealed class FastAsyncLock : IDisposable +{ + private readonly SemaphoreSlim _semaphore = new(initialCount: 1, maxCount: 1); + + public async Task Lock(CancellationToken ct = default) + { + await _semaphore.WaitAsync(ct); + return this; + } + + public void Dispose() => _semaphore.Release(); +} diff --git a/src/UiPath.CoreIpc/Client/IpcProxy.cs b/src/UiPath.CoreIpc/Client/IpcProxy.cs new file mode 100644 index 00000000..9203b1a5 --- /dev/null +++ b/src/UiPath.CoreIpc/Client/IpcProxy.cs @@ -0,0 +1,21 @@ +namespace UiPath.Ipc; + +public class IpcProxy : DispatchProxy, IDisposable +{ + internal ServiceClient ServiceClient { get; set; } = null!; + + protected override object? Invoke(MethodInfo? targetMethod, object?[]? args) + => ServiceClient.Invoke(targetMethod!, args!); + + public void Dispose() => ServiceClient?.Dispose(); + + public ValueTask CloseConnection() => ServiceClient.CloseConnection(); + + public event EventHandler ConnectionClosed + { + add => ServiceClient.ConnectionClosed += value; + remove => ServiceClient.ConnectionClosed -= value; + } + + public Stream? Network => ServiceClient.Network; +} diff --git a/src/UiPath.CoreIpc/Client/ServiceClient.cs b/src/UiPath.CoreIpc/Client/ServiceClient.cs index 8ee847f5..c0638560 100644 --- a/src/UiPath.CoreIpc/Client/ServiceClient.cs +++ b/src/UiPath.CoreIpc/Client/ServiceClient.cs @@ -1,122 +1,80 @@ -using System.Net.Security; -namespace UiPath.CoreIpc; +namespace UiPath.Ipc; -using ConnectionFactory = Func>; -using BeforeCallHandler = Func; -using InvokeDelegate = Func; - -interface IServiceClient : IDisposable +internal abstract class ServiceClient : IDisposable { - Task Invoke(MethodInfo method, object[] args); - Connection Connection { get; } -} + protected abstract IServiceClientConfig Config { get; } + public abstract Stream? Network { get; } + public event EventHandler? ConnectionClosed; -class ServiceClient : IServiceClient, IConnectionKey where TInterface : class -{ - private readonly ISerializer _serializer; - private readonly TimeSpan _requestTimeout; - private readonly ILogger _logger; - private readonly ConnectionFactory _connectionFactory; - private readonly BeforeCallHandler _beforeCall; - private readonly EndpointSettings _serviceEndpoint; - private readonly SemaphoreSlim _connectionLock = new(1); - private Connection _connection; - private Server _server; - private ClientConnection _clientConnection; - - internal ServiceClient(ISerializer serializer, TimeSpan requestTimeout, ILogger logger, ConnectionFactory connectionFactory, string sslServer = null, BeforeCallHandler beforeCall = null, bool objectParameters = false, EndpointSettings serviceEndpoint = null) - { - ObjectParameters = objectParameters; - _serializer = serializer; - _requestTimeout = requestTimeout; - _logger = logger; - _connectionFactory = connectionFactory; - SslServer = sslServer; - _beforeCall = beforeCall; - _serviceEndpoint = serviceEndpoint; - } - protected int HashCode { get; init; } - public string SslServer { get; init; } - public virtual string Name => _connection?.Name; - private bool LogEnabled => _logger.Enabled(); - Connection IServiceClient.Connection => _connection; - public bool ObjectParameters { get; init; } - - public TInterface CreateProxy() + private readonly Type _interfaceType; + private readonly ContextfulLazy _proxy = new(); + + protected ServiceClient(Type interfaceType) { - var proxy = DispatchProxy.Create(); - (proxy as IpcProxy).ServiceClient = this; - return proxy; + _interfaceType = interfaceType; } - - public override int GetHashCode() => HashCode; - private void OnNewConnection(Connection connection, bool alreadyHasServer = false) + protected void RaiseConnectionClosed() => ConnectionClosed?.Invoke(this, EventArgs.Empty); + public virtual ValueTask CloseConnection() => throw new NotSupportedException(); + public object? Invoke(MethodInfo method, object?[] args) => GetInvokeDelegate(method.ReturnType)(this, method, args); + + protected abstract Task<(Connection connection, bool newlyConnected)> EnsureConnection(CancellationToken ct); + + public T GetProxy() where T : class { - _connection?.Dispose(); - _connection = connection; - if (alreadyHasServer || _serviceEndpoint == null) + if (!typeof(T).IsAssignableFrom(_interfaceType)) { - return; + throw new ArgumentOutOfRangeException($"The provided generic argument T is not assignable to the proxy type. T is {typeof(T).Name}. The proxy type is {_interfaceType.Name}."); } - connection.Logger ??= _logger; - var endpoints = new ConcurrentDictionary { [_serviceEndpoint.Name] = _serviceEndpoint }; - var listenerSettings = new ListenerSettings(Name) { RequestTimeout = _requestTimeout, ServiceProvider = _serviceEndpoint.ServiceProvider, Endpoints = endpoints }; - _server = new(listenerSettings, connection); + + return (_proxy.GetValue(() => + { + var proxy = (DispatchProxy.Create() as IpcProxy)!; + proxy.ServiceClient = this; + return proxy; + }) as T)!; } - public Task Invoke(MethodInfo method, object[] args) + private Task Invoke(MethodInfo method, object?[] args) { var syncContext = SynchronizationContext.Current; - var defaultContext = syncContext == null || syncContext.GetType() == typeof(SynchronizationContext); + var defaultContext = syncContext is null || syncContext.GetType() == typeof(SynchronizationContext); return defaultContext ? Invoke() : Task.Run(Invoke); + async Task Invoke() { CancellationToken cancellationToken = default; TimeSpan messageTimeout = default; - TimeSpan clientTimeout = _requestTimeout; - Stream uploadStream = null; - string[] serializedArguments = null; + TimeSpan clientTimeout = Config.RequestTimeout; + Stream? uploadStream = null; var methodName = method.Name; - SerializeArguments(); + + var serializedArguments = SerializeArguments(); + var timeoutHelper = new TimeoutHelper(clientTimeout, cancellationToken); try { - var token = timeoutHelper.Token; - bool newConnection; - await _connectionLock.WaitAsync(token); - try - { - newConnection = await EnsureConnection(token); - } - finally - { - _connectionLock.Release(); - } - if (_beforeCall != null) + var ct = timeoutHelper.Token; + + var (connection, newConnection) = await EnsureConnection(ct); + + if (Config.BeforeCall is not null) { - await _beforeCall(new(newConnection, method, args), token); + var callInfo = new CallInfo(newConnection, method, args); + await Config.BeforeCall(callInfo, ct); } - var requestId = _connection.NewRequestId(); - var request = new Request(typeof(TInterface).Name, requestId, methodName, serializedArguments, ObjectParameters ? args : null, messageTimeout.TotalSeconds) + + var requestId = connection.NewRequestId(); + var request = new Request(_interfaceType.Name, requestId, methodName, serializedArguments, messageTimeout.TotalSeconds) { UploadStream = uploadStream }; - if (LogEnabled) - { - Log($"IpcClient calling {methodName} {requestId} {Name}."); - } - if (ObjectParameters && !method.ReturnType.IsGenericType) - { - await _connection.Send(request, token); - return default; - } - var response = await _connection.RemoteCall(request, token); - if (LogEnabled) - { - Log($"IpcClient called {methodName} {requestId} {Name}."); - } - return response.Deserialize(_serializer, ObjectParameters); + + Config.Logger?.ServiceClientCalling(methodName, requestId, Config.DebugName); + var response = await connection.RemoteCall(request, ct); // returns user errors instead of throwing them (could throw for system bugs) + Config.Logger?.ServiceClientCalled(methodName, requestId, Config.DebugName); + + return response.Deserialize(Config.Serializer); } catch (Exception ex) { @@ -127,12 +85,11 @@ async Task Invoke() { timeoutHelper.Dispose(); } - void SerializeArguments() + + string[] SerializeArguments() { - if (!ObjectParameters) - { - serializedArguments = new string[args.Length]; - } + var result = new string[args.Length]; + for (int index = 0; index < args.Length; index++) { switch (args[index]) @@ -150,168 +107,145 @@ void SerializeArguments() args[index] = ""; break; } - if (!ObjectParameters) - { - serializedArguments[index] = _serializer.Serialize(args[index]); - } + + result[index] = Config.Serializer.OrDefault().Serialize(args[index]); } + + return result; } } } - private async Task EnsureConnection(CancellationToken cancellationToken) + public void Dispose() { - if (_connectionFactory != null) - { - var externalConnection = await _connectionFactory(_connection, cancellationToken); - if (externalConnection != null) - { - if (_connection == null) - { - OnNewConnection(externalConnection); - return true; - } - return false; - } - } - if (_clientConnection?.Connected is true) - { - return false; - } - return await Connect(cancellationToken); + Dispose(true); + GC.SuppressFinalize(this); + } + private void Dispose(bool disposing) + { + Config.Logger?.ServiceClientDispose(Config.DebugName); } + public override string ToString() => Config.DebugName; + + #region Generic adapter cache + private static readonly MethodInfo GenericDefinition = ((Func>)Invoke).Method.GetGenericMethodDefinition(); + private static readonly ConcurrentDictionary ReturnTypeToInvokeDelegate = new(); + private static InvokeDelegate GetInvokeDelegate(Type returnType) => ReturnTypeToInvokeDelegate.GetOrAdd(returnType, CreateInvokeDelegate); + private static InvokeDelegate CreateInvokeDelegate(Type returnType) + => GenericDefinition.MakeGenericDelegate( + returnType.IsGenericType + ? returnType.GetGenericArguments()[0] + : typeof(object)); + + private static Task Invoke(ServiceClient serviceClient, MethodInfo method, object?[] args) => serviceClient.Invoke(method, args); + #endregion +} + +internal sealed class ServiceClientProper : ServiceClient +{ + private readonly FastAsyncLock _lock = new(); + private readonly IpcClient _client; + private readonly IClientState _clientState; - private async Task Connect(CancellationToken cancellationToken) + private Connection? _latestConnection; + private Server? _latestServer; + + private Connection? LatestConnection { - var clientConnection = await ClientConnectionsRegistry.GetOrCreate(this, cancellationToken); - try + get => _latestConnection; + set { - if (clientConnection.Connected) - { - ReuseClientConnection(clientConnection); - return false; - } - clientConnection.Dispose(); - Stream network; - try - { - network = await clientConnection.Connect(cancellationToken); - } - catch - { - clientConnection.Dispose(); - throw; - } - var stream = SslServer == null ? network : await AuthenticateAsClient(network); - OnNewConnection(new(stream, _serializer, _logger, Name)); - if (LogEnabled) + if (_latestConnection == value) { - Log($"CreateConnection {Name}."); + return; } - InitializeClientConnection(clientConnection); - } - finally - { - clientConnection.Release(); - } - return true; - async Task AuthenticateAsClient(Stream network) - { - var sslStream = new SslStream(network); - try + + if (_latestConnection is not null) { - await sslStream.AuthenticateAsClientAsync(SslServer); + _latestConnection.Closed -= LatestConnection_Closed; } - catch + + _latestConnection = value; + + if (_latestConnection is not null) { - sslStream.Dispose(); - throw; + _latestConnection.Closed += LatestConnection_Closed; } - Debug.Assert(sslStream.IsEncrypted && sslStream.IsSigned); - return sslStream; } } - private void ReuseClientConnection(ClientConnection clientConnection) + public override Stream? Network => LatestConnection?.Network; + + public ServiceClientProper(IpcClient client, Type interfaceType) : base(interfaceType) { - _clientConnection = clientConnection; - var alreadyHasServer = clientConnection.Server != null; - if (LogEnabled) - { - Log(nameof(ReuseClientConnection) + " " + clientConnection); - } - OnNewConnection(clientConnection.Connection, alreadyHasServer); - if (!alreadyHasServer) + _client = client; + _clientState = client.Transport.CreateState(); + } + + public override async ValueTask CloseConnection() + { + using (await _lock.Lock()) { - clientConnection.Server = _server; - } - else if (_serviceEndpoint != null) - { - _server = clientConnection.Server; - if (_server.Endpoints.ContainsKey(_serviceEndpoint.Name)) - { - throw new InvalidOperationException($"Duplicate callback proxy instance {Name} <{typeof(TInterface).Name}, {_serviceEndpoint.Contract.Name}>. Consider using a singleton callback proxy."); - } - _server.Endpoints.Add(_serviceEndpoint.Name, _serviceEndpoint); + LatestConnection?.Dispose(); + LatestConnection = null; } } - public void Log(string message) => _logger.LogInformation(message); + private void LatestConnection_Closed(object? sender, EventArgs e) => RaiseConnectionClosed(); - private void InitializeClientConnection(ClientConnection clientConnection) + protected override async Task<(Connection connection, bool newlyConnected)> EnsureConnection(CancellationToken ct) { - _connection.Listen().LogException(_logger, Name); - clientConnection.Connection = _connection; - clientConnection.Server = _server; - _clientConnection = clientConnection; - } + using (await _lock.Lock(ct)) + { + if (LatestConnection is not null && _clientState.IsConnected()) + { + return (LatestConnection, newlyConnected: false); + } - public void Dispose() - { - Dispose(true); - GC.SuppressFinalize(this); + if (Config.BeforeConnect is not null) + { + await Config.BeforeConnect(ct); + } + + var network = await Connect(ct); + LatestConnection = new Connection(network, Config.Serializer, Config.Logger, Config.DebugName); + var router = new Router(_client.Config.CreateCallbackRouterConfig(), _client.Config.ServiceProvider); + _latestServer = new Server(router, _client.Config.RequestTimeout, LatestConnection); + LatestConnection.Listen().LogException(Config.Logger, Config.DebugName); + return (LatestConnection, newlyConnected: true); + } } - protected virtual void Dispose(bool disposing) + private async Task Connect(CancellationToken ct) { - _connectionLock.AssertDisposed(); - if (LogEnabled) - { - Log($"Dispose {Name}"); - } - if (disposing) + await _clientState.Connect(_client, ct); + + if (_clientState.Network is not { } network) { - _server?.Endpoints.Remove(_serviceEndpoint.Name); + throw new InvalidOperationException(); } - } - - public override string ToString() => Name; - public virtual bool Equals(IConnectionKey other) => SslServer == other.SslServer; + return network; + } - public virtual ClientConnection CreateClientConnection() => throw new NotImplementedException(); + protected override IServiceClientConfig Config => _client.Config; } -public class IpcProxy : DispatchProxy, IDisposable +internal sealed class ServiceClientForCallback : ServiceClient { - private static readonly MethodInfo InvokeMethod = typeof(IpcProxy).GetStaticMethod(nameof(GenericInvoke)); - private static readonly ConcurrentDictionary InvokeByType = new(); - - internal IServiceClient ServiceClient { get; set; } - - public Connection Connection => ServiceClient.Connection; + private readonly Connection _connection; + private readonly Listener _listener; - protected override object Invoke(MethodInfo targetMethod, object[] args) => GetInvoke(targetMethod)(ServiceClient, targetMethod, args); + public override Stream? Network => _connection.Network; - public void Dispose() => ServiceClient.Dispose(); - - public void CloseConnection() => Connection?.Dispose(); - - private static InvokeDelegate GetInvoke(MethodInfo targetMethod) => InvokeByType.GetOrAdd(targetMethod.ReturnType, taskType => + public ServiceClientForCallback(Connection connection, Listener listener, Type interfaceType) : base(interfaceType) { - var resultType = taskType.IsGenericType ? taskType.GenericTypeArguments[0] : typeof(object); - return InvokeMethod.MakeGenericDelegate(resultType); - }); + _connection = connection; + _listener = listener; + } + + protected override Task<(Connection connection, bool newlyConnected)> EnsureConnection(CancellationToken ct) + => Task.FromResult((_connection, newlyConnected: false)); - private static object GenericInvoke(IServiceClient serviceClient, MethodInfo method, object[] args) => serviceClient.Invoke(method, args); -} \ No newline at end of file + protected override IServiceClientConfig Config => _listener.Config; +} diff --git a/src/UiPath.CoreIpc/Client/ServiceClientBuilder.cs b/src/UiPath.CoreIpc/Client/ServiceClientBuilder.cs index db59c9f7..1d30a148 100644 --- a/src/UiPath.CoreIpc/Client/ServiceClientBuilder.cs +++ b/src/UiPath.CoreIpc/Client/ServiceClientBuilder.cs @@ -1,104 +1,8 @@ -namespace UiPath.CoreIpc; - -using ConnectionFactory = Func>; -using BeforeCallHandler = Func; - -public abstract class ServiceClientBuilder where TInterface : class where TDerived : ServiceClientBuilder -{ - protected readonly IServiceProvider _serviceProvider; - protected ISerializer _serializer = new IpcJsonSerializer(); - protected TimeSpan _requestTimeout = Timeout.InfiniteTimeSpan; - protected ILogger _logger; - protected ConnectionFactory _connectionFactory; - protected BeforeCallHandler _beforeCall; - protected object _callbackInstance; - protected TaskScheduler _taskScheduler; - protected string _sslServer; - protected bool _objectParameters; - - protected ServiceClientBuilder(Type callbackContract, IServiceProvider serviceProvider) - { - CallbackContract = callbackContract; - _serviceProvider = serviceProvider; - } - - internal Type CallbackContract { get; } - - public TDerived DontReconnect() => ConnectionFactory((connection, _) => Task.FromResult(connection)); - - public TDerived ConnectionFactory(ConnectionFactory connectionFactory) - { - _connectionFactory = connectionFactory; - return (TDerived)this; - } - - public TDerived EncryptAndSign(string certificateServerName) - { - if (string.IsNullOrWhiteSpace(certificateServerName)) - { - throw new ArgumentException($"'{nameof(certificateServerName)}' must match the name on the server's certificate.", nameof(certificateServerName)); - } - _sslServer = certificateServerName; - return (TDerived)this; - } - - public TDerived BeforeCall(BeforeCallHandler beforeCall) - { - _beforeCall = beforeCall; - return (TDerived)this; - } - - public TDerived Logger(ILogger logger) - { - _logger = logger; - return (TDerived)this; - } - /// - /// By default, method parameters are serialized as json strings. Setting this allows serialization as json objects. - /// This should improve performance for large strings, but decrease it for many small objects. - /// Setting it breaks compatibility with older servers. - /// So a proxy with this setting will only be able to connect to servers that understand the new encoding. - /// - /// this - public TDerived SerializeParametersAsObjects() - { - _objectParameters = true; - return (TDerived)this; - } - - public TDerived Logger(IServiceProvider serviceProvider) => Logger(serviceProvider.GetRequiredService>()); - - public TDerived Serializer(ISerializer serializer) - { - _serializer = serializer; - return (TDerived) this; - } - - public TDerived RequestTimeout(TimeSpan timeout) - { - _requestTimeout = timeout; - return (TDerived) this; - } - - protected abstract TInterface BuildCore(EndpointSettings serviceEndpoint); - - public TInterface Build() - { - if (CallbackContract == null) - { - return BuildCore(null); - } - if (_logger == null) - { - Logger(_serviceProvider); - } - return BuildCore(new(CallbackContract, _callbackInstance) { Scheduler = _taskScheduler, ServiceProvider = _serviceProvider }); - } -} +namespace UiPath.Ipc; public readonly struct CallInfo { - public CallInfo(bool newConnection, MethodInfo method, object[] arguments) + public CallInfo(bool newConnection, MethodInfo method, object?[] arguments) { NewConnection = newConnection; Method = method; @@ -106,5 +10,5 @@ public CallInfo(bool newConnection, MethodInfo method, object[] arguments) } public bool NewConnection { get; } public MethodInfo Method { get; } - public object[] Arguments { get; } + public object?[] Arguments { get; } } \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Config/ClientConfig.cs b/src/UiPath.CoreIpc/Config/ClientConfig.cs new file mode 100644 index 00000000..6b0191ac --- /dev/null +++ b/src/UiPath.CoreIpc/Config/ClientConfig.cs @@ -0,0 +1,60 @@ +using System.ComponentModel; + +namespace UiPath.Ipc; + +public sealed record ClientConfig : EndpointConfig, IServiceClientConfig +{ + public EndpointCollection? Callbacks { get; init; } + + public IServiceProvider? ServiceProvider { get; init; } + public ILogger? Logger { get; init; } + public BeforeConnectHandler? BeforeConnect { get; init; } + public BeforeCallHandler? BeforeCall { get; init; } + public TaskScheduler? Scheduler { get; init; } + public ISerializer? Serializer { get; set; } + + [EditorBrowsable(EditorBrowsableState.Never)] + public string DebugName { get; set; } = null!; + + internal void Validate() + { + var haveDeferredInjectedCallbacks = Callbacks?.Any(x => x.Service.MaybeGetServiceProvider() is null && x.Service.MaybeGetInstance() is null) ?? false; + + if (haveDeferredInjectedCallbacks && ServiceProvider is null) + { + throw new InvalidOperationException("ServiceProvider is required when you register injectable callbacks. Consider registering a callback instance."); + } + } + + internal ILogger? GetLogger(string name) + { + if (Logger is not null) + { + return Logger; + } + + if (ServiceProvider?.GetService() is not { } loggerFactory) + { + return null; + } + + return loggerFactory.CreateLogger(name); + } + + internal override RouterConfig CreateCallbackRouterConfig() + => RouterConfig.From( + Callbacks.OrDefault(), + endpoint => endpoint with + { + BeforeCall = null, // callbacks don't support BeforeCall + Scheduler = endpoint.Scheduler ?? Scheduler + }); +} + +public interface IClientState : IDisposable +{ + Stream? Network { get; } + + bool IsConnected(); + ValueTask Connect(IpcClient client, CancellationToken ct); +} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Config/ClientTransport.cs b/src/UiPath.CoreIpc/Config/ClientTransport.cs new file mode 100644 index 00000000..2e21728a --- /dev/null +++ b/src/UiPath.CoreIpc/Config/ClientTransport.cs @@ -0,0 +1,7 @@ +namespace UiPath.Ipc; + +public abstract record ClientTransport +{ + public abstract IClientState CreateState(); + public abstract void Validate(); +} diff --git a/src/UiPath.CoreIpc/Config/EndpointCollection.cs b/src/UiPath.CoreIpc/Config/EndpointCollection.cs new file mode 100644 index 00000000..e48560ae --- /dev/null +++ b/src/UiPath.CoreIpc/Config/EndpointCollection.cs @@ -0,0 +1,21 @@ +using System.Collections; + +namespace UiPath.Ipc; + +public class EndpointCollection : IEnumerable, IEnumerable +{ + internal readonly Dictionary Endpoints = new(); + + public void Add(Type type) => Add(type, instance: null); + public void Add(Type contractType, object? instance) => Add(new EndpointSettings(contractType, instance)); + public void Add(EndpointSettings endpointSettings) + { + if (endpointSettings is null) throw new ArgumentNullException(nameof(endpointSettings)); + endpointSettings.Validate(); + + Endpoints[endpointSettings.Service.Type] = endpointSettings; + } + public IEnumerator GetEnumerator() => Endpoints.Values.GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); +} diff --git a/src/UiPath.CoreIpc/Config/EndpointConfig.cs b/src/UiPath.CoreIpc/Config/EndpointConfig.cs new file mode 100644 index 00000000..4a06504a --- /dev/null +++ b/src/UiPath.CoreIpc/Config/EndpointConfig.cs @@ -0,0 +1,10 @@ +namespace UiPath.Ipc; + +public abstract record EndpointConfig +{ + public TimeSpan RequestTimeout { get; init; } = Timeout.InfiniteTimeSpan; + + internal virtual RouterConfig CreateRouterConfig(IpcServer server) => throw new NotSupportedException(); + + internal virtual RouterConfig CreateCallbackRouterConfig() => throw new NotSupportedException(); +} diff --git a/src/UiPath.CoreIpc/Config/IListenerConfig.cs b/src/UiPath.CoreIpc/Config/IListenerConfig.cs new file mode 100644 index 00000000..a9513957 --- /dev/null +++ b/src/UiPath.CoreIpc/Config/IListenerConfig.cs @@ -0,0 +1,12 @@ +namespace UiPath.Ipc.Extensibility; + +public interface IListenerConfig + where TSelf : ListenerConfig, IListenerConfig + where TListenerState : IAsyncDisposable +{ + TListenerState CreateListenerState(IpcServer server); + TConnectionState CreateConnectionState(IpcServer server, TListenerState listenerState); + ValueTask AwaitConnection(TListenerState listenerState, TConnectionState connectionState, CancellationToken ct); + IEnumerable Validate(); +} + diff --git a/src/UiPath.CoreIpc/Config/IServiceClientConfig.cs b/src/UiPath.CoreIpc/Config/IServiceClientConfig.cs new file mode 100644 index 00000000..95d3a29e --- /dev/null +++ b/src/UiPath.CoreIpc/Config/IServiceClientConfig.cs @@ -0,0 +1,11 @@ +namespace UiPath.Ipc; + +internal interface IServiceClientConfig +{ + TimeSpan RequestTimeout { get; } + BeforeConnectHandler? BeforeConnect { get; } + BeforeCallHandler? BeforeCall { get; } + ILogger? Logger { get; } + ISerializer? Serializer { get; } + string DebugName { get; } +} diff --git a/src/UiPath.CoreIpc/Config/IpcClient.cs b/src/UiPath.CoreIpc/Config/IpcClient.cs new file mode 100644 index 00000000..0c1735ef --- /dev/null +++ b/src/UiPath.CoreIpc/Config/IpcClient.cs @@ -0,0 +1,34 @@ +namespace UiPath.Ipc; + +public sealed class IpcClient +{ + public required ClientConfig Config { get; init; } + public required ClientTransport Transport { get; init; } + + private readonly ConcurrentDictionary _clients = new(); + private ServiceClient GetServiceClient(Type proxyType) + { + return _clients.GetOrAdd(proxyType, Create); + + ServiceClient Create(Type proxyType) => new ServiceClientProper(this, proxyType); + } + public TProxy GetProxy() where TProxy : class + => GetServiceClient(typeof(TProxy)).GetProxy(); + + internal void Validate() + { + if (Config is null) + { + throw new InvalidOperationException($"{Config} is required."); + } + if (Transport is null) + { + throw new InvalidOperationException($"{Transport} is required."); + } + + Config.Validate(); + Transport.Validate(); + + Config.DebugName ??= Transport.ToString(); + } +} diff --git a/src/UiPath.CoreIpc/Config/IpcServer.cs b/src/UiPath.CoreIpc/Config/IpcServer.cs new file mode 100644 index 00000000..938fa8c3 --- /dev/null +++ b/src/UiPath.CoreIpc/Config/IpcServer.cs @@ -0,0 +1,92 @@ +namespace UiPath.Ipc; + +public sealed class IpcServer : IAsyncDisposable +{ + public required IServiceProvider ServiceProvider { get; init; } + public required EndpointCollection Endpoints { get; init; } + public required IReadOnlyList Listeners { get; init; } + public TaskScheduler? Scheduler { get; init; } + + private readonly Lazy> _started; + private readonly TaskCompletionSource _tcsStopped = new(); + + public IpcServer() => _started = new(StartCore); + + public void Start() + { + if (!IsValid(out var errors)) + { + throw new InvalidOperationException($"ValidationErrors:\r\n{string.Join("\r\n", errors)}"); + } + + _ = _started.Value; + } + public Task WaitForStart() => _started.Value; + public Task WaitForStop() => _tcsStopped.Task; + + private async Task StartCore() + { + if (!IsValid(out _)) + { + return null; + } + + var disposables = new StopAdapter(this); + try + { + foreach (var listenerConfig in Listeners) + { + disposables.Add(Listener.Create(this, listenerConfig)); + } + return disposables; + } + catch (Exception ex) + { + Trace.TraceError($"Failed to start server. Ex: {ex}"); + disposables.SetException(ex); + await disposables.DisposeAsync(); + throw; + } + } + + private bool IsValid(out IReadOnlyList errors) + { + errors = Listeners.SelectMany(PrefixErrors).ToArray(); + return errors is { Count: 0 }; + + static IEnumerable PrefixErrors(ListenerConfig config) + => config.Validate().Select(error => $"{config.GetType().Name}: {error}"); + } + + public async ValueTask DisposeAsync() + => await ((await _started.Value)?.DisposeAsync() ?? default); + + private sealed class StopAdapter : IAsyncDisposable + { + private readonly List _items = new(); + private readonly IpcServer _server; + private Exception? _exception; + + public StopAdapter(IpcServer server) => _server = server; + + public void Add(IAsyncDisposable item) => _items.Add(item); + + public void SetException(Exception ex) => _exception = ex; + + public async ValueTask DisposeAsync() + { + foreach (var item in _items) + { + await item.DisposeAsync(); + } + + if (_exception is not null) + { + _server._tcsStopped.TrySetException(_exception); + return; + } + + _server._tcsStopped.TrySetResult(null); + } + } +} diff --git a/src/UiPath.CoreIpc/Config/ListenerConfig.cs b/src/UiPath.CoreIpc/Config/ListenerConfig.cs new file mode 100644 index 00000000..2c41dcc6 --- /dev/null +++ b/src/UiPath.CoreIpc/Config/ListenerConfig.cs @@ -0,0 +1,31 @@ +using System.Security.Cryptography.X509Certificates; + +namespace UiPath.Ipc; + +public abstract record ListenerConfig : EndpointConfig, IServiceClientConfig +{ + public int ConcurrentAccepts { get; init; } = 5; + public byte MaxReceivedMessageSizeInMegabytes { get; init; } = 2; + public X509Certificate? Certificate { get; init; } + internal int MaxMessageSize => MaxReceivedMessageSizeInMegabytes * 1024 * 1024; + + internal IEnumerable Validate() => Enumerable.Empty(); + + internal override RouterConfig CreateRouterConfig(IpcServer server) + => RouterConfig.From( + server.Endpoints, + endpoint => endpoint with + { + Scheduler = endpoint.Scheduler ?? server.Scheduler + }); + + #region IServiceClientConfig + /// Do not implement explicitly, as it must be implicitly implemented by . + + BeforeConnectHandler? IServiceClientConfig.BeforeConnect => null; + BeforeCallHandler? IServiceClientConfig.BeforeCall => null; + ILogger? IServiceClientConfig.Logger => null; + ISerializer? IServiceClientConfig.Serializer => null!; + string IServiceClientConfig.DebugName => $"CallbackClient for {this}"; + #endregion +} diff --git a/src/UiPath.CoreIpc/Connection.cs b/src/UiPath.CoreIpc/Connection.cs index e4404147..20fde1b4 100644 --- a/src/UiPath.CoreIpc/Connection.cs +++ b/src/UiPath.CoreIpc/Connection.cs @@ -1,6 +1,11 @@ -namespace UiPath.CoreIpc; +using System.Diagnostics.CodeAnalysis; +using System.IO.Pipes; + +namespace UiPath.Ipc; + using static TaskCompletionPool; using static IOHelpers; + public sealed class Connection : IDisposable { private static readonly IOException ClosedException = new("Connection closed."); @@ -12,34 +17,39 @@ public sealed class Connection : IDisposable private readonly WaitCallback _onResponse; private readonly WaitCallback _onRequest; private readonly WaitCallback _onCancellation; - private readonly Action _cancelRequest; + private readonly Action _cancelRequest; private readonly byte[] _buffer = new byte[sizeof(long)]; private readonly NestedStream _nestedStream; - public Connection(Stream network, ISerializer serializer, ILogger logger, string name, int maxMessageSize = int.MaxValue) + public Stream Network { get; } + public ILogger? Logger { get; internal set; } + + [MemberNotNullWhen(returnValue: true, nameof(Logger))] + public bool LogEnabled => Logger.Enabled(); + + public string DebugName { get; } + public ISerializer? Serializer { get; } + + public Connection(Stream network, ISerializer? serializer, ILogger? logger, string debugName, int maxMessageSize = int.MaxValue) { Network = network; _nestedStream = new NestedStream(network, 0); Serializer = serializer; Logger = logger; - Name = $"{name} {GetHashCode()}"; + DebugName = $"{debugName} {GetHashCode()}"; _maxMessageSize = maxMessageSize; _receiveLoop = new(ReceiveLoop); - _onResponse = response => OnResponseReceived((Response)response); - _onRequest = request => OnRequestReceived((Request)request); - _onCancellation = requestId => OnCancellationReceived((string)requestId); - _cancelRequest = requestId => CancelRequest((string)requestId); + _onResponse = response => OnResponseReceived((Response)response!); + _onRequest = request => OnRequestReceived((Request)request!); + _onCancellation = requestId => OnCancellationReceived((string)requestId!); + _cancelRequest = requestId => CancelRequest((string)requestId!); } - public Stream Network { get; } - public ILogger Logger { get; internal set; } - public bool LogEnabled => Logger.Enabled(); - public string Name { get; } - public ISerializer Serializer { get; } - public override string ToString() => Name; + + public override string ToString() => DebugName; public string NewRequestId() => Interlocked.Increment(ref _requestCounter).ToString(); public Task Listen() => _receiveLoop.Value; internal event Func RequestReceived; internal event Action CancellationReceived; - public event EventHandler Closed; + public event EventHandler? Closed; #if !NET461 [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))] #endif @@ -75,7 +85,6 @@ internal async ValueTask RemoteCall(Request request, CancellationToken } internal ValueTask Send(Request request, CancellationToken token) { - Debug.Assert(request.Parameters == null || request.ObjectParameters == null); var uploadStream = request.UploadStream; var requestBytes = SerializeToStream(request); return uploadStream == null ? @@ -95,7 +104,6 @@ Task CancelServerCall(string requestId) => } internal ValueTask Send(Response response, CancellationToken cancellationToken) { - Debug.Assert(response.Data == null || response.ObjectData == null); var responseBytes = SerializeToStream(response); return response.DownloadStream == null ? SendMessage(MessageType.Response, responseBytes, cancellationToken) : @@ -120,7 +128,7 @@ private async ValueTask SendStream(MessageType messageType, Stream data, Stream CancellationTokenRegistration tokenRegistration = default; try { - tokenRegistration = cancellationToken.UnsafeRegister(state => ((Connection)state).Dispose(), this); + tokenRegistration = cancellationToken.UnsafeRegister(state => ((Connection)state!).Dispose(), this); await Network.WriteMessage(messageType, data, cancellationToken); await Network.WriteBuffer(BitConverter.GetBytes(userStream.Length), cancellationToken); const int DefaultCopyBufferSize = 81920; @@ -183,14 +191,32 @@ private async ValueTask ReadBuffer(int length) { int offset = 0; int toRead = length; + do { - var read = await Network.ReadAsync( + int read; + try + { + read = await Network.ReadAsync( #if NET461 - _buffer, offset, toRead); + _buffer, offset, toRead); #else - _buffer.AsMemory(offset, toRead)); + _buffer.AsMemory(offset, toRead)); #endif + } + catch (OperationCanceledException ex) when (Network is PipeStream) + { + // Originally we decided to throw this exception the 2nd time we caught it, but later it was discovered that the NodeJS runtime continuosly retries. + + // In some Windows client environments, OperationCanceledException is sporadically thrown on named pipe ReadAsync operation (ERROR_OPERATION_ABORTED on overlapped ReadFile) + // The cause has not yet been discovered(os specific, antiviruses, monitoring application), and we have implemented a retry system + // ROBO-3083 + + Logger.LogException(ex, $"Retrying ReadAsync for {Network.GetType()}"); + await Task.Delay(10); //Without this delay, on net framework can get OperationCanceledException on the second ReadAsync call + continue; + } + if (read == 0) { return false; @@ -218,12 +244,12 @@ private async Task ReceiveLoop() } } catch (Exception ex) - { - Logger.LogException(ex, $"{nameof(ReceiveLoop)} {Name}"); + { + Logger.LogException(ex, $"{nameof(ReceiveLoop)} {DebugName}"); } if (LogEnabled) { - Log($"{nameof(ReceiveLoop)} {Name} finished."); + Log($"{nameof(ReceiveLoop)} {DebugName} finished."); } Dispose(); return; @@ -236,13 +262,13 @@ async ValueTask HandleMessage() switch (messageType) { case MessageType.Response: - RunAsync(_onResponse, await Deserialize()); + RunAsync(_onResponse, (await Deserialize())!); break; case MessageType.Request: - RunAsync(_onRequest, await Deserialize()); + RunAsync(_onRequest, (await Deserialize())!); break; case MessageType.CancellationRequest: - RunAsync(_onCancellation, (await Deserialize()).RequestId); + RunAsync(_onCancellation, (await Deserialize())!.RequestId); break; case MessageType.UploadRequest: await OnUploadRequest(); @@ -262,7 +288,7 @@ async ValueTask HandleMessage() static void RunAsync(WaitCallback callback, object state) => ThreadPool.UnsafeQueueUserWorkItem(callback, state); private async Task OnDownloadResponse() { - var response = await Deserialize(); + var response = (await Deserialize())!; await EnterStreamMode(); var streamDisposed = new TaskCompletionSource(); EventHandler disposedHandler = delegate { streamDisposed.TrySetResult(true); }; @@ -280,7 +306,7 @@ private async Task OnDownloadResponse() } private async Task OnUploadRequest() { - var request = await Deserialize(); + var request = (await Deserialize())!; await EnterStreamMode(); using (_nestedStream) { @@ -303,7 +329,7 @@ private MemoryStream SerializeToStream(object value) try { stream.Position = HeaderLength; - Serializer.Serialize(value, stream); + Serializer.OrDefault().Serialize(value, stream); return stream; } catch @@ -312,19 +338,19 @@ private MemoryStream SerializeToStream(object value) throw; } } - private ValueTask Deserialize() => Serializer.DeserializeAsync(_nestedStream); + private ValueTask Deserialize() => Serializer.OrDefault().DeserializeAsync(_nestedStream); private void OnCancellationReceived(string requestId) { try { CancellationReceived(requestId); } - catch(Exception ex) + catch (Exception ex) { Log(ex); } } - private void Log(Exception ex) => Logger.LogException(ex, Name); + private void Log(Exception ex) => Logger.LogException(ex, DebugName); private ValueTask OnRequestReceived(Request request) { try @@ -343,7 +369,7 @@ private void OnResponseReceived(Response response) { if (LogEnabled) { - Log($"Received response for request {response.RequestId} {Name}."); + Log($"Received response for request {response.RequestId} {DebugName}."); } if (_requests.TryRemove(response.RequestId, out var completionSource)) { @@ -355,5 +381,14 @@ private void OnResponseReceived(Response response) Log(ex); } } - public void Log(string message) => Logger.LogInformation(message); + + private void Log(string message) + { + if (Logger is null) + { + throw new InvalidOperationException(); + } + + Logger.LogInformation(message); + } } \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Dtos.cs b/src/UiPath.CoreIpc/Dtos.cs index cbf278ba..a5cb95e9 100644 --- a/src/UiPath.CoreIpc/Dtos.cs +++ b/src/UiPath.CoreIpc/Dtos.cs @@ -1,16 +1,17 @@ -using System.Text; +using System.Diagnostics.CodeAnalysis; +using System.Text; using Newtonsoft.Json; -namespace UiPath.CoreIpc; + +namespace UiPath.Ipc; + public class Message { - internal bool ObjectParameters { get; set; } - internal Type CallbackContract { get; set; } [JsonIgnore] public IClient Client { get; set; } [JsonIgnore] public TimeSpan RequestTimeout { get; set; } public TCallbackInterface GetCallback() where TCallbackInterface : class => - Client.GetCallback(CallbackContract, ObjectParameters); + Client.GetCallback(); public void ImpersonateClient(Action action) => Client.Impersonate(action); } public class Message : Message @@ -18,34 +19,50 @@ public class Message : Message public Message(TPayload payload) => Payload = payload; public TPayload Payload { get; } } -record Request(string Endpoint, string Id, string MethodName, string[] Parameters, object[] ObjectParameters, double TimeoutInSeconds) +internal record Request(string Endpoint, string Id, string MethodName, string[] Parameters, double TimeoutInSeconds) { - internal Stream UploadStream { get; set; } + [JsonIgnore] + public Stream? UploadStream { get; set; } + public override string ToString() => $"{Endpoint} {MethodName} {Id}."; - internal bool HasObjectParameters => ObjectParameters is not null; - internal TimeSpan GetTimeout(TimeSpan defaultTimeout) => TimeoutInSeconds == 0 ? defaultTimeout : TimeSpan.FromSeconds(TimeoutInSeconds); + + public TimeSpan GetTimeout(TimeSpan defaultTimeout) => TimeoutInSeconds == 0 ? defaultTimeout : TimeSpan.FromSeconds(TimeoutInSeconds); } record CancellationRequest(string RequestId); -record Response(string RequestId, string Data = null, object ObjectData = null, Error Error = null) + +internal record Response(string RequestId, string? Data = null, Error? Error = null) { - internal Stream DownloadStream { get; set; } + [JsonIgnore] + public Stream? DownloadStream { get; set; } + public static Response Fail(Request request, Exception ex) => new(request.Id, Error: ex.ToError()); public static Response Success(Request request, string data) => new(request.Id, data); public static Response Success(Request request, Stream downloadStream) => new(request.Id) { DownloadStream = downloadStream }; - public TResult Deserialize(ISerializer serializer, bool objectParameters) - { + public TResult Deserialize(ISerializer? serializer) + { if (Error != null) { throw new RemoteException(Error); } - return (TResult)(DownloadStream ?? (objectParameters ? - serializer.Deserialize(ObjectData, typeof(TResult)) : serializer.Deserialize(Data ?? "", typeof(TResult)))); + + return (TResult)(DownloadStream ?? serializer.OrDefault().Deserialize(Data ?? "", typeof(TResult)))!; } } [Serializable] -public record Error(string Message, string StackTrace, string Type, Error InnerError) +public record Error(string Message, string StackTrace, string Type, Error? InnerError) { + [return: NotNullIfNotNull("exception")] + public static Error? FromException(Exception? exception) + => exception is null + ? null + : new( + Message: exception.Message, + StackTrace: exception.StackTrace ?? exception.GetBaseException().StackTrace!, + Type: GetExceptionType(exception), + InnerError: FromException(exception.InnerException)); public override string ToString() => new RemoteException(this).ToString(); + + private static string GetExceptionType(Exception exception) => (exception as RemoteException)?.Type ?? exception.GetType().FullName!; } [Serializable] public class RemoteException : Exception @@ -57,7 +74,7 @@ public class RemoteException : Exception } public string Type { get; } public override string StackTrace { get; } - public new RemoteException InnerException => (RemoteException)base.InnerException; + public new RemoteException? InnerException => base.InnerException as RemoteException; public override string ToString() { var result = new StringBuilder(); @@ -81,4 +98,4 @@ private void GatherInnerExceptions(StringBuilder result) } public bool Is() where TException : Exception => Type == typeof(TException).FullName; } -enum MessageType : byte { Request, Response, CancellationRequest, UploadRequest, DownloadResponse } \ No newline at end of file +internal enum MessageType : byte { Request, Response, CancellationRequest, UploadRequest, DownloadResponse } \ No newline at end of file diff --git a/src/UiPath.CoreIpc/EndpointNotFoundException.cs b/src/UiPath.CoreIpc/EndpointNotFoundException.cs new file mode 100644 index 00000000..037e9fc1 --- /dev/null +++ b/src/UiPath.CoreIpc/EndpointNotFoundException.cs @@ -0,0 +1,17 @@ +namespace UiPath.Ipc; + +[Serializable] +public sealed class EndpointNotFoundException : ArgumentOutOfRangeException +{ + public string ServerDebugName { get; } + public string EndpointName { get; } + + public EndpointNotFoundException(string paramName, string serverDebugName, string endpointName) + : base(paramName, FormatMessage(serverDebugName, endpointName)) + { + ServerDebugName = serverDebugName; + EndpointName = endpointName; + } + + internal static string FormatMessage(string serverDebugName, string endpointName) => $"Endpoint not found. Server was \"{serverDebugName}\". Endpoint was \"{endpointName}\"."; +} diff --git a/src/UiPath.CoreIpc/GlobalSuppressions.cs b/src/UiPath.CoreIpc/GlobalSuppressions.cs index cee98987..ef17d024 100644 --- a/src/UiPath.CoreIpc/GlobalSuppressions.cs +++ b/src/UiPath.CoreIpc/GlobalSuppressions.cs @@ -6,9 +6,3 @@ [assembly: SuppressMessage("Performance", "HAA0505:Initializer reference type allocation", Scope = "module")] [assembly: SuppressMessage("Performance", "HAA0502:Explicit new reference type allocation", Scope = "module")] [assembly: SuppressMessage("Performance", "HAA0501:Explicit new array type allocation", Scope = "module")] -#if NET461 -namespace System.Runtime.CompilerServices; -internal static class IsExternalInit -{ -} -#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/GlobalUsings.cs b/src/UiPath.CoreIpc/GlobalUsings.cs new file mode 100644 index 00000000..ab295693 --- /dev/null +++ b/src/UiPath.CoreIpc/GlobalUsings.cs @@ -0,0 +1,7 @@ +global using UiPath.Ipc.Extensibility; +global using BeforeConnectHandler = System.Func; +global using BeforeCallHandler = System.Func; +global using InvokeDelegate = System.Func; +global using Accept = System.Func>; +global using ContractToSettingsMap = System.Collections.Generic.Dictionary; +global using AccessControlDelegate = System.Action; diff --git a/src/UiPath.CoreIpc/Helpers/DefaultsExtensions.cs b/src/UiPath.CoreIpc/Helpers/DefaultsExtensions.cs new file mode 100644 index 00000000..9752811d --- /dev/null +++ b/src/UiPath.CoreIpc/Helpers/DefaultsExtensions.cs @@ -0,0 +1,28 @@ +using Microsoft.Extensions.Logging.Abstractions; + +namespace UiPath.Ipc; + +internal static class DefaultsExtensions +{ + public static ISerializer OrDefault(this ISerializer? serializer) => serializer ?? IpcJsonSerializer.Instance; + public static ILoggerFactory OrDefault(this ILoggerFactory? loggerFactory) => loggerFactory ?? NullLoggerFactory.Instance; + public static ILogger OrDefault(this ILogger? logger) => logger ?? NullLogger.Instance; + public static BeforeCallHandler OrDefault(this BeforeCallHandler? beforeCallHandler) => beforeCallHandler ?? DefaultBeforeCallHandler; + public static TaskScheduler OrDefault(this TaskScheduler? scheduler) => scheduler ?? TaskScheduler.Default; + public static ContractToSettingsMap OrDefault(this ContractToSettingsMap? map) => map ?? EmptyContractToSettingsMap; + public static EndpointCollection OrDefault(this EndpointCollection? endpoints) => endpoints ?? new(); + + public static Func? MaybeCreateServiceFactory(this IServiceProvider? serviceProvider) where T : class + { + if (serviceProvider is null) + { + return null; + } + + return serviceProvider.GetRequiredService; + } + + private static readonly BeforeCallHandler DefaultBeforeCallHandler = (_, _) => Task.CompletedTask; + + private static readonly ContractToSettingsMap EmptyContractToSettingsMap = new(); +} diff --git a/src/UiPath.CoreIpc/Helpers.cs b/src/UiPath.CoreIpc/Helpers/Helpers.cs similarity index 76% rename from src/UiPath.CoreIpc/Helpers.cs rename to src/UiPath.CoreIpc/Helpers/Helpers.cs index 58c39029..cd7bd1cd 100644 --- a/src/UiPath.CoreIpc/Helpers.cs +++ b/src/UiPath.CoreIpc/Helpers/Helpers.cs @@ -1,31 +1,24 @@ using Microsoft.IO; using System.Collections.ObjectModel; using System.IO.Pipes; -using System.Net; -using System.Net.Sockets; using System.Runtime.InteropServices; using System.Security.AccessControl; using System.Security.Principal; -namespace UiPath.CoreIpc; + +namespace UiPath.Ipc; + using static CancellationTokenSourcePool; + public static class Helpers { - public const BindingFlags InstanceFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly; -#if NET461 - public static CancellationTokenRegistration UnsafeRegister(this CancellationToken token, Action callback, object state) => token.Register(callback, state); - public static async Task ConnectAsync(this TcpClient tcpClient, IPAddress address, int port, CancellationToken cancellationToken) - { - using var token = cancellationToken.Register(state => ((TcpClient)state).Dispose(), tcpClient); - await tcpClient.ConnectAsync(address, port); - } -#endif - public static Error ToError(this Exception ex) => new(ex.Message, ex.StackTrace ?? ex.GetBaseException().StackTrace, GetExceptionType(ex), ex.InnerException?.ToError()); - private static string GetExceptionType(Exception exception) => (exception as RemoteException)?.Type ?? exception.GetType().FullName; - public static bool Enabled(this ILogger logger) => logger != null && logger.IsEnabled(LogLevel.Information); + internal const BindingFlags InstanceFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly; + internal static Error ToError(this Exception ex) => new(ex.Message, ex.StackTrace ?? ex.GetBaseException().StackTrace!, GetExceptionType(ex), ex.InnerException?.ToError()); + private static string GetExceptionType(Exception exception) => (exception as RemoteException)?.Type ?? exception.GetType().FullName!; + internal static bool Enabled(this ILogger? logger, LogLevel logLevel = LogLevel.Information) => logger is not null && logger.IsEnabled(logLevel); [Conditional("DEBUG")] - public static void AssertDisposed(this SemaphoreSlim semaphore) => semaphore.AssertFieldNull("m_waitHandle"); + internal static void AssertDisposed(this SemaphoreSlim semaphore) => semaphore.AssertFieldNull("m_waitHandle"); [Conditional("DEBUG")] - public static void AssertDisposed(this CancellationTokenSource cts) + internal static void AssertDisposed(this CancellationTokenSource cts) { #if NET461 cts.AssertFieldNull("m_kernelEvent"); @@ -37,13 +30,12 @@ public static void AssertDisposed(this CancellationTokenSource cts) } [Conditional("DEBUG")] static void AssertFieldNull(this object obj, string field) => - Debug.Assert(obj.GetType().GetField(field, BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj) == null); - public static TDelegate MakeGenericDelegate(this MethodInfo genericMethod, Type genericArgument) where TDelegate : Delegate => + Debug.Assert(obj.GetType().GetField(field, BindingFlags.Instance | BindingFlags.NonPublic)!.GetValue(obj) is null); + internal static TDelegate MakeGenericDelegate(this MethodInfo genericMethod, Type genericArgument) where TDelegate : Delegate => (TDelegate)genericMethod.MakeGenericMethod(genericArgument).CreateDelegate(typeof(TDelegate)); - public static MethodInfo GetStaticMethod(this Type type, string name) => type.GetMethod(name, BindingFlags.Static | BindingFlags.NonPublic); - public static MethodInfo GetInterfaceMethod(this Type type, string name) + internal static MethodInfo GetInterfaceMethod(this Type type, string name) { - var method = type.GetMethod(name, InstanceFlags) ?? + var method = type.GetMethod(name, InstanceFlags) ?? type.GetInterfaces().Select(t => t.GetMethod(name, InstanceFlags)).FirstOrDefault(m => m != null) ?? throw new ArgumentOutOfRangeException(nameof(name), name, $"Method '{name}' not found in interface '{type}'."); if (method.IsGenericMethod) @@ -52,28 +44,38 @@ public static MethodInfo GetInterfaceMethod(this Type type, string name) } return method; } - public static IEnumerable GetInterfaceMethods(this Type type) => + internal static IEnumerable GetInterfaceMethods(this Type type) => type.GetMethods().Concat(type.GetInterfaces().SelectMany(i => i.GetMethods())); - public static object GetDefaultValue(this ParameterInfo parameter) => parameter switch + internal static object? GetDefaultValue(this ParameterInfo parameter) => parameter switch { { HasDefaultValue: false } => null, { ParameterType: { IsValueType: true }, DefaultValue: null } => Activator.CreateInstance(parameter.ParameterType), _ => parameter.DefaultValue }; - public static ReadOnlyDictionary ToReadOnlyDictionary(this IDictionary dictionary) => new(dictionary); - public static void LogException(this ILogger logger, Exception ex, object tag) + internal static ReadOnlyDictionary ToReadOnlyDictionary(this IDictionary dictionary) where TKey : notnull => new(dictionary); + internal static void LogException(this ILogger? logger, Exception ex, object tag) { var message = $"{tag} # {ex}"; - if (logger != null) + + if (logger is not null) { logger.LogError(message); + return; } - else + + Trace.TraceError(message); + } + internal static void LogException(this Task task, ILogger? logger, object tag) => task.ContinueWith(result => logger.LogException(result.Exception!, tag), TaskContinuationOptions.NotOnRanToCompletion); + + internal static void WaitAndUnwrapException(this Task task) + { + if (task is null) { - Trace.TraceError(message); + throw new ArgumentNullException(nameof(task)); } + + task.GetAwaiter().GetResult(); } - public static void LogException(this Task task, ILogger logger, object tag) => task.ContinueWith(result => logger.LogException(result.Exception, tag), TaskContinuationOptions.NotOnRanToCompletion); } public static class IOHelpers { @@ -81,7 +83,7 @@ public static class IOHelpers private static readonly RecyclableMemoryStreamManager Pool = new(MaxBytes, MaxBytes); internal static MemoryStream GetStream(int size = 0) => Pool.GetStream("IpcMessage", size); internal const int HeaderLength = sizeof(int) + 1; - internal static NamedPipeServerStream NewNamedPipeServerStream(string pipeName, PipeDirection direction, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeOptions options, Func pipeSecurity) + internal static NamedPipeServerStream NewNamedPipeServerStream(string pipeName, PipeDirection direction, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeOptions options, Func pipeSecurity) { #if NET461 return new(pipeName, direction, maxNumberOfServerInstances, transmissionMode, options, inBufferSize: 0, outBufferSize: 0, pipeSecurity()); @@ -120,7 +122,7 @@ public static PipeSecurity AllowCurrentUser(this PipeSecurity pipeSecurity, bool { return pipeSecurity; } - pipeSecurity.Allow(currentIdentity.User, PipeAccessRights.ReadWrite|PipeAccessRights.CreateNewInstance); + pipeSecurity.Allow(currentIdentity.User, PipeAccessRights.ReadWrite | PipeAccessRights.CreateNewInstance); } return pipeSecurity; } @@ -161,26 +163,25 @@ private static async ValueTask WriteMessageCore(this Stream stream, RecyclableMe { using (recyclableStream) { - await recyclableStream.CopyToAsync(stream, 0, cancellationToken); + try + { + await recyclableStream.CopyToAsync(stream, 0, cancellationToken); + } + catch + { + throw; + } } } - internal static Task WriteBuffer(this Stream stream, byte[] buffer, CancellationToken cancellationToken) => + internal static Task WriteBuffer(this Stream stream, byte[] buffer, CancellationToken cancellationToken) => stream.WriteAsync(buffer, 0, buffer.Length, cancellationToken); } -public static class Validator +internal static class Validator { - public static void Validate(ServiceHostBuilder serviceHostBuilder) - { - foreach (var endpointSettings in serviceHostBuilder.Endpoints.Values) - { - endpointSettings.Validate(); - } - } - - public static void Validate(ServiceClientBuilder builder) where TInterface : class where TDerived : ServiceClientBuilder - => Validate(typeof(TInterface), builder.CallbackContract); - public static void Validate(params Type[] contracts) + => Validate(contracts.AsEnumerable()); + + public static void Validate(IEnumerable contracts) { foreach (var contract in contracts.Where(c => c != null)) { @@ -267,26 +268,30 @@ private static void CheckDerivedStream(MethodInfo method, Type type) } } } -public readonly struct TimeoutHelper : IDisposable +internal readonly struct TimeoutHelper : IDisposable { private static readonly Action LinkedTokenCancelDelegate = static s => ((CancellationTokenSource)s).Cancel(); private readonly PooledCancellationTokenSource _timeoutCancellationSource; private readonly CancellationToken _cancellationToken; private readonly CancellationTokenRegistration _linkedRegistration; + public TimeoutHelper(TimeSpan timeout, CancellationToken token) { _timeoutCancellationSource = Rent(); _timeoutCancellationSource.CancelAfter(timeout); _cancellationToken = token; - _linkedRegistration = token.UnsafeRegister(LinkedTokenCancelDelegate, _timeoutCancellationSource); + _linkedRegistration = token.UnsafeRegister(LinkedTokenCancelDelegate!, _timeoutCancellationSource); } + + public static string ComputeTimeoutMessage(string operation) => $"{operation} timed out."; + public Exception CheckTimeout(Exception exception, string message) { if (_timeoutCancellationSource.IsCancellationRequested) { if (!_cancellationToken.IsCancellationRequested) { - return new TimeoutException(message + " timed out.", exception); + return new TimeoutException(ComputeTimeoutMessage(message), exception); } if (exception is not TaskCanceledException) { diff --git a/src/UiPath.CoreIpc/NestedStream.cs b/src/UiPath.CoreIpc/Helpers/NestedStream.cs similarity index 98% rename from src/UiPath.CoreIpc/NestedStream.cs rename to src/UiPath.CoreIpc/Helpers/NestedStream.cs index fdc40877..2e69166e 100644 --- a/src/UiPath.CoreIpc/NestedStream.cs +++ b/src/UiPath.CoreIpc/Helpers/NestedStream.cs @@ -1,10 +1,10 @@ -namespace UiPath.CoreIpc; +namespace UiPath.Ipc; /// /// A stream that allows for reading from another stream up to a given number of bytes. /// https://github.com/AArnott/Nerdbank.Streams/blob/3303c541c29b979f61c86c3c2ed5c0e7372d7a55/src/Nerdbank.Streams/NestedStream.cs#L18 /// -public class NestedStream : Stream +internal class NestedStream : Stream { /// /// The stream to read from. diff --git a/src/UiPath.CoreIpc/Helpers/Router.cs b/src/UiPath.CoreIpc/Helpers/Router.cs new file mode 100644 index 00000000..ff3d25a6 --- /dev/null +++ b/src/UiPath.CoreIpc/Helpers/Router.cs @@ -0,0 +1,140 @@ +namespace UiPath.Ipc; + +internal readonly record struct RouterConfig(IReadOnlyDictionary Endpoints) +{ + public static RouterConfig From(EndpointCollection endpoints, Func transform) + { + ContractToSettingsMap nameToEndpoint = []; + + foreach (var endpoint in endpoints) + { + var newEndpoint = transform(endpoint); + foreach (var iface in endpoint.Service.Type.GetInterfaces().Prepend(endpoint.Service.Type)) + { + nameToEndpoint[iface.Name] = newEndpoint; + } + } + + return new(nameToEndpoint); + } +} + +internal readonly struct Router +{ + private readonly RouterConfig? _config; // nullable for the case when the constructor is bypassed + private readonly IServiceProvider? _serviceProvider; + + public Router(RouterConfig config, IServiceProvider? serviceProvider) + { + _config = config; + _serviceProvider = serviceProvider; + } + + public bool TryResolve(string endpoint, out Route route) + { + if (_config is not { } config) /// in case was allocated as default(Router), bypassing the constructor + { + throw new InvalidOperationException(); + } + + if (config.Endpoints.TryGetValue(endpoint, out var endpointSettings)) + { + route = Route.From(_serviceProvider, endpointSettings); + return true; + } + + route = default; + return false; + } +} + +internal abstract record ServiceFactory +{ + public required Type Type { get; init; } + + public abstract IDisposable? Get(out object service); + + public virtual ServiceFactory WithProvider(IServiceProvider? serviceProvider) => this; + + internal virtual object? MaybeGetInstance() => null; + internal virtual IServiceProvider? MaybeGetServiceProvider() => null; + + public sealed record Injected : ServiceFactory + { + public required IServiceProvider ServiceProvider { get; init; } + + internal override IServiceProvider? MaybeGetServiceProvider() => ServiceProvider; + + public override IDisposable? Get(out object service) + { + var scope = ServiceProvider.CreateScope(); + service = scope.ServiceProvider.GetRequiredService(Type); + return scope; + } + + public override ServiceFactory WithProvider(IServiceProvider? serviceProvider) + { + if (serviceProvider is null) + { + throw new InvalidOperationException(); + } + + return this with { ServiceProvider = serviceProvider }; + } + } + + public sealed record Instance : ServiceFactory + { + public required object ServiceInstance { get; init; } + + internal override object? MaybeGetInstance() => ServiceInstance; + + public override IDisposable? Get(out object service) + { + service = ServiceInstance; + return null; + } + } + + public sealed record Deferred : ServiceFactory + { + public override IDisposable? Get(out object service) + { + throw new NotSupportedException(); + } + + public override ServiceFactory WithProvider(IServiceProvider? serviceProvider) + { + if (serviceProvider is null) + { + throw new InvalidOperationException(); + } + + return new Injected() + { + Type = Type, + ServiceProvider = serviceProvider + }; + } + } +} + +internal readonly struct Route +{ + public static Route From(IServiceProvider? serviceProvider, EndpointSettings endpointSettings) + => new Route() + { + Service = endpointSettings.Service.WithProvider(serviceProvider), + BeforeCall = endpointSettings.BeforeCall, + Scheduler = endpointSettings.Scheduler.OrDefault(), + LoggerFactory = serviceProvider.MaybeCreateServiceFactory(), + Serializer = serviceProvider.MaybeCreateServiceFactory() + }; + + public required ServiceFactory Service { get; init; } + + public TaskScheduler Scheduler { get; init; } + public BeforeCallHandler? BeforeCall { get; init; } + public Func? LoggerFactory { get; init; } + public Func? Serializer { get; init; } +} diff --git a/src/UiPath.CoreIpc/Helpers/ScopedReaderWriterLock.cs b/src/UiPath.CoreIpc/Helpers/ScopedReaderWriterLock.cs new file mode 100644 index 00000000..6fd5c506 --- /dev/null +++ b/src/UiPath.CoreIpc/Helpers/ScopedReaderWriterLock.cs @@ -0,0 +1,74 @@ +namespace UiPath.Ipc; + +internal sealed class ScopedReaderWriterLock : IDisposable +{ + private readonly ReaderWriterLockSlim _innerLock; + private readonly Adapter _exitRead; + private readonly Adapter _exitUpgradeableRead; + private readonly Adapter _exitWrite; + + public ScopedReaderWriterLock(LockRecursionPolicy policy = LockRecursionPolicy.NoRecursion) + { + _innerLock = new(policy); + _exitRead = new(_innerLock.ExitReadLock); + _exitUpgradeableRead = new(_innerLock.ExitUpgradeableReadLock); + _exitWrite = new(_innerLock.ExitWriteLock); + } + + public void Dispose() => _innerLock.Dispose(); + + public IDisposable EnterReadLock() + { + _innerLock.EnterReadLock(); + return _exitRead; + } + public IDisposable EnterUpgradeableRead() + { + _innerLock.EnterUpgradeableReadLock(); + return _exitUpgradeableRead; + } + public IDisposable EnterWriteLock() + { + _innerLock.EnterWriteLock(); + return _exitWrite; + } + + private sealed class Adapter(Action action) : IDisposable + { + void IDisposable.Dispose() => action(); + } +} + +public sealed class ContextfulLazy +{ + private readonly ScopedReaderWriterLock _lock = new(); + + private bool _haveValue; + private T? _value; + + public T GetValue(Func factory) + { + using (_lock.EnterReadLock()) + { + if (_haveValue) + { + return _value!; + } + } + + using (_lock.EnterUpgradeableRead()) + { + if (_haveValue) + { + return _value!; + } + + using (_lock.EnterWriteLock()) + { + _value = factory(); + _haveValue = true; + return _value; + } + } + } +} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/TaskCompletionPool.cs b/src/UiPath.CoreIpc/Helpers/TaskCompletionPool.cs similarity index 98% rename from src/UiPath.CoreIpc/TaskCompletionPool.cs rename to src/UiPath.CoreIpc/Helpers/TaskCompletionPool.cs index 11f9ece9..f1f971a2 100644 --- a/src/UiPath.CoreIpc/TaskCompletionPool.cs +++ b/src/UiPath.CoreIpc/Helpers/TaskCompletionPool.cs @@ -1,5 +1,5 @@ using System.Threading.Tasks.Sources; -namespace UiPath.CoreIpc; +namespace UiPath.Ipc; internal static class TaskCompletionPool { public static ManualResetValueTaskSource Rent() => ObjectPool.Rent(); diff --git a/src/UiPath.CoreIpc/IpcJsonSerializer.cs b/src/UiPath.CoreIpc/IpcJsonSerializer.cs index 33a9faf5..5534da88 100644 --- a/src/UiPath.CoreIpc/IpcJsonSerializer.cs +++ b/src/UiPath.CoreIpc/IpcJsonSerializer.cs @@ -1,59 +1,62 @@ using Newtonsoft.Json; -using Newtonsoft.Json.Linq; using System.Buffers; using System.Globalization; using System.Text; -namespace UiPath.CoreIpc; + +namespace UiPath.Ipc; public interface ISerializer { - ValueTask DeserializeAsync(Stream json); - object Deserialize(object json, Type type); - void Serialize(object obj, Stream stream); - string Serialize(object obj); - object Deserialize(string json, Type type); + ValueTask DeserializeAsync(Stream json); + void Serialize(object? obj, Stream stream); + string Serialize(object? obj); + object? Deserialize(string json, Type type); } -class IpcJsonSerializer : ISerializer, IArrayPool + +internal class IpcJsonSerializer : ISerializer, IArrayPool { - static readonly JsonSerializer ObjectArgsSerializer = new(){ DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate, NullValueHandling = NullValueHandling.Ignore, - CheckAdditionalContent = true }; - static readonly JsonSerializer StringArgsSerializer = new(){ CheckAdditionalContent = true }; + public static readonly IpcJsonSerializer Instance = new(); + + static readonly JsonSerializer StringArgsSerializer = new() { CheckAdditionalContent = true }; #if !NET461 [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))] #endif - public async ValueTask DeserializeAsync(Stream json) + public async ValueTask DeserializeAsync(Stream json) { using var stream = IOHelpers.GetStream((int)json.Length); await json.CopyToAsync(stream); stream.Position = 0; using var reader = CreateReader(new StreamReader(stream)); - return ObjectArgsSerializer.Deserialize(reader); + return StringArgsSerializer.Deserialize(reader); } - public object Deserialize(object json, Type type) => json switch - { - JToken token => token.ToObject(type, ObjectArgsSerializer), - { } => type.IsAssignableFrom(json.GetType()) ? json : new JValue(json).ToObject(type), - null => null, - }; - public void Serialize(object obj, Stream stream) => Serialize(obj, new StreamWriter(stream), ObjectArgsSerializer); - private void Serialize(object obj, TextWriter streamWriter, JsonSerializer serializer) + public void Serialize(object? obj, Stream stream) => Serialize(obj, new StreamWriter(stream), StringArgsSerializer); + private void Serialize(object? obj, TextWriter streamWriter, JsonSerializer serializer) { using var writer = new JsonTextWriter(streamWriter) { ArrayPool = this, CloseOutput = false }; serializer.Serialize(writer, obj); writer.Flush(); } public char[] Rent(int minimumLength) => ArrayPool.Shared.Rent(minimumLength); - public void Return(char[] array) => ArrayPool.Shared.Return(array); - public string Serialize(object obj) + public void Return(char[]? array) + { + if (array is null) + { + return; + } + + ArrayPool.Shared.Return(array); + } + + public string Serialize(object? obj) { var stringWriter = new StringWriter(new StringBuilder(capacity: 256), CultureInfo.InvariantCulture); Serialize(obj, stringWriter, StringArgsSerializer); return stringWriter.ToString(); } - public object Deserialize(string json, Type type) + public object? Deserialize(string json, Type type) { using var reader = CreateReader(new StringReader(json)); return StringArgsSerializer.Deserialize(reader, type); } - private JsonTextReader CreateReader(TextReader json) => new(json){ ArrayPool = this }; -} \ No newline at end of file + private JsonTextReader CreateReader(TextReader json) => new(json) { ArrayPool = this }; +} diff --git a/src/UiPath.CoreIpc/Logging/LoggingExtensions.cs b/src/UiPath.CoreIpc/Logging/LoggingExtensions.cs new file mode 100644 index 00000000..cc54cf5a --- /dev/null +++ b/src/UiPath.CoreIpc/Logging/LoggingExtensions.cs @@ -0,0 +1,37 @@ +namespace UiPath.Ipc; + +using static LoggingExtensions.Event; + +internal static partial class LoggingExtensions +{ + private const string ServiceClient = "IpcClient"; + + public enum Event + { + ServiceClient = 0, + ServiceClient_Calling = ServiceClient + 1, + ServiceClient_Called = ServiceClient + 2, + ServiceClient_Dispose = ServiceClient + 3, + } + + [LoggerMessage( + EventId = (int)ServiceClient_Calling, + EventName = nameof(ServiceClient_Calling), + Level = LogLevel.Information, + Message = $$"""{{ServiceClient}} calling {methodName} {requestId} {debugName}.""")] + public static partial void ServiceClientCalling(this ILogger logger, string methodName, string requestId, string debugName); + + [LoggerMessage( + EventId = (int)ServiceClient_Called, + EventName = nameof(ServiceClient_Called), + Level = LogLevel.Information, + Message = $$"""{{ServiceClient}} called {methodName} {requestId} {debugName}.""")] + public static partial void ServiceClientCalled(this ILogger logger, string methodName, string requestId, string debugName); + + [LoggerMessage( + EventId = (int)ServiceClient_Dispose, + EventName = nameof(ServiceClient_Dispose), + Level = LogLevel.Information, + Message = $$"""{{ServiceClient}} dispose {debugName}.""")] + public static partial void ServiceClientDispose(this ILogger logger, string debugName); +} diff --git a/src/UiPath.CoreIpc/NamedPipe/NamedPipeClient.cs b/src/UiPath.CoreIpc/NamedPipe/NamedPipeClient.cs deleted file mode 100644 index 61584f39..00000000 --- a/src/UiPath.CoreIpc/NamedPipe/NamedPipeClient.cs +++ /dev/null @@ -1,51 +0,0 @@ -using System.IO.Pipes; -using System.Security.Principal; - -namespace UiPath.CoreIpc.NamedPipe; - -using ConnectionFactory = Func>; -using BeforeCallHandler = Func; - -interface INamedPipeKey : IConnectionKey -{ - string ServerName { get; } - string PipeName { get; } - bool AllowImpersonation { get; } -} - -class NamedPipeClient : ServiceClient, INamedPipeKey where TInterface : class -{ - public NamedPipeClient(string serverName, string pipeName, ISerializer serializer, TimeSpan requestTimeout, bool allowImpersonation, ILogger logger, ConnectionFactory connectionFactory, string sslServer, BeforeCallHandler beforeCall, bool objectParameters, EndpointSettings serviceEndpoint) - : base(serializer, requestTimeout, logger, connectionFactory, sslServer, beforeCall, objectParameters, serviceEndpoint) - { - ServerName = serverName; - PipeName = pipeName; - AllowImpersonation = allowImpersonation; - HashCode = (serverName, pipeName, allowImpersonation, sslServer).GetHashCode(); - } - public override string Name => base.Name ?? PipeName; - public string ServerName { get; } - public string PipeName { get; } - public bool AllowImpersonation { get; } - public override bool Equals(IConnectionKey other) => other == this || (other is INamedPipeKey otherClient && - otherClient.ServerName == ServerName && otherClient.PipeName == PipeName && otherClient.AllowImpersonation == AllowImpersonation && base.Equals(other)); - public override ClientConnection CreateClientConnection() => new NamedPipeClientConnection(this); - class NamedPipeClientConnection : ClientConnection - { - private NamedPipeClientStream _pipe; - public NamedPipeClientConnection(IConnectionKey connectionKey) : base(connectionKey) { } - public override bool Connected => _pipe?.IsConnected is true; - protected override void Dispose(bool disposing) - { - _pipe?.Dispose(); - base.Dispose(disposing); - } - public override async Task Connect(CancellationToken cancellationToken) - { - var key = (INamedPipeKey)ConnectionKey; - _pipe = new(key.ServerName, key.PipeName, PipeDirection.InOut, PipeOptions.Asynchronous, key.AllowImpersonation ? TokenImpersonationLevel.Impersonation : TokenImpersonationLevel.Identification); - await _pipe.ConnectAsync(cancellationToken); - return _pipe; - } - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/NamedPipe/NamedPipeClientBuilder.cs b/src/UiPath.CoreIpc/NamedPipe/NamedPipeClientBuilder.cs deleted file mode 100644 index 5e4b69d4..00000000 --- a/src/UiPath.CoreIpc/NamedPipe/NamedPipeClientBuilder.cs +++ /dev/null @@ -1,53 +0,0 @@ -namespace UiPath.CoreIpc.NamedPipe; - -public abstract class NamedPipeClientBuilderBase : ServiceClientBuilder where TInterface : class where TDerived : ServiceClientBuilder -{ - private readonly string _pipeName; - private string _serverName = "."; - private bool _allowImpersonation; - - protected NamedPipeClientBuilderBase(string pipeName, Type callbackContract = null, IServiceProvider serviceProvider = null) : base(callbackContract, serviceProvider) => _pipeName = pipeName; - - public TDerived ServerName(string serverName) - { - _serverName = serverName; - return this as TDerived; - } - - /// - /// Don't set this if you can connect to less privileged processes. - /// Allow impersonation is false by default to prevent an escalation of privilege attack. - /// If a privileged process connects to a less privileged one and the proxy allows impersonation then the server could impersonate the client's identity. - /// - /// this - public TDerived AllowImpersonation() - { - _allowImpersonation = true; - return this as TDerived; - } - - protected override TInterface BuildCore(EndpointSettings serviceEndpoint) => - new NamedPipeClient(_serverName, _pipeName, _serializer, _requestTimeout, _allowImpersonation, _logger, _connectionFactory, _sslServer, _beforeCall, _objectParameters, serviceEndpoint).CreateProxy(); -} - -public class NamedPipeClientBuilder : NamedPipeClientBuilderBase, TInterface> where TInterface : class -{ - public NamedPipeClientBuilder(string pipeName) : base(pipeName){} -} - -public class NamedPipeClientBuilder : NamedPipeClientBuilderBase, TInterface> where TInterface : class where TCallbackInterface : class -{ - public NamedPipeClientBuilder(string pipeName, IServiceProvider serviceProvider) : base(pipeName, typeof(TCallbackInterface), serviceProvider) { } - - public NamedPipeClientBuilder CallbackInstance(TCallbackInterface singleton) - { - _callbackInstance = singleton; - return this; - } - - public NamedPipeClientBuilder TaskScheduler(TaskScheduler taskScheduler) - { - _taskScheduler = taskScheduler; - return this; - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/NamedPipe/NamedPipeListener.cs b/src/UiPath.CoreIpc/NamedPipe/NamedPipeListener.cs deleted file mode 100644 index 5f408757..00000000 --- a/src/UiPath.CoreIpc/NamedPipe/NamedPipeListener.cs +++ /dev/null @@ -1,55 +0,0 @@ -using System.IO.Pipes; -using System.Security.Principal; - -namespace UiPath.CoreIpc.NamedPipe; - -public class NamedPipeSettings : ListenerSettings -{ - public NamedPipeSettings(string pipeName) : base(pipeName) { } - public Action AccessControl { get; set; } -} -class NamedPipeListener : Listener -{ - public NamedPipeListener(NamedPipeSettings settings) : base(settings) { } - protected override ServerConnection CreateServerConnection() => new NamedPipeServerConnection(this); - class NamedPipeServerConnection : ServerConnection - { - readonly NamedPipeServerStream _server; - public NamedPipeServerConnection(Listener listener) : base(listener) - { - _server = IOHelpers.NewNamedPipeServerStream(Settings.Name, PipeDirection.InOut, NamedPipeServerStream.MaxAllowedServerInstances, - PipeTransmissionMode.Byte, PipeOptions.Asynchronous, GetPipeSecurity); - } - public override async Task AcceptClient(CancellationToken cancellationToken) - { - await _server.WaitForConnectionAsync(cancellationToken); - return _server; - } - public override void Impersonate(Action action) => _server.RunAsClient(()=>action()); - protected override void Dispose(bool disposing) - { - _server.Dispose(); - base.Dispose(disposing); - } - PipeSecurity GetPipeSecurity() - { - var setAccessControl = ((NamedPipeSettings)Settings).AccessControl; - if (setAccessControl == null) - { - return null; - } - var pipeSecurity = new PipeSecurity(); - FullControlFor(WellKnownSidType.BuiltinAdministratorsSid); - FullControlFor(WellKnownSidType.LocalSystemSid); - pipeSecurity.AllowCurrentUser(onlyNonAdmin: true); - setAccessControl(pipeSecurity); - return pipeSecurity; - void FullControlFor(WellKnownSidType sid) => pipeSecurity.Allow(sid, PipeAccessRights.FullControl); - } - } -} -public static class NamedPipeServiceExtensions -{ - public static ServiceHostBuilder UseNamedPipes(this ServiceHostBuilder builder, NamedPipeSettings settings) => - builder.AddListener(new NamedPipeListener(settings)); -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/CallerArgumentExpressionAttribute.cs b/src/UiPath.CoreIpc/Polyfills/CallerArgumentExpressionAttribute.cs new file mode 100644 index 00000000..0032e3dd --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/CallerArgumentExpressionAttribute.cs @@ -0,0 +1,36 @@ +#pragma warning disable + +#if !NET5_0_OR_GREATER + +namespace System.Runtime.CompilerServices; + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; + +// +// Summary: +// Allows capturing of the expressions passed to a method. +[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)] +internal sealed class CallerArgumentExpressionAttribute : Attribute +{ + // + // Summary: + // Initializes a new instance of the System.Runtime.CompilerServices.CallerArgumentExpressionAttribute + // class. + // + // Parameters: + // parameterName: + // The name of the targeted parameter. + public CallerArgumentExpressionAttribute(string parameterName) => ParameterName = parameterName; + + // + // Summary: + // Gets the target parameter name of the CallerArgumentExpression. + // + // Returns: + // The name of the targeted parameter of the CallerArgumentExpression. + public string ParameterName { get; } +} + + +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/CancellationTokenExtensions.cs b/src/UiPath.CoreIpc/Polyfills/CancellationTokenExtensions.cs new file mode 100644 index 00000000..16ef1aa5 --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/CancellationTokenExtensions.cs @@ -0,0 +1,11 @@ +#if NET461 + +namespace System.Threading; + +internal static class CancellationTokenExtensions +{ + public static CancellationTokenRegistration UnsafeRegister(this CancellationToken token, Action callback, object state) + => token.Register(callback, state); +} + +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/CollectionExtensions.cs b/src/UiPath.CoreIpc/Polyfills/CollectionExtensions.cs new file mode 100644 index 00000000..c850d4a9 --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/CollectionExtensions.cs @@ -0,0 +1,19 @@ +#if NETFRAMEWORK + +namespace System.Collections.Generic; + +public static class CollectionExtensions +{ + public static bool TryAdd(this IDictionary dictionary, TKey key, TValue value) + { + if (dictionary.ContainsKey(key)) + { + return false; + } + + dictionary.Add(key, value); + return true; + } +} + +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/CompilerFeatureRequiredAttribute.cs b/src/UiPath.CoreIpc/Polyfills/CompilerFeatureRequiredAttribute.cs new file mode 100644 index 00000000..c40e1129 --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/CompilerFeatureRequiredAttribute.cs @@ -0,0 +1,56 @@ +// +#pragma warning disable + +#if !NET7_0_OR_GREATER + +namespace System.Runtime.CompilerServices; + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using Link = System.ComponentModel.DescriptionAttribute; + +/// +/// Indicates that compiler support for a particular feature is required for the location where this attribute is applied. +/// +[ExcludeFromCodeCoverage] +[DebuggerNonUserCode] +[AttributeUsage( + validOn: AttributeTargets.All, + AllowMultiple = true, + Inherited = false)] +[Link("https://learn.microsoft.com/en-us/dotnet/api/system.runtime.compilerservices.compilerfeaturerequiredattribute")] +#if PolyPublic +public +#endif +sealed class CompilerFeatureRequiredAttribute : + Attribute +{ + /// + /// Initialize a new instance of + /// + /// The name of the required compiler feature. + public CompilerFeatureRequiredAttribute(string featureName) => + FeatureName = featureName; + + /// + /// The name of the compiler feature. + /// + public string FeatureName { get; } + + /// + /// If true, the compiler can choose to allow access to the location where this attribute is applied if it does not understand . + /// + public bool IsOptional { get; init; } + + /// + /// The used for the ref structs C# feature. + /// + public const string RefStructs = nameof(RefStructs); + + /// + /// The used for the required members C# feature. + /// + public const string RequiredMembers = nameof(RequiredMembers); +} + +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/EnumerableExtensions.cs b/src/UiPath.CoreIpc/Polyfills/EnumerableExtensions.cs new file mode 100644 index 00000000..48bf84b1 --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/EnumerableExtensions.cs @@ -0,0 +1,17 @@ +#if NET461 + +namespace System.Linq; + +public static class EnumerableExtensions +{ + public static IEnumerable Prepend(this IEnumerable enumerable, T element) + { + yield return element; + foreach (var item in enumerable) + { + yield return item; + } + } +} + +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/IsExternalInit.cs b/src/UiPath.CoreIpc/Polyfills/IsExternalInit.cs new file mode 100644 index 00000000..dc521fbf --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/IsExternalInit.cs @@ -0,0 +1,19 @@ +#pragma warning disable + +#if !NET5_0_OR_GREATER + +namespace System.Runtime.CompilerServices; + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; + +/// +/// Reserved to be used by the compiler for tracking metadata. This class should not be used by developers in source code. +/// +[ExcludeFromCodeCoverage] +[DebuggerNonUserCode] +internal static class IsExternalInit +{ +} + +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/MemberNotNullWhenAttribute.cs b/src/UiPath.CoreIpc/Polyfills/MemberNotNullWhenAttribute.cs new file mode 100644 index 00000000..bf9ad270 --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/MemberNotNullWhenAttribute.cs @@ -0,0 +1,71 @@ +// +#pragma warning disable + +#if NETSTANDARD || NETFRAMEWORK || NETCOREAPPX + +namespace System.Diagnostics.CodeAnalysis; + +using Targets = AttributeTargets; + +/// +/// Specifies that the method or property will ensure that the listed field and property members have +/// non- values when returning with the specified return value condition. +/// +[ExcludeFromCodeCoverage] +[DebuggerNonUserCode] +[AttributeUsage( + validOn: Targets.Method | + Targets.Property, + Inherited = false, + AllowMultiple = true)] +#if PolyPublic +public +#endif +sealed class MemberNotNullWhenAttribute : + Attribute +{ + /// + /// Gets the return value condition. + /// + public bool ReturnValue { get; } + + /// + /// Gets field or property member names. + /// + public string[] Members { get; } + + /// + /// Initializes the attribute with the specified return value condition and a field or property member. + /// + /// + /// The return value condition. If the method returns this value, + /// the associated parameter will not be . + /// + /// + /// The field or property member that is promised to be not-. + /// + public MemberNotNullWhenAttribute(bool returnValue, string member) + { + ReturnValue = returnValue; + Members = [member]; + } + + /// + /// Initializes the attribute with the specified return value condition and list + /// of field and property members. + /// + /// + /// The return value condition. If the method returns this value, + /// the associated parameter will not be . + /// + /// + /// The list of field and property members that are promised to be not-null. + /// + public MemberNotNullWhenAttribute(bool returnValue, params string[] members) + { + ReturnValue = returnValue; + Members = members; + } +} + +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/NotNullIfNotNullAttribute.cs b/src/UiPath.CoreIpc/Polyfills/NotNullIfNotNullAttribute.cs new file mode 100644 index 00000000..50afab43 --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/NotNullIfNotNullAttribute.cs @@ -0,0 +1,41 @@ +// +#pragma warning disable + +#if NETSTANDARD2_0 || NETFRAMEWORK || NETCOREAPP2X + +namespace System.Diagnostics.CodeAnalysis; + +using Targets = AttributeTargets; + +[ExcludeFromCodeCoverage] +[DebuggerNonUserCode] +[AttributeUsage( + validOn: Targets.Parameter | + Targets.Property | + Targets.ReturnValue, + AllowMultiple = true)] +#if PolyPublic +public +#endif +sealed class NotNullIfNotNullAttribute : + Attribute +{ + /// + /// Gets the associated parameter name. + /// The output will be non- if the argument to the + /// parameter specified is non-. + /// + public string ParameterName { get; } + + /// + /// Initializes the attribute with the associated parameter name. + /// + /// + /// The associated parameter name. + /// The output will be non- if the argument to the + /// parameter specified is non-. + /// + public NotNullIfNotNullAttribute(string parameterName) => + ParameterName = parameterName; +} +#endif diff --git a/src/UiPath.CoreIpc/Polyfills/NotNullWhenAttribute.cs b/src/UiPath.CoreIpc/Polyfills/NotNullWhenAttribute.cs new file mode 100644 index 00000000..be043ad9 --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/NotNullWhenAttribute.cs @@ -0,0 +1,38 @@ +// +#pragma warning disable + +#if NETSTANDARD2_0 || NETFRAMEWORK || NETCOREAPP2X + +namespace System.Diagnostics.CodeAnalysis; + +/// +/// Specifies that when a method returns , +/// the parameter will not be even if the corresponding type allows it. +/// +[ExcludeFromCodeCoverage] +[DebuggerNonUserCode] +[AttributeUsage(AttributeTargets.Parameter)] +#if PolyPublic +public +#endif +sealed class NotNullWhenAttribute : + Attribute +{ + /// + /// Gets the return value condition. + /// If the method returns this value, the associated parameter will not be . + /// + public bool ReturnValue { get; } + + /// + /// Initializes the attribute with the specified return value condition. + /// + /// + /// The return value condition. + /// If the method returns this value, the associated parameter will not be . + /// + public NotNullWhenAttribute(bool returnValue) => + ReturnValue = returnValue; +} + +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/RequiredMemberAttribute.cs b/src/UiPath.CoreIpc/Polyfills/RequiredMemberAttribute.cs new file mode 100644 index 00000000..8564df41 --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/RequiredMemberAttribute.cs @@ -0,0 +1,29 @@ +// +#pragma warning disable + +#if !NET7_0_OR_GREATER + +namespace System.Runtime.CompilerServices; + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; + +using Targets = AttributeTargets; + +/// +/// Specifies that a type has required members or that a member is required. +/// +[ExcludeFromCodeCoverage] +[DebuggerNonUserCode] +[AttributeUsage( + validOn: Targets.Class | + Targets.Struct | + Targets.Field | + Targets.Property, + Inherited = false)] +#if PolyPublic +public +#endif +sealed class RequiredMemberAttribute : + Attribute; +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/SetsRequiredMembersAttribute.cs b/src/UiPath.CoreIpc/Polyfills/SetsRequiredMembersAttribute.cs new file mode 100644 index 00000000..f3db6439 --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/SetsRequiredMembersAttribute.cs @@ -0,0 +1,20 @@ +// +#pragma warning disable + +#if !NET7_0_OR_GREATER + +namespace System.Diagnostics.CodeAnalysis; + +/// +/// Specifies that this constructor sets all required members for the current type, and callers +/// do not need to set any required members themselves. +/// +[ExcludeFromCodeCoverage] +[DebuggerNonUserCode] +[AttributeUsage(AttributeTargets.Constructor)] +#if PolyPublic +public +#endif +sealed class SetsRequiredMembersAttribute : + Attribute; +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/System_Index.cs b/src/UiPath.CoreIpc/Polyfills/System_Index.cs new file mode 100644 index 00000000..177b155c --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/System_Index.cs @@ -0,0 +1,151 @@ +// +#pragma warning disable + +#if !NET5_0_OR_GREATER + +namespace System; + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; + +/// Represent a type can be used to index a collection either from the start or the end. +/// +/// Index is used by the C# compiler to support the new index syntax +/// +/// int[] someArray = new int[5] { 1, 2, 3, 4, 5 } ; +/// int lastElement = someArray[^1]; // lastElement = 5 +/// +/// +[ExcludeFromCodeCoverage] +[DebuggerNonUserCode] +internal readonly struct Index : IEquatable +{ + readonly int _value; + + /// Construct an Index using a value and indicating if the index is from the start or from the end. + /// The index value. it has to be zero or positive number. + /// Indicating if the index is from the start or from the end. + /// + /// If the Index constructed from the end, index value 1 means pointing at the last element and index value 0 means pointing at beyond last element. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Index(int value, bool fromEnd = false) + { + if (value < 0) + { + throw new ArgumentOutOfRangeException(nameof(value)); + } + + if (fromEnd) + { + _value = ~value; + } + else + { + _value = value; + } + } + + // The following private constructors mainly created for perf reason to avoid the checks + Index(int value) => + _value = value; + + /// Create an Index pointing at first element. + public static Index Start => new(0); + + /// Create an Index pointing at beyond last element. + public static Index End => new(~0); + + /// Create an Index from the start at the position indicated by the value. + /// The index value from the start. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Index FromStart(int value) + { + if (value < 0) + { + throw new IndexOutOfRangeException(nameof(value)); + } + + return new(value); + } + + /// Create an Index from the end at the position indicated by the value. + /// The index value from the end. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Index FromEnd(int value) + { + if (value < 0) + { + throw new IndexOutOfRangeException(nameof(value)); + } + + return new(~value); + } + + /// Returns the index value. + public int Value + { + get + { + if (_value < 0) + { + return ~_value; + } + + return _value; + } + } + + /// Indicates whether the index is from the start or the end. + public bool IsFromEnd => _value < 0; + + /// Calculate the offset from the start using the giving collection length. + /// The length of the collection that the Index will be used with. length has to be a positive value + /// + /// For performance reason, we don't validate the input length parameter and the returned offset value against negative values. + /// we don't validate either the returned offset is greater than the input length. + /// It is expected Index will be used with collections which always have non negative length/count. If the returned offset is negative and + /// then used to index a collection will get out of range exception which will be same affect as the validation. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int GetOffset(int length) + { + var offset = _value; + if (IsFromEnd) + { + offset += length + 1; + } + + return offset; + } + + /// Indicates whether the current Index object is equal to another object of the same type. + /// An object to compare with this object + public override bool Equals(object value) => value is Index index && _value == index._value; + + /// Indicates whether the current Index object is equal to another Index object. + /// An object to compare with this object + public bool Equals(Index other) => _value == other._value; + + /// Returns the hash code for this instance. + public override int GetHashCode() => _value; + + /// Converts integer number to an Index. + public static implicit operator Index(int value) => FromStart(value); + + /// Converts the value of the current Index object to its equivalent string representation. + public override string ToString() + { + if (IsFromEnd) + { + return ToStringFromEnd(); + } + + return ((uint)Value).ToString(); + } + + string ToStringFromEnd() => + '^' + Value.ToString(); +} +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Polyfills/TcpClientExtensions.cs b/src/UiPath.CoreIpc/Polyfills/TcpClientExtensions.cs new file mode 100644 index 00000000..10b4a728 --- /dev/null +++ b/src/UiPath.CoreIpc/Polyfills/TcpClientExtensions.cs @@ -0,0 +1,14 @@ +#if NET461 + +namespace System.Net.Sockets; + +internal static class TcpClientExtensions +{ + public static async Task ConnectAsync(this TcpClient tcpClient, IPAddress address, int port, CancellationToken cancellationToken) + { + using var token = cancellationToken.Register(state => (state as TcpClient)!.Dispose(), tcpClient); + await tcpClient.ConnectAsync(address, port); + } +} + +#endif \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Server/EndpointSettings.cs b/src/UiPath.CoreIpc/Server/EndpointSettings.cs new file mode 100644 index 00000000..26a39d6b --- /dev/null +++ b/src/UiPath.CoreIpc/Server/EndpointSettings.cs @@ -0,0 +1,58 @@ +namespace UiPath.Ipc; + +using System; + +public record EndpointSettings +{ + public TaskScheduler? Scheduler { get; set; } + public BeforeCallHandler? BeforeCall { get; set; } + public Type ContractType => Service.Type; + public object? ServiceInstance => Service.MaybeGetInstance(); + public IServiceProvider? ServiceProvider => Service.MaybeGetServiceProvider(); + internal ServiceFactory Service { get; } + + public EndpointSettings(Type contractType, object? serviceInstance = null) : this( + serviceInstance is not null + ? new ServiceFactory.Instance() + { + Type = contractType ?? throw new ArgumentNullException(nameof(contractType)), + ServiceInstance = serviceInstance + } + : new ServiceFactory.Deferred() + { + Type = contractType ?? throw new ArgumentNullException(nameof(contractType)), + }) + { } + + public EndpointSettings(Type contractType, IServiceProvider serviceProvider) : this( + new ServiceFactory.Injected() + { + Type = contractType ?? throw new ArgumentNullException(nameof(contractType)), + ServiceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider)) + }) + { } + + private protected EndpointSettings(ServiceFactory service) => Service = service; + + public virtual EndpointSettings WithServiceProvider(IServiceProvider? serviceProvider) + => new(Service.WithProvider(serviceProvider)); + + public void Validate() + { + Validator.Validate(Service.Type); + if (Service.MaybeGetInstance() is { } instance && !Service.Type.IsAssignableFrom(instance.GetType())) + { + throw new ArgumentOutOfRangeException(nameof(instance)); + } + } +} + +public sealed record EndpointSettings : EndpointSettings where TContract : class +{ + public EndpointSettings(TContract? serviceInstance = null) : base(typeof(TContract), serviceInstance) { } + public EndpointSettings(IServiceProvider serviceProvider) : base(typeof(TContract), serviceProvider) { } + private EndpointSettings(ServiceFactory service) : base(service) { } + + public override EndpointSettings WithServiceProvider(IServiceProvider? serviceProvider) + => new EndpointSettings(Service.WithProvider(serviceProvider)); +} diff --git a/src/UiPath.CoreIpc/Server/Listener.cs b/src/UiPath.CoreIpc/Server/Listener.cs index a9c10adf..f8d6c26b 100644 --- a/src/UiPath.CoreIpc/Server/Listener.cs +++ b/src/UiPath.CoreIpc/Server/Listener.cs @@ -1,80 +1,212 @@ -using System.Security.Cryptography.X509Certificates; +using System.Linq.Expressions; -namespace UiPath.CoreIpc; +namespace UiPath.Ipc; -public class ListenerSettings -{ - public ListenerSettings(string name) => Name = name; - public byte ConcurrentAccepts { get; set; } = 5; - public byte MaxReceivedMessageSizeInMegabytes { get; set; } = 2; - public X509Certificate Certificate { get; set; } - public string Name { get; } - public TimeSpan RequestTimeout { get; set; } = Timeout.InfiniteTimeSpan; - internal IServiceProvider ServiceProvider { get; set; } - internal IDictionary Endpoints { get; set; } -} -abstract class Listener : IDisposable +using ListenerFactory = Func; + +internal abstract class Listener : IAsyncDisposable { - protected Listener(ListenerSettings settings) + public static Listener Create(IpcServer server, ListenerConfig config) + => GetFactory(config.GetType())( + server ?? throw new ArgumentNullException(nameof(server)), + config ?? throw new ArgumentNullException(nameof(config))); + + private readonly struct Result { - Settings = settings; - MaxMessageSize = settings.MaxReceivedMessageSizeInMegabytes * 1024 * 1024; + private readonly T _value; + private readonly Exception? _exception; + + public T Value => _exception is null ? _value : throw _exception; + + public Result(T value) + { + _value = value; + _exception = null; + } + + public Result(Exception exception) + { + _value = default!; + _exception = exception; + } } - public string Name => Settings.Name; - public ILogger Logger { get; private set; } - public IServiceProvider ServiceProvider => Settings.ServiceProvider; - public ListenerSettings Settings { get; } - public int MaxMessageSize { get; } - public Task Listen(CancellationToken token) + private static readonly ConcurrentDictionary> Factories = new(); + private static ListenerFactory GetFactory(Type configType) => Factories.GetOrAdd(configType, CreateFactory).Value; + private static Result CreateFactory(Type configType) { - Logger = ServiceProvider.GetRequiredService().CreateLogger(GetType()); - if (LogEnabled) + try + { + return new(Pal(configType)); + } + catch (Exception ex) { - Log($"Starting listener {Name}..."); + return new(ex); } - return Task.WhenAll(Enumerable.Range(1, Settings.ConcurrentAccepts).Select(async _ => + + static ListenerFactory Pal(Type configType) { - while (!token.IsCancellationRequested) + if (configType.GetInterfaces().SingleOrDefault(IsIListenerConfig) is not { } iface + || iface.GetGenericArguments() is not [_, var listenerStateType, var connectionStateType]) { - await AcceptConnection(token); + throw new ArgumentOutOfRangeException(nameof(iface), $"The ListenerConfig type must implement IListenerConfig<,>. ListenerConfig type was: {configType.FullName}"); } - })); + + var listenerType = typeof(Listener<,,>).MakeGenericType(configType, listenerStateType, connectionStateType); + var listenerCtor = listenerType.GetConstructor( + bindingAttr: BindingFlags.Public | BindingFlags.Instance, + binder: Type.DefaultBinder, + types: [typeof(IpcServer), configType], + modifiers: null)!; + + var paramofServer = Expression.Parameter(typeof(IpcServer)); + var paramofConfig = Expression.Parameter(typeof(ListenerConfig)); + var lambda = Expression.Lambda( + delegateType: typeof(ListenerFactory), + body: Expression.New(listenerCtor, paramofServer, Expression.Convert(paramofConfig, configType)), + paramofServer, + paramofConfig); + + var @delegate = (lambda.Compile() as ListenerFactory)!; + return @delegate; + } + + static bool IsIListenerConfig(Type candidateIface) + => candidateIface.IsGenericType && candidateIface.GetGenericTypeDefinition() == typeof(IListenerConfig<,,>); + } + + private readonly Lazy _disposeTask = null!; + public readonly ListenerConfig Config; + public readonly IpcServer Server; + private readonly Lazy _loggerCategory; + + private readonly Lazy _lazyLogger; + public ILogger Logger => _lazyLogger.Value; + + protected Listener(IpcServer server, ListenerConfig config) + { + _loggerCategory = new(ComputeLoggerCategory); + Config = config; + Server = server; + _lazyLogger = new(() => server.ServiceProvider.GetRequiredService().CreateLogger(LoggerCategory)); + _disposeTask = new(DisposeCore); + } + + ValueTask IAsyncDisposable.DisposeAsync() => new(_disposeTask.Value); + + protected abstract Task DisposeCore(); + + private string LoggerCategory => _loggerCategory.Value; + + private string ComputeLoggerCategory() + => $"{GetType().Namespace}.{nameof(Listener)}<{ConfigType.Name}[{Config}],..>"; + + protected abstract Type ConfigType { get; } +} + +internal sealed class Listener : Listener, IAsyncDisposable + where TConfig : ListenerConfig, IListenerConfig + where TListenerState : IAsyncDisposable +{ + private readonly CancellationTokenSource _cts = new(); + private readonly Task _listeningTask = null!; + + public new readonly TConfig Config; + + public TListenerState State { get; } + + public Listener(IpcServer server, TConfig config) : base(server, config) + { + Config = config; + State = Config.CreateListenerState(server); + + _listeningTask = Task.Run(() => Listen(_cts.Token)); + } + + public void Log(string message) + { + if (!Logger.Enabled()) + { + return; + } + + Logger.LogInformation(message); } - protected abstract ServerConnection CreateServerConnection(); - async Task AcceptConnection(CancellationToken token) + public void LogError(Exception exception, string message) + { + if (!Logger.Enabled(LogLevel.Error)) + { + return; + } + + Logger.LogError(exception, message); + } + + protected override async Task DisposeCore() { - var serverConnection = CreateServerConnection(); + Log($"Stopping listener {Config}..."); try { - var network = await serverConnection.AcceptClient(token); - serverConnection.Listen(network, token).LogException(Logger, Name); + _cts.Cancel(); } catch (Exception ex) { - serverConnection.Dispose(); - if (!token.IsCancellationRequested) + LogError(ex, $"Canceling {Config} failed."); + } + try + { + await _listeningTask; + } + catch (OperationCanceledException ex) when (ex.CancellationToken == _cts.Token) + { + Log($"Stopping listener {Config} threw OCE."); + } + catch (Exception ex) + { + LogError(ex, $"Stopping listener {Config} failed."); + } + await State.DisposeAsync(); + _cts.Dispose(); + } + + private async Task Listen(CancellationToken ct) + { + Log($"Starting listener {Config}..."); + + await Task.WhenAll(Enumerable.Range(1, Config.ConcurrentAccepts).Select(async _ => + { + while (!ct.IsCancellationRequested) { - Logger.LogException(ex, Settings.Name); + await AcceptConnection(ct); } - } + })); } - protected virtual void Dispose(bool disposing) + private async Task AcceptConnection(CancellationToken ct) { - if (!disposing) + var serverConnection = new ServerConnection(this); + + Stream network; + try + { + network = await serverConnection.AcceptClient(ct); + } + catch (OperationCanceledException ex) when (ex.CancellationToken == ct) { return; } - Settings.Certificate?.Dispose(); - } - public void Dispose() - { - if (LogEnabled) + + try { - Log($"Stopping listener {Name}..."); + serverConnection.Listen(network, ct).LogException(Logger, Config); + } + catch (Exception ex) + { + serverConnection.Dispose(); + if (!ct.IsCancellationRequested) + { + Logger.LogException(ex, Config); + } } - Dispose(disposing: true); - GC.SuppressFinalize(this); } - public void Log(string message) => Logger.LogInformation(message); - public bool LogEnabled => Logger.Enabled(); -} \ No newline at end of file + + protected override Type ConfigType => typeof(TConfig); +} diff --git a/src/UiPath.CoreIpc/Server/Server.cs b/src/UiPath.CoreIpc/Server/Server.cs index 5e6d5b4d..b5405cba 100644 --- a/src/UiPath.CoreIpc/Server/Server.cs +++ b/src/UiPath.CoreIpc/Server/Server.cs @@ -1,20 +1,40 @@ using System.Linq.Expressions; -namespace UiPath.CoreIpc; + +namespace UiPath.Ipc; + using GetTaskResultFunc = Func; -using MethodExecutor = Func; +using MethodExecutor = Func; using static Expression; using static CancellationTokenSourcePool; -class Server + +internal class Server { - private static readonly MethodInfo GetResultMethod = typeof(Server).GetStaticMethod(nameof(GetTaskResultImpl)); - private static readonly ConcurrentDictionary<(Type,string), Method> Methods = new(); + static Server() + { + var prototype = GetTaskResultImpl; + GetResultMethod = prototype.Method.GetGenericMethodDefinition(); + } + + private static readonly MethodInfo GetResultMethod; + private static readonly ConcurrentDictionary Methods = new(); private static readonly ConcurrentDictionary GetTaskResultByType = new(); + + private readonly Router _router; private readonly Connection _connection; - private readonly IClient _client; + private readonly IClient? _client; private readonly ConcurrentDictionary _requests = new(); - public Server(ListenerSettings settings, Connection connection, IClient client = null) + + private readonly TimeSpan _requestTimeout; + + private ILogger? Logger => _connection.Logger; + private bool LogEnabled => Logger.Enabled(); + public ISerializer Serializer => _connection.Serializer.OrDefault(); + public string DebugName => _connection.DebugName; + + public Server(Router router, TimeSpan requestTimeout, Connection connection, IClient? client = null) { - Settings = settings; + _router = router; + _requestTimeout = requestTimeout; _connection = connection; _client = client; connection.RequestReceived += OnRequestReceived; @@ -23,7 +43,7 @@ public Server(ListenerSettings settings, Connection connection, IClient client = { if (LogEnabled) { - Log($"Server {Name} closed."); + Log($"Server {DebugName} closed."); } foreach (var requestId in _requests.Keys) { @@ -33,12 +53,13 @@ public Server(ListenerSettings settings, Connection connection, IClient client = } catch (Exception ex) { - Logger.LogException(ex, $"{Name}"); + Logger.OrDefault().LogException(ex, $"{DebugName}"); } } }; } - void CancelRequest(string requestId) + + private void CancelRequest(string requestId) { if (_requests.TryRemove(requestId, out var cancellation)) { @@ -46,44 +67,40 @@ void CancelRequest(string requestId) cancellation.Return(); } } + #if !NET461 [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder))] #endif - async ValueTask OnRequestReceived(Request request) + private async ValueTask OnRequestReceived(Request request) { try { if (LogEnabled) { - Log($"{Name} received request {request}"); - } - if (!Endpoints.TryGetValue(request.Endpoint, out var endpoint)) - { - await OnError(request, new ArgumentOutOfRangeException(nameof(request.Endpoint), $"{Name} cannot find endpoint {request.Endpoint}")); - return; + Log($"{DebugName} received request {request}"); } - var method = GetMethod(endpoint.Contract, request.MethodName); - if (request.HasObjectParameters && !method.ReturnType.IsGenericType) + if (!_router.TryResolve(request.Endpoint, out var route)) { - await HandleRequest(method, endpoint, request, default); + await OnError(request, new EndpointNotFoundException(nameof(request.Endpoint), DebugName, request.Endpoint)); return; } - Response response = null; + var method = GetMethod(route.Service.Type, request.MethodName); + Response? response = null; var requestCancellation = Rent(); _requests[request.Id] = requestCancellation; - var timeout = request.GetTimeout(Settings.RequestTimeout); + var timeout = request.GetTimeout(_requestTimeout); var timeoutHelper = new TimeoutHelper(timeout, requestCancellation.Token); try { var token = timeoutHelper.Token; - response = await HandleRequest(method, endpoint, request, token); + response = await HandleRequest(method, route, request, token); if (LogEnabled) { - Log($"{Name} sending response for {request}"); + Log($"{DebugName} sending response for {request}"); } await SendResponse(response, token); } - catch (Exception ex) when(response == null) + catch (Exception ex) when (response is null) { await OnError(request, timeoutHelper.CheckTimeout(ex, request.MethodName)); } @@ -94,7 +111,7 @@ async ValueTask OnRequestReceived(Request request) } catch (Exception ex) { - Logger.LogException(ex, $"{Name} {request}"); + Logger.LogException(ex, $"{DebugName} {request}"); } if (_requests.TryRemove(request.Id, out var cancellation)) { @@ -103,81 +120,80 @@ async ValueTask OnRequestReceived(Request request) } ValueTask OnError(Request request, Exception ex) { - Logger.LogException(ex, $"{Name} {request}"); + Logger.LogException(ex, $"{DebugName} {request}"); return SendResponse(Response.Fail(request, ex), default); } + #if !NET461 [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))] #endif - async ValueTask HandleRequest(Method method, EndpointSettings endpoint, Request request, CancellationToken cancellationToken) + private async ValueTask HandleRequest(Method method, Route route, Request request, CancellationToken cancellationToken) { - var objectParameters = request.HasObjectParameters; - var contract = endpoint.Contract; var arguments = GetArguments(); - var beforeCall = endpoint.BeforeCall; - if (beforeCall != null) + + object service; + using (route.Service.Get(out service)) { - await beforeCall(new(default, method.MethodInfo, arguments), cancellationToken); - } - IServiceScope scope = null; - var service = endpoint.ServiceInstance; - try - { - if (service == null) - { - scope = ServiceProvider.CreateScope(); - service = scope.ServiceProvider.GetRequiredService(contract); - } return await InvokeMethod(); } - finally - { - scope?.Dispose(); - } #if !NET461 [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))] #endif async ValueTask InvokeMethod() { var returnTaskType = method.ReturnType; - var scheduler = endpoint.Scheduler; + var scheduler = route.Scheduler; Debug.Assert(scheduler != null); var defaultScheduler = scheduler == TaskScheduler.Default; + if (returnTaskType.IsGenericType) { - var methodResult = defaultScheduler ? MethodCall() : await RunOnScheduler(); - await methodResult; - var returnValue = GetTaskResult(returnTaskType, methodResult); - if (returnValue is Stream downloadStream) + var result = await ScheduleMethodCall(); + return result switch { - return Response.Success(request, downloadStream); - } - return objectParameters ? new Response(request.Id, ObjectData: returnValue) : Response.Success(request, Serializer.Serialize(returnValue)); + Stream downloadStream => Response.Success(request, downloadStream), + var x => Response.Success(request, Serializer.Serialize(x)) + }; } - else + + ScheduleMethodCall().LogException(Logger, method.MethodInfo); + return Response.Success(request, ""); + + Task ScheduleMethodCall() => defaultScheduler ? MethodCall() : RunOnScheduler(); + async Task MethodCall() { - (defaultScheduler ? MethodCall() : RunOnScheduler().Unwrap()).LogException(Logger, method.MethodInfo); - return objectParameters ? null : Response.Success(request, ""); + await (route.BeforeCall?.Invoke( + new CallInfo(newConnection: false, method.MethodInfo, arguments), + cancellationToken) ?? Task.CompletedTask); + var invocationTask = method.Invoke(service, arguments, cancellationToken); + await invocationTask; + + if (!returnTaskType.IsGenericType) + { + return null; + } + + return GetTaskResult(returnTaskType, invocationTask); } - Task MethodCall() => method.Invoke(service, arguments, cancellationToken); - Task RunOnScheduler() => Task.Factory.StartNew(MethodCall, cancellationToken, TaskCreationOptions.DenyChildAttach, scheduler); + + Task RunOnScheduler() => Task.Factory.StartNew(MethodCall, cancellationToken, TaskCreationOptions.DenyChildAttach, scheduler).Unwrap(); } - object[] GetArguments() + object?[] GetArguments() { var parameters = method.Parameters; var allParametersLength = parameters.Length; - var requestParametersLength = objectParameters ? request.ObjectParameters.Length : request.Parameters.Length; + var requestParametersLength = request.Parameters.Length; if (requestParametersLength > allParametersLength) { throw new ArgumentException("Too many parameters for " + method.MethodInfo); } - var allArguments = objectParameters && requestParametersLength == allParametersLength ? request.ObjectParameters : new object[allParametersLength]; + var allArguments = new object?[allParametersLength]; Deserialize(); SetOptionalArguments(); return allArguments; void Deserialize() { - object argument; + object? argument; for (int index = 0; index < requestParametersLength; index++) { var parameterType = parameters[index].ParameterType; @@ -191,9 +207,7 @@ void Deserialize() } else { - argument = objectParameters ? - Serializer.Deserialize(request.ObjectParameters[index], parameterType) : - Serializer.Deserialize(request.Parameters[index], parameterType); + argument = Serializer.Deserialize(request.Parameters[index], parameterType); argument = CheckMessage(argument, parameterType); } allArguments[index] = argument; @@ -207,9 +221,7 @@ object CheckMessage(object argument, Type parameterType) } if (argument is Message message) { - message.CallbackContract = endpoint.CallbackContract; message.Client = _client; - message.ObjectParameters = objectParameters; } return argument; } @@ -222,46 +234,57 @@ void SetOptionalArguments() } } } - private void Log(string message) => _connection.Log(message); - private ILogger Logger => _connection.Logger; - private bool LogEnabled => Logger.Enabled(); - private ListenerSettings Settings { get; } - public IServiceProvider ServiceProvider => Settings.ServiceProvider; - public ISerializer Serializer => _connection.Serializer; - public string Name => _connection.Name; - public IDictionary Endpoints => Settings.Endpoints; - ValueTask SendResponse(Response response, CancellationToken responseCancellation) => _connection.Send(response, responseCancellation); - static object GetTaskResultImpl(Task task) => ((Task)task).Result; - static object GetTaskResult(Type taskType, Task task) => - GetTaskResultByType.GetOrAdd(taskType.GenericTypeArguments[0], - resultType => GetResultMethod.MakeGenericDelegate(resultType))(task); - static Method GetMethod(Type contract, string methodName) => Methods.GetOrAdd((contract, methodName), - ((Type contract,string methodName) key) => new(key.contract.GetInterfaceMethod(key.methodName))); - readonly struct Method + + private void Log(string message) => Logger.OrDefault().LogInformation(message); + + private ValueTask SendResponse(Response response, CancellationToken responseCancellation) => _connection.Send(response, responseCancellation); + + private static object? GetTaskResultImpl(Task task) => (task as Task)!.Result; + + private static object GetTaskResult(Type taskType, Task task) + => GetTaskResultByType.GetOrAdd( + taskType.GenericTypeArguments[0], + GetResultMethod.MakeGenericDelegate)(task); + + private static Method GetMethod(Type contract, string methodName) + => Methods.GetOrAdd(new(contract, methodName), Method.FromKey); + + private readonly record struct MethodKey(Type Contract, string MethodName); + + private readonly struct Method { - static readonly ParameterExpression TargetParameter = Parameter(typeof(object), "target"); - static readonly ParameterExpression TokenParameter = Parameter(typeof(CancellationToken), "cancellationToken"); - static readonly ParameterExpression ParametersParameter = Parameter(typeof(object[]), "parameters"); - readonly MethodExecutor _executor; + public static Method FromKey(MethodKey key) + { + var methodInfo = key.Contract.GetInterfaceMethod(key.MethodName); + return new(methodInfo); + } + + private static readonly ParameterExpression TargetParameter = Parameter(typeof(object), "target"); + private static readonly ParameterExpression TokenParameter = Parameter(typeof(CancellationToken), "cancellationToken"); + private static readonly ParameterExpression ParametersParameter = Parameter(typeof(object[]), "parameters"); + + private readonly MethodExecutor _executor; public readonly MethodInfo MethodInfo; public readonly ParameterInfo[] Parameters; - public readonly object[] Defaults; + public readonly object?[] Defaults; + public Type ReturnType => MethodInfo.ReturnType; - public Method(MethodInfo method) + + private Method(MethodInfo method) { // https://github.com/dotnet/aspnetcore/blob/3f620310883092905ed6f13d784c908b5f4a9d7e/src/Shared/ObjectMethodExecutor/ObjectMethodExecutor.cs#L156 var parameters = method.GetParameters(); var parametersLength = parameters.Length; var callParameters = new Expression[parametersLength]; - var defaults = new object[parametersLength]; + var defaults = new object?[parametersLength]; for (int index = 0; index < parametersLength; index++) { var parameter = parameters[index]; defaults[index] = parameter.GetDefaultValue(); - callParameters[index] = parameter.ParameterType == typeof(CancellationToken) ? TokenParameter : + callParameters[index] = parameter.ParameterType == typeof(CancellationToken) ? TokenParameter : Convert(ArrayIndex(ParametersParameter, Constant(index, typeof(int))), parameter.ParameterType); } - var instanceCast = Convert(TargetParameter, method.DeclaringType); + var instanceCast = Convert(TargetParameter, method.DeclaringType!); var methodCall = Call(instanceCast, method, callParameters); var lambda = Lambda(methodCall, TargetParameter, ParametersParameter, TokenParameter); _executor = lambda.Compile(); @@ -269,7 +292,9 @@ public Method(MethodInfo method) Parameters = parameters; Defaults = defaults; } - public Task Invoke(object service, object[] arguments, CancellationToken cancellationToken) => _executor.Invoke(service, arguments, cancellationToken); - public override string ToString() => MethodInfo.ToString(); + + public Task Invoke(object service, object?[] arguments, CancellationToken cancellationToken) => _executor.Invoke(service, arguments, cancellationToken); + + public override string ToString() => MethodInfo.ToString()!; } } \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Server/ServerConnection.cs b/src/UiPath.CoreIpc/Server/ServerConnection.cs index 43f11a6a..d2229703 100644 --- a/src/UiPath.CoreIpc/Server/ServerConnection.cs +++ b/src/UiPath.CoreIpc/Server/ServerConnection.cs @@ -1,85 +1,123 @@ -using System.Net.Security; -namespace UiPath.CoreIpc; +using System.IO.Pipes; +using System.Net.Security; +namespace UiPath.Ipc; public interface IClient { - TCallbackInterface GetCallback(Type callbackContract, bool objectParameters) where TCallbackInterface : class; + TCallbackInterface GetCallback() where TCallbackInterface : class; void Impersonate(Action action); } -abstract class ServerConnection : IClient, IDisposable + +internal sealed class ServerConnection : ServerConnection + where TConfig : ListenerConfig, IListenerConfig + where TListenerState : IAsyncDisposable { + public new readonly Listener Listener; + + public ServerConnection(Listener listener) : base(listener) + { + Listener = listener; + } + + public override ValueTask AcceptClient(CancellationToken ct) + => Listener.Config.AwaitConnection(Listener.State, Listener.Config.CreateConnectionState(Listener.Server, Listener.State), ct); +} + +internal abstract class ServerConnection : IClient, IDisposable +{ + public readonly Listener Listener; + private readonly ConcurrentDictionary _callbacks = new(); - protected readonly Listener _listener; - private Connection _connection; - private Task _connectionAsTask; - private Server _server; - protected ServerConnection(Listener listener) => _listener = listener; - public ILogger Logger => _listener.Logger; - public ListenerSettings Settings => _listener.Settings; - public abstract Task AcceptClient(CancellationToken cancellationToken); - public virtual void Impersonate(Action action) => action(); - TCallbackInterface IClient.GetCallback(Type callbackContract, bool objectParameters) where TCallbackInterface : class + internal Connection? Connection; + private Task? _connectionAsTask; + private Server? Server; + + protected ServerConnection(Listener listener) { - if (callbackContract == null) + Listener = listener; + } + + protected internal virtual void Initialize() { } + + public abstract ValueTask AcceptClient(CancellationToken cancellationToken); + + public void Impersonate(Action action) + { + if (Connection is null) + { + throw new InvalidOperationException("The server connection is not listening yet."); + } + + if (Connection.Network is not NamedPipeServerStream pipeStream) { - throw new InvalidOperationException($"Callback contract mismatch. Requested {typeof(TCallbackInterface)}, but it's not configured."); + action(); + return; } - return (TCallbackInterface)_callbacks.GetOrAdd(callbackContract, CreateCallback); + + pipeStream.RunAsClient(() => action()); + } + + TCallbackInterface IClient.GetCallback() where TCallbackInterface : class + { + return (TCallbackInterface)_callbacks.GetOrAdd(typeof(TCallbackInterface), CreateCallback); + TCallbackInterface CreateCallback(Type callbackContract) { - if (!typeof(TCallbackInterface).IsAssignableFrom(callbackContract)) - { - throw new ArgumentException($"Callback contract mismatch. Requested {typeof(TCallbackInterface)}, but it's {callbackContract}."); - } - if (_listener.LogEnabled) - { - _listener.Log($"Create callback {callbackContract} {_listener.Name}"); - } - _connectionAsTask ??= Task.FromResult(_connection); - var serviceClient = new ServiceClient(_connection.Serializer, Settings.RequestTimeout, Logger, (_, _) => _connectionAsTask) - { - ObjectParameters = objectParameters - }; - return serviceClient.CreateProxy(); + Listener.Logger.LogInformation($"Create callback {callbackContract} {Listener.Config}"); + + _connectionAsTask ??= Task.FromResult(Connection!); + + // TODO: rethink this double specification of TCallbackInterface + return new ServiceClientForCallback(Connection!, Listener, typeof(TCallbackInterface)).GetProxy(); } } public async Task Listen(Stream network, CancellationToken cancellationToken) { - var stream = await AuthenticateAsServer(); - var serializer = Settings.ServiceProvider.GetRequiredService(); - _connection = new(stream, serializer, Logger, _listener.Name, _listener.MaxMessageSize); - _server = new(Settings, _connection, this); + var stream = await AuthenticateAsServer(); // TODO: should we decommission this? + var serializer = Listener.Server.ServiceProvider.GetService(); + Connection = new Connection(stream, serializer, Listener.Logger, debugName: Listener.ToString(), maxMessageSize: Listener.Config.MaxMessageSize); + Server = new Server( + new Router( + Listener.Config.CreateRouterConfig(Listener.Server), + Listener.Server.ServiceProvider), + Listener.Config.RequestTimeout, + Connection, + client: this); + // close the connection when the service host closes - using (cancellationToken.UnsafeRegister(state => ((Connection)state).Dispose(), _connection)) + using (cancellationToken.UnsafeRegister(_ => Connection.Dispose(), null!)) { - await _connection.Listen(); + await Connection.Listen(); } return; + + // TODO: should we decommission this? async Task AuthenticateAsServer() { - var certificate = Settings.Certificate; - if (certificate == null) + if (Listener.Config.Certificate is null) { return network; } + var sslStream = new SslStream(network); try { - await sslStream.AuthenticateAsServerAsync(certificate); + await sslStream.AuthenticateAsServerAsync(Listener.Config.Certificate); } catch { sslStream.Dispose(); throw; } + Debug.Assert(sslStream.IsEncrypted && sslStream.IsSigned); return sslStream; } } - protected virtual void Dispose(bool disposing){} + protected virtual void Dispose(bool disposing) { } public void Dispose() { Dispose(disposing: true); GC.SuppressFinalize(this); } -} \ No newline at end of file +} diff --git a/src/UiPath.CoreIpc/Server/ServiceHost.cs b/src/UiPath.CoreIpc/Server/ServiceHost.cs index 13a834b1..deb352a8 100644 --- a/src/UiPath.CoreIpc/Server/ServiceHost.cs +++ b/src/UiPath.CoreIpc/Server/ServiceHost.cs @@ -1,34 +1,39 @@ -namespace UiPath.CoreIpc; -public sealed class ServiceHost : IDisposable -{ - private readonly CancellationTokenSource _cancellationTokenSource = new(); - private readonly IDictionary _endpoints; - private readonly IReadOnlyCollection _listeners; - internal ServiceHost(IEnumerable listeners, IDictionary endpoints) - { - _endpoints = endpoints.ToReadOnlyDictionary(); - _listeners = listeners.ToArray(); - } - public void Dispose() - { - if(_cancellationTokenSource.IsCancellationRequested) - { - return; - } - foreach (var listener in _listeners) - { - listener.Dispose(); - } - _cancellationTokenSource.Cancel(); - _cancellationTokenSource.AssertDisposed(); - } - public void Run() => RunAsync().Wait(); - public Task RunAsync(TaskScheduler taskScheduler = null) - { - foreach (var endpoint in _endpoints.Values) - { - endpoint.Scheduler = taskScheduler; - } - return Task.Run(() => Task.WhenAll(_listeners.Select(listener => listener.Listen(_cancellationTokenSource.Token)))); - } -} \ No newline at end of file +namespace UiPath.Ipc; + +//public sealed class ServiceHost : IDisposable +//{ +// private readonly IServiceProvider _serviceProvider; +// private readonly CancellationTokenSource _cancellationTokenSource = new(); +// private readonly IDictionary _endpoints; +// private readonly IReadOnlyCollection _listeners; + +// internal ServiceHost(IServiceProvider serviceProvider, IEnumerable listeners, IDictionary endpoints) +// { +// _serviceProvider = serviceProvider; +// _endpoints = endpoints.ToReadOnlyDictionary(); +// _listeners = listeners.ToArray(); +// } + +// public void Dispose() +// { +// if(_cancellationTokenSource.IsCancellationRequested) +// { +// return; +// } +// foreach (var listener in _listeners) +// { +// listener.Dispose(); +// } +// _cancellationTokenSource.Cancel(); +// _cancellationTokenSource.AssertDisposed(); +// } +// public void Run() => RunAsync().Wait(); +// public Task RunAsync(TaskScheduler? taskScheduler = null) +// { +// foreach (var endpoint in _endpoints.Values) +// { +// endpoint.SetScheduler(taskScheduler); +// } +// return Task.Run(() => Task.WhenAll(_listeners.Select(listener => listener.Listen(_serviceProvider, _cancellationTokenSource.Token)))); +// } +//} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Server/ServiceHostBuilder.cs b/src/UiPath.CoreIpc/Server/ServiceHostBuilder.cs deleted file mode 100644 index e5c3474f..00000000 --- a/src/UiPath.CoreIpc/Server/ServiceHostBuilder.cs +++ /dev/null @@ -1,74 +0,0 @@ -namespace UiPath.CoreIpc; - -using BeforeCallHandler = Func; -public class ServiceHostBuilder -{ - private readonly List _listeners = new(); - public ServiceHostBuilder(IServiceProvider serviceProvider) => ServiceProvider = serviceProvider; - internal IServiceProvider ServiceProvider { get; } - internal Dictionary Endpoints { get; } = new(); - public ServiceHostBuilder AddEndpoint(EndpointSettings settings) - { - settings.ServiceProvider = ServiceProvider; - Endpoints.Add(settings.Name, settings); - return this; - } - internal ServiceHostBuilder AddListener(Listener listener) - { - listener.Settings.ServiceProvider = ServiceProvider; - listener.Settings.Endpoints = Endpoints; - _listeners.Add(listener); - return this; - } - public ServiceHost Build() => new(_listeners, Endpoints); -} -public static class ServiceHostBuilderExtensions -{ - public static ServiceHostBuilder AddEndpoints(this ServiceHostBuilder serviceHostBuilder, IEnumerable endpoints) - { - foreach (var endpoint in endpoints) - { - serviceHostBuilder.AddEndpoint(endpoint); - } - return serviceHostBuilder; - } - public static ServiceHostBuilder AddEndpoint(this ServiceHostBuilder serviceHostBuilder, TContract serviceInstance = null) where TContract : class => - serviceHostBuilder.AddEndpoint(new EndpointSettings(serviceInstance)); - public static ServiceHostBuilder AddEndpoint(this ServiceHostBuilder serviceHostBuilder, TContract serviceInstance = null) where TContract : class where TCallbackContract : class => - serviceHostBuilder.AddEndpoint(new EndpointSettings(serviceInstance)); -} -public static class ServiceCollectionExtensions -{ - public static IServiceCollection AddIpc(this IServiceCollection services) - { - services.AddSingleton(); - return services; - } -} -public class EndpointSettings -{ - private TaskScheduler _scheduler; - public EndpointSettings(Type contract, object serviceInstance = null, Type callbackContract = null) - { - Contract = contract ?? throw new ArgumentNullException(nameof(contract)); - Name = contract.Name; - ServiceInstance = serviceInstance; - CallbackContract = callbackContract; - } - internal string Name { get; } - internal TaskScheduler Scheduler { get => _scheduler; set => _scheduler = value ?? TaskScheduler.Default; } - internal object ServiceInstance { get; } - internal Type Contract { get; } - internal Type CallbackContract { get; } - internal IServiceProvider ServiceProvider { get; set; } - public BeforeCallHandler BeforeCall { get; set; } - public void Validate() => Validator.Validate(Contract, CallbackContract); -} -public class EndpointSettings : EndpointSettings where TContract : class -{ - public EndpointSettings(TContract serviceInstance = null, Type callbackContract = null) : base(typeof(TContract), serviceInstance, callbackContract) { } -} -public class EndpointSettings : EndpointSettings where TContract : class where TCallbackContract : class -{ - public EndpointSettings(TContract serviceInstance = null) : base(serviceInstance, typeof(TCallbackContract)) { } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Tcp/TcpClient.cs b/src/UiPath.CoreIpc/Tcp/TcpClient.cs deleted file mode 100644 index 50386575..00000000 --- a/src/UiPath.CoreIpc/Tcp/TcpClient.cs +++ /dev/null @@ -1,42 +0,0 @@ -using System.Net; -using System.Net.Sockets; - -namespace UiPath.CoreIpc.Tcp; - -using ConnectionFactory = Func>; -using BeforeCallHandler = Func; -interface ITcpKey : IConnectionKey -{ - IPEndPoint EndPoint { get; } -} -class TcpClient : ServiceClient, ITcpKey where TInterface : class -{ - public TcpClient(IPEndPoint endPoint, ISerializer serializer, TimeSpan requestTimeout, ILogger logger, ConnectionFactory connectionFactory, string sslServer, BeforeCallHandler beforeCall, bool objectParameters, EndpointSettings serviceEndpoint) : base(serializer, requestTimeout, logger, connectionFactory, sslServer, beforeCall, objectParameters, serviceEndpoint) - { - EndPoint = endPoint; - HashCode = (EndPoint, sslServer).GetHashCode(); - } - public override string Name => base.Name ?? EndPoint.ToString(); - public IPEndPoint EndPoint { get; } - public override bool Equals(IConnectionKey other) => other == this || (other is ITcpKey otherClient && EndPoint.Equals(otherClient.EndPoint) && - base.Equals(other)); - public override ClientConnection CreateClientConnection() => new TcpClientConnection(this); - class TcpClientConnection : ClientConnection - { - private TcpClient _tcpClient; - public TcpClientConnection(IConnectionKey connectionKey) : base(connectionKey) {} - public override bool Connected => _tcpClient?.Client?.Connected is true; - protected override void Dispose(bool disposing) - { - _tcpClient?.Dispose(); - base.Dispose(disposing); - } - public override async Task Connect(CancellationToken cancellationToken) - { - _tcpClient = new(); - var endPoint = ((ITcpKey)ConnectionKey).EndPoint; - await _tcpClient.ConnectAsync(endPoint.Address, endPoint.Port, cancellationToken); - return _tcpClient.GetStream(); - } - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Tcp/TcpClientBuilder.cs b/src/UiPath.CoreIpc/Tcp/TcpClientBuilder.cs deleted file mode 100644 index a0a05b71..00000000 --- a/src/UiPath.CoreIpc/Tcp/TcpClientBuilder.cs +++ /dev/null @@ -1,36 +0,0 @@ -using System.Net; - -namespace UiPath.CoreIpc.Tcp; - -public abstract class TcpClientBuilderBase : ServiceClientBuilder where TInterface : class where TDerived : ServiceClientBuilder -{ - private readonly IPEndPoint _endPoint; - - protected TcpClientBuilderBase(IPEndPoint endPoint, Type callbackContract = null, IServiceProvider serviceProvider = null) : base(callbackContract, serviceProvider) => - _endPoint = endPoint; - - protected override TInterface BuildCore(EndpointSettings serviceEndpoint) => - new TcpClient(_endPoint, _serializer, _requestTimeout, _logger, _connectionFactory, _sslServer, _beforeCall, _objectParameters, serviceEndpoint).CreateProxy(); -} - -public class TcpClientBuilder : TcpClientBuilderBase, TInterface> where TInterface : class -{ - public TcpClientBuilder(IPEndPoint endPoint) : base(endPoint){} -} - -public class TcpClientBuilder : TcpClientBuilderBase, TInterface> where TInterface : class where TCallbackInterface : class -{ - public TcpClientBuilder(IPEndPoint endPoint, IServiceProvider serviceProvider) : base(endPoint, typeof(TCallbackInterface), serviceProvider) { } - - public TcpClientBuilder CallbackInstance(TCallbackInterface singleton) - { - _callbackInstance = singleton; - return this; - } - - public TcpClientBuilder TaskScheduler(TaskScheduler taskScheduler) - { - _taskScheduler = taskScheduler; - return this; - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Tcp/TcpListener.cs b/src/UiPath.CoreIpc/Tcp/TcpListener.cs deleted file mode 100644 index b2019e3c..00000000 --- a/src/UiPath.CoreIpc/Tcp/TcpListener.cs +++ /dev/null @@ -1,47 +0,0 @@ -using System.Net; -namespace UiPath.CoreIpc.Tcp; - -public class TcpSettings : ListenerSettings -{ - public TcpSettings(IPEndPoint endPoint) : base(endPoint.ToString()) - { - EndPoint = endPoint; - } - public IPEndPoint EndPoint { get; } -} -class TcpListener : Listener -{ - readonly System.Net.Sockets.TcpListener _tcpServer; - public TcpListener(ListenerSettings settings) : base(settings) - { - _tcpServer = new(Settings.EndPoint); - _tcpServer.Start(backlog: Settings.ConcurrentAccepts); - } - public new TcpSettings Settings => (TcpSettings)base.Settings; - protected override ServerConnection CreateServerConnection() => new TcpServerConnection(this); - protected override void Dispose(bool disposing) - { - base.Dispose(disposing); - _tcpServer.Stop(); - } - Task AcceptClient(CancellationToken cancellationToken) => _tcpServer.AcceptTcpClientAsync(); - class TcpServerConnection : ServerConnection - { - System.Net.Sockets.TcpClient _tcpClient; - public TcpServerConnection(Listener listener) : base(listener){} - public override async Task AcceptClient(CancellationToken cancellationToken) - { - _tcpClient = await ((TcpListener)_listener).AcceptClient(cancellationToken); - return _tcpClient.GetStream(); - } - protected override void Dispose(bool disposing) - { - _tcpClient?.Dispose(); - base.Dispose(disposing); - } - } -} -public static class TcpServiceExtensions -{ - public static ServiceHostBuilder UseTcp(this ServiceHostBuilder builder, TcpSettings settings) => builder.AddListener(new TcpListener(settings)); -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/Transport/NamedPipe/NamedPipeListener.cs b/src/UiPath.CoreIpc/Transport/NamedPipe/NamedPipeListener.cs new file mode 100644 index 00000000..38456901 --- /dev/null +++ b/src/UiPath.CoreIpc/Transport/NamedPipe/NamedPipeListener.cs @@ -0,0 +1,68 @@ +using System.IO.Pipes; +using System.Security.Principal; + +namespace UiPath.Ipc.Transport.NamedPipe; + +using INamedPipeListenerConfig = IListenerConfig; + +public sealed record NamedPipeListener : ListenerConfig, INamedPipeListenerConfig +{ + public required string PipeName { get; init; } + public string ServerName { get; init; } = "."; + public AccessControlDelegate? AccessControl { get; init; } + + private PipeSecurity? GetPipeSecurity() + { + var setAccessControl = AccessControl; + if (setAccessControl is null) + { + return null; + } + + var pipeSecurity = new PipeSecurity(); + FullControlFor(WellKnownSidType.BuiltinAdministratorsSid); + FullControlFor(WellKnownSidType.LocalSystemSid); + pipeSecurity.AllowCurrentUser(onlyNonAdmin: true); + setAccessControl(pipeSecurity); + return pipeSecurity; + void FullControlFor(WellKnownSidType sid) => pipeSecurity.Allow(sid, PipeAccessRights.FullControl); + } + + NamedPipeListenerState INamedPipeListenerConfig.CreateListenerState(IpcServer server) + => new(); + + NamedPipeServerConnectionState INamedPipeListenerConfig.CreateConnectionState(IpcServer server, NamedPipeListenerState listenerState) + => new() + { + Stream = IOHelpers.NewNamedPipeServerStream( + PipeName, + PipeDirection.InOut, + NamedPipeServerStream.MaxAllowedServerInstances, + PipeTransmissionMode.Byte, + PipeOptions.Asynchronous, + GetPipeSecurity) + }; + + async ValueTask INamedPipeListenerConfig.AwaitConnection(NamedPipeListenerState listenerState, NamedPipeServerConnectionState connectionState, CancellationToken ct) + { + await connectionState.Stream.WaitForConnectionAsync(ct); + return connectionState.Stream; + } + + IEnumerable INamedPipeListenerConfig.Validate() + { + if (PipeName is null or "") { yield return "PipeName is required"; } + } + + public override string ToString() => $"ServerPipe={PipeName}"; +} + +internal sealed class NamedPipeServerConnectionState +{ + public required NamedPipeServerStream Stream { get; init; } +} + +internal sealed class NamedPipeListenerState : IAsyncDisposable +{ + public ValueTask DisposeAsync() => default; +} diff --git a/src/UiPath.CoreIpc/Transport/NamedPipe/NamedPipeTransport.cs b/src/UiPath.CoreIpc/Transport/NamedPipe/NamedPipeTransport.cs new file mode 100644 index 00000000..ba8fe11e --- /dev/null +++ b/src/UiPath.CoreIpc/Transport/NamedPipe/NamedPipeTransport.cs @@ -0,0 +1,51 @@ +using System.IO.Pipes; +using System.Security.Principal; + +namespace UiPath.Ipc.Transport.NamedPipe; + +public sealed record NamedPipeTransport : ClientTransport +{ + public required string PipeName { get; init; } + public string ServerName { get; init; } = "."; + public bool AllowImpersonation { get; init; } + + public override string ToString() => $"ClientPipe={PipeName}"; + + public override IClientState CreateState() => new NamedPipeClientState(); + + public override void Validate() + { + if (PipeName is null or "") + { + throw new InvalidOperationException($"{nameof(PipeName)} is required."); + } + if (ServerName is null or "") + { + throw new InvalidOperationException($"{nameof(ServerName)} is required."); + } + } +} + +internal sealed class NamedPipeClientState : IClientState +{ + private NamedPipeClientStream? _pipe; + + public Stream? Network => _pipe; + public bool IsConnected() => _pipe?.IsConnected is true; + + public async ValueTask Connect(IpcClient client, CancellationToken ct) + { + var transport = client.Transport as NamedPipeTransport ?? throw new InvalidOperationException(); + + _pipe = new NamedPipeClientStream( + transport.ServerName, + transport.PipeName, + PipeDirection.InOut, + PipeOptions.Asynchronous, + transport.AllowImpersonation ? TokenImpersonationLevel.Impersonation : TokenImpersonationLevel.Identification); + + await _pipe.ConnectAsync(ct); + } + + public void Dispose() => _pipe?.Dispose(); +} diff --git a/src/UiPath.CoreIpc/Transport/Tcp/TcpListener.cs b/src/UiPath.CoreIpc/Transport/Tcp/TcpListener.cs new file mode 100644 index 00000000..30fc99ab --- /dev/null +++ b/src/UiPath.CoreIpc/Transport/Tcp/TcpListener.cs @@ -0,0 +1,60 @@ +using System.Net; +using System.Net.Sockets; + +namespace UiPath.Ipc.Transport.Tcp; + +using ITcpListenerConfig = IListenerConfig; + +public sealed record TcpListener : ListenerConfig, ITcpListenerConfig +{ + public required IPEndPoint EndPoint { get; init; } + + TcpListenerState ITcpListenerConfig.CreateListenerState(IpcServer server) + { + var listener = new System.Net.Sockets.TcpListener(EndPoint); + listener.Start(backlog: ConcurrentAccepts); + + return new() { Listener = listener }; + } + + TcpServerConnectionState ITcpListenerConfig.CreateConnectionState(IpcServer server, TcpListenerState listenerState) + => new(); + + async ValueTask ITcpListenerConfig.AwaitConnection(TcpListenerState listenerState, TcpServerConnectionState connectionState, CancellationToken ct) + { + System.Net.Sockets.TcpClient tcpClient; +#if NET461 + using var ctreg = ct.Register(listenerState.Listener.Stop); + tcpClient = await listenerState.Listener.AcceptTcpClientAsync(); +#else + tcpClient = await listenerState.Listener.AcceptTcpClientAsync(ct); +#endif + return tcpClient.GetStream(); + } + + IEnumerable ITcpListenerConfig.Validate() + { + if (EndPoint is null) + { + yield return "EndPoint is required"; + } + } + + public override string ToString() => $"TcpServer={EndPoint}"; +} + +internal sealed class TcpListenerState : IAsyncDisposable +{ + public required System.Net.Sockets.TcpListener Listener { get; init; } + + public ValueTask DisposeAsync() + { + Listener.Stop(); + return default; + } +} + +internal sealed class TcpServerConnectionState +{ +} + diff --git a/src/UiPath.CoreIpc/Transport/Tcp/TcpTransport.cs b/src/UiPath.CoreIpc/Transport/Tcp/TcpTransport.cs new file mode 100644 index 00000000..c114f4f6 --- /dev/null +++ b/src/UiPath.CoreIpc/Transport/Tcp/TcpTransport.cs @@ -0,0 +1,56 @@ +using System.Net; + +namespace UiPath.Ipc.Transport.Tcp; + +public sealed record TcpTransport : ClientTransport +{ + public required IPEndPoint EndPoint { get; init; } + + public override string ToString() => $"TcpClient={EndPoint}"; + + public override IClientState CreateState() => new TcpClientState(); + + public override void Validate() + { + if (EndPoint is null) + { + throw new InvalidOperationException($"{nameof(EndPoint)} is required."); + } + } +} + +internal sealed class TcpClientState : IClientState +{ + private System.Net.Sockets.TcpClient? _tcpClient; + + public Stream? Network { get; private set; } + + public bool IsConnected() + { + return _tcpClient?.Client?.Connected is true; + } + + public async ValueTask Connect(IpcClient client, CancellationToken ct) + { + var transport = client.Transport as TcpTransport ?? throw new InvalidOperationException(); + + _tcpClient = new System.Net.Sockets.TcpClient(); +#if NET461 + using var ctreg = ct.Register(_tcpClient.Dispose); + try + { + await _tcpClient.ConnectAsync(transport.EndPoint.Address, transport.EndPoint.Port); + } + catch (ObjectDisposedException) + { + _tcpClient = null; + throw new OperationCanceledException(ct); + } +#else + await _tcpClient.ConnectAsync(transport.EndPoint.Address, transport.EndPoint.Port, ct); +#endif + Network = _tcpClient.GetStream(); + } + + public void Dispose() => _tcpClient?.Dispose(); +} diff --git a/src/UiPath.CoreIpc/Transport/WebSocket/WebSocketListener.cs b/src/UiPath.CoreIpc/Transport/WebSocket/WebSocketListener.cs new file mode 100644 index 00000000..4442fcb7 --- /dev/null +++ b/src/UiPath.CoreIpc/Transport/WebSocket/WebSocketListener.cs @@ -0,0 +1,37 @@ +namespace UiPath.Ipc.Transport.WebSocket; + +using IWebSocketListenerConfig = IListenerConfig; + +public sealed record WebSocketListener : ListenerConfig, IWebSocketListenerConfig +{ + public required Accept Accept { get; init; } + + WebSocketListenerState IWebSocketListenerConfig.CreateListenerState(IpcServer server) + => new(); + + WebSocketServerConnectionState IWebSocketListenerConfig.CreateConnectionState(IpcServer server, WebSocketListenerState listenerState) + => new(); + + async ValueTask IWebSocketListenerConfig.AwaitConnection(WebSocketListenerState listenerState, WebSocketServerConnectionState connectionState, CancellationToken ct) + { + var webSocket = await Accept(ct); + + return new WebSocketStream(webSocket); + } + + IEnumerable IWebSocketListenerConfig.Validate() + { + if (Accept is null) { yield return "Accept is required"; } + } + + public override string ToString() => "WebSocketServer"; +} + +internal sealed class WebSocketListenerState : IAsyncDisposable +{ + public ValueTask DisposeAsync() => default; +} + +internal sealed class WebSocketServerConnectionState +{ +} diff --git a/src/UiPath.CoreIpc/WebSockets/WebSocketStream.cs b/src/UiPath.CoreIpc/Transport/WebSocket/WebSocketStream.cs similarity index 93% rename from src/UiPath.CoreIpc/WebSockets/WebSocketStream.cs rename to src/UiPath.CoreIpc/Transport/WebSocket/WebSocketStream.cs index c64b4816..eac709f9 100644 --- a/src/UiPath.CoreIpc/WebSockets/WebSocketStream.cs +++ b/src/UiPath.CoreIpc/Transport/WebSocket/WebSocketStream.cs @@ -1,10 +1,14 @@ using System.Net.WebSockets; -namespace UiPath.CoreIpc.WebSockets; + +namespace UiPath.Ipc.Transport.WebSocket; + +using WebSocket = System.Net.WebSockets.WebSocket; + /// -/// Exposes a as a . +/// Exposes a as a . /// https://github.com/AArnott/Nerdbank.Streams/blob/main/src/Nerdbank.Streams/WebSocketStream.cs /// -public class WebSocketStream : Stream +internal class WebSocketStream : Stream { /// /// The socket wrapped by this stream. diff --git a/src/UiPath.CoreIpc/Transport/WebSocket/WebSocketTransport.cs b/src/UiPath.CoreIpc/Transport/WebSocket/WebSocketTransport.cs new file mode 100644 index 00000000..6558b2c7 --- /dev/null +++ b/src/UiPath.CoreIpc/Transport/WebSocket/WebSocketTransport.cs @@ -0,0 +1,39 @@ +using System.Net.WebSockets; + +namespace UiPath.Ipc.Transport.WebSocket; + +public sealed record WebSocketTransport : ClientTransport +{ + public required Uri Uri { get; init; } + public override string ToString() => $"WebSocketClient={Uri}"; + + public override IClientState CreateState() => new WebSocketClientState(); + + public override void Validate() + { + if (Uri is null) + { + throw new InvalidOperationException($"{nameof(Uri)} is required."); + } + } +} + +internal sealed class WebSocketClientState : IClientState +{ + private ClientWebSocket? _clientWebSocket; + + public Stream? Network { get; private set; } + + public bool IsConnected() => _clientWebSocket?.State is WebSocketState.Open; + + public async ValueTask Connect(IpcClient client, CancellationToken ct) + { + var transport = client.Transport as WebSocketTransport ?? throw new InvalidOperationException(); + + _clientWebSocket = new(); + await _clientWebSocket.ConnectAsync(transport.Uri, ct); + Network = new WebSocketStream(_clientWebSocket); + } + + public void Dispose() => _clientWebSocket?.Dispose(); +} diff --git a/src/UiPath.CoreIpc/UiPath.CoreIpc.csproj b/src/UiPath.CoreIpc/UiPath.CoreIpc.csproj index b0111764..94dd2c85 100644 --- a/src/UiPath.CoreIpc/UiPath.CoreIpc.csproj +++ b/src/UiPath.CoreIpc/UiPath.CoreIpc.csproj @@ -1,8 +1,10 @@  net6.0;net461;net6.0-windows - UiPath.CoreIpc + UiPath.Ipc + UiPath.Ipc true + true UiPath 2.5.1 https://github.com/UiPath/CoreIpc/ @@ -14,25 +16,36 @@ true snupkg CA1416 - latest + preview true + enable + true - - <_Parameter1>UiPath.CoreIpc.Tests - - + + + + + + + + + + + + + diff --git a/src/UiPath.CoreIpc/WebSockets/WebSocketClient.cs b/src/UiPath.CoreIpc/WebSockets/WebSocketClient.cs deleted file mode 100644 index f0774988..00000000 --- a/src/UiPath.CoreIpc/WebSockets/WebSocketClient.cs +++ /dev/null @@ -1,38 +0,0 @@ -using System.Net.WebSockets; -namespace UiPath.CoreIpc.WebSockets; -using ConnectionFactory = Func>; -using BeforeCallHandler = Func; -interface IWebSocketsKey : IConnectionKey -{ - Uri Uri { get; } -} -class WebSocketClient : ServiceClient, IWebSocketsKey where TInterface : class -{ - public WebSocketClient(Uri uri, ISerializer serializer, TimeSpan requestTimeout, ILogger logger, ConnectionFactory connectionFactory, string sslServer, BeforeCallHandler beforeCall, bool objectParameters, EndpointSettings serviceEndpoint) : base(serializer, requestTimeout, logger, connectionFactory, sslServer, beforeCall, objectParameters, serviceEndpoint) - { - Uri = uri; - HashCode = (uri, sslServer).GetHashCode(); - } - public override string Name => base.Name ?? Uri.ToString(); - public Uri Uri { get; } - public override bool Equals(IConnectionKey other) => other == this || (other is IWebSocketsKey otherClient && Uri.Equals(otherClient.Uri) && base.Equals(other)); - public override ClientConnection CreateClientConnection() => new WebSocketClientConnection(this); - class WebSocketClientConnection : ClientConnection - { - ClientWebSocket _clientWebSocket; - public WebSocketClientConnection(IConnectionKey connectionKey) : base(connectionKey) {} - public override bool Connected => _clientWebSocket?.State == WebSocketState.Open; - protected override void Dispose(bool disposing) - { - _clientWebSocket?.Dispose(); - base.Dispose(disposing); - } - public override async Task Connect(CancellationToken cancellationToken) - { - _clientWebSocket = new(); - var uri = ((IWebSocketsKey)ConnectionKey).Uri; - await _clientWebSocket.ConnectAsync(uri, cancellationToken); - return new WebSocketStream(_clientWebSocket); - } - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/WebSockets/WebSocketClientBuilder.cs b/src/UiPath.CoreIpc/WebSockets/WebSocketClientBuilder.cs deleted file mode 100644 index 893a8b7a..00000000 --- a/src/UiPath.CoreIpc/WebSockets/WebSocketClientBuilder.cs +++ /dev/null @@ -1,27 +0,0 @@ -namespace UiPath.CoreIpc.WebSockets; -public abstract class WebSocketClientBuilderBase : ServiceClientBuilder where TInterface : class where TDerived : ServiceClientBuilder -{ - private readonly Uri _uri; - protected WebSocketClientBuilderBase(Uri uri, Type callbackContract = null, IServiceProvider serviceProvider = null) : base(callbackContract, serviceProvider) => - _uri = uri; - protected override TInterface BuildCore(EndpointSettings serviceEndpoint) => - new WebSocketClient(_uri, _serializer, _requestTimeout, _logger, _connectionFactory, _sslServer, _beforeCall, _objectParameters, serviceEndpoint).CreateProxy(); -} -public class WebSocketClientBuilder : WebSocketClientBuilderBase, TInterface> where TInterface : class -{ - public WebSocketClientBuilder(Uri uri) : base(uri){} -} -public class WebSocketClientBuilder : WebSocketClientBuilderBase, TInterface> where TInterface : class where TCallbackInterface : class -{ - public WebSocketClientBuilder(Uri uri, IServiceProvider serviceProvider) : base(uri, typeof(TCallbackInterface), serviceProvider) { } - public WebSocketClientBuilder CallbackInstance(TCallbackInterface singleton) - { - _callbackInstance = singleton; - return this; - } - public WebSocketClientBuilder TaskScheduler(TaskScheduler taskScheduler) - { - _taskScheduler = taskScheduler; - return this; - } -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/WebSockets/WebSocketListener.cs b/src/UiPath.CoreIpc/WebSockets/WebSocketListener.cs deleted file mode 100644 index 20b95a06..00000000 --- a/src/UiPath.CoreIpc/WebSockets/WebSocketListener.cs +++ /dev/null @@ -1,24 +0,0 @@ -using System.Net.WebSockets; -namespace UiPath.CoreIpc.WebSockets; -using Accept = Func>; -public class WebSocketSettings : ListenerSettings -{ - public WebSocketSettings(Accept accept) : base("") => Accept = accept; - public Accept Accept { get; } -} -class WebSocketListener : Listener -{ - public WebSocketListener(ListenerSettings settings) : base(settings){} - protected override ServerConnection CreateServerConnection() => new WebSocketConnection(this); - class WebSocketConnection : ServerConnection - { - public WebSocketConnection(Listener listener) : base(listener){} - public override async Task AcceptClient(CancellationToken cancellationToken) => - new WebSocketStream(await ((WebSocketSettings)_listener.Settings).Accept(cancellationToken)); - } -} -public static class WebSocketServiceExtensions -{ - public static ServiceHostBuilder UseWebSockets(this ServiceHostBuilder builder, WebSocketSettings settings) => - builder.AddListener(new WebSocketListener(settings)); -} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/report/UiPath.Ipc.net6.0.received.txt b/src/UiPath.CoreIpc/report/UiPath.Ipc.net6.0.received.txt new file mode 100644 index 00000000..5833c110 --- /dev/null +++ b/src/UiPath.CoreIpc/report/UiPath.Ipc.net6.0.received.txt @@ -0,0 +1,282 @@ +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/UiPath/coreipc.git")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Playground")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("UiPath.CoreIpc.BackCompat")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("UiPath.CoreIpc.Tests")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("UiPath.Ipc.Tests")] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")] +namespace UiPath.Ipc +{ + public readonly struct CallInfo + { + public CallInfo(bool newConnection, System.Reflection.MethodInfo method, object?[] arguments) { } + public object?[] Arguments { get; } + public System.Reflection.MethodInfo Method { get; } + public bool NewConnection { get; } + } + public sealed class ClientConfig : UiPath.Ipc.EndpointConfig, System.IEquatable + { + public ClientConfig() { } + public string DebugName { get; set; } + public UiPath.Ipc.ISerializer? Serializer { get; set; } + public System.Func? BeforeCall { get; init; } + public System.Func? BeforeConnect { get; init; } + public UiPath.Ipc.EndpointCollection? Callbacks { get; init; } + public Microsoft.Extensions.Logging.ILogger? Logger { get; init; } + public System.Threading.Tasks.TaskScheduler? Scheduler { get; init; } + public System.IServiceProvider? ServiceProvider { get; init; } + } + public abstract class ClientTransport : System.IEquatable + { + protected ClientTransport() { } + public abstract UiPath.Ipc.IClientState CreateState(); + public abstract void Validate(); + } + public sealed class Connection : System.IDisposable + { + public Connection(System.IO.Stream network, UiPath.Ipc.ISerializer? serializer, Microsoft.Extensions.Logging.ILogger? logger, string debugName, int maxMessageSize = 2147483647) { } + public string DebugName { get; } + [System.Diagnostics.CodeAnalysis.MemberNotNullWhen(true, "Logger")] + [get: System.Diagnostics.CodeAnalysis.MemberNotNullWhen(true, "Logger")] + public bool LogEnabled { get; } + public Microsoft.Extensions.Logging.ILogger? Logger { get; } + public System.IO.Stream Network { get; } + public UiPath.Ipc.ISerializer? Serializer { get; } + public event System.EventHandler? Closed; + public void Dispose() { } + public System.Threading.Tasks.Task Listen() { } + public string NewRequestId() { } + public override string ToString() { } + } + public sealed class ContextfulLazy + { + public ContextfulLazy() { } + public T GetValue(System.Func factory) { } + } + public class EndpointCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EndpointCollection() { } + public void Add(System.Type type) { } + public void Add(UiPath.Ipc.EndpointSettings endpointSettings) { } + public void Add(System.Type contractType, object? instance) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + } + public abstract class EndpointConfig : System.IEquatable + { + protected EndpointConfig() { } + public System.TimeSpan RequestTimeout { get; init; } + } + [System.Serializable] + public sealed class EndpointNotFoundException : System.ArgumentOutOfRangeException + { + public EndpointNotFoundException(string paramName, string serverDebugName, string endpointName) { } + public string EndpointName { get; } + public string ServerDebugName { get; } + } + public class EndpointSettings : System.IEquatable + { + public EndpointSettings(System.Type contractType, System.IServiceProvider serviceProvider) { } + public EndpointSettings(System.Type contractType, object? serviceInstance = null) { } + public System.Func? BeforeCall { get; set; } + public System.Type ContractType { get; } + public System.Threading.Tasks.TaskScheduler? Scheduler { get; set; } + public object? ServiceInstance { get; } + public System.IServiceProvider? ServiceProvider { get; } + public void Validate() { } + public virtual UiPath.Ipc.EndpointSettings WithServiceProvider(System.IServiceProvider? serviceProvider) { } + } + public sealed class EndpointSettings : UiPath.Ipc.EndpointSettings, System.IEquatable> + where TContract : class + { + public EndpointSettings(System.IServiceProvider serviceProvider) { } + public EndpointSettings(TContract? serviceInstance = null) { } + public override UiPath.Ipc.EndpointSettings WithServiceProvider(System.IServiceProvider? serviceProvider) { } + } + [System.Serializable] + public class Error : System.IEquatable + { + public Error(string Message, string StackTrace, string Type, UiPath.Ipc.Error? InnerError) { } + public UiPath.Ipc.Error? InnerError { get; init; } + public string Message { get; init; } + public string StackTrace { get; init; } + public string Type { get; init; } + public override string ToString() { } + [return: System.Diagnostics.CodeAnalysis.NotNullIfNotNull("exception")] + public static UiPath.Ipc.Error? FromException(System.Exception? exception) { } + } + public static class Helpers { } + public interface IClient + { + TCallbackInterface GetCallback() + where TCallbackInterface : class; + void Impersonate(System.Action action); + } + public interface IClientState : System.IDisposable + { + System.IO.Stream? Network { get; } + System.Threading.Tasks.ValueTask Connect(UiPath.Ipc.IpcClient client, System.Threading.CancellationToken ct); + bool IsConnected(); + } + public static class IOHelpers + { + public static System.IO.Pipes.PipeSecurity Allow(this System.IO.Pipes.PipeSecurity pipeSecurity, System.Security.Principal.IdentityReference sid, System.IO.Pipes.PipeAccessRights pipeAccessRights) { } + public static System.IO.Pipes.PipeSecurity Allow(this System.IO.Pipes.PipeSecurity pipeSecurity, System.Security.Principal.WellKnownSidType sid, System.IO.Pipes.PipeAccessRights pipeAccessRights) { } + public static System.IO.Pipes.PipeSecurity AllowCurrentUser(this System.IO.Pipes.PipeSecurity pipeSecurity, bool onlyNonAdmin = false) { } + public static System.IO.Pipes.PipeSecurity Deny(this System.IO.Pipes.PipeSecurity pipeSecurity, System.Security.Principal.IdentityReference sid, System.IO.Pipes.PipeAccessRights pipeAccessRights) { } + public static System.IO.Pipes.PipeSecurity Deny(this System.IO.Pipes.PipeSecurity pipeSecurity, System.Security.Principal.WellKnownSidType sid, System.IO.Pipes.PipeAccessRights pipeAccessRights) { } + public static System.IO.Pipes.PipeSecurity LocalOnly(this System.IO.Pipes.PipeSecurity pipeSecurity) { } + public static bool PipeExists(string pipeName, int timeout = 1) { } + } + public interface ISerializer + { + object? Deserialize(string json, System.Type type); + System.Threading.Tasks.ValueTask DeserializeAsync(System.IO.Stream json); + string Serialize(object? obj); + void Serialize(object? obj, System.IO.Stream stream); + } + public sealed class IpcClient + { + [System.Obsolete("Constructors of types with required members are not supported in this version of " + + "your compiler.", true)] + public IpcClient() { } + public UiPath.Ipc.ClientConfig Config { get; init; } + public UiPath.Ipc.ClientTransport Transport { get; init; } + public TProxy GetProxy() + where TProxy : class { } + } + public class IpcProxy : System.Reflection.DispatchProxy, System.IDisposable + { + public IpcProxy() { } + public System.IO.Stream? Network { get; } + public event System.EventHandler ConnectionClosed; + public System.Threading.Tasks.ValueTask CloseConnection() { } + public void Dispose() { } + protected override object? Invoke(System.Reflection.MethodInfo? targetMethod, object?[]? args) { } + } + public sealed class IpcServer : System.IAsyncDisposable + { + [System.Obsolete("Constructors of types with required members are not supported in this version of " + + "your compiler.", true)] + public IpcServer() { } + public UiPath.Ipc.EndpointCollection Endpoints { get; init; } + public System.Collections.Generic.IReadOnlyList Listeners { get; init; } + public System.Threading.Tasks.TaskScheduler? Scheduler { get; init; } + public System.IServiceProvider ServiceProvider { get; init; } + public System.Threading.Tasks.ValueTask DisposeAsync() { } + public void Start() { } + public System.Threading.Tasks.Task WaitForStart() { } + public System.Threading.Tasks.Task WaitForStop() { } + } + public abstract class ListenerConfig : UiPath.Ipc.EndpointConfig, System.IEquatable + { + protected ListenerConfig() { } + public System.Security.Cryptography.X509Certificates.X509Certificate? Certificate { get; init; } + public int ConcurrentAccepts { get; init; } + public byte MaxReceivedMessageSizeInMegabytes { get; init; } + } + public class Message + { + public Message() { } + [Newtonsoft.Json.JsonIgnore] + public UiPath.Ipc.IClient Client { get; set; } + [Newtonsoft.Json.JsonIgnore] + public System.TimeSpan RequestTimeout { get; set; } + public TCallbackInterface GetCallback() + where TCallbackInterface : class { } + public void ImpersonateClient(System.Action action) { } + } + public class Message : UiPath.Ipc.Message + { + public Message(TPayload payload) { } + public TPayload Payload { get; } + } + [System.Serializable] + public class RemoteException : System.Exception + { + public RemoteException(UiPath.Ipc.Error error) { } + public UiPath.Ipc.RemoteException? InnerException { get; } + public override string StackTrace { get; } + public string Type { get; } + public bool Is() + where TException : System.Exception { } + public override string ToString() { } + } +} +namespace UiPath.Ipc.Extensibility +{ + public interface IListenerConfig + where TSelf : UiPath.Ipc.ListenerConfig, UiPath.Ipc.Extensibility.IListenerConfig + where TListenerState : System.IAsyncDisposable + { + System.Threading.Tasks.ValueTask AwaitConnection(TListenerState listenerState, TConnectionState connectionState, System.Threading.CancellationToken ct); + TConnectionState CreateConnectionState(UiPath.Ipc.IpcServer server, TListenerState listenerState); + TListenerState CreateListenerState(UiPath.Ipc.IpcServer server); + System.Collections.Generic.IEnumerable Validate(); + } +} +namespace UiPath.Ipc.Transport.NamedPipe +{ + public sealed class NamedPipeListener : UiPath.Ipc.ListenerConfig, System.IEquatable, UiPath.Ipc.Extensibility.IListenerConfig + { + [System.Obsolete("Constructors of types with required members are not supported in this version of " + + "your compiler.", true)] + public NamedPipeListener() { } + public System.Action? AccessControl { get; init; } + public string PipeName { get; init; } + public string ServerName { get; init; } + public override string ToString() { } + } + public sealed class NamedPipeTransport : UiPath.Ipc.ClientTransport, System.IEquatable + { + [System.Obsolete("Constructors of types with required members are not supported in this version of " + + "your compiler.", true)] + public NamedPipeTransport() { } + public bool AllowImpersonation { get; init; } + public string PipeName { get; init; } + public string ServerName { get; init; } + public override UiPath.Ipc.IClientState CreateState() { } + public override string ToString() { } + public override void Validate() { } + } +} +namespace UiPath.Ipc.Transport.Tcp +{ + public sealed class TcpListener : UiPath.Ipc.ListenerConfig, System.IEquatable, UiPath.Ipc.Extensibility.IListenerConfig + { + [System.Obsolete("Constructors of types with required members are not supported in this version of " + + "your compiler.", true)] + public TcpListener() { } + public System.Net.IPEndPoint EndPoint { get; init; } + public override string ToString() { } + } + public sealed class TcpTransport : UiPath.Ipc.ClientTransport, System.IEquatable + { + [System.Obsolete("Constructors of types with required members are not supported in this version of " + + "your compiler.", true)] + public TcpTransport() { } + public System.Net.IPEndPoint EndPoint { get; init; } + public override UiPath.Ipc.IClientState CreateState() { } + public override string ToString() { } + public override void Validate() { } + } +} +namespace UiPath.Ipc.Transport.WebSocket +{ + public sealed class WebSocketListener : UiPath.Ipc.ListenerConfig, System.IEquatable, UiPath.Ipc.Extensibility.IListenerConfig + { + [System.Obsolete("Constructors of types with required members are not supported in this version of " + + "your compiler.", true)] + public WebSocketListener() { } + public System.Func> Accept { get; init; } + public override string ToString() { } + } + public sealed class WebSocketTransport : UiPath.Ipc.ClientTransport, System.IEquatable + { + [System.Obsolete("Constructors of types with required members are not supported in this version of " + + "your compiler.", true)] + public WebSocketTransport() { } + public System.Uri Uri { get; init; } + public override UiPath.Ipc.IClientState CreateState() { } + public override string ToString() { } + public override void Validate() { } + } +} \ No newline at end of file diff --git a/src/UiPath.CoreIpc/report/generate-report.bat b/src/UiPath.CoreIpc/report/generate-report.bat new file mode 100644 index 00000000..434df540 --- /dev/null +++ b/src/UiPath.CoreIpc/report/generate-report.bat @@ -0,0 +1 @@ +generate-public-api --target-frameworks "net6.0" --assembly UiPath.Ipc.dll --project-path "D:\Alt\coreipc\src\UiPath.CoreIpc\UiPath.CoreIpc.csproj" --output-directory "D:\Alt\coreipc\src\UiPath.CoreIpc\report" \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/ComputingTests.cs b/src/UiPath.Ipc.Tests/ComputingTests.cs new file mode 100644 index 00000000..178727f3 --- /dev/null +++ b/src/UiPath.Ipc.Tests/ComputingTests.cs @@ -0,0 +1,319 @@ +using AutoFixture; +using Newtonsoft.Json; +using Nito.AsyncEx; +using Nito.Disposables; +using NSubstitute; +using System.Collections.Concurrent; +using System.Runtime.InteropServices; +using System.Text; +using UiPath.Ipc.Transport.NamedPipe; +using UiPath.Ipc.Transport.Tcp; +using UiPath.Ipc.Transport.WebSocket; +using Xunit; +using Xunit.Abstractions; + +namespace UiPath.Ipc.Tests; + +public abstract class ComputingTests : TestBase +{ + #region " Setup " + protected readonly ComputingCallback _computingCallback = new(); + + private readonly Lazy _service; + private readonly Lazy _proxy; + + protected ComputingService Service => _service.Value; + protected IComputingService Proxy => _proxy.Value!; + + protected sealed override IpcProxy? IpcProxy => Proxy as IpcProxy; + protected sealed override Type ContractType => typeof(IComputingService); + + protected readonly ConcurrentBag _clientBeforeCalls = new(); + + protected ComputingTests(ITestOutputHelper outputHelper) : base(outputHelper) + { + ServiceProvider.InjectLazy(out _service); + CreateLazyProxy(out _proxy); + } + + protected override ListenerConfig ConfigTransportAgnostic(ListenerConfig listener) + => listener with + { + ConcurrentAccepts = 10, + RequestTimeout = Timeouts.DefaultRequest, + MaxReceivedMessageSizeInMegabytes = 1, + }; + protected override ClientConfig CreateClientConfig(EndpointCollection? callbacks = null) + => new() + { + RequestTimeout = Timeouts.DefaultRequest, + Scheduler = GuiScheduler, + Callbacks = callbacks ?? new() + { + { typeof(IComputingCallback), _computingCallback } + }, + BeforeCall = async (callInfo, _) => _clientBeforeCalls.Add(callInfo), + }; + #endregion + + [Theory, IpcAutoData] + public async Task Calls_ShouldWork(float x, float y) + { + await Proxy.AddFloats(x, y).ShouldBeAsync(x + y); + } + + [Theory, IpcAutoData] + public Task ConcurrentCalls_ShouldWork(float sameX, float sameY) => Task.WhenAll(Enumerable.Range(1, 50).Select(_ => Calls_ShouldWork(sameX, sameY))); + + [Theory, IpcAutoData] + public async Task CallsWithStructParamsAndReturns_ShouldWork(ComplexNumber a, ComplexNumber b) + => await Proxy.AddComplexNumbers(a, b).ShouldBeAsync(a + b); + + [Fact] + public async Task ClientCancellations_ShouldWork() + { + using var cts = new CancellationTokenSource(); + + var taskWaiting = Proxy.Wait(Timeout.InfiniteTimeSpan, cts.Token); + + await Task.Delay(Timeouts.Short); + + taskWaiting.IsCompleted.ShouldBeFalse(); + + cts.Cancel(); + + await taskWaiting.ShouldCompleteInAsync(Timeouts.Short).ShouldThrowAsync(); // in-process scheduling fast + + await Proxy.Wait(TimeSpan.Zero).ShouldCompleteInAsync(Timeouts.IpcRoundtrip).ShouldBeAsync(true); // connection still alive + } + + [Fact, OverrideConfig(typeof(ShortClientTimeout))] + public async Task ClientTimeouts_ShouldWork() + { + await Proxy.Wait(Timeout.InfiniteTimeSpan).ShouldThrowAsync(); + + await Proxy.GetCallbackThreadName( + waitOnServer: TimeSpan.Zero, + message: new() + { + RequestTimeout = Timeouts.DefaultRequest + }) + .ShouldBeAsync(Names.GuiThreadName) + .ShouldNotThrowAsync(); + } + + private sealed class ShortClientTimeout : OverrideConfig + { + public override IpcClient? Override(Func client) => client().WithRequestTimeout(TimeSpan.FromMilliseconds(10)); + } + + [Theory, IpcAutoData] + public async Task CallsWithArraysOfStructsAsParams_ShouldWork(ComplexNumber a, ComplexNumber b, ComplexNumber c) + => await Proxy.AddComplexNumberList([a, b, c]).ShouldBeAsync(a + b + c); + + [Fact] + public async Task Callbacks_ShouldWork() + => await Proxy.GetCallbackThreadName(waitOnServer: TimeSpan.Zero).ShouldBeAsync(Names.GuiThreadName); + + [Fact] + public async Task CallbacksWithParams_ShouldWork() + => await Proxy.MultiplyInts(7, 1).ShouldBeAsync(7); + + [Fact] + public async Task ConcurrentCallbacksWithParams_ShouldWork() + => await Task.WhenAll( + Enumerable.Range(1, 50).Select(_ => CallbacksWithParams_ShouldWork())); + + [Fact] + public async Task BeforeCall_ShouldApplyToCallsButNotToToCallbacks() + { + await Proxy.GetCallbackThreadName(TimeSpan.Zero).ShouldBeAsync(Names.GuiThreadName); + + _clientBeforeCalls.ShouldContain(x => x.Method.Name == nameof(IComputingService.GetCallbackThreadName)); + _clientBeforeCalls.ShouldNotContain(x => x.Method.Name == nameof(IComputingCallback.GetThreadName)); + + _serverBeforeCalls.ShouldContain(x => x.Method.Name == nameof(IComputingService.GetCallbackThreadName)); + _serverBeforeCalls.ShouldNotContain(x => x.Method.Name == nameof(IComputingCallback.GetThreadName)); + } + + [Fact] + public async Task ServerBeforeCall_WhenSync_ShouldShareAsyncLocalContextWithTheTargetMethodCall() + { + await Proxy.GetCallContext().ShouldBeAsync(null); + + var id = $"{Guid.NewGuid():N}"; + var expectedCallContext = $"{nameof(IComputingService.GetCallContext)}-{id}"; + + _tailBeforeCall = (callInfo, _) => + { + ComputingService.CallContext = $"{callInfo.Method.Name}-{id}"; + return Task.CompletedTask; + }; + + await Proxy.GetCallContext().ShouldBeAsync(expectedCallContext); + } + + [Fact] + [OverrideConfig(typeof(SetBeforeConnect))] + public async Task BeforeConnect_ShouldWork() + { + int callCount = 0; + SetBeforeConnect.Set(async _ => callCount++); + + await Proxy.AddFloats(1, 2).ShouldBeAsync(3); + callCount.ShouldBe(1); + + await Proxy.AddFloats(1, 2).ShouldBeAsync(3); + callCount.ShouldBe(1); + + await IpcProxy.CloseConnection(); + await Proxy.AddFloats(1, 2).ShouldBeAsync(3); + callCount.ShouldBe(2); + } + + private sealed class SetBeforeConnect : OverrideConfig + { + private static readonly AsyncLocal ValueStorage = new(); + public static void Set(BeforeConnectHandler value) => ValueStorage.Value = value; + + public override IpcClient? Override(Func client) + => client().WithBeforeConnect(ct => ValueStorage.Value.ShouldNotBeNull().Invoke(ct)); + } + +#if !NET461 && !CI + [SkippableFact] +#endif + [OverrideConfig(typeof(DisableInProcClientServer))] + public async Task BeforeConnect_ShouldStartExternalServerJIT() + { + Skip.IfNot(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "Test works only on Windows."); + + using var whereDotNet = new Process + { + StartInfo = + { + FileName = "where.exe", + Arguments = "dotnet.exe", + } + }; + var pathDotNet = await whereDotNet.RunReturnStdOut(); + + var externalServerParams = RandomServerParams(); + var arg = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(externalServerParams))); + + var pipeName = $"{Guid.NewGuid():N}"; + + using var serverProcess = new Process + { + StartInfo = + { + FileName = pathDotNet, + Arguments = $"\"{Assembly.GetExecutingAssembly().Location}\" {arg}", + UseShellExecute = false, + }, + }; + using var killProcess = new Disposable(() => + { + try + { + serverProcess.Kill(); + } + catch + { + } + _outputHelper.WriteLine("Killed server process"); + }); + var proxy = new IpcClient + { + Config = new() + { + Scheduler = GuiScheduler, + BeforeConnect = async (_) => + { + serverProcess.Start(); + var time = TimeSpan.FromSeconds(1); + _outputHelper.WriteLine($"Server started. Waiting {time}. PID={serverProcess.Id}"); + await Task.Delay(time); + }, + }, + Transport = externalServerParams.CreateClientTransport() + }.GetProxy(); + + await proxy.AddFloats(1, 2).ShouldBeAsync(3); + } + + [SkippableFact] + public async Task ManyConnections_ShouldWork() + { + const int CParallelism = 10; + const int CTimesEach = 100; + + await Enumerable.Range(1, CParallelism) + .Select(async index => + { + var mockCallback = Substitute.For(); + mockCallback.AddInts(0, 1).Returns(1); + + var proxy = CreateClient(callbacks: new() + { + { typeof(IComputingCallback), mockCallback } + })!.GetProxy(); + + foreach (var time in Enumerable.Range(1, CTimesEach)) + { + await (proxy as IpcProxy)!.CloseConnection(); + + mockCallback.ClearReceivedCalls(); + await proxy.MultiplyInts(1, 1).ShouldBeAsync(1); + await mockCallback.Received().AddInts(0, 1); + } + }) + .WhenAll(); + } + + public abstract IAsyncDisposable? RandomTransportPair(out ListenerConfig listener, out ClientTransport transport); + + public abstract ExternalServerParams RandomServerParams(); + public readonly record struct ExternalServerParams(ServerKind Kind, string? PipeName = null, int Port = 0) + { + public IAsyncDisposable? CreateListenerConfig(out ListenerConfig listenerConfig) + { + switch (Kind) + { + case ServerKind.NamedPipes: + { + listenerConfig = new NamedPipeListener() { PipeName = PipeName! }; + return null; + } + case ServerKind.Tcp: + { + listenerConfig = new TcpListener() { EndPoint = new(System.Net.IPAddress.Loopback, Port) }; + return null; + } + case ServerKind.WebSockets: + { + var context = new WebSocketContext(Port); + listenerConfig = new WebSocketListener { Accept = context.Accept }; + return context; + } + default: + throw new NotSupportedException($"Kind not supported. Kind was {Kind}"); + } + } + + public ClientTransport CreateClientTransport() => Kind switch + { + ServerKind.NamedPipes => new NamedPipeTransport() { PipeName = PipeName! }, + ServerKind.Tcp => new TcpTransport() { EndPoint = new(System.Net.IPAddress.Loopback, Port) }, + ServerKind.WebSockets => new WebSocketTransport() { Uri = new($"ws://localhost:{Port}") }, + _ => throw new NotSupportedException($"Kind not supported. Kind was {Kind}") + }; + } + public enum ServerKind { NamedPipes, Tcp, WebSockets } + + private sealed class DisableInProcClientServer : OverrideConfig + { + public override async Task Override(Func> listener) => null; + public override IpcClient? Override(Func client) => null; + } +} diff --git a/src/UiPath.Ipc.Tests/ComputingTestsOverNamedPipes.cs b/src/UiPath.Ipc.Tests/ComputingTestsOverNamedPipes.cs new file mode 100644 index 00000000..68235bae --- /dev/null +++ b/src/UiPath.Ipc.Tests/ComputingTestsOverNamedPipes.cs @@ -0,0 +1,32 @@ +using UiPath.Ipc.Transport.NamedPipe; +using Xunit.Abstractions; + +namespace UiPath.Ipc.Tests; + +public sealed class ComputingTestsOverNamedPipes : ComputingTests +{ + private string PipeName => Names.GetPipeName(role: "computing", TestRunId); + + public ComputingTestsOverNamedPipes(ITestOutputHelper outputHelper) : base(outputHelper) { } + + protected override async Task CreateListener() => new NamedPipeListener + { + PipeName = PipeName + }; + protected override ClientTransport CreateClientTransport() => new NamedPipeTransport + { + PipeName = PipeName, + AllowImpersonation = true, + }; + + public override IAsyncDisposable? RandomTransportPair(out ListenerConfig listener, out ClientTransport transport) + { + var pipeName = $"{Guid.NewGuid():N}"; + listener = new NamedPipeListener { PipeName = pipeName }; + transport = new NamedPipeTransport { PipeName = pipeName }; + return null; + } + + public override ExternalServerParams RandomServerParams() + => new(ServerKind.NamedPipes, PipeName: $"{Guid.NewGuid():N}"); +} diff --git a/src/UiPath.Ipc.Tests/ComputingTestsOverTcp.cs b/src/UiPath.Ipc.Tests/ComputingTestsOverTcp.cs new file mode 100644 index 00000000..12cec28c --- /dev/null +++ b/src/UiPath.Ipc.Tests/ComputingTestsOverTcp.cs @@ -0,0 +1,35 @@ +using System.Net; +using UiPath.Ipc.Transport.Tcp; +using Xunit.Abstractions; + +namespace UiPath.Ipc.Tests; + +public sealed class ComputingTestsOverTcp : ComputingTests +{ + private readonly IPEndPoint _endPoint = NetworkHelper.FindFreeLocalPort(); + + public ComputingTestsOverTcp(ITestOutputHelper outputHelper) : base(outputHelper) { } + + protected override async Task CreateListener() + => new TcpListener + { + EndPoint = _endPoint, + }; + + protected override ClientTransport CreateClientTransport() + => new TcpTransport() { EndPoint = _endPoint }; + + public override IAsyncDisposable? RandomTransportPair(out ListenerConfig listener, out ClientTransport transport) + { + var endPoint = NetworkHelper.FindFreeLocalPort(); + listener = new TcpListener() { EndPoint = endPoint }; + transport = new TcpTransport() { EndPoint = endPoint }; + return null; + } + + public override ExternalServerParams RandomServerParams() + { + var endPoint = NetworkHelper.FindFreeLocalPort(); + return new(ServerKind.Tcp, Port: endPoint.Port); + } +} diff --git a/src/UiPath.Ipc.Tests/ComputingTestsOverWebSockets.cs b/src/UiPath.Ipc.Tests/ComputingTestsOverWebSockets.cs new file mode 100644 index 00000000..3b6022aa --- /dev/null +++ b/src/UiPath.Ipc.Tests/ComputingTestsOverWebSockets.cs @@ -0,0 +1,44 @@ +using UiPath.Ipc.Transport.WebSocket; +using Xunit.Abstractions; + +namespace UiPath.Ipc.Tests; + +public sealed class ComputingTestsOverWebSockets : ComputingTests +{ + private readonly WebSocketContext _webSocketContext = new(); + + public ComputingTestsOverWebSockets(ITestOutputHelper outputHelper) : base(outputHelper) { } + + protected override async Task DisposeAsync() + { + await _webSocketContext.DisposeAsync(); + await base.DisposeAsync(); + } + + protected override async Task CreateListener() + { + var listener = new WebSocketListener + { + Accept = _webSocketContext.Accept, + }; + await Task.Delay(200); // Wait for the listener to start. + return listener; + } + + protected override ClientTransport CreateClientTransport() + => new WebSocketTransport() { Uri = _webSocketContext.ClientUri }; + + public override IAsyncDisposable? RandomTransportPair(out ListenerConfig listener, out ClientTransport transport) + { + var context = new WebSocketContext(); + listener = new WebSocketListener() { Accept = context.Accept }; + transport = new WebSocketTransport() { Uri = context.ClientUri }; + return context; + } + + public override ExternalServerParams RandomServerParams() + { + var endPoint = NetworkHelper.FindFreeLocalPort(); + return new(ServerKind.WebSockets, Port: endPoint.Port); + } +} \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/Config/OverrideConfigAttribute.cs b/src/UiPath.Ipc.Tests/Config/OverrideConfigAttribute.cs new file mode 100644 index 00000000..a49f2aa9 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Config/OverrideConfigAttribute.cs @@ -0,0 +1,39 @@ +namespace UiPath.Ipc.Tests; + +[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)] +internal sealed class OverrideConfigAttribute : Attribute +{ + public Type OverrideConfigType { get; } + + /// + /// Initializes a new instance of the class. + /// + /// A typeof expression that indicates a concrete subclass of , with a public, parameterless constructor. + public OverrideConfigAttribute(Type overrideConfigType) + { + if (overrideConfigType is null) + { + throw new ArgumentNullException(nameof(overrideConfigType)); + } + if (overrideConfigType.IsAbstract) + { + throw new ArgumentException($"The type {overrideConfigType} is abstract.", nameof(overrideConfigType)); + } + if (!typeof(OverrideConfig).IsAssignableFrom(overrideConfigType)) + { + throw new ArgumentException($"The type {overrideConfigType} does not inherit from {typeof(OverrideConfig)}.", nameof(overrideConfigType)); + } + if (overrideConfigType.GetConstructor(BindingFlags.Public | BindingFlags.Instance, Type.DefaultBinder, Type.EmptyTypes, modifiers: null) is null) + { + throw new ArgumentException($"The type {overrideConfigType} does not have a public, parameterless constructor.", nameof(overrideConfigType)); + } + + OverrideConfigType = overrideConfigType; + } +} + +public abstract class OverrideConfig +{ + public virtual Task Override(Func> listener) => listener()!; + public virtual IpcClient? Override(Func client) => client(); +} \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/GlobalUsings.cs b/src/UiPath.Ipc.Tests/GlobalUsings.cs new file mode 100644 index 00000000..1f26ad7a --- /dev/null +++ b/src/UiPath.Ipc.Tests/GlobalUsings.cs @@ -0,0 +1,2 @@ +global using Accept = System.Func>; +global using BeforeConnectHandler = System.Func; diff --git a/src/UiPath.Ipc.Tests/Helpers/DiExtensions.cs b/src/UiPath.Ipc.Tests/Helpers/DiExtensions.cs new file mode 100644 index 00000000..fd750042 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/DiExtensions.cs @@ -0,0 +1,17 @@ +using Microsoft.Extensions.Hosting; + +namespace UiPath.Ipc.Tests; + +public static class DiExtensions +{ + public static void InjectLazy(this IServiceProvider serviceProvider, out Lazy lazy) + where T : class + => lazy = new(serviceProvider.GetRequiredService); + + public static IServiceCollection AddHostedSingleton(this IServiceCollection services) + where TService : class + where THostedImpl : class, TService, IHostedService + => services + .AddSingleton() + .AddHostedService(sp => (THostedImpl)sp.GetRequiredService()); +} \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/Helpers/HttpSysWebSocketsListener.cs b/src/UiPath.Ipc.Tests/Helpers/HttpSysWebSocketsListener.cs new file mode 100644 index 00000000..257e9a8b --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/HttpSysWebSocketsListener.cs @@ -0,0 +1,72 @@ +using System.Net.WebSockets; +using System.Net; +using System.Threading.Channels; + +namespace UiPath.Ipc.Tests; + +public class HttpSysWebSocketsListener : IAsyncDisposable +{ + private readonly CancellationTokenSource _cts = new(); + private readonly HttpListener _httpListener = new(); + private readonly Channel _channel = Channel.CreateBounded(capacity: 5); + private readonly Task _processingContexts; + + public HttpSysWebSocketsListener(string uriPrefix) + { + _httpListener.Prefixes.Add(uriPrefix); + _httpListener.Start(); + + _processingContexts = ProcessContexts(_cts.Token); + } + + private async Task ProcessContexts(CancellationToken ct) + { + try + { + while (!ct.IsCancellationRequested) + { + var context = await _httpListener.GetContextAsync(); + await _channel.Writer.WriteAsync(context, ct); + } + _channel.Writer.Complete(); + } + catch (Exception ex) + { + _channel.Writer.Complete(ex); + } + } + + public async Task Accept(CancellationToken ct) + { + while (true) + { + var listenerContext = await _channel.Reader.ReadAsync(ct); + if (listenerContext.Request.IsWebSocketRequest) + { + var webSocketContext = await listenerContext.AcceptWebSocketAsync(subProtocol: null); + return webSocketContext.WebSocket; + } + listenerContext.Response.StatusCode = 400; + listenerContext.Response.Close(); + } + } + + public async ValueTask DisposeAsync() + { + _cts.Cancel(); + _httpListener.Stop(); + + try + { + await _processingContexts; + } + catch (ObjectDisposedException) + { + // ignore + } + catch (OperationCanceledException ex) when (ex.CancellationToken == _cts.Token) + { + // ignore + } + } +} \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/Helpers/IpcAutoDataAttribute.cs b/src/UiPath.Ipc.Tests/Helpers/IpcAutoDataAttribute.cs new file mode 100644 index 00000000..2ce875a1 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/IpcAutoDataAttribute.cs @@ -0,0 +1,19 @@ +using AutoFixture; +using AutoFixture.Xunit2; + +namespace UiPath.Ipc.Tests; + +internal class IpcAutoDataAttribute : AutoDataAttribute +{ + public IpcAutoDataAttribute() : base(CreateFixture) + { + } + + public static Fixture CreateFixture() + { + var fixture = new Fixture(); + new SupportMutableValueTypesCustomization().Customize(fixture); + return fixture; + } +} + diff --git a/src/UiPath.Ipc.Tests/Helpers/IpcHelpers.cs b/src/UiPath.Ipc.Tests/Helpers/IpcHelpers.cs new file mode 100644 index 00000000..399acc8a --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/IpcHelpers.cs @@ -0,0 +1,58 @@ +using Microsoft.Extensions.Logging; +using Xunit.Abstractions; + +namespace UiPath.Ipc.Tests; + +using SP = ServiceProviderServiceExtensions; + +internal static class IpcHelpers +{ + public static ServiceProvider ConfigureServices(ITestOutputHelper outputHelper) + => new ServiceCollection() + .AddLogging(builder => builder + .AddTraceSource(new SourceSwitch("", "All")) + .AddXUnit(outputHelper)) + + .AddSingleton() + .AddSingletonAlias() + + .AddSingleton() + .AddSingletonAlias() + + .BuildServiceProvider(); + + private static IServiceCollection AddSingletonAlias(this IServiceCollection services) + where TNew : class + where TExisting : class, TNew + => services.AddSingleton(SP.GetRequiredService); + + public static IServiceProvider GetRequired(this IServiceProvider serviceProvider, out T service) where T : class + { + service = serviceProvider.GetRequiredService(); + return serviceProvider; + } +} + +internal static class IpcClientExtensions +{ + public static IpcClient WithRequestTimeout(this IpcClient ipcClient, TimeSpan requestTimeout) + => new() + { + Config = ipcClient.Config with { RequestTimeout = requestTimeout }, + Transport = ipcClient.Transport, + }; + + public static IpcClient WithCallbacks(this IpcClient ipcClient, EndpointCollection callbacks) + => new() + { + Config = ipcClient.Config with { Callbacks = callbacks }, + Transport = ipcClient.Transport, + }; + + public static IpcClient WithBeforeConnect(this IpcClient ipcClient, BeforeConnectHandler beforeConnect) + => new() + { + Config = ipcClient.Config with { BeforeConnect = beforeConnect }, + Transport = ipcClient.Transport, + }; +} \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/Helpers/Names.cs b/src/UiPath.Ipc.Tests/Helpers/Names.cs new file mode 100644 index 00000000..2668055b --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/Names.cs @@ -0,0 +1,8 @@ +namespace UiPath.Ipc.Tests; + +internal static class Names +{ + public const string GuiThreadName = "GuiThread"; + + public static string GetPipeName(string role, TestRunId testRunId) => $"{role}_{testRunId.Value:N}"; +} diff --git a/src/UiPath.Ipc.Tests/Helpers/NetworkHelper.cs b/src/UiPath.Ipc.Tests/Helpers/NetworkHelper.cs new file mode 100644 index 00000000..327ffbd1 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/NetworkHelper.cs @@ -0,0 +1,14 @@ +using System.Net; +using System.Net.Sockets; + +namespace UiPath.Ipc.Tests; + +public static class NetworkHelper +{ + public static IPEndPoint FindFreeLocalPort() + { + using var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); + socket.Bind(new IPEndPoint(IPAddress.Loopback, 0)); + return (IPEndPoint)socket.LocalEndPoint!; + } +} diff --git a/src/UiPath.Ipc.Tests/Helpers/ShouldlyHelpers.cs b/src/UiPath.Ipc.Tests/Helpers/ShouldlyHelpers.cs new file mode 100644 index 00000000..0895c94d --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/ShouldlyHelpers.cs @@ -0,0 +1,117 @@ +using System.Runtime.CompilerServices; + +namespace UiPath.Ipc.Tests; + +[ShouldlyMethods] +internal static class ShouldlyHelpers +{ + public static async Task ShouldBeAsync(this Task task, T expected, [CallerArgumentExpression(nameof(task))] string? taskExpression = null, bool launchDebugger = false) + { + var actual = await task; + try + { + actual.ShouldBe(expected); + } + catch (Exception ex) + { + if (launchDebugger) + { + Debugger.Launch(); + } + throw new ShouldAssertException($"Awaiting the expression `{taskExpression}`\r\n\tshould yield\r\n{expected}\r\n\tbut actually yielded\r\n{actual}", ex); + } + } + + public static async Task ShouldNotBeNullAsync(this Task task, [CallerArgumentExpression(nameof(task))] string? taskExpression = null) + where T : class + { + var actual = await task; + try + { + return actual.ShouldNotBeNull(); + } + catch + { + throw new ShouldAssertException($"The provided expression `{taskExpression}`\r\n\tshouldn't have yielded null but did."); + } + } + + + public static async Task ShouldNotThrowAsyncAnd(this Task task, [CallerArgumentExpression(nameof(task))] string? taskExpression = null) + { + try + { + return await task; + } + catch (Exception ex) + { + throw new ShouldAssertException($"The provided expression `{taskExpression}`\r\n\tshould not throw but threw\r\n{ex.GetType().FullName}\r\n\twith message\r\n\"{ex.Message}\"", ex); + } + } + + + public static Task ShouldCompleteInAsync(this Task task, TimeSpan lease, [CallerArgumentExpression(nameof(task))] string? taskExpression = null) + => task.Return(0).ShouldCompleteInAsync(lease, taskExpression); + + public static async Task ShouldCompleteInAsync(this Task task, TimeSpan lease, [CallerArgumentExpression(nameof(task))] string? taskExpression = null) + { + using var cts = new CancellationTokenSource(lease); + try + { + return await Nito.AsyncEx.TaskExtensions.WaitAsync(task, cts.Token); + } + catch (OperationCanceledException ex) when (ex.CancellationToken == cts.Token) + { + throw new ShouldCompleteInException($"The task {taskExpression} should complete in {lease} but did not.", inner: null); + } + } + + public static async Task ShouldStallForAtLeastAsync(this Task task, TimeSpan lease, [CallerArgumentExpression(nameof(task))] string? taskExpression = null) + { + using var cts = new CancellationTokenSource(lease); + try + { + _ = await Nito.AsyncEx.TaskExtensions.WaitAsync(task, cts.Token); + throw new ShouldAssertException($"The task {taskExpression} should stall for at least {lease} but it completed faster."); + } + catch (OperationCanceledException ex) when (ex.CancellationToken == cts.Token) + { + } + } + + + public static async Task ShouldSatisfyAllConditionsAsync(this Task task, Action[] assertions, [CallerArgumentExpression(nameof(task))] string? taskExpression = null, [CallerArgumentExpression(nameof(assertions))] string? assertionsExpression = null) + { + var actual = await task; + var exceptions = new List(); + foreach (var assertion in assertions) + { + try + { + assertion(actual); + } + catch (Exception ex) + { + exceptions.Add(ex); + } + } + + + var innerException = exceptions switch + { + [] => null, + [var singleException] => singleException, + _ => new AggregateException(exceptions) + }; + + if (innerException is not null) + { + throw new ShouldAssertException($"Awaiting the expression `{taskExpression}`\r\n\tshould yield a value that satisfies these assertions\r\n{assertionsExpression}\r\n\tbut at least one assertion was not satisfied.", innerException); + } + } + private static async Task Return(this Task task, T value = default!) + { + await task; + return value; + } +} diff --git a/src/UiPath.Ipc.Tests/Helpers/StreamBase.cs b/src/UiPath.Ipc.Tests/Helpers/StreamBase.cs new file mode 100644 index 00000000..cbf2c599 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/StreamBase.cs @@ -0,0 +1,15 @@ +namespace UiPath.Ipc.Tests; + +internal abstract class StreamBase : Stream + { + public override bool CanRead => true; + public override bool CanSeek => false; + public override bool CanWrite => false; + public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); } + + public override void Flush() { } + public override int Read(byte[] buffer, int offset, int count) => throw new NotImplementedException(); + public override long Seek(long offset, SeekOrigin origin) => throw new NotImplementedException(); + public override void SetLength(long value) => throw new NotImplementedException(); + public override void Write(byte[] buffer, int offset, int count) => throw new NotImplementedException(); + } \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/Helpers/StreamExtensions.cs b/src/UiPath.Ipc.Tests/Helpers/StreamExtensions.cs new file mode 100644 index 00000000..82174e14 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/StreamExtensions.cs @@ -0,0 +1,27 @@ +namespace UiPath.Ipc.Tests; + +public static class StreamExtensions +{ + public static async Task ReadExactlyAsync(this Stream stream, byte[] buffer, int offset, int length, CancellationToken ct = default) + { + while (length > 0) + { + var cbRead = await stream.ReadAsync(buffer, offset, length, ct); + if (cbRead == 0) + { + throw new EndOfStreamException(); + } + + offset += cbRead; + length -= cbRead; + } + } + + public static async Task ReadToEndAsync(this Stream stream, CancellationToken ct = default) + { + using var memory = new MemoryStream(); + await stream.CopyToAsync(memory, bufferSize: 8192, ct); + return memory.ToArray(); + } + +} diff --git a/src/UiPath.Ipc.Tests/Helpers/TestRunId.cs b/src/UiPath.Ipc.Tests/Helpers/TestRunId.cs new file mode 100644 index 00000000..f76d43c8 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/TestRunId.cs @@ -0,0 +1,32 @@ +namespace UiPath.Ipc.Tests; + +public readonly record struct TestRunId(Guid Value) +{ + public static TestRunId New() => new(Guid.NewGuid()); +} + +public static class ProcessHelper +{ + public static async Task RunReturnStdOut(this Process process) + { + process.StartInfo.UseShellExecute = false; + process.StartInfo.RedirectStandardOutput = true; + process.StartInfo.RedirectStandardError = true; + + TaskCompletionSource tcsProcessExited = new(); + process.EnableRaisingEvents = true; + process.Exited += (_, _) => tcsProcessExited.SetResult(null); + + _ = process.Start(); + await tcsProcessExited.Task; + + var stdOut = await process.StandardOutput.ReadToEndAsync(); + if (process.ExitCode is not 0) + { + var stdErr = await process.StandardError.ReadToEndAsync(); + throw new InvalidOperationException($"The process exited with a non zero code. ExitCode={process.ExitCode}\r\nStdOut:\r\n{stdOut}\r\n\r\nStdErr:\r\n{stdErr}"); + } + + return stdOut; + } +} \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/Helpers/Timeouts.cs b/src/UiPath.Ipc.Tests/Helpers/Timeouts.cs new file mode 100644 index 00000000..d09e1e2e --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/Timeouts.cs @@ -0,0 +1,12 @@ +namespace UiPath.Ipc.Tests; + +internal static class Timeouts +{ + public static readonly TimeSpan LocalProxyToThrowOCE = TimeSpan.FromMilliseconds(200); + + public static readonly TimeSpan IpcRoundtrip = TimeSpan.FromMilliseconds(800); + + public static readonly TimeSpan Short = TimeSpan.FromMilliseconds(300); + + public static readonly TimeSpan DefaultRequest = Debugger.IsAttached ? TimeSpan.FromDays(1) : TimeSpan.FromMinutes(1); +} diff --git a/src/UiPath.Ipc.Tests/Helpers/TracedStream.cs b/src/UiPath.Ipc.Tests/Helpers/TracedStream.cs new file mode 100644 index 00000000..e9648056 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/TracedStream.cs @@ -0,0 +1,16 @@ +namespace UiPath.Ipc.Tests; + +internal sealed class TracedStream(Stream target) : StreamBase +{ + private readonly MemoryStream _bytes = new(); + + public byte[] GetTrace() => _bytes.ToArray(); + + public override long Length => target.Length; + public override async Task ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) + { + var cbRead = await target.ReadAsync(buffer, offset, count, cancellationToken); + _bytes.Write(buffer, offset, cbRead); + return cbRead; + } +} diff --git a/src/UiPath.Ipc.Tests/Helpers/WebSocketContext.cs b/src/UiPath.Ipc.Tests/Helpers/WebSocketContext.cs new file mode 100644 index 00000000..5fb55217 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Helpers/WebSocketContext.cs @@ -0,0 +1,30 @@ +namespace UiPath.Ipc.Tests; + +internal sealed class WebSocketContext : IAsyncDisposable +{ + private readonly HttpSysWebSocketsListener _httpListener; + + public Accept Accept => _httpListener.Accept; + public Uri ClientUri { get; } + + public WebSocketContext(int? port = null) + { + var actualPort = port ?? NetworkHelper.FindFreeLocalPort().Port; + ClientUri = Uri("ws"); + _httpListener = new(uriPrefix: Uri("http").ToString()); + + Uri Uri(string scheme) => new UriBuilder(scheme, "localhost", actualPort).Uri; + } + + public async ValueTask DisposeAsync() + { + try + { + await _httpListener.DisposeAsync(); + } + catch (Exception ex) + { + Trace.TraceError($"Disposing the http listener threw: {ex}"); + } + } +} diff --git a/src/UiPath.Ipc.Tests/Polyfills/CallerArgumentExpressionAttribute.cs b/src/UiPath.Ipc.Tests/Polyfills/CallerArgumentExpressionAttribute.cs new file mode 100644 index 00000000..0032e3dd --- /dev/null +++ b/src/UiPath.Ipc.Tests/Polyfills/CallerArgumentExpressionAttribute.cs @@ -0,0 +1,36 @@ +#pragma warning disable + +#if !NET5_0_OR_GREATER + +namespace System.Runtime.CompilerServices; + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; + +// +// Summary: +// Allows capturing of the expressions passed to a method. +[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)] +internal sealed class CallerArgumentExpressionAttribute : Attribute +{ + // + // Summary: + // Initializes a new instance of the System.Runtime.CompilerServices.CallerArgumentExpressionAttribute + // class. + // + // Parameters: + // parameterName: + // The name of the targeted parameter. + public CallerArgumentExpressionAttribute(string parameterName) => ParameterName = parameterName; + + // + // Summary: + // Gets the target parameter name of the CallerArgumentExpression. + // + // Returns: + // The name of the targeted parameter of the CallerArgumentExpression. + public string ParameterName { get; } +} + + +#endif \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/Polyfills/IsExternalInit.cs b/src/UiPath.Ipc.Tests/Polyfills/IsExternalInit.cs new file mode 100644 index 00000000..dc521fbf --- /dev/null +++ b/src/UiPath.Ipc.Tests/Polyfills/IsExternalInit.cs @@ -0,0 +1,19 @@ +#pragma warning disable + +#if !NET5_0_OR_GREATER + +namespace System.Runtime.CompilerServices; + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; + +/// +/// Reserved to be used by the compiler for tracking metadata. This class should not be used by developers in source code. +/// +[ExcludeFromCodeCoverage] +[DebuggerNonUserCode] +internal static class IsExternalInit +{ +} + +#endif \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/Polyfills/System_Index.cs b/src/UiPath.Ipc.Tests/Polyfills/System_Index.cs new file mode 100644 index 00000000..177b155c --- /dev/null +++ b/src/UiPath.Ipc.Tests/Polyfills/System_Index.cs @@ -0,0 +1,151 @@ +// +#pragma warning disable + +#if !NET5_0_OR_GREATER + +namespace System; + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; + +/// Represent a type can be used to index a collection either from the start or the end. +/// +/// Index is used by the C# compiler to support the new index syntax +/// +/// int[] someArray = new int[5] { 1, 2, 3, 4, 5 } ; +/// int lastElement = someArray[^1]; // lastElement = 5 +/// +/// +[ExcludeFromCodeCoverage] +[DebuggerNonUserCode] +internal readonly struct Index : IEquatable +{ + readonly int _value; + + /// Construct an Index using a value and indicating if the index is from the start or from the end. + /// The index value. it has to be zero or positive number. + /// Indicating if the index is from the start or from the end. + /// + /// If the Index constructed from the end, index value 1 means pointing at the last element and index value 0 means pointing at beyond last element. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Index(int value, bool fromEnd = false) + { + if (value < 0) + { + throw new ArgumentOutOfRangeException(nameof(value)); + } + + if (fromEnd) + { + _value = ~value; + } + else + { + _value = value; + } + } + + // The following private constructors mainly created for perf reason to avoid the checks + Index(int value) => + _value = value; + + /// Create an Index pointing at first element. + public static Index Start => new(0); + + /// Create an Index pointing at beyond last element. + public static Index End => new(~0); + + /// Create an Index from the start at the position indicated by the value. + /// The index value from the start. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Index FromStart(int value) + { + if (value < 0) + { + throw new IndexOutOfRangeException(nameof(value)); + } + + return new(value); + } + + /// Create an Index from the end at the position indicated by the value. + /// The index value from the end. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Index FromEnd(int value) + { + if (value < 0) + { + throw new IndexOutOfRangeException(nameof(value)); + } + + return new(~value); + } + + /// Returns the index value. + public int Value + { + get + { + if (_value < 0) + { + return ~_value; + } + + return _value; + } + } + + /// Indicates whether the index is from the start or the end. + public bool IsFromEnd => _value < 0; + + /// Calculate the offset from the start using the giving collection length. + /// The length of the collection that the Index will be used with. length has to be a positive value + /// + /// For performance reason, we don't validate the input length parameter and the returned offset value against negative values. + /// we don't validate either the returned offset is greater than the input length. + /// It is expected Index will be used with collections which always have non negative length/count. If the returned offset is negative and + /// then used to index a collection will get out of range exception which will be same affect as the validation. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int GetOffset(int length) + { + var offset = _value; + if (IsFromEnd) + { + offset += length + 1; + } + + return offset; + } + + /// Indicates whether the current Index object is equal to another object of the same type. + /// An object to compare with this object + public override bool Equals(object value) => value is Index index && _value == index._value; + + /// Indicates whether the current Index object is equal to another Index object. + /// An object to compare with this object + public bool Equals(Index other) => _value == other._value; + + /// Returns the hash code for this instance. + public override int GetHashCode() => _value; + + /// Converts integer number to an Index. + public static implicit operator Index(int value) => FromStart(value); + + /// Converts the value of the current Index object to its equivalent string representation. + public override string ToString() + { + if (IsFromEnd) + { + return ToStringFromEnd(); + } + + return ((uint)Value).ToString(); + } + + string ToStringFromEnd() => + '^' + Value.ToString(); +} +#endif \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/Program.cs b/src/UiPath.Ipc.Tests/Program.cs new file mode 100644 index 00000000..6e917ad3 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Program.cs @@ -0,0 +1,33 @@ +using Microsoft.Extensions.Logging; +using Newtonsoft.Json; +using System.Text; +using UiPath.Ipc; +using UiPath.Ipc.Tests; + +if (args is not [var base64]) +{ + Console.Error.WriteLine($"Usage: dotnet {Path.GetFileName(Assembly.GetEntryAssembly()!.Location)} "); + return 1; +} +var externalServerParams = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(Convert.FromBase64String(base64))); +await using var asyncDisposable = externalServerParams.CreateListenerConfig(out var listener); + +await using var serviceProvider = new ServiceCollection() + .AddLogging(builder => builder.AddConsole()) + .AddSingleton() + .BuildServiceProvider(); + +await using var ipcServer = new IpcServer() +{ + ServiceProvider = serviceProvider, + Scheduler = new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler, + Endpoints = new() + { + { typeof(IComputingService) }, + }, + Listeners = [listener], +}; +ipcServer.Start(); +await ipcServer.WaitForStop(); + +return 0; \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/Services/ArithmeticCallback.cs b/src/UiPath.Ipc.Tests/Services/ArithmeticCallback.cs new file mode 100644 index 00000000..4493a934 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Services/ArithmeticCallback.cs @@ -0,0 +1,7 @@ +namespace UiPath.Ipc.Tests; + +public sealed class ArithmeticCallback : IArithmeticCallback +{ + public async Task Increment(int x) => x + 1; +} + diff --git a/src/UiPath.Ipc.Tests/Services/ComputingCallback.cs b/src/UiPath.Ipc.Tests/Services/ComputingCallback.cs new file mode 100644 index 00000000..630a8c71 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Services/ComputingCallback.cs @@ -0,0 +1,11 @@ +namespace UiPath.Ipc.Tests; + +public sealed class ComputingCallback : IComputingCallback +{ + public Guid Id { get; } = Guid.NewGuid(); + + public async Task GetThreadName() => Thread.CurrentThread.Name!; + + public async Task AddInts(int x, int y) => x + y; +} + diff --git a/src/UiPath.Ipc.Tests/Services/ComputingService.cs b/src/UiPath.Ipc.Tests/Services/ComputingService.cs new file mode 100644 index 00000000..32ea7a7f --- /dev/null +++ b/src/UiPath.Ipc.Tests/Services/ComputingService.cs @@ -0,0 +1,66 @@ +using Microsoft.Extensions.Logging; + +namespace UiPath.Ipc.Tests; + +public sealed class ComputingService(ILogger logger) : IComputingService +{ + private static readonly AsyncLocal CallContextStorage = new(); + public static string? CallContext + { + get => CallContextStorage.Value; + set => CallContextStorage.Value = value; + } + + public async Task AddFloats(float a, float b, CancellationToken ct = default) + { + logger.LogInformation($"{nameof(AddFloats)} called."); + return a + b; + } + + public async Task AddComplexNumbers(ComplexNumber a, ComplexNumber b) + { + logger.LogInformation($"{nameof(AddComplexNumbers)} called."); + return a + b; + } + + public async Task Wait(TimeSpan duration, CancellationToken ct = default) + { + await Task.Delay(duration, ct); + return true; + } + + public async Task GetCallbackThreadName(TimeSpan waitOnServer, Message message = null!, CancellationToken cancellationToken = default) + { + await Task.Delay(waitOnServer); + return await message.GetCallback().GetThreadName(); + } + + public async Task AddComplexNumberList(IReadOnlyList numbers) + { + var result = ComplexNumber.Zero; + foreach (var number in numbers) + { + result += number; + } + return result; + } + + public async Task MultiplyInts(int x, int y, Message message = null!) + { + var callback = message.GetCallback(); + + var result = 0; + for (int i = 0; i < y; i++) + { + result = await callback.AddInts(result, x); + } + + return result; + } + + public async Task GetCallContext() + { + await Task.Delay(1).ConfigureAwait(continueOnCapturedContext: false); + return CallContext; + } +} diff --git a/src/UiPath.Ipc.Tests/Services/IComputingService.cs b/src/UiPath.Ipc.Tests/Services/IComputingService.cs new file mode 100644 index 00000000..dd5bce90 --- /dev/null +++ b/src/UiPath.Ipc.Tests/Services/IComputingService.cs @@ -0,0 +1,48 @@ + +namespace UiPath.Ipc.Tests; + +public interface IComputingServiceBase +{ + Task AddFloats(float x, float y, CancellationToken ct = default); +} + +public interface IComputingService : IComputingServiceBase +{ + Task AddComplexNumbers(ComplexNumber a, ComplexNumber b); + Task Wait(TimeSpan duration, CancellationToken ct = default); + Task GetCallbackThreadName(TimeSpan waitOnServer, Message message = null!, CancellationToken cancellationToken = default); + Task AddComplexNumberList(IReadOnlyList numbers); + Task MultiplyInts(int x, int y, Message message = null!); + Task GetCallContext(); +} + +public interface IComputingCallbackBase +{ + Task AddInts(int x, int y); +} + +public interface IComputingCallback : IComputingCallbackBase +{ + Task GetThreadName(); +} + +public interface IArithmeticCallback +{ + Task Increment(int x); +} + +public readonly record struct ComplexNumber +{ + public static readonly ComplexNumber Zero = default; + public static ComplexNumber operator +(ComplexNumber a, ComplexNumber b) + => new() + { + I = a.I + b.I, + J = a.J + b.J + }; + + public required float I { get; init; } + public required float J { get; init; } + + public override string ToString() => $"[{I}, {J}]"; +} \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/Services/ISystemService.cs b/src/UiPath.Ipc.Tests/Services/ISystemService.cs new file mode 100644 index 00000000..574b9abd --- /dev/null +++ b/src/UiPath.Ipc.Tests/Services/ISystemService.cs @@ -0,0 +1,45 @@ +namespace UiPath.Ipc.Tests; + +public interface ISystemService +{ + /// + /// Returns the after the is ellapsed. + /// + /// The duration to wait before completing the operation. + /// A to cancel the operation. + /// A task that completes successfully with a null result, after the specified , or is canceled when the passed is signaled. + Task EchoGuidAfter(Guid value, TimeSpan waitOnServer, Message? message = null, CancellationToken ct = default); + + /// + /// Returns true if the received is not null. + /// + /// An optional . + /// + Task MessageReceivedAsNotNull(Message? message = null); + + /// + /// A method that does not return a result and whose algorithm will not be awaited by the remote client. + /// + /// A task that completes when the Ipc infrastructure confirms that the operation has begun but way before it has ended. + Task FireAndForget(); + + Task EchoString(string value); + + Task<(string ExceptionType, string ExceptionMessage, string? MarshalledExceptionType)?> CallUnregisteredCallback(Message message = null!); + + Task FireAndForgetThrowSync(); + + Task GetThreadName(); + + Task UploadEcho(Stream stream, CancellationToken ct = default); + + Task UploadJustCountBytes(Stream stream, int serverReadByteCount, TimeSpan serverDelay, CancellationToken ct = default); + Task Download(string s, CancellationToken ct = default); + + Task AddIncrement(int x, int y, Message message = null!); +} + +public interface IUnregisteredCallback +{ + Task SomeMethod(); +} diff --git a/src/UiPath.Ipc.Tests/Services/SystemService.cs b/src/UiPath.Ipc.Tests/Services/SystemService.cs new file mode 100644 index 00000000..07821b2e --- /dev/null +++ b/src/UiPath.Ipc.Tests/Services/SystemService.cs @@ -0,0 +1,82 @@ +using System.Buffers; +using System.Text; + +namespace UiPath.Ipc.Tests; + +public sealed class SystemService : ISystemService +{ + public async Task EchoGuidAfter(Guid value, TimeSpan waitOnServer, Message? message = null, CancellationToken ct = default) + { + await Task.Delay(waitOnServer, ct); + return value; + } + + public async Task MessageReceivedAsNotNull(Message? message = null) + => message is not null; + + private volatile TaskCompletionSource? _tripWire = null; + internal Task ResetTripWire() => (_tripWire = new()).Task; + public const int MsFireAndForgetDelay = +#if CI + 400; +#else + 40; +#endif + public async Task FireAndForget() + { + await Task.Delay(MsFireAndForgetDelay); + _tripWire?.TrySetResult(null); + } + + public Task EchoString(string value) => Task.FromResult(value); + + public async Task<(string ExceptionType, string ExceptionMessage, string? MarshalledExceptionType)?> CallUnregisteredCallback(Message message = null!) + { + try + { + _ = await message.GetCallback().SomeMethod(); + return null; + } + catch (Exception ex) + { + return (ex.GetType().Name, ex.Message, (ex as RemoteException)?.Type); + } + } + + public Task FireAndForgetThrowSync() => throw new MarkerException(); + + public sealed class MarkerException : Exception { } + + public async Task GetThreadName() => Thread.CurrentThread.Name; + + public async Task UploadEcho(Stream stream, CancellationToken ct = default) + { + var bytes = await stream.ReadToEndAsync(ct); + return Encoding.UTF8.GetString(bytes); + } + + public async Task UploadJustCountBytes(Stream stream, int serverReadByteCount, TimeSpan serverDelay, CancellationToken ct = default) + { + var buffer = ArrayPool.Shared.Rent(serverReadByteCount); + try + { + await Task.Delay(serverDelay, ct); + await stream.ReadExactlyAsync(buffer, 0, serverReadByteCount, ct); + return true; + } + finally + { + ArrayPool.Shared.Return(buffer); + } + } + + public async Task Download(string s, CancellationToken ct = default) + => new MemoryStream(Encoding.UTF8.GetBytes(s)); + + public async Task AddIncrement(int x, int y, Message message = null!) + { + var sum = await message.GetCallback().AddInts(x, y); + var result = await message.GetCallback().Increment(sum); + return result; + } +} diff --git a/src/UiPath.Ipc.Tests/SystemTests.cs b/src/UiPath.Ipc.Tests/SystemTests.cs new file mode 100644 index 00000000..1ac05d85 --- /dev/null +++ b/src/UiPath.Ipc.Tests/SystemTests.cs @@ -0,0 +1,436 @@ +using AutoFixture; +using AutoFixture.Xunit2; +using Microsoft.Extensions.Hosting; +using System.Text; +using System.Threading.Channels; +using Xunit.Abstractions; + +namespace UiPath.Ipc.Tests; + +public abstract class SystemTests : TestBase +{ + #region " Setup " + private readonly Lazy _service; + private readonly Lazy _proxy; + + protected SystemService Service => _service.Value; + protected ISystemService Proxy => _proxy.Value!; + + protected sealed override IpcProxy IpcProxy => Proxy as IpcProxy ?? throw new InvalidOperationException($"Proxy was expected to be a {nameof(IpcProxy)} but was not."); + protected sealed override Type ContractType => typeof(ISystemService); + + protected SystemTests(ITestOutputHelper outputHelper) : base(outputHelper) + { + ServiceProvider.InjectLazy(out _service); + CreateLazyProxy(out _proxy); + } + + protected override ListenerConfig ConfigTransportAgnostic(ListenerConfig listener) + => listener with + { + ConcurrentAccepts = 10, + RequestTimeout = Timeouts.DefaultRequest, + MaxReceivedMessageSizeInMegabytes = 1, + }; + protected override ClientConfig CreateClientConfig(EndpointCollection? callbacks = null) + => new() + { + RequestTimeout = Timeouts.DefaultRequest, + ServiceProvider = ServiceProvider, + Callbacks = callbacks + }; + #endregion + + [Theory, IpcAutoData] + public async Task PassingArgsAndReturning_ShouldWork(Guid guid) + { + var clone = await Proxy.EchoGuidAfter(guid, TimeSpan.Zero); + clone.ShouldBe(guid); + } + + [Theory, IpcAutoData] + public async Task ConcurrentOperations_ShouldWork(Guid guid1, Guid guid2) + { + using var cts = new CancellationTokenSource(); + var task1 = Proxy.EchoGuidAfter(guid1, Timeout.InfiniteTimeSpan, message: null, cts.Token); + + (await Proxy.EchoGuidAfter(guid2, TimeSpan.Zero)).ShouldBe(guid2); + + task1.IsCompleted.ShouldBeFalse(); + cts.Cancel(); + var act = () => task1.ShouldCompleteInAsync(Timeouts.LocalProxyToThrowOCE); + await act.ShouldThrowAsync(); + } + + [Fact] + public async Task NotPassingAnOptionalMessage_ShouldWork() + => await Proxy + .MessageReceivedAsNotNull(message: null) + .ShouldCompleteInAsync(Timeouts.IpcRoundtrip) + .ShouldNotThrowAsyncAnd() + .ShouldBeAsync(true); + + [Fact] + [OverrideConfig(typeof(ServerExecutingTooLongACall_ShouldThrowTimeout_Config))] + public async Task ServerExecutingTooLongACall_ShouldThrowTimeout() + => await Proxy.EchoGuidAfter(Guid.Empty, Timeout.InfiniteTimeSpan) // method takes forever but we have a server side RequestTimeout configured + .ShouldThrowAsync() + .ShouldSatisfyAllConditionsAsync( + [ + ex => ex.Message.ShouldBe(TimeoutHelper.ComputeTimeoutMessage(nameof(Proxy.EchoGuidAfter))), + ex => ex.Is().ShouldBeTrue() + ]); + + [Fact] + [OverrideConfig(typeof(ClientWaitingForTooLongACall_ShouldThrowTimeout_Config))] + public async Task ClientWaitingForTooLongACall_ShouldThrowTimeout() + => await Proxy.EchoGuidAfter(Guid.Empty, Timeout.InfiniteTimeSpan) // method takes forever but we have a server side RequestTimeout configured + .ShouldThrowAsync(); + + private sealed class ServerExecutingTooLongACall_ShouldThrowTimeout_Config : OverrideConfig + { + public override async Task Override(Func> listener) => await listener() with { RequestTimeout = Timeouts.Short }; + public override IpcClient? Override(Func client) + => client().WithRequestTimeout(Timeout.InfiniteTimeSpan); + } + + private sealed class ClientWaitingForTooLongACall_ShouldThrowTimeout_Config : OverrideConfig + { + public override async Task Override(Func> listener) => await listener() with { RequestTimeout = Timeout.InfiniteTimeSpan }; + public override IpcClient? Override(Func client) + => client().WithRequestTimeout(Timeouts.IpcRoundtrip); + } + + private ListenerConfig ShortClientTimeout(ListenerConfig listener) => listener with { RequestTimeout = TimeSpan.FromMilliseconds(100) }; + private ListenerConfig InfiniteServerTimeout(ListenerConfig listener) => listener with { RequestTimeout = Timeout.InfiniteTimeSpan }; + + [Fact] + public async Task FireAndForget_ShouldWork() + { + var taskRequestHonoured = Service.ResetTripWire(); + + await Proxy.FireAndForget().ShouldCompleteInAsync(Timeouts.IpcRoundtrip); + taskRequestHonoured.IsCompleted.ShouldBeFalse(); + + await taskRequestHonoured.ShouldCompleteInAsync(Timeouts.IpcRoundtrip + TimeSpan.FromMilliseconds(SystemService.MsFireAndForgetDelay)); + } + + [Fact] + public async Task ExceedingMsgSize_ShouldBreakNetwork_ButShouldBeRecoverable() + { + const string Little = "a"; + + const int KB = 1024; + const int MB = 1024 * KB; + var TooBig = new string('a', 2 * MB); + + // Prime the connection + await Proxy.EchoString(Little).ShouldBeAsync(Little); + var originalNetwork = (Proxy as IpcProxy)!.Network! + .ShouldNotBeNull(); + + // Send a message that is too big, the network should be closed + await Proxy.EchoString(TooBig).ShouldThrowAsync(); + + // Send a regular message, the connection should be reestablished + await Proxy.EchoString(Little).ShouldBeAsync(Little); + + (Proxy as IpcProxy)!.Network! + .ShouldNotBeNull() + .ShouldNotBeSameAs(originalNetwork); + } + + [Fact] + public async Task ServerCallingInexistentCallback_ShouldThrow() + { + var (exceptionType, exceptionMessage, marshalledExceptionType) = (await Proxy.CallUnregisteredCallback()).ShouldNotBeNull(); + exceptionType.ShouldBe(nameof(RemoteException)); + marshalledExceptionType.ShouldBe(typeof(EndpointNotFoundException).FullName); + } + + [Fact] + public async Task ServerCallingInexistentCallback_ShouldThrow2() + => await Proxy.AddIncrement(1, 2).ShouldThrowAsync() + .ShouldSatisfyAllConditionsAsync([ + ex => ex.Is() + ]); + + [Fact, OverrideConfig(typeof(RegisterCallbacks))] + public async Task ServerCallingMultipleCallbackTypes_ShouldWork() + => await Proxy.AddIncrement(1, 2).ShouldBeAsync(1 + 2 + 1); + + private sealed class RegisterCallbacks : OverrideConfig + { + public override IpcClient? Override(Func client) + => client().WithCallbacks(new() + { + { typeof(IComputingCallback), new ComputingCallback() }, + { typeof(IArithmeticCallback), new ArithmeticCallback() }, + }); + } + + [Fact] + public async Task FireAndForgetOperations_ShouldNotDeliverBusinessExceptionsEvenWhenThrownSynchronously() + => await Proxy.FireAndForgetThrowSync() + .ShouldNotThrowAsync() + .ShouldCompleteInAsync(Timeouts.IpcRoundtrip); + + [Fact] + public async Task ServerScheduler_ShouldBeUsed() + => await Proxy.GetThreadName() + .ShouldBeAsync(Names.GuiThreadName); + + [Theory, IpcAutoData] + public async Task UploadingStreams_ShouldWork(string str) + { + using var memory = new MemoryStream(Encoding.UTF8.GetBytes(str)); + await Proxy.UploadEcho(memory).ShouldBeAsync(str); + } + + [Theory, IpcAutoData] + public async Task CancelingStreamUploads_ShouldThrow(string str, Guid guid) + { + var sourceMemory = new Memory(Encoding.UTF8.GetBytes(str)); + + using var cts = new CancellationTokenSource(); + using var stream = new UploadStream(); + + var taskReadCall = stream.AwaitReadCall(); + + var taskUploading = Proxy.UploadEcho(stream, cts.Token); + + var readCall = await taskReadCall.ShouldCompleteInAsync(TimeSpan.FromSeconds(60));// Constants.Timeout_IpcRoundtrip); + stream.AutoRespondByte = (byte)'a'; + var cbRead = Math.Min(readCall.Memory.Length, sourceMemory.Length); + var sourceSlice = sourceMemory.Slice(start: 0, cbRead); + sourceSlice.CopyTo(readCall.Memory); + var expectedServerRead = Encoding.UTF8.GetString(sourceSlice.ToArray()); + + readCall.Return(cbRead); + + taskUploading.IsCompleted.ShouldBeFalse(); + + await Task.Delay(Timeouts.IpcRoundtrip); // we just replied to the read call, but canceling during stream uploads works by destroying the network + var networkBeforeCancel = IpcProxy.Network; + cts.Cancel(); + + await taskUploading + .ShouldThrowAsync() + .ShouldCompleteInAsync(Timeouts.Short); // in-process scheduling fast + + await Proxy.EchoGuidAfter(guid, waitOnServer: TimeSpan.Zero) // we expect the connection to recover + .ShouldBeAsync(guid); + + IpcProxy.Network.ShouldNotBeNull().ShouldNotBeSameAs(networkBeforeCancel); // and the network to be a new one + } + + [Theory, IpcAutoData] + public async Task UnfinishedUploads_ShouldThrowOnTheClient_AndRecover(Guid guid) + { + var stream = new UploadStream() { AutoRespondByte = 0 }; + + await Proxy.UploadJustCountBytes(stream, serverReadByteCount: 1, TimeSpan.Zero) // the server method deliberately returns before finishing to read the entire stream + .ShouldThrowAsync(); + + var act = async () => + { + while (true) + { + try + { + var actual = await Proxy.EchoGuidAfter(guid, TimeSpan.Zero); + actual.ShouldBe(guid); + return; + } + catch + { + } + await Task.Delay(100); + } + }; + await act().ShouldCompleteInAsync(TimeSpan.FromSeconds(5)); + } + +#if !CI + [Theory, IpcAutoData] +#endif + public async Task UnfinishedUploads_ShouldThrowOnTheClient_AndRecover_Repeat(Guid guid) + { + const int IterationCount = 500; + foreach (var i in Enumerable.Range(1, IterationCount)) + { + _outputHelper.WriteLine($"Starting iteration {i}/{IterationCount}..."); + await UnfinishedUploads_ShouldThrowOnTheClient_AndRecover(guid); + _outputHelper.WriteLine($"Finished iteration {i}/{IterationCount}."); + } + } + + [Theory, IpcAutoData] + public async Task DownloadingStreams_ShouldWork(string str) + { + using var stream = await Proxy.Download(str); + using var reader = new StreamReader(stream); + var clone = await reader.ReadToEndAsync(); + clone.ShouldBe(str); + } + +#if !CI + [Theory, MemberData(nameof(DownloadingStreams_ShouldWork_Repeat_Cases))] +#endif + public async Task DownloadingStreams_ShouldWork_Repeat(int index, string str) + { + _outputHelper.WriteLine($"Calling {nameof(DownloadingStreams_ShouldWork)}[{index}]"); + await DownloadingStreams_ShouldWork(str); + } + + public static IEnumerable DownloadingStreams_ShouldWork_Repeat_Cases() + { + var fixture = IpcAutoDataAttribute.CreateFixture(); + const int CTimes = 100; + + foreach (var time in Enumerable.Range(1, CTimes)) + { + yield return [time, fixture.Create()]; + } + } + + [Theory, IpcAutoData] + public async Task StreamDownloadsClosedUnfinished_ShouldNotAffectTheConnection(string str, Guid guid) + { + using (var stream = await Proxy.Download(str)) + { + } + + await Proxy.EchoGuidAfter(guid, TimeSpan.Zero) + .ShouldBeAsync(guid) + .ShouldCompleteInAsync(Timeouts.IpcRoundtrip); + } + + [Theory, IpcAutoData] + public async Task StreamDownloadsLeftOpen_WillHijackTheConnection(string str, Guid guid) + { + using (var stream = await Proxy.Download(str)) + { + await new StreamReader(stream).ReadToEndAsync() + .ShouldBeAsync(str); + + await Proxy.EchoGuidAfter(guid, waitOnServer: TimeSpan.Zero, message: new() { RequestTimeout = Timeout.InfiniteTimeSpan }) + .ShouldStallForAtLeastAsync(Timeouts.IpcRoundtrip); + } + } + +#if !CI + [Theory, IpcAutoData] +#endif + public async Task StreamDownloadsLeftOpen_WillHijackTheConnection_Repeat(string str, Guid guid) + { + const int IterationCount = 20; + foreach (var i in Enumerable.Range(0, IterationCount)) + { + await StreamDownloadsLeftOpen_WillHijackTheConnection(str, guid); + } + } + + [Theory, IpcAutoData] + public async Task IpcServerDispose_ShouldBeIdempotent(Guid guid) + { + await Proxy.EchoGuidAfter(guid, waitOnServer: default).ShouldBeAsync(guid); + var infiniteTask = Proxy.EchoGuidAfter(guid, Timeout.InfiniteTimeSpan); + + using (var host = Host.CreateDefaultBuilder() + .ConfigureServices(services => services.AddHostedSingleton()) + .Build()) + { + await host.StartAsync(); + var hostedIpcServer = host.Services.GetRequiredService(); + hostedIpcServer.Set(IpcServer!); + await host.StopAsync(); + } + + await IpcServer!.DisposeAsync(); + await IpcServer!.DisposeAsync(); + await infiniteTask.ShouldThrowAsync().ShouldCompleteInAsync(Timeouts.IpcRoundtrip); + } + + private sealed class UploadStream : StreamBase + { + private readonly Channel _readCalls = Channel.CreateUnbounded(); + + public byte? AutoRespondByte { get; set; } + + public async Task AwaitReadCall(CancellationToken ct = default) => await _readCalls.Reader.ReadAsync(ct); + + public override long Length => long.MaxValue; + public override bool CanRead => true; + public override Task ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) + { + if (AutoRespondByte is { } @byte) + { + if (@byte > 0) + { + buffer.AsSpan().Slice(offset, count).Fill(@byte); + } + + return Task.FromResult(count); + } + + var memory = new Memory(buffer, offset, count); + var call = new ReadCall(out var task) + { + Memory = new(buffer, offset, count), + CancellationToken = cancellationToken + }; + + if (!_readCalls.Writer.TryWrite(call)) + { + throw new InvalidOperationException(); + } + + return task; + } + + public sealed class ReadCall + { + public required Memory Memory { get; init; } + public required CancellationToken CancellationToken { get; init; } + + private readonly TaskCompletionSource _tcs = new(); + + public ReadCall(out Task task) => task = _tcs.Task; + + public void Return(int cbRead) => _tcs.TrySetResult(cbRead); + } + } + + private interface IHostedIpcServer + { + void Set(IpcServer ipcServer); + } + + private sealed class HostedIpcServer : IHostedService, IHostedIpcServer, IAsyncDisposable + { + private IpcServer? _ipcServer; + + public void Set(IpcServer ipcServer) => _ipcServer = ipcServer; + + public Task StartAsync(CancellationToken cancellationToken) => Task.CompletedTask; + + public async Task StopAsync(CancellationToken cancellationToken) + { + await _ipcServer!.DisposeAsync(); + } + + public async ValueTask DisposeAsync() + { + try + { + await _ipcServer!.DisposeAsync(); + } + catch (Exception ex) + { + Debug.WriteLine(ex.ToString()); + throw; + } + } + } +} \ No newline at end of file diff --git a/src/UiPath.Ipc.Tests/SystemTestsOverNamedPipes.cs b/src/UiPath.Ipc.Tests/SystemTestsOverNamedPipes.cs new file mode 100644 index 00000000..ebcdac6c --- /dev/null +++ b/src/UiPath.Ipc.Tests/SystemTestsOverNamedPipes.cs @@ -0,0 +1,21 @@ +using UiPath.Ipc.Transport.NamedPipe; +using Xunit.Abstractions; + +namespace UiPath.Ipc.Tests; + +public sealed class SystemTestsOverNamedPipes : SystemTests +{ + private string PipeName => Names.GetPipeName(role: "system", TestRunId); + + public SystemTestsOverNamedPipes(ITestOutputHelper outputHelper) : base(outputHelper) { } + + protected sealed override async Task CreateListener() => new NamedPipeListener + { + PipeName = PipeName + }; + protected sealed override ClientTransport CreateClientTransport() => new NamedPipeTransport() + { + PipeName = PipeName, + AllowImpersonation = true, + }; +} diff --git a/src/UiPath.Ipc.Tests/SystemTestsOverTcp.cs b/src/UiPath.Ipc.Tests/SystemTestsOverTcp.cs new file mode 100644 index 00000000..d1fefa1f --- /dev/null +++ b/src/UiPath.Ipc.Tests/SystemTestsOverTcp.cs @@ -0,0 +1,21 @@ +using System.Net; +using UiPath.Ipc.Transport.Tcp; +using Xunit.Abstractions; + +namespace UiPath.Ipc.Tests; + +public sealed class SystemTestsOverTcp : SystemTests +{ + private readonly IPEndPoint _endPoint = NetworkHelper.FindFreeLocalPort(); + + public SystemTestsOverTcp(ITestOutputHelper outputHelper) : base(outputHelper) { } + + protected sealed override async Task CreateListener() + => new TcpListener + { + EndPoint = _endPoint, + }; + + protected override ClientTransport CreateClientTransport() + => new TcpTransport() { EndPoint = _endPoint }; +} diff --git a/src/UiPath.Ipc.Tests/SystemTestsOverWebSockets.cs b/src/UiPath.Ipc.Tests/SystemTestsOverWebSockets.cs new file mode 100644 index 00000000..09598cf6 --- /dev/null +++ b/src/UiPath.Ipc.Tests/SystemTestsOverWebSockets.cs @@ -0,0 +1,31 @@ +using UiPath.Ipc.Transport.WebSocket; +using Xunit.Abstractions; + +namespace UiPath.Ipc.Tests; + +public sealed class SystemTestsOverWebSockets : SystemTests +{ + private readonly WebSocketContext _webSocketContext = new(); + + public SystemTestsOverWebSockets(ITestOutputHelper outputHelper) : base(outputHelper) { } + + protected override async Task DisposeAsync() + { + await _webSocketContext.DisposeAsync(); + await base.DisposeAsync(); + } + + protected override async Task CreateListener() + { + var listener = new WebSocketListener + { + Accept = _webSocketContext.Accept, + ConcurrentAccepts = 1, + }; + await Task.Delay(500); // Wait for the listener to start. + return listener; + } + + protected override ClientTransport CreateClientTransport() + => new WebSocketTransport() { Uri = _webSocketContext.ClientUri }; +} diff --git a/src/UiPath.Ipc.Tests/TestBase.cs b/src/UiPath.Ipc.Tests/TestBase.cs new file mode 100644 index 00000000..fe72ec3a --- /dev/null +++ b/src/UiPath.Ipc.Tests/TestBase.cs @@ -0,0 +1,158 @@ +using Nito.AsyncEx; +using System.Collections.Concurrent; +using System.Runtime.InteropServices; +using Xunit.Abstractions; + +namespace UiPath.Ipc.Tests; + +public abstract class TestBase : IAsyncLifetime +{ + protected readonly ITestOutputHelper _outputHelper; + private readonly IMethodInfo _xUnitMethod; + private readonly ServiceProvider _serviceProvider; + private readonly AsyncContext _guiThread = new AsyncContextThread().Context; + private readonly Lazy> _ipcServer; + private readonly Lazy _ipcClient; + private readonly OverrideConfig? _overrideConfig; + + protected TestRunId TestRunId { get; } = TestRunId.New(); + protected IServiceProvider ServiceProvider => _serviceProvider; + protected TaskScheduler GuiScheduler => _guiThread.Scheduler; + protected IpcServer? IpcServer { get; private set; } + protected abstract IpcProxy? IpcProxy { get; } + protected abstract Type ContractType { get; } + + protected readonly ConcurrentBag _serverBeforeCalls = new(); + protected Func? _tailBeforeCall = null; + + public TestBase(ITestOutputHelper outputHelper) + { + _outputHelper = outputHelper; + + _xUnitMethod = CustomTestFramework.Context?.Method ?? throw new InvalidOperationException(); + + string runtime = +#if NET461 + RuntimeInformation.FrameworkDescription +#else + $"{RuntimeInformation.FrameworkDescription}, {RuntimeInformation.RuntimeIdentifier}" +#endif + ; + _outputHelper.WriteLine($"[{runtime}] \"{_xUnitMethod.Name}\""); + _outputHelper.WriteLine("--------------------------------------\r\n"); + _overrideConfig = GetOverrideConfig(); + + _guiThread.SynchronizationContext.Send(() => Thread.CurrentThread.Name = Names.GuiThreadName); + _serviceProvider = IpcHelpers.ConfigureServices(_outputHelper); + + _ipcServer = new(CreateServer); + _ipcClient = new(() => CreateClient()); + + OverrideConfig? GetOverrideConfig() + { + var xUnitMethod = _xUnitMethod ?? throw new InvalidOperationException(); + + var overrideConfigType = xUnitMethod + .GetCustomAttributes(typeof(OverrideConfigAttribute)) + .SingleOrDefault()?.GetConstructorArguments() + .SingleOrDefault() as Type; + + if (overrideConfigType is null) + { + return null; + } + return Activator.CreateInstance(overrideConfigType) as OverrideConfig; + } + } + + private Task CreateListenerAndConfigure() + { + var factory = async () => + { + _outputHelper.WriteLine("Creating listener..."); + var listener = await CreateListener(); + listener = ConfigTransportAgnostic(listener); + return listener; + }; + + if (_overrideConfig is null) + { + return factory(); + } + + return _overrideConfig.Override(factory); + } + + protected async Task CreateServer() + { + if (await CreateListenerAndConfigure() is not { } listener) return null; + + return new() + { + Endpoints = new() { + new EndpointSettings(ContractType) + { + BeforeCall = (callInfo, ct) => + { + _serverBeforeCalls.Add(callInfo); + return _tailBeforeCall?.Invoke(callInfo, ct) ?? Task.CompletedTask; + } + } + }, + Listeners = [listener], + ServiceProvider = _serviceProvider, + Scheduler = GuiScheduler + }; + } + + protected IpcClient? CreateClient(EndpointCollection? callbacks = null) + { + var factory = () => + { + var config = CreateClientConfig(callbacks); + var transport = CreateClientTransport(); + var client = new IpcClient + { + Config = config, + Transport = transport + }; + return client; + }; + + if (_overrideConfig is null) + { + return factory(); + } + + return _overrideConfig.Override(factory); + } + private TContract? GetProxy() where TContract : class + => _ipcClient.Value?.GetProxy(); + + protected void CreateLazyProxy(out Lazy lazy) where TContract : class => lazy = new(GetProxy); + + protected abstract Task CreateListener(); + + protected abstract ClientConfig CreateClientConfig(EndpointCollection? callbacks = null); + protected abstract ClientTransport CreateClientTransport(); + + protected abstract ListenerConfig ConfigTransportAgnostic(ListenerConfig listener); + + protected virtual async Task DisposeAsync() + { + IpcProxy?.Dispose(); + await (IpcProxy?.CloseConnection() ?? default); + await (IpcServer?.DisposeAsync() ?? default); + _guiThread.Dispose(); + await _serviceProvider.DisposeAsync(); + } + + async Task IAsyncLifetime.InitializeAsync() + { + IpcServer = await _ipcServer.Value; + IpcServer?.Start(); + await (IpcServer?.WaitForStart() ?? Task.CompletedTask); + } + + Task IAsyncLifetime.DisposeAsync() => DisposeAsync(); +} diff --git a/src/UiPath.Ipc.Tests/UiPath.Ipc.Tests.csproj b/src/UiPath.Ipc.Tests/UiPath.Ipc.Tests.csproj new file mode 100644 index 00000000..dfa8469a --- /dev/null +++ b/src/UiPath.Ipc.Tests/UiPath.Ipc.Tests.csproj @@ -0,0 +1,52 @@ + + + + WinExe + net6.0;net461 + UiPath.Ipc.Tests + $(NoWarn);1998 + $(DefineConstants);$(DefineConstantsEx) + latest + true + enable + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/UiPath.Ipc.Tests/Xunit/CustomTestFramework.cs b/src/UiPath.Ipc.Tests/Xunit/CustomTestFramework.cs new file mode 100644 index 00000000..b954340b --- /dev/null +++ b/src/UiPath.Ipc.Tests/Xunit/CustomTestFramework.cs @@ -0,0 +1,120 @@ +using Xunit.Abstractions; +using Xunit.Sdk; + +[assembly: TestFramework(typeName: "UiPath.Ipc.Tests.CustomTestFramework", assemblyName: "UiPath.Ipc.Tests")] + +namespace UiPath.Ipc.Tests; + +public readonly struct CustomTestContext +{ + public required IMethodInfo Method { get; init; } +} + +public class CustomTestFramework : XunitTestFramework +{ + private static readonly AsyncLocal AsyncLocalContext = new(); + public static CustomTestContext? Context => AsyncLocalContext.Value; + + public CustomTestFramework(IMessageSink messageSink) + : base(messageSink) + { + messageSink.OnMessage(new DiagnosticMessage($"Using {nameof(CustomTestFramework)}")); + } + + protected override ITestFrameworkExecutor CreateExecutor(AssemblyName assemblyName) + => new CustomExecutor(assemblyName, SourceInformationProvider, DiagnosticMessageSink); + + private class CustomExecutor : XunitTestFrameworkExecutor + { + public CustomExecutor(AssemblyName assemblyName, ISourceInformationProvider sourceInformationProvider, IMessageSink diagnosticMessageSink) + : base(assemblyName, sourceInformationProvider, diagnosticMessageSink) + { + } + + protected override async void RunTestCases(IEnumerable testCases, IMessageSink executionMessageSink, ITestFrameworkExecutionOptions executionOptions) + { + using var assemblyRunner = new CustomAssemblyRunner(TestAssembly, testCases, DiagnosticMessageSink, executionMessageSink, executionOptions); + await assemblyRunner.RunAsync(); + } + } + + private class CustomAssemblyRunner : XunitTestAssemblyRunner + { + public CustomAssemblyRunner(ITestAssembly testAssembly, IEnumerable testCases, IMessageSink diagnosticMessageSink, IMessageSink executionMessageSink, ITestFrameworkExecutionOptions executionOptions) + : base(testAssembly, testCases, diagnosticMessageSink, executionMessageSink, executionOptions) + { + } + + protected override Task RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable testCases, CancellationTokenSource cancellationTokenSource) + => new CustomTestCollectionRunner(testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource).RunAsync(); + } + + private class CustomTestCollectionRunner : XunitTestCollectionRunner + { + public CustomTestCollectionRunner(ITestCollection testCollection, IEnumerable testCases, IMessageSink diagnosticMessageSink, IMessageBus messageBus, ITestCaseOrderer testCaseOrderer, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) + : base(testCollection, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource) + { + } + + protected override Task RunTestClassAsync(ITestClass testClass, IReflectionTypeInfo @class, IEnumerable testCases) + => new CustomTestClassRunner(testClass, @class, testCases, DiagnosticMessageSink, MessageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), CancellationTokenSource, CollectionFixtureMappings).RunAsync(); + } + + private class CustomTestClassRunner : XunitTestClassRunner + { + public CustomTestClassRunner(ITestClass testClass, IReflectionTypeInfo @class, IEnumerable testCases, IMessageSink diagnosticMessageSink, IMessageBus messageBus, ITestCaseOrderer testCaseOrderer, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource, IDictionary collectionFixtureMappings) + : base(testClass, @class, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource, collectionFixtureMappings) + { + } + + protected override Task RunTestMethodAsync(ITestMethod testMethod, IReflectionMethodInfo method, IEnumerable testCases, object[] constructorArguments) + => new CustomTestMethodRunner(testMethod, Class, method, testCases, DiagnosticMessageSink, MessageBus, new ExceptionAggregator(Aggregator), CancellationTokenSource, constructorArguments).RunAsync(); + } + + private class CustomTestMethodRunner : XunitTestMethodRunner + { + private readonly IMessageSink _diagnosticMessageSink; + + public CustomTestMethodRunner(ITestMethod testMethod, IReflectionTypeInfo @class, IReflectionMethodInfo method, IEnumerable testCases, IMessageSink diagnosticMessageSink, IMessageBus messageBus, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource, object[] constructorArguments) + : base(testMethod, @class, method, testCases, diagnosticMessageSink, messageBus, aggregator, cancellationTokenSource, constructorArguments) + { + _diagnosticMessageSink = diagnosticMessageSink; + } + + protected override async Task RunTestCaseAsync(IXunitTestCase testCase) + { + var parameters = string.Empty; + + if (testCase.TestMethodArguments != null) + { + parameters = string.Join(", ", testCase.TestMethodArguments.Select(a => a?.ToString() ?? "null")); + } + + var test = $"{TestMethod.TestClass.Class.Name}.{TestMethod.Method.Name}({parameters})"; + + _diagnosticMessageSink.OnMessage(new DiagnosticMessage($"STARTED: {test}")); + + try + { + AsyncLocalContext.Value = new() + { + Method = testCase.Method + }; + var result = await base.RunTestCaseAsync(testCase); + + var status = result.Failed > 0 + ? "FAILURE" + : (result.Skipped > 0 ? "SKIPPED" : "SUCCESS"); + + _diagnosticMessageSink.OnMessage(new DiagnosticMessage($"{status}: {test} ({result.Time}s)")); + + return result; + } + catch (Exception ex) + { + _diagnosticMessageSink.OnMessage(new DiagnosticMessage($"ERROR: {test} ({ex.Message})")); + throw; + } + } + } +} \ No newline at end of file