def Run():
try:
print "Running web server on port: "+str(Config["Web server"]["Port"])
sessionsManager = SessionsManager()
socket = zmq.Context.instance().socket(zmq.SUB)
socket.bind("tcp://*:"+str(Config["Web server"]["IncomingZmqPort"]))
socket.setsockopt(zmq.SUBSCRIBE, "")
stream = ZMQStream(socket)
stream.on_recv(sessionsManager.ProcessZmqMessages)
settings = {
"debug" : False,
"template_path":os.path.join(os.path.dirname(__file__), "../Frontend"),
}
app = tornado.web.Application([
(r'/Static/(.*)', tornado.web.StaticFileHandler, {'path': os.path.join(os.path.dirname(__file__), "../Frontend/Static")}),
(r'/Tmp/(.*)', tornado.web.StaticFileHandler, {'path': Config["Web server"]["Temporary files folder"]}),
(r'/RCP', IndexHandler),
(r'/RCP/', IndexHandler),
(r'/StreamsTree/(.*)', StreamsTreeRequestHandler, dict(sessionsManager=sessionsManager)),
(r'/WebSockets/', WebSocketHandler, dict(sessionsManager=sessionsManager)),
], **settings)
periodic = ioloop.PeriodicCallback(CheckServerStopRequests, 500)
periodic.start()
app.listen(Config["Web server"]["Port"])
tornado.ioloop.IOLoop.instance().start()
except:
print traceback.format_exc()
def enable_depth_frames(self, kinect_id):
"""Enable streaming of depth frames. *kinect_id* is the id of the
device which should have streaming enabled.
:raises ValueError: if *kinect_id* does not correspond to a connected device
"""
try:
record = self._kinect_records[kinect_id]
except KeyError:
raise ValueError('Kinect id "{0}" does not correspond to a connected device'.format(
kinect_id))
# Create subscriber stream
socket = self._zmq_ctx.socket(zmq.SUB)
socket.connect(record.endpoints[EndpointType.depth])
socket.setsockopt_string(zmq.SUBSCRIBE, u'')
stream = ZMQStream(socket, self._io_loop)
record.streams[EndpointType.depth] = stream
# Fire signal on incoming depth frame
def on_recv(msg, kinect_id=kinect_id):
# TODO: decompress frame
self.on_depth_frame.send(self, kinect_id=kinect_id, depth_frame=msg)
# Wire up callback
stream.on_recv(on_recv)
class Connection(object):
"""The base class for the connection between node and master
"""
def __init__(self, endpoint):
self.endpoint = endpoint
# init zeromq
self.context = zmq.Context()
self.socket = self.context.socket(zmq.REQ)
self.stream = ZMQStream(self.socket)
self.stream.on_recv(self.OnRecvMsg)
# get local endpoint
self.socket.bind("tcp://eth0:*")
self.local_endpoint = str(self.socket.getsockopt(zmq.LAST_ENDPOINT))
print "Local endpoint [%s]" % self.local_endpoint
# connect to target
self.socket.connect(endpoint)
print "Connected to [%s]" % endpoint
def SendMsg(self, msg):
self.socket.send(msg, copy=False)
print "Sending message [%s]" % msg
#msg_rsp = self.socket.recv( copy = False )
#print "Receiving message [%s]" % msg_rsp
def OnRecvMsg(self, msg):
#msg_rsp = self.socket.recv( copy = False )
#print "Receiving message [%s]" % msg_rsp
print "Receiving message ========== [%s]" % msg
def GetLocalEndpoint(self):
return self.local_endpoint
def GetEndpoint(self):
return self.endpoint
def run(self):
if self.filename == 'sys.stdout':
self.file = sys.stdout
elif self.filename == 'sys.stderr':
self.file = sys.stderr
else:
self.file = open(self.filename, 'a+b')
ioloop.install()
loop = ioloop.IOLoop.instance()
stream = None
try:
context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect(self.addr)
socket.setsockopt(zmq.SUBSCRIBE, '')
stream = ZMQStream(socket)
except Exception, err:
print self.name, 'error getting outstream:', err
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
traceback.print_tb(exc_traceback, limit=30)
if stream and not stream.closed():
stream.close()
class SoundServer(object):
def __init__(self):
self._context = zmq.Context()
self._socket = self._context.socket(zmq.REP)
self._socket.bind('tcp://127.0.0.1:{0}'.format(CONTROL_PORT))
self._stream = ZMQStream(self._socket)
self._stream.on_recv(self._handle_msg)
def start(self):
IOLoop.instance().start()
def _handle_msg(self, msg):
method = '_handler_{0}'.format(msg[0].decode("utf-8"))
try:
print("Trying method {0}".format(method))
getattr(self, method)()
except AttributeError:
sys.exit(1)
def _handler_hi(self):
self._socket.send_string('sup?')
def _handler_exit(self):
pass
class InternalRouter(object):
def __init__(self, context):
socket = context.socket(zmq.ROUTER)
socket.setsockopt(zmq.LINGER, 0)
identity = 'router'
socket.identity = identity.encode('ascii')
session = Session()
router_internal = session.query(RoutingDefiniton.route) \
.filter_by(name="internal_router") \
.scalar()
session.close()
socket.bind(router_internal)
ioloop = IOLoop.instance()
self.internal_router = ZMQStream(socket, ioloop)
self.internal_router.on_recv(callback=self.router_recv)
return
def shutdown(self):
self.internal_router.on_recv(callback=None)
self.internal_router = None
return
def router_recv(self, msg):
return
def main(pat):
fname = find_connection_file(pat)
with open(fname) as f:
cfg = json.load(f)
url = "%s://%s:%s" % (cfg.get('transport', 'tcp'), cfg['ip'], cfg['iopub_port'])
session = Session(key=cfg['key'])
ctx = zmq.Context.instance()
sub = ctx.socket(zmq.SUB)
sub.subscribe = b''
sub.connect(url)
# import IPython
# IPython.embed()
# return
stream = ZMQStream(sub)
stream.on_recv(lambda msg_list: log_msg(session, msg_list))
pc = PeriodicCallback(print_time, 5 * 60 * 1000)
pc.start()
IOLoop.instance().start()
def main():
import sys
from PyQt4 import QtGui, Qt
from eventloop import QtLoop, ZMQLoop
from kernel import Kernel
from epubsub.hub import Hub
import zmq
from zmq.eventloop.zmqstream import ZMQStream
def callback(stream, msg):
print msg
stream.send('OK')
print 'running'
#app = QtGui.QApplication(sys.argv)
loop = ZMQLoop()
loop.install()
kernel = Kernel()
ctx = zmq.Context()
socket = ctx.socket(zmq.ROUTER)
socket.bind('tcp://127.0.0.1:11111')
stream = ZMQStream(socket)
stream.on_recv_stream(callback)
loop.start()
class UartzStream(object):
def __init__(self, addr, io_loop=None):
self.addr = addr
self.ioloop = io_loop
self.stream = None
self.reset_stream()
def reset_stream(self):
ctx = zmq.Context.instance()
sock = ctx.socket(zmq.SUB)
sock.connect(self.addr)
sock.setsockopt(zmq.SUBSCRIBE, b'')
self.stream = ZMQStream(sock, self.ioloop)
self.stream.on_recv(self._handle_msg)
def _handle_msg(self, msg):
assert len(msg) == 1
msg = msg[0]
chan_idx = msg.index(b":")
assert chan_idx > 0
self.handle_msg(UartzMsg(dev=msg[:chan_idx],
msg=msg[chan_idx + 1:]))
def __init__(self, port=5556):
self.port = port
self.ctx = zmq.Context()
self.kvmap = {}
self.loop = IOLoop.instance()
# Set up our clone server sockets
self.snapshot = self.ctx.socket(zmq.ROUTER)
self.publisher = self.ctx.socket(zmq.PUB)
self.collector = self.ctx.socket(zmq.PULL)
self.snapshot.bind("tcp://*:%d" % self.port)
self.publisher.bind("tcp://*:%d" % (self.port + 1))
self.collector.bind("tcp://*:%d" % (self.port + 2))
# Wrap sockets in ZMQStreams for IOLoop handlers
self.snapshot = ZMQStream(self.snapshot)
self.publisher = ZMQStream(self.publisher)
self.collector = ZMQStream(self.collector)
# Register our handlers with reactor
self.snapshot.on_recv(self.handle_snapshot)
self.collector.on_recv(self.handle_collect)
self.flush_callback = PeriodicCallback(self.flush_ttl, 1000)
# basic log formatting:
logging.basicConfig(format="%(asctime)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S",
level=logging.INFO)
class LRUQueue(object):
def __init__(self, backend_socket, frontend_socket, clients, workers):
self.avaliable_workers = 0
self.workers = []
self.worker_num = workers
self.client_num = clients
self.backend = ZMQStream(backend_socket)
self.frontend = ZMQStream(frontend_socket)
self.backend.on_recv(self.handle_backend)
self.loop = IOLoop.instance()
def handle_backend(self, msg):
worker_addr, empty, client_addr = msg[:3]
assert self.avaliable_workers < self.worker_num
self.avaliable_workers += 1
self.workers.append(worker_addr)
assert empty == ""
if client_addr != "READY":
empty, reply = msg[3:]
assert empty == ""
self.frontend.send_multipart([client_addr, "", reply])
self.client_num -= 1
if 0 == self.client_num:
self.loop.add_timeout(time.time() + 1, self.loop.stop)
if self.avaliable_workers == 1:
self.frontend.on_recv(self.handle_frontend)
def handle_frontend(self, msg):
client_addr, empty, request = msg
assert empty == ""
self.avaliable_workers -= 1
worker_id = self.workers.pop()
self.backend.send_multipart([worker_id, "", client_addr, "", request])
if self.avaliable_workers == 0:
self.frontend.stop_on_recv()
class ZBus(object):
def __init__(self):
self._context = zmq.Context()
self._callback = {}
self._zstream = None
@staticmethod
def instance():
if not hasattr(ZBus, '_instance'):
ZBus._instance = ZBus()
return ZBus._instance
@staticmethod
def initialized():
return hasattr(ZBus, '_instance')
def connect(self, dist):
if self._zstream:
self._zstream.close()
self._zsock = self._context.socket(zmq.XREQ)
self._zsock.connect('tcp://{dist}'.format(dist=dist))
self._zstream = ZMQStream(self._zsock)
self._zstream.on_recv(self.on_recv)
def send(self, request, callback):
self._callback[request.seed_id] = callback
self._zstream.send_multipart(request.box())
def on_recv(self, frame):
response = ZResponse(frame)
callback = self._callback.pop(response.seed_id) if self._callback.get(response.seed_id) else None
if callback and callable(callback):
callback(response)
class Subscriber(object):
def __init__(self, context, sub_address, sub_topics):
self.context = context
self.subscriber_address = sub_address
self.subscriber_topics = sub_topics
socket = self.context.socket(zmq.SUB)
ioloop = IOLoop.instance()
self.subscriber = ZMQStream(socket, ioloop)
self.subscriber.setsockopt(zmq.LINGER, 0)
self.subscriber.on_recv(callback=self.subscriber_recv)
self.subscriber.setsockopt(zmq.SUBSCRIBE, "")
self.subscriber.connect(self.subscriber_address)
return
def shutdown(self):
self.subscriber.on_recv(callback=None)
self.subscriber.socket.disconnect(self.subscriber_address)
self.subscriber = None
return
def subscriber_recv(self, msg):
return
def __init__(self, robot,
data_in_sock='ipc:///tmp/robot-data-m2w.sock',
data_out_sock='ipc:///tmp/robot-data-w2m.sock',
msg_in_sock='ipc:///tmp/robot-msg-m2w.sock',
msg_out_sock='ipc:///tmp/robot-msg-w2m.sock',
io_loop=None):
self.identity = 'worker:%s:%s' % (socket.gethostname(), os.getpid())
context = zmq.Context()
self._io_loop = io_loop or IOLoop.instance()
self._in_socket = context.socket(zmq.PULL)
self._in_socket.connect(data_in_sock)
self._in_stream = ZMQStream(self._in_socket, io_loop)
self._out_socket = context.socket(zmq.PUB)
self._out_socket.connect(data_out_sock)
self._out_stream = ZMQStream(self._out_socket, io_loop)
self._running = False
self.robot = robot
self.robot.set_worker_identity(self.identity)
self.messenger = ClientMessenger(msg_in_sock, msg_out_sock,
context, io_loop)
def __init__(self, context, main_ep, opt_ep=None, worker_q=None):
"""Init MDPBroker instance.
"""
socket = context.socket(zmq.XREP)
socket.bind(main_ep)
self.main_stream = ZMQStream(socket)
self.main_stream.on_recv(self.on_message)
if opt_ep:
socket = context.socket(zmq.XREP)
socket.bind(opt_ep)
self.client_stream = ZMQStream(socket)
self.client_stream.on_recv(self.on_message)
else:
self.client_stream = self.main_stream
self._workers = {}
# services contain the worker queue and the request queue
self._services = {}
self._worker_cmds = { '\x01': self.on_ready,
'\x03': self.on_reply,
'\x04': self.on_heartbeat,
'\x05': self.on_disconnect,
}
self.hb_check_timer = PeriodicCallback(self.on_timer, HB_INTERVAL)
self.hb_check_timer.start()
return
def __init__(self, context, front, back, top=True):
self.workers = WorkerQueue()
self.loop = IOLoop.instance()
self.liveness = HEARTBEAT_LIVENESS
self.heartbeat = HEARTBEAT_INTERVAL
self.interval = INTERVAL_INIT
self.time = self.interval * self.heartbeat
self.heartbeat_at = time.time() + self.heartbeat * HEARTBEAT_LIVENESS
self.callback = None
self.timed_out = False
self.hearbeats = 0
if top:
self.frontend_socket = context.socket(zmq.ROUTER)
self.frontend_socket.bind(url_str(front,True))
else:
self.frontend_socket = context.socket(zmq.DEALER)
self.frontend_socket.connect(url_str(front))
self.frontend.send(PPP_READY)
self.backend_socket = context.socket(zmq.ROUTER)
self.backend_socket.bind(url_str(back,True))
self.frontend = ZMQStream(self.frontend_socket)
self.backend = ZMQStream(self.backend_socket)
self.start()
def __init__(self, front_end_name, back_end_name, loop):
'''
Initializes an instance of LocalRequestProxy
@param front_end_name - name of the front end socket. It will be
initialized with the Router socket.
@param back_end_name - name of the back end socket. It will be
initialized with the Dealer socket.
@param loop - zmq IOLoop
'''
self._loop = loop
ctx = zmq.Context.instance()
# Create the front end stream
front_address = ZmqAddress(chan_name=front_end_name, transport=INPROC)
self._front_end = ZMQStream(ctx.socket(zmq.ROUTER), io_loop=loop)
self._front_end.setsockopt(zmq.ROUTER_MANDATORY, 1)
self._front_end.bind(front_address.zmq_url())
# Create the back end stream
back_address = ZmqAddress(chan_name=back_end_name)
self._back_end = ZMQStream(ctx.socket(zmq.DEALER), io_loop=loop)
self._back_end.connect(back_address.zmq_url())
def callback(from_name, to_name, zmq_stream, msgs):
log.debug("Routing from {0} to {1} messages {2}"
.format(from_name, to_name, msgs))
zmq_stream.send_multipart(msgs)
zmq_stream.flush()
self._front_end.on_recv(lambda msgs:
callback(front_end_name, back_end_name, self._back_end, msgs))
self._back_end.on_recv(lambda msgs:
callback(back_end_name, front_end_name, self._front_end, msgs))
def __init__(self, settings, identity, insocket, outsocket, mgmt, frontier,
log_handler, log_level, io_loop):
"""
Initialize the master.
"""
LoggingMixin.__init__(self, log_handler, log_level)
self._identity = identity
self._io_loop = io_loop or IOLoop.instance()
self._in_stream = ZMQStream(insocket, io_loop)
self._out_stream = ZMQStream(outsocket, io_loop)
self._mgmt = mgmt
self._frontier = frontier
self._running = False
self._available_workers = []
# periodically check if there are pending URIs to crawl
self._periodic_update = PeriodicCallback(self._send_next_uri,
settings.MASTER_PERIODIC_UPDATE_INTERVAL, io_loop=io_loop)
# start this periodic callback when you are waiting for the workers to
# finish
self._periodic_shutdown = PeriodicCallback(self._shutdown_wait, 500,
io_loop=io_loop)
self._shutdown_counter = 0
self._logger.debug("zmqmaster::initialized")
class SwysSearchRequestHandler(BaseHandler):
def initialize(self):
socket = context.socket(zmq.REQ)
socket.connect(conf.SEARCH_WORKER_ZMQ_ENDPOINT)
self._zmq_stream = ZMQStream(socket)
self._zmq_stream.on_recv(self._recv_result, copy=True)
@tornado.web.asynchronous
def handle_request_async(self, *args, **kwargs):
files = self.request.files.get('image', [])
if len(files) == 0:
raise Exception("there is no file attached")
file = files[0]
temp_file = tempfile.NamedTemporaryFile('wb', delete=False)
temp_file.write(file.body)
self._zmq_stream.send_json({'filename': temp_file.name})
def _recv_result(self, msg):
result_str = "".join(( part.decode('utf-8') for part in msg ))
result = json.loads(result_str)['data']
return self.on_complete(result)
class MonitorEvents(SockJSConnection):
def _zmq_msg(self, msg):
#logging.debug(msg)
try:
msg_obj = json.loads(msg[0])
logging.debug(msg_obj)
if self.monitor != 'All':
if 'mon_id' in msg_obj and msg_obj['mon_id'] == self.monitor:
self.send(msg_obj)
else:
self.send(msg_obj)
except Exception as ex:
logging.error(ex)
def on_open(self, info):
logging.debug("Monitor ticker open: "+self.monitor)
zmq_socket = zmq.Context.instance().socket(zmq.SUB)
zmq_socket.connect(zmq_local_endpoint)
zmq_socket.setsockopt(zmq.SUBSCRIBE, '')
self.stream = ZMQStream(zmq_socket)
self.stream.on_recv(self._zmq_msg)
def on_close(self):
logging.debug("Monitor ticker close: "+self.monitor)
self.stream.stop_on_recv()
def start(self):
identifier = self.identifier
job = self.job
def execute_next(msg):
# We can't use zodb object from outside here because
# this code is executed in another thread (eventloop)
# We don't have site or interaction, so the job must be created
# before.
# we can't use push_event_callback_after_commit here because
# it will never commit in this thread (eventloop)
if identifier in callbacks:
callbacks[identifier].close()
del callbacks[identifier]
job.args = (msg, )
# wait 2s that the throw event transaction has committed
dc = DelayedCallback(job, 2000)
dc.start()
ctx = get_zmq_context()
s = ctx.socket(zmq.SUB)
s.setsockopt_string(zmq.SUBSCRIBE, u'')
s.connect(get_signal_socket_url())
stream = ZMQStream(s)
callbacks[identifier] = stream
stream.on_recv(execute_next)
def __init__(self, broker, service, io_loop=None):
"""Create and setup an MDP worker.
@param broker A string containing the broker's URL
@param service A string containing the service name
@param io_loop An existing I/O loop object. If None, the default will be used.
"""
self.service=service
self._broker = broker
self.ctx = zmq.Context()
sock = self.ctx.socket(zmq.DEALER)
ZMQStream.__init__(self, sock, io_loop)
# last watchdog timer tick
self.watchdog = 0
# connection callback one-shot
self._conncb = DelayedCallback(self.send_ready, 3000, self.io_loop)
# heartbeat callback..runs continuous when connected
self._hbcb = PeriodicCallback(self.send_heartbeat, 2000, self.io_loop)
# number of connection attempts
self._conn_attempt = 0
# waiting to connect state
self._waiting_to_connect = True
# have we been disconnected? (flags a reconnect attempt)
self.disconnected = False
# connect the socket and send a READY when the io_loop starts
self.connect(self._broker)
self._conncb.start()
def __init__(self, frontier,
data_in_sock='ipc:///tmp/robot-data-w2m.sock',
data_out_sock='ipc:///tmp/robot-data-m2w.sock',
msg_in_sock='ipc:///tmp/robot-msg-w2m.sock',
msg_out_sock='ipc:///tmp/robot-msg-m2w.sock',
io_loop=None):
self.identity = 'master:%s:%s' % (socket.gethostname(), os.getpid())
context = zmq.Context()
self._io_loop = io_loop or IOLoop.instance()
self._in_socket = context.socket(zmq.SUB)
self._in_socket.setsockopt(zmq.SUBSCRIBE, '')
self._in_socket.bind(data_in_sock)
self._in_stream = ZMQStream(self._in_socket, io_loop)
self._out_socket = context.socket(zmq.PUSH)
self._out_socket.bind(data_out_sock)
self._out_stream = ZMQStream(self._out_socket, io_loop)
self._online_workers = set()
self._running = False
self._updater = PeriodicCallback(self._send_next, 100, io_loop=io_loop)
self._reloader = PeriodicCallback(self.reload, 1000, io_loop=io_loop)
self.frontier = frontier
self.messenger = ServerMessenger(msg_in_sock, msg_out_sock,
context, io_loop)
def connect_stream(self, sname, zmq_channel):
socket = self.context.socket(zmq_channel.socket_type)
if zmq_channel.bind:
socket.bind(zmq_channel.endpoint)
if zmq_channel.socket_type == zmq.SUB:
# Workaround for https://zeromq.jira.com/browse/LIBZMQ-270
socket.getsockopt(zmq.EVENTS)
else:
socket.connect(zmq_channel.endpoint)
if zmq_channel.socket_type == zmq.SUB and zmq_channel.subscription:
for prefix in zmq_channel.subscription:
socket.setsockopt(zmq.SUBSCRIBE, prefix.encode('utf8'))
stream = ZMQStream(socket, io_loop=self.loop)
stream.channel_name = sname
# Wire up any defined handlers
self.init_recv(sname, stream)
tname = SOCKET_TYPES[zmq_channel.socket_type]
ctype = 'Bound' if zmq_channel.bind else 'Connected'
self.logger.debug("%s %s stream to address %s",
ctype, tname, zmq_channel.endpoint)
self.streams[sname] = stream
def __init__(self, context, main_ep, opt_ep=None):
"""Init MDPBroker instance.
"""
l = logger.Logger('mq_broker')
self.log = l.get_logger()
self.log.info("MDP broker startup...")
socket = ZmqSocket(context, zmq.ROUTER)
socket.bind(main_ep)
self.main_stream = ZMQStream(socket)
self.main_stream.on_recv(self.on_message)
if opt_ep:
socket = ZmqSocket(context, zmq.ROUTER)
socket.bind(opt_ep)
self.client_stream = ZMQStream(socket)
self.client_stream.on_recv(self.on_message)
else:
self.client_stream = self.main_stream
self.log.debug("Socket created...")
self._workers = {}
# services contain the worker queue and the request queue
self._services = {}
self._worker_cmds = { b'\x01': self.on_ready,
b'\x03': self.on_reply,
b'\x04': self.on_heartbeat,
b'\x05': self.on_disconnect,
}
self.log.debug("Launch the timer...")
self.hb_check_timer = PeriodicCallback(self.on_timer, HB_INTERVAL)
self.hb_check_timer.start()
self.log.info("MDP broker started")
return
class SocketConnection(sockjs.tornado.SockJSConnection):
clients = set()
def on_open(self, request):
self.clients.add(self)
subscriber = context.socket(zmq.SUB)
subscriber.connect("tcp://localhost:%s" % str(ZMQ_PORT))
subscriber.setsockopt(zmq.SUBSCRIBE, '')
self.subscribe_stream = ZMQStream(subscriber)
self.subscribe_stream.on_recv(self.on_message_published)
def on_message(self, message):
logging.info(
'message received, publish it to %d clients' % len(self.clients)
)
publish_stream.send_unicode(message)
def on_message_published(self, message):
logging.info('client received new published message')
self.send(message)
def on_close(self):
self.clients.remove(self)
# Properly close ZMQ socket
self.subscribe_stream.close()
class DevPort(object):
def __init__(self, card, depth, rate):
self.card = card
self.depth = depth
self.rate = rate
self.running = False
context = zmq.Context()
self.prog_socket = context.socket(zmq.PUB)
self.prog_socket.connect('ipc:///tmp/progressIn.ipc')
self.prog_stream = ZMQStream(self.prog_socket, IOLoop.instance())
self.scheduleProgress()
self.peak_socket = context.socket(zmq.PUB)
self.peak_socket.bind('ipc:///tmp/peaks.ipc')
self.peak_stream = ZMQStream(self.peak_socket, IOLoop.instance())
self.sendPeaks()
def startRecording(self, path):
self.curPath = path
self.started = time()
self.running = True
def stopRecording(self):
self.running = False
def resetPeaks(self):
pass
def stop(self):
self.stopRecording()
def waitTillFinished(self):
pass
def gotSignal(self):
return True
def sendProgress(self):
duration = 0
mode = 0
if self.running:
duration = int((time() - self.started) * self.rate)
mode = 1
d = {'t':duration, 'm': mode, 'b' : 0 }
s = json.dumps(d)
self.prog_stream.send(s)
IOLoop.instance().add_timeout(time() + .333, self.sendProgress)
def sendPeaks(self):
l = [-140, -140, -140, -140]
self.peak_stream.send(json.dumps(l))
IOLoop.instance().add_timeout(time() + .1, self.sendPeaks)
def scheduleProgress(self):
IOLoop.instance().add_timeout(time() + .333, self.sendProgress)
def connect(self):
if self.connected:
return
self.socket = ctx.socket(zmq.SUBSCRIBE)
self.socket.connect(self.socket_addr)
stream = ZMQStream(self.socket, self.io_loop)
stream.on_recv(self.on_message)
self.connected = True
def call(self, message, callback):
context = zmq.Context()
socket = context.socket(zmq.DEALER)
socket.connect(self.endpoint)
stream = ZMQStream(socket)
stream.on_recv(callback)
socket.send(message)
class SubQueue(BaseQueue):
def __init__(self, connect, callback, ioloop=None):
super().__init__(zmq.PULL)
self.socket.connect(connect)
self.stream = ZMQStream(self.socket, ioloop)
self.stream.on_recv(callback)
self.stream.flush()
def start(self):
loop = self.loop
loop.add_handler(self.udp.handle.fileno(), self.handle_beacon,
loop.READ)
stream = ZMQStream(self.pipe, loop)
stream.on_recv(self.control_message)
pc = PeriodicCallback(self.send_ping, PING_INTERVAL * 1000, loop)
pc.start()
pc = PeriodicCallback(self.reap_peers, PING_INTERVAL * 1000, loop)
pc.start()
pc = PeriodicCallback(self.send_ports, PING_INTERVAL * 1000, loop)
pc.start()
loop.start()
def _start_broker(self, do_reply=False):
"""Helper activating a fake broker in the ioloop.
"""
socket = self.context.socket(zmq.XREP)
self.broker = ZMQStream(socket)
self.broker.socket.setsockopt(zmq.LINGER, 0)
self.broker.bind(self.endpoint)
self.broker.on_recv(self._on_msg)
self.broker.do_reply = do_reply
self.broker.ticker = PeriodicCallback(self._tick, MyWorker.HB_INTERVAL)
self.broker.ticker.start()
self.target = None
return
class ReplyQueue(BaseQueue):
def __init__(self, bind, callback, ioloop=None):
super().__init__(zmq.REP)
self.socket.bind(bind)
self.socket.SNDTIMEO = 1000
self.socket.RCVTIMEO = 1000
self.stream = ZMQStream(self.socket, ioloop)
self.stream.on_recv(callback)
self.stream.flush()
def __getattr__(self, name):
return getattr(self.stream, name)
def _create_stream(self):
"""Helper to create the socket and the stream.
"""
socket = self.context.socket(zmq.DEALER)
ioloop = IOLoop.instance()
self.stream = ZMQStream(socket, ioloop)
self.stream.on_recv(self._on_message)
self.stream.socket.setsockopt(zmq.LINGER, 0)
self.stream.connect(self.endpoint)
self.ticker = PeriodicCallback(self._tick, self.HB_INTERVAL)
self._send_ready()
self.ticker.start()
return
def connect(self, stream):
self.context = zmq.Context()
self.subscriber = self.context.socket(zmq.SUB)
# self.subscriber.setsockopt(zmq.RCVHWM, 1)
# self.subscriber.setsockopt(zmq.RCVBUF, 1*1024)
self.subscriber.setsockopt(zmq.LINGER, 0)
self.subscriber.connect(stream)
self.subscriber = ZMQStream(self.subscriber)
self.subscriber.on_recv(self.callback, copy=False)
# self.request.linger = 0
self.subscriber.setsockopt(zmq.SUBSCRIBE, b"")
self.subscriber.setsockopt(zmq.SUBSCRIBE, self.name.encode('ascii'))
class ZMQSubscriber(object):
"""
This class represents a subscriber socket connecting to a ZMQ Service.
"""
clients = set()
stream = None
def __init__(self, url, topics=None):
self.url = url
self.topics = topics
def setup(self):
"""
Setup the subscriber connection on first use.
"""
print "Connecting to publisher: %s" % self.url
ctxt = zmq.Context()
subscriber = ctxt.socket(zmq.SUB)
subscriber.connect(self.url)
if self.topics:
for topic in self.topics:
subscriber.setsockopt(zmq.SUBSCRIBE, topic)
else:
subscriber.setsockopt(zmq.SUBSCRIBE, '')
self.stream = ZMQStream(subscriber)
self.stream.on_recv(self.on_recv_sub)
def add(self, client):
"""
Add a new participant, setup on first access.
"""
if self.stream is None:
self.setup()
self.clients.add(client)
def remove(self, client):
"""
Remove a participant, possibly disconnect when empty.
"""
self.clients.remove(client)
if len(self.clients) == 0:
print "Possibly close connection."
def on_recv_sub(self, message):
"""
Send the message to all clients connected.
"""
print "Got a message:", message
for conn in self.clients:
conn.broadcast(self.clients, message)
break
class MultiplexPubSub(object):
def __init__(self):
self.callbacks = set()
def add_callback(self, callback):
self.callbacks.add(callback)
def remove_callback(self, callback):
self.callbacks.remove(callback)
@tornado.gen.coroutine
def on_recv(self, data):
data[2] = json.loads(data[2])
if data[2] == 1:
data[2] = {"value": data[3]}
if not "timestamp" in data[2]:
data[2]['timestamp'] = time.time()
# print("callback:",data,self.callbacks)
for callback in self.callbacks:
try:
callback(data)
except WebSocketClosedError:
print("Closed by WebSocketClosedError!")
self.callbacks.remove(callback)
data.on_close()
def connect(self):
self.context = zmq.Context()
self.socket = self.context.socket(zmq.SUB)
self.socket.connect('tcp://house-nas:10900')
self.send_socket = self.context.socket(zmq.PUB)
self.send_socket.connect('tcp://house-nas:10901')
print("socket connect:", self.socket, self.on_recv)
self.stream = ZMQStream(self.socket)
self.stream.on_recv(self.on_recv)
def send(self, data):
self.send_socket.send_multipart([str(i) for i in json.loads(data)])
def subscribe(self, channel_id):
print("subscribe:", channel_id)
self.socket.setsockopt(zmq.SUBSCRIBE, channel_id)
def close(self):
self.stream.close()
print self.socket.close()
def __init__(self, root_dir):
"""Инициализирует uwsgi-emperor.
:param root_dir: Полный путь к корневой директории uwsgi-emperor
:type root_dir: str
"""
self.__root_dir__ = root_dir
if not os.path.exists(self.vassal_dir):
log_message("Vassal directory does not exist, creating one",
component="Emperor")
os.mkdir(self.vassal_dir)
emperor_pid = 0
if os.path.exists(self.pidfile):
with open(self.pidfile) as pid_file:
try:
emperor_pid = int(pid_file.read())
psutil.Process(emperor_pid)
log_message("Found running emperor server",
component="Emperor")
except (ValueError, psutil.NoSuchProcess):
os.remove(self.pidfile)
if not emperor_pid:
emperor = subprocess.Popen([
self.uwsgi_binary, "--plugins-dir", self.binary_dir,
"--emperor", self.vassal_dir, "--pidfile", self.pidfile,
"--logger", "zeromq:tcp://127.0.0.1:5123", "--daemonize",
"/dev/null", "--emperor-stats", "127.0.0.1:1777",
"--emperor-required-heartbeat", "40", "--emperor-throttle",
"10000", "--vassal-set", "plugins-dir={}".format(
self.binary_dir)
],
bufsize=1,
close_fds=True)
code = emperor.wait()
assert code == 0, "Error starting emperor server"
log_message("Started emperor server", component="Emperor")
self.vassals = {}
ctx = zmq.Context()
s = ctx.socket(zmq.PULL)
s.bind('tcp://127.0.0.1:5123')
self.stream = ZMQStream(s)
self.stream.on_recv(self.log_message)
def run(self):
self.context = zmq.Context()
self.socket = self.context.socket(zmq.DEALER)
self.socket.connect(self.controller_uri)
self.stream = ZMQStream(self.socket)
self.stream.on_recv(self.on_rcv)
self.ioloop = ioloop.IOLoop.instance()
self.ioloop.add_callback(self.on_start)
tornado.ioloop.PeriodicCallback(self.on_ping, 1000).start()
try:
self.ioloop.start()
except KeyboardInterrupt:
self.shutdown()
self.ioloop.close()
def open(self):
stream = None
try:
context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect(self.addr)
socket.setsockopt(zmq.SUBSCRIBE, '')
stream = ZMQStream(socket)
except Exception, err:
exc_type, exc_value, exc_traceback = sys.exc_info()
print 'ZMQStreamHandler ERROR getting ZMQ stream:', err
traceback.print_exception(exc_type, exc_value, exc_traceback)
if stream and not stream.closed():
stream.close()
class WebSocketZMQBridgeHandler(websocket.WebSocketHandler):
def open(self, *args, **kwargs):
self.currentMessage = []
self.__endpoint = 'tcp://localhost:224'
socket = zmq.Context().socket(zmq.DEALER)
self.__stream = ZMQStream(socket, IOLoop.current())
self.__stream.on_recv(self.__onReceive)
self.__stream.socket.setsockopt(zmq.LINGER, 0)
self.__stream.connect(self.__endpoint)
def on_close(self, *args, **kwargs):
self.__stream.close()
def on_message(self, message):
hasMore = message[0]
self.currentMessage.append(message[1:])
if not hasMore:
sendingMessage = self.currentMessage
self.currentMessage = []
self.__stream.send_multipart(sendingMessage)
def __onReceive(self, msg):
for frame in msg[:-1]:
self.write_message(b'\x01' + frame, binary=True)
self.write_message(b'\x00' + msg[-1], binary=True)
def setupZmqSubscriber():
ctx = zmq.Context()
s = ctx.socket(zmq.SUB)
s.connect('tcp://127.0.0.1:5000')
s.setsockopt(zmq.SUBSCRIBE, "")
stream = ZMQStream(s)
def echo(product):
print "receiving message: %s" % product
for socket in socket_connections:
socket.write_message(product[0])
stream.on_recv(echo)
def __init__(self, endpoint):
self.endpoint = endpoint
# init zeromq
self.context = zmq.Context()
self.socket = self.context.socket(zmq.REQ)
self.stream = ZMQStream(self.socket)
self.stream.on_recv(self.OnRecvMsg)
# get local endpoint
self.socket.bind("tcp://eth0:*")
self.local_endpoint = str(self.socket.getsockopt(zmq.LAST_ENDPOINT))
print "Local endpoint [%s]" % self.local_endpoint
# connect to target
self.socket.connect(endpoint)
print "Connected to [%s]" % endpoint
def on_open(self, info):
self.prog_socket = context.socket(zmq.SUB)
self.prog_socket.connect('ipc:///tmp/progressOut.ipc')
self.prog_socket.setsockopt(zmq.SUBSCRIBE, '')
self.prog_stream = ZMQStream(self.prog_socket,
tornado.ioloop.IOLoop.instance())
self.prog_stream.on_recv(self.process_prog)
self.peak_socket = context.socket(zmq.SUB)
self.peak_socket.connect('ipc:///tmp/peaks.ipc')
self.peak_socket.setsockopt(zmq.SUBSCRIBE, '')
self.peak_stream = ZMQStream(self.peak_socket,
tornado.ioloop.IOLoop.instance())
self.peak_stream.on_recv(self.process_peaks)
def _init_data_handler(self):
"""
Initialize data port handler.
"""
# Set the linger period to prevent hanging on unsent
# messages when shutting down:
self.logger.info('initializing data handler')
self.sock_data = self.zmq_ctx.socket(zmq.ROUTER)
self.sock_data.setsockopt(zmq.LINGER, LINGER_TIME)
self.sock_data.bind("tcp://*:%i" % self.port_data)
self.stream_data = ZMQStream(self.sock_data, self.ioloop)
self.stream_data.on_recv(self._data_handler)
class ZMQDownlinkConnector:
def __init__(self, connect_addr):
self._zmq_sub_socket = zmq.Context.instance().socket(zmq.SUB)
self._zmq_sub_socket.setsockopt(zmq.RCVHWM, 0)
self._zmq_sub_socket.connect(connect_addr)
self._zmq_sub_stream = ZMQStream(self._zmq_sub_socket)
self._zmq_sub_socket.setsockopt_string(
zmq.SUBSCRIBE, '') # Subscribing to every message
def register_callback(self, callback):
self._zmq_sub_stream.on_recv(callback)
def close(self):
self._zmq_sub_stream.close()
def __init__(self):
self.ctx = zmq.Context()
self.loop = IOLoop.instance()
self.client = self.ctx.socket(zmq.DEALER)
if self.crypto:
self.keymonkey = KeyMonkey("client")
self.client = self.keymonkey.setupClient(self.client,
self.endpoint, "server")
self.client.connect(self.endpoint)
print("Connecting to", self.endpoint)
self.client = ZMQStream(self.client)
self.client.on_recv(self.on_recv)
self.periodic = PeriodicCallback(self.periodictask, 1000)
self.last_recv = None
def main():
print("Websocket Server Process ID: ", os.getpid())
print("Local IP Address: ", env_config.get_self_ip())
print("Now env_config SELF_IP is: ", env_config.SELF_IP)
env_config.config_leds()
print("Upper Pane: ", env_config.WIN_UPPER_PANE)
print("Display type (0 = LEDs, 1 = DMX/Relays): ", env_config.PI_DISPLAY_TYPE)
# set up Zero MQ connection to Flask server
flask_context = zmq.Context()
socket = flask_context.socket(zmq.PAIR)
print("Binding to port 62830")
#socket.bind("tcp://127.0.0.1:62830")
socket.bind(env_config.ZMQ_SOCKET_IP + ":" + env_config.ZMQ_SOCKET_PORT)
# set up multiprocessing pipes
ws_ledp_conn, ledp_conn = multiprocessing.Pipe()
if not env_config.PI_DISPLAY_TYPE:
# initialize fadecandy led control class
led_controller = fc.LEDController()
else:
# initialize dmx light control class
led_controller = dmx.LEDController()
# get new process
ledp = multiprocessing.Process(target=led_controller.run, args=[ledp_conn])
# message callback
flask_stream = ZMQStream(socket)
flask_stream.on_recv(partial(process_zmq_message, conn=ws_ledp_conn), copy=True)
ledp.start() # start led controller process
# create websocket listener
websocket_listener = tornado.web.Application([
(r"/ledctrl", WebSocketHandler, dict(ledp=ledp, conn=ws_ledp_conn))
])
# # listen to websocket indefinitely
# websocket_listener.listen(31415)
websocket_listener.listen(env_config.TORNADO_PORT)
tornado.ioloop.IOLoop.current().start()
def __init__(self, primary=True, ports=(5556, 5566)):
self.primary = primary
if primary:
self.port, self.peer = ports
frontend = "tcp://*:5003"
backend = "tcp://localhost:5004"
self.kvmap = {}
else:
self.peer, self.port = ports
frontend = "tcp://*:5004"
backend = "tcp://localhost:5003"
self.ctx = zmq.Context.instance()
self.pending = []
self.bstar = BinaryStar(primary, frontend, backend)
self.bstar.register_voter("tcp://*:%i" % self.port, zmq.ROUTER,
self.handle_snapshot)
# Set up our clone server sockets
self.publisher = self.ctx.socket(zmq.PUB)
self.collector = self.ctx.socket(zmq.SUB)
self.collector.setsockopt(zmq.SUBSCRIBE, b'')
self.publisher.bind("tcp://*:%d" % (self.port + 1))
self.collector.bind("tcp://*:%d" % (self.port + 2))
# Set up our own clone client interface to peer
self.subscriber = self.ctx.socket(zmq.SUB)
self.subscriber.setsockopt(zmq.SUBSCRIBE, b'')
self.subscriber.connect("tcp://localhost:%d" % (self.peer + 1))
# Register state change handlers
self.bstar.master_callback = self.become_master
self.bstar.slave_callback = self.become_slave
# Wrap sockets in ZMQStreams for IOLoop handlers
self.publisher = ZMQStream(self.publisher)
self.subscriber = ZMQStream(self.subscriber)
self.collector = ZMQStream(self.collector)
# Register our handlers with reactor
self.collector.on_recv(self.handle_collect)
self.flush_callback = PeriodicCallback(self.flush_ttl, 1000)
self.hugz_callback = PeriodicCallback(self.send_hugz, 1000)
# basic log formatting:
logging.basicConfig(format="%(asctime)s %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
level=logging.INFO)
class AnsibleKernelHelpersThread(object):
def __init__(self, queue):
self.queue = queue
self.io_loop = IOLoop(make_current=False)
context = zmq.Context.instance()
self.pause_socket = context.socket(zmq.REP)
self.pause_socket_port = self.pause_socket.bind_to_random_port(
"tcp://127.0.0.1")
self.status_socket = context.socket(zmq.PULL)
self.status_socket_port = self.status_socket.bind_to_random_port(
"tcp://127.0.0.1")
self.pause_stream = ZMQStream(self.pause_socket, self.io_loop)
self.status_stream = ZMQStream(self.status_socket, self.io_loop)
self.pause_stream.on_recv(self.recv_pause)
self.status_stream.on_recv(self.recv_status)
self.thread = threading.Thread(target=self._thread_main)
self.thread.daemon = True
def start(self):
logger.info('thread.start')
self.thread.start()
atexit.register(self.stop)
def stop(self):
logger.info('thread.stop start')
if not self.thread.is_alive():
return
self.io_loop.add_callback(self.io_loop.stop)
self.thread.join()
logger.info('thread.stop end')
def recv_status(self, msg):
logger = logging.getLogger('ansible_kernel.kernel.recv_status')
logger.info(msg)
self.queue.put(StatusMessage(json.loads(msg[0])))
def recv_pause(self, msg):
logger = logging.getLogger('ansible_kernel.kernel.recv_pause')
logger.info("completed %s waiting...", msg)
self.queue.put(TaskCompletionMessage(json.loads(msg[0])))
def _thread_main(self):
"""The inner loop that's actually run in a thread"""
self.io_loop.make_current()
self.io_loop.start()
self.io_loop.close(all_fds=True)
def set_resource(self, tree):
"""Set a resource on our JID"""
bind_element = tree[0]
if tree.get("type") != "set" or \
bind_element.tag != 'bind' or\
bind_element.get("xmlns") != BIND_NS:
raise NotAuthorizedError
resource_element = bind_element.find("resource")
if resource_element is None:
# No prefered resource was set, generate one
self.jid.resource = uuid.uuid4().hex
else:
self.jid.resource = resource_element.text
if not self.jid.validate():
raise BadRequestError
# Check if given resource is already in use
known_jids = get_known_jids()
try:
known_jids.append(self.jid)
except ValueError:
raise ConflictError
log.info("Bound connection as %s" % str(self.jid))
# Connect to forwarder to receive stanzas sent back to client
log.debug('Registering Client at forwarder..')
self.pull_socket = zmq.Context().socket(zmq.PULL)
self.processed_stream = ZMQStream(self.pull_socket,
self.connection.stream.io_loop)
self.processed_stream.on_recv(self.masked_send_list, False)
port = self.pull_socket.bind_to_random_port('tcp://127.0.0.1')
self.pull_url = 'tcp://127.0.0.1:' + str(port)
reg_msg = ZMQForwarder_message('REGISTER')
reg_msg.attributes = (config.get('ipc',
'password'), self.pull_url, self.jid)
self.publisher.send_pyobj(reg_msg)
# Send registered resource back to client
response_element = ET.Element("iq")
response_element.set("type", "result")
response_element.set("id", tree.get("id"))
bind_element = ET.SubElement(response_element, "bind")
bind_element.set("xmlns", BIND_NS)
jid_element = ET.SubElement(bind_element, "jid")
jid_element.text = str(self.jid)
self.send_element(response_element)
class Subscriber(object):
u"""
本地订阅者
订阅topic匹配关系
订阅 ehr:api:1
匹配消息 'ehr', 'ehr:api', 'ehr:api:1'
实现直连推送,或者广播
"""
def __init__(self, callback):
self.callback = callback
self.topic = ''
self.sock = context.socket(zmq.SUB)
self.sock.connect('inproc:///tmp/hub_{}'.format(pid))
self.stream = ZMQStream(self.sock)
self.stream.on_recv(self.recv)
def subscribe(self, topic):
if not isinstance(topic, basestring) or not topic:
return
self.topic = topic
self.sock.setsockopt(zmq.SUBSCRIBE, str(topic.split(':')[0]))
def unsubscribe(self):
if self.topic:
self.sock.setsockopt(zmq.UNSUBSCRIBE,
str(self.topic.split(':')[0]))
self.topic = ''
def recv(self, msg):
_, body = msg
try:
data = json.loads(body)
topic = data.get('topic', '')
if not topic:
return
if re.match(r'^{}(:.+)?$'.format(topic), self.topic):
self.callback(body)
except:
pass
def close(self):
self.topic = None
self.callback = None
self.stream.close()
class DeviceApp(object):
# endpoint = "tcp://127.0.0.1:5556"
# endpoint = "tcp://localhost:5556"
endpoint = "tcp://165.227.24.226:5556"
def __init__(self):
self.ctx = zmq.Context()
self.loop = IOLoop.instance()
self.client = self.ctx.socket(zmq.DEALER)
self.client.connect(self.endpoint)
print("Connecting to", self.endpoint)
self.client = ZMQStream(self.client)
self.client.on_recv(self.on_recv)
self.periodic = PeriodicCallback(self.periodictask, 1000)
self.last_recv = None
def periodictask(self):
if not (self.last_recv) or (self.last_recv +
timedelta(seconds=5)) < datetime.utcnow():
print(
"Hmmm... haven't heard from the server in 5 seconds... Server unresponsive."
)
print("Sending HELLO to server")
msg = HelloMessage()
print("msg=", msg)
msg.send(self.client)
def start(self):
self.periodic.start()
try:
self.loop.start()
except KeyboardInterrupt:
pass
def on_recv(self, msg):
self.last_recv = datetime.utcnow()
print("Received a message of type %s from server!" % msg[0])
def setupZmqSubscriber(address):
ctx = zmq.Context()
s = ctx.socket(zmq.SUB)
s.connect(address)
s.setsockopt(zmq.SUBSCRIBE, "")
stream = ZMQStream(s)
def echo(msg):
print "receiving message: %s" % msg
#stream.send_multipart(msg)
for socket in socket_connections:
socket.write_message(msg[0] + '\r\n\r\n')
stream.on_recv(echo)
def _setup_streams(self):
"""
Setup ZMQ streams.
These need to be constructed within the right active event loop,
i.e. this must run in the background thread.
"""
assert threading.current_thread() is self.thread
assert self.loop
from zmq.eventloop.zmqstream import ZMQStream
with self._condition:
self._shell_stream = ZMQStream(self._shell_socket,
io_loop=self.loop)
self._control_stream = ZMQStream(self._control_socket,
io_loop=self.loop)
self._condition.notify_all()
def start(self):
"""
Initialize the zmq sockets on a ioloop stream.
The separation of this part from the init is useful if
we start the client on a separate thread with a new ioloop
(for example to enable use in an ipython notebook)
"""
socket = self.context.socket(zmq.DEALER)
ioloop = IOLoop.instance()
self.stream = ZMQStream(socket, ioloop)
self.stream.on_recv(self._on_message)
self._proto_prefix = [EMPTY_FRAME, self._proto_version]
self._delayed_timeout = None
self.timed_out = False
socket.connect(self.endpoint)
def setup(self):
"""
Setup the subscriber connection on first use.
"""
print "Connecting to publisher: %s" % self.url
ctxt = zmq.Context()
subscriber = ctxt.socket(zmq.SUB)
subscriber.connect(self.url)
if self.topics:
for topic in self.topics:
subscriber.setsockopt(zmq.SUBSCRIBE, topic)
else:
subscriber.setsockopt(zmq.SUBSCRIBE, '')
self.stream = ZMQStream(subscriber)
self.stream.on_recv(self.on_recv_sub)
def _init_ctrl_handler(self):
"""
Initialize control port handler.
"""
# Set the linger period to prevent hanging on unsent messages
# when shutting down:
self.logger.info('initializing ctrl handler')
self.sock_ctrl = self.zmq_ctx.socket(zmq.DEALER)
self.sock_ctrl.setsockopt(zmq.IDENTITY, self.id)
self.sock_ctrl.setsockopt(zmq.LINGER, LINGER_TIME)
self.sock_ctrl.connect('tcp://localhost:%i' % self.port_ctrl)
self.stream_ctrl = ZMQStream(self.sock_ctrl, self.ioloop_ctrl)
self.stream_ctrl.on_recv(self._ctrl_handler)
def __init__(self, game_id=b'0', port=5556):
self.GID = game_id
self.port = port
self.ctx = zmq.Context()
self.loop = IOLoop.instance()
self.client_input_sock = self.ctx.socket(zmq.PULL)
self.client_pub_sock = self.ctx.socket(zmq.PUB)
self.command_enqueue, self.command_dequeue = zpipe(self.ctx, 1000)
self.client_input_sock.bind("tcp://*:%d" % self.port)
self.client_pub_sock.bind("tcp://*:%d" % (self.port + 1))
self.client_input_sock = ZMQStream(self.client_input_sock)
self.client_input_sock.on_recv(self.handle_input)
def __init__(self, context, endpoint, service):
"""Initialize the MDPClient.
"""
socket = context.socket(zmq.REQ)
ioloop = IOLoop.instance()
self.service = service
self.endpoint = endpoint
self.stream = ZMQStream(socket, ioloop)
self.stream.on_recv(self._on_message)
self.can_send = True
self._proto_prefix = [PROTO_VERSION, service]
self._tmo = None
self.timed_out = False
socket.connect(endpoint)
return
