public async Task UnserializableOutput_ThrowFaultException(string pipeName)
{
_serviceMock
.Setup(x => x.UnserializableOutput())
.Returns(UnserializableObject.Create());
IIpcClient <ITestService> client = _factory
.WithIpcHostConfiguration(hostBuilder =>
{
hostBuilder.AddNamedPipeEndpoint <ITestService>(pipeName);
})
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, pipeName);
});
#if !DISABLE_DYNAMIC_CODE_GENERATION
IpcFaultException exception = await Assert.ThrowsAnyAsync <IpcFaultException>(async() =>
{
await client.InvokeAsync(x => x.UnserializableOutput());
});
Assert.Equal(IpcStatus.InternalServerError, exception.Status);
#endif
IpcFaultException exception2 = await Assert.ThrowsAnyAsync <IpcFaultException>(async() =>
{
var request = TestHelpers.CreateIpcRequest("UnserializableOutput");
await client.InvokeAsync(request);
});
Assert.Equal(IpcStatus.InternalServerError, exception2.Status);
}
public void ConnectionCancelled_Throw()
{
IIpcClient <ITestService> client = _factory
.CreateClient((name, services) =>
{
services.AddTcpIpcClient <ITestService>(name, (_, options) =>
{
// Connect to a non-routable IP address can trigger timeout
options.ServerIp = IPAddress.Parse("10.0.0.0");
});
});
using (var cts = new CancellationTokenSource())
{
Task.WaitAll(
Task.Run(async() =>
{
await Assert.ThrowsAsync <OperationCanceledException>(async() =>
{
var request = TestHelpers.CreateIpcRequest(typeof(ITestService), "StringType", new object[] { string.Empty });
await client.InvokeAsync(request, cts.Token);
});
}),
Task.Run(() => cts.CancelAfter(1000)));
}
}
public async Task ServerIsOff_Timeout()
{
int timeout = 1000; // 1s
IIpcClient <ITestService> client = _factory
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, (_, options) =>
{
options.PipeName = "inexisted-pipe";
options.ConnectionTimeout = timeout;
});
});
#if !DISABLE_DYNAMIC_CODE_GENERATION
var sw = Stopwatch.StartNew();
await Assert.ThrowsAsync <TimeoutException>(async() =>
{
string output = await client.InvokeAsync(x => x.StringType("abc"));
});
Assert.True(sw.ElapsedMilliseconds < timeout * 2); // makesure timeout works with marge
#endif
var sw2 = Stopwatch.StartNew();
await Assert.ThrowsAsync <TimeoutException>(async() =>
{
var request = TestHelpers.CreateIpcRequest(typeof(ITestService), "StringType", false, new object[] { "abc" });
string output = await client.InvokeAsync <string>(request);
});
Assert.True(sw2.ElapsedMilliseconds < timeout * 2); // makesure timeout works with marge
}
public async Task UnserializableInput_ThrowSerializationException(string pipeName)
{
IIpcClient <ITestService> client = _factory
.WithIpcHostConfiguration(hostBuilder =>
{
hostBuilder.AddNamedPipeEndpoint <ITestService>(pipeName);
})
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, pipeName);
});
#if !DISABLE_DYNAMIC_CODE_GENERATION
await Assert.ThrowsAnyAsync <IpcSerializationException>(async() =>
{
await client.InvokeAsync(x => x.UnserializableInput(UnserializableObject.Create()));
});
#endif
await Assert.ThrowsAnyAsync <IpcSerializationException>(async() =>
{
var request = TestHelpers.CreateIpcRequest(typeof(ITestService), "UnserializableInput", UnserializableObject.Create());
await client.InvokeAsync(request);
});
}
internal void CleanupServer()
{
try
{
_queueProcessMonitor.Shutdown();
_hangfireServerMonitor.Shutdown();
if (_startWebServer != null)
{
_startWebServer.Dispose();
_startWebServer = null;
}
if (_ipcClient != null)
{
_ipcClient.Dispose();
_ipcClient = null;
}
DebugDispatcher.Instance.Shutdown();
}
catch (Exception ex)
{
Dev2Logger.Error("Dev2.ServerLifecycleManager", ex, GlobalConstants.WarewolfError);
}
}
public async Task Exception_ThrowWithDetails(string pipeName, string details)
{
_serviceMock.Setup(x => x.ThrowException())
.Throws(new Exception(details));
IIpcClient <ITestService> client = _factory
.WithIpcHostConfiguration(hostBuilder =>
{
hostBuilder.AddNamedPipeEndpoint <ITestService>(options =>
{
options.PipeName = pipeName;
options.IncludeFailureDetailsInResponse = true;
});
})
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, (_, options) =>
{
options.PipeName = pipeName;
});
});
IpcFaultException actual = await Assert.ThrowsAsync <IpcFaultException>(async() =>
{
await client.InvokeAsync(x => x.ThrowException());
});
Assert.NotNull(actual.InnerException);
Assert.NotNull(actual.InnerException.InnerException);
Assert.Equal(details, actual.InnerException.InnerException.Message);
}
private async void SendTask(WebSocketContext context, IIpcClient client, CancellationToken cancellationToken)
{
try
{
var webSocket = context.WebSocket;
while (!cancellationToken.IsCancellationRequested && webSocket.State == WebSocketState.Open)
{
var result = await client.SendChannel.Reader.ReadAsync(cancellationToken);
if (webSocket.State != WebSocketState.Open)
{
break;
}
Logger.Debug("\"{0}\" sent data: \"{1}\"", client.IpcName, result);
if (string.IsNullOrWhiteSpace(result))
{
continue;
}
await SendStringAsync(webSocket, result, cancellationToken);
}
}
catch (OperationCanceledException) { }
}
public ServerLifecycleManager(StartupConfiguration startupConfiguration)
{
SetApplicationDirectory();
_writer = startupConfiguration.Writer;
_serverEnvironmentPreparer = startupConfiguration.ServerEnvironmentPreparer;
_startUpDirectory = startupConfiguration.Directory;
_startupResourceCatalogFactory = startupConfiguration.ResourceCatalogFactory;
_ipcClient = startupConfiguration.IpcClient;
_assemblyLoader = startupConfiguration.AssemblyLoader;
_pulseLogger = new PulseLogger(60000).Start();
_pulseTracker = new PulseTracker(TimeSpan.FromDays(1).TotalMilliseconds).Start();
_serverEnvironmentPreparer.PrepareEnvironment();
_startWebServer = startupConfiguration.StartWebServer;
_webServerConfiguration = startupConfiguration.WebServerConfiguration;
_loggingProcessMonitor = startupConfiguration.LoggingServiceMonitor;
_loggingProcessMonitor.OnProcessDied += (e) => _writer.WriteLine("logging service exited");
_queueProcessMonitor = startupConfiguration.QueueWorkerMonitor;
_queueProcessMonitor.OnProcessDied += (config) => _writer.WriteLine($"queue process died: {config.Name}({config.Id})");
_webSocketPool = startupConfiguration.WebSocketPool;
SecurityIdentityFactory.Set(startupConfiguration.SecurityIdentityFactory);
}
public async Task StreamTranslator_HappyPath(string pipeName, string input, string expected)
{
_serviceMock
.Setup(x => x.StringType(input))
.Returns(expected);
IIpcClient <ITestService> client = _factory
.WithServiceImplementation(_ => _serviceMock.Object)
.WithIpcHostConfiguration(hostBuilder =>
{
hostBuilder.AddNamedPipeEndpoint <ITestService>(options =>
{
options.PipeName = pipeName;
options.StreamTranslator = x => new XorStream(x);
});
})
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, (_, options) =>
{
options.PipeName = pipeName;
options.StreamTranslator = x => new XorStream(x);
});
});
string actual = await client.InvokeAsync(x => x.StringType(input));
Assert.Equal(expected, actual);
}
public void Dispose()
{
Log.Output -= HandleMessage;
Server = null;
Log.Debug("Daemon", $"Stopped log server {{{Identifier}}}");
}
private void OnStartup(object sender, StartupEventArgs eventArgs)
{
_ipcClient = CreateGrpcClient();
_ipcClient.Start();
var acquisitionManagerProxy = CreateGrpcAcquisitionManagerProxy(_ipcClient);
ServiceLocator.Instance.RegisterService <IAcquisitionManager>(acquisitionManagerProxy);
}
/// <summary>
/// Creates a new Anperi interface. It will connect to the IPC server automatically. To actually use this class you'll need to subscribe to almost all events.
/// </summary>
public Anperi()
{
_ipcClient = new NamedPipeIpcClient();
_ipcClient.Opened += _ipcClient_Opened;
_ipcClient.MessageReceived += _ipcClient_MessageReceived;
_ipcClient.Closed += _ipcClient_Closed;
_ipcClient.Error += _ipcClient_Error;
ReconnectIn(TimeSpan.Zero);
}
private IAcquisitionManager CreateGrpcAcquisitionManagerProxy(IIpcClient ipcClient)
{
var grpcClientImplementation = (IpcClientGrpcImplementation)ipcClient;
var grpcAcquisitionManagerProxyImplementation = new AcquisitionManagerProxyGrpcImplementation(
grpcClientImplementation.Channel,
grpcClientImplementation.CancellationToken);
return(grpcAcquisitionManagerProxyImplementation);
}
public async Task Run()
{
_thread = new Thread(MetricsSendingLoop);
_thread.Start();
var periodMs = int.Parse(_config.ConfigItems[Constants.Config_MetricMeasurmantPeriod]);
_client = IpcConnector.Connect(_config);
_timer = new Timer(OnTimerTick, null, periodMs, periodMs);
await MetricsMeasurmentLoop();
}
public ContractTest(IpcApplicationFactory <ITestService> factory)
{
string pipeName = Guid.NewGuid().ToString();
_client = factory
.WithServiceImplementation(_ => _serviceMock.Object)
.WithIpcHostConfiguration(hostBuilder =>
{
hostBuilder.AddNamedPipeEndpoint <ITestService>(pipeName);
})
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, pipeName);
});
}
public HappyPathTest(IpcApplicationFactory <ITestService> factory)
{
int port = _rand.Next(10000, 50000);
_client = factory
.WithServiceImplementation(_ => _serviceMock.Object)
.WithIpcHostConfiguration(hostBuilder =>
{
hostBuilder.AddTcpEndpoint <ITestService>(IPAddress.Loopback, port);
})
.CreateClient((name, services) =>
{
services.AddTcpIpcClient <ITestService>(name, IPAddress.Loopback, port);
});
}
public async Task UnserializableInput_ThrowSerializationException(string pipeName)
{
IIpcClient <ITestService> client = _factory
.WithIpcHostConfiguration(hostBuilder =>
{
hostBuilder.AddNamedPipeEndpoint <ITestService>(pipeName);
})
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, pipeName);
});
await Assert.ThrowsAnyAsync <IpcSerializationException>(async() =>
{
await client.InvokeAsync(x => x.UnserializableInput(UnserializableObject.Create()));
});
}
public AppInfo()
{
this.InitializeComponent();
// register IPC clients
ServiceProvider serviceProvider = new ServiceCollection()
.AddNamedPipeIpcClient <ServiceContractInterfaces>("broker", pipeName: "pipeinternal")
.BuildServiceProvider();
// resolve IPC client factory
IIpcClientFactory <ServiceContractInterfaces> clientFactory = serviceProvider
.GetRequiredService <IIpcClientFactory <ServiceContractInterfaces> >();
// create client
this.client = clientFactory.CreateClient("broker");
DataContext = new BackgroundServiceSettingsViewModel();
Ping();
}
public AddCommandDialog()
{
this.InitializeComponent();
DataContext = new AddCommandViewModel();
this.comboBox = this.FindControl <ComboBox>("ComboBox");
this.comboBox.Items = Enum.GetValues(typeof(AvailableCommands)).Cast <AvailableCommands>().OrderBy(v => v.ToString());
this.comboBox.SelectedIndex = 0;
// register IPC clients
ServiceProvider serviceProvider = new ServiceCollection()
.AddNamedPipeIpcClient <ServiceContractInterfaces>("addCommand", pipeName: "pipeinternal")
.BuildServiceProvider();
// resolve IPC client factory
IIpcClientFactory <ServiceContractInterfaces> clientFactory = serviceProvider
.GetRequiredService <IIpcClientFactory <ServiceContractInterfaces> >();
// create client
this.client = clientFactory.CreateClient("addCommand");
}
public async Task MultipleEndpoints(
Mock <ITestService> service1,
Mock <ITestService2> service2)
{
IHost host = Host.CreateDefaultBuilder()
.ConfigureServices(services =>
{
services
.AddScoped(x => service1.Object)
.AddScoped(x => service2.Object);
})
.ConfigureIpcHost(builder =>
{
builder
.AddNamedPipeEndpoint <ITestService>("pipe1")
.AddNamedPipeEndpoint <ITestService2>("pipe2");
})
.Build();
await host.StartAsync();
ServiceProvider clientServiceProvider = new ServiceCollection()
.AddNamedPipeIpcClient <ITestService>("client1", "pipe1")
.AddNamedPipeIpcClient <ITestService2>("client2", "pipe2")
.BuildServiceProvider();
IIpcClient <ITestService> client1 = clientServiceProvider
.GetRequiredService <IIpcClientFactory <ITestService> >()
.CreateClient("client1");
await client1.InvokeAsync(x => x.ReturnVoid());
service1.Verify(x => x.ReturnVoid(), Times.Once);
IIpcClient <ITestService2> client2 = clientServiceProvider
.GetRequiredService <IIpcClientFactory <ITestService2> >()
.CreateClient("client2");
await client2.InvokeAsync(x => x.SomeMethod());
service2.Verify(x => x.SomeMethod(), Times.Once);
}
public async Task ServerIsOff_Timeout()
{
int timeout = 1000; // 1s
IIpcClient <ITestService> client = _factory
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, (_, options) =>
{
options.PipeName = "inexisted-pipe";
options.ConnectionTimeout = timeout;
});
});
var sw = Stopwatch.StartNew();
await Assert.ThrowsAsync <TimeoutException>(async() =>
{
string output = await client.InvokeAsync(x => x.StringType("abc"));
});
Assert.True(sw.ElapsedMilliseconds < timeout * 2); // makesure timeout works with marge
}
public CommandSettings()
{
this.InitializeComponent();
// register IPC clients
ServiceProvider serviceProvider = new ServiceCollection()
.AddNamedPipeIpcClient <ServiceContractInterfaces>("commands", pipeName: "pipeinternal")
.BuildServiceProvider();
// resolve IPC client factory
IIpcClientFactory <ServiceContractInterfaces> clientFactory = serviceProvider
.GetRequiredService <IIpcClientFactory <ServiceContractInterfaces> >();
// create client
this.client = clientFactory.CreateClient("commands");
DataContext = new CommandSettingsViewModel();
GetConfiguredCommands();
this._dataGrid = this.FindControl <DataGrid>("Grid");
}
public void ConnectionCancelled_Throw()
{
IIpcClient <ITestService> client = _factory
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, (_, options) =>
{
options.PipeName = "inexisted-pipe";
options.ConnectionTimeout = Timeout.Infinite;
});
});
#if !DISABLE_DYNAMIC_CODE_GENERATION
using (var cts = new CancellationTokenSource())
{
Task.WaitAll(
Task.Run(async() =>
{
await Assert.ThrowsAsync <OperationCanceledException>(async() =>
{
await client.InvokeAsync(x => x.ReturnVoid(), cts.Token);
});
}),
Task.Run(() => cts.CancelAfter(1000)));
}
#endif
using (var cts = new CancellationTokenSource())
{
Task.WaitAll(
Task.Run(async() =>
{
await Assert.ThrowsAsync <OperationCanceledException>(async() =>
{
var request = TestHelpers.CreateIpcRequest("ReturnVoid");
await client.InvokeAsync(request, cts.Token);
});
}),
Task.Run(() => cts.CancelAfter(1000)));
}
}
public async Task ConnectionTimeout_Throw()
{
int timeout = 3000; // 3s
IIpcClient <ITestService> client = _factory
.CreateClient((name, services) =>
{
services.AddTcpIpcClient <ITestService>(name, (_, options) =>
{
// Connect to a non-routable IP address can trigger timeout
options.ServerIp = IPAddress.Parse("10.0.0.0");
options.ConnectionTimeout = timeout;
});
});
var sw = Stopwatch.StartNew();
await Assert.ThrowsAsync <TimeoutException>(async() =>
{
string output = await client.InvokeAsync(x => x.StringType("abc"));
});
Assert.True(sw.ElapsedMilliseconds < timeout * 2); // makesure timeout works with marge
}
public async Task Exception_ThrowWithoutDetails(string pipeName, string details)
{
_serviceMock.Setup(x => x.ThrowException())
.Throws(new Exception(details));
IIpcClient <ITestService> client = _factory
.WithIpcHostConfiguration(hostBuilder =>
{
hostBuilder.AddNamedPipeEndpoint <ITestService>(options =>
{
options.PipeName = pipeName;
options.IncludeFailureDetailsInResponse = false;
});
})
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, (_, options) =>
{
options.PipeName = pipeName;
});
});
#if !DISABLE_DYNAMIC_CODE_GENERATION
IpcFaultException actual = await Assert.ThrowsAsync <IpcFaultException>(async() =>
{
await client.InvokeAsync(x => x.ThrowException());
});
Assert.Null(actual.InnerException);
#endif
IpcFaultException actual2 = await Assert.ThrowsAsync <IpcFaultException>(async() =>
{
var request = TestHelpers.CreateIpcRequest("ThrowException");
await client.InvokeAsync(request);
});
Assert.Null(actual2.InnerException);
}
public async Task UnserializableOutput_ThrowFaultException(string pipeName)
{
_serviceMock
.Setup(x => x.UnserializableOutput())
.Returns(UnserializableObject.Create());
IIpcClient <ITestService> client = _factory
.WithIpcHostConfiguration(hostBuilder =>
{
hostBuilder.AddNamedPipeEndpoint <ITestService>(pipeName);
})
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, pipeName);
});
IpcFaultException exception = await Assert.ThrowsAnyAsync <IpcFaultException>(async() =>
{
await client.InvokeAsync(x => x.UnserializableOutput());
});
Assert.Equal(IpcStatus.InternalServerError, exception.Status);
}
public SimpleTypeNameContractTest(IpcApplicationFactory <ITestService> factory)
{
string pipeName = Guid.NewGuid().ToString();
_client = factory
.WithServiceImplementation(_ => _serviceMock.Object)
.WithIpcHostConfiguration(hostBuilder =>
{
hostBuilder.AddNamedPipeEndpoint <ITestService>(options =>
{
options.PipeName = pipeName;
options.IncludeFailureDetailsInResponse = true;
});
})
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, (_, options) =>
{
options.UseSimpleTypeNameAssemblyFormatHandling = true;
options.PipeName = pipeName;
}
);
});
}
public void ConnectionCancelled_Throw()
{
IIpcClient <ITestService> client = _factory
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, (_, options) =>
{
options.PipeName = "inexisted-pipe";
options.ConnectionTimeout = Timeout.Infinite;
});
});
using var cts = new CancellationTokenSource();
Task.WaitAll(
Task.Run(async() =>
{
await Assert.ThrowsAsync <OperationCanceledException>(async() =>
{
await client.InvokeAsync(x => x.ReturnVoid(), cts.Token);
});
}),
Task.Run(() => cts.CancelAfter(1000)));
}
public AddSensorDialog()
{
this.InitializeComponent();
#if DEBUG
this.AttachDevTools();
#endif
this.comboBox = this.FindControl <ComboBox>("ComboBox");
this.comboBox.Items = Enum.GetValues(typeof(AvailableSensors)).Cast <AvailableSensors>();
// register IPC clients
ServiceProvider serviceProvider = new ServiceCollection()
.AddNamedPipeIpcClient <ServiceContractInterfaces>("addsensor", pipeName: "pipeinternal")
.BuildServiceProvider();
// resolve IPC client factory
IIpcClientFactory <ServiceContractInterfaces> clientFactory = serviceProvider
.GetRequiredService <IIpcClientFactory <ServiceContractInterfaces> >();
// create client
this.client = clientFactory.CreateClient("addsensor");
DataContext = new AddSensorViewModel();
}
public async Task StreamTranslator_HappyPath(string pipeName, string input, string expected)
{
_serviceMock
.Setup(x => x.StringType(input))
.Returns(expected);
IIpcClient <ITestService> client = _factory
.WithServiceImplementation(_ => _serviceMock.Object)
.WithIpcHostConfiguration(hostBuilder =>
{
hostBuilder.AddNamedPipeEndpoint <ITestService>(options =>
{
options.PipeName = pipeName;
options.StreamTranslator = x => new XorStream(x);
});
})
.CreateClient((name, services) =>
{
services.AddNamedPipeIpcClient <ITestService>(name, (_, options) =>
{
options.PipeName = pipeName;
options.StreamTranslator = x => new XorStream(x);
});
});
#if !DISABLE_DYNAMIC_CODE_GENERATION
string actual = await client.InvokeAsync(x => x.StringType(input));
Assert.Equal(expected, actual);
#endif
var request = TestHelpers.CreateIpcRequest(typeof(ITestService), "StringType", false, new object[] { input });
var actual2 = await client.InvokeAsync <string>(request);
Assert.Equal(expected, actual2);
}
