def main(): # Prepare our context and publisher socket ctx = zmq.Context() publisher = ctx.socket(zmq.PUB) publisher.bind("tcp://*:5556") time.sleep(0.2) sequence = 0 random.seed(time.time()) kvmap = {} try: while True: # Distribute as key-value message sequence += 1 kvmsg = KVMsg(sequence) kvmsg.key = ("%4d" % random.randint(0,9999)).encode() kvmsg.body = ("%6d" % random.randint(0,999999)).encode() kvmsg.send(publisher) kvmsg.store(kvmap) time.sleep(0.1) except KeyboardInterrupt: print (" Interrupted\n%d messages out" % sequence) dump_all(kvmap, 'pub.txt')
def main(): # Prepare our context and publisher socket ctx = zmq.Context() publisher = ctx.socket(zmq.PUB) publisher.bind("tcp://*:5557") updates, peer = zpipe(ctx) manager_thread = threading.Thread(target=state_manager, args=(ctx, peer)) # manager_thread.daemon=True manager_thread.start() sequence = 0 random.seed(time.time()) try: while True: # Distribute as key-value message sequence += 1 kvmsg = KVMsg(sequence) kvmsg.key = ("%6d" % random.randint(0, 9999)).encode() kvmsg.body = ("%4d" % random.randint(0, 999999)).encode() kvmsg.send(publisher) kvmsg.send(updates) time.sleep(0.01) except KeyboardInterrupt: updates.send_multipart([b'QUIT']) manager_thread.join() print(" Interrupted\n%d messages out" % sequence)
def main(): # Prepare our context and publisher socket ctx = zmq.Context() publisher = ctx.socket(zmq.PUB) publisher.bind("tcp://*:5557") updates, peer = zpipe(ctx) manager_thread = threading.Thread(target=state_manager, args=(ctx, peer)) manager_thread.daemon = True manager_thread.start() sequence = 0 random.seed(time.time()) try: while True: # Distribute as key-value message sequence += 1 kvmsg = KVMsg(sequence) kvmsg.key = "%d" % random.randint(1, 10000) kvmsg.body = "%d" % random.randint(1, 1000000) kvmsg.send(publisher) kvmsg.send(updates) except KeyboardInterrupt: print " Interrupted\n%d messages out" % sequence
def main(): # Prepare our context and publisher socket ctx = zmq.Context() publisher = ctx.socket(zmq.PUB) publisher.bind("tcp://*:5557") updates, peer = zpipe(ctx) manager_thread = threading.Thread(target=state_manager, args=(ctx,peer)) manager_thread.daemon=True manager_thread.start() sequence = 0 random.seed(time.time()) try: while True: # Distribute as key-value message sequence += 1 kvmsg = KVMsg(sequence) kvmsg.key = "%d" % random.randint(1,10000) kvmsg.body = "%d" % random.randint(1,1000000) kvmsg.send(publisher) kvmsg.send(updates) except KeyboardInterrupt: print " Interrupted\n%d messages out" % sequence
def main(): # server context and sockets ctx = zmq.Context() snapshot = ctx.socket(zmq.ROUTER) snapshot.bind('tcp://*:5556') publisher = ctx.socket(zmq.PUB) publisher.bind('tcp://*:5557') collector = ctx.socket(zmq.PULL) collector.bind('tcp://*:5558') sequence = 0 kvmap = {} poller = zmq.Poller() # s collectoru aj snapshotu viem naraz vyberat spravy poller.register(collector,zmq.POLLIN) poller.register(snapshot, zmq.POLLIN) while True: try: items = dict(poller.poll(1000)) except KeyboardInterrupt: break # apply state update sent from client if collector in items: kvmsg = KVMsg.recv(collector) sequence += 1 kvmsg.sequence = sequence kvmsg.send(publisher) kvmsg.store(kvmap) print('I: publishing update %d' % sequence) # execute state snapshot request if snapshot in items: msg = snapshot.recv_multipart() identity = msg[0] request = msg[1] if request == 'ICANHAZ?': pass else: print('E: bad request, aborting\n') break # send state snapshot to clientdifference route = Route(snapshot, identity) # for each entry in kvmap, send kvmsg to client for k,v in kvmap.items(): send_single(k,v,route) # now send END message with sequence number print('sending state snapshot=%d\n' % sequence) snapshot.send(identity, zmq.SNDMORE) kvmsg = KVMsg(sequence) kvmsg.key = 'KTHXBAI' kvmsg.body = '' kvmsg.send(snapshot) print(' Interrupted\n%d messages handled' % sequence)
def main(): # context and sockets ctx = zmq.Context() snapshot = ctx.socket(zmq.ROUTER) snapshot.bind("tcp://*:5556") publisher = ctx.socket(zmq.PUB) publisher.bind("tcp://*:5557") collector = ctx.socket(zmq.PULL) collector.bind("tcp://*:5558") sequence = 0 kvmap = {} poller = zmq.Poller() poller.register(collector, zmq.POLLIN) poller.register(snapshot, zmq.POLLIN) while True: try: items = dict(poller.poll(1000)) except: break # Interrupted # Apply state update sent from client if collector in items: kvmsg = KVMsg.recv(collector) sequence += 1 kvmsg.sequence = sequence kvmsg.send(publisher) kvmsg.store(kvmap) print("I: publishing update %5d" % sequence) # Execute state snapshot request if snapshot in items: msg = snapshot.recv_multipart() identity = msg[0] request = msg[1] if request == b"ICANHAZ?": pass else: print("E: bad request, aborting\n", ) break # Send state snapshot to client route = Route(snapshot, identity) # For each entry in kvmap, send kvmsg to client for k, v in kvmap.items(): send_single(k, v, route) # Now send END message with sequence number print("Sending state shapshot=%d\n" % sequence, ) snapshot.send(identity, zmq.SNDMORE) kvmsg = KVMsg(sequence) kvmsg.key = b"KTHXBAI" kvmsg.body = b"" kvmsg.send(snapshot) print(" Interrupted\n%d messages handled" % sequence) dump_all(kvmap, 'pub.txt')
def main(): # context and sockets ctx = zmq.Context() snapshot = ctx.socket(zmq.ROUTER) snapshot.bind("tcp://*:5556") publisher = ctx.socket(zmq.PUB) publisher.bind("tcp://*:5557") collector = ctx.socket(zmq.PULL) collector.bind("tcp://*:5558") sequence = 0 kvmap = {} poller = zmq.Poller() poller.register(collector, zmq.POLLIN) poller.register(snapshot, zmq.POLLIN) while True: try: items = dict(poller.poll(1000)) except: break # Interrupted # Apply state update sent from client if collector in items: kvmsg = KVMsg.recv(collector) sequence += 1 kvmsg.sequence = sequence kvmsg.send(publisher) kvmsg.store(kvmap) print "I: publishing update %5d" % sequence # Execute state snapshot request if snapshot in items: msg = snapshot.recv_multipart() identity = msg[0] request = msg[1] if request == "ICANHAZ?": pass else: print "E: bad request, aborting\n", break # Send state snapshot to client route = Route(snapshot, identity) # For each entry in kvmap, send kvmsg to client for k, v in kvmap.items(): send_single(k, v, route) # Now send END message with sequence number print "Sending state shapshot=%d\n" % sequence, snapshot.send(identity, zmq.SNDMORE) kvmsg = KVMsg(sequence) kvmsg.key = "KTHXBAI" kvmsg.body = "" kvmsg.send(snapshot) print " Interrupted\n%d messages handled" % sequence
def send_event(self, eventType): msg = { 'type': 'eventReport', 'solution': self.solutionName, 'eventType': eventType, } sequence = 0 kvmsg = KVMsg(sequence) kvmsg.key = b"generic" kvmsg.body = json.dumps(msg).encode('utf-8') kvmsg.send(self.requestSocket)
def send_monitor_report(self, mon_type, value, unit): msg = { 'type': 'monitorReport', 'monitorType': mon_type, 'monitorValue': value, 'monitorUnit': unit, } sequence = 0 kvmsg = KVMsg(sequence) kvmsg.key = b"generic" kvmsg.body = json.dumps(msg).encode('utf-8') kvmsg.send(self.requestSocket)
def state_manager(ctx, pipe): '''This thread maintains the state and handles requests from clients for snapshots.''' kvmap = {} pipe.send("READY") snapshot = ctx.socket(zmq.ROUTER) snapshot.bind('tcp://*:5556') poller = zmq.Poller() poller.register(pipe, zmq.POLLIN) poller.register(snapshot, zmq.POLLIN) sequence = 0 while True: try: items = dict(poller.poll()) except (zmq.ZMQError, KeyboardInterrupt): break # appy state update from main thread if pipe in items: kvmsg = KVMsg.recv(pipe) sequence = kvmsg.sequence kvmsg.store(kvmap) # execute state snapshot request if snapshot in items: msg = snapshot.recv_multipart() identity = msg[0] request = msg[1] if request == 'ICANHAZ?': pass else: print 'E: bad request, aborting\n' break # send state snapshot to client route = Route(snapshot, identity) # for each entry in kvmap, send kvmsg to client for k, v in kvmap.items(): send_single(k, v, route) # now send END message with sequence number print 'Sending state snapshot=%d\n' % sequence snapshot.send(identity, zmq.SNDMORE) kvmsg = KVMsg(sequence) kvmsg.key = 'KTHXBAI' kvmsg.body = '' kvmsg.send(snapshot)
def state_manager(ctx, pipe): """This thread maintains the state and handles requests from clients for snapshots. """ kvmap = {} pipe.send("READY") snapshot = ctx.socket(zmq.ROUTER) snapshot.bind("tcp://*:5556") poller = zmq.Poller() poller.register(pipe, zmq.POLLIN) poller.register(snapshot, zmq.POLLIN) sequence = 0 # Current snapshot version number while True: try: items = dict(poller.poll()) except (zmq.ZMQError, KeyboardInterrupt): break # interrupt/context shutdown # Apply state update from main thread if pipe in items: kvmsg = KVMsg.recv(pipe) sequence = kvmsg.sequence kvmsg.store(kvmap) # Execute state snapshot request if snapshot in items: msg = snapshot.recv_multipart() identity = msg[0] request = msg[1] if request == "ICANHAZ?": pass else: print "E: bad request, aborting\n", break # Send state snapshot to client route = Route(snapshot, identity) # For each entry in kvmap, send kvmsg to client for k, v in kvmap.items(): send_single(k, v, route) # Now send END message with sequence number print "Sending state shapshot=%d\n" % sequence, snapshot.send(identity, zmq.SNDMORE) kvmsg = KVMsg(sequence) kvmsg.key = "KTHXBAI" kvmsg.body = "" kvmsg.send(snapshot)
def state_manager(ctx, pipe): """This thread maintains the state and handles requests from clients for snapshots. """ kvmap = {} pipe.send("READY") snapshot = ctx.socket(zmq.ROUTER) snapshot.bind("tcp://*:5556") poller = zmq.Poller() poller.register(pipe, zmq.POLLIN) poller.register(snapshot, zmq.POLLIN) sequence = 0 # Current snapshot version number while True: try: items = dict(poller.poll()) except (zmq.ZMQError, KeyboardInterrupt): break # interrupt/context shutdown # Apply state update from main thread if pipe in items: kvmsg = KVMsg.recv(pipe) sequence = kvmsg.sequence kvmsg.store(kvmap) # Execute state snapshot request if snapshot in items: msg = snapshot.recv_multipart() identity = msg[0] request = msg[1] if request == "ICANHAZ?": pass else: print "E: bad request, aborting\n", break # Send state snapshot to client route = Route(snapshot, identity) # For each entry in kvmap, send kvmsg to client for k,v in kvmap.items(): send_single(k,v,route) # Now send END message with sequence number print "Sending state shapshot=%d\n" % sequence, snapshot.send(identity, zmq.SNDMORE) kvmsg = KVMsg(sequence) kvmsg.key = "KTHXBAI" kvmsg.body = "" kvmsg.send(snapshot)
def register_solution(self): """ SETUP SOLUTION GLOBAL CONTROLLER CONNECTION This function is used to setup the connection with the experiment GUI, a ZMQ socket server is created on port 8500, able to receive command from GUI """ # Register solution to solution global controller # Activation Event # De - activation # Event List of monitoring parameters # List of control knobs / parameters # create the json format message msg = { "type": "registerRequest", "solution": self.solutionName, "commandList": self.commandList, "eventList": self.eventList } sequence = 1 kvmsg = KVMsg(sequence) kvmsg.key = b"generic" kvmsg.body = json.dumps(msg).encode('utf-8') # send the message kvmsg.send(self.requestSocket) # process the registerRespons try: kvmsg_reply = KVMsg.recv(self.requestSocket) except Exception: return False body = kvmsg_reply.body parsed_json = json.loads(body.decode("utf-8")) if "type" in parsed_json: mtype = parsed_json["type"] if mtype == "registerResponse": print("Received registration registerResponse") return True return False
def main(): # prepare our context and publisher socket ctx = zmq.Context() publisher = ctx.socket(zmq.PUB) publisher.bind('tcp://*:5556') time.sleep(0.2) random.seed(time.time()) kvmap = {} sequence = 0 try: while True: # distribute as key-value message sequence += 1 kvmsg = KVMsg(sequence) kvmsg.key = '%d' % random.randint(1, 10000) kvmsg.body = '%d' % random.randint(1, 1000000) kvmsg.send(publisher) kvmsg.store(kvmap) except KeyboardInterrupt: print ' Interrupted\n%d messages out' % sequence
def main(): # Prepare our context and publisher socket ctx = zmq.Context() publisher = ctx.socket(zmq.PUB) publisher.bind("tcp://*:5556") time.sleep(0.2) sequence = 0 seed(time.time()) kvmap = {} try: while True: # Distribute as key-value message sequence += 1 kvmsg = KVMsg(sequence) kvmsg.key = f"{randint(1, 10000):d}".encode() kvmsg.body = f"{randint(1, 1000000):d}".encode() kvmsg.send(publisher) kvmsg.store(kvmap) except KeyboardInterrupt: print(f"Interrupted\n{sequence} messages out")
def main(): # Prepare our context and publisher socket ctx = zmq.Context() publisher = ctx.socket(zmq.PUB) publisher.bind("tcp://*:5556") time.sleep(0.2) sequence = 0 random.seed(time.time()) kvmap = {} try: while True: # Distribute as key-value message sequence += 1 kvmsg = KVMsg(sequence) kvmsg.key = "%d" % random.randint(1,10000) kvmsg.body = "%d" % random.randint(1,1000000) kvmsg.send(publisher) kvmsg.store(kvmap) except KeyboardInterrupt: print " Interrupted\n%d messages out" % sequence
def main(): # Prepare our context and subscriber ctx = zmq.Context() snapshot = ctx.socket(zmq.DEALER) snapshot.linger = 0 snapshot.connect("tcp://localhost:5556") subscriber = ctx.socket(zmq.SUB) subscriber.linger = 0 subscriber.setsockopt(zmq.SUBSCRIBE, b'') subscriber.connect("tcp://localhost:5557") publisher = ctx.socket(zmq.PUSH) publisher.linger = 0 publisher.connect("tcp://localhost:5558") random.seed(time.time()) kvmap = {} # Get state snapshot sequence = 0 snapshot.send(b"ICANHAZ?") while True: try: kvmsg = KVMsg.recv(snapshot) except: return # Interrupted if kvmsg.key == b"KTHXBAI": sequence = kvmsg.sequence print("I: Received snapshot=%d" % sequence) break # Done kvmsg.store(kvmap) poller = zmq.Poller() poller.register(subscriber, zmq.POLLIN) alarm = time.time()+1. while True: tickless = 1000*max(0, alarm - time.time()) try: items = dict(poller.poll(tickless)) except: print('cli3 quitting') dump_all(kvmap, 'pub.txt') break # Interrupted if subscriber in items: kvmsg = KVMsg.recv(subscriber) # Discard out-of-sequence kvmsgs, incl. heartbeats if kvmsg.sequence > sequence: sequence = kvmsg.sequence kvmsg.store(kvmap) print("I: received update=%d" % sequence) # If we timed-out, generate a random kvmsg if time.time() >= alarm: kvmsg = KVMsg(0) kvmsg.key = ("%d" % random.randint(0,9999)).encode() kvmsg.body = ("%d" % random.randint(0,999999)).encode() kvmsg.send(publisher) kvmsg.store(kvmap) alarm = time.time() + 1. print(" Interrupted\n%d messages in" % sequence)
def state_manager(ctx, pipe): """This thread maintains the state and handles requests from clients for snapshots. """ kvmap = {} pipe.send(b"READY") snapshot = ctx.socket(zmq.ROUTER) snapshot.bind("tcp://*:5556") poller = zmq.Poller() poller.register(pipe, zmq.POLLIN) poller.register(snapshot, zmq.POLLIN) sequence = 0 # Current snapshot version number while True: try: items = dict(poller.poll()) except (zmq.ZMQError, KeyboardInterrupt): dump_all(kvmap, 'pub.txt') print('pub: interrupted') break # interrupt/context shutdown # Apply state update from main thread if pipe in items: parts = pipe.recv_multipart() if len(parts) == 1: assert parts[0] == b'QUIT' print('quitting') dump_all(kvmap, 'pub.txt') break key, seq_s, body = parts key = key if key else None seq = struct.unpack('!l', seq_s)[0] body = body if body else None kvmsg = KVMsg(seq, key=key, body=body) sequence = kvmsg.sequence kvmsg.store(kvmap) # Execute state snapshot request if snapshot in items: msg = snapshot.recv_multipart() identity = msg[0] request = msg[1] if request == b"ICANHAZ?": pass else: print("E: bad request, aborting\n", ) break # Send state snapshot to client route = Route(snapshot, identity) # For each entry in kvmap, send kvmsg to client for k, v in kvmap.items(): send_single(k, v, route) # Now send END message with sequence number print("Sending state shapshot=%d\n" % sequence, ) snapshot.send(identity, zmq.SNDMORE) kvmsg = KVMsg(sequence) kvmsg.key = b"KTHXBAI" kvmsg.body = b"" kvmsg.send(snapshot)
def main(): # Prepare our context and subscriber ctx = zmq.Context() snapshot = ctx.socket(zmq.DEALER) snapshot.linger = 0 snapshot.connect("tcp://localhost:5556") subscriber = ctx.socket(zmq.SUB) subscriber.linger = 0 subscriber.setsockopt(zmq.SUBSCRIBE, SUBTREE) subscriber.connect("tcp://localhost:5557") publisher = ctx.socket(zmq.PUSH) publisher.linger = 0 publisher.connect("tcp://localhost:5558") random.seed(time.time()) kvmap = {} # Get state snapshot sequence = 0 snapshot.send_multipart(["ICANHAZ?", SUBTREE]) while True: try: kvmsg = KVMsg.recv(snapshot) except: raise return # Interrupted if kvmsg.key == "KTHXBAI": sequence = kvmsg.sequence print "I: Received snapshot=%d" % sequence break # Done kvmsg.store(kvmap) poller = zmq.Poller() poller.register(subscriber, zmq.POLLIN) alarm = time.time()+1. while True: tickless = 1000*max(0, alarm - time.time()) try: items = dict(poller.poll(tickless)) except: break # Interrupted if subscriber in items: kvmsg = KVMsg.recv(subscriber) # Discard out-of-sequence kvmsgs, incl. heartbeats if kvmsg.sequence > sequence: sequence = kvmsg.sequence kvmsg.store(kvmap) print "I: received update=%d" % sequence # If we timed-out, generate a random kvmsg if time.time() >= alarm: kvmsg = KVMsg(0) kvmsg.key = SUBTREE + "%d" % random.randint(1,10000) kvmsg.body = "%d" % random.randint(1,1000000) kvmsg.send(publisher) kvmsg.store(kvmap) alarm = time.time() + 1. print " Interrupted\n%d messages in" % sequence
def main(): ctx = zmq.Context() snapshot = ctx.socket(zmq.DEALER) snapshot.linger = 0 snapshot.connect('tcp://localhost:5556') subscriber = ctx.socket(zmq.SUB) subscriber.linger = 0 subscriber.setsockopt(zmq.SUBSCRIBE, '') subscriber.connect('tcp://localhost:5557') publisher = ctx.socket(zmq.PUSH) publisher.linger = 0 publisher.connect('tcp://localhost:5558') random.seed(time.time()) kvmap = {} # get state snapshot sequence = 0 snapshot.send('ICANHAZ?') while True: # prijme snapshot, celu kv-mapu (jedna sprava, jeden riadok) try: kvmsg = KVMsg.recv(snapshot) except: return if kvmsg.key == 'KTHXBAI': sequence = kvmsg.sequence print('I: received snapshot=%d' % sequence) break kvmsg.store(kvmap) poller = zmq.Poller() poller.register(subscriber, zmq.POLLIN) alarm = time.time() + 1 while True: tickless = 1000 * max(0, alarm - time.time()) try: items = dict(poller.poll(tickless)) except: break if subscriber in items: kvmsg = KVMsg.recv(subscriber) # discard out-of-sequence kvmsgs, incl. heartbeats if kvmsg.sequence > sequence: sequence = kvmsg.sequence kvmsg.store(kvmap) print('I: received update=%d' % sequence) if time.time( ) > alarm: # kazdu 1s vytvorim novy kluc a uploadnem ho na server (PUSH socket) kvmsg = KVMsg(0) kvmsg.key = '%d' % random.randint(1, 10000) kvmsg.body = '%d' % random.randint(1, 1000000) kvmsg.send(publisher) kvmsg.store(kvmap) alarm = time.time() + 1 print(' Interrupted\n%d message in' % sequence)
def main(): # Prepare our context and subscriber ctx = zmq.Context() snapshot = ctx.socket(zmq.DEALER) snapshot.linger = 0 snapshot.connect("tcp://localhost:5556") subscriber = ctx.socket(zmq.SUB) subscriber.linger = 0 subscriber.setsockopt(zmq.SUBSCRIBE, SUBTREE) subscriber.connect("tcp://localhost:5557") publisher = ctx.socket(zmq.PUSH) publisher.linger = 0 publisher.connect("tcp://localhost:5558") random.seed(time.time()) kvmap = {} # Get state snapshot sequence = 0 snapshot.send_multipart([b"ICANHAZ?", SUBTREE]) while True: try: kvmsg = KVMsg.recv(snapshot) except: raise return # Interrupted if kvmsg.key == b"KTHXBAI": sequence = kvmsg.sequence print(f"I: Received snapshot={sequence:d}") break # Done kvmsg.store(kvmap) poller = zmq.Poller() poller.register(subscriber, zmq.POLLIN) alarm = time.time() + 1 while True: tickless = 1000 * max(0, alarm - time.time()) try: items = dict(poller.poll(tickless)) except: break # Interrupted if subscriber in items: kvmsg = KVMsg.recv(subscriber) # Discard out-of-sequence kvmsgs, incl. heartbeats if kvmsg.sequence > sequence: sequence = kvmsg.sequence kvmsg.store(kvmap) print(f"I: received update={sequence:d}") # If we timed-out, generate a random kvmsg if time.time() >= alarm: kvmsg = KVMsg(0) kvmsg.key = SUBTREE + str(random.randint(1, 10000)).encode() kvmsg.body = str(random.randint(1, 1000000)).encode() kvmsg.send(publisher) kvmsg.store(kvmap) alarm = time.time() + 1 print(f"Interrupted\n{sequence:d} messages in")