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 shutdown(self):
TCPServer.shutdown(self)
TCPServer.server_close(self)
self.trd.join()
del self.trd
def stop_http_server(httpd: TCPServer):
_logger.debug('stop_http_server - stopping server')
httpd.shutdown()
