class server(object): def __init__(self, offtime): self.offtime = offtime self.server = TCPServer( ('127.0.0.1', 7654), BaseRequestHandler ) self.server_thread = None self.server.running = False def shutdown(self, signum, frame): print("[*] Shutting down server thread") self.server.running = False self.server.shutdown() def up(self): signal.signal(signal.SIGTERM, self.shutdown) signal.signal(signal.SIGINT, self.shutdown) signal.signal(signal.SIGALRM, self.shutdown) signal.alarm(self.offtime) self.server_thread = threading.Thread(target=self.server.serve_forever) print("[*] Starting server thread") self.server_thread.start() self.server.running = True print("[*] Waiting for server thread to shut down") while self.server.running: time.sleep(1) self.server_thread.join() print("[*] Server thread terminated")
class PickleServer: def __init__(self, address): ''' @param address: A tuple of ip and port. For example, PickleServer(('127.0.0.1', 3750)) ''' handler = self.handle from socketserver import StreamRequestHandler class Handler(StreamRequestHandler): def handle(self): from pclib import iostream stream = iostream(self.rfile, self.wfile) stream = PickleStream(stream) handler(stream) from socketserver import TCPServer self.server = TCPServer(address, Handler) def start(self): from threading import Thread Thread(target = self.run).start() def run(self): self.server.serve_forever() def shutdown(self): self.server.shutdown() def handle(self, stream): pass
def main(): sys.excepthook = Pyro4.util.excepthook print("Welcome to the prototype !\n") print("Would you like to be [s]erver or [c]lient? (s/c)") user_interaction = input(":> ").strip() if "s" == user_interaction: print("Please enter the IP-Address which the server should listen on.") ip_adr = input(":> ").strip() rl_ip_adr = Pyro4.socketutil.getInterfaceAddress(ip_adr) print("\nIMPORTANT: The Server will listen on: %s" % rl_ip_adr) HOST, PORT = rl_ip_adr, 20111 daemon = Pyro4.Daemon(host=rl_ip_adr) srv_uri = daemon.register(Server()) tcpserver = TCPServer((HOST, PORT), lambda *args, **keys: SingleTCPHandler(send_server_uri, srv_uri.asString(), *args, **keys)) t = threading.Thread(target=tcpserver.serve_forever) t.start() print("Serving...") daemon.requestLoop() tcpserver.shutdown() elif "c" == user_interaction: print("Please enter your name.") name = input(":> ").strip() print("Please enter the ip of the server.") srv_ip = input(":> ").strip() client = Client(name, srv_ip) clt_uri = client.get_uri().asString() TCPSender.send(clt_uri, (srv_ip, 20111)) client.start() while client.is_running(): time.sleep(1) contact = Contact(name, client.get_srv_uri()) contact.register() input("Press Enter to exit.") contact.deregister()
def iiif_server(): address = ('localhost', 0) httpd = TCPServer(address, SimpleHTTPRequestHandler) t = threading.Thread(target=httpd.serve_forever) t.start() yield httpd.server_address httpd.shutdown() t.join()
def start_server_for_ips(): serv = TCPServer(('', 20007), EchoHandler) ser = Thread(target=serv.serve_forever) ser.start() global members_count members_count = 2 while members_count: sleep(1) serv.shutdown()
def serve(self): self.monitor() os.chdir(self.directory) request_handler = server.SimpleHTTPRequestHandler httpd = TCPServer(('', self.port), request_handler) try: print('Preview available at http://0.0.0.0:{}/'.format(self.port)) httpd.serve_forever() except KeyboardInterrupt: httpd.shutdown()
class SimpleServer(Thread): def __init__(self): Thread.__init__(self) self.httpd = None def run(self): chdir(root + "/_site") self.httpd = TCPServer(('', 8000), SimpleHTTPRequestHandler) self.httpd.serve_forever() def shutdown(self): self.httpd.shutdown()
class HTTPServerThread(threading.Thread): def __init__(self): super().__init__() self.host = 'localhost' self.httpd = TCPServer((self.host, 0), HTTPRequestHandler) self.port = self.httpd.socket.getsockname()[1] self.url = 'http://%s:%d' % (self.host, self.port) def run(self): self.httpd.serve_forever() def shutdown(self): self.httpd.shutdown() self.httpd.server_close()
def run_server(port, site_dir, ctx): output_dir = ctx["OutputDir"] # start server class RequestHandler(SimpleHTTPRequestHandler): def do_GET(self): if hasattr(self, "error") and self.error is not None: self.send_response(200, 'OK') self.send_header('Content-type', 'html') self.end_headers() self.wfile.write(bytes(self.error, 'UTF-8')) else: super().do_GET() def translate_path(self, path): return os.path.join(site_dir, output_dir, path[1:]) handler = RequestHandler httpd = TCPServer(("", port), handler) atexit_register(lambda: httpd.shutdown()) # start update thread thread = Thread(target=update, args=(site_dir, ctx, handler, port)) thread.daemon = True thread.start() print("Serving at http://localhost:" + str(port) + "/") httpd.serve_forever()
class netserver: def __init__(self, address, handler): class a(StreamRequestHandler): def handle(self): stream = iostream(self.rfile, self.wfile) stream = objectstream(stream) handler(stream) self._server = TCPServer(address, a) def start(self): Thread(target = self.run).start() def run(self): self._server.serve_forever() def shutdown(self): self._server.shutdown()
class GitTimeoutTest(unittest.TestCase): class MuteHandler(BaseRequestHandler): def handle(self): data = True while data: data = self.request.recv(1024) @classmethod def setUpClass(self): self.mute_server = TCPServer(('localhost', 0), GitTimeoutTest.MuteHandler) _, self.mute_port = self.mute_server.server_address serv_thread = threading.Thread(target=self.mute_server.serve_forever) serv_thread.daemon = True serv_thread.start() self.root_directory = tempfile.mkdtemp() self.local_path = os.path.join(self.root_directory, "ros") def test_checkout_timeout(self): ## SSH'ing to a mute server will hang for a very long time url = 'ssh://[email protected]:{0}/test'.format(self.mute_port) client = GitClient(self.local_path) start = time.time() self.assertFalse(client.checkout(url, timeout=2.0)) stop = time.time() self.assertTrue(stop - start > 1.9) self.assertTrue(stop - start < 3.0) # the git processes will clean up the checkout dir, we have to wait # for them to finish in order to avoid a race condition with rmtree() while os.path.exists(self.local_path): time.sleep(0.2) @classmethod def tearDownClass(self): self.mute_server.shutdown() if os.path.exists(self.root_directory): shutil.rmtree(self.root_directory) def tearDown(self): if os.path.exists(self.local_path): shutil.rmtree(self.local_path)
def shutdown(self): """Completely shutdown the server and close it's socket.""" TCPServer.shutdown(self) self.server_close()
def shutdown(self): return TCPServer.shutdown(self)
def shutdown(self): TCPServer.shutdown(self) TCPServer.server_close(self) self.trd.join() del self.trd
content = json.dumps(data).encode("utf-8") return content.strip() def do_HEAD(self): self._headers() def do_GET(self): self._headers() self.wfile.write(self._content()) def do_POST(self): length = int(self.headers.get("Content-Length")) data = self.rfile.read(length) self._headers() self.wfile.write(self._content(data.decode("utf-8")).encode("utf-8")) if __name__ == "__main__": HOST, PORT = "localhost", 8001 try: httpd = TCPServer((HOST, PORT), RequestHandler) print("Serving HTTP at port", PORT) httpd.serve_forever() except KeyboardInterrupt: print("Shutting down HTTP server") httpd.shutdown() httpd.server_close() print()
from socketserver import TCPServer from socketserver import StreamRequestHandler from time import ctime import utils HOST = '' PORT = 21567 ADDR = (HOST, PORT) class TimeRequestHandler(StreamRequestHandler): def handle(self): print("...connection from: ", self.client_address) msg = '[%s] %s' % (ctime(), utils.ensure_unicode(self.rfile.readline()).strip()) print(msg) self.wfile.write(utils.ensure_bytes(msg)) tcp_server = TCPServer(ADDR, TimeRequestHandler) try: tcp_server.serve_forever() except KeyboardInterrupt as err: tcp_server.shutdown()
def shutdown(self): if self._serving_event.is_set(): self._shutdown_request_event.set() self._serving_event.clear() TCPServer.shutdown(self)
def stop_http_server(httpd: TCPServer): _logger.debug('stop_http_server - stopping server') httpd.shutdown()