def main(port, brain_wallet, db): global DEFAULT_BRAIN global DB DEFAULT_BRAIN = brain_wallet DB = db ip = '' http.server(DB, port, page1, home)
def start(self, port=DEFAULT_PORT, blocking=True): if self._httpd: self.open() return if not port: #None or 0 port = random.randint(50080, 59080) self.port = port self.init = True #http.server.SimpleHTTPRequestHandler #ViewerHandler #handler = ViewerHandler handler = HandlerFactory(self.parser) #http.socketserver.TCPServer #http.server.HTTPServer #ThreadedHTTPServer server = ThreadedHTTPServer address = ('localhost', port) self._httpd = server(address, handler) if blocking: try: self._serve() except KeyboardInterrupt: pass #finally: #external # self.stop() else: self._thread = threading.Thread(target=self._serve) self._thread.daemon = True self._thread.start()
def run(self): server = http.server.ThreadingHTTPServer handler = self.HttpRequestHandler port = 5151 with server(("", port), handler) as httpd: httpd.serve_forever()
def send_head(self): i = io.BytesIO() if self.path[:19] == "/cgi/chat_server.py": tmp = server(self.path[9:]) self.send_response(tmp[0]) data = tmp[1] self.send_header("Pragma", "No-cache") self.send_header("Cache-Control", "no-cache") i.write(bytes(data.encode("gb2312"))) # 在中国貌似浏览器都用的gbk编码 这是微软的锅 else: path = self.translate_path( self.path if self.path != '/' else "/index.html") try: f = open(path, 'rb') self.send_response(200) if len(self.path) < 2 or ".html" in self.path: self.send_header("Content-type", "text/html") elif ".css" in self.path: self.send_header("Content-type", "text/css") data = f.read() i.write(data) except OSError: self.send_error(404, self.path + "File not found.\n") return None i.seek(0) # 移动光标至初始 return i
def run(server=Server.HTTPServer, handler=EchoServer): httpd = server((listen['ip'], listen['port']), handler) try: httpd.serve_forever() except KeyboardInterrupt: pass httpd.server_close()
def run(self): server = BaseHTTPServer.HTTPServer bind_to = ('127.0.0.1', 8091) reqhandler = Handler httpd = server(bind_to, reqhandler) self.ready.set() for i in range(self.numtests): httpd.handle_request()
def start_server(self, func): myHandler.func = func address = (self.host, self.port) self.server = server(address, myHandler) print('Started httpserver on port %d' % self.port) self.server.serve_forever() host, port = self.server.socket.getsockname()[:2] print(host)
def web_server(port): server = http.server.HTTPServer handler = CGIHTTPServer.CGIHTTPRequestHandler #RequestsHandler server_address = ("", port) handler.cgi_directories = ["/cgi-bin", ] httpd = server(server_address, handler) print(f'Starting web server with CGI support on port: {port}') httpd.serve_forever()
def web_server(port): server = http.server.HTTPServer handler = http.server.CGIHTTPRequestHandler server_address = ("",port) handler.cgi_directories = ["/cgi-bin" ] httpd = server(server_address,handler) print("Starting web server with CGI support on port: {!s} ...".format(port)) httpd.serve_forever()
def run(self): global area area.type = 'VIEW_3D' server = http.server.HTTPServer self.httpd = server(self.server_address, myHandler) global timeInit timeInit = time.process_time() bpy.context.scene.frame_set(0) self.httpd.serve_forever()
def main_monitor(port, vehicle, lock): print("run_monitor") server_address = ("", port) server = http.server.HTTPServer handler = S handler.vehicle = vehicle handler.lock = lock print("Serveur actif sur le port :", port) httpd = server(server_address, handler) httpd.serve_forever()
def start_server(): server, handler = http.server.HTTPServer, SilentServer httpd = server(("", port), handler) sa = httpd.socket.getsockname() print("Serving HTTP on", sa[0], "port", sa[1], "...") print("Type Ctrl-C to exit.") try: httpd.serve_forever() finally: httpd.server_close()
def run(server=http.server.HTTPServer, handler=http.server.BaseHTTPRequestHandler): address = (IP, PORT) httpd = server(address, handler) print(time.asctime(), "Server starts - %s:%s" % address) try: httpd.serve_forever() except KeyboardInterrupt: pass httpd.server_close() print(time.asctime(), "Server stops - %s:%s" % address)
def main_monitor(port, vehicle, sensors_lock, on_off_lock): server_address = ("", port) server = http.server.HTTPServer handler = S print("Serveur actif sur le port :", port) httpd = server(server_address, handler) handler.vehicle = vehicle handler.sensors_lock = sensors_lock handler.on_off_lock = on_off_lock httpd.serve_forever()
def lauchServer(PORT=8888, IP=""): server_address = (IP, PORT) server = http.server.HTTPServer handler = http.server.CGIHTTPRequestHandler handler.cgi_directories = ["//"] print("Serveur actif sur le port :", PORT) httpd = server(server_address, handler) httpd.serve_forever()
def start_server(): server, handler = http.server.HTTPServer, SilentServer httpd = server(('', 8000), handler) sa = httpd.socket.getsockname() print('Serving HTTP on', sa[0], 'port', sa[1], '...') print('Type Ctrl-C to exit.') try: httpd.serve_forever() finally: httpd.server_close()
def run(self): """ Démarrage du service web """ server_address = ("", Constantes.httpPort) server = http.server.HTTPServer handler = http.server.CGIHTTPRequestHandler handler.cgi_directories = ["/"] affichage = "Server up on port : " + str(Constantes.httpPort) print(affichage) httpd = server(server_address, handler) httpd.serve_forever()
def runserver(server, handler, protocol="HTTP/1.0", port=80, bind=""): server_address = (bind, port) handler.protocol_version = protocol httpd = server(server_address, handler) sa = httpd.socket.getsockname() sever_message = "Serving HTTP on {host} port {port}" try: httpd.serve_forever() except KeyboardInterrupt: print('\nKeyboard interrupt recieved') sys.exit(0)
def main(args): build_dir = args.build_dir port = args.port httpd = server(port) os.chdir(build_dir) print("serving from {0} at localhost:".format(build_dir) + str(port)) try: httpd.serve_forever() except KeyboardInterrupt: print("\n...shutting down http server") httpd.shutdown() sys.exit()
def main(args): build_dir = pathlib.Path(args.build_dir).resolve() port = args.port httpd = server(port) os.chdir(build_dir) print(f"serving from {build_dir} at localhost:{port}") try: httpd.serve_forever() except KeyboardInterrupt: print("\n...shutting down http server") httpd.shutdown() sys.exit()
def server_site(site, port, watching, renderer, render_kwargs): site_dir = config.sites[site]['path'] msg_file = render_kwargs['msg_file'] output_dirname = render_kwargs['output_dirname'] output_dir = os.path.join(site_dir, output_dirname) current_dir = os.getcwd() # start watch thread(optional) watch_thread = None if watching: regex = re.compile(r'(\.md$|{})'.format(output_dirname)) watch_thread = WatchThread(site_dir, output_dir, renderer, render_kwargs, regex, msg_file) watch_thread.start() # start server in main thread, so that KeyboardInterrupt can be captured try: server(current_dir, output_dir, port, msg_file) except KeyboardInterrupt: # elegant termination watcher thread if watch_thread is not None: watch_thread.stop() watch_thread.join() message('Server', 'Bye, Bye!', msg_file)
def main(): try: args = parser().parse_args() project_path = args.path[0] except IndexError: parser.print_help() sys.exit(1) print(args) if args.serve: server() elif args.build: builder() elif args.new: vite.create_project(project_path) else: parser().print_help() sys.exit(1) if len(sys.argv) == 1: parser.print_help() sys.exit(1)
def __init__(self, robot, webport=8000, name=DEFAULT_NAME, auto=True): """ Initialisation de la tâche. Un serveur Web est instancié. :param robot: Robot propriétaire de de la tâche. :param webport: Port réseau utilisé par le serveur Web (8000 par défaut) :param name: Nom de la tâche ("RobotWeb" par défaut). :param auto: Indicateur si la tâche est automaitquement démarrée. """ super().__init__(robot, name=name, auto=auto) server = http.server.HTTPServer self._httpd = server(("", webport), self._getHttpHandler())
def runServer(q): global myQueue myQueue = q PORT = 8888 server_address = ("", PORT) server = http.server.HTTPServer handler = MyHandler handler.cgi_directories = ["/"] print("\t\tServeur actif sur le port :", PORT) httpd = server(server_address, handler) httpd.serve_forever()
def __init__(self): Thread.__init__(self) global httpd import http.server PORT = 8888 server_address = ("", PORT) server = http.server.HTTPServer handler = http.server.CGIHTTPRequestHandler handler.cgi_directories = ["/cgi"] httpd = server(server_address, handler)
def run(server_class=HTTPServer, handler_class=S, addr="localhost", port=7000, allData=None): server_address = ("", port) server = http.server.HTTPServer handler = S#http.server.CGIHTTPRequestHandler handler.cgi_directories = ["/index.html"] handler.allData = allData print("Serveur actif sur le port :", port) httpd = server(server_address, handler) print("Before") thread1 = threading.Thread(target = httpd.serve_forever) thread1.start()
def httpServerMain(self): server = http.server.HTTPServer # use handler = http.server.SimpleHTTPRequestHandler to get http logs handler = quietServer print("Viewer actif sur le port :", self.port) web_dir = os.path.join(os.path.dirname(__file__), 'res/html_root') os.chdir(web_dir) cgitb.enable() server_address = ("", self.port) httpd = server(server_address, handler) httpd.serve_forever()
def run(handler=RequestHandler,port=80,apps=[App], server=socketserver.ThreadingTCPServer, address_family=socket.AF_INET): server.address_family=address_family import Karrigell.check_apps Karrigell.check_apps.check(apps) handler.apps = apps handler.alias = {} for app in apps : root_url = app.root_url.lstrip('/') for host in app.hosts : handler.alias[(host, root_url)] = app s=server(('',port),handler) print("%s %s running on port %s (%s)" %(handler.name,version,port, {socket.AF_INET : "IPV4", socket.AF_INET6 : "IPV6"}[address_family])) s.serve_forever()
def web_server(port): server = http.server.HTTPServer # Comment out the above line and uncomment the below for Python 2.7.x. #server = BaseHTTPServer.HTTPServer handler = http.server.CGIHTTPRequestHandler #RequestsHandler # Comment out the above line and uncomment the below for Python 2.7.x. #handler = CGIHTTPServer.CGIHTTPRequestHandler #RequestsHandler server_address = ("", port) handler.cgi_directories = [ "/cgi-bin", ] httpd = server(server_address, handler) print("Starting web server with CGI support on port: %s ..." % port) httpd.serve_forever()
def main(): parser = argparse.ArgumentParser(description='HTTP Server for G2D3') parser.add_argument('--bind', '-b', default='', metavar='ADDRESS', help='Specify alternate bind address ' '[default: all interfaces]') parser.add_argument('port', action='store', default=8000, type=int, nargs='?', help='Specify alternate port [default: 8000]') args = parser.parse_args() handler = G2D3HTTPRequestHandler server = http.server.HTTPServer server_address = (args.bind, args.port) httpd = server(server_address, handler) print('G2D3Server serving HTTP on',args.bind,'port',args.port,'...') httpd.serve_forever()
#python3 -m server.py import http.server PORT = 8888 server_address = ("", PORT) server = http.server.HTTPServer handler = http.server.CGIHTTPRequestHandler handler.cgi_directories = ["./"] print("Serveur actif sur le port :", PORT) httpd = server(server_address, handler) httpd.serve_forever()
btn.pack() screen.geometry("800x900") out = output(txt2) sys.stdout = out #####sys.stderr=out sys.stdin = ainput(txt2) screen.bind("<F5>", run) import glob with open("_extension.py") as ext: exec(ext.read()) for x in glob.glob("_*.py"): with open(x) as ext: exec(ext.read()) import socket # create an INET, STREAMing socket serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # bind the socket to a public host, and a well-known port serversocket.bind((socket.gethostname(), serverport)) built = "starting" # become a server socket serversocket.listen(5) x = server() x.start() editmenu.add_command(label="archive code from other server(running idle)", command=doclient) while True: built = txt.get('1.0', END) screen.update_idletasks() screen.update()
PORT = 8002 class HTTPRequestHandler(http.server.SimpleHTTPRequestHandler): def do_GET(self): if self.path == "/" or self.path == "/index.html": self.path = "/build/index.html" super().do_GET() def end_headers(self): self.send_header('Access-Control-Allow-Origin', '*') self.send_header('Access-Control-Allow-Methods', 'GET, POST') http.server.SimpleHTTPRequestHandler.end_headers(self) def server(s_port): return socketserver.TCPServer(('', s_port), HTTPRequestHandler) if __name__ == "__main__": port = PORT httpd = server(port) try: os.chdir('.') print("\Starting server at 127.0.0.1:" + str(port)) httpd.serve_forever() except KeyboardInterrupt: print("\n...shutting down http server") httpd.shutdown() sys.exit()
def main(port, brain_wallet, db): global DB DB = db ip = '' http.server(DB, port, page1, home)
#!/usr/bin/env python3 # above 'she-bang' line makes the script executable from command line """ A Simple Web Server Run with ./simpleServer.py Make sure all cgi scripts are executable for single script: chmod +x simpleServer.py or for a whole directory: chmod -r +x cgi-bin/ """ import http.server # import http.server module import cgitb; cgitb.enable() # import and enable cgitb module for exception handling PORT = 8000 # specifies the port number to accept connections on server = http.server.HTTPServer # provides simple web server handler = http.server.CGIHTTPRequestHandler # provides request handler server_address = ("", PORT) # specify server directory and port number handler.cgi_directories = ["/","/cgi-bin","/htbin"] # where CGI scripts will reside in relation to the `server' directory print("Starting server...") # outputs a message httpd = server(server_address, handler) # creates the server, passing it the server address and port number, as well as the CGI handler (httpd stands for HTTP Daemon) print("serving at port", PORT) # outputs a message httpd.serve_forever() # puts program in infinite loop so that the server can `serve_forever'
import sys import codecs sys.stdout = codecs.getwriter("utf-8")(sys.stdout.detach()) host = '' port = **** address = (host, port) server = http.server.HTTPServer handler = http.server.CGIHTTPRequestHandler handler.cgi_directories = ["/"] httpd = server(address, handler) print (f"Server running on the port {port}") httpd.serve_forever() ''' import http.server import socketserver host = '' port = 80 address = ('', port) handler = http.server.SimpleHTTPRequestHandler
import http #Create an HTTP server to handle responses */ http.server(request, response) response.writeHead(200, {"Content-Type": "text/plain"}) response.write("Hello World") response.end() respose.listen(8888)
def cgi_server(cgi_directory): server = http.server.HTTPServer handler = http.server.CGIHTTPRequestHandler server_address = ("", 8000) handler.cgi_directories = [cgi_directory] return server(server_address, handler)
def main(): if len(sys.argv) > 1: port = int(sys.argv[1]) server(("", port)) else: client()
data = [] while True: line = self.rfile.readline() line = line.rstrip() length = int(line, 16) if length != 0: data.append(self.rfile.read(length)) self.rfile.read(2) # ignore CRLF if length == 0: break data = b"".join(data) self.wfile.write(data) else: self._404() def server(ready, host, port): server_address = (host, port) httpd = HTTPServer(server_address, Handler) ready.set() httpd.serve_forever() if __name__ == "__main__": ready = threading.Event() srv = threading.Thread(target=lambda: server(ready, "", 8090)) srv.daemon = True srv.start() ready.wait() sys.exit(subprocess.call(sys.argv[1:], stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr))
import http.server server = http.server.HTTPServer handler = http.server.SimpleHTTPRequestHandler httpd = server(('', 80), handler) httpd.serve_forever()
#!/usr/bin/python import http.server import cgitb; cgitb.enable() ## This line enables CGI error reporting server = http.server.HTTPServer handler = http.server.CGIHTTPRequestHandler server_address = ("", 8000) handler.cgi_directories = ["/cgi"] httpd = server(server_address, handler) httpd.serve_forever()