public static void Main()
{
// using (var responder = new ResponseSocket())
// {
// responder.Bind("tcp://*:5555");
// while (true)
// {
// string str = responder.ReceiveFrameString();
// Console.WriteLine(str);
// Thread.Sleep(50); // Do some 'work'
// responder.SendFrame("World");
// }
// }
Console.WriteLine("Connecting to hello world server…");
using (var requester = new SubscriberSocket())
{
requester.Connect("tcp://localhost:5555");
requester.Subscribe("PUB");
int requestNumber = 0;
while (true)
{
NetMQMessage arr = requester.ReceiveMultipartMessage();
string str = arr[1].ConvertToString();
Console.WriteLine(str);
Console.WriteLine(requestNumber++);
}
}
}
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();
}
private static void XSubscriberSocket()
{
using var subSocket = new SubscriberSocket();
string loginMark = "";
string userName = "";
subSocket.Connect(_subscriberAddress);
subSocket.Subscribe($"{_topic}/{TopicType.EquipAddEvent}");
subSocket.Subscribe($"{_topic}/{TopicType.EquipChangeEvent}");
subSocket.Subscribe($"{_topic}/{TopicType.EquipDeleteEvent}");
subSocket.Subscribe($"{_topic}/{TopicType.YcChangeEvent}/{11151}");
subSocket.Subscribe($"{_topic}/{TopicType.YxChangeEvent}/{11151}");
subSocket.Subscribe($"{_topic}/{TopicType.SendControl}/{11151}");
subSocket.Subscribe($"{_topic}/{TopicType.AddRealTimeSnapshot}");
subSocket.Subscribe($"{_topic}/{TopicType.EquipStateEvent}");
subSocket.Subscribe($"{_topic}/{TopicType.DeleteRealTimeSnapshot}");
subSocket.Subscribe($"{_topic}/{TopicType.OpenPage4InterScreen}");
subSocket.Subscribe($"{_topic}/{TopicType.ShowOrClosePage}");
subSocket.Subscribe($"{_topic}/{TopicType.KickClient}/{loginMark}");
subSocket.Subscribe($"{_topic}/{TopicType.ShowMsg}");
subSocket.Subscribe($"{_topic}/{TopicType.NotifyOffLine}");
subSocket.Subscribe($"{_topic}/{TopicType.NotifyRoleOffLine}");
subSocket.Subscribe($"{_topic}/{TopicType.ShowLockSetParmMsg}");
subSocket.Subscribe($"{_topic}/{TopicType.VOpenPage}/{userName}");
subSocket.Subscribe($"{_topic}/{TopicType.ShowInfo}");
subSocket.SubscribeToAnyTopic();
Console.WriteLine("Subscriber socket connecting...\n");
ReceiveFrameString();
}
protected override void Run()
{
AsyncIO.ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use, not sure why yet
using (SUB = new SubscriberSocket())
using (PUB = new PublisherSocket())
using (REQ = new RequestSocket()) {
SUB.Connect("tcp://localhost:5555");
SUB.Subscribe("");
PUB.Connect("tcp://localhost:5556");
REQ.Connect("tcp://localhost:5557");
Debug.Log("Connected: Receiving Messages");
while (Running)
{
/*Receive continuos Slicer data*/
string msg = SUB.ReceiveFrameString();
/*Send continuos Unity data*/
var bytes = new byte[dataPackage.t.Length * 4];
System.Buffer.BlockCopy(dataPackage.t, 0, bytes, 0, bytes.Length);
PUB.SendFrame(bytes);
/*Request volume data once*/
if (reqestData)
{
REQ.SendFrame("volume");
string msg2 = REQ.ReceiveFrameString();
Debug.Log(msg2);
byte[] file = System.IO.File.ReadAllBytes(msg2);
Debug.Log(file.Length);
int d1 = System.BitConverter.ToInt32(file, 0);
int d2 = System.BitConverter.ToInt32(file, 4);
int d3 = System.BitConverter.ToInt32(file, 8);
float[] volume = new float[d1 * d2 * d3];
System.Buffer.BlockCopy(file, 12, volume, 0, volume.Length * sizeof(float));
string s = d1 + " " + d2 + " " + d3 + " : ";
//for (int i = 0; i < volume.Length; ++i) s += volume[i] + " ";
Debug.Log(s);
reqestData = false;
}
/*60fps*/
System.Threading.Thread.Sleep(16);
}
SUB.Close();
PUB.Close();
REQ.Close();
}
NetMQConfig.Cleanup();
}
public ZmqClient()
{
context = NetMQContext.Create();
subSocket = context.CreateSubscriberSocket();
subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect(MarketDataSettings.RealTimeUpdateServerAddress);
}
public ZmqClient()
{
context = NetMQContext.Create();
subSocket = context.CreateSubscriberSocket();
subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect(MarketDataSettings.RealTimeUpdateServerAddress);
}
/// <summary>
/// Add <see cref="IAddress"/> to the socket
/// </summary>
/// <param name="address"><see cref="IAddress"/> to be added</param>
public override void SocketAdd(IAddress address)
{
if (disposedValue)
{
throw new InvalidOperationException("NetMQSubscriber has been disposed");
}
socket.Connect(address.ToString());
}
public FrmClient()
{
InitializeComponent();
client.Connect($"tcp://{serverIP}:{serverPort}");
subSocket.Connect($"tcp://{pubIP}:{pubPort}");
//1、订阅主题
subSocket.Subscribe(topic);
}
private IObservable <PooledArraySegment <byte>[]> ZmqSubscribeEndpoint(DaemonEndpointConfig endPoint, string url, string topic, int numMsgSegments = 2)
{
return(Observable.Defer(() => Observable.Create <PooledArraySegment <byte>[]>(obs =>
{
var tcs = new CancellationTokenSource();
Task.Factory.StartNew(() =>
{
using (tcs)
{
while (!tcs.IsCancellationRequested)
{
try
{
using (var subSocket = new SubscriberSocket())
{
//subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect(url);
subSocket.Subscribe(topic);
logger.Debug($"Subscribed to {url}/{BitcoinConstants.ZmqPublisherTopicBlockHash}");
while (!tcs.IsCancellationRequested)
{
var msg = subSocket.ReceiveMultipartMessage(numMsgSegments);
// Export all frame data as array of PooledArraySegments
var result = msg.Select(x =>
{
var buf = ArrayPool <byte> .Shared.Rent(x.BufferSize);
Array.Copy(x.ToByteArray(), buf, x.BufferSize);
return new PooledArraySegment <byte>(buf, 0, x.BufferSize);
}).ToArray();
obs.OnNext(result);
}
}
}
catch (Exception ex)
{
logger.Error(ex);
}
// do not consume all CPU cycles in case of a long lasting error condition
Thread.Sleep(1000);
}
}
}, tcs.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
return Disposable.Create(() =>
{
tcs.Cancel();
});
})));
}
public void Test_Two_Subscribers()
{
NUnitUtils.PrintTestName();
var sw = Stopwatch.StartNew();
using (var pub = new PublisherSocket())
{
using (var sub1 = new SubscriberSocket())
{
using (var sub2 = new SubscriberSocket())
{
var freePort = NUnitUtils.TcpPortFree();
pub.Bind("tcp://127.0.0.1:" + freePort);
sub1.Connect("tcp://127.0.0.1:" + freePort);
sub1.Subscribe("A");
sub2.Connect("tcp://127.0.0.1:" + freePort);
sub2.Subscribe("B");
Thread.Sleep(500);
var swInner = Stopwatch.StartNew();
{
pub.SendFrame("A\n"); // Ping.
{
string topic;
var pass1 = sub1.TryReceiveFrameString(TimeSpan.FromMilliseconds(250), out topic);
if (pass1)
{
Console.Write(topic);
}
else
{
Assert.Fail();
}
}
pub.SendFrame("B\n"); // Ping.
{
string topic;
var pass2 = sub2.TryReceiveFrameString(TimeSpan.FromMilliseconds(250), out topic);
if (pass2)
{
Console.Write(topic);
}
else
{
Assert.Fail();
}
}
}
Console.WriteLine("Connected in {0} ms.", swInner.ElapsedMilliseconds);
}
}
}
NUnitUtils.PrintElapsedTime(sw.Elapsed);
}
// Start is called before the first frame update
private void Start()
{
_hip = GetComponent <Rigidbody>();
_pub.Bind(pubAddress);
_sub.Connect(subAddress);
_sub.SubscribeToAnyTopic();
_sub.Options.ReceiveHighWatermark = 1;
}
static void Main(string[] args)
{
//TestSerilog();
using (var subSocket = new SubscriberSocket())
{
var tcpLocalhost = "tcp://localhost:12345";
subSocket.Connect(tcpLocalhost);
subSocket.SubscribeToAnyTopic();
Console.WriteLine("Waiting to Connect");
var connectMessage = subSocket.ReceiveMultipartMessage();
if (connectMessage[0].ConvertToString(Encoding.UTF8) == "CONNECT")
{
Console.WriteLine("Connected");
var port = connectMessage[1].ConvertToString(Encoding.UTF8);
using (var reqSocket = new RequestSocket(port))
{
var syncMessage = new NetMQMessage();
syncMessage.Append(new NetMQFrame("SYNC", Encoding.UTF8));
syncMessage.Append(new NetMQFrame(tcpLocalhost, Encoding.UTF8));
reqSocket.SendMultipartMessage(syncMessage);
Console.WriteLine("Syncing");
var syncOk = reqSocket.ReceiveFrameString();
Console.WriteLine($"Synced: {syncOk}");
}
using (var poller = new NetMQPoller())
{
poller.Add(subSocket);
subSocket.ReceiveReady += (sender, eventArgs) =>
{
var subMessage = eventArgs.Socket.ReceiveMultipartMessage();
var topic = subMessage[0].ConvertToString(Encoding.UTF8);
if (topic == "TopicA")
{
var decodedMessage = MessagePackSerializer.Deserialize <string>(subMessage[1].ToByteArray());
Console.WriteLine(
$"{subMessage[0].ConvertToString(Encoding.UTF8)}: {decodedMessage}");
}
};
poller.RunAsync();
Console.WriteLine("Press Enter to Exit");
Console.ReadLine();
poller.StopAsync();
}
}
}
}
/// <summary>
/// Intent: See interface.
/// </summary>
public SubscriberSocket GetSharedSubscriberSocket(string addressZeroMq)
{
lock (_initializeSubscriberLock)
{
// Must return a unique subscriber for every new ISubject of T.
var subscriberSocket = new SubscriberSocket();
subscriberSocket.Options.ReceiveHighWatermark = this.HighwaterMark;
subscriberSocket.Connect(addressZeroMq);
return(subscriberSocket);
}
}
private void createRSocket()
{
clientR = context.CreateSubscriberSocket();
string[] addrs = cfg.ServerS.Split(',');
foreach (string addr in addrs)
{
clientR.Connect(addr);
}
clientR.Subscribe(Global.DC_CTRL_HB); //接收心跳数据包
clientR.Subscribe(Global.Encoding.GetBytes(string.Concat(Global.DC_HEAD_AS_RPLY, Global.ENVELOPE_SPLITTER, this.guidStr))); //接收Act操作的回复数据包
}
public byte[] NetMQReceiveBytes(string connectionString)
{
using (SubscriberSocket subSocket = new SubscriberSocket())
{
subSocket.Connect(connectionString);
subSocket.Subscribe(String.Empty);
byte[] result = subSocket.ReceiveFrameBytes();
return(result);
}
}
public void ConnectSubscribe()
{
subscriber = new SubscriberSocket();
subscriber.Connect(SubscribeAddress);
subscriber.ReceiveReady += _Subscire_ReceiveReady;
subscriber.SubscribeToAnyTopic();
subscriberPoller = new NetMQPoller {
subscriber
};
subscriberPoller.RunAsync();
}
private void Subscribe()
{
subscribing = true;
subscriberSocket.Connect(@"tcp://127.0.0.1:17232");
subscriberSocket.SubscribeToAnyTopic();
while (subscribing)
{
if (subscriberSocket.TryReceiveFrameBytes(TimeSpan.FromMilliseconds(100), out var frame))
{
teleprinter.Read(frame[^ 1]);
public TcpConsumer(string address)
{
Address = address;
sub = new SubscriberSocket();
sub.Connect(Address);
var type = typeof(T).AssemblyQualifiedName;
sub.Subscribe(type);
subThread = new Thread(Consume);
subThread.Start();
pipe = new List <Action <T> >();
}
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));
}
private void InitSub()
{
subscriber = new SubscriberSocket();
subscriber.Connect(Address);
subscriber.ReceiveReady += _Subscire_ReceiveReady;
subscriber.SubscribeToAnyTopic();
subscriberPoller = new NetMQPoller {
subscriber
};
subscriberPoller.RunAsync();
}
public string NetMQReceiveString(string connectionString)
{
using (SubscriberSocket subSocket = new SubscriberSocket())
{
subSocket.Connect(connectionString);
subSocket.Subscribe(String.Empty);
string result = subSocket.ReceiveFrameString();
return(result);
}
}
private void SubscribeEntry(object n)
{
string name = (string)n;
using (SubscriberSocket subscriber = new SubscriberSocket())
{
if (!SubRM.ContainsKey(name))
{
Logging.logger.Error("do not have the sub name, return");
return;
}
string endpoint = "tcp://" + SubRM[name].point.ip + ":" + SubRM[name].point.port;
try
{
subscriber.Connect(endpoint);
}
catch (Exception err)
{
Logging.logger.Error("connect to DataSubscribe faild " + endpoint + " " + err.Message);
throw (err);
}
subscriber.Subscribe("");
SubRM[name].subsock = subscriber;
SubRM[name].Working = true;
while (SubRM[name].Running)
{
//string received = serverSocket.ReceiveFrameString();
string received = string.Empty;
bool result = subscriber.TryReceiveFrameString(out received);
if (result == true)
{
try
{
this.SubscriptEntry(name, received);
}
catch (Exception err)
{
Logging.logger.Error(err.Message);
throw (err);
}
}
DelayTime();
}
SubRM[name].Working = false;
subscriber.Close();
}
}
public void Connect(string givenAddress)
{
if (IsConnected)
{
return;
}
subSocket = context.CreateSubscriberSocket();
subSocket.Connect(givenAddress);
subSocket.Subscribe("EasyErgsocket");
IsConnected = true;
}
void establish()
{
subSocket = Core.ZeroMQ.CreateSubscriberSocket();
subSocket.Options.ReceiveHighWatermark = EngCfg.HighWatermark;
ConnAddres = ConnectAddr(typeof(SubscriberSocket));
subSocket.Connect(ConnAddres);
ConsoleEx.DebugLog("Sub socket has connected to " + ConnAddres, ConsoleEx.YELLOW);
subSocket.Subscribe(topic);
subSocket.ReceiveReady += Client_ReceiveReady;
AddPoller();
}
private void Subscribe(object state)
{
_running = true;
foreach (string subscriberAddress in _configuration.SubscriberAddresses)
{
SubscriberSocket subscriberSocket = _context.CreateSubscriberSocket();
subscriberSocket.Connect(subscriberAddress);
subscriberSocket.Subscribe("");
_subscriberSockets.Add(subscriberSocket);
Task.Factory.StartNew(() => WaitForMessages(subscriberSocket));
}
}
public PriceTickerScreenViewModel()
{
// get UI context so can ensure updates are on correct threada
var uiContext = SynchronizationContext.Current;
// add the list of Assets to display
AssetViewModels.Add(new AssetViewModel {
Name = "Stock 1", Price = 0
});
AssetViewModels.Add(new AssetViewModel {
Name = "Stock 2", Price = 0
});
// set up subscriber to asset stream subject
_assetStream.Subscribe(asset =>
{
var avm = AssetViewModels.Single(a => a.Name == asset.Name);
// update on UI context
uiContext.Send(_ =>
{
avm.Price = asset.Price;
avm.History.Add(new HistoryItem
{
Timestamp = asset.Timestamp,
Price = asset.Price
});
}, null);
});
// connect to the price server, receive updates and push to the subject stream
Task.Run(() =>
{
using (var client = new SubscriberSocket())
{
client.Options.ReceiveHighWatermark = 1000;
client.Connect("tcp://localhost:5555");
client.Subscribe("Stock 1");
client.Subscribe("Stock 2");
while (true)
{
var topicMessage = client.ReceiveFrameString();
var message = client.ReceiveFrameString();
// push onto subject
_assetStream.OnNext(message.Deserialise <Asset>());
}
}
});
}
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();
}
public void Start(string serverAddress, int serverPublishPort, int clientId, Action <ServerToClientMessage> messageHandler)
{
this.messageHandler = messageHandler;
subscribeSocket = new SubscriberSocket();
subscribeSocket.Connect(string.Format("tcp://{0}:{1}", serverAddress, serverPublishPort));
subscribeSocket.Subscribe(clientId.ToString());
subscribeSocket.Subscribe("a");
isRunning = true;
receiveThread = new Thread(Run);
receiveThread.Name = "ClientMessageListenThread";
receiveThread.Start();
logger.Info("Server message subscriber started");
}
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);
}
public void Start(string serverAddress, int serverPublishPort, int clientId, Action<ServerToClientMessage> messageHandler)
{
this.messageHandler = messageHandler;
ctx = NetMQContext.Create();
subscribeSocket = ctx.CreateSubscriberSocket();
subscribeSocket.Connect(string.Format("tcp://{0}:{1}", serverAddress, serverPublishPort));
subscribeSocket.Subscribe(clientId.ToString());
subscribeSocket.Subscribe("a");
isRunning = true;
receiveThread = new Thread(Run);
receiveThread.Name = "ClientMessageListenThread";
receiveThread.Start();
logger.Info("Server message subscriber started");
}
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);
}
}
public void Subscribe()
{
using (SubscriberSocket subscriber = new SubscriberSocket())
{
subscriber.Options.ReceiveHighWatermark = 1000;
subscriber.Connect("tcp://127.0.0.1:12345");
subscriber.Subscribe("TopicA");
var data = subscriber.ReceiveFrameString();
Console.WriteLine("Topic: TopicA received data: {0}", data);
}
}
static void Main(string[] args)
{
using (var subSocket = new SubscriberSocket())
{
subSocket.Options.ReceiveHighWatermark = 100;
subSocket.Connect("tcp://localhost:12345");
subSocket.Subscribe("");
Console.WriteLine("Subscriber socket connecting...");
while (true)
{
string messageTopicReceived = subSocket.ReceiveFrameString();
string messageReceived = subSocket.ReceiveFrameString();
Console.WriteLine(messageReceived);
Thread.Sleep(300);
}
}
}
private static void Main()
{
Console.Title = "NetMQ Weather Update Client";
const int zipToSubscribeTo = 10001;
const int iterations = 100;
int totalTemp = 0;
int totalHumidity = 0;
Console.WriteLine("Collecting updates for weather service for zipcode {0}...", zipToSubscribeTo);
using (var subscriber = new SubscriberSocket())
{
subscriber.Connect("tcp://127.0.0.1:5556");
subscriber.Subscribe(zipToSubscribeTo.ToString(CultureInfo.InvariantCulture));
for (int i = 0; i < iterations; i++)
{
string results = subscriber.ReceiveFrameString();
Console.Write(".");
// "zip temp relh" ... "10001 84 23" -> ["10001", "84", "23"]
string[] split = results.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
int zip = int.Parse(split[0]);
if (zip != zipToSubscribeTo)
{
throw new Exception(string.Format("Received message for unexpected zipcode: {0} (expected {1})", zip, zipToSubscribeTo));
}
totalTemp += int.Parse(split[1]);
totalHumidity += int.Parse(split[2]);
}
}
Console.WriteLine();
Console.WriteLine("Average temperature was: {0}", totalTemp/iterations);
Console.WriteLine("Average relative humidity was: {0}", totalHumidity/iterations);
}
private static void SubscriberContinuousLoop(string pubSubAddress, string requestString)
{
Task.Factory.StartNew(() =>
{
using (var progressSubscriber = new SubscriberSocket())
{
progressSubscriber.Connect(pubSubAddress);
progressSubscriber.SubscribeToAnyTopic();
while (true)
{
var topic = progressSubscriber.ReceiveFrameString();
RequestSocket.ProgressTopic progressTopic;
Enum.TryParse(topic, out progressTopic);
switch (progressTopic)
{
case RequestSocket.ProgressTopic.Send:
Console.WriteLine("C: Sending {0}", requestString);
break;
case RequestSocket.ProgressTopic.Retry:
Console.WriteLine("C: No response from server, retrying...");
break;
case RequestSocket.ProgressTopic.Failure:
Console.WriteLine("C: Server seems to be offline, abandoning");
break;
case RequestSocket.ProgressTopic.Success:
Console.WriteLine("C: Server replied OK");
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
});
}
/// <summary>
/// the broker setting up the cluster
///
///
/// State 2 ---+ +--- State n
/// | |
/// +----+----+
/// client 1 ---| | |--- worker 1
/// client 2 ---+---- BROKER 1 ----+--- worker 2
/// : | | | :
/// client n ---+ +----+----+ +--- worker n
/// | |
/// BROKER 2 BROKER n
///
/// BROKER 2 and n are not included and must be setup separately
///
/// A minimum of two address must be supplied
/// </summary>
/// <param name="args">[0] = this broker's address
/// [1] = 1st peer's address
/// :
/// [n] = nth peer address</param>
/// <remarks>
/// since "inproc://" is not working in NetMQ we use "tcp://"
/// for each broker we need 5 ports which for this example are
/// assigned as follows (in true life it should be configurable whether
/// they are ports or tcp/ip addresses)
///
/// this brokers address => local frontend binds to tcp://127.0.0.1:5555
/// cloud frontend binds to :5556
/// local backend binds to :5557
/// state backend binds to :5558
/// monitor PULL binds to :5559
///
/// the sockets are connected as follows
///
/// this broker's monitor PUSH connects to tcp://127.0.0.1:5559
///
/// (if peer's address and port is tcp://127.0.0.1:5575)
///
/// this broker's cloud backend connects to :5576
/// this broker's state frontend connects to :5578
///
/// this scheme is fix in this example
/// </remarks>
public static void Main(string[] args)
{
Console.Title = "NetMQ Inter-Broker Router";
const string baseAddress = "tcp://127.0.0.1:";
if (args.Length < 2)
{
Console.WriteLine("usage: program me peer1 [peer]*");
Console.WriteLine("each broker needs 5 port for his sockets!");
Console.WriteLine("place enough distance between multiple broker addresses!");
Environment.Exit(-1);
}
// trapping Ctrl+C as exit signal!
Console.CancelKeyPress += (s, e) =>
{
e.Cancel = true;
s_keepRunning = false;
};
// get random generator for later use
var rnd = new Random();
// get list for registering the clients
var clients = new List<byte[]>(NbrClients);
// get a list of peer addresses
var peers = new List<byte[]>();
// get all peer addresses - first is this broker!
for (var i = 1; i < args.Length; i++)
peers.Add(Encoding.UTF8.GetBytes(args[i]));
// build this broker's address
var me = baseAddress + args[0];
// get the port as integer for later use
var myPort = int.Parse(args[0]);
Console.WriteLine("[BROKER] The broker can be stopped by using CTRL+C!");
Console.WriteLine("[BROKER] setting up sockets ...");
// set up all the addresses needed in the due course
var localFrontendAddress = me;
var cloudFrontendAddress = baseAddress + (myPort + 1);
var localBackendAddress = baseAddress + (myPort + 2);
var stateBackendAddress = baseAddress + (myPort + 3);
var monitorAddress = baseAddress + (myPort + 4);
// create the context and all the sockets
using (var localFrontend = new RouterSocket())
using (var localBackend = new RouterSocket())
using (var cloudFrontend = new RouterSocket())
using (var cloudBackend = new RouterSocket())
using (var stateBackend = new PublisherSocket())
using (var stateFrontend = new SubscriberSocket())
using (var monitor = new PullSocket())
{
// give every socket an unique identity, e.g. LocalFrontend[Port]
SetIdentities(myPort,
localFrontend,
cloudFrontend,
localBackend,
stateBackend,
monitor,
cloudBackend, stateFrontend);
// subscribe to any message on the stateFrontend socket!
stateFrontend.Subscribe("");
// bind the serving sockets
localFrontend.Bind(localFrontendAddress);
cloudFrontend.Bind(cloudFrontendAddress);
localBackend.Bind(localBackendAddress);
stateBackend.Bind(stateBackendAddress);
monitor.Bind(monitorAddress);
// connect sockets to peers
for (var i = 1; i < args.Length; i++)
{
// build the cloud back end address
var peerPort = int.Parse(args[i]);
var address = baseAddress + (peerPort + 1);
Console.WriteLine("[BROKER] connect to cloud peer {0}", address);
// this cloudBackend connects to all peer cloudFrontends
cloudBackend.Connect(address);
// build the state front end address
address = baseAddress + (peerPort + 3);
Console.WriteLine("[BROKER] subscribe to state peer {0}", address);
// this stateFrontend to all peer stateBackends
stateFrontend.Connect(address);
}
// setup the local worker queue for LRU and monitor cloud capacity
var workerQueue = new Queue<byte[]>();
int previousLocalCapacity = 0;
// receive the capacity available from other peer(s)
stateFrontend.ReceiveReady += (s, e) =>
{
// the message should contain the available cloud capacity
var capacity = e.Socket.ReceiveFrameString();
Debug.Assert(string.IsNullOrWhiteSpace(capacity), "StateFrontend: message was empty!");
int couldCapacity;
Debug.Assert(int.TryParse(capacity, out couldCapacity), "StateFrontend: message did not contain a number!");
};
// get the status message and print it
monitor.ReceiveReady += (s, e) =>
{
var msg = e.Socket.ReceiveFrameString();
Console.WriteLine("[MONITOR] {0}", msg);
};
// all local clients are connecting to this socket
// they send a REQ and get a REPLY
localFrontend.ReceiveReady += (s, e) =>
{
// [client adr][empty][message id]
var request = e.Socket.ReceiveMultipartMessage();
// register the local client for later identification if not known
if (!clients.Any(n => AreSame(n, request[0])))
clients.Add(request[0].Buffer);
// if we have local capacity send worker else send to cloud
if (workerQueue.Count > 0)
{
// get the LRU worker adr
var worker = workerQueue.Dequeue();
// wrap message with workers address
var msg = Wrap(worker, request);
// send message to the worker
// [worker adr][empty][client adr][empty][data]
localBackend.SendMultipartMessage(msg);
}
else
{
// get an random index for peers
var peerIdx = rnd.Next(peers.Count - 2) + 2;
// get peers address
var peer = peers[peerIdx];
// wrap message with peer's address
var msg = Wrap(peer, request);
// [peer adr][empty][client adr][empty][data]
cloudBackend.SendMultipartMessage(msg);
}
};
// the workers are connected to this socket
// we get a REPLY either for a cloud client [worker adr][empty][peer adr][empty][peer client adr][empty][data]
// or local client [worker adr][empty][client adr][empty][data]
// or a READY message [worker adr][empty][WORKER_READY]
localBackend.ReceiveReady += (s, e) =>
{
// a worker can send "READY" or a request
// or an REPLAY
var msg = e.Socket.ReceiveMultipartMessage();
// just to make sure we received a proper message
Debug.Assert(msg != null && msg.FrameCount > 0, "[LocalBackend] message was empty or frame count == 0!");
// get the workers identity
var id = Unwrap(msg);
// this worker done in either way so add it to available workers
workerQueue.Enqueue(id);
// if it is NOT a ready message we need to route the message
// it could be a reply to a peer or a local client
// [WORKER_READY] or [client adr][empty][data] or [peer adr][empty][peer client adr][empty][data]
if (msg[0].Buffer[0] != WorkerReady)
{
Debug.Assert(msg.FrameCount > 2, "[LocalBackend] None READY message malformed");
// if the adr (first frame) is any of the clients send the REPLY there
// and send it to the peer otherwise
if (clients.Any(n => AreSame(n, msg.First)))
localFrontend.SendMultipartMessage(msg);
else
cloudFrontend.SendMultipartMessage(msg);
}
};
// this socket is connected to all peers
// we receive either a REQ or a REPLY form a peer
// REQ [peer adr][empty][peer client adr][empty][message id] -> send to peer for processing
// REP [peer adr][empty][client adr][empty][message id] -> send to local client
cloudBackend.ReceiveReady += (s, e) =>
{
var msg = e.Socket.ReceiveMultipartMessage();
// just to make sure we received a message
Debug.Assert(msg != null && msg.FrameCount > 0, "[CloudBackend] message was empty or frame count == 0!");
// we need the peers address for proper addressing
var peerAdr = Unwrap(msg);
// the remaining message must be at least 3 frames!
Debug.Assert(msg.FrameCount > 2, "[CloudBackend] message malformed");
// if the id is any of the local clients it is a REPLY
// and a REQ otherwise
if (clients.Any(n => AreSame(n, msg.First)))
{
// [client adr][empty][message id]
localFrontend.SendMultipartMessage(msg);
}
else
{
// add the peers address to the request
var request = Wrap(peerAdr, msg);
// [peer adr][empty][peer client adr][empty][message id]
cloudFrontend.SendMultipartMessage(request);
}
};
// all peers are binding to this socket
// we receive REPLY or REQ from peers
// REQ [peer adr][empty][peer client adr][empty][data] -> send to local worker for processing
// REP [peer adr][empty][client adr][empty][data] -> send to local client
cloudFrontend.ReceiveReady += (s, e) =>
{
var msg = e.Socket.ReceiveMultipartMessage();
// just to make sure we received a message
Debug.Assert(msg != null && msg.FrameCount > 0, "[CloudFrontend] message was empty or frame count == 0!");
// we may need the peers address for proper addressing
var peerAdr = Unwrap(msg);
// the remaining message must be at least 3 frames!
Debug.Assert(msg.FrameCount > 2, "[CloudFrontend] message malformed");
// if the address is any of the local clients it is a REPLY
// and a REQ otherwise
if (clients.Any(n => AreSame(n, msg.First)))
localFrontend.SendMultipartMessage(msg);
else
{
// in order to know which per to send back the peers adr must be added again
var original = Wrap(peerAdr, msg);
// reduce the capacity to reflect the use of a worker by a cloud request
previousLocalCapacity = workerQueue.Count;
// get the LRU worker
var workerAdr = workerQueue.Dequeue();
// wrap the message with the worker address and send
var request = Wrap(workerAdr, original);
localBackend.SendMultipartMessage(request);
}
};
// in order to reduce chatter we only check to see if we have local capacity to provide to cloud
// periodically every 2 seconds with a timer
var timer = new NetMQTimer((int)TimeSpan.FromSeconds(2).TotalMilliseconds);
timer.Elapsed += (t, e) =>
{
// send message only if the previous send information changed
if (previousLocalCapacity != workerQueue.Count)
{
// set the information
previousLocalCapacity = workerQueue.Count;
// generate the message
var msg = new NetMQMessage();
var data = new NetMQFrame(previousLocalCapacity.ToString());
msg.Append(data);
var stateMessage = Wrap(Encoding.UTF8.GetBytes(me), msg);
// publish info
stateBackend.SendMultipartMessage(stateMessage);
}
// restart the timer
e.Timer.Enable = true;
};
// start all clients and workers as threads
var clientTasks = new Thread[NbrClients];
var workerTasks = new Thread[NbrWorker];
for (var i = 0; i < NbrClients; i++)
{
var client = new Client(localFrontendAddress, monitorAddress, (byte)i);
clientTasks[i] = new Thread(client.Run) { Name = string.Format("Client_{0}", i) };
clientTasks[i].Start();
}
for (var i = 0; i < NbrWorker; i++)
{
var worker = new Worker(localBackendAddress, (byte)i);
workerTasks[i] = new Thread(worker.Run) { Name = string.Format("Worker_{0}", i) };
workerTasks[i].Start();
}
// create poller and add sockets & timer
var poller = new NetMQPoller
{
localFrontend,
localBackend,
cloudFrontend,
cloudBackend,
stateFrontend,
stateBackend,
monitor,
timer
};
// start monitoring the sockets
poller.RunAsync();
// we wait for a CTRL+C to exit
while (s_keepRunning)
Thread.Sleep(100);
Console.WriteLine("Ctrl-C encountered! Exiting the program!");
if (poller.IsRunning)
poller.Stop();
poller.Dispose();
}
}