def start(self):
        """
        Start the daemon
        """
        logger.debug('Starting daemon')
        # Check for a pidfile to see if the daemon already runs
        try:
            pf = open(self.pidfile, 'r')
            pid = int(pf.read().strip())
            pf.close()
        except IOError:
            pid = None

        if pid:
            message = "pidfile {} already exist. Daemon already running?\n".format(pid)
            logger.error(message)
            sys.stderr.write(message)
            sys.exit(1)

        # Start the daemon
        self.daemonize()
        try:
            self.run()
        except Exception as e:
            logger.error('Exception running process: {}'.format(e))

        if os.path.exists(self.pidfile):
            os.remove(self.pidfile)

    def do_POST(self):
        path = self.path.split('?')[0][1:].split('/')
        if path[0] != HTTPServerHandler.uuid:
            self.sendJsonError(403, 'Forbidden')
            return

        if len(path) != 2:
            self.sendJsonError(400, 'Invalid request')
            return

        try:
            HTTPServerHandler.lock.acquire()
            length = int(self.headers.getheader('content-length'))
            content = self.rfile.read(length)
            logger.debug('length: {}, content >>{}<<'.format(length, content))
            params = json.loads(content)

            operation = getattr(self, 'post_' + path[1])
            result = operation(params)  # Protect not POST methods
        except AttributeError:
            self.sendJsonError(404, 'Method not found')
            return
        except Exception as e:
            logger.error('Got exception executing POST {}: {}'.format(path[1], utils.toUnicode(e.message)))
            self.sendJsonError(500, str(e))
            return
        finally:
            HTTPServerHandler.lock.release()

        self.sendJsonResponse(result)

    def run(self):
        if self.ipc is None:
            return
        self.running = True

        # Wait a bit so we ensure IPC thread is running...
        time.sleep(2)

        while self.running and self.ipc.running:
            try:
                msg = self.ipc.getMessage()
                if msg is None:
                    break
                msgId, data = msg
                logger.debug('Got Message on User Space: {}:{}'.format(msgId, data))
                if msgId == ipc.MSG_MESSAGE:
                    self.displayMessage.emit(QtCore.QString.fromUtf8(data))
                elif msgId == ipc.MSG_LOGOFF:
                    self.logoff.emit()
                elif msgId == ipc.MSG_SCRIPT:
                    self.script.emit(QtCore.QString.fromUtf8(data))
                elif msgId == ipc.MSG_INFORMATION:
                    self.information.emit(pickle.loads(data))
            except Exception as e:
                try:
                    logger.error('Got error on IPC thread {}'.format(utils.exceptionToMessage(e)))
                except:
                    logger.error('Got error on IPC thread (an unicode error??)')

        if self.ipc.running is False and self.running is True:
            logger.warn('Lost connection with Service, closing program')

        self.exit.emit()

    def _request(self, url, data=None):
        try:
            if data is None:
                # Old requests version does not support verify, but they do not checks ssl certificate by default
                if self.newerRequestLib:
                    r = requests.get(url, verify=VERIFY_CERT)
                else:
                    logger.debug('Requesting with old')
                    r = requests.get(url)  # Always ignore certs??
            else:
                if data == '':
                    data = '{"dummy": true}'  # Ensures no proxy rewrites POST as GET because body is empty...
                if self.newerRequestLib:
                    r = requests.post(url, data=data, headers={'content-type': 'application/json'}, verify=VERIFY_CERT)
                else:
                    logger.debug('Requesting with old')
                    r = requests.post(url, data=data, headers={'content-type': 'application/json'})

            # From versions of requests, content maybe bytes or str. We need str for json.loads
            content = r.content
            if not isinstance(content, six.text_type):
                content = content.decode('utf8')
            r = json.loads(content)  # Using instead of r.json() to make compatible with oooold rquests lib versions
        except requests.exceptions.RequestException as e:
            raise ConnectionError(e)
        except Exception as e:
            raise ConnectionError(exceptionToMessage(e))

        ensureResultIsOk(r)

        return r

def rename(newName):
    '''
    RH, Centos, Fedora Renamer
    Expects new host name on newName
    Host does not needs to be rebooted after renaming
    '''
    logger.debug('using RH renamer')

    with open('/etc/hostname', 'w') as hostname:
        hostname.write(newName)

    # Force system new name
    os.system('/bin/hostname %s' % newName)

    # add name to "hosts"
    with open('/etc/hosts', 'r') as hosts:
        lines = hosts.readlines()
    with open('/etc/hosts', 'w') as hosts:
        hosts.write("127.0.1.1\t{}\n".format(newName))
        for l in lines:
            if l[:9] != '127.0.1.1':  # Skips existing 127.0.1.1. if it already exists
                hosts.write(l)

    with open('/etc/sysconfig/network', 'r') as net:
        lines = net.readlines()
    with open('/etc/sysconfig/network', 'w') as net:
        net.write('HOSTNAME={}\n'.format(newName))
        for l in lines:
            if l[:8] != 'HOSTNAME':
                net.write(l)

    return True

    def _request(self, url, data=None):
        try:
            if data is None:
                # Old requests version does not support verify, but they do not checks ssl certificate by default
                if self.newerRequestLib:
                    r = requests.get(url, verify=VERIFY_CERT)
                else:
                    logger.debug('Requesting with old')
                    r = requests.get(url)  # Always ignore certs??
            else:
                if self.newerRequestLib:
                    r = requests.post(url, data=data, headers={'content-type': 'application/json'}, verify=VERIFY_CERT)
                else:
                    logger.debug('Requesting with old')
                    r = requests.post(url, data=data, headers={'content-type': 'application/json'})

            r = json.loads(r.content)  # Using instead of r.json() to make compatible with oooold rquests lib versions
        except requests.exceptions.RequestException as e:
            raise ConnectionError(e)
        except Exception as e:
            raise ConnectionError(exceptionToMessage(e))

        ensureResultIsOk(r)

        return r

def rename(newName):
    """
    Debian renamer
    Expects new host name on newName
    Host does not needs to be rebooted after renaming
    """
    logger.debug("using Debian renamer")

    with open("/etc/hostname", "w") as hostname:
        hostname.write(newName)

    # Force system new name
    os.system("/bin/hostname %s" % newName)

    # add name to "hosts"
    with open("/etc/hosts", "r") as hosts:
        lines = hosts.readlines()
    with open("/etc/hosts", "w") as hosts:
        hosts.write("127.0.1.1\t%s\n" % newName)
        for l in lines:
            if l[:9] == "127.0.1.1":  # Skips existing 127.0.1.1. if it already exists
                continue
            hosts.write(l)

    return True

    def clientMessageProcessor(self, msg, data):
        logger.debug('Got message {}'.format(msg))
        if self.api is None:
            logger.info('Rest api not ready')
            return

        if msg == ipc.REQ_LOGIN:
            res = self.api.login(data).split('\t')
            # third parameter, if exists, sets maxSession duration to this.
            # First & second parameters are ip & hostname of connection source
            if len(res) >= 3:
                self.api.maxSession = int(res[2])  # Third parameter is max session duration
                msg = ipc.REQ_INFORMATION  # Senf information, requested or not, to client on login notification
        elif msg == ipc.REQ_LOGOUT:
            self.api.logout(data)
            self.onLogout(data)
        elif msg == ipc.REQ_INFORMATION:
            info = {}
            if self.api.idle is not None:
                info['idle'] = self.api.idle
            if self.api.maxSession is not None:
                info['maxSession'] = self.api.maxSession
            self.ipc.sendInformationMessage(info)
        elif msg == ipc.REQ_TICKET:
            d = json.loads('data')
            try:
                result = self.api.getTicket(d['ticketId'], d['secure'])
                self.ipc.sendTicketMessage(result)
            except Exception:
                logger.exception('Getting ticket')
                self.ipc.sendTicketMessage({'error': 'invalid ticket'})

 def setReady(self, ipsInfo, hostName=None):
     logger.debug('Notifying readyness: {}'.format(ipsInfo))
     #    data = ','.join(['{}={}'.format(v[0], v[1]) for v in ipsInfo])
     data = {
         'ips': ipsInfo,
         'hostname': hostName
     }
     return self.postMessage('ready', data)

    def postMessage(self, msg, data, processData=True):
        logger.debug('Invoking post message {} with data {}'.format(msg, data))

        if self.uuid is None:
            raise ConnectionError('REST api has not been initialized')

        if processData:
            data = json.dumps({'data': data})
        url = self._getUrl('/'.join([self.uuid, msg]))
        return self._request(url, data)['result']

    def stop(self):
        logger.debug('Stopping Server IPC')
        self.running = False
        for t in self.threads:
            t.stop()
        socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect(('localhost', self.port))
        self.serverSocket.close()

        for t in self.threads:
            t.join()

 def cleanupFinishedThreads(self):
     '''
     Cleans up current threads list
     '''
     aliveThreads = []
     for t in self.threads:
         if t.isAlive():
             logger.debug('Thread {} is alive'.format(t))
             aliveThreads.append(t)
     self.threads[:] = aliveThreads

    def sendRequestMessage(self, msg, data=None):
        logger.debug('Sending request for msg: {}({}), {}'.format(msg, REV_DICT.get(msg), data))
        if data is None:
            data = b''

        if isinstance(data, six.text_type):  # Convert to bytes if necessary
            data = data.encode('utf-8')

        l = len(data)
        msg = six.int2byte(msg) + six.int2byte(l & 0xFF) + six.int2byte(l >> 8) + data
        self.clientSocket.sendall(msg)

 def information(self, info):
     '''
     Invoked when received information from service
     '''
     logger.debug('Got information message: {}'.format(info))
     if 'idle' in info:
         idle = int(info['idle'])
         operations.initIdleDuration(idle)
         self.maxIdleTime = idle
         logger.debug('Set screensaver launching to {}'.format(idle))
     else:
         self.maxIdleTime = None

 def testParameters(self):
     logger.debug('Testing connection')
     try:
         cfg = self._getCfg()
         api = REST.Api(
             cfg['host'], cfg['masterKey'], cfg['ssl'])
         api.test()
         QtGui.QMessageBox.information(
             self, 'Test Passed', 'The test was executed successfully', QtGui.QMessageBox.Ok)
         logger.info('Test was passed successfully')
     except Exception as e:
         logger.info('Test error: {}'.format(utils.exceptionToMessage(e)))
         QtGui.QMessageBox.critical(self, 'Test Error', utils.exceptionToMessage(e), QtGui.QMessageBox.Ok)

 def post_script(self, params):
     logger.debug('Received script: {}'.format(params))
     if 'script' not in params:
         raise Exception('Invalid script parameters')
     if 'user' in params:
         logger.debug('Sending SCRIPT to clients')
         HTTPServerHandler.service.ipc.sendScriptMessage(params['script'])
     else:
         # Execute script at server space, that is, here
         # as a secondary thread
         th = ScriptExecutorThread(params['script'])
         th.start()
     return 'ok'

    def __init__(self):
        super(self.__class__, self).__init__()
        # Retries connection for a while
        for _ in range(10):
            try:
                self.ipc = ipc.ClientIPC(IPC_PORT)
                self.ipc.start()
                break
            except Exception:
                logger.debug('IPC Server is not reachable')
                self.ipc = None
                time.sleep(2)

        self.running = False

    def sendMessage(self, msgId, msgData):
        '''
        Notify message to all listening threads
        '''
        logger.debug('Sending message {}({}),{} to all clients'.format(msgId, REV_DICT.get(msgId), msgData))

        # Convert to bytes so length is correctly calculated
        if isinstance(msgData, six.text_type):
            msgData = msgData.encode('utf8')

        for t in self.threads:
            if t.isAlive():
                logger.debug('Sending to {}'.format(t))
                t.messages.put((msgId, msgData))

    def joinDomain(self, name, domain, ou, account, password):
        ver = operations.getWindowsVersion()
        ver = ver[0] * 10 + ver[1]
        logger.debug('Starting joining domain {} with name {} (detected operating version: {})'.format(
            domain, name, ver))
        # If file c:\compat.bin exists, joind domain in two steps instead one

        # Accepts one step joinDomain, also remember XP is no more supported by
        # microsoft, but this also must works with it because will do a "multi
        # step" join
        if ver >= 60 and store.useOldJoinSystem() is False:
            self.oneStepJoin(name, domain, ou, account, password)
        else:
            logger.info('Using multiple step join because configuration requests to do so')
            self.multiStepJoin(name, domain, ou, account, password)

    def initIPC(self):
        # ******************************************
        # * Initialize listener IPC & REST threads *
        # ******************************************
        logger.debug('Starting IPC listener at {}'.format(IPC_PORT))
        self.ipc = ipc.ServerIPC(IPC_PORT, clientMessageProcessor=self.clientMessageProcessor)
        self.ipc.start()

        if self.api.mac in self.knownIps:
            address = (self.knownIps[self.api.mac], random.randrange(40000, 44000))
            logger.info('Starting REST listener at {}'.format(address))
            self.httpServer = httpserver.HTTPServerThread(address, self)
            self.httpServer.start()
            # And notify it to broker
            self.api.notifyComm(self.httpServer.getServerUrl())