public Listener(Args args)
{
var certfile = ExecutableTools.Relative("DaemonManager.pfx");
certificate = new X509Certificate2(certfile, "none");
factory = args.ShellFactory;
clients = new Dictionary <string, ClientRt>();
server = new TcpListener(args.EndPoint);
server.MakeNotInheritable();
using (var disposer = new Disposer())
{
//push must match dispose order
register = new Runner(new Runner.Args {
ThreadName = "Register"
});
disposer.Push(register);
accepter = new Runner(new Runner.Args {
ThreadName = "Accepter"
});
disposer.Push(accepter);
disposer.Push(Dispose); //ensure cleanup order
server.Start();
endpoint = server.LocalEndpoint as IPEndPoint;
disposer.Clear();
}
}
public DaemonRT(DaemonDto dto, string root, int delay)
{
this.delay = delay;
this.dto = dto.Clone();
using (var disposer = new Disposer())
{
process = new DaemonProcess(new DaemonProcess.Args
{
Executable = PathTools.Combine(root, dto.Path),
//id matches [a-zA_Z][a-zA_Z0-9_]*
Arguments = string.Format("Id={0} Daemon=True {1}", dto.Id, dto.Args),
});
disposer.Push(process);
status = "Starting...";
reader = new Runner(new Runner.Args {
ThreadName = string.Format("DAEMON_{0}_{1}_O", dto.Id, process.Id)
});
erroer = new Runner(new Runner.Args {
ThreadName = string.Format("DAEMON_{0}_{1}_E", dto.Id, process.Id)
});
disposer.Push(erroer);
disposer.Push(Dispose); //ensure cleanup order
erroer.Run(ErrorLoop);
reader.Run(ReadLoop);
reader.Run(UpdateRestart);
disposer.Clear();
}
}
public Instance(Args args)
{
using (var disposer = new Disposer())
{
Logger.Trace("DbPath {0}", args.DbPath);
Logger.Trace("Downloads {0}", args.Downloads);
Logger.Trace("RestartDelay {0}ms", args.RestartDelay);
Logger.Trace("EndPoint {0}", args.EndPoint);
factory = new ShellFactory();
factory.Add(new SystemScriptable());
factory.Add(new RunnerScriptable(args.Downloads));
factory.Add(new DownloadScriptable(args.Downloads));
manager = new Manager(new Manager.Args
{
RestartDelay = args.RestartDelay,
Root = args.Downloads,
Database = args.DbPath,
});
disposer.Push(manager);
factory.Add(manager);
listener = new Listener(new Listener.Args
{
ShellFactory = factory,
EndPoint = args.EndPoint,
});
disposer.Push(listener);
factory.Add(listener);
endpoint = listener.EndPoint;
disposer.Push(Dispose); //ensure cleanup order
listener.Start();
disposer.Clear();
}
}
protected virtual void CleanupBindings()
{
if (_isQuitting)
{
return;
}
Disposer.Clear();
}
public override void Setup(IEventSystem eventSystem, IPoolManager poolManager, GroupFactory groupFactory)
{
base.Setup(eventSystem, poolManager, groupFactory);
EventSystem.OnEvent <DeathEvent> ().Where(_ => _.Target.HasComponent <InputComponent> ()).Subscribe(_ =>
{
Observable.EveryUpdate().Subscribe(__ =>
{
if (Input.GetMouseButton(0))
{
EventSystem.Publish(new LoadSceneEvent()
{
SceneName = "Level_01"
});
Disposer.Clear();
}
}).AddTo(Disposer).AddTo(this);
}).AddTo(this);
}
private void AcceptLoop()
{
while (true)
{
var client = server.AcceptTcpClient();
register.Run(() =>
{
using (var disposer = new Disposer())
{
disposer.Push(client);
var rt = new ClientRt(client, certificate, factory);
disposer.Push(rt.Dispose); //ensure cleanup order
clients.Add(rt.EndPoint.ToString(), rt);
rt.Run(() => RemoveClient(rt));
Logger.Trace("Client {0} connected", rt.EndPoint);
disposer.Clear();
}
});
}
}
public ClientRt(TcpClient client, X509Certificate2 certificate, ShellFactory factory)
{
//client disposed in caller on throw
this.client = client;
this.certificate = certificate;
using (var disposer = new Disposer())
{
start = DateTime.Now;
last = DateTime.Now;
shell = factory.Create();
endpoint = client.Client.RemoteEndPoint as IPEndPoint;
reader = new Runner(new Runner.Args {
ThreadName = string.Format("Client_{0}", endpoint)
});
disposer.Push(reader);
disposer.Push(Dispose); //ensure cleanup order
reader.Run(ReadLoop);
disposer.Clear();
}
}
