public void StopServer()
{
if (!ServerRunning)
{
return;
}
poller?.Stop();
poller?.Dispose();
lock (responseSocketLock)
{
if (responseSocket != null)
{
try
{
responseSocket.Disconnect(responseSocketConnectionString);
}
finally
{
responseSocket.Close();
responseSocket = null;
}
}
}
}
public void Dispose()
{
_cancellationSource.Dispose();
_poller.Stop();
_poller.Dispose();
_socket.Dispose();
}
/// <summary>
/// Release any contained resources.
/// </summary>
/// <param name="disposing">true if managed resources are to be released</param>
protected virtual void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
if (_isRunning)
{
Stop();
}
if (_poller.IsRunning)
{
_poller?.Stop();
}
_poller?.Dispose();
_beacon?.Dispose();
_inbox?.Dispose();
_outbox?.Dispose();
foreach (var peer in _peers.Values)
{
peer.Destroy();
}
foreach (var group in _peerGroups.Values)
{
group.Dispose();
}
foreach (var group in _ownGroups.Values)
{
group.Dispose();
}
}
private void StopQueryMQ()
{
try
{
if (null != _queryPoller)
{
if (null != _querySocket)
{
_queryPoller.Remove(_querySocket);
}
if (_queryPoller.IsRunning)
{
_queryPoller.Stop();
}
_queryPoller.Dispose();
_queryPoller = null;
}
if (null != _querySocket)
{
_querySocket.ReceiveReady -= _querySocket_ReceiveReady;
_querySocket.SendReady -= _querySocket_SendReady;
//_querySocket.Disconnect(_querySocket.Options.LastEndpoint);
_querySocket.Dispose();
_querySocket = null;
}
_queryMsgList.Clear();
}
catch (Exception ex)
{
}
}
/// <summary>
/// Stop the server.
/// </summary>
public void StopServer()
{
if (!ServerRunning)
{
return;
}
_poller?.Stop();
_poller?.Dispose();
lock (_socketLock)
{
if (_socket != null)
{
try
{
_socket.Disconnect(_connectionString);
}
finally
{
_socket.ReceiveReady -= SocketReceiveReady;
_socket.Close();
_socket = null;
}
}
}
_poller = null;
}
public void Disconnect()
{
pushSocket?.Disconnect(pushConnectionString);
poller?.Stop();
poller?.Dispose();
pushSocket?.Dispose();
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
_disposed = true; //prevent second call to Dispose
if (disposing)
{
if (null != _heartBeatTimer)
{
_heartBeatTimer.Enable = false;
}
if (null != _socketPoller)
{
_socketPoller.Dispose();
}
if (null != _sendQueue)
{
_sendQueue.Dispose();
}
if (null != _dealerSocket)
{
_dealerSocket.Dispose();
}
if (null != _clientPoller)
{
_clientPoller.Dispose();
}
if (null != _receiveQueue)
{
_receiveQueue.Dispose();
}
}
}
}
public virtual void Stop()
{
GlobalServerProxy?.Stop();
Poller?.Stop();
Poller?.Dispose();
Poller = null;
}
/// <summary>
///
/// </summary>
public void Stop()
{
if (m_started)
{
m_poller.Dispose();
m_server.Dispose();
m_started = false;
}
}
public void Dispose()
{
_actor?.Dispose();
_publisher?.Dispose();
_subscriber?.Dispose();
_beacon?.Dispose();
_poll?.Dispose();
_shim?.Dispose();
}
public void Cleanup()
{
if (isIgniteBotEmbedded && !hasCleanedUp)
{
poller.StopAsync();
Thread.Sleep(10);
subSocket.Dispose();
poller.Dispose();
NetMQConfig.Cleanup(false);
hasCleanedUp = true;
}
}
protected virtual void Dispose(bool disposing)
{
if (!_IsDisposed)
{
if (disposing)
{
Poller?.Dispose();
Socket?.Dispose();
}
_IsDisposed = true;
}
}
public void Stop()
{
if (!IsRunning)
{
return;
}
this._nodes.Clear();
_poller.Stop();
_beacon.Unsubscribe();
_poller.Remove(_beacon);
_poller.Remove(timer);
_poller.Dispose();
_poller = null;
_beacon.Dispose();
_beacon = null;
timer = null;
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_poller?.Dispose();
_subscriberSocket?.Dispose();
}
disposedValue = true;
}
}
public void Run(PairSocket shim)
{
_poller = new NetMQPoller();
_ = Observable.FromEventPattern <NetMQSocketEventArgs>(e => shim.ReceiveReady += e, e => shim.ReceiveReady -= e)
.Select(e => e.EventArgs)
.Subscribe(OnShimReady);
_poller.Add(shim);
// Timer
var timeoutTimer = new NetMQTimer(TimeSpan.FromSeconds(5));
_ = Observable.FromEventPattern <NetMQTimerEventArgs>(e => timeoutTimer.Elapsed += e, e => timeoutTimer.Elapsed -= e)
.Select(e => e.EventArgs)
.ObserveOn(ThreadPoolScheduler.Instance)
.Subscribe(OnTimeoutElapsed);
_poller.Add(timeoutTimer);
_subscriberSocket = new SubscriberSocket();
_subscriberSocket.Options.Linger = TimeSpan.Zero;
_subscriberSocket.Subscribe(CoreHearbeatTopic);
_subscriberSocket.Connect($"tcp://{_address}:{_port + 1}");
_subject.OnNext(ConnectionStatus.Connecting);
_ = Observable.FromEventPattern <NetMQSocketEventArgs>(e => _subscriberSocket.ReceiveReady += e, e => _subscriberSocket.ReceiveReady -= e)
.Select(e => e.EventArgs)
.Where(e => e.Socket.ReceiveFrameString() == CoreHearbeatTopic)
.ObserveOn(ThreadPoolScheduler.Instance)
.Subscribe(e =>
{
timeoutTimer.Reset();
Thread.MemoryBarrier();
var status = _borgConnected
? (ConnectionStatus.Online | ConnectionStatus.Connected)
: (ConnectionStatus.Online | ConnectionStatus.Disconnected);
_subject.OnNext(status);
});
_poller.Add(_subscriberSocket);
timeoutTimer.Reset();
shim.SignalOK();
_poller.Run();
// Cleanup stuff after stopping
_poller.Remove(_subscriberSocket);
_poller.Remove(timeoutTimer);
_poller.Remove(shim);
_poller.Dispose();
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_poller?.Dispose();
_responseSocket?.Dispose();
_publisherSocket?.Dispose();
}
disposedValue = true;
}
}
private void StopStationNetMQ()
{
// HockSocketEvents(false);
try
{
if (null != _poller)
{
if (null != _subscriber)
{
_poller.Remove(_subscriber);
}
if (null != _requester)
{
_poller.Remove(_requester);
}
//_poller.Remove(_fileSubscriber);
if (_poller.IsRunning)
{
_poller.Stop();
}
_poller.Dispose();
_poller = null;
}
if (null != _subscriber)
{
_subscriber.Dispose();
_subscriber = null;
}
if (null != _requester)
{
_requester.Dispose();
_requester = null;
}
//_fileSubscriber.Dispose();
//_fileSubscriber = null;
}
catch (Exception err)
{
logger.ErrorFormat("Disconnect pub-sub error:{0}", err);
}
// this.OnDisconnected();
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
_readyGraphUpdates = null;
_updateThread.Abort();
_poller.StopAsync();
_poller.Dispose();
}
base.Dispose(disposing);
_zyre.Dispose();
NetMQConfig.Cleanup(true);
}
void OnApplicationQuit()//cleanup
{
SceneClient.Close();
SceneClient.Dispose();
try
{
ScenePoller.StopAsync();
}
catch (System.Exception e)
{
UnityEngine.Debug.Log("Tried to stopasync while the poller wasn't running! Oops.");
}
ScenePoller.Dispose();
NetMQConfig.Cleanup();
}
public void TearDown()
{
_actorService?.Stop();
Poller?.Stop();
PushSocket?.Close();
PullSocket?.Close();
Poller?.Dispose();
PullSocket = null;
PushSocket = null;
Poller = null;
_actorService = null;
Thread.Sleep(1000);
}
/// <summary>
/// Cancels Subscription to the topic and closes connections.
/// </summary>
public void Stop()
{
if (Poller != null)
{
Poller.StopAsync();
Poller.Dispose();
Poller = null;
}
if (Subscriber != null)
{
Subscriber.ReceiveReady -= Subscriber_ReceiveReady;
Subscriber.Unsubscribe(Topic);
Subscriber.Disconnect("tcp://" + IP + ":" + Port.ToString());
Subscriber = null;
}
}
/// <summary>
/// Release any contained resources.
/// </summary>
/// <param name="disposing">true if managed resources are to be released</param>
protected virtual void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
Stop();
if (_useEvents)
{
_inboxPoller?.StopAsync();
_inboxPoller?.Dispose();
}
_actor?.Dispose();
_inbox?.Dispose();
}
public void Stop()
{
try
{
_poller.Stop();
_publisherSocket.Disconnect(_publisherAddress);
_dealerSocket.Disconnect(_dealerAddress);
_poller.Dispose();
_publisherSocket.Dispose();
_dealerSocket.Dispose();
}
finally
{
NetMQConfig.Cleanup();
}
}
/// <summary>
/// Stops the server.
/// </summary>
public void StopServer()
{
if (!ServerRunning)
{
return;
}
poller?.Stop();
poller?.Dispose();
lock (publisherSocketLock)
{
if (publisherSocket != null)
{
try
{
publisherSocket.Disconnect(publisherConnectionString);
}
finally
{
publisherSocket.Close();
publisherSocket = null;
}
}
}
lock (requestSocketLock)
{
if (requestSocket != null)
{
try
{
requestSocket.Disconnect(requestConnectionString);
}
finally
{
requestSocket.ReceiveReady -= RequestSocketReceiveReady;
requestSocket.Close();
requestSocket = null;
}
}
}
poller = null;
}
public void DisposeThrowsIfSocketAlreadyDisposed()
{
var socket = new RouterSocket();
var poller = new NetMQPoller {
socket
};
// Dispose the socket.
// It is incorrect to have a disposed socket in a poller.
// Disposed sockets can throw into the poller's thread.
socket.Dispose();
// Dispose throws if a polled socket is disposed
var ex = Assert.Throws <NetMQException>(() => poller.Dispose());
Assert.AreEqual("Invalid state detected: NetMQPoller contains a disposed NetMQSocket. Sockets must be either removed before being disposed, or disposed after the poller is disposed.", ex.Message);
}
protected virtual void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
// m_poller might not have been created yet!
if (!ReferenceEquals(m_poller, null))
{
m_poller.Dispose();
}
// m_client might not have been created yet!
if (!ReferenceEquals(m_client, null))
{
m_client.Dispose();
}
}
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)
{
}
}
public void Dispose()
{
if (_beacon != null)
{
_beacon.Dispose();
_beacon = null;
}
if (_poller != null)
{
_poller.Dispose();
_poller = null;
}
if (_subscriber != null)
{
_subscriber.Dispose();
_subscriber = null;
}
}
/// <summary>
/// Disconnects from the server.
/// </summary>
public void Disconnect()
{
if (!PollerRunning)
{
return;
}
while (RealTimeDataStreams.Count > 0)
{
CancelRealTimeData(RealTimeDataStreams.First().Instrument);
}
poller?.Stop();
poller?.Dispose();
StopSockets();
poller = null;
}
public void AddThrowsIfSocketAlreadyDisposed()
{
var poller = new NetMQPoller();
var socket = new RouterSocket();
// Dispose the socket.
// It is incorrect to have a disposed socket in a poller.
// Disposed sockets can throw into the poller's thread.
socket.Dispose();
// Adding a disposed socket throws
var ex = Assert.Throws <ArgumentException>(() => poller.Add(socket));
Assert.True(ex.Message.StartsWith("Must not be disposed."));
Assert.AreEqual("socket", ex.ParamName);
// Still dispose it. It throws after cleanup.
Assert.Throws <NetMQException>(() => poller.Dispose());
}
