public async void TestSendAndReceiveWithPoller()
{
var resolver = new DependencyResolver();
using (var broker = new ZmqPollBroker(this.zmqContext, ClientInboundAddress, ServerInboundAddress))
{
broker.Listen();
using (var server = new ZmqPollServer(this.zmqContext, ServerInboundAddress, new ServiceFactory(resolver)))
{
server.Listen();
using (var client = new ZmqPollClient(this.zmqContext, ClientInboundAddress))
{
var clientFactory = new ServiceClientFactory(client);
var serviceClient = clientFactory.CreateServiceClient <ITestService2>();
Assert.That(serviceClient.GetPerson(1), Is.Not.Null);
var persons = await serviceClient.ListPersonsAsync(5);
Assert.That(persons, Is.Not.Null);
Assert.AreEqual(5, persons.Count());
var nullCollection = await serviceClient.ListPersonsAsync(-1);
Assert.IsNull(nullCollection);
var nullObject = serviceClient.GetPerson(-1);
Assert.IsNull(nullObject);
}
}
}
}
public async void RequestGetsResponseFromServer()
{
var clientFactory = new ServiceClientFactory(new SimpleClient(new ServiceFactory(this.resolver)));
var serviceClient = clientFactory.CreateServiceClient <ITestService2>();
//Synchronous
Assert.That(serviceClient.GetPerson(1), Is.Not.Null);
//Asynchronous task based
var persons = await serviceClient.ListPersonsAsync(5);
Assert.That(persons, Is.Not.Null);
Assert.AreEqual(5, persons.Count());
//Asynchronous IAsyncResult based , awaiting with Task
var person = await Task.Factory.FromAsync <int, Person>(serviceClient.BeginGetPerson, serviceClient.EndGetPerson, 1, null);
Assert.That(person, Is.Not.Null);
var nullCollection = await serviceClient.ListPersonsAsync(-1);
Assert.IsNull(nullCollection);
var nullObject = serviceClient.GetPerson(-1);
Assert.IsNull(nullObject);
}
static void Main(string[] args)
{
var logger = new LoggerStub();
// using (var logger = new ConsoleLoggerWrapper(new LoggerStub()))
// {
Helpers.LogCurrentMemoryUsage(logger);
// Console.ReadLine();
var messagePackSerializerFactory = new MessagePackSerializerFactory();
using (var testServiceClient = ServiceClientFactory.CreateServiceClient <ITestService>(
"localhost",
logger,
messagePackSerializerFactory))
{
using (var wcfTestServiceClient = CommonWcfComponents.ServiceClient <ITestService> .Create())
{
Console.WriteLine("Test service client created.");
RunTest(wcfTestServiceClient.Service, logger);
Helpers.LogCurrentMemoryUsage(logger);
Console.WriteLine("All requests send.");
Console.ReadLine();
}
}
// }
}
public async void RequestGetsResponseFromServer()
{
var clientFactory = new ServiceClientFactory(new SimpleClient(new ServiceFactory(this.resolver)));
var serviceClient = clientFactory.CreateServiceClient<ITestService2>();
//Synchronous
Assert.That(serviceClient.GetPerson(1), Is.Not.Null);
//Asynchronous task based
var persons = await serviceClient.ListPersonsAsync(5);
Assert.That(persons, Is.Not.Null);
Assert.AreEqual(5, persons.Count());
//Asynchronous IAsyncResult based , awaiting with Task
var person = await Task.Factory.FromAsync<int, Person>(serviceClient.BeginGetPerson, serviceClient.EndGetPerson, 1, null);
Assert.That(person, Is.Not.Null);
var nullCollection = await serviceClient.ListPersonsAsync(-1);
Assert.IsNull(nullCollection);
var nullObject = serviceClient.GetPerson(-1);
Assert.IsNull(nullObject);
}
static void Main(string[] args)
{
var logger = new LoggerStub();
Helpers.LogCurrentMemoryUsage(logger);
var serviceClientFactory = new ServiceClientFactory(logger);
using (var testServiceClient = serviceClientFactory.CreateServiceClient <ITestService>(
"localhost"))
{
Console.WriteLine("Test service client created.");
// Warm up
const int warmUpCallsCount = 5000;
Enumerable
.Range(0, warmUpCallsCount)
.ParallelForEach(_ => SendRequestAndLogResult(testServiceClient.ServiceInstance, logger));
Console.WriteLine("Warmup done");
GC.Collect(2, GCCollectionMode.Forced);
// Thread.Sleep(TimeSpan.FromSeconds(5));
const int callsCount = 10000;
RunTests(() => TestAsyncOperations(testServiceClient.ServiceInstance, logger, callsCount), logger);
Console.WriteLine("All requests send.");
Console.ReadLine();
}
}
public void CanCreateClient()
{
var factory = new ServiceClientFactory(new Mock<IClient>().Object);
var serviceClient = factory.CreateServiceClient<ITestService>();
Assert.That(serviceClient, Is.Not.Null);
}
public async void TestSendAndReceiveWithPoller()
{
var resolver = new DependencyResolver();
using (var broker = new ZmqPollBroker(this.zmqContext, ClientInboundAddress, ServerInboundAddress))
{
broker.Listen();
using (var server = new ZmqPollServer(this.zmqContext, ServerInboundAddress, new ServiceFactory(resolver)))
{
server.Listen();
using (var client = new ZmqPollClient(this.zmqContext, ClientInboundAddress))
{
var clientFactory = new ServiceClientFactory(client);
var serviceClient = clientFactory.CreateServiceClient<ITestService2>();
Assert.That(serviceClient.GetPerson(1), Is.Not.Null);
var persons = await serviceClient.ListPersonsAsync(5);
Assert.That(persons, Is.Not.Null);
Assert.AreEqual(5, persons.Count());
var nullCollection = await serviceClient.ListPersonsAsync(-1);
Assert.IsNull(nullCollection);
var nullObject = serviceClient.GetPerson(-1);
Assert.IsNull(nullObject);
}
}
}
}
public async void AsyncClientMethodsTest()
{
var serializerFactory = new MessagePackSerializerFactory();
var serviceClientFactory = new ServiceClientFactory(new LoggerStub());
using (var _ = GetTestService(serializerFactory))
{
using (var client = serviceClientFactory.CreateServiceClient <ITestService>(
"localhost",
serializerFactory))
{
var myHashcode = await client.ServiceInstance.GetHashCodeOfMeAsync(SerializableObject.GetTestInstance());
Assert.Equal(SerializableObject.TestInt, myHashcode);
var constructedObject = await client.ServiceInstance.ConstructObjectAsync(
SerializableObject.TestInt,
SerializableObject.TestString,
SerializableObject.TestDouble);
Assert.NotNull(constructedObject);
Assert.Equal(SerializableObject.TestInt, constructedObject.IntProperty);
Assert.Equal(SerializableObject.TestString, constructedObject.StringProperty);
Assert.Equal(SerializableObject.TestDouble, constructedObject.NestedObject.DoubleProperty);
var(count, objects) = await client.ServiceInstance.GetObjectsAsync(1, 1);
Assert.Equal(2, count);
constructedObject = objects.Single();
Assert.Equal(SerializableObject.TestInt, constructedObject.IntProperty);
Assert.Equal(SerializableObject.TestString, constructedObject.StringProperty);
Assert.Equal(SerializableObject.TestDouble, constructedObject.NestedObject.DoubleProperty);
}
}
}
public void CanCreateClient()
{
var factory = new ServiceClientFactory(new Mock <IClient>().Object);
var serviceClient = factory.CreateServiceClient <ITestService>();
Assert.That(serviceClient, Is.Not.Null);
}
public void CanHandleTimeouts()
{
var clientMock = new Mock <IClient>();
this.SetupClient(clientMock, 1000); //takes 100ms to reply
var factory = new ServiceClientFactory(clientMock.Object);
var serviceClient = factory.CreateServiceClient <ITestService>(50); //50ms timeout
Assert.Throws <TimeoutException>(() => serviceClient.Sum(10, 5));
}
/// <summary>
/// Handles ClientConnected event of _scsServer object.
/// </summary>
/// <param name="sender">Source of event</param>
/// <param name="e">Event arguments</param>
private void ScsServer_ClientConnected(object sender, ServerClientEventArgs e)
{
var requestReplyMessenger = new RequestReplyMessenger <IServerClient>(e.Client);
requestReplyMessenger.MessageReceived += Client_MessageReceived;
requestReplyMessenger.Start();
var serviceClient = ServiceClientFactory.CreateServiceClient(e.Client, requestReplyMessenger);
_serviceClients[serviceClient.ClientId] = serviceClient;
OnClientConnected(serviceClient);
}
public void CanUseClientWithNonComplexTypes()
{
var clientMock = new Mock<IClient>();
this.SetupClient(clientMock);
var factory = new ServiceClientFactory(clientMock.Object);
var serviceClient = factory.CreateServiceClient<ITestService>();
var sum = serviceClient.Sum(10, 5);
Assert.That(sum, Is.EqualTo(15));
var concatenated = serviceClient.Concatenate("10", "01");
Assert.That(concatenated.Result, Is.EqualTo("1001"));
}
public void CanUseClientWithNonComplexTypes()
{
var clientMock = new Mock <IClient>();
this.SetupClient(clientMock);
var factory = new ServiceClientFactory(clientMock.Object);
var serviceClient = factory.CreateServiceClient <ITestService>();
var sum = serviceClient.Sum(10, 5);
Assert.That(sum, Is.EqualTo(15));
var concatenated = serviceClient.Concatenate("10", "01");
Assert.That(concatenated.Result, Is.EqualTo("1001"));
}
/// <summary>
/// Creates an instance with specified endpoint, credential information and credential information.
/// </summary>
/// <param name="endpoint">OSS endpoint</param>
/// <param name="credsProvider">Credentials information</param>
/// <param name="configuration">client side configuration</param>
public OssClient(Uri endpoint, ICredentialsProvider credsProvider, ClientConfiguration configuration)
{
if (endpoint == null)
{
throw new ArgumentException(Resources.ExceptionIfArgumentStringIsNullOrEmpty, "endpoint");
}
if (!endpoint.ToString().StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
!endpoint.ToString().StartsWith("https://", StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentException(OssResources.EndpointNotSupportedProtocal, "endpoint");
}
_endpoint = endpoint;
_credsProvider = credsProvider ?? throw new ArgumentException(Resources.ExceptionIfArgumentStringIsNullOrEmpty, "credsProvider");
_serviceClient = ServiceClientFactory.CreateServiceClient(configuration ?? new ClientConfiguration());
}
//[TestCase(5, 1000000)]
public async void TestLoadBalancingWithPoll(int nServers, int nMsgs)
{
var resolver = new DependencyResolver();
using (var broker = new ZmqPollBroker(this.zmqContext, ClientInboundAddress, ServerInboundAddress))
{
broker.Listen();
var servers = Enumerable.Range(0, nServers)
.Select(i => new ZmqPollServer(this.zmqContext, ServerInboundAddress, new ServiceFactory(resolver)))
.ToArray();
try
{
foreach (var server in servers)
{
server.Listen();
}
using (var client = new ZmqPollClient(this.zmqContext, ClientInboundAddress))
{
var clientFactory = new ServiceClientFactory(client);
var serviceClient = clientFactory.CreateServiceClient <ITestService2>();
var tasks = Enumerable.Range(0, nMsgs)
//.Select(i => serviceClient.SumAsync(5, 15))
.Select(i => serviceClient.ListPersonsAsync(7))
.ToArray();
await Task.WhenAll(tasks);
Assert.True(tasks.All(t => t.Result.Count() == 7));
}
}
finally
{
foreach (var server in servers)
{
server.Dispose();
}
}
}
}
public async void TestSendAndReceiveExceptions()
{
var resolver = new DependencyResolver();
using (var broker = new ZmqBroker(this.zmqContext, ClientInboundAddress, ClientOutboundAddress, ServerInboundAddress, ServerOutboundAddress))
{
broker.Listen();
using (var server = new ZmqServer(this.zmqContext, ServerInboundAddress, ServerOutboundAddress, new ServiceFactory(resolver)))
{
server.Listen();
using (var client = new ZmqClient(this.zmqContext, ClientInboundAddress, ClientOutboundAddress))
{
var clientFactory = new ServiceClientFactory(client);
var serviceClient = clientFactory.CreateServiceClient <ITestService>();
//Synchronous
var err = Assert.Catch(async() => await serviceClient.FailAsync());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf <AggregateException>(err);
//Asynchronous task based
err = Assert.Catch(() => serviceClient.Fail());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf <AggregateException>(err);
//Asynchronous IAsyncResult based , awaiting with Task
err = Assert.Catch(async() => await Task.Factory.FromAsync(serviceClient.BeginFail, serviceClient.EndFail, null));
Assert.IsNotNull(err);
Assert.IsNotInstanceOf <AggregateException>(err);
//Timeout exceptions
var factoryWithTimeout = new ServiceClientFactory(client);
var serviceClientWithTimeout = factoryWithTimeout.CreateServiceClient <ITestService>(50); //50ms
Assert.Throws <TimeoutException>(async() => await serviceClientWithTimeout.ReplyAfter(1000));
}
}
}
}
public async void TestSendAndReceiveExceptions()
{
var resolver = new DependencyResolver();
using (var broker = new ZmqBroker(this.zmqContext, ClientInboundAddress, ClientOutboundAddress, ServerInboundAddress, ServerOutboundAddress))
{
broker.Listen();
using (var server = new ZmqServer(this.zmqContext, ServerInboundAddress, ServerOutboundAddress, new ServiceFactory(resolver)))
{
server.Listen();
using (var client = new ZmqClient(this.zmqContext, ClientInboundAddress, ClientOutboundAddress))
{
var clientFactory = new ServiceClientFactory(client);
var serviceClient = clientFactory.CreateServiceClient<ITestService>();
//Synchronous
var err = Assert.Catch(async () => await serviceClient.FailAsync());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf<AggregateException>(err);
//Asynchronous task based
err = Assert.Catch(() => serviceClient.Fail());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf<AggregateException>(err);
//Asynchronous IAsyncResult based , awaiting with Task
err = Assert.Catch(async () => await Task.Factory.FromAsync(serviceClient.BeginFail, serviceClient.EndFail, null));
Assert.IsNotNull(err);
Assert.IsNotInstanceOf<AggregateException>(err);
//Timeout exceptions
var factoryWithTimeout = new ServiceClientFactory(client);
var serviceClientWithTimeout = factoryWithTimeout.CreateServiceClient<ITestService>(50); //50ms
Assert.Throws<TimeoutException>(async () => await serviceClientWithTimeout.ReplyAfter(1000));
}
}
}
}
public void RequestGetsExceptionFromServer()
{
var clientFactory = new ServiceClientFactory(new SimpleClient(new ServiceFactory(this.resolver)));
var serviceClient = clientFactory.CreateServiceClient<ITestService>();
//Synchronous
var err = Assert.Catch(async () => await serviceClient.FailAsync());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf<AggregateException>(err);
//Asynchronous task based
err = Assert.Catch(() => serviceClient.Fail());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf<AggregateException>(err);
//Asynchronous IAsyncResult based , awaiting with Task
err = Assert.Catch(async () => await Task.Factory.FromAsync(serviceClient.BeginFail, serviceClient.EndFail, null));
Assert.IsNotNull(err);
Assert.IsNotInstanceOf<AggregateException>(err);
}
public void RequestGetsExceptionFromServer()
{
var clientFactory = new ServiceClientFactory(new SimpleClient(new ServiceFactory(this.resolver)));
var serviceClient = clientFactory.CreateServiceClient <ITestService>();
//Synchronous
var err = Assert.Catch(async() => await serviceClient.FailAsync());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf <AggregateException>(err);
//Asynchronous task based
err = Assert.Catch(() => serviceClient.Fail());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf <AggregateException>(err);
//Asynchronous IAsyncResult based , awaiting with Task
err = Assert.Catch(async() => await Task.Factory.FromAsync(serviceClient.BeginFail, serviceClient.EndFail, null));
Assert.IsNotNull(err);
Assert.IsNotInstanceOf <AggregateException>(err);
}
//[TestCase(5, 1000000)]
public async void TestLoadBalancing(int nServers, int nMsgs)
{
var resolver = new DependencyResolver();
var servers = Enumerable.Range(0, nServers)
.Select(i => new RedisServer(new RedisConnection(RedisHost, RedisPort, RedisPassword), ServerQueue, new ServiceFactory(resolver)))
.ToArray();
try
{
foreach (var server in servers)
{
server.Listen();
}
using (var client = new RedisClient(new RedisConnection(RedisHost, RedisPort, RedisPassword), ClientQueue, ServerQueue))
{
var clientFactory = new ServiceClientFactory(client);
var serviceClient = clientFactory.CreateServiceClient <ITestService2>();
var tasks = Enumerable.Range(0, nMsgs)
//.Select(i => serviceClient.SumAsync(5, 15))
.Select(i => serviceClient.ListPersonsAsync(7))
.ToArray();
await Task.WhenAll(tasks);
Assert.True(tasks.All(t => t.Result.Count() == 7));
}
}
finally
{
foreach (var server in servers)
{
server.Dispose();
}
}
}
public async void TestSendAndReceiveExceptions()
{
var resolver = new DependencyResolver();
using (var server = new RedisServer(new RedisConnection(RedisHost, RedisPort, RedisPassword), ServerQueue, new ServiceFactory(resolver)))
{
server.Listen();
using (var client = new RedisClient(new RedisConnection(RedisHost, RedisPort, RedisPassword), ClientQueue, ServerQueue))
{
var clientFactory = new ServiceClientFactory(client);
var serviceClient = clientFactory.CreateServiceClient <ITestService>();
//Synchronous
var err = Assert.Catch(async() => await serviceClient.FailAsync());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf <AggregateException>(err);
//Asynchronous task based
err = Assert.Catch(() => serviceClient.Fail());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf <AggregateException>(err);
//Asynchronous IAsyncResult based , awaiting with Task
err = Assert.Catch(async() => await Task.Factory.FromAsync(serviceClient.BeginFail, serviceClient.EndFail, null));
Assert.IsNotNull(err);
Assert.IsNotInstanceOf <AggregateException>(err);
//Timeout exceptions
var factoryWithTimeout = new ServiceClientFactory(client);
var serviceClientWithTimeout = factoryWithTimeout.CreateServiceClient <ITestService>(50); //50ms
Assert.Throws <TimeoutException>(async() => await serviceClientWithTimeout.ReplyAfter(1000));
}
}
}
//[TestCase(5, 1000000)]
public async void TestLoadBalancing(int nServers, int nMsgs)
{
var resolver = new DependencyResolver();
var servers = Enumerable.Range(0, nServers)
.Select(i => new RedisServer(new RedisConnection(RedisHost, RedisPort, RedisPassword), ServerQueue, new ServiceFactory(resolver)))
.ToArray();
try
{
foreach (var server in servers) server.Listen();
using (var client = new RedisClient(new RedisConnection(RedisHost, RedisPort, RedisPassword), ClientQueue, ServerQueue))
{
var clientFactory = new ServiceClientFactory(client);
var serviceClient = clientFactory.CreateServiceClient<ITestService2>();
var tasks = Enumerable.Range(0, nMsgs)
//.Select(i => serviceClient.SumAsync(5, 15))
.Select(i => serviceClient.ListPersonsAsync(7))
.ToArray();
await Task.WhenAll(tasks);
Assert.True(tasks.All(t => t.Result.Count() == 7));
}
}
finally
{
foreach (var server in servers) server.Dispose();
}
}
public async void TestSendAndReceiveExceptions()
{
var resolver = new DependencyResolver();
using (var server = new RedisServer(new RedisConnection(RedisHost, RedisPort, RedisPassword), ServerQueue, new ServiceFactory(resolver)))
{
server.Listen();
using (var client = new RedisClient(new RedisConnection(RedisHost, RedisPort, RedisPassword), ClientQueue, ServerQueue))
{
var clientFactory = new ServiceClientFactory(client);
var serviceClient = clientFactory.CreateServiceClient<ITestService>();
//Synchronous
var err = Assert.Catch(async () => await serviceClient.FailAsync());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf<AggregateException>(err);
//Asynchronous task based
err = Assert.Catch(() => serviceClient.Fail());
Assert.IsNotNull(err);
Assert.IsNotInstanceOf<AggregateException>(err);
//Asynchronous IAsyncResult based , awaiting with Task
err = Assert.Catch(async () => await Task.Factory.FromAsync(serviceClient.BeginFail, serviceClient.EndFail, null));
Assert.IsNotNull(err);
Assert.IsNotInstanceOf<AggregateException>(err);
//Timeout exceptions
var factoryWithTimeout = new ServiceClientFactory(client);
var serviceClientWithTimeout = factoryWithTimeout.CreateServiceClient<ITestService>(50); //50ms
Assert.Throws<TimeoutException>(async () => await serviceClientWithTimeout.ReplyAfter(1000));
}
}
}
//[TestCase(5, 1000000)]
public async void TestLoadBalancingWithPoll(int nServers, int nMsgs)
{
var resolver = new DependencyResolver();
using (var broker = new ZmqPollBroker(this.zmqContext, ClientInboundAddress, ServerInboundAddress))
{
broker.Listen();
var servers = Enumerable.Range(0, nServers)
.Select(i => new ZmqPollServer(this.zmqContext, ServerInboundAddress, new ServiceFactory(resolver)))
.ToArray();
try
{
foreach (var server in servers) server.Listen();
using (var client = new ZmqPollClient(this.zmqContext, ClientInboundAddress))
{
var clientFactory = new ServiceClientFactory(client);
var serviceClient = clientFactory.CreateServiceClient<ITestService2>();
var tasks = Enumerable.Range(0, nMsgs)
//.Select(i => serviceClient.SumAsync(5, 15))
.Select(i => serviceClient.ListPersonsAsync(7))
.ToArray();
await Task.WhenAll(tasks);
Assert.True(tasks.All(t => t.Result.Count() == 7));
}
}
finally
{
foreach (var server in servers) server.Dispose();
}
}
}
public void CanHandleTimeouts()
{
var clientMock = new Mock<IClient>();
this.SetupClient(clientMock, 1000); //takes 100ms to reply
var factory = new ServiceClientFactory(clientMock.Object);
var serviceClient = factory.CreateServiceClient<ITestService>(50); //50ms timeout
Assert.Throws<TimeoutException>(() => serviceClient.Sum(10, 5));
}
