public void ReceiveTimeout()
{
ConsoleEx.DebugLog("Subscribe is timeout.", ConsoleEx.RED);
if (poller != null)
{
if (poller.IsStarted)
{
poller.CancelAndJoin();
}
poller.Dispose();
}
if (subSocket != null)
{
if (warInfo.warMo == WarMode.InLanWar)
{
subSocket.Disconnect(ConnAddres);
}
subSocket.Close();
subSocket = null;
}
poller = new Poller();
establish();
}
public void Stop()
{
_subscribeThreadCancellation.Cancel();
_pingThreadCancellation.Cancel();
_subscribeThread.Join();
_pingThread.Join();
_subscribeThreadCancellation.Dispose();
_pingThreadCancellation.Dispose();
lock (_publishSocketLocker)
{
_publishSocket?.Disconnect(_publishAddress);
}
_subscribeSocket?.Disconnect(_subscribeAddress);
lock (_publishSocketLocker)
{
_publishSocket?.Dispose();
}
_subscribeSocket?.Dispose();
_messageHost?.Stop();
}
internal void GivenInstrument_WithSubscriber_PublishesMessage()
{
// Arrange
this.publisher.Start();
Task.Delay(100).Wait(); // Allow publisher to start
var instrument = StubInstrumentProvider.AUDUSD();
var subscriber = new SubscriberSocket(TestAddress);
subscriber.Connect(TestAddress);
subscriber.Subscribe(nameof(Instrument) + ":" + instrument.Symbol.Value);
Task.Delay(100).Wait();
// Act
this.publisher.Endpoint.SendAsync(instrument);
var topic = subscriber.ReceiveFrameBytes();
var message = subscriber.ReceiveFrameBytes();
// Assert
Assert.Equal("Instrument:AUD/USD.FXCM", Encoding.UTF8.GetString(topic));
Assert.Equal(instrument, this.instrumentSerializer.Deserialize(message));
// Tear Down
subscriber.Disconnect(TestAddress);
subscriber.Dispose();
this.publisher.Stop().Wait();
this.publisher.Dispose();
}
internal void GivenTickMessage_WithSubscriber_PublishesMessage()
{
// Arrange
var symbol = new Symbol("AUDUSD", new Venue("FXCM"));
var subscriber = new SubscriberSocket(TestAddress);
subscriber.Connect(TestAddress);
subscriber.Subscribe($"Quote:{symbol.Value}");
Task.Delay(100).Wait(); // Allow subscribers to connect
var tick = StubQuoteTickProvider.Create(symbol);
// Act
this.publisher.Endpoint.SendAsync(tick).Wait();
var topic = subscriber.ReceiveFrameBytes();
var message = subscriber.ReceiveFrameBytes();
// Assert
Assert.Equal(1, this.publisher.SentCount);
Assert.Equal("Quote:AUDUSD.FXCM", Encoding.UTF8.GetString(topic));
Assert.Equal(tick.ToSerializableString(), Encoding.UTF8.GetString(message));
// Tear Down
subscriber.Disconnect(TestAddress);
subscriber.Dispose();
this.publisher.Stop().Wait();
this.publisher.Dispose();
}
private void Subscriber(CancellationToken token, IObserver <TMessage> observer, ManualResetEventSlim subscribedEvent)
{
try
{
using (var socket = new SubscriberSocket())
{
socket.Connect(_address);
socket.Subscribe(_topic);
subscribedEvent.Set();
while (!token.IsCancellationRequested)
{
ReceiveMessage(observer, socket);
}
socket.Unsubscribe(_topic);
socket.Disconnect(_address);
socket.Close();
}
}
finally
{
if (!subscribedEvent.IsSet)
{
subscribedEvent.Set();
}
}
}
/// <summary>
/// Remote <see cref="IAddress"/> from the socket
/// </summary>
/// <param name="address"><see cref="IAddress"/> to be removed</param>
public override void SocketRemove(IAddress address)
{
if (disposedValue)
{
throw new InvalidOperationException("NetMQSubscriber has been disposed");
}
socket.Disconnect(address.ToString());
}
public void Dispose()
{
_cancellationSource.Dispose();
if (_poller.IsRunning)
{
_poller.Stop();
}
_responseSocket.Disconnect("tcp://127.0.0.1:3781");
_poller.RemoveAndDispose(_responseSocket);
}
private static Task StartProcessor(string nodeAddr, string[] subscriptions, CancellationTokenSource cancellationTokenSource)
{
telemetryClient.TrackTrace($"Starting processor for {nodeAddr}", SeverityLevel.Information, new Dictionary <string, string>
{
{ nameof(nodeAddr), nodeAddr },
});
return(Task.Factory.StartNew(async() =>
{
string index = "kv6";
using (var socket = new SubscriberSocket())
{
socket.Connect(nodeAddr);
try
{
subscriptions.All((s) =>
{
socket.Subscribe(s);
return true;
});
while (!cancellationTokenSource.IsCancellationRequested)
{
var messageList = socket.ReceiveMultipartBytes(2);
var subscription = Encoding.UTF8.GetString(messageList[0]);
string payload = null;
using (GZipStream stream = new GZipStream(new MemoryStream(messageList[1]), CompressionMode.Decompress))
using (var sr = new StreamReader(stream))
payload = await sr.ReadToEndAsync();
#if DEBUG
Console.Write($"{subscription} - {payload.Length} chars...");
#endif
var xml = DeserializeMessage(payload);
telemetryClient.TrackTrace($"Received payload for {subscription}, size: {payload.Length} characters", SeverityLevel.Verbose, new Dictionary <string, string>
{
{ nameof(subscription), subscription },
{ nameof(payload), payload },
});
var jsonObjects = GetJsonRepresentation(xml.Timestamp, xml.KV6posinfo);
await StoreJsonObjects(index, jsonObjects);
}
}
finally
{
socket.Disconnect(nodeAddr);
socket.Close();
telemetryClient.TrackTrace("Stopped processor", SeverityLevel.Information);
}
}
}, cancellationTokenSource.Token));
}
/// <summary>
/// This thread is needed to handle network disconnects.
/// </summary>
/// <remarks>
/// If the PC the message host is running on disconnects from the
/// network, the subscribe thread is never able to reconnect to it by
/// itself. Therefore we periodically network ping the subscriber
/// address to check if it responds. If it at one point does not
/// respond we will need to reconnect to it again when it starts
/// responding.
/// </remarks>
private void PingThread()
{
Uri uri = new Uri(_subscribeAddress);
bool needsReinitialization = false;
while (!_pingThreadCancellation.IsCancellationRequested)
{
bool pingable;
Ping pinger = new Ping();
try
{
PingReply reply = pinger.Send(uri.Host, 1000);
pingable = reply != null && (reply.Status == IPStatus.Success);
}
catch (PingException)
{
pingable = false;
}
if (!pingable)
{
needsReinitialization = true;
}
if (pingable && needsReinitialization)
{
_subscribeThreadCancellation.Cancel();
_subscribeSocket.Disconnect(_subscribeAddress);
_subscribeSocket.Dispose();
_subscribeThread.Join();
_subscribeThreadCancellation = new CancellationTokenSource();
_subscribeThread = new Thread(SubscribeThread)
{
IsBackground = true
};
_subscribeThread.Start();
while (!_subscribeThreadRunning)
{
Thread.Sleep(50);
}
needsReinitialization = false;
}
Thread.Sleep(5000);
}
}
public Task StopAsync(CancellationToken cancellationToken)
{
if (connected)
{
socket.Unsubscribe(_configuration["EventBus:Topic"]);
socket.Disconnect(_configuration["NetMq:SubscribeConnection"]);
poller.Stop();
connected = false;
}
return(Task.CompletedTask);
}
static int Main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Arguments: <nodeAddr> <subscr...>");
Console.WriteLine("Eg: tcp://node03.kv7.openov.nl:7817 /GOVI/KV8");
return(-1);
}
var nodeAddr = args[0];
var subscriptions = args.Skip(1).ToArray();
using (var socket = new SubscriberSocket())
{
int msgCount = 0;
socket.Connect(nodeAddr);
try
{
subscriptions.All((s) =>
{
socket.Subscribe(s);
return(true);
});
// Download just 20 messages, it's just a test tool...
while (msgCount < 20)
{
var messageList = socket.ReceiveMultipartBytes(2);
msgCount++;
var msg1 = Encoding.UTF8.GetString(messageList[0]);
using (GZipStream stream = new GZipStream(new MemoryStream(messageList[1]), CompressionMode.Decompress))
using (var sr = new StreamReader(stream))
{
var msg2 = sr.ReadToEnd();
Console.Write($"{msg1} - {msg2.Length} chars...");
var filename = msg1.Substring(1).Replace('/', '-') + $"{msgCount}.xml";
File.WriteAllText(filename, msg2, Encoding.UTF8);
Console.WriteLine();
}
}
}
finally
{
socket.Disconnect(nodeAddr);
socket.Close();
}
}
return(0);
}
/// <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;
}
}
internal void Test_can_publish_events()
{
// Arrange
const string testAddress = "tcp://127.0.0.1:56601";
var publisher = new EventPublisher(
this.container,
new MsgPackEventSerializer(),
new BypassCompressor(),
EncryptionSettings.None(),
new Label("test-publisher"),
new Port(56601));
publisher.Start().Wait();
var subscriber = new SubscriberSocket(testAddress);
subscriber.Connect(testAddress);
subscriber.Subscribe("Event:Trade:TESTER-001");
Task.Delay(100).Wait(); // Allow socket to subscribe
var serializer = new MsgPackEventSerializer();
var order = new StubOrderBuilder().BuildMarketOrder();
var rejected = StubEventMessageProvider.OrderRejectedEvent(order);
var tradeEvent = new TradeEvent(TraderId.FromString("TESTER-001"), rejected);
// Act
publisher.Endpoint.Send(tradeEvent);
this.Output.WriteLine("Waiting for published events...");
var topic = subscriber.ReceiveFrameBytes();
var message = subscriber.ReceiveFrameBytes();
var @event = serializer.Deserialize(message);
// Assert
Assert.Equal("Event:Trade:TESTER-001", Encoding.UTF8.GetString(topic));
Assert.Equal(typeof(OrderRejected), @event.GetType());
// Tear Down
subscriber.Disconnect(testAddress);
subscriber.Dispose();
publisher.Stop().Wait();
publisher.Dispose();
}
//!
//! client function, listening for messages in receiveMessageQueue from server (executed in separate thread)
//!
public void listener()
{
AsyncIO.ForceDotNet.Force();
using (var receiver = new SubscriberSocket())
{
receiver.SubscribeToAnyTopic();
//receiver.Subscribe("client");
//receiver.Subscribe("ncam");
//receiver.Subscribe("record");
receiver.Connect("tcp://" + VPETSettings.Instance.serverIP + ":5556");
lastReceiveTime = currentTimeTime;
Debug.Log("Listener connected: " + "tcp://" + VPETSettings.Instance.serverIP + ":5556");
byte[] input;
while (isRunning)
{
if (receiver.TryReceiveFrameBytes(out input))
{
//Thread.Sleep(100);
//this.receiveMessageQueue.Clear();
this.receiveMessageQueue.Add(input);
lastReceiveTime = currentTimeTime;
}
else
{
listenerRestartCount = Mathf.Min(int.MaxValue, listenerRestartCount + 1);
// VPETSettings.Instance.msg = string.Format("Exception in Listener: {0}", listenerRestartCount);
if (currentTimeTime - lastReceiveTime > receiveTimeout)
{
// break;
}
}
}
receiver.Disconnect("tcp://" + VPETSettings.Instance.serverIP + ":5556");
receiver.Close();
receiver.Dispose();
}
//NetMQConfig.Cleanup();
}
private void StopRealTimeDataSocket()
{
lock (realTimeDataSocketLock)
{
if (realTimeDataSocket != null)
{
try
{
realTimeDataSocket.Disconnect(realTimeDataConnectionString);
}
finally
{
realTimeDataSocket.ReceiveReady -= RealTimeDataSocketReceiveReady;
realTimeDataSocket.Close();
realTimeDataSocket = null;
}
}
}
}
/// <summary>
/// 关闭套接字
/// </summary>
private void CloseSocket()
{
lock (this)
{
if (_socket == null)
{
return;
}
try
{
_socket.Disconnect(Config.InnerAddress);
}
catch (Exception)
{
//LogRecorder.Exception(e);//一般是无法连接服务器而出错
}
_socket.Close();
_socket = null;
}
}
/// <summary>
/// Shut down the service and clean up resources.
/// </summary>
public void Stop()
{
if (IsRunning)
{
try
{
_poller.Stop();
_subscriberSocket.Disconnect(_publisherAddress);
_dealerSocket.Disconnect(_dealerAddress);
_poller.Dispose();
_subscriberSocket.Dispose();
_dealerSocket.Dispose();
}
finally
{
IsRunning = false;
NetMQConfig.Cleanup();
}
}
}
private void reconnect()
{
DCLogger.LogError("Connection broked.");
try
{
//if (clientR != null)
// clientR.Dispose();
//createRSocket();
string[] addrs = cfg.ServerS.Split(',');
foreach (string addr in addrs)
{
clientR.Disconnect(addr);
clientR.Connect(addr);
}
DCLogger.LogInfo("Connection reonlined.");
}
catch (Exception ex)
{
DCLogger.LogError("Exception when establish reconnect:{0}", ex.Message);
}
}
internal void GivenMessageToPublish_WhenMessageValid_PublishesToSubscriber()
{
// Arrange
var publisher = new MockDataPublisher(
this.container,
DataBusFactory.Create(this.container),
EncryptionSettings.None(),
ZmqNetworkAddress.LocalHost(new Port(55555)));
publisher.Start().Wait();
const string testAddress = "tcp://localhost:55555";
var subscriber = new SubscriberSocket(testAddress);
subscriber.Connect(testAddress);
subscriber.Subscribe(TestTopic);
Task.Delay(100).Wait(); // Allow sockets to subscribe
// Act
const string toSend = "1234,1234";
publisher.Endpoint.SendAsync((TestTopic, toSend));
var topic = subscriber.ReceiveFrameBytes();
var message = subscriber.ReceiveFrameBytes();
// Assert
Assert.Equal(TestTopic, Encoding.UTF8.GetString(topic));
Assert.Equal(toSend, Encoding.UTF8.GetString(message));
Assert.Equal(ComponentState.Running, publisher.ComponentState);
Assert.Equal(1, publisher.SentCount);
// Tear Down
subscriber.Disconnect(testAddress);
subscriber.Dispose();
publisher.Stop().Wait();
publisher.Dispose();
}
static void Main(string[] args)
{
var addr = "tcp://127.0.0.1:3004";
NetMQPoller poller = new NetMQPoller();
using (var subSocket = new SubscriberSocket())
{
subSocket.ReceiveReady += OnReceiveReady;
subSocket.Options.ReceiveHighWatermark = 10;
subSocket.Connect(addr);
subSocket.Subscribe("NQ");
poller.Add(subSocket);
Task.Factory.StartNew(() => { poller.Run(); });
for (int i = 0; i < 20; i++)
{
Thread.Sleep(1000);
}
subSocket.Disconnect(addr);
}
}
private void receiveMessagesAsync(object sender, DoWorkEventArgs e)
{
Debug.Log("ZMQReceiver starting async worker");
// need to create ZMQ socket in thread that is going to use it
if (m_socket == null)
{
AsyncIO.ForceDotNet.Force();
m_socket = new SubscriberSocket();
m_socket.Connect(m_address);
Debug.Log("ZMQReceiver socket init ok");
}
const int messagePartsCount = 2;
while (!m_workerThread.CancellationPending)
{
while (m_pendingReceivePackets.Count > 0)
{
ReceivePacket recv = null;
if (m_pendingReceivePackets.TryDequeue(out recv))
{
if (recv == null)
{
continue;
}
if (recv.messageCallback == null)
{
Debug.LogError("ZMQReceiver: Object '" + recv.objectName + "' registered null Action<> callback. Ignoring this subscription.");
continue;
}
//recv.objectName;
m_socket.Subscribe(recv.subscriptionName);
m_receivePackets.Add(recv);
}
}
NetMQMessage multipartMessage = new NetMQMessage(messagePartsCount);
var hasMessage = m_socket.TryReceiveMultipartMessage(TimeSpan.FromMilliseconds(100), ref multipartMessage, messagePartsCount);
if (multipartMessage.IsEmpty)
{
log("ZMQReceiver: failed to receive message");
continue;
}
string address = multipartMessage[0].ConvertToString();
string message = multipartMessage[1].ConvertToString();
m_receivedValues.AddOrUpdate(address, message, (key, oldValue) => message);
log("ZMQReceiver: " + address + " / " + message);
}
m_socket.Disconnect(m_address);
m_socket.Dispose();
m_socket = null;
e.Cancel = true;
Debug.Log("ZMQReceiver: async thread finished");
}
/// <summary>
/// Disconnects from the server.
/// </summary>
public void Disconnect(bool cancelStreams = true)
{
//start by canceling all active real time streams
if (cancelStreams)
{
while (RealTimeDataStreams.Count > 0)
{
CancelRealTimeData(RealTimeDataStreams.First().Instrument);
}
}
_running = false;
if (_poller != null && _poller.IsStarted)
{
_poller.Stop(true);
}
if (_heartBeatTimer != null)
{
_heartBeatTimer.Stop();
}
if (_dealerLoopThread != null && _dealerLoopThread.ThreadState == ThreadState.Running)
{
_dealerLoopThread.Join(10);
}
if (_reqSocket != null)
{
try
{
_reqSocket.Disconnect(string.Format("tcp://{0}:{1}", _host, _realTimeRequestPort));
}
catch
{
_reqSocket.Dispose();
_reqSocket = null;
}
}
if (_subSocket != null)
{
try
{
_subSocket.Disconnect(string.Format("tcp://{0}:{1}", _host, _realTimePublishPort));
}
catch
{
_subSocket.Dispose();
_subSocket = null;
}
}
if (_dealerSocket != null)
{
try
{
_dealerSocket.Disconnect(string.Format("tcp://{0}:{1}", _host, _historicalDataPort));
}
catch
{
_dealerSocket.Dispose();
_dealerSocket = null;
}
}
}
protected override void OnStop(SubscriberSocket socket)
{
socket.Disconnect(_address);
}
/// <summary>
/// Disconnects from the server.
/// </summary>
public void Disconnect(bool cancelStreams = true)
{
if (!PollerRunning)
{
return;
}
// Start by canceling all active real time streams
if (cancelStreams)
{
while (RealTimeDataStreams.Count > 0)
{
CancelRealTimeData(RealTimeDataStreams.First().Instrument);
}
}
_poller?.Stop();
_poller?.Dispose();
lock (_realTimeRequestSocketLock)
{
if (_realTimeRequestSocket != null)
{
try
{
_realTimeRequestSocket.Disconnect(_realTimeRequestConnectionString);
}
finally
{
_realTimeRequestSocket.ReceiveReady -= RealTimeRequestSocketReceiveReady;
_realTimeRequestSocket.Close();
_realTimeRequestSocket = null;
}
}
}
lock (_realTimeDataSocketLock)
{
if (_realTimeDataSocket != null)
{
try
{
_realTimeDataSocket.Disconnect(_realTimeDataConnectionString);
}
finally
{
_realTimeDataSocket.ReceiveReady -= RealTimeDataSocketReceiveReady;
_realTimeDataSocket.Close();
_realTimeDataSocket = null;
}
}
}
lock (_historicalDataSocket)
{
if (_historicalDataSocket != null)
{
try
{
_historicalDataSocket.Disconnect(_historicalDataConnectionString);
}
finally
{
_historicalDataSocket.ReceiveReady -= HistoricalDataSocketReceiveReady;
_historicalDataSocket.Close();
_historicalDataSocket = null;
}
}
}
_poller = null;
}
