/// <summary>
/// Creates a task that will complete when it receives a SIGINT, SIGTERM or SIGHUP signal.
/// </summary>
/// <returns></returns>
private static Task WaitForUnixKillSignal()
{
var sigIntHandle = new UnixSignal(Signum.SIGINT);
var sigTermHandle = new UnixSignal(Signum.SIGTERM);
var sigHupHandle = new UnixSignal(Signum.SIGHUP);
return(Task.Factory.StartNew(() =>
{
int signal = UnixSignal.WaitAny(new[] { sigIntHandle, sigTermHandle, sigHupHandle });
if (signal == 0)
{
Log("Received kill signal (SIGINT)");
}
else if (signal == 1)
{
Log("Received kill signal (SIGTERM)");
}
else if (signal == 2)
{
Log("Received kill signal (SIGHUP)");
}
else
{
Log("Received kill signal (unknown)");
}
}, TaskCreationOptions.LongRunning));
}
static void InitSignalHandlers()
{
if ((Environment.OSVersion.Platform == PlatformID.Unix) ||
(Environment.OSVersion.Platform == PlatformID.MacOSX))
{
// Register shutdown handlers
#if LOG4NET
_Logger.Info("Registering signal handlers");
#endif
UnixSignal[] shutdown_signals =
{
new UnixSignal(Signum.SIGINT),
new UnixSignal(Signum.SIGTERM),
};
Thread signal_thread = new Thread(() => {
var index = UnixSignal.WaitAny(shutdown_signals);
#if LOG4NET
_Logger.Info("Caught signal " + shutdown_signals[index].Signum.ToString() + ", shutting down");
#endif
Gtk.Application.Invoke(delegate {
Quit();
});
});
signal_thread.IsBackground = true;
signal_thread.Start();
}
}
public void TestRaise()
{
Thread t1 = new Thread(delegate() {
using (UnixSignal a = new UnixSignal(Signum.SIGINT)) {
DateTime start = DateTime.Now;
bool r = a.WaitOne(5000, false);
DateTime end = DateTime.Now;
Assert.AreEqual(a.Count, 1);
Assert.AreEqual(r, true);
if ((end - start) > new TimeSpan(0, 0, 5))
{
throw new InvalidOperationException("Signal slept too long");
}
}
});
Thread t2 = new Thread(delegate() {
Thread.Sleep(1000);
Stdlib.raise(Signum.SIGINT);
});
t1.Start();
t2.Start();
t1.Join();
t2.Join();
}
public void TestNoEmitAny()
{
using (UnixSignal u = new UnixSignal(Signum.SIGINT)) {
int idx = UnixSignal.WaitAny(new UnixSignal[] { u }, 5100);
Assert.AreEqual(idx, 5100);
}
}
private static void Main(string[] args)
{
var uri = "http://localhost:8900";
StaticConfiguration.DisableErrorTraces = false;
using (var host = new NancyHost(new HostConfiguration {
UrlReservations = new UrlReservations {
CreateAutomatically = true
}
}, new Uri(uri)))
{
host.Start();
if (Type.GetType("Mono.Runtime") != null)
{
UnixSignal.WaitAny(new[]
{
new UnixSignal(Signum.SIGINT),
new UnixSignal(Signum.SIGTERM),
new UnixSignal(Signum.SIGQUIT),
new UnixSignal(Signum.SIGHUP)
});
}
else
{
Console.WriteLine(string.Format("I'm a runnin' on {0}", uri));
Console.ReadKey();
}
host.Stop();
}
}
public static void Main(string[] args)
{
BasicConfigurator.Configure();
var now = DateTime.UtcNow;
var uri = "http://localhost:8888";
Log.Info(log, "Starting MyRouter on " + uri, DateTime.UtcNow);
// initialize an instance of NancyHost
var host = new NancyHost(new Uri(uri));
host.Start(); // start hosting
// check if we're running on mono
if (Type.GetType("Mono.Runtime") != null)
{
// on mono, processes will usually run as daemons - this allows you to listen
// for termination signals (ctrl+c, shutdown, etc) and finalize correctly
UnixSignal.WaitAny(new[] {
new UnixSignal(Signum.SIGINT),
new UnixSignal(Signum.SIGTERM),
new UnixSignal(Signum.SIGQUIT),
new UnixSignal(Signum.SIGHUP)
});
}
else
{
System.Console.ReadLine();
}
Log.Info(log, "Stopping Nancy", DateTime.UtcNow);
host.Stop(); // stop hosting
}
public static void Main()
{
AppConfig.Init();
using (var host = new NancyHost(new Uri(AppConfig.HostUri), new Bootstrapper(), new HostConfiguration {
UrlReservations = new UrlReservations {
CreateAutomatically = true
}
}))
{
host.Start();
Log.Write("Server started at " + AppConfig.HostUri);
if (Type.GetType("Mono.Runtime") != null)
{
UnixSignal.WaitAny(new[]
{
new UnixSignal(Signum.SIGINT),
new UnixSignal(Signum.SIGTERM),
new UnixSignal(Signum.SIGQUIT),
new UnixSignal(Signum.SIGHUP)
});
}
else
{
while (Console.ReadKey().Key != ConsoleKey.Escape)
{
}
}
host.Stop();
}
}
static void Main(string[] args)
{
#if DEBUG
const string url = "http://+:8899";
#else
const string url = "http://+:8888";
#endif
Console.WriteLine($"Starting Nancy on {url} @ {DateTime.Now}");
using (WebApp.Start <Startup>(url))
{
if (IsRunningOnMono())
{
var terminationSignals = GetUnixTerminationSignals();
UnixSignal.WaitAny(terminationSignals);
}
else
{
Console.ReadLine();
}
}
Console.WriteLine($"Stopped Nancy on {url} @ {DateTime.Now}");
}
public void TestRaiseRTMINPlusOneSignal()
{
if (!TestHelper.CanUseRealTimeSignals())
{
return;
}
/*this number is a guestimate, but it's ok*/
for (int i = 1; i < 10; ++i)
{
RealTimeSignum rts = new RealTimeSignum(i);
UnixSignal signal;
try {
signal = new UnixSignal(rts);
} catch (ArgumentException) { /*skip the ones that are unavailable*/
continue;
}
using (signal)
{
MultiThreadTest(signal, 5000, delegate() {
Thread.Sleep(1000);
Stdlib.raise(rts);
});
}
return;
}
Assert.IsTrue(false, "#1 No available RT signal");
}
public void TestCanRegisterRTSignalMultipleTimes()
{
if (!TestHelper.CanUseRealTimeSignals())
{
return;
}
/*this number is a guestimate, but it's ok*/
for (int i = 1; i < 10; ++i)
{
RealTimeSignum rts = new RealTimeSignum(i);
UnixSignal signal;
try {
signal = new UnixSignal(rts);
} catch (ArgumentException) { /*skip the ones that are unavailable*/
continue;
}
try {
using (UnixSignal signal2 = new UnixSignal(rts))
{
//ok
return;
}
} catch (ArgumentException) { /*skip the ones that are unavailable*/
Assert.IsTrue(false, "#1 Could not register second signal handler");
}
}
Assert.IsTrue(false, "#2 No available RT signal");
}
private void HandleSignals()
{
const int timeoutMs = 1000;
while (!_stop)
{
UnixSignal[] handledSignals;
lock (_handledSignalsLock) {
handledSignals = _handledSignals.ToArray();
}
var index = UnixSignal.WaitAny(handledSignals, TimeSpan.FromMilliseconds(timeoutMs));
if (index == timeoutMs)
{
continue;
}
if (_actions.TryGetValue(handledSignals[index].Signum, out List <Action> actions))
{
foreach (var action in actions)
{
action.Invoke();
}
}
handledSignals[index].Reset();
}
}
static void Main(string[] args)
{
var uri = "http://localhost:8888";
Logger.Info("Starting server on {0}", uri);
var host = new NancyHost(new Uri(uri));
host.Start();
if (Type.GetType("Mono.Runtime") != null)
{
UnixSignal.WaitAny(new[]
{
new UnixSignal(Signum.SIGINT),
new UnixSignal(Signum.SIGTERM),
new UnixSignal(Signum.SIGQUIT),
new UnixSignal(Signum.SIGHUP)
});
}
else
{
Console.ReadLine();
}
Logger.Info("Stopping server...");
host.Stop();
NLog.LogManager.Shutdown();
}
public void TestSeparation()
{
Thread t1 = new Thread(delegate() {
using (UnixSignal a = new UnixSignal(Signum.SIGINT))
using (UnixSignal b = new UnixSignal(Signum.SIGTERM)) {
var sw = Stopwatch.StartNew();
int idx = UnixSignal.WaitAny(new UnixSignal[] { a, b }, 5000);
sw.Stop();
Assert.AreEqual(idx, 1);
Assert.AreEqual(a.Count, 0);
Assert.AreEqual(b.Count, 1);
if (sw.Elapsed > new TimeSpan(0, 0, 5))
{
throw new InvalidOperationException("Signal slept too long");
}
}
});
Thread t2 = new Thread(delegate() {
Thread.Sleep(1000);
Stdlib.raise(Signum.SIGTERM);
});
t1.Start();
t2.Start();
t1.Join();
t2.Join();
}
public void TestRaise()
{
Thread t1 = new Thread(delegate() {
using (UnixSignal a = new UnixSignal(Signum.SIGINT)) {
var sw = Stopwatch.StartNew();
bool r = a.WaitOne(5000, false);
sw.Stop();
Assert.AreEqual(a.Count, 1);
Assert.AreEqual(r, true);
if (sw.Elapsed > new TimeSpan(0, 0, 5))
{
throw new InvalidOperationException("Signal slept too long");
}
}
});
Thread t2 = new Thread(delegate() {
Thread.Sleep(1000);
Stdlib.raise(Signum.SIGINT);
});
t1.Start();
t2.Start();
t1.Join();
t2.Join();
}
static void Main()
{
ServiceStartup.Run();
UnixSignal[] signals =
{
new UnixSignal(Signum.SIGINT),
new UnixSignal(Signum.SIGTERM),
};
// Wait for a unix signal
for (bool exit = false; !exit;)
{
int id = UnixSignal.WaitAny(signals);
if (id >= 0 && id < signals.Length)
{
if (signals[id].IsSet)
{
exit = true;
}
}
}
ServiceStartup.Stop();
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Console(new RenderedCompactJsonFormatter())
.Enrich.FromLogContext()
.CreateLogger();
// See https://support.microsoft.com/en-gb/help/821268/contention-poor-performance-and-deadlocks-when-you-make-calls-to-web-s
ThreadPool.SetMaxThreads(100, 100);
ThreadPool.SetMinThreads(50, 50);
Parser.Default.ParseArguments <DeploymentPoolArgs>(args)
.WithParsed(parsedArgs =>
{
parsedArgs.Validate();
var spatialRefreshToken = Environment.GetEnvironmentVariable(SpatialRefreshTokenEnvironmentVariable) ??
throw new Exception(
$"{SpatialRefreshTokenEnvironmentVariable} environment variable is required.");
if (spatialRefreshToken == "")
{
throw new ArgumentException("Refresh token should not be empty");
}
IAnalyticsSender analyticsSender = new AnalyticsSenderBuilder("deployment_pool")
.WithCommandLineArgs(parsedArgs)
.With(new LogExceptionStrategy(Log.Logger))
.Build();
var spatialDeploymentClient =
DeploymentServiceClient.Create(credentials: new PlatformRefreshTokenCredential(spatialRefreshToken));
var spatialSnapshotClient =
SnapshotServiceClient.Create(credentials: new PlatformRefreshTokenCredential(spatialRefreshToken));
var platformInvoker = new PlatformInvoker(parsedArgs, spatialDeploymentClient, spatialSnapshotClient, analyticsSender);
var cancelTokenSource = new CancellationTokenSource();
var cancelToken = cancelTokenSource.Token;
var metricsServer = new MetricServer(parsedArgs.MetricsPort).Start();
var dplPool = new DeploymentPool(parsedArgs, spatialDeploymentClient, platformInvoker, cancelToken, analyticsSender);
var dplPoolTask = Task.Run(() => dplPool.Start());
var unixSignalTask = Task.Run(() => UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM) }));
Task.WaitAny(dplPoolTask, unixSignalTask);
if (unixSignalTask.IsCompleted)
{
Log.Information($"Received UNIX signal {unixSignalTask.Result}");
Log.Information("Server shutting down...");
cancelTokenSource.Cancel();
metricsServer.StopAsync();
dplPoolTask.Wait();
Log.Information("Server stopped cleanly");
}
else
{
/* The server task has completed; we can just exit. */
Log.Information($"The deployment pool has stopped itself or encountered an unhandled exception {dplPoolTask.Exception}");
}
});
}
public static void Main(string [] args)
{
if (args.Length == 0)
{
UnixSignal [] signals = new UnixSignal[] {
new UnixSignal(Signum.SIGINT),
new UnixSignal(Signum.SIGTERM),
};
RemotingConfiguration.Configure(ConfigurationFileName, false);
ShowVerboseConfigurationInfo(ConfigurationFileName);
// Wait for a unix signal to exit
for (bool exit = false; !exit;)
{
int id = UnixSignal.WaitAny(signals);
if (id >= 0 && id < signals.Length)
{
if (signals[id].IsSet)
{
exit = true;
}
}
}
}
else
{
ShowUsage();
}
}
static void Main(string[] args)
{
var matcher = new Matcher();
var matcherTask = new Task(() => { matcher.Start(); });
var unixSignalTask = new Task <int>(() =>
{
return(UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM) }));
});
matcherTask.Start();
Console.WriteLine("Matcher started up");
unixSignalTask.Start();
Task.WaitAny(matcherTask, unixSignalTask);
if (unixSignalTask.IsCompleted)
{
Console.WriteLine($"Received UNIX signal {unixSignalTask.Result}");
Console.WriteLine("Matcher shutting down...");
matcher.Stop();
matcherTask.Wait(TimeSpan.FromSeconds(10));
Console.WriteLine("Matcher stopped cleanly");
}
else
{
/* The matcher task has completed; we can just exit. */
Console.WriteLine("The matcher has stopped itself or encountered an unhandled exception.");
}
Environment.Exit(0);
}
public static void Main(string[] args)
{
// See https://support.microsoft.com/en-gb/help/821268/contention-poor-performance-and-deadlocks-when-you-make-calls-to-web-s
// Experimentation shows we need the ThreadPool to always spin up threads for good performance under load
ThreadPool.GetMaxThreads(out var workerThreads, out var ioThreads);
ThreadPool.SetMinThreads(workerThreads, ioThreads);
Parser.Default.ParseArguments <PartyServerCommandLineArgs>(args)
.WithParsed(parsedArgs =>
{
parsedArgs.Validate();
var spatialRefreshToken = Secrets.GetEnvSecret(SpatialRefreshTokenEnvironmentVariable);
PartyDataModel.Defaults.MinMembers = (uint)parsedArgs.DefaultMinMembers;
PartyDataModel.Defaults.MaxMembers = (uint)parsedArgs.DefaultMaxMembers;
Log.Logger = new LoggerConfiguration()
.WriteTo.Console(new RenderedCompactJsonFormatter())
.Enrich.FromLogContext()
.CreateLogger();
using (var server = GrpcBaseServer.Build(parsedArgs))
using (var memoryStoreManager = new RedisClientManager(parsedArgs.RedisConnectionString))
{
Log.Information($"Successfully connected to Redis at {parsedArgs.RedisConnectionString}");
server.AddInterceptor(new PlayerIdentityTokenValidatingInterceptor(
PlayerAuthServiceClient.Create(credentials: new PlatformRefreshTokenCredential(spatialRefreshToken)),
memoryStoreManager.GetRawClient(Database.CACHE)
))
.AddInterceptor(new ExceptionMappingInterceptor(new Dictionary <Type, StatusCode>
{
{ typeof(EntryNotFoundException), StatusCode.NotFound },
{ typeof(EntryAlreadyExistsException), StatusCode.AlreadyExists },
{ typeof(TransactionAbortedException), StatusCode.Unavailable }
}));
server.AddService(
PartyService.BindService(new PartyServiceImpl(memoryStoreManager)));
server.AddService(
InviteService.BindService(new InviteServiceImpl(memoryStoreManager)));
var serverTask = Task.Run(() => server.Start());
var signalTask = Task.Run(() => UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM) }));
Task.WaitAny(serverTask, signalTask);
if (signalTask.IsCompleted)
{
Log.Information($"Received UNIX signal {signalTask.Result}");
Log.Information("Server shutting down...");
server.Shutdown();
serverTask.Wait();
Log.Information("Server stopped cleanly");
}
else
{
/* The server task has completed; we can just exit. */
Log.Information("The Party server has stopped itself or encountered an unhandled exception.");
}
}
});
}
private static void SigTermHandler()
{
Console.WriteLine("(initializing SIGTERM handler)");
UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGTERM) });
TaskTimerFactory.ShutdownAll();
_host.Dispose();
}
static void Main(string[] args)
{
GamePlatform.Init();
if (GamePlatform.Startup())
{
Console.WriteLine("Press any [Enter] to close the host.");
// check if we're running on mono
if (Utility.CheckIfRunningOnMono())
{
// on mono, processes will usually run as daemons - this allows you to listen
// for termination signals (ctrl+c, shutdown, etc) and finalize correctly
UnixSignal.WaitAny(new[] {
new UnixSignal(Signum.SIGINT),
new UnixSignal(Signum.SIGTERM),
new UnixSignal(Signum.SIGQUIT),
new UnixSignal(Signum.SIGHUP)
});
}
else
{
Console.ReadLine();
}
}
//AirFrog.LoggerMan.LogErr("Stopping AirFrog by hand or system signal.");
GamePlatform.Stop();
}
public void TestRealTimeSignumProperty()
{
RealTimeSignum rts = new RealTimeSignum(0);
UnixSignal signal1 = new UnixSignal(rts);
Assert.That(signal1.RealTimeSignum, Is.EqualTo(rts));
}
public static void Run(Uri endpointUri, Type[] serviceTypes)
{
if (serviceTypes == null)
{
throw new ArgumentNullException(nameof(serviceTypes));
}
using (var servicehost = new ServiceHost()) {
servicehost.Start(endpointUri, serviceTypes);
Console.WriteLine("Service host running on {0}...", endpointUri.ToString());
if (Is_running_on_Mono)
{
Console.WriteLine("Ctrl-C to stop service host");
UnixSignal.WaitAny(UnixTerminationSignals);
}
else
{
Console.WriteLine("ENTER to stop service host");
Console.ReadLine();
}
Console.WriteLine("Stopping service host");
servicehost.Stop();
}
}
public void TestSeparation()
{
Thread t1 = new Thread(delegate() {
using (UnixSignal a = new UnixSignal(Signum.SIGINT))
using (UnixSignal b = new UnixSignal(Signum.SIGTERM)) {
DateTime start = DateTime.Now;
int idx = UnixSignal.WaitAny(new UnixSignal[] { a, b }, 5000);
DateTime end = DateTime.Now;
Assert.AreEqual(idx, 1);
Assert.AreEqual(a.Count, 0);
Assert.AreEqual(b.Count, 1);
if ((end - start) > new TimeSpan(0, 0, 5))
{
throw new InvalidOperationException("Signal slept too long");
}
}
});
Thread t2 = new Thread(delegate() {
Thread.Sleep(1000);
Stdlib.raise(Signum.SIGTERM);
});
t1.Start();
t2.Start();
t1.Join();
t2.Join();
}
/// <summary>
/// Set a handler for SIGINT, so they system can exit gracefully.
/// </summary>
public static void setSignalHandler <MeasurerT, PoseT, MeasurementT>(
Manipulator <MeasurerT, PoseT, MeasurementT> manipulator)
where PoseT : IPose <PoseT>, new()
where MeasurementT : IMeasurement <MeasurementT>, new()
where MeasurerT : IMeasurer <MeasurerT, PoseT, MeasurementT>, new()
{
UnixSignal sigint = new UnixSignal(Mono.Unix.Native.Signum.SIGINT);
signalthread = new Thread(() => {
while (true)
{
sigint.WaitOne();
if (manipulator != null && !manipulator.Abort)
{
manipulator.Abort = true;
}
else
{
Environment.Exit(1);
}
}
});
signalthread.Start();
}
static Thread CreateWaitAnyThread(params UnixSignal[] usignals)
{
return(new Thread(delegate() {
int idx = UnixSignal.WaitAny(usignals, 30000);
Assert.AreEqual(idx >= 0 && idx < usignals.Length, true);
}));
}
private static void HookUnixCancelSignals()
{
// SetConsoleCtrlHandler not exposed on mono
// Seems like a bit of a complex topic http://mono.1490590.n4.nabble.com/Control-C-handler-td1532196.html
// Some hope http://stackoverflow.com/questions/6546509/detect-when-console-application-is-closing-killed
// http://www.mono-project.com/docs/faq/technical/#operating-system-questions
// Need to conditionally reference Mono.Posix for all this to work
// https://github.com/ninjarobot/MonoConditionalReference
// Catch SIGINT and SIGUSR1
UnixSignal[] signals = new UnixSignal [] {
new UnixSignal (Signum.SIGINT),
new UnixSignal (Signum.SIGUSR1),
};
var token = new ProcessCancellationToken();
var signal_thread = new Thread(() =>
{
while (true)
{
// Wait for a signal to be delivered
int index = UnixSignal.WaitAny(signals, -1);
var signal = signals[index].Signum;
// Notify the main thread that a signal was received
CancelRequested = true;
}
});
}
static void Main(string[] args)
{
var uri = "http://localhost:8888";
Logger.Info("Starting Nancy on " + uri);
// initialize an instance of NancyHost
var host = new NancyHost(new Uri(uri));
host.Start();
// check if we're running on mono
if (Type.GetType("Mono.Runtime") != null)
{
// on mono, processes will usually run as daemons - this allows you to listen
// for termination signals (ctrl+c, shutdown, etc) and finalize correctly
UnixSignal.WaitAny(new[]
{
new UnixSignal(Signum.SIGINT),
new UnixSignal(Signum.SIGTERM),
new UnixSignal(Signum.SIGQUIT),
new UnixSignal(Signum.SIGHUP)
});
}
else
{
Console.ReadLine();
}
Logger.Info("Stopping Nancy");
host.Stop();
}
private void StartShutdownSignalHandlerThread()
{
if (_ShutdownSignalHandlerThread == null)
{
_ShutdownSignalHandlerThread = new Thread(() => {
try {
var signals = new UnixSignal[] {
new UnixSignal(Signum.SIGINT),
};
while (true)
{
if (UnixSignal.WaitAny(signals, -1) != -1)
{
ProgramLifetime.MainView?.CloseView();
}
}
} catch (ThreadAbortException) {
; // these get rethrown automatically, I just don't want them logged
} catch (Exception ex) {
try {
var log = Factory.ResolveSingleton <ILog>();
log.WriteLine("Caught exception in shutdown signal handler: {0}", ex);
} catch {
// Don't let exceptions bubble out of a background thread
}
}
});
_ShutdownSignalHandlerThread.Start();
}
}
public static int Main(string[] args)
{
var server = WebApp.Start($"http://+:5000", appBuilder => {
appBuilder.Run(ctx => {
ctx.Response.StatusCode = 200;
return(ctx.Response.WriteAsync("<h1>٩(｡•́‿•̀｡)۶</h1>"));
});
});
Console.WriteLine("Listening http://0.0.0.0:5000/");
Console.WriteLine("Press Ctrl+C, send INT or TERM signal to stop.");
Console.Error.WriteLine("Hello from STDERR.");
UnixSignal.WaitAny(new []
{
new UnixSignal(Signum.SIGINT),
new UnixSignal(Signum.SIGTERM)
}, -1);
Console.WriteLine("Stopping...");
server.Dispose();
return(0);
}
static void Main(string[] args)
{
var strPort = Environment.GetEnvironmentVariable("PORT") ?? "8080";
var strUrl = string.Format("http://*:{0}", strPort);
var options = new StartOptions();
options.Urls.Add(strUrl);
using (WebApp.Start(options, builder =>
{
ServiceContext.Instance.HangfireContext.Initialize(builder);
builder.UseNancy();
}))
{
Console.WriteLine("Started Nancy on {0}...", strUrl);
if (IsRunningOnMono())
{
var terminationSignals = GetUnixTerminationSignals();
UnixSignal.WaitAny(terminationSignals);
}
else
{
Console.ReadKey();
}
}
}
