static void Main(string[] args) { using (var context = ZmqContext.Create()) { using (ZmqSocket frontend = context.CreateSocket(SocketType.ROUTER), backend = context.CreateSocket(SocketType.ROUTER)) { frontend.Bind("tcp://*:5555"); // For Clients backend.Bind("tcp://*:5556"); // For Workers // Logic of LRU loop // - Poll backend always, frontend only if 1+ worker ready // - If worker replies, queue worker as ready and forward reply // to client if necessary // - If client requests, pop next worker and send request to it // Queue of available workers var workerQueue = new Queue <byte[]>(); // Handle worker activity on backend backend.ReceiveReady += (s, e) => { var zmsg = new ZMessage(e.Socket); // Use worker address for LRU routing workerQueue.Enqueue(zmsg.Unwrap()); // Forward message to client if it's not a READY if (!Encoding.Unicode.GetString(zmsg.Address).Equals(LRU_READY)) { zmsg.Send(frontend); } }; frontend.ReceiveReady += (s, e) => { // Now get next client request, route to next worker // Dequeue and drop the next worker address var zmsg = new ZMessage(e.Socket); zmsg.Wrap(workerQueue.Dequeue(), new byte[0]); zmsg.Send(backend); }; var poller = new Poller(new ZmqSocket[] { frontend, backend }); while (true) { //int rc = ZmqContext.Poller(workerQueue.Count > 0 // ? new List<ZmqSocket>(new ZmqSocket[] {frontend, backend}) // : new List<ZmqSocket>(new ZmqSocket[] {backend})); int rc = poller.Poll(); if (rc == -1) { break; } } } } }
static void Main(string[] args) { using (var context = ZmqContext.Create()) { using (ZmqSocket frontend = context.CreateSocket(SocketType.ROUTER), backend = context.CreateSocket(SocketType.ROUTER)) { frontend.Bind("tcp://*:5555"); // For Clients backend.Bind("tcp://*:5556"); // For Workers // Logic of LRU loop // - Poll backend always, frontend only if 1+ worker ready // - If worker replies, queue worker as ready and forward reply // to client if necessary // - If client requests, pop next worker and send request to it // Queue of available workers var workerQueue = new Queue<byte[]>(); // Handle worker activity on backend backend.ReceiveReady += (s, e) => { var zmsg = new ZMessage(e.Socket); // Use worker address for LRU routing workerQueue.Enqueue(zmsg.Unwrap()); // Forward message to client if it's not a READY if (!Encoding.Unicode.GetString(zmsg.Address).Equals(LRU_READY)) { zmsg.Send(frontend); } }; frontend.ReceiveReady += (s, e) => { // Now get next client request, route to next worker // Dequeue and drop the next worker address var zmsg = new ZMessage(e.Socket); zmsg.Wrap(workerQueue.Dequeue(), new byte[0]); zmsg.Send(backend); }; var poller = new Poller(new ZmqSocket[] { frontend, backend }); while (true) { //int rc = ZmqContext.Poller(workerQueue.Count > 0 // ? new List<ZmqSocket>(new ZmqSocket[] {frontend, backend}) // : new List<ZmqSocket>(new ZmqSocket[] {backend})); int rc = poller.Poll(); if (rc == -1) { break; } } } } }
// .split broker client_msg method // Process a request coming from a client. We implement MMI requests // directly here (at present, we implement only the mmi.service request): public void ClientMsg(ZFrame sender, ZMessage msg) { // service & body if (msg.Count < 2) { throw new InvalidOperationException(); } using (ZFrame serviceFrame = msg.Pop()) { Service service = RequireService(serviceFrame); // Set reply return identity to client sender msg.Wrap(sender.Duplicate()); //if we got a MMI Service request, process that internally if (serviceFrame.Length >= 4 && serviceFrame.ToString().StartsWith("mmi.")) { string returnCode; if (serviceFrame.ToString().Equals("mmi.service")) { string name = msg.Last().ToString(); returnCode = Services.ContainsKey(name) && Services[name].Workers > 0 ? "200" : "404"; } else { returnCode = "501"; } var client = msg.Unwrap(); msg.Clear(); msg.Add(new ZFrame(returnCode)); msg.Prepend(serviceFrame); msg.Prepend(new ZFrame(MdpCommon.MDPC_CLIENT)); msg.Wrap(client); Socket.Send(msg); } else { // Else dispatch the message to the requested Service service.Dispatch(msg); } } }
static void Main(string[] args) { using (var context = new Context(1)) { using (Socket frontend = context.Socket(SocketType.ROUTER), backend = context.Socket(SocketType.ROUTER)) { frontend.Bind("tcp://*:5555"); // For Clients backend.Bind("tcp://*:5556"); // For Workers // Queue of available workers var workerQueue = new List <Worker>(); backend.PollInHandler += (socket, revents) => { var zmsg = new ZMessage(socket); byte[] identity = zmsg.Unwrap(); //Any sign of life from worker means it's ready, Only add it to the queue if it's not in there already Worker worker = null; if (workerQueue.Count > 0) { var workers = workerQueue.Where(x => x.address.SequenceEqual(identity)); if (workers.Count() > 0) { worker = workers.Single(); } } if (worker == null) { workerQueue.Add(new Worker(identity)); } //Return reply to client if it's not a control message switch (Encoding.Unicode.GetString(zmsg.Address)) { case PPP_READY: Console.WriteLine("Worker " + Encoding.Unicode.GetString(identity) + " is ready..."); break; case PPP_HEARTBEAT: bool found = false; //Worker Refresh if (worker != null) { found = true; worker.ResetExpiry(); } if (!found) { Console.WriteLine("E: worker " + Encoding.Unicode.GetString(identity) + " not ready..."); } break; default: zmsg.Send(frontend); break; } ; }; frontend.PollInHandler += (socket, revents) => { // Now get next client request, route to next worker // Dequeue and drop the next worker address var zmsg = new ZMessage(socket); Worker w = workerQueue[0]; zmsg.Wrap(w.address, new byte[0]); workerQueue.RemoveAt(0); zmsg.Send(backend); }; DateTime heartbeat_at = DateTime.Now.AddMilliseconds(HEARTBEAT_INTERVAL); while (true) { //Only poll frontend only if there are workers ready if (workerQueue.Count > 0) { List <Socket> pollItems = new List <Socket>(new Socket[] { frontend, backend }); Context.Poller(pollItems, HEARTBEAT_INTERVAL * 1000); } else { List <ZMQ.Socket> pollItems = new List <Socket>(new Socket[] { backend }); Context.Poller(pollItems, HEARTBEAT_INTERVAL * 1000); } //Send heartbeats to idle workers if it's time if (DateTime.Now >= heartbeat_at) { foreach (var worker in workerQueue) { ZMessage zmsg = new ZMessage(PPP_HEARTBEAT); zmsg.Wrap(worker.address, new byte[0]); zmsg.Send(backend); } heartbeat_at = DateTime.Now.AddMilliseconds(HEARTBEAT_INTERVAL); } } } } }
// .split broker client_msg method // Process a request coming from a client. We implement MMI requests // directly here (at present, we implement only the mmi.service request): public void ClientMsg(ZFrame sender, ZMessage msg) { // service & body if(msg.Count < 2) throw new InvalidOperationException(); using (ZFrame serviceFrame = msg.Pop()) { Service service = RequireService(serviceFrame); // Set reply return identity to client sender msg.Wrap(sender.Duplicate()); //if we got a MMI Service request, process that internally if (serviceFrame.Length >= 4 && serviceFrame.ToString().StartsWith("mmi.")) { string returnCode; if (serviceFrame.ToString().Equals("mmi.service")) { string name = msg.Last().ToString(); returnCode = Services.ContainsKey(name) && Services[name].Workers > 0 ? "200" : "404"; } else returnCode = "501"; var client = msg.Unwrap(); msg.Clear(); msg.Add(new ZFrame(returnCode)); msg.Prepend(serviceFrame); msg.Prepend(new ZFrame(MdpCommon.MDPC_CLIENT)); msg.Wrap(client); Socket.Send(msg); } else { // Else dispatch the message to the requested Service service.Dispatch(msg); } } }
// .split broker worker_msg method // This method processes one READY, REPLY, HEARTBEAT, or // DISCONNECT message sent to the broker by a worker: public void WorkerMsg(ZFrame sender, ZMessage msg) { if(msg.Count < 1) // At least, command throw new InvalidOperationException(); ZFrame command = msg.Pop(); //string id_string = sender.ReadString(); bool isWorkerReady; //string id_string; using (var sfrm = sender.Duplicate()) { var idString = sfrm.Read().ToHexString(); isWorkerReady = Workers.ContainsKey(idString); } Worker worker = RequireWorker(sender); using (msg) using (command) { if (command.StrHexEq(MdpCommon.MdpwCmd.READY)) { if (isWorkerReady) // Not first command in session worker.Delete(true); else if (command.Length >= 4 && command.ToString().StartsWith("mmi.")) // Reserd servicee name worker.Delete(true); else { // Attach worker to service and mark as idle using (ZFrame serviceFrame = msg.Pop()) { worker.Service = RequireService(serviceFrame); worker.Service.Workers++; worker.Waiting(); } } } else if (command.StrHexEq(MdpCommon.MdpwCmd.REPLY)) { if (isWorkerReady) { // Remove and save client return envelope and insert the // protocol header and service name, then rewrap envelope. ZFrame client = msg.Unwrap(); msg.Prepend(new ZFrame(worker.Service.Name)); msg.Prepend(new ZFrame(MdpCommon.MDPC_CLIENT)); msg.Wrap(client); Socket.Send(msg); worker.Waiting(); } else { worker.Delete(true); } } else if (command.StrHexEq(MdpCommon.MdpwCmd.HEARTBEAT)) { if (isWorkerReady) { worker.Expiry = DateTime.UtcNow + MdpCommon.HEARTBEAT_EXPIRY; } else { worker.Delete(true); } } else if (command.StrHexEq(MdpCommon.MdpwCmd.DISCONNECT)) worker.Delete(false); else { msg.DumpZmsg("E: invalid input message"); } } }
static void Main(string[] args) { List<Thread> workers = new List<Thread>(); List<Thread> clients = new List<Thread>(); // Prepare our context and sockets using (Context ctx = new Context(1)) { using (Socket frontend = ctx.Socket(SocketType.XREP), backend = ctx.Socket(SocketType.XREP)) { frontend.Bind("tcp://*:5555"); backend.Bind("tcp://*:5556"); int clientNbr; for (clientNbr = 0; clientNbr < NBR_CLIENTS; clientNbr++) { clients.Add(new Thread(ClientTask)); clients[clientNbr].Start(); } for (int workerNbr = 0; workerNbr < NBR_WORKERS; workerNbr++) { workers.Add(new Thread(WorkerTask)); workers[workerNbr].Start(); } // Logic of LRU loop // - Poll backend always, frontend only if 1+ worker ready // - If worker replies, queue worker as ready and forward reply // to client if necessary // - If client requests, pop next worker and send request to it // Queue of available workers Queue<byte[]> workerQueue = new Queue<byte[]>(); // Handle worker activity on backend backend.PollInHandler += (skt, revents) => { ZMessage zmsg = new ZMessage(skt); // Use worker address for LRU routing workerQueue.Enqueue(zmsg.Unwrap()); // Forward message to client if it's not a READY if (!Encoding.Unicode.GetString(zmsg.Address).Equals("READY")) { zmsg.Send(frontend); clientNbr--; // Exit after N messages } }; frontend.PollInHandler += (skt, revents) => { // Now get next client request, route to next worker // Dequeue and drop the next worker address ZMessage zmsg = new ZMessage(skt); zmsg.Wrap(workerQueue.Dequeue(), new byte[0]); zmsg.Send(backend); }; while (clientNbr > 0) { // Exit after N messages if (workerQueue.Count > 0) { Context.Poller(new List<Socket>(new Socket[] { frontend, backend })); } else { Context.Poller(new List<Socket>(new Socket[] { backend })); } } } } }
public static void Main(string[] args) { if (args.Length < 2) { Console.WriteLine("Usage: peering2 <myself> <peer_1> … <peer_N>"); return; } var myself = args[0]; Console.WriteLine("Hello, I am " + myself); using (var context = new Context(1)) { using (Socket cloudfe = context.Socket(SocketType.ROUTER), cloudbe = context.Socket(SocketType.ROUTER), localfe = context.Socket(SocketType.ROUTER), localbe = context.Socket(SocketType.ROUTER)) { cloudFeAddress = "tcp://127.0.0.1:" + myself; cloudfe.Identity = Encoding.Unicode.GetBytes(myself); cloudfe.Bind(cloudFeAddress); cloudbe.Identity = Encoding.Unicode.GetBytes(myself); for (int arg = 1; arg < args.Length; arg++) { var endpoint = "tcp://127.0.0.1:" + args[arg]; peers.Add(endpoint); Console.WriteLine("I: connecting to cloud frontend at " + endpoint); cloudbe.Connect(endpoint); } localFeAddress = cloudFeAddress + "1"; localfe.Bind(localFeAddress); localBeAddress = cloudFeAddress + "2"; localbe.Bind(localBeAddress); Console.WriteLine("Press Enter when all brokers are started: "); Console.ReadKey(); var workers = new List <Thread>(); for (int workerNumber = 0; workerNumber < numberOfWorkers; workerNumber++) { workers.Add(new Thread(WorkerTask)); workers[workerNumber].Start(); } var clients = new List <Thread>(); for (int clientNumber = 0; clientNumber < numberOfClients; clientNumber++) { clients.Add(new Thread(ClientTask)); clients[clientNumber].Start(); } var workerQueue = new Queue <byte[]>(); var localfeReady = false; var cloudfeReady = false; var backends = new PollItem[2]; backends[0] = localbe.CreatePollItem(IOMultiPlex.POLLIN); backends[0].PollInHandler += (socket, revents) => { var zmsg = new ZMessage(socket); // Use worker address for LRU routing workerQueue.Enqueue(zmsg.Unwrap()); if (zmsg.BodyToString() != "READY") { SendReply(zmsg, cloudfe, localfe); } }; backends[1] = cloudbe.CreatePollItem(IOMultiPlex.POLLIN); backends[1].PollInHandler += (socket, revents) => { var zmsg = new ZMessage(socket); // We don't use peer broker address for anything zmsg.Unwrap(); SendReply(zmsg, cloudfe, localfe); }; var frontends = new PollItem[2]; frontends[0] = cloudfe.CreatePollItem(IOMultiPlex.POLLIN); frontends[0].PollInHandler += (socket, revents) => { cloudfeReady = true; }; frontends[1] = localfe.CreatePollItem(IOMultiPlex.POLLIN); frontends[1].PollInHandler += (socket, revents) => { localfeReady = true; }; while (true) { var timeout = (workerQueue.Count > 0 ? 1000000 : -1); var rc = Context.Poller(backends, timeout); if (rc == -1) { break; // Interrupted } while (workerQueue.Count > 0) { Context.Poller(frontends, 0); bool reRoutable; ZMessage msg; if (cloudfeReady) { cloudfeReady = false; msg = new ZMessage(cloudfe); reRoutable = false; } else if (localfeReady) { localfeReady = false; msg = new ZMessage(localfe); reRoutable = true; } else { break; } //if (reRoutable && workerQueue.Count > 0 && randomizer.Next(3) == 0) if (reRoutable && peers.Count > 0 && randomizer.Next(4) == 0) { var randomPeer = randomizer.Next(1, args.Length - 1); var endpoint = "tcp://127.0.0.1:" + args[randomPeer]; msg.Wrap(Encoding.Unicode.GetBytes(endpoint), new byte[0]); msg.Send(cloudbe); } else { msg.Wrap(workerQueue.Dequeue(), new byte[0]); msg.Send(localbe); } } } } } }
static void Main(string[] args) { using (var context = new Context(1)) { int interval = INTERVAL_INIT; int liveness = HEARTBEAT_LIVENESS; while (true) { int cylces = 0; using (Socket worker = ConnectWorker(context)) { worker.PollInHandler += (socket, revents) => { var zmsg = new ZMessage(socket); byte[] identity = zmsg.Unwrap(); switch (Encoding.Unicode.GetString(zmsg.Address)) { case PPP_HEARTBEAT: interval = INTERVAL_INIT; liveness = HEARTBEAT_LIVENESS; break; default: if (zmsg.FrameCount > 1) { if (!doTheWork(cylces++)) { break; } interval = INTERVAL_INIT; liveness = HEARTBEAT_LIVENESS; Console.WriteLine("W: work completed"); zmsg.Send(worker); } else { Console.WriteLine("E: invalied message {0}", identity); } break; } ; }; //Send out heartbeats at regular intervals DateTime heartbeat_at = DateTime.Now.AddMilliseconds(HEARTBEAT_INTERVAL); while (true) { List <Socket> pollItems = new List <Socket>(new Socket[] { worker }); Context.Poller(pollItems, HEARTBEAT_INTERVAL * 1000); //If liveness hits zero, queue is considered disconnected if (--liveness <= 0) { Console.WriteLine("W: heartbeat failure, can't reach queue."); Console.WriteLine("W: reconnecting in {0} msecs...", interval); try { Thread.Sleep(interval); } catch (System.Exception ex) { Console.WriteLine(ex.Message); } //Exponential Backoff if (interval < INTERVAL_MAX) { interval *= 2; } liveness = HEARTBEAT_LIVENESS; //Break the while loop and start the connection over break; } //Send heartbeat to queue if it's time if (DateTime.Now > heartbeat_at) { heartbeat_at = DateTime.Now.AddMilliseconds(HEARTBEAT_INTERVAL); ZMessage zmsg = new ZMessage(PPP_HEARTBEAT); zmsg.Send(worker); } } } } } }
public static void Main(string[] args) { var workers = new List <Thread>(); var clients = new List <Thread>(); // Prepare our context and sockets using (var ctx = new Context(1)) { using (Socket frontend = ctx.Socket(SocketType.ROUTER), backend = ctx.Socket(SocketType.ROUTER)) { frontend.Bind("tcp://*:5555"); backend.Bind("tcp://*:5556"); int clientId; for (clientId = 0; clientId < Program.clients; clientId++) { clients.Add(new Thread(ClientTask)); clients[clientId].Start(); } for (int workerId = 0; workerId < Program.workers; workerId++) { workers.Add(new Thread(WorkerTask)); workers[workerId].Start(); } // Logic of LRU loop // - Poll backend always, frontend only if 1+ worker ready // - If worker replies, queue worker as ready and forward reply // to client if necessary // - If client requests, pop next worker and send request to it // Queue of available workers var workerQueue = new Queue <byte[]>(); // Handle worker activity on backend backend.PollInHandler += (socket, revents) => { var zmsg = new ZMessage(socket); // Use worker address for LRU routing workerQueue.Enqueue(zmsg.Unwrap()); // Forward message to client if it's not a READY if (!Encoding.Unicode.GetString(zmsg.Address).Equals("READY")) { zmsg.Send(frontend); } }; frontend.PollInHandler += (socket, revents) => { // Now get next client request, route to next worker // Dequeue and drop the next worker address var zmsg = new ZMessage(socket); zmsg.Wrap(workerQueue.Dequeue(), new byte[0]); zmsg.Send(backend); }; while (true) { int rc = Context.Poller(workerQueue.Count > 0 ? new List <Socket>(new Socket[] { frontend, backend }) : new List <Socket>(new Socket[] { backend })); if (rc == -1) { break; } } } } }
// .split broker client_msg method // Process a request coming from a client. We implement MMI requests // directly here (at present, we implement only the mmi.service request): public void ClientMsg(ZFrame sender, ZMessage msg) { // service & body if(msg.Count < 2) throw new InvalidOperationException(); using (ZFrame serviceFrame = msg.Pop()) { Service service = RequireService(serviceFrame); // Set reply return identity to client sender msg.Wrap(sender.Duplicate()); //if we got a MMI Service request, process that internally if (serviceFrame.Length >= 4 && serviceFrame.ToString().StartsWith("mmi.")) { string returnCode; if (serviceFrame.ToString().Equals("mmi.service")) { string name = msg.Last().ToString(); returnCode = Services.ContainsKey(name) && Services[name].Workers > 0 ? "200" : "400"; } else returnCode = "501"; using (var resetableFrame = msg.Pop()) { msg.Prepend(new ZFrame(returnCode)); } //ToDo check c implementation throw new NotImplementedException("ToDo: fix this section, never tested. contains errors mmi services never called with the mdclient/mdbroker/mdworker examples"); //## following code has some errors // Remove & save client return envelope and insert the // protocol header and Service name, then rewrap envelope. ZFrame client = msg.Unwrap(); msg.Prepend(serviceFrame); msg.Prepend(new ZFrame(MdpCommon.MDPC_CLIENT)); msg.Wrap(client); Socket.Send(msg); } else { // Else dispatch the message to the requested Service service.Dispatch(msg); } } }
static void Main(string[] args) { List <Thread> workers = new List <Thread>(); List <Thread> clients = new List <Thread>(); // Prepare our context and sockets using (Context ctx = new Context(1)) { using (Socket frontend = ctx.Socket(SocketType.ROUTER), backend = ctx.Socket(SocketType.ROUTER)) { frontend.Bind("tcp://*:5555"); backend.Bind("tcp://*:5556"); int clientNbr; for (clientNbr = 0; clientNbr < NBR_CLIENTS; clientNbr++) { clients.Add(new Thread(ClientTask)); clients[clientNbr].Start(); } for (int workerNbr = 0; workerNbr < NBR_WORKERS; workerNbr++) { workers.Add(new Thread(WorkerTask)); workers[workerNbr].Start(); } // Logic of LRU loop // - Poll backend always, frontend only if 1+ worker ready // - If worker replies, queue worker as ready and forward reply // to client if necessary // - If client requests, pop next worker and send request to it // Queue of available workers Queue <byte[]> workerQueue = new Queue <byte[]>(); // Handle worker activity on backend backend.PollInHandler += (skt, revents) => { ZMessage zmsg = new ZMessage(skt); // Use worker address for LRU routing workerQueue.Enqueue(zmsg.Unwrap()); // Forward message to client if it's not a READY if (!Encoding.Unicode.GetString(zmsg.Address).Equals("READY")) { zmsg.Send(frontend); clientNbr--; // Exit after N messages } }; frontend.PollInHandler += (skt, revents) => { // Now get next client request, route to next worker // Dequeue and drop the next worker address ZMessage zmsg = new ZMessage(skt); zmsg.Wrap(workerQueue.Dequeue(), new byte[0]); zmsg.Send(backend); }; while (clientNbr > 0) // Exit after N messages { if (workerQueue.Count > 0) { Context.Poller(new List <Socket>(new Socket[] { frontend, backend })); } else { Context.Poller(new List <Socket>(new Socket[] { backend })); } } } } }
// .split broker worker_msg method // This method processes one READY, REPLY, HEARTBEAT, or // DISCONNECT message sent to the broker by a worker: public void WorkerMsg(ZFrame sender, ZMessage msg) { if (msg.Count < 1) // At least, command { throw new InvalidOperationException(); } ZFrame command = msg.Pop(); //string id_string = sender.ReadString(); bool isWorkerReady; //string id_string; using (var sfrm = sender.Duplicate()) { var idString = sfrm.Read().ToHexString(); isWorkerReady = Workers.ContainsKey(idString); } Worker worker = RequireWorker(sender); using (msg) using (command) { if (command.StrHexEq(MdpCommon.MdpwCmd.READY)) { if (isWorkerReady) { // Not first command in session worker.Delete(true); } else if (command.Length >= 4 && command.ToString().StartsWith("mmi.")) { // Reserd servicee name worker.Delete(true); } else { // Attach worker to service and mark as idle using (ZFrame serviceFrame = msg.Pop()) { worker.Service = RequireService(serviceFrame); worker.Service.Workers++; worker.Waiting(); } } } else if (command.StrHexEq(MdpCommon.MdpwCmd.REPLY)) { if (isWorkerReady) { // Remove and save client return envelope and insert the // protocol header and service name, then rewrap envelope. ZFrame client = msg.Unwrap(); msg.Prepend(new ZFrame(worker.Service.Name)); msg.Prepend(new ZFrame(MdpCommon.MDPC_CLIENT)); msg.Wrap(client); Socket.Send(msg); worker.Waiting(); } else { worker.Delete(true); } } else if (command.StrHexEq(MdpCommon.MdpwCmd.HEARTBEAT)) { if (isWorkerReady) { worker.Expiry = DateTime.UtcNow + MdpCommon.HEARTBEAT_EXPIRY; } else { worker.Delete(true); } } else if (command.StrHexEq(MdpCommon.MdpwCmd.DISCONNECT)) { worker.Delete(false); } else { msg.DumpZmsg("E: invalid input message"); } } }
static void Main(string[] args) { using (var context = ZmqContext.Create()) { using (ZmqSocket frontend = context.CreateSocket(SocketType.ROUTER), backend = context.CreateSocket(SocketType.ROUTER)) { frontend.Bind("tcp://*:5555"); // For Clients backend.Bind("tcp://*:5556"); // For Workers // Queue of available workers var workerQueue = new List<Worker>(); backend.ReceiveReady += (socket, e) => { var zmsg = new ZMessage(e.Socket); byte[] identity = zmsg.Unwrap(); //Any sign of life from worker means it's ready, Only add it to the queue if it's not in there already Worker worker = null; if (workerQueue.Count > 0) { var workers = workerQueue.Where(x => x.address.SequenceEqual(identity)); if (workers.Any()) worker = workers.Single(); } if (worker == null) { workerQueue.Add(new Worker(identity)); } //Return reply to client if it's not a control message switch (Encoding.Unicode.GetString(zmsg.Address)) { case PPP_READY: Console.WriteLine("Worker " + Encoding.Unicode.GetString(identity) + " is ready..."); break; case PPP_HEARTBEAT: bool found = false; //Worker Refresh if (worker != null) { found = true; worker.ResetExpiry(); } if (!found) { Console.WriteLine("E: worker " + Encoding.Unicode.GetString(identity) + " not ready..."); } break; default: zmsg.Send(frontend); break; }; }; frontend.ReceiveReady += (socket, e) => { // Now get next client request, route to next worker // Dequeue and drop the next worker address var zmsg = new ZMessage(e.Socket); Worker w = workerQueue[0]; zmsg.Wrap(w.address, new byte[0]); workerQueue.RemoveAt(0); zmsg.Send(backend); }; var poller = new Poller(new List<ZmqSocket> { frontend, backend }); DateTime heartbeat_at = DateTime.Now.AddMilliseconds(HEARTBEAT_INTERVAL); while (true) { //Only poll frontend only if there are workers ready if (workerQueue.Count > 0) { //List<ZmqSocket> pollItems = new List<ZmqSocket>(new ZmqSocket[] { frontend, backend }); poller.Poll(TimeSpan.FromMilliseconds(HEARTBEAT_INTERVAL * 1000)); } else { //List<ZmqSocket> pollItems = new List<ZmqSocket>(new ZmqSocket[] { backend }); poller.Poll(TimeSpan.FromMilliseconds(HEARTBEAT_INTERVAL * 1000)); } //Send heartbeats to idle workers if it's time if (DateTime.Now >= heartbeat_at) { foreach (var worker in workerQueue) { ZMessage zmsg = new ZMessage(PPP_HEARTBEAT); zmsg.Wrap(worker.address, new byte[0]); zmsg.Send(backend); } heartbeat_at = DateTime.Now.AddMilliseconds(HEARTBEAT_INTERVAL); } } } } }
public static void Main(string[] args) { if (args.Length < 2) { Console.WriteLine("Usage: peering2 <myself> <peer_1> ... <peer_N>"); return; } var myself = args[0]; Console.WriteLine("Hello, I am " + myself); using (var context = ZmqContext.Create()) { using (ZmqSocket cloudfe = context.CreateSocket(SocketType.ROUTER), cloudbe = context.CreateSocket(SocketType.ROUTER), localfe = context.CreateSocket(SocketType.ROUTER), localbe = context.CreateSocket(SocketType.ROUTER)) { cloudFeAddress = "tcp://127.0.0.1:" + myself; cloudfe.Identity = Encoding.Unicode.GetBytes(myself); cloudfe.Bind(cloudFeAddress); cloudbe.Identity = Encoding.Unicode.GetBytes(myself); for (int arg = 1; arg < args.Length; arg++) { var endpoint = "tcp://127.0.0.1:" + args[arg]; peers.Add(endpoint); Console.WriteLine("I: connecting to cloud frontend at " + endpoint); cloudbe.Connect(endpoint); } localFeAddress = cloudFeAddress + "1"; localfe.Bind(localFeAddress); localBeAddress = cloudFeAddress + "2"; localbe.Bind(localBeAddress); Console.WriteLine("Press Enter when all brokers are started: "); Console.ReadKey(); var workers = new List<Thread>(); for (int workerNumber = 0; workerNumber < numberOfWorkers; workerNumber++) { workers.Add(new Thread(WorkerTask)); workers[workerNumber].Start(); } var clients = new List<Thread>(); for (int clientNumber = 0; clientNumber < numberOfClients; clientNumber++) { clients.Add(new Thread(ClientTask)); clients[clientNumber].Start(); } var workerQueue = new Queue<byte[]>(); var localfeReady = false; var cloudfeReady = false; var backends = new Poller(); localbe.ReceiveReady += (socket, revents) => { var zmsg = new ZMessage(revents.Socket); // Use worker address for LRU routing workerQueue.Enqueue(zmsg.Unwrap()); if (zmsg.BodyToString() != "READY") { SendReply(zmsg, cloudfe, localfe); } }; cloudbe.ReceiveReady += (socket, revents) => { var zmsg = new ZMessage(revents.Socket); // We don't use peer broker address for anything zmsg.Unwrap(); SendReply(zmsg, cloudfe, localfe); }; var frontends = new Poller(); cloudfe.ReceiveReady += (socket, revents) => { cloudfeReady = true; }; localfe.ReceiveReady += (socket, revents) => { localfeReady = true; }; while (true) { var timeout = (workerQueue.Count > 0 ? 1000000 : -1); var rc = backends.Poll(TimeSpan.FromMilliseconds(timeout)); if (rc == -1) break; // Interrupted while (workerQueue.Count > 0) { frontends.Poll(TimeSpan.Zero); bool reRoutable; ZMessage msg; if (cloudfeReady) { cloudfeReady = false; msg = new ZMessage(cloudfe); reRoutable = false; } else if (localfeReady) { localfeReady = false; msg = new ZMessage(localfe); reRoutable = true; } else { break; } //if (reRoutable && workerQueue.Count > 0 && randomizer.Next(3) == 0) if (reRoutable && peers.Count > 0 && randomizer.Next(4) == 0) { var randomPeer = randomizer.Next(1, args.Length - 1); var endpoint = "tcp://127.0.0.1:" + args[randomPeer]; msg.Wrap(Encoding.Unicode.GetBytes(endpoint), new byte[0]); msg.Send(cloudbe); } else { msg.Wrap(workerQueue.Dequeue(), new byte[0]); msg.Send(localbe); } } } } } }