private void GameLoop(int period, CancellationToken token)
{
Thread.CurrentThread.Name = "GameLoop";
//Get tickers
var tickers = Services.Resolve <IEnumerable <ITicker> >().OrderByDescending(t => t.Priority).ToList();
int tickCount = 0;
Map = Services.Resolve <TileMap>();
foreach (var ticker in tickers)
{
ticker.Start();
Logger.Info($"Started Ticker {ticker}");
}
while (!token.IsCancellationRequested)
{
var startTime = DateTime.Now;
foreach (var ticker in tickers)
{
ticker.Update(tickCount);
}
var duration = (DateTime.Now - startTime).Milliseconds;
Logger.Debug($"Tick {tickCount} takes {duration} ms.");
if (duration < period)
{
Thread.Sleep(period - duration);
}
else
{
Logger.Warn($"Tick {tickCount} timeout.");
}
tickCount++;
}
foreach (var session in RpcServer.Sessions)
{
session.OnExiting();
}
RpcServer.Stop();
Save();
//Stop tickers
foreach (var ticker in tickers)
{
ticker.Stop();
Logger.Info($"Stopped Ticker {ticker}");
}
}
static Task runServer(int limit)
{
var server = new RpcServer(new IPEndPoint(IPAddress.Loopback, port));
server.OnException = x => Console.WriteLine("server: " + x.Message);
return(server.Start((r, w) =>
{
r.OnAdd = (x, y) =>
{
if (limit == Interlocked.Increment(ref serverCounter))
{
server.Stop().Wait();
}
return x + y;
};
}));
}
static void Main(string[] args)
{
//var server = new Server("127.0.0.1", 5000);
//server.Start();
//Console.WriteLine("按任意键关闭server...");
//Console.ReadLine();
//server.Stop();
var server = new RpcServer("127.0.0.1", 5000);
var simpleContract = new DataContractImpl();
server.AddService <IDataContract>(simpleContract);
server.Start();
Console.WriteLine("按任意键关闭server...");
Console.ReadLine();
server.Stop();
Console.Read();
}
private static long Dispose = 0; // To detect redundant calls
public static async Task DisposeAsync()
{
var compareRes = Interlocked.CompareExchange(ref Dispose, 1, 0);
if (compareRes == 1)
{
while (Interlocked.Read(ref Dispose) != 2)
{
await Task.Delay(50);
}
return;
}
else if (compareRes == 2)
{
return;
}
try
{
await DisposeInWalletDependentServicesAsync();
if (RpcServer != null)
{
RpcServer.Stop();
Logger.LogInfo($"{nameof(RpcServer)} is stopped.", nameof(Global));
}
if (UpdateChecker != null)
{
await UpdateChecker?.StopAsync();
Logger.LogInfo($"{nameof(UpdateChecker)} is stopped.", nameof(Global));
}
if (Synchronizer != null)
{
await Synchronizer?.StopAsync();
Logger.LogInfo($"{nameof(Synchronizer)} is stopped.", nameof(Global));
}
if (AddressManagerFilePath != null)
{
IoHelpers.EnsureContainingDirectoryExists(AddressManagerFilePath);
if (AddressManager != null)
{
AddressManager?.SavePeerFile(AddressManagerFilePath, Config.Network);
Logger.LogInfo($"{nameof(AddressManager)} is saved to `{AddressManagerFilePath}`.", nameof(Global));
}
}
if (Nodes != null)
{
Nodes?.Disconnect();
while (Nodes.ConnectedNodes.Any(x => x.IsConnected))
{
await Task.Delay(50);
}
Nodes?.Dispose();
Logger.LogInfo($"{nameof(Nodes)} are disposed.", nameof(Global));
}
if (RegTestMemPoolServingNode != null)
{
RegTestMemPoolServingNode.Disconnect();
Logger.LogInfo($"{nameof(RegTestMemPoolServingNode)} is disposed.", nameof(Global));
}
if (TorManager != null)
{
await TorManager?.StopAsync();
Logger.LogInfo($"{nameof(TorManager)} is stopped.", nameof(Global));
}
if (AsyncMutex.IsAny)
{
try
{
await AsyncMutex.WaitForAllMutexToCloseAsync();
Logger.LogInfo($"{nameof(AsyncMutex)}(es) are stopped.", nameof(Global));
}
catch (Exception ex)
{
Logger.LogError($"Error during stopping {nameof(AsyncMutex)}: {ex}", nameof(Global));
}
}
}
catch (Exception ex)
{
Logger.LogWarning(ex, nameof(Global));
}
finally
{
Interlocked.Exchange(ref Dispose, 2);
}
}
/// <inheritdoc cref="NtCore.StopRpcServer"/>
public void StopRpcServer()
{
m_rpcServer.Stop();
}
private void RpcSingleProcessTest(int runs, int loops, RpcConfig config, RpcTestType type)
{
var server = new RpcServer <SimpleRpcSession, RpcConfig>(config, null);
TestService testService;
double[] totalValues = { 0, 0 };
var sw = new Stopwatch();
var wait = new AutoResetEvent(false);
var completeTest = new AutoResetEvent(false);
var client = new RpcClient <SimpleRpcSession, RpcConfig>(config);
server.SessionSetup += (sender, args) =>
{
testService = new TestService();
args.Session.AddService(testService);
testService.Completed += (o, session) =>
{
sw.Stop();
var mode = "Release";
#if DEBUG
mode = "Debug";
#endif
var messagesPerSecond = (int)((double)runs / sw.ElapsedMilliseconds * 1000);
Console.WriteLine("| {0,7} | {1,9} | {2,10:N0} | {3,12:N0} | {4,8:N0} |", mode, type, runs,
sw.ElapsedMilliseconds, messagesPerSecond);
totalValues[0] += sw.ElapsedMilliseconds;
totalValues[1] += messagesPerSecond;
wait.Set();
};
};
server.Start();
Console.WriteLine("| Build | Type | Calls | Milliseconds | RPC/sec |");
Console.WriteLine("|---------|-----------|------------|--------------|------------|");
var send = new Action(() =>
{
var service = client.Session.GetProxy <ITestService>();
service.ResetTest();
sw.Restart();
for (var i = 0; i < runs; i++)
{
switch (type)
{
case RpcTestType.LngBlock:
service.TestNoReturnLongBlocking();
break;
case RpcTestType.Block:
service.TestNoReturnBlock();
break;
case RpcTestType.NoReturn:
service.TestNoReturn();
break;
case RpcTestType.Await:
service.TestNoReturnAwait();
break;
case RpcTestType.Return:
service.TestIncrement();
break;
case RpcTestType.Exception:
try
{
service.TestException();
}
catch
{
//ignored
}
break;
}
}
wait.WaitOne();
wait.Reset();
});
client.Ready += (sender, args) =>
{
Thread.Sleep(300);
args.Session.AddProxy <ITestService>("TestService");
var service = client.Session.GetProxy <ITestService>();
service.TestSetup(runs);
for (var i = 0; i < loops; i++)
{
send();
}
Console.WriteLine("| | | AVERAGES | {0,12:N0} | {1,10:N0} |", totalValues[0] / loops,
totalValues[1] / loops);
Console.WriteLine();
server.Stop();
client.Close();
completeTest.Set();
};
client.Connect();
completeTest.WaitOne();
}