public void TestNotification()
{
using var listener = new VRpcListener(IPAddress.Any);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", listener.Port, false, true);
var iface = cli.GetProxy <IServerTestController>();
iface.Notify(123);
}
public void TestSumResult()
{
using var listener = new VRpcListener(IPAddress.Any);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", listener.Port, false, true);
var iface = cli.GetProxy <IServerTestController>();
int sum = iface.GetSum(1, 2);
Assert.Equal(3, sum);
}
public void TestAsyncCallback()
{
using var listener = new VRpcListener(IPAddress.Any);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", listener.Port, false, true);
var iface = cli.GetProxy <IServerTestController>();
string selfEcho = iface.MakeAsyncCallback("qwerty");
Assert.Equal("qwerty", selfEcho);
}
public async Task TestNullStringAsync()
{
using var listener = new VRpcListener(IPAddress.Any);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", listener.Port, false, true);
var iface = cli.GetProxy <IServerTestController>();
string value = await iface.GetNullStringAsync();
Assert.Null(value);
}
public void TestStringResult()
{
using var listener = new VRpcListener(IPAddress.Any);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", listener.Port, false, true);
var iface = cli.GetProxy <IServerTestController>();
string value = iface.GetString();
Assert.Equal("OK", value);
}
public async Task TestNotificationAsync()
{
const int port = 1008;
using var listener = new VRpcListener(IPAddress.Any, port);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", port, false, true);
var iface = cli.GetProxy <IServerTestController>();
await iface.NotifyAsync(123);
}
public async Task TestSumAsync()
{
using var listener = new VRpcListener(IPAddress.Any);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", listener.Port, false, true);
var iface = cli.GetProxy <IServerTestController>();
int sum = await iface.GetSumAsync(1, 2);
Assert.AreEqual(3, sum);
}
static void Main()
{
var listener = VRpcListener.StartNew(IPAddress.Any);
var cli = new VRpcClient("127.0.0.1", listener.Port, false, true);
var iface = cli.GetProxy <IServerTestController>();
iface.GetSum(1, 2);
iface.GetSum(1, 2);
iface.GetSum(1, 2);
Thread.Sleep(-1);
}
private static void Console_CancelKeyPress(ConsoleCancelEventArgs e, VRpcClient client)
{
_appExit = true;
if (!e.Cancel)
{
e.Cancel = true;
lock (_conLock)
{
Console.WriteLine("Stopping...");
}
}
client.Shutdown(TimeSpan.FromSeconds(100), "Был нажат Ctrl+C");
}
public void TestSumValueTask()
{
const int port = 1003;
using var listener = new VRpcListener(IPAddress.Any, port);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", port, false, true);
var iface = cli.GetProxy <IServerTestController>();
int sum = iface.GetSum2(1, 2);
Assert.Equal(3, sum);
}
public void TestNullStringResult()
{
const int port = 1005;
using var listener = new VRpcListener(IPAddress.Any, port);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", port, false, true);
var iface = cli.GetProxy <IServerTestController>();
string value = iface.GetNullString();
Assert.Null(value);
}
public void TestNotificationCallback()
{
using var listener = new VRpcListener(IPAddress.Any);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", listener.Port, false, true);
var mre = new ManualResetEventSlim(false);
cli.ConfigureService(x => x.AddSingleton(mre));
var iface = cli.GetProxy <IServerTestController>();
iface.NotifyCallback(123);
Assert.True(mre.Wait(30_000));
}
public async Task TestAsyncVoid()
{
using var listener = new VRpcListener(IPAddress.Any);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", listener.Port, false, false);
var iface = cli.GetProxy <IServerTestController>();
cli.Connect();
var sw = Stopwatch.StartNew();
await iface.Test2Async();
Assert.True(sw.ElapsedMilliseconds >= 500);
}
public void TestInternalError()
{
var listener = VRpcListener.StartNew(IPAddress.Any);
var client = new VRpcClient("localhost", listener.Port, false, true);
try
{
client.GetProxy <IServerTestController>().JTestInternalError();
}
catch (VRpcInternalErrorException)
{
return;
}
Assert.Fail();
}
public void TestMethodNotFound()
{
var listener = VRpcListener.StartNew(IPAddress.Any);
var client = new VRpcClient("localhost", listener.Port, false, true);
try
{
client.GetProxy <IServerTestController>().JNotExistedMethod();
}
catch (VRpcMethodNotFoundException)
{
return;
}
Assert.Fail();
}
public void TestVoid()
{
const int port = 1000;
using var listener = new VRpcListener(IPAddress.Any, port);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", port, false, false);
var iface = cli.GetProxy <IServerTestController>();
cli.Connect();
var sw = Stopwatch.StartNew();
iface.TestDelay();
Assert.True(sw.ElapsedMilliseconds >= 500);
}
public void TestMethodNotFound()
{
using var listener = new VRpcListener(IPAddress.Any);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", listener.Port, false, true);
var iface = cli.GetProxy <IServerTestController>();
try
{
iface.NotFoundMethod();
Assert.True(false);
}
catch (VRpcException ex)
{
}
}
public void TestException()
{
using var listener = new VRpcListener(IPAddress.Any);
listener.Start();
using var cli = new VRpcClient("127.0.0.1", listener.Port, false, true);
var iface = cli.GetProxy <IServerTestController>();
try
{
iface.TestException("проверка");
}
catch (VRpcBadRequestException ex)
{
Assert.Equal("проверка", ex.Message);
}
}
static async Task Main()
{
var listener = new VRpcListener(IPAddress.Any, 1234);
listener.Start();
var client = new VRpcClient("localhost", port: 1234, ssl: false, allowAutoConnect: true);
client.Connect();
var proxy = client.GetProxy <IBenchmark>();
while (true)
{
try
{
proxy.VoidOneArg(123);
}
catch (VRpcBadRequestException ex)
{
}
}
}
public void TestInterfaceNaming()
{
var rpc = new VRpcClient("127.0.0.1", 1234, false, true);
var decorator = rpc.GetProxyDecorator <IHomeController>();
Assert.AreEqual("Home", decorator.ControllerName);
try
{
rpc.GetProxy <I>();
Assert.True(false);
}
catch (VRpcException)
{
// OK
}
try
{
rpc.GetProxy <IController>();
Assert.True(false);
}
catch (VRpcException)
{
// OK
}
try
{
rpc.GetProxy <Controller>();
Assert.True(false);
}
catch (VRpcException)
{
// OK
}
}
static void Main()
{
Console.Title = "Клиент";
Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.AboveNormal;
Thread.CurrentThread.Priority = ThreadPriority.BelowNormal;
string ipStr;
IPAddress ipAddress;
do
{
Console.Write("IP адрес сервера (127.0.0.1): ");
ipStr = Console.ReadLine();
if (ipStr == "")
{
ipStr = "127.0.0.1";
}
} while (!IPAddress.TryParse(ipStr, out ipAddress));
string cpusStr;
int processorCount = Environment.ProcessorCount;
do
{
Console.Write($"Ядер – {processorCount}. Сколько потоков (1): ");
cpusStr = Console.ReadLine();
if (cpusStr == "")
{
cpusStr = $"{1}";
}
} while (!int.TryParse(cpusStr, out Threads));
long reqCount = 0;
int activeThreads = 0;
var threads = new List <Task>(Threads);
for (int i = 0; i < Threads; i++)
{
var t = Task.Factory.StartNew(() =>
{
if (_appExit)
{
return;
}
Interlocked.Increment(ref activeThreads);
using (var client = new VRpcClient(new Uri($"ws://{ipAddress}:{Port}"), true))
{
Console.CancelKeyPress += (__, e) => Console_CancelKeyPress(e, client);
client.ConfigureService(ioc =>
{
ioc.AddLogging(loggingBuilder =>
{
loggingBuilder
.AddConsole();
});
});
var controller = client.GetProxy <IBenchmarkController>();
while (true)
{
ConnectResult conResult;
while ((conResult = client.ConnectEx()).State == ConnectionState.SocketError)
{
Thread.Sleep(new Random().Next(2000, 3000));
}
if (conResult.State == ConnectionState.ShutdownRequest)
{
break;
}
while (true)
{
try
{
controller.VoidNoArgs();
}
catch (VRpcWasShutdownException)
{
return;
}
catch (Exception ex)
{
Console.Error.WriteLine(ex);
Thread.Sleep(new Random().Next(2000, 3000));
break;
}
Interlocked.Increment(ref reqCount);
}
}
// Подождать грациозное закрытие.
CloseReason closeReason = client.WaitCompletion();
}
Interlocked.Decrement(ref activeThreads);
}, TaskCreationOptions.LongRunning);
threads.Add(t);
}
long prev = 0;
Console.Clear();
var sw = Stopwatch.StartNew();
while (threads.TrueForAll(x => x.Status != TaskStatus.RanToCompletion))
{
Thread.Sleep(1000);
long elapsedMs = sw.ElapsedMilliseconds;
long rCount = Interlocked.Read(ref reqCount);
ulong reqPerSecond = unchecked ((ulong)(rCount - prev));
prev = rCount;
sw.Restart();
var reqPerSec = (int)Math.Round(reqPerSecond * 1000d / elapsedMs);
PrintConsole(activeThreads, reqPerSec);
}
PrintConsole(0, 0);
}
