source: remote_control/puzzlebox_brainstorms_network_server.py @ 87

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Puzzlebox - Brainstorms - Network - Server
#
# Copyright Puzzlebox Productions, LLC (2010)
#
# This code is released under the GNU Pulic License (GPL) version 2
# For more information please refer to http://www.gnu.org/copyleft/gpl.html
#
# Last Update: 2010.07.06
#
#####################################################################

import os, sys
import signal

import simplejson as json

from PyQt4 import QtCore, QtNetwork

import puzzlebox_brainstorms_configuration as configuration
import puzzlebox_brainstorms_remote_control as remote_control
#import puzzlebox_logger

#####################################################################
# Globals
#####################################################################

DEBUG = 1

SERVER_INTERFACE = configuration.BRAINSTORMS_SERVER_INTERFACE
SERVER_PORT = configuration.BRAINSTORMS_SERVER_PORT

CLIENT_NO_REPLY_WAIT = configuration.CLIENT_NO_REPLY_WAIT * 1000

DELIMITER = configuration.BRAINSTORMS_DELIMITER

BLUETOOTH_DEVICE = configuration.NXT_BLUETOOTH_DEVICE

DISCRETE_CONTROL_COMMANDS = configuration.BRAINSTORMS_DISCRETE_CONTROL_COMMANDS

#####################################################################
# Classes
#####################################################################

class puzzlebox_brainstorms_network_server:
        
        def __init__(self, log, \
                          server_interface=SERVER_INTERFACE, \
                          server_port=SERVER_PORT, \
                          DEBUG=DEBUG, \
                          parent=None):
                
                self.log = log
                self.DEBUG = DEBUG
                
                self.server_interface = server_interface
                self.server_port = server_port
                
                self.configureNetwork()
                
                self.rc = remote_control.puzzlebox_brainstorms_remote_control( \
                            device=BLUETOOTH_DEVICE, \
                            DEBUG=DEBUG)
        
        
        ##################################################################
        
        def configureNetwork(self):
        
                #self.blockSize = 0
                self.socket = QtNetwork.QTcpServer()
                self.socket.name = 'Brainstorms Server'
                
                if self.DEBUG:
                        print "<---- [%s] Initializing server on %s:%i" % \
                                (self.socket.name, self.server_interface, self.server_port)
        
                if (self.server_interface == ''):
                        result = self.socket.listen(port=self.server_port)
                else:
                        result = self.socket.listen(address=self.server_interface, \
                                           port=self.server_port)
                
                if not result:
                        if self.DEBUG:
                                print "ERROR [%s] Unable to start the server:", self.socket.name,
                                print self.socket.errorString()
                                
                        self.socket.close()
                        return
                
                
                self.socket.newConnection.connect(self.processConnection)
                #self.socket.error.connect(self.displayError)
        
        
        ##################################################################
        
        def processConnection(self):
                
                clientConnection = self.socket.nextPendingConnection()
                clientConnection.disconnected.connect(clientConnection.deleteLater)
                
                if not clientConnection.waitForReadyRead(CLIENT_NO_REPLY_WAIT):
                        if self.DEBUG:
                                print "WARNING [%s] Timeout waiting for client to transmit data" % \
                                   self.socket.name
                                print "Status:",
                                print clientConnection.state()
                        #return
                
                socket_buffer = clientConnection.readAll()
                
                for packet in socket_buffer.split(DELIMITER):
                        
                        if packet != '':
                                
                                try:
                                        data = json.loads(packet.data())
                                except:
                                        data = packet
                                
                                if self.DEBUG:
                                        print "--> [%s] Received:" % self.socket.name,
                                        print data
                                
                                response = self.processCommand(data)
                                
                                if response != None:
                                
                                        data = json.dumps(response)
                                        
                                        
                                        if clientConnection.waitForConnected(CLIENT_NO_REPLY_WAIT):
                                                clientConnection.write(data)
                
                
                clientConnection.disconnectFromHost()
        
        
        ##################################################################
        
        def processCommand(self, data):
                
                #response = '%s command received' % command
                response = None
                
                if DISCRETE_CONTROL_COMMANDS:
                        
                        self.executeCommand(data['command'], data['power'])
                        
                        
                elif self.rc.connection != None:
                        
                        self.rc.run(data['command'], data['power'])
                
                
                return(response)
        
        
        ##################################################################
        
        def executeCommand(self, command):
                
                #command_line = 'python puzzlebox_brainstorms_remote_control.py --command=%s' % command
                
                #os.system(command_line)
                
                rc = remote_control.puzzlebox_brainstorms_remote_control( \
                        device=BLUETOOTH_DEVICE, \
                        command=command, \
                        DEBUG=DEBUG)
                
                if rc.connection != None:
                        rc.run(rc.command)
                        rc.stop()


#####################################################################
# Main
#####################################################################

if __name__ == '__main__':
        
        # Perform correct KeyboardInterrupt handling
        signal.signal(signal.SIGINT, signal.SIG_DFL)
        
        #log = puzzlebox_logger.puzzlebox_logger(logfile='server_brainstorms')
        log = None
        
        # Collect default settings and command line parameters
        server_interface = SERVER_INTERFACE
        server_port = SERVER_PORT
        
        for each in sys.argv:
                
                if each.startswith("--interface="):
                        server_interface = each[ len("--interface="): ]
                if each.startswith("--port="):
                        server_port = each[ len("--port="): ]
        
        
        app = QtCore.QCoreApplication(sys.argv)
        
        server = puzzlebox_brainstorms_network_server(log, \
                                                      server_interface, \
                                                      server_port, \
                                                      DEBUG=DEBUG)
        
        sys.exit(app.exec_())