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(); }
private void RealTimeDataSocketReceiveReady(object sender, NetMQSocketEventArgs e) { lock (_realTimeDataSocketLock) { if (_realTimeDataSocket == null) { return; } bool hasMore; _realTimeDataSocket.ReceiveFrameBytes(out hasMore); if (hasMore) { var buffer = _realTimeDataSocket.ReceiveFrameBytes(); using (var ms = new MemoryStream()) { var bar = MyUtils.ProtoBufDeserialize <RealTimeDataEventArgs>(buffer, ms); RaiseEvent(RealTimeDataReceived, null, bar); } } } }
/// <summary> /// Subscription worker /// - Creates ZMQ subscriber socket and listens for specified frames /// </summary> private void SubscribeWorker() { using (var subscriber = new SubscriberSocket()) { subscriber.Connect(_zmqConnectTo); subscriber.Subscribe(_zmqSubscribeTopic); Console.WriteLine("Subscribed to ZeroMQ '" + _zmqConnectTo + "' publisher for '" + _zmqSubscribeTopic + "' frames."); while (true) { // we expect the publisher to sends 3 frames per data packet // first, the header frame var replyHeader = subscriber.ReceiveFrameString(); if (replyHeader != _zmqSubscribeTopic) { Console.WriteLine("Unexpected Frame Header! '" + _zmqSubscribeTopic + "' expected, but received " + replyHeader + ". Skipping and waiting for proper frame header."); continue; } // next, the data frame var replyFrame = subscriber.ReceiveFrameBytes(); // last, the reply counter frame var replyCounter = BitConverter.ToInt32(subscriber.ReceiveFrameBytes(), 0); // Console.WriteLine("counter: " + replyCounter); // pass the received data to our consumer thread _consumer.EnqueueTask(replyFrame, replyCounter); } } }
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(); }
/// <summary> /// Subscription worker /// - Creates ZMQ subscriber socket and listens for specified frames /// </summary> private void SubscribeWorker() { using (var subscriber = new SubscriberSocket()) { subscriber.Connect(_connectTo.AbsoluteUri.TrimEnd('/')); subscriber.Subscribe(_subscribeTopic); Console.WriteLine("Subscribed to ZeroMQ '" + _connectTo + "' publisher for '" + _subscribeTopic + "' frames."); while (true) { // the publisher sends 3 frames per data packet // first, the header frame var replyHeader = subscriber.ReceiveFrameString(); // if this is not a valid header frame, continue to next frame if (replyHeader != _subscribeTopic) { Console.WriteLine("Unexpected Frame Header! '" + _subscribeTopic + "' expected, but received " + replyHeader + ". Skipping and waiting for proper frame header."); continue; } // next, the data frame var replyFrame = subscriber.ReceiveFrameBytes(); // last, the reply counter frame var replyCounter = BitConverter.ToInt32(subscriber.ReceiveFrameBytes(), 0); // pass the received data to callback function _callback(replyHeader, replyFrame, replyCounter); } } }
private void HandleNextConsumer() { using (_consumerSocket = new SubscriberSocket()) { _consumerSocket.Options.ReceiveHighWatermark = 1000; _consumerSocket.Connect(_currentProducer.Endpoint); _consumerSocket.Subscribe(_consumerConfiguration.Topic); while (!_cancel.IsCancellationRequested && !_currentConsumerTaskCancellation.IsCancellationRequested) { var topic = _consumerSocket.ReceiveFrameString(); var messageBytes = _consumerSocket.ReceiveFrameBytes(); var transportMessage = JsonConvert.DeserializeObject <TransportMessage>(Encoding.UTF32.GetString(messageBytes)); if (transportMessage.MessageType != typeof(TEvent)) { throw new InvalidOperationException($"wrong event type {transportMessage.MessageType} vs expected {typeof(TEvent)}"); } var message = (TEvent)JsonConvert.DeserializeObject(Encoding.UTF32.GetString(transportMessage.Message), transportMessage.MessageType); _subject.OnNext(message); } } }
private void FilteredBackgroundWorker(object sender, DoWorkEventArgs e) { var filter = (string)e.Argument; using (var subscriberSocket = new SubscriberSocket()) { subscriberSocket.Options.ReceiveHighWatermark = 1000; subscriberSocket.Connect(transportMethod + "eventsystem"); subscriberSocket.Subscribe(filter); while (!e.Cancel) { string messageTopicReceived = subscriberSocket.ReceiveFrameString(); byte[] message = subscriberSocket.ReceiveFrameBytes(); var eventMessage = EventMessage.Create(message); Debug.Log("Event received for " + filter + "|" + messageTopicReceived); foreach (var actionDelegate in subscriberDelegates[filter]) { try { actionDelegate.Invoke(eventMessage.Sender, eventMessage.Parameter); } catch (Exception ex) { Console.WriteLine(ex.Message); } } } } }
private void Run() { while (isRunning) { try { bool hasMore; var clientIdString = subscribeSocket.ReceiveFrameString(out hasMore); if (hasMore) { var receiedBuffer = subscribeSocket.ReceiveFrameBytes(out hasMore); if (!hasMore && receiedBuffer != null && receiedBuffer.Length > 0) { var deserialized = serializer.Deserialize <ServerToClientMessage>(receiedBuffer); if (deserialized != null && messageHandler != null) { messageHandler(deserialized); } } } } catch (Exception ex) { } } }
private void ThreadSub() { List <SubscriberSocket> socklist = new List <SubscriberSocket>(); var sock = new SubscriberSocket(); sock.Options.IPv4Only = true; sock.SubscribeToAnyTopic(); foreach (var port in PortList) { string addr = $"tcp://{IPAddress.Loopback}:{port}"; sock.Connect(addr); } Thread.Sleep(2000); while (EventStop.Wait(WaitInterval) == false) { var buffer = sock.ReceiveFrameBytes(); string msg = Encoding.Unicode.GetString(buffer); textBox1.AppendLine(msg); } sock.Close(); }
public async Task ListenToEddn() { var utf8 = new UTF8Encoding(); using (var client = new SubscriberSocket()) { client.Options.ReceiveHighWatermark = 1000; client.Connect("tcp://eddn.edcd.io:9500"); client.SubscribeToAnyTopic(); while (true) { var bytes = client.ReceiveFrameBytes(); var uncompressed = ZlibStream.UncompressBuffer(bytes); var result = utf8.GetString(uncompressed); // ignore all outfitting and commodity responses if (!result.Contains(@"""Influence""")) { continue; } Submissions.Add(EddnRequest.FromJson(result)); } } }
public void SubscriberData(List <string> topics = null) { SubscriberSocket subscriber = Create(addrPoint); Register(subscriber, topics); Task.Factory.StartNew(() => { try { while (true) { string messageTopicReceived = subscriber.ReceiveFrameString(); byte[] dataReceived = subscriber.ReceiveFrameBytes(); if (MyFuncOfFlag.IsEndOfFlag(dataReceived)) { break; } Notify(messageTopicReceived, dataReceived); } } catch { } finally { Unregister(subscriber, topics); } }); }
public void MultipleLargeMessages() { var largeMessage = new byte[12000]; for (int i = 0; i < 12000; i++) { largeMessage[i] = (byte)(i % 256); } using (var pub = new PublisherSocket()) using (var sub = new SubscriberSocket()) { var port = pub.BindRandomPort("tcp://127.0.0.1"); sub.Connect("tcp://127.0.0.1:" + port); sub.Subscribe(""); Thread.Sleep(1000); pub.SendFrame(""); sub.SkipFrame(); for (int i = 0; i < 100; i++) { pub.SendFrame(largeMessage); byte[] recvMesage = sub.ReceiveFrameBytes(); for (int j = 0; j < 12000; j++) { Assert.AreEqual(largeMessage[j], recvMesage[j]); } } } }
public void LargerBufferLength() { var largerBuffer = new byte[256]; { largerBuffer[124] = 0xD; largerBuffer[125] = 0xE; largerBuffer[126] = 0xE; largerBuffer[127] = 0xD; } using (var pub = new PublisherSocket()) using (var sub = new SubscriberSocket()) { var port = pub.BindRandomPort("tcp://127.0.0.1"); sub.Connect("tcp://127.0.0.1:" + port); sub.Subscribe(""); Thread.Sleep(100); pub.SendFrame(largerBuffer, 128); byte[] recvMesage = sub.ReceiveFrameBytes(); Assert.AreEqual(128, recvMesage.Length); Assert.AreEqual(0xD, recvMesage[124]); Assert.AreEqual(0xE, recvMesage[125]); Assert.AreEqual(0xE, recvMesage[126]); Assert.AreEqual(0xD, recvMesage[127]); Assert.AreNotEqual(largerBuffer.Length, recvMesage.Length); } }
void Run() { while (_running) { try { string topic; if (_subSocket.TryReceiveFrameString(TimeSpan.FromMilliseconds(100), out topic)) { var eventName = _subSocket.ReceiveFrameString(); var messageReceived = _subSocket.ReceiveFrameBytes(); try { MessaggioRicevuto(eventName, messageReceived); } catch { } } } catch (Exception ex) { if (_running) { Console.WriteLine(this.GetType().Name + " : " + ex.Message); } } } }
static void Main(string[] args) { var utf8 = new UTF8Encoding(); try { using (var client = new SubscriberSocket()) { client.Options.ReceiveHighWatermark = 1000; client.Connect("tcp://eddn.edcd.io:9500"); client.SubscribeToAnyTopic(); while (true) { var bytes = client.ReceiveFrameBytes(); var uncompressed = ZlibStream.UncompressBuffer(bytes); var result = utf8.GetString(uncompressed); addmessage(result); } } } catch (Exception e) { Console.WriteLine(e.Message); Console.Read(); } }
public void LargeMessage() { using (var pub = new PublisherSocket()) using (var sub = new SubscriberSocket()) { pub.Connect("pgm://224.0.0.1:5555"); sub.Bind("pgm://224.0.0.1:5555"); sub.Subscribe(""); var data = new byte[3200]; // this should be at least 3 packets for (Int16 i = 0; i < 1600; i++) { Array.Copy(BitConverter.GetBytes(i), 0, data, i * 2, 2); } pub.SendFrame(data); byte[] message = sub.ReceiveFrameBytes(); Assert.AreEqual(3200, message.Length); for (Int16 i = 0; i < 1600; i++) { Assert.AreEqual(i, BitConverter.ToInt16(message, i * 2)); } } }
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(); }
public static T Deserialise <T>(this SubscriberSocket subscriberSocket) { var messageReceived = subscriberSocket.ReceiveFrameBytes(); using (BsonReader reader = new BsonReader(new MemoryStream(messageReceived))) { JsonSerializer serializer = new JsonSerializer(); return(serializer.Deserialize <T>(reader)); } }
public void Sending1000Messages() { // creating two different context and sending 1000 messages int count = 0; var subReady = new ManualResetEvent(false); Task subTask = Task.Factory.StartNew(() => { using (var sub = new SubscriberSocket()) { sub.Bind("pgm://224.0.0.1:5555"); sub.Subscribe(""); subReady.Set(); while (count < 1000) { bool more; Assert.AreEqual(count, BitConverter.ToInt32(sub.ReceiveFrameBytes(out more), 0)); Assert.IsFalse(more); count++; } } }); subReady.WaitOne(); Task pubTask = Task.Factory.StartNew(() => { using (var pub = new PublisherSocket()) { pub.Connect("pgm://224.0.0.1:5555"); for (int i = 0; i < 1000; i++) { pub.SendFrame(BitConverter.GetBytes(i)); } // if we close the socket before the subscriber receives all messages subscriber // might miss messages, lets wait another second Thread.Sleep(1000); } }); pubTask.Wait(); subTask.Wait(); Thread.MemoryBarrier(); Assert.AreEqual(1000, count); }
public byte[] NetMQReceiveBytes(string connectionString) { using (SubscriberSocket subSocket = new SubscriberSocket()) { subSocket.Connect(connectionString); subSocket.Subscribe(String.Empty); byte[] result = subSocket.ReceiveFrameBytes(); return(result); } }
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(); }
public async Task TestProducer() { var cancel = new CancellationTokenSource(); SubscriberSocket _subSocket = null; var serializer = new EventSerializer(); var messages = new List <AccidentEvent>(); var directory = new Directory(); var configuration = new ProducerConfiguration() { IsTest = true, Endpoint = "tcp://localhost:8080", Id = Guid.NewGuid() }; var producer = new AccidentProducer(configuration, directory, new JsonSerializerSettings()); producer.Start(); await Task.Delay(500); new Task(() => { using (_subSocket = new SubscriberSocket()) { _subSocket.Options.ReceiveHighWatermark = 1000; _subSocket.Connect("tcp://localhost:8080"); _subSocket.Subscribe("Paris"); while (!cancel.IsCancellationRequested) { var topic = _subSocket.ReceiveFrameString(); var messageBytes = _subSocket.ReceiveFrameBytes(); var transportMessage = JsonConvert.DeserializeObject <TransportMessage>(Encoding.UTF32.GetString(messageBytes)); var message = (AccidentEvent)JsonConvert.DeserializeObject(Encoding.UTF32.GetString(transportMessage.Message), transportMessage.MessageType); messages.Add(message); } } }, cancel.Token).Start(); await Task.Delay(1000); Assert.Greater(messages.Count, 0); Assert.IsTrue(messages.All(m => { return(serializer.Serialize(m).StartsWith("Paris.")); })); }
public async Task StartAsync(CancellationToken cancellationToken) { _subscriberSocket.Connect(_options.Address); _subscriberSocket.SubscribeToAnyTopic(); while (true) { var bytesReceived = _subscriberSocket.ReceiveFrameBytes(); var uncompressed = ZlibStream.UncompressBuffer(bytesReceived); var entity = _encoding.GetString(uncompressed); await _importTargetFactory.ImportAsync(entity); _logger.LogInformation(entity); } }
/// <summary> /// Function that is called by Poller Object when a data is received. /// Data Contains both topic and user data in the order . /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Subscriber_ReceiveReady(object sender, NetMQSocketEventArgs e) { var topic = Subscriber.ReceiveFrameString(); var msg = Subscriber.ReceiveFrameBytes(); if (msg == null) { System.Diagnostics.Debug.WriteLine("Subscriber : Received data is null! Topic:" + topic); return; } if (OnDataReceived != null) { OnDataReceived(msg); } }
public void PubSub() { ThreadPool.QueueUserWorkItem(state => { var client = new SubscriberSocket(); client.Connect("tcp://" + IP + ":5556"); while (!_stopLoops) { try { var receiveFrame = client.ReceiveFrameBytes(); var @event = Serializer.Deserialize <Event>(new MemoryStream(receiveFrame)); } catch (Exception e) { Console.WriteLine(e); } } }); }
private void EventTask(string channel) { Debug.Log("Start event thread on chanel " + channel); var address = string.Format(">tcp://{0}:{1}", serverIp, eventPort); using (var subscriber = new SubscriberSocket(address)) { // Listen to all topics subscriber.Subscribe(channel); while (true) { var eventPacket = subscriber.ReceiveFrameBytes(); EnqueueEvent(eventPacket); } } }
static void Main(string[] args) { string uuid = "A"; using (var subSocket = new SubscriberSocket()) { subSocket.Connect("tcp://192.168.1.106:5555"); // subSocket.Options.ReceiveHighWatermark = 0; subSocket.Subscribe(uuid); Console.WriteLine("Subscriber socket connecting..."); while (true) { string uuid_value = subSocket.ReceiveFrameString(); byte[] RMSValue = subSocket.ReceiveFrameBytes(); string result = string.Concat(Enumerable.Repeat("#", (int)(Math.Round((BitConverter.ToDouble(RMSValue, 0) * 200))))); Console.WriteLine(result); } } }
public void Subscriber <T>(List <string> topics = null) { if (typeof(T) == typeof(byte[])) { SubscriberData(topics); } else if (typeof(T) == typeof(string)) { SubscriberString(topics); } else { SubscriberSocket subscriber = Create(addrPoint); Register(subscriber, topics); Task.Factory.StartNew(() => { try { while (true) { string messageTopicReceived = subscriber.ReceiveFrameString(); byte[] dataReceived = subscriber.ReceiveFrameBytes(); if (MyFuncOfFlag.IsEndOfFlag(dataReceived)) { break; } using (MemoryStream stream = new MemoryStream()) { stream.Write(dataReceived, 0, dataReceived.Length); stream.Seek(0, SeekOrigin.Begin); Notify(messageTopicReceived, (T) new BinaryFormatter().Deserialize(stream)); } } } catch { } finally { Unregister(subscriber, topics); } }); } }
public void LargeMessage() { using (var pub = new PublisherSocket()) using (var sub = new SubscriberSocket()) { var port = pub.BindRandomPort("tcp://127.0.0.1"); sub.Connect("tcp://127.0.0.1:" + port); sub.Subscribe(""); Thread.Sleep(100); var msg = new byte[300]; pub.SendFrame(msg); byte[] msg2 = sub.ReceiveFrameBytes(); Assert.AreEqual(300, msg2.Length); } }
static void Main(string[] args) { var utf8 = new UTF8Encoding(); using (var client = new SubscriberSocket()) { client.Options.ReceiveHighWatermark = 1000; client.Connect("tcp://cedar.canonn.tech:9500"); client.SubscribeToAnyTopic(); while (true) { var bytes = client.ReceiveFrameBytes(); var uncompressed = ZlibStream.UncompressBuffer(bytes); var result = utf8.GetString(uncompressed); Console.WriteLine(result); } } }