public void TestMaxPendingLimit()
{
TaskCompletionSource <bool> serverBlocker = new TaskCompletionSource <bool>();
var serverMessages = 0;
LeanIPC.RequestHandler serverHandler = async(message) =>
{
System.Threading.Interlocked.Increment(ref serverMessages);
await serverBlocker.Task;
if (message.Arguments == null || message.Arguments.Length == 0)
{
return(RequestHandlerResponse.FromResult((object)null));
}
return(new RequestHandlerResponse(message.Types, message.Arguments));
};
using (var setup = new ClientServerTester(serverHandler, EchoMethod))
{
setup.Client.MaxPendingRequests = 10;
var sendTasks = Enumerable
.Range(0, 20)
.Select(x =>
setup.GuardedOperationAsync(() => setup.Client.SendAndWaitAsync <int, int>(x))
)
.ToArray();
// Make sure the requests have propagated
System.Threading.Thread.Sleep(1000);
if (serverMessages != setup.Client.MaxPendingRequests)
{
throw new Exception($"Server got {serverMessages} messages but the pending limit is {setup.Client.MaxPendingRequests}");
}
// Trigger a resend
setup.Client.MaxPendingRequests = 15;
System.Threading.Thread.Sleep(1000);
if (serverMessages != setup.Client.MaxPendingRequests)
{
throw new Exception($"Server got {serverMessages} messages but the pending limit is {setup.Client.MaxPendingRequests}");
}
// Trigger a no-op resend
setup.Client.MaxPendingRequests = 10;
System.Threading.Thread.Sleep(1000);
if (serverMessages != 15)
{
throw new Exception($"Server got {serverMessages} messages but the pending limit is {15}");
}
serverBlocker.TrySetResult(true);
Task.WhenAll(sendTasks).Wait();
if (serverMessages != 20)
{
throw new Exception($"Server got {serverMessages} messages but should have {12}");
}
}
}
public void TestEchoWithAllPrimitiveDictionary()
{
System.Diagnostics.Trace.WriteLine($"* Running {nameof(TestEchoWithAllPrimitiveDictionary)}");
using (var setup = new ClientServerTester(EchoMethod, EchoMethod))
{
foreach (var tvalue in LeanIPC.TypeSerializer.PRIMITIVE_TYPES)
{
foreach (var tkey in new Type[] { typeof(int), typeof(long), typeof(string) })
{
var k = CreateDefault(tkey);
var v = CreateDefault(tvalue);
if (v == null)
{
continue;
}
System.Diagnostics.Trace.WriteLine($"* Testing with Dictionary<{tkey}, {tvalue}>");
var dictMethod = typeof(IPCTypeTest).GetMethod(nameof(RunWithDictionary)).MakeGenericMethod(new Type[] { tkey, tvalue });
((Task)dictMethod.Invoke(null, new object[] { setup, k, v })).Wait();
}
}
System.Diagnostics.Trace.WriteLine($"* Shutting down");
}
}
public void TestEchoWithAllPrimitiveKeyValuePairs()
{
System.Diagnostics.Trace.WriteLine($"* Running {nameof(TestEchoWithAllPrimitiveKeyValuePairs)}");
using (var setup = new ClientServerTester(EchoMethod, EchoMethod))
{
foreach (var t1 in LeanIPC.TypeSerializer.PRIMITIVE_TYPES)
{
foreach (var t2 in LeanIPC.TypeSerializer.PRIMITIVE_TYPES)
{
var v1 = CreateDefault(t1);
var v2 = CreateDefault(t2);
if (v1 == null || v2 == null)
{
continue;
}
System.Diagnostics.Trace.WriteLine($"* Testing with KeyValuePair<{t1},{t2}>");
var kvpMethod = typeof(IPCTypeTest).GetMethod(nameof(RunWithKeyValuePair)).MakeGenericMethod(new Type[] { t1, t2 });
((Task)kvpMethod.Invoke(null, new object[] { setup, v1, v2 })).Wait();
}
}
System.Diagnostics.Trace.WriteLine($"* Shutting down");
}
}
public void TestEchoWithAllPrimitiveArraysAndLists()
{
System.Diagnostics.Trace.WriteLine($"* Running {nameof(TestEchoWithAllPrimitiveArraysAndLists)}");
using (var setup = new ClientServerTester(EchoMethod, EchoMethod))
{
foreach (var t in LeanIPC.TypeSerializer.PRIMITIVE_TYPES)
{
var v = CreateDefault(t);
if (v == null)
{
continue;
}
System.Diagnostics.Trace.WriteLine($"* Testing with array {t}[]");
var arrayMethod = typeof(IPCTypeTest).GetMethod(nameof(RunWithArray)).MakeGenericMethod(new Type[] { t });
((Task)arrayMethod.Invoke(null, new object[] { setup, v })).Wait();
System.Diagnostics.Trace.WriteLine($"* Testing with List<{t}>");
var listMethod = typeof(IPCTypeTest).GetMethod(nameof(RunWithList)).MakeGenericMethod(new Type[] { t });
((Task)arrayMethod.Invoke(null, new object[] { setup, v })).Wait();
}
System.Diagnostics.Trace.WriteLine($"* Shutting down");
}
}
public static async Task RunWithList <T>(ClientServerTester setup, T value)
{
var a = new List <T>(new T[] { value });
var result = await setup.GuardedOperationAsync(() => setup.Server.SendAndWaitAsync <List <T>, List <T> >(a));
if (!AreEqual(typeof(T), result[0], value))
{
throw new Exception($"Failed to transport unboxed {typeof(T[])} through server");
}
result = await setup.GuardedOperationAsync(() => setup.Client.SendAndWaitAsync <List <T>, List <T> >(a));
if (!AreEqual(typeof(T), result[0], value))
{
throw new Exception($"Failed to transport unboxed {typeof(T[])} through client");
}
var resultObject = await setup.GuardedOperationAsync(() => setup.Server.SendAndWaitAsync <object, object>(a));
if (!AreEqual(typeof(T), result[0], value))
{
throw new Exception($"Failed to transport boxed {typeof(T[])} through server");
}
resultObject = await setup.GuardedOperationAsync(() => setup.Client.SendAndWaitAsync <object, object>(a));
if (!AreEqual(typeof(T), result[0], value))
{
throw new Exception($"Failed to transport boxed {typeof(T[])} through client");
}
}
public static async Task RunWithKeyValuePair <TKey, TValue>(ClientServerTester setup, TKey key, TValue value)
{
var a = new KeyValuePair <TKey, TValue>(key, value);
var result = await setup.GuardedOperationAsync(() => setup.Server.SendAndWaitAsync <KeyValuePair <TKey, TValue>, KeyValuePair <TKey, TValue> >(a));
if (!AreEqual(typeof(TKey), result.Key, key))
{
throw new Exception($"Failed to transport unboxed {typeof(KeyValuePair<TKey, TValue>)} through server");
}
if (!AreEqual(typeof(TValue), result.Value, value))
{
throw new Exception($"Failed to transport unboxed {typeof(KeyValuePair<TKey, TValue>)} through server");
}
result = await setup.GuardedOperationAsync(() => setup.Client.SendAndWaitAsync <KeyValuePair <TKey, TValue>, KeyValuePair <TKey, TValue> >(a));
if (!AreEqual(typeof(TKey), result.Key, key))
{
throw new Exception($"Failed to transport unboxed {typeof(KeyValuePair<TKey, TValue>)} through client");
}
if (!AreEqual(typeof(TValue), result.Value, value))
{
throw new Exception($"Failed to transport unboxed {typeof(KeyValuePair<TKey, TValue>)} through client");
}
var resultObject = await setup.GuardedOperationAsync(() => setup.Server.SendAndWaitAsync <object, object>(a));
if (!AreEqual(typeof(TKey), result.Key, key))
{
throw new Exception($"Failed to transport boxed {typeof(KeyValuePair<TKey, TValue>)} through server");
}
if (!AreEqual(typeof(TValue), result.Value, value))
{
throw new Exception($"Failed to transport boxed {typeof(KeyValuePair<TKey, TValue>)} through server");
}
resultObject = await setup.GuardedOperationAsync(() => setup.Client.SendAndWaitAsync <object, object>(a));
if (!AreEqual(typeof(TKey), result.Key, key))
{
throw new Exception($"Failed to transport boxed {typeof(KeyValuePair<TKey, TValue>)} through client");
}
if (!AreEqual(typeof(TValue), result.Value, value))
{
throw new Exception($"Failed to transport boxed {typeof(KeyValuePair<TKey, TValue>)} through client");
}
}
public static async Task RunWithDictionary <TKey, TValue>(ClientServerTester setup, TKey key, TValue value)
{
var a = new Dictionary <TKey, TValue>();
a.Add(key, value);
var result = (await setup.GuardedOperationAsync(() => setup.Server.SendAndWaitAsync <Dictionary <TKey, TValue>, Dictionary <TKey, TValue> >(a))).First();
if (!AreEqual(typeof(TKey), result.Key, key))
{
throw new Exception($"Failed to transport unboxed {typeof(Dictionary<TKey, TValue>)} through server");
}
if (!AreEqual(typeof(TValue), result.Value, value))
{
throw new Exception($"Failed to transport unboxed {typeof(Dictionary<TKey, TValue>)} through server");
}
result = (await setup.GuardedOperationAsync(() => setup.Client.SendAndWaitAsync <Dictionary <TKey, TValue>, Dictionary <TKey, TValue> >(a))).First();
if (!AreEqual(typeof(TKey), result.Key, key))
{
throw new Exception($"Failed to transport unboxed {typeof(Dictionary<TKey, TValue>)} through client");
}
if (!AreEqual(typeof(TValue), result.Value, value))
{
throw new Exception($"Failed to transport unboxed {typeof(Dictionary<TKey, TValue>)} through client");
}
result = ((Dictionary <TKey, TValue>)(await setup.GuardedOperationAsync(() => setup.Server.SendAndWaitAsync <object, object>(a)))).First();
if (!AreEqual(typeof(TKey), result.Key, key))
{
throw new Exception($"Failed to transport boxed {typeof(Dictionary<TKey, TValue>)} through server");
}
if (!AreEqual(typeof(TValue), result.Value, value))
{
throw new Exception($"Failed to transport boxed {typeof(Dictionary<TKey, TValue>)} through server");
}
result = ((Dictionary <TKey, TValue>)(await setup.GuardedOperationAsync(() => setup.Client.SendAndWaitAsync <object, object>(a)))).First();
if (!AreEqual(typeof(TKey), result.Key, key))
{
throw new Exception($"Failed to transport boxed {typeof(Dictionary<TKey, TValue>)} through client");
}
if (!AreEqual(typeof(TValue), result.Value, value))
{
throw new Exception($"Failed to transport boxed {typeof(Dictionary<TKey, TValue>)} through client");
}
}
public void TestEchoWithInts()
{
using (var setup = new ClientServerTester(EchoMethod, EchoMethod))
{
var sendIntTask = setup.GuardedOperationAsync(() => setup.Server.SendAndWaitAsync <int, int>(42));
if (sendIntTask.Result != 42)
{
throw new Exception("Failed to transport int through server");
}
sendIntTask = setup.GuardedOperationAsync(() => setup.Client.SendAndWaitAsync <int, int>(42));
if (sendIntTask.Result != 42)
{
throw new Exception("Failed to transport int through client");
}
}
}
public void TestEchoWithAllPrimitives()
{
System.Diagnostics.Trace.WriteLine($"* Running {nameof(TestEchoWithAllPrimitives)}");
using (var setup = new ClientServerTester(EchoMethod, EchoMethod))
{
foreach (var t in LeanIPC.TypeSerializer.PRIMITIVE_TYPES)
{
var v = CreateDefault(t);
if (v == null)
{
continue;
}
System.Diagnostics.Trace.WriteLine($"* Testing with {t}");
var method = typeof(IPCTypeTest).GetMethod(nameof(GenericInvokeHelper)).MakeGenericMethod(new Type[] { t });
var sendItemTask = (Task <object>)method.Invoke(null, new object[] { setup, setup.Server, v });
if (!AreEqual(t, sendItemTask.Result, v))
{
throw new Exception($"Failed to transport unboxed {t} through server");
}
sendItemTask = (Task <object>)method.Invoke(null, new object[] { setup, setup.Client, v });
if (!AreEqual(t, sendItemTask.Result, v))
{
throw new Exception($"Failed to transport unboxed {t} through server");
}
sendItemTask = setup.GuardedOperationAsync(() => setup.Server.SendAndWaitAsync <object, object>(v));
if (!AreEqual(t, sendItemTask.Result, v))
{
throw new Exception($"Failed to transport boxed {t} through server");
}
sendItemTask = setup.GuardedOperationAsync(() => setup.Client.SendAndWaitAsync <object, object>(v));
if (!AreEqual(t, sendItemTask.Result, v))
{
throw new Exception($"Failed to transport boxed {t} through client");
}
}
System.Diagnostics.Trace.WriteLine($"* Shutting down");
}
}
public void RemoteReferences()
{
using (var setup = new ClientServerTester(FailMethod, FailMethod))
{
var client = new RPCPeer(setup.Client);
var server = new RPCPeer(setup.Server, typeof(RemoteInvokeAble));
// Let the client create proxy objects
client.AddProxyGenerator((peer, type, handle) => new RemoteInvokeAbleProxy(peer, handle));
// Let the server pass the object by reference
server.TypeSerializer.RegisterSerializationAction(typeof(RemoteInvokeAble), SerializationAction.Reference);
// Run the tests
using (var proxy = client.InvokeRemoteMethodAsync <IRemoteInvokeAbleProxy>(0, typeof(RemoteInvokeAble).GetConstructor(new Type[0]), null, false).Result)
{
if (proxy.Echo("test message") != "Echo : test message")
{
throw new Exception("Expected echo message back");
}
if (proxy.ID != 42)
{
throw new Exception("Expected 42 as the ID");
}
proxy.ID = 45;
if (proxy.ID != 45)
{
throw new Exception("Expected 45 as the ID");
}
if (proxy.CreateTime == 0)
{
throw new Exception("Expected a proxy creation time");
}
proxy.CreateTime = 0;
if (proxy.CreateTime != 0)
{
throw new Exception("Expected no proxy creation time");
}
}
}
}
public void TestEchoWithAllPrimitivePairs()
{
System.Diagnostics.Trace.WriteLine($"* Running {nameof(TestEchoWithAllPrimitivePairs)}");
using (var setup = new ClientServerTester(EchoMethod, EchoMethod))
{
foreach (var t1 in LeanIPC.TypeSerializer.PRIMITIVE_TYPES)
{
foreach (var t2 in LeanIPC.TypeSerializer.PRIMITIVE_TYPES)
{
var v1 = CreateDefault(t1);
var v2 = CreateDefault(t2);
if (v1 == null || v2 == null)
{
continue;
}
System.Diagnostics.Trace.WriteLine($"* Testing with [{t1},{t2}]");
var sendItemTask = setup.GuardedOperationAsync(() => setup.Server.SendAndWaitAsync(new Type[] { t1, t2 }, new object[] { v1, v2 }));
if (!AreEqual(t1, sendItemTask.Result.Values[0], v1))
{
throw new Exception($"Failed to transport boxed {t1} through server");
}
if (!AreEqual(t2, sendItemTask.Result.Values[1], v2))
{
throw new Exception($"Failed to transport boxed {t2} through server");
}
sendItemTask = setup.GuardedOperationAsync(() => setup.Client.SendAndWaitAsync(new Type[] { t1, t2 }, new object[] { v1, v2 }));
if (!AreEqual(t1, sendItemTask.Result.Values[0], v1))
{
throw new Exception($"Failed to transport boxed {t1} through client");
}
if (!AreEqual(t2, sendItemTask.Result.Values[1], v2))
{
throw new Exception($"Failed to transport boxed {t2} through client");
}
}
}
System.Diagnostics.Trace.WriteLine($"* Shutting down");
}
}
public static async Task <RequestHandlerResponse> GenericInvokeHelper2 <T1, T2>(ClientServerTester setup, InterProcessConnection con, T1 v1, T2 v2)
{
return(await setup.GuardedOperationAsync(() => con.SendAndWaitAsync(new Type[] { typeof(T1), typeof(T2) }, new object[] { v1, v2 })));
}
public void TestRunningShutdown()
{
System.Diagnostics.Trace.WriteLine($"* Running {nameof(TestRunningShutdown)}");
try
{
using (var setup = new ClientServerTester(EchoMethod, EchoMethod))
{
System.Diagnostics.Trace.WriteLine($"* Firing into server");
// Fire a bunch of data into the system
for (var i = 0; i < 1000; i++)
{
setup.Server.SendAndWaitAsync <int, int>(i);
}
// Then quit without waiting for the responses
System.Diagnostics.Trace.WriteLine($"* Shutting down");
}
}
catch
{
}
try
{
using (var setup = new ClientServerTester(EchoMethod, EchoMethod))
{
System.Diagnostics.Trace.WriteLine($"* Firing into client");
// Fire a bunch of data into the system
for (var i = 0; i < 1000; i++)
{
setup.Client.SendAndWaitAsync <int, int>(i);
}
// Then quit without waiting for the responses
System.Diagnostics.Trace.WriteLine($"* Shutting down");
}
}
catch
{
}
try
{
using (var setup = new ClientServerTester(EchoMethod, EchoMethod))
{
System.Diagnostics.Trace.WriteLine($"* Firing into server and client");
// Fire a bunch of data into the system
for (var i = 0; i < 1000; i++)
{
setup.Server.SendAndWaitAsync <int, int>(i);
setup.Client.SendAndWaitAsync <int, int>(i);
}
// Then quit without waiting for the responses
System.Diagnostics.Trace.WriteLine($"* Killing connection");
}
}
catch
{
}
try
{
using (var setup = new ClientServerTester(EchoMethod, EchoMethod))
{
System.Diagnostics.Trace.WriteLine($"* Firing into server and client");
// Fire a bunch of data into the system
for (var i = 0; i < 1000; i++)
{
setup.Server.SendAndWaitAsync <int, int>(i);
setup.Client.SendAndWaitAsync <int, int>(i);
}
// Then quit without waiting for the responses
System.Diagnostics.Trace.WriteLine($"* Killing connection");
setup.S1.Dispose();
}
}
catch
{
}
try
{
using (var setup = new ClientServerTester(EchoMethod, EchoMethod))
{
System.Diagnostics.Trace.WriteLine($"* Firing into server and client");
// Fire a bunch of data into the system
for (var i = 0; i < 1000; i++)
{
setup.Server.SendAndWaitAsync <int, int>(i);
setup.Client.SendAndWaitAsync <int, int>(i);
}
// Then quit without waiting for the responses
System.Diagnostics.Trace.WriteLine($"* Killing connection");
setup.S2.Dispose();
}
}
catch
{
}
}
public static async Task <object> GenericInvokeHelper <T>(ClientServerTester setup, InterProcessConnection con, T value)
{
return((object)await setup.GuardedOperationAsync(() => con.SendAndWaitAsync <T, T>(value)));
}
public void RemoteInvoke()
{
using (var setup = new ClientServerTester(FailMethod, FailMethod))
{
var client = new RPCPeer(setup.Client);
var server = new RPCPeer(setup.Server, new Type[] { typeof(System.IO.Directory) }, (m, a) => m.Name == nameof(System.IO.Directory.GetCurrentDirectory));
var result = client.InvokeRemoteMethodAsync <string>(0L, typeof(System.IO.Directory).GetMethod(nameof(System.IO.Directory.GetCurrentDirectory)), null, false).Result;
if (result != System.IO.Directory.GetCurrentDirectory())
{
throw new Exception("Failed to get the correct ");
}
Exception res = null;
// Try unsupported type:
try
{
client.InvokeRemoteMethodAsync(0, typeof(System.IO.File).GetMethod(nameof(System.IO.File.Create)), new object[] { "test.txt" }, false).Wait();
}
catch (Exception ex)
{
res = ex;
}
if (res == null)
{
throw new Exception("Unwanted access to other type");
}
// Try other method
res = null;
try
{
client.InvokeRemoteMethodAsync(0, typeof(System.IO.Directory).GetMethod(nameof(System.IO.Directory.CreateDirectory)), new object[] { "testdir" }, false).Wait();
}
catch (Exception ex)
{
res = ex;
}
if (res == null)
{
throw new Exception("Unwanted access to other method");
}
// Try invoking on the client
res = null;
try
{
server.InvokeRemoteMethodAsync <string>(0, typeof(System.IO.Directory).GetMethod(nameof(System.IO.Directory.GetCurrentDirectory)), null, false).Wait();
}
catch (Exception ex)
{
res = ex;
}
if (res == null)
{
throw new Exception("Unwanted access to client method");
}
}
}