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()

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:]))

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

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 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)

    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

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, 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 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 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)

    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 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 __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

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()

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 __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")

    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)

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

    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()