class FSServer():
def __init__(self,config_file, settings_file):
self._logger = logging.getLogger(__name__)
self._logger.setLevel(logging.DEBUG)
self.hardwareController = None
self.config_file = config_file
self.settings_file = settings_file
def run(self):
self._logger.info("FabScanPi-Server "+str(__version__))
try:
injector.provide_instance(FSEventManager, FSEventManager(), name="FSEventManager")
# create Singleton instances
_config = Config.instance(self.config_file)
_settings = Settings.instance(self.settings_file)
_hardwareController = HardwareController.instance()
_eventManager = FSEventManager.instance()
# Websocket Server
self.fsWebSocketServer = FSWebSocketServer()
self.fsWebSocketServer.start()
_scanner = FSScanner()
_scanner.start()
# Web Server
self.fsWebServer = WebServer()
self.fsWebServer.start()
while True:
time.sleep(0.3)
#self.fsWebServer.serve_forever()
except (KeyboardInterrupt, SystemExit):
time.sleep(0.5)
_hardwareController.laser.off()
_hardwareController.led.off()
_hardwareController.turntable.stop_turning()
sys.exit(0)
def main():
web_server = WebServer(teams)
web_server.start()
print "Start ZMQ response server."
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind("tcp://*:5555")
while True:
print "Waiting for next request..."
message = socket.recv()
max = len(message)
max = 150 if max > 150 else max
print "Request: ", message[:max]
answer = processRequest(message)
socket.send(answer)
print "\tResponse: ", answer
web_server.stop()
# local imports from PassScheduler import PassScheduler from WebServer import WebServer scheduler = PassScheduler() webserver = WebServer(scheduler) scheduler.start() webserver.start() input()
### MAIN ###
import signal
import sys
import time
import RPi.GPIO as GPIO
from WebServer import WebServer
GPIO.setwarnings(False)
def shutdownServer(sig, unused):
server.shutdown()
print('Clean-up')
GPIO.cleanup()
time.sleep(1)
sys.exit(1)
signal.signal(signal.SIGINT, shutdownServer)
server = WebServer(10000)
server.start()
print("Press Ctrl+C to shut down server.")
def main():
ws = WebServer()
signal(SIGINT, ws.endServer)
ws.start()
class Game(QWidget):
def __init__(self, m):
QWidget.__init__(self)
self.gameVar = GameVar() # Contient tout les variables du jeu
self.MW = m
self.on_click
try:
self.initSerial()
except serial.SerialException as e:
print("Erreur connexion Arduino")
self.gameVar.error += str(e)
print(e)
self.ws = WebServer(self.gameVar, self)
self.ws.start()
def checkSensor(self):
gv = self.gameVar
try:
self.ser.write(gv.sendArduino().encode())
line = self.ser.readline()
gv.interprete(line.decode('utf-8').rstrip())
except Exception as e:
self.gameVar.error = str(e)
if not gv.defaite and not gv.pause and not gv.stressMode:
Simon.checkSimon(self)
Fils.checkFils(self)
Symbole.checkSymbole(self)
checkBouton(self)
if gv.stressMode and gv.stressModeStarted:
StressMode.checkStressMode(self)
def erreurGlobal(self, module):
self.gameVar.moduleErr[module] += 1
self.gameVar.nbErreur = sum(self.gameVar.moduleErr)
self.gameVar.sounds["error"].play()
if self.gameVar.nbErreur > self.gameVar.nbErreurMax:
self.defaite()
else:
for i in range(4):
if i < self.gameVar.nbErreur:
self.gameVar.chronoLedErr[i] = 1
else:
self.gameVar.chronoLedErr[i] = 0
if self.gameVar.moduleErr[module] == 1 and module != 5:
Chrono.removeXmMin(self, 3)
elif self.gameVar.moduleErr[module] > 1 and module != 5:
Chrono.removeXmMin(self, 1)
def bip(self):
if self.gameVar.pause:
return
if self.gameVar.stressMode:
self.gameVar.sounds["bip2"].play()
elif self.gameVar.chronoBoutonSon:
self.gameVar.sounds["bip"].play()
Chrono.chrono(self)
def initSerial(self):
self.ser = ""
try:
self.ser = serial.Serial('/dev/ttyUSB0', 19200, timeout=1)
except:
try:
self.ser = serial.Serial('/dev/ttyUSB1', 19200, timeout=1)
except Exception as e:
raise e
print(self.ser.write("initialisation\n".encode()))
line = self.ser.readline()
self.gameVar.serialOK = 1
def start(self):
Fils.initFils(self.gameVar)
Symbole.initSymbole(self.gameVar)
Simon.initSimon(self.gameVar)
ScreenGame.paintButton(self)
self.timerBip = QtCore.QTimer()
self.timerBip.timeout.connect(self.bip)
self.timerBip.start(1000)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.checkSensor)
self.timer.start(50)
self.timerLumiere = QtCore.QTimer()
self.timerLumiere.timeout.connect(
lambda: Simon.lumiereSimon(self.gameVar))
self.timerLumiere.start(500)
@pyqtSlot()
def on_click(self):
print("lala")
btn = self.sender()
guess(self, btn)
def victoire(self):
self.gameVar.pause = 1
self.gameVar.sounds["victoire"].play()
self.timerBip.stop()
self.gameVar.moduleWin = [1, 1, 1, 1, 1]
self.gameVar.lumSimon = [0, 0, 0, 0]
self.gameVar.symboleLum = [0, 0, 0, 0]
self.gameVar.boutonBande = [0, 1, 0]
self.gameVar.chronoLum = 1
self.gameVar.chronoBlink = 0
if self.gameVar.escapeGame:
self.timerStress.stop()
self.gameVar.stressModeStarted = 0
self.MW.stackSetup.setCurrentIndex(4)
self.MW.win.reloadChrono()
def defaite(self):
if self.gameVar.defaite: # defaite() déjà appelé
return
print("defaite")
if self.gameVar.stressModeStarted == 1:
try:
self.gameVar.sounds["stress"].stop()
except:
pass
self.gameVar.chronoBlink = 1
self.gameVar.chronoLum = 2
self.gameVar.defaite = True
self.timerLumiere.stop()
self.timerBip.stop()
self.gameVar.sounds["defaite"].play()
QTimer().singleShot(14000, self.retourMenu)
QTimer().singleShot(3200, self.callbackDefaite)
self.gameVar.moduleWin = [0, 0, 0, 0, 0]
self.blink = 30
def callbackDefaite(self):
self.gameVar.chronoLum = 0
self.gameVar.chronoBlink = 0
self.gameVar.chronoLedErr = [1, 1, 1, 1]
self.gameVar.simonErreur = 1
self.gameVar.calcErreur = 1
self.gameVar.symboleErreur = 1
self.gameVar.boutonErreur = 1
self.gameVar.filErreur = 1
self.gameVar.lumSimon = [1, 1, 1, 1]
self.gameVar.symboleLum = [1, 1, 1, 1]
self.gameVar.boutonBande = [1, 1, 1]
QTimer().singleShot(50, self.callbackDefaiteBlink)
def callbackDefaiteBlink(self):
self.gameVar.chronoLedErr = [0, 0, 0, 0]
self.gameVar.simonErreur = 0
self.gameVar.calcErreur = 0
self.gameVar.symboleErreur = 0
self.gameVar.boutonErreur = 0
self.gameVar.filErreur = 0
self.gameVar.moduleErr = [1, 1, 1, 1, 1]
self.gameVar.lumSimon = [0, 0, 0, 0]
self.gameVar.symboleLum = [0, 0, 0, 0]
self.gameVar.boutonBande = [0, 0, 0]
self.blink -= 1
if self.blink > 0:
QTimer().singleShot(50, self.callbackDefaite)
def retourMenu(self):
self.gameVar.reset()
self.MW.stackSetup.setCurrentIndex(0)
self.MW.setup.mPrincipal()
def slot_repaint(self):
eraseAll(self)
paintButton(self)
def slot_win_screenGame(self):
win(self)
def exit(self):
self.ws.exit()
# simulate different request coming into the system
from WebServer import WebServer, Request, Action
configMap = {"numberToServe": 10, "data_dir": "DATA"}
server = WebServer(configMap)
server.start(
) # load all the data in the database, start the first model training
# now experiment
reqX1 = Request(userId='X1')
req1 = Request(userId=1)
print(reqX1)
print(req1)
recX1 = server.renderRec(reqX1) # output recommendations
print(recX1)
rec1 = server.renderRec(req1) # output recommendations
print(rec1)
# now we start an action
action1 = Action(1, 255, 5) # user 1 rated item 255 as score 5
print(server.getFromInventory(255)) # find out the name of item 255
server.getAction(action1) # feed the action to the server
rec1_afteraction = server.renderRec(
req1) # get recommendation after the system knows about the action
print(rec1_afteraction)
actionX1 = Action('X1', 123,
5) # anonymous user's action won't be saved in database
class ClusterServer(Factory):
"""ClusterServer is the root class for the server.
It maintains the database and listens for incoming connections.
"""
protocol = WorkerConnection
versionNumber = (1, 45)
def __init__(self, db):
self.db = db
self.workProvider = WorkProvider(self)
self.workers = []
self.web = None
self.configCallbacks = {}
def getConfig(self, var, type=str, default=None, callback=None):
"""Reads a configuration variable out of the database.
Will attempt to convert it into the specified type. If the variable
is not found, or type conversion fails, returns the default.
"""
# Take care of the callback first, before encountering any returns...
if callable(callback):
callbacks = self.configCallbacks.setdefault(var, [])
if callback not in callbacks:
callbacks.append(callback)
# This should only loop once.
for value, in self.db.execute(
'SELECT value FROM config WHERE var=? '
'LIMIT 1;', (var, )):
try:
value = type(value)
except (TypeError, ValueError):
return default
else:
return value # Type-converted
# Variable is not present in the database.
return default
def getAllConfig(self):
"""Retrieves all configuration values from the database."""
config = {}
for var, value in self.db.execute('SELECT var, value FROM config;'):
config[var] = value
return config
def setConfig(self, var, value):
"""Writes a configuration variable to the database.
The value is type-converted to a string for storage.
"""
# There might be an old definition, so take it out if so.
self.db.execute('DELETE FROM config WHERE var=?;', (var, ))
if value is not None: # Setting to None means the variable gets cleared.
self.db.execute('INSERT INTO config (var,value) VALUES (?,?);',
(var, str(value)))
# Now inform any waiting callbacks...
for callback in self.configCallbacks.get(var, []):
callback()
def listAccountConnections(self, username):
"""List every connected, logged-in worker using the specified username.
The username is case-sensitive.
"""
return filter(lambda x: x.account and x.account.username == username,
self.workers)
def getConnection(self, sessionno):
"""Gets a connection by its session ID."""
for w in self.workers:
if w.transport.sessionno == sessionno:
return w
def start(self):
"""Sets up the server to listen on a port and starts all subsystems."""
port = self.getConfig('server_port', int, 8880)
ip = self.getConfig('server_ip', str, '')
reactor.listenTCP(port, self, interface=ip)
self.web = WebServer(self)
self.web.start()
self.workProvider.start()
class ClusterServer(Factory):
"""ClusterServer is the root class for the server.
It maintains the database and listens for incoming connections.
"""
protocol = WorkerConnection
versionNumber = (1, 45)
def __init__(self, db):
self.db = db
self.workProvider = WorkProvider(self)
self.workers = []
self.web = None
self.configCallbacks = {}
def getConfig(self, var, type=str, default=None, callback=None):
"""Reads a configuration variable out of the database.
Will attempt to convert it into the specified type. If the variable
is not found, or type conversion fails, returns the default.
"""
# Take care of the callback first, before encountering any returns...
if callable(callback):
callbacks = self.configCallbacks.setdefault(var, [])
if callback not in callbacks:
callbacks.append(callback)
# This should only loop once.
for (value,) in self.db.execute("SELECT value FROM config WHERE var=? " "LIMIT 1;", (var,)):
try:
value = type(value)
except (TypeError, ValueError):
return default
else:
return value # Type-converted
# Variable is not present in the database.
return default
def getAllConfig(self):
"""Retrieves all configuration values from the database."""
config = {}
for var, value in self.db.execute("SELECT var, value FROM config;"):
config[var] = value
return config
def setConfig(self, var, value):
"""Writes a configuration variable to the database.
The value is type-converted to a string for storage.
"""
# There might be an old definition, so take it out if so.
self.db.execute("DELETE FROM config WHERE var=?;", (var,))
if value is not None: # Setting to None means the variable gets cleared.
self.db.execute("INSERT INTO config (var,value) VALUES (?,?);", (var, str(value)))
# Now inform any waiting callbacks...
for callback in self.configCallbacks.get(var, []):
callback()
def listAccountConnections(self, username):
"""List every connected, logged-in worker using the specified username.
The username is case-sensitive.
"""
return filter(lambda x: x.account and x.account.username == username, self.workers)
def getConnection(self, sessionno):
"""Gets a connection by its session ID."""
for w in self.workers:
if w.transport.sessionno == sessionno:
return w
def start(self):
"""Sets up the server to listen on a port and starts all subsystems."""
port = self.getConfig("server_port", int, 8880)
ip = self.getConfig("server_ip", str, "")
reactor.listenTCP(port, self, interface=ip)
self.web = WebServer(self)
self.web.start()
self.workProvider.start()
