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://*: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():
# 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():
# 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():
# 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")
kvmap = {}
# Get state snapshot
sequence = 0
snapshot.send(b"ICANHAZ?")
while True:
try:
kvmsg = KVMsg.recv(snapshot)
except:
break
# Interrupted
if kvmsg.key == b"KTHXBAI":
sequence = kvmsg.sequence
print("Received snapshot=%d" % sequence)
break # Done
kvmsg.store(kvmap)
# Now apply pending updates, discard out-of-sequence messages
while True:
try:
kvmsg = KVMsg.recv(subscriber)
except:
break # Interrupted
if kvmsg.sequence > sequence:
sequence = kvmsg.sequence
kvmsg.store(kvmap)
else:
print('dropped duplicates', kvmsg.sequence)
print('quiting')
dump_all(kvmap, 'sub.txt')
def main():
# prepare our context for 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, '')
subscriber.connect('tcp://localhost:5557')
kvmap = {}
# get state snapshot
sequence = 0
snapshot.send('ICANHAZ?')
while True:
try:
kvmsg = KVMsg.recv(snapshot)
except KeyboardInterrupt:
break
if kvmsg.key == 'KTHXBAI':
sequence = kvmsg.sequence
print 'Received snapshot = %d' % sequence
break # done
kvmsg.store(kvmap)
print 'state snapshot received'
# now apply pending updates, discard out-of-sequence messages
while True:
try:
kvmsg = KVMsg.recv(subscriber)
except KeyboardInterrupt:
break
if kvmsg.sequence > sequence:
sequence = kvmsg.sequence
kvmsg.store(kvmap)
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 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, '')
subscriber.connect("tcp://localhost:5557")
kvmap = {}
# Get state snapshot
sequence = 0
snapshot.send("ICANHAZ?")
while True:
try:
kvmsg = KVMsg.recv(snapshot)
except:
break; # Interrupted
if kvmsg.key == "KTHXBAI":
sequence = kvmsg.sequence
print "Received snapshot=%d" % sequence
break # Done
kvmsg.store(kvmap)
# Now apply pending updates, discard out-of-sequence messages
while True:
try:
kvmsg = KVMsg.recv(subscriber)
except:
break # Interrupted
if kvmsg.sequence > sequence:
sequence = kvmsg.sequence
kvmsg.store(kvmap)
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 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 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 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 main():
# Prepare our context and publisher socket
ctx = zmq.Context()
updates = ctx.socket(zmq.SUB)
updates.linger = 0
updates.setsockopt(zmq.SUBSCRIBE, '')
updates.connect("tcp://localhost:5556")
kvmap = {}
sequence = 0
while True:
try:
kvmsg = KVMsg.recv(updates)
except:
break # Interrupted
kvmsg.store(kvmap)
sequence += 1
print "Interrupted\n%d messages in" % sequence
def main():
ctx = zmq.Context()
updates = ctx.socket(zmq.SUB)
updates.linger = 0
updates.setsockopt(zmq.SUBSCRIBE, '')
updates.connect('tcp://localhost:5556')
kvmap = {}
sequence = 0
while True:
try:
kvmsg = KVMsg.recv(updates)
except KeyboardInterrupt:
break # interrupted
kvmsg.store(kvmap)
sequence += 1
print 'Interrupted\n%d messages in' % sequence
def main():
# Prepare our context and publisher socket
ctx = zmq.Context()
updates = ctx.socket(zmq.SUB)
updates.linger = 0
updates.setsockopt(zmq.SUBSCRIBE, '')
updates.connect("tcp://localhost:5556")
kvmap = {}
sequence = 0
while True:
try:
kvmsg = KVMsg.recv(updates)
except:
break # Interrupted
kvmsg.store(kvmap)
sequence += 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("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 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 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 command_subscriber(self):
while True:
try:
kvmsg = KVMsg.recv(self.subSocket)
mdict = kvmsg.body.decode('utf-8')
mdict = json.loads(mdict)
involvedSolutions = mdict.get("involvedSolutions", [])
if self.solutionName in involvedSolutions:
commandList = mdict.get("commandList", [])
if isinstance(commandList, str):
commandList = [commandList]
for cmd in commandList:
if cmd in self.commands:
print("Execute command:", cmd)
function = self.commands[cmd]
function()
except KeyboardInterrupt:
return
except Exception:
break # Interrupted
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([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")
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)
