protected virtual void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
socket.Dispose();
}
disposed = true;
}
public void RunPipeline(PairSocket shim)
{
publisherSocket = context.CreatePublisherSocket();
publisherSocket.Bind("tcp://*:" + StreamingProtocol.Port);
snapshotSocket = context.CreateResponseSocket();
snapshotSocket.Bind("tcp://*:" + SnapshotProtocol.Port);
snapshotSocket.ReceiveReady += OnSnapshotReady;
shim.ReceiveReady += OnShimReady;
heartbeatTimer = new NetMQTimer(StreamingProtocol.HeartbeatInterval);
heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
shim.SignalOK();
poller = new Poller();
poller.AddSocket(shim);
poller.AddSocket(snapshotSocket);
poller.AddTimer(heartbeatTimer);
poller.Start();
publisherSocket.Dispose();
snapshotSocket.Dispose();
}
private void Serve()
{
log.Info("Session server is starting.");
responseSocket = new ResponseSocket();
switch (sessionType)
{
case eSessionType.Local:
responseSocket.Bind("inproc://opendiablo2-session");
break;
case eSessionType.Server:
case eSessionType.Remote:
default:
throw new OpenDiablo2Exception("This session type is currently unsupported.");
}
OnJoinGame += OnJoinGameHandler;
OnMoveRequest += OnMovementRequestHandler;
OnUpdateEquipment += OnUpdateEquipmentHandler;
var proactor = new NetMQProactor(responseSocket, (socket, message) =>
{
foreach (var msg in message)
{
using (var ms = new MemoryStream(msg.ToByteArray()))
using (var br = new BinaryReader(ms))
{
var messageFrame = getMessageFrame((eMessageFrameType)br.ReadByte());
messageFrame.LoadFrom(br);
messageFrame.Process(socket.GetHashCode(), this);
}
}
});
running = true;
WaitServerStartEvent.Set();
Task.Run(() =>
{
var lastRun = DateTime.Now;
while (running)
{
var newTime = DateTime.Now;
var timeDiff = (newTime - lastRun).TotalMilliseconds;
lastRun = newTime;
gameServer.Update((int)timeDiff);
if (timeDiff < serverUpdateRate)
{
Thread.Sleep((int)Math.Min(serverUpdateRate, Math.Max(0, serverUpdateRate - timeDiff)));
}
}
});
resetEvent.WaitOne();
proactor.Dispose();
running = false;
responseSocket.Dispose();
log.Info("Session server has stopped.");
}
public void Dispose()
{
_cancellationTokenSource?.Cancel();
_task?.Wait();
_task?.Dispose();
_responseSocket?.Dispose();
_cancellationTokenSource?.Dispose();
}
public override void WillTerminate(NSNotification notification)
{
_socketServer?.Disconnect(Ipc.RepoZIpcEndpoint.Address);
_socketServer?.Dispose();
// Insert code here to tear down your application
NSEvent.RemoveMonitor(_eventMonitor);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_socketServer?.Disconnect(EndpointProvider.Address);
_socketServer?.Dispose();
_socketServer = null;
}
}
public void Stop()
{
running = false;
try {
server.Dispose();
t.Abort();
} catch (Exception ex) {
;
}
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
socket?.Dispose();
}
disposedValue = true;
}
}
private void Serve()
{
log.Info("Session server is starting.");
responseSocket = new ResponseSocket();
switch (sessionType)
{
case eSessionType.Local:
responseSocket.Bind("inproc://opendiablo2-session");
break;
case eSessionType.Server:
case eSessionType.Remote:
default:
throw new OpenDiablo2Exception("This session type is currently unsupported.");
}
OnJoinGame += OnJoinGameHandler;
OnMoveRequest += OnMovementRequestHandler;
var proactor = new NetMQProactor(responseSocket, (socket, message) =>
{
var bytes = message.First().ToByteArray();
var frameType = (eMessageFrameType)bytes[0];
var frameData = bytes.Skip(1).ToArray(); // TODO: Can we maybe use pointers? This seems wasteful
var messageFrame = getMessageFrame(frameType);
messageFrame.Data = frameData;
messageFrame.Process(socket.GetHashCode(), this);
});
running = true;
WaitServerStartEvent.Set();
Task.Run(() =>
{
var lastRun = DateTime.Now;
while (running)
{
var newTime = DateTime.Now;
var timeDiff = (newTime - lastRun).TotalMilliseconds;
lastRun = newTime;
gameServer.Update((int)timeDiff);
if (timeDiff < serverUpdateRate)
{
Thread.Sleep((int)Math.Min(serverUpdateRate, Math.Max(0, serverUpdateRate - timeDiff)));
}
}
});
resetEvent.WaitOne();
proactor.Dispose();
running = false;
responseSocket.Dispose();
log.Info("Session server has stopped.");
}
protected override Task DestroyInternal()
{
_cancel.Cancel();
_poller.Stop();
_heartbeatSocket.Close();
_heartbeatSocket.Dispose();
_stateRequestSocket.Close();
_stateRequestSocket.Dispose();
return(Task.CompletedTask);
}
protected override void Run()
{
ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use, not sure why yet
using (server = new ResponseSocket()) // check if its response or request ?
{
server.Bind("tcp://*:1234"); //SEND
using (client = new RequestSocket())
{
client.Connect("tcp://localhost:2222"); // RECIEVE
// for (int i = 0; i < 2 && Running; i++)
while (Running)
{
// TO BE ABLE TO SEND USING SERVER SOCKET:
string DummyServerReceive = server.ReceiveFrameString();
//Debug.Log("MY DUMMY SERVER REC: " + DummyServerReceive);
//SENDING TO SERVER : //SEND A VARIABLE BOOLEAN HERE
server.SendFrame(Mode + "," + Yindex + "," + Xindex + "," + Resign + "," + Pass + "," + HumanColor);
//Pass = "******";
//Resign = "-1";
//Debug.Log("SERVER IS DONE ");
// DUMMY SEND OF CLIENT TO RECEIVE
client.SendFrame("HELLOOOOOOO");
while (Running)
{
message = client.ReceiveFrameString(); // this returns true if it's successful
//Debug.Log("MESSAGE IS :" + this.message);
break;
}
}
client.Disconnect("tcp://localhost:2222");
client.Close();
client.Dispose();
}
server.Disconnect("tcp://*:1234");
server.Close();
server.Dispose();
}
NetMQConfig.Cleanup();
}
protected void Dispose(bool dispose)
{
if (!_disposed)
{
if (dispose)
{
if (_socket != null)
{
_socket.Dispose();
}
_disposed = true;
}
}
}
public void Kill()
{
_poller.Stop();
_heartbeat.Close();
_heartbeat.Dispose();
_frontend.Close();
_frontend.Dispose();
_backend.Close();
_backend.Dispose();
_workerQueue.Dispose();
_workQueue.Dispose();
}
/// <summary>
/// Dispose
/// </summary>
/// <returns>Returns void.</returns>
public void Dispose()
{
m_PublisherThread.Abort();
m_SubscriberThread.Abort();
m_ResponseThread.Abort();
m_PublisherSocket.Dispose();
m_SubscriberSocket.Dispose();
m_ResponseSocket.Dispose();
m_PublisherSignal.Dispose();
m_SubAPIResponse.Clear();
m_SubAPITypeResponse.Clear();
m_RepAPIResponse.Clear();
m_RepAPITypeResponse.Clear();
}
protected override void OnExit(ExitEventArgs e)
{
_socketServer?.Disconnect(Ipc.RepoZIpcEndpoint.Address);
_socketServer?.Dispose();
_hotkey.Unregister();
_explorerUpdateTimer.Change(Timeout.Infinite, Timeout.Infinite);
var explorerHandler = TinyIoCContainer.Current.Resolve <WindowsExplorerHandler>();
explorerHandler.CleanTitles();
_notifyIcon.Dispose();
base.OnExit(e);
}
public void Stop()
{
_cancel.Cancel();
_poller.Stop();
_heartbeat.Close();
_heartbeat.Dispose();
_publishStateUpdate.Close();
_publishStateUpdate.Dispose();
_subscribeToUpdates.Close();
_subscribeToUpdates.Dispose();
_stateRequest.Close();
_stateRequest.Dispose();
}
public override Task Stop()
{
_cancel.Cancel();
_poller.Stop();
_heartbeat.Close();
_heartbeat.Dispose();
_frontend.Close();
_frontend.Dispose();
_backend.Close();
_backend.Dispose();
return(Task.CompletedTask);
}
private void StopQueryMQ()
{
try
{
if (null != _resPoller)
{
_resPoller.Stop();
_resPoller.Remove(_resSocket);
_resSocket.ReceiveReady -= _resSocket_ReceiveReady;
_resSocket.Dispose();
_resPoller.Dispose();
_resSocket = null;
_resPoller = null;
}
}
catch (Exception ex)
{
}
}
private void BackgroundTask(object state)
{
var cancellationToken = (CancellationToken)state;
ResponseSocket socket = _ctx.CreateResponseSocket();
try
{
switch (_cxMode)
{
case ConnectionMode.Connect:
socket.Connect(_address);
break;
case ConnectionMode.Bind:
socket.Bind(_address);
break;
}
byte[] receiveBuffer;
while (!cancellationToken.IsCancellationRequested)
{
try
{
receiveBuffer = socket.Receive();
if (receiveBuffer == null)
{
continue; // NetMQ > 3.3.0.11
}
}
catch (AgainException)
{
continue; // NetMQ = 3.3.0.11
}
#region Always send a reply...
try
{
Thread.Sleep(500); // simulates processing...
socket.Send(string.Format("Reply ({0})", Encoding.UTF8.GetString(receiveBuffer)));
}
catch (TerminatingException)
{
try
{
socket.Send("Exit...");
}
catch
{
}
throw;
}
#endregion
}
}
catch (TerminatingException)
{
}
finally
{
try
{
socket.Dispose();
}
catch (NetMQException)
{
}
}
}
public void Dispose() => _socket?.Dispose();
private void dataServer()
{
AsyncIO.ForceDotNet.Force();
using (var dataSender = new ResponseSocket()) {
dataSender.Bind("tcp://*:5565");
Debug.Log("Enter while.. ");
while (isRunning)
{
string message = dataSender.ReceiveFrameString();
print("Got request message: " + message);
// re-run scene iteration if true
if (doGatherOnRequest)
{
gatherSceneData();
}
switch (message)
{
case "header":
print("Send Header.. ");
dataSender.SendFrame(headerByteData);
print(string.Format(".. Nodes ({0} bytes) sent ", headerByteData.Length));
break;
case "nodes":
print("Send Nodes.. ");
dataSender.SendFrame(nodesByteData);
print(string.Format(".. Nodes ({0} bytes) sent ", nodesByteData.Length));
break;
case "objects":
print("Send Objects.. ");
dataSender.SendFrame(objectsByteData);
print(string.Format(".. Objects ({0} bytes) sent ", objectsByteData.Length));
break;
case "textures":
print("Send Textures.. ");
dataSender.SendFrame(texturesByteData);
print(string.Format(".. Textures ({0} bytes) sent ", texturesByteData.Length));
break;
#if TRUNK
case "materials":
print("Send Materials.. ");
dataSender.SendFrame(materialsByteData);
print(string.Format(".. Materials ({0} bytes) sent ", materialsByteData.Length));
break;
#endif
default:
break;
}
}
dataSender.Unbind("tcp://127.0.0.1:5565");
dataSender.Close();
dataSender.Dispose();
}
//NetMQConfig.Cleanup();
}
public void Kill()
{
_heartbeat.Close();
_heartbeat.Dispose();
}
private void dataServer()
{
AsyncIO.ForceDotNet.Force();
using (var dataSender = new ResponseSocket())
{
dataSender.Bind("tcp://" + VPETSettings.Instance.serverIP + ":5565");
Debug.Log("Enter while.. ");
while (isRunning)
{
string message = "";
dataSender.TryReceiveFrameString(out message);
//print ("Got request message: " + message);
// re-run scene iteration if true
if (doGatherOnRequest)
{
gatherSceneData();
}
switch (message)
{
case "header":
print("Send Header.. ");
dataSender.SendFrame(headerByteData);
print(string.Format(".. Nodes ({0} bytes) sent ", headerByteData.Length));
break;
case "nodes":
print("Send Nodes.. ");
dataSender.SendFrame(nodesByteData);
print(string.Format(".. Nodes ({0} bytes) sent ", nodesByteData.Length));
break;
case "objects":
print("Send Objects.. ");
dataSender.SendFrame(objectsByteData);
print(string.Format(".. Objects ({0} bytes) sent ", objectsByteData.Length));
break;
case "characters":
print("Send Characters.. ");
dataSender.SendFrame(charactersByteData);
print(string.Format(".. Characters ({0} bytes) sent ", charactersByteData.Length));
break;
case "textures":
print("Send Textures.. ");
dataSender.SendFrame(texturesByteData);
print(string.Format(".. Textures ({0} bytes) sent ", texturesByteData.Length));
break;
#if TRUNK
case "materials":
print("Send Materials.. ");
dataSender.SendFrame(materialsByteData);
print(string.Format(".. Materials ({0} bytes) sent ", materialsByteData.Length));
break;
#endif
default:
break;
}
}
// TODO: check first if closed
try
{
dataSender.Disconnect("tcp://" + VPETSettings.Instance.serverIP + ":5565");
dataSender.Dispose();
dataSender.Close();
}
finally
{
NetMQConfig.Cleanup(false);
}
}
}
public void Dispose()
{
_poller.Dispose();
_server.Dispose();
}
public void Close()
{
poller.StopAsync();
socket.Dispose();
}
public Task StopAsync(CancellationToken cancellationToken)
{
_server.Dispose();
return(Task.CompletedTask);
}
void OnDisable()
{
_server?.Dispose();
NetMQConfig.Cleanup(false);
}
