#!/usr/bin/env python
# encoding: utf-8
import threading
import time

from PySide import QtCore

import zmq
from zmq.auth.thread import ThreadAuthenticator

from api import SIGNALS
from certificates import get_frontend_certificates
from utils import get_log_handler

logger = get_log_handler(__name__)


class SignalerQt(QtCore.QThread):
    """
    Signaling server.
    Receives signals from the signaling client and emit Qt signals for the GUI.
    """
    PORT = "5667"
    BIND_ADDR = "tcp://127.0.0.1:%s" % PORT

    def __init__(self):
        QtCore.QThread.__init__(self)
        self._do_work = threading.Event()
        self._do_work.set()

    def run(self):
        """
        Start a loop to process the ZMQ requests from the signaler client.
        """
        logger.debug("Running SignalerQt loop")
        context = zmq.Context()
        socket = context.socket(zmq.REP)

        # Start an authenticator for this context.
        auth = ThreadAuthenticator(context)
        auth.start()
        auth.allow('127.0.0.1')

        # Tell authenticator to use the certificate in a directory
        auth.configure_curve(domain='*', location=zmq.auth.CURVE_ALLOW_ANY)
        public, secret = get_frontend_certificates()
        socket.curve_publickey = public
        socket.curve_secretkey = secret
        socket.curve_server = True  # must come before bind

        socket.bind(self.BIND_ADDR)

        while self._do_work.is_set():
            # Wait for next request from client
            try:
                request = socket.recv(zmq.NOBLOCK)
                logger.debug("Received request: '{0}'".format(request))
                socket.send("OK")
                self._process_request(request)
            except zmq.ZMQError as e:
                if e.errno != zmq.EAGAIN:
                    raise
            time.sleep(0.01)

        logger.debug("SignalerQt thread stopped.")

    def stop(self):
        """
        Stop the SignalerQt blocking loop.
        """
        self._do_work.clear()

    def _process_request(self, request_json):
        """
        Process a request and call the according method with the given
        parameters.

        :param request_json: a json specification of a request.
        :type request_json: str
        """
        try:
            request = zmq.utils.jsonapi.loads(request_json)
            signal = request['signal']
            data = request['data']
        except Exception as e:
            msg = "Malformed JSON data in Signaler request '{0}'. Exc: {1!r}"
            msg = msg.format(request_json, e)
            logger.critical(msg)
            raise

        if signal not in SIGNALS:
            logger.error("Unknown signal received, '{0}'".format(signal))
            return

        try:
            qt_signal = getattr(self, signal)
        except Exception:
            logger.warning("Signal not implemented, '{0}'".format(signal))
            return

        logger.debug("Emitting '{0}'".format(signal))
        if data is None:
            qt_signal.emit()
        else:
            qt_signal.emit(data)

@@ -322,22 +322,22 @@
 QtCore.Q
-Thread
+Object
 ):%0A    %22
@@ -556,96 +556,480 @@
 re.Q
-Thread.__init__(self)%0A        self._do_work = threading.Event()%0A        self._do_work.se
+Object.__init__(self)%0A%0A        # Note: we use a plain thread instead of a QThread since works better.%0A        # The signaler was not responding on OSX if the worker loop was run in%0A        # a QThread.%0A        self._worker_thread = threading.Thread(target=self._run)%0A        self._do_work = threading.Event()%0A%0A    def start(self):%0A        %22%22%22%0A        Start the worker thread for the signaler server.%0A        %22%22%22%0A        self._do_work.set()%0A        self._worker_thread.star
 t()%0A
@@ -1037,16 +1037,17 @@
     def 
+_
 run(self

Use plain Thread instead of QThread.