def run(self):
os.chdir(self.project['target-path'])
port = self.args.port
shutil.copyfile(DOCS_INDEX_FILE_PATH, 'index.html')
logger.info("Serving docs at 0.0.0.0:{}".format(port))
logger.info(
"To access from your browser, navigate to http://localhost:{}.".
format(port))
logger.info("Press Ctrl+C to exit.\n\n")
httpd = TCPServer(('0.0.0.0', port), SimpleHTTPRequestHandler)
try:
webbrowser.open_new_tab('http://127.0.0.1:{}'.format(port))
except webbrowser.Error as e:
pass
try:
httpd.serve_forever() # blocks
finally:
httpd.shutdown()
httpd.server_close()
return None
def _start_web_server():
global http_server
from http.server import SimpleHTTPRequestHandler
from socketserver import TCPServer
try:
if need_chdir:
os.chdir(root)
handler = SimpleHTTPRequestHandler
else:
handler = partial(SimpleHTTPRequestHandler, directory=root)
http_server = TCPServer(("", 8000),
handler,
bind_and_activate=False)
http_server.daemon_threads = True
http_server.allow_reuse_address = True
http_server.server_bind()
http_server.server_activate()
http_server_ready.set()
http_server.serve_forever()
except:
import traceback
traceback.print_exc()
finally:
http_server = None
http_server_ready.set()
if need_chdir:
os.chdir(curr_dir)
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()
def serve_forever(uwsgi_addr,
uwsgi_host=None,
local_addr='',
redirect_static=True):
uwsgi_addr, uwsgi_port = parse_addr(uwsgi_addr, 3030)
local_addr = parse_addr(local_addr, uwsgi_port)
print('Proxying remote uWSGI server %s:%s "%s" to local HTTP server '
'%s:%s...' % (uwsgi_addr, uwsgi_port,
(uwsgi_host or ''), local_addr[0], local_addr[1]))
TCPServer.allow_reuse_address = True
s = TCPServer(
server_address=local_addr,
RequestHandlerClass=RequestHandler,
)
s.uwsgi_addr = uwsgi_addr
s.uwsgi_port = uwsgi_port
s.uwsgi_host = uwsgi_host or uwsgi_addr
s.redirect_static = redirect_static
try:
s.serve_forever()
except KeyboardInterrupt:
s.shutdown()
s.server_close()
print(' Bye.')
class TCPCommandListener(threading.Thread):
"""
This listener is to use a SocketServer.TCPServer on the logic for listening commands
the advantage of this version is that is basically a server shipped with python so
more error prone.
It requires the implementation of a Handler class which will contain all the handshaking
logic that was implemented on the original SocketServer (below).
There's a specific TODO on this version: need to find the way to tell the server to stop
once the command execution has completed.
"""
def __init__(self, output_handler):
threading.Thread.__init__(self)
self.handshake = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(8))
self.close_key = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(8))
self._server = TCPServer(('127.0.0.1', 0), lambda r, c, s: HandShakeHandler(r, c, s, (self.handshake, self.close_key), output_handler), False)
self._server.server_bind()
self.port = self._server.server_address[1]
def run(self):
self._server.server_activate()
self._server.serve_forever()
class SocketServerExtension(Extension):
'''
Socket Server
最初用于实现与 Etoys 互操作: https://blog.just4fun.site/post/%E5%B0%91%E5%84%BF%E7%BC%96%E7%A8%8B/etoys-learning-note/
socket client -> Scratch
'''
NODE_ID = "eim/extension_socket_server"
HELP_URL = "https://adapter.codelab.club/extension_guide/socket_server/" # Documentation page for the project
VERSION = "1.0" # extension version
DESCRIPTION = "Socket Server"
ICON_URL = ""
REQUIRES_ADAPTER = "" # ">= 3.2.0"
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.port = 42001
self.address = '127.0.0.1'
self.socket_server = TCPServer((self.address, self.port),
ScratchEchoHandler)
def extension_message_handle(self, topic, payload):
pass
def run(self):
# 高频消息使用 osc
self.socket_server.serve_forever()
def terminate(self, **kwargs):
self.logger.debug('terminate!')
self.socket_server.shutdown() # 无法外部 shutdown
self.socket_server.server_close()
super().terminate(**kwargs)
def run(self):
os.chdir(self.config.target_path)
port = self.args.port
shutil.copyfile(DOCS_INDEX_FILE_PATH, 'index.html')
logger.info("Serving docs at 0.0.0.0:{}".format(port))
logger.info(
"To access from your browser, navigate to: http://localhost:{}"
.format(port)
)
logger.info("Press Ctrl+C to exit.\n\n")
# mypy doesn't think SimpleHTTPRequestHandler is ok here, but it is
httpd = TCPServer( # type: ignore
('0.0.0.0', port),
SimpleHTTPRequestHandler # type: ignore
) # type: ignore
if self.args.open_browser:
try:
webbrowser.open_new_tab(f'http://127.0.0.1:{port}')
except webbrowser.Error:
pass
try:
httpd.serve_forever() # blocks
finally:
httpd.shutdown()
httpd.server_close()
return None
def get_current_pose_joints(server_ip, server_port, ur_ip, tool_angle_axis):
global script
script = script.replace("{SERVER_ADDRESS}", server_ip)
script = script.replace("{PORT}", str(server_port))
script = script.replace(
"{TCP}",
str([
tool_angle_axis[i] if i >= 3 else tool_angle_axis[i] / 1000.
for i in range(len(tool_angle_axis))
]))
print(script)
ur_available = is_available(ur_ip)
if ur_available:
# start server
server = TCPServer((server_ip, server_port), MyTCPHandler)
send_script(ur_ip, script)
# send file
try:
server.serve_forever()
except:
return list_str_to_list(server.rcv_msg)
def change_socket_configuration():
"""
设置参数 bind_and_activate=False 来修改 socket 参数
设置参数 TCPServer.allow_reuse_address = True， 来允许服务器重新绑定一个
之前使用过的端口号
TCPServer.allow_reuse_address = True
serv = TCPServer(('', 20000), EchoHandler)
serv.serve_forever()
:return:
"""
from socketserver import TCPServer
from socketserver import BaseRequestHandler
from socket import socket
class EchoHandler(BaseRequestHandler):
def handle(self):
print('Got connection from', self.client_address)
while True:
msg = self.request.recv(8192)
print('---receive client message:----', msg)
if not msg:
break
self.request.send(msg)
serv = TCPServer(('', 20000), EchoHandler, bind_and_activate=False)
# Set up various socket options
serv.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
# Bind and activate
serv.server_bind()
serv.server_activate()
serv.serve_forever()
def run(self):
def signal_func(sig, stack):
raise KeyboardInterrupt
signal.signal(signal.SIGTERM, signal_func)
try:
self._logger.info("Start listening for other host's access.")
addr = params.peer_address
access_ip = addr.split(':')[0]
access_port = int(addr.split(':')[1])
peer_server = ThreadingTCPServer((access_ip, access_port),
peers_handler)
peer_server.socket = secure_socket(sock=peer_server.socket,
server_side=True)
listening_thread = threading.Thread(
target=peer_server.serve_forever)
listening_thread.setDaemon(True)
listening_thread.start()
self._logger.info("Device monitor start, listening %s." %
self._proxy_addr)
device_server = TCPServer((self._proxy_ip, self._proxy_port),
device_handler)
device_server.serve_forever()
except KeyboardInterrupt:
self._logger.info("Device monitor receive KeyboardInterrupt.")
device_server.shutdown()
device_server.server_close()
peer_server.shutdown()
peer_server.server_close()
self._logger.info("Device monitor closed.")
def run(host, port):
server = TCPServer((host, port), RequestHandler)
try:
server.serve_forever()
except KeyboardInterrupt:
print("bye")
server.server_close()
def tcpserver(self, host: str, port: int):
callback = self.onecmd
welcome = 'vxi11cmd server, listening on port {}:{}, connected to remote {}.\r\n\r\n'
welcome = welcome.format(host, port, self.address).encode()
class CmdServerHandler(BaseRequestHandler):
def handle(self):
self.request.send(welcome)
buffer = bytearray()
while True:
buffer.extend(self.request.recv(64))
while True:
i = buffer.find(b'\n')
if i == -1:
break
else:
line = bytes(buffer[:i + 1])
buffer[:] = buffer[i + 1:]
command = line.decode().strip()
print(command)
answer = callback(command)
if answer:
self.request.send(answer.encode() + b'\r\n')
server = TCPServer((host, port), CmdServerHandler)
server.serve_forever()
def test1():
'''
spam 函数 原本有4个参数，通过 partial 固定了一个参数的值，返回了一个新函数。
pool.apply_async(func[, args[, kwds[, callback[, error_callback]]]])
用进程池调用 func 函数（包括可选的args,kwds参数）
callback 是一个回调函数，只有一个参数，是func执行的结果。
'''
s1 = partial(spam, 1) # a = 1
s1(2, 3, 4)
s1(4, 5, 6)
s2 = partial(spam, d=42) # d = 42
s2(1, 2, 3)
s2(4, 5, 5)
s3 = partial(spam, 1, 2, d=42) # a = 1, b = 2, d = 42
s3(3)
s3(4)
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger('test')
p = Pool()
p.apply_async(add, (3, 4), callback=partial(output_result, log=log))
p.close()
p.join()
# socket服务器
serv = TCPServer(('', 15000), partial(EchoHandler, ack=b'RECEIVED:'))
serv.serve_forever()
class jeedom_socket():
def __init__(self, address='localhost', port=55000):
self.address = address
self.port = port
SocketServer.TCPServer.allow_reuse_address = True
def open(self):
self.netAdapter = TCPServer((self.address, self.port),
jeedom_socket_handler)
if self.netAdapter:
logging.debug("SOCKETHANDLER------Socket interface started")
threading.Thread(target=self.loopNetServer, args=()).start()
else:
logging.debug("SOCKETHANDLER------Cannot start socket interface")
def loopNetServer(self):
logging.debug("SOCKETHANDLER------LoopNetServer Thread started")
logging.debug("SOCKETHANDLER------Listening on: [%s:%d]" %
(self.address, self.port))
self.netAdapter.serve_forever()
logging.debug("SOCKETHANDLER------LoopNetServer Thread stopped")
def close(self):
self.netAdapter.shutdown()
def getMessage(self):
return self.message
class WebServer(Thread):
""" Web server for devices connected to the temporary access point """
def __init__(self, host, port):
super(WebServer, self).__init__()
LOG.info("Creating TCPServer...")
root = getattr(sys, '_MEIPASS', abspath(dirname(__file__) + '/..'))
self.daemon = True
self.dir = os.path.join(root, 'wifisetup', 'web')
try:
self.server = TCPServer((host, port), CaptiveHTTPRequestHandler)
except OSError:
raise RuntimeError('Could not create webserver! Port already in use.')
def shutdown(self):
Thread(target=self.server.shutdown, daemon=True).start()
self.server.server_close()
self.join(0.5)
def run(self):
LOG.info("Starting Web Server at %s:%s" % self.server.server_address)
LOG.info("Serving from: %s" % self.dir)
os.chdir(self.dir)
self.server.serve_forever()
LOG.info("Web Server stopped!")
def main(argv=None):
if argv is None:
argv = sys.argv[1:]
if len(argv) > 1 and argv[0] == 'always':
Handler.filename = argv[1]
elif argv:
Handler.auth = True
httpd = None
port = None
while port is None:
try:
port = random.randrange(32760, 59760)
httpd = TCPServer(('', port), Handler)
except socket.error:
port = None
try:
sys.stdout.write('%d\nstarted\n' % (port,))
sys.stdout.flush()
sys.stdout.close()
sys.stderr.write('Serving forever on %d.\n' % port)
httpd.serve_forever()
finally:
sys.stderr.write('Goodbye.\n')
class jeedom_socket():
def __init__(self, address='localhost', port=55000):
self.address = address
self.port = port
self.queue = Queue()
self.get = self.queue.get
self.empty = self.queue.empty
self.netAdapter = None
socketserver.TCPServer.allow_reuse_address = True
def open(self):
if self.netAdapter is not None:
logging.warning("Socket interface already started")
return
self.netAdapter = TCPServer((self.address, self.port),
jeedom_socket_handler)
if self.netAdapter:
self.netAdapter.queue = self.queue
logging.debug("Socket interface started")
threading.Thread(target=self.loopNetServer, args=()).start()
else:
logging.debug("Cannot start socket interface")
def loopNetServer(self):
logging.debug("LoopNetServer Thread started")
logging.debug("Listening on: [%s:%d]", self.address, self.port)
self.netAdapter.serve_forever()
logging.debug("LoopNetServer Thread stopped")
def close(self):
self.netAdapter.shutdown()
def getMessage(self):
return self.message
def run(self):
"""
:return:
"""
remote_control_server = TCPServer((host, port), TcpHandler)
remote_control_server.serve_forever()
def _do_preview(*, build, subdir, port):
"""Implements the "serve" (http) mode of main().
Args:
build: Same as per main().
subdir: Same as per main().
port: Local port number to serve on, per the command line.
"""
print("Generating documentation preview ...")
with tempfile.TemporaryDirectory(prefix="doc_builder_preview_") as scratch:
if subdir:
out_dir = join(scratch, subdir)
os.mkdir(out_dir)
else:
out_dir = scratch
pages = _call_build(build=build, out_dir=out_dir)
assert len(pages) > 0
os.chdir(scratch)
print(f"The files have temporarily been generated into {scratch}")
print()
print("Serving at the following URLs for local preview:")
print()
for page in pages:
print(f" http://127.0.0.1:{port}/{join(subdir, page)}")
print()
print("Use Ctrl-C to exit.")
TCPServer.allow_reuse_address = True
server = TCPServer(("127.0.0.1", port), _HttpHandler)
try:
server.serve_forever()
except KeyboardInterrupt:
print()
return
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
class HealthcheckServer(threading.Thread):
def __init__(self, port):
self._port = port
super(HealthcheckServer, self).__init__()
def run(self):
host, port = '0.0.0.0', int(self._port)
handler = HealthcheckHandler
TCPServer.allow_reuse_address = True
try:
self.httpd = TCPServer((host, port), handler)
self.httpd.serve_forever()
except OSError as ose:
LOG.critical('Could not serve healthcheck endpoint: %s' % ose)
sys.exit(1)
def stop(self):
try:
LOG.debug('stopping healthcheck endpoint')
self.httpd.shutdown()
self.httpd.server_close()
LOG.debug('healthcheck stopped.')
except AttributeError:
LOG.debug('Healthcheck was already down.')
class WebServer:
def __init__(self, port=8080, verbose=False):
""" Constructs a restartable WebServer on 'port'. """
self.port = port
self._verbose = verbose
self._handler = Handler
self.httpd = TCPServer(("", port), self._handler)
self._start = Event()
Thread(name=repr(self), target=self.run, daemon=True).start()
self.start() # remove if don't want to start on opening
def start(self):
""" Allow the server to serve. """
self._start.set()
def shutdown(self):
""" Block re-starting and shut down the current server. """
self._start.clear()
self.httpd.shutdown()
def run(self):
""" Serve forever, restart when allowed. """
while 'program running':
self._start.wait()
if self._verbose:
print('serving at port', self.port)
self.httpd.serve_forever()
def __repr__(self):
""" A formal string representation of this instance. """
return f'{self.__class__.__name__}(port={self.port})'
def main():
host = ''
port = 7777
server = None
board = PyMata3(5)
shoulder = Actuator(board, 9)
arm = Actuator(board, 10)
elbow = Actuator(board, 11, min_angle=-90, max_angle=90, offset=-90)
global mech_arm
mech_arm = MechanicalArm(
[shoulder, arm, elbow],
Fabrik(
joint_positions=[Vector2(0, 0), Vector2(53, 0), Vector2(100, 0)],
link_lengths=[53, 47],
tolerance=0.1
)
)
sleep(2)
while server is None:
try:
server = TCPServer((host, port), ConnectionHandler)
except OSError:
port += 1
continue
print("Serving on: {}".format(port))
server.serve_forever()
server.server_close()
class tcp_server(threading.Thread):
def __init__(self, port):
super().__init__()
self.serv = None
self.port = port
def run(self):
self.serv = TCPServer(
('', self.port), SeverHandler, bind_and_activate=False)
self.serv.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
True)
# Bind and activate
self.serv.server_bind()
self.serv.server_activate()
self.serv.serve_forever()
def send_data(self, data):
'''
Args:
data: bytes data
'''
if self.is_alive():
for client in client_socket:
client.sendall(data)
def shutdown(self):
shutting_flag[0] = True
self.serv.socket.close()
self.serv.shutdown()
self.serv.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()
def fixed_up_server_support_more_clients():
"""
但由于客户端连接数没有限制，因此可以同时发送大量的
连接让你的服务器崩溃。
预防这个问题，可以预先分配固定的线程池或进程池。创建一个普通非线程服务器，然后在一个
线程中使用 serve_forever() 来启动
:return:
"""
from threading import Thread
from socketserver import TCPServer
from socketserver import BaseRequestHandler
class EchoHandler(BaseRequestHandler):
def handle(self):
print('Got connection from', self.client_address)
while True:
msg = self.request.recv(8192)
print('---receive client message:----', msg)
if not msg:
break
self.request.send(msg)
NWORKERS = 16
serv = TCPServer(('', 20000), EchoHandler)
for n in range(NWORKERS):
t = Thread(target=serv.serve_forever)
t.daemon = True
t.start()
serv.serve_forever()
def main():
host = "0.0.0.0"
port = 80
addr = (host, port)
newTCPServer = TCP(addr, LaserQtRequestHandler)
print("等待客户端的连接...")
newTCPServer.serve_forever()
def runserver(config=None):
if config is None:
config={'host':'','port':200}
serv=TCPServer((config['host'],config['port']),MyHandler)
print('listening port: '+str(config['port']))
print('server name : svncount')
print('server type : tcp')
serv.serve_forever()
class Httpd(Thread):
def __init__(self):
super().__init__()
self.server = TCPServer(('127.0.0.1', 8000), SimpleHTTPRequestHandler)
self.start()
def run(self):
self.server.serve_forever()
def tcp_server():
host = "" # 主机名，可以是ip,像localhost的主机名,或""
port = 9997 # 端口
addr = (host, port)
# 购置TCPServer对象，
server = TCPServer(addr, tcpserver.MyBaseRequestHandlerr)
# 启动服务监听
server.serve_forever()
class ClientSocketManager():
_TCPServer = None
def __init__(self, ip_port, HANDLER):
self._TCPServer = TCPServer(ip_port, HANDLER)
def start(self):
self._TCPServer.serve_forever()
class MobileServer:
def __init__(self, address):
''' @param address: A tuple of ip and port. '''
from socketserver import TCPServer
self.server = TCPServer(address, MobileHandler)
def run(self):
self.server.serve_forever()
class ServerProcess(multiprocessing.Process):
def __init__(self, port, *args, **kwargs):
super(ServerProcess, self).__init__(*args, **kwargs)
self.port = port
def run(self):
self.server = TCPServer(('', self.port), NotificationHandler)
self.server.serve_forever()
def run(self):
"""
Main thread method. Open socket and waiting for connections.
"""
server = TCPServer((self.host, self.port), TCPHandler)
server.lymphocytes_getter = self.lymphocytes_getter
# runs forever - so make this thread daemon
server.serve_forever()
def http_server(address, path, error, log, conf):
try:
os.chdir(path)
httpd = TCPServer(address, HttpHandler)
httpd._log = log
httpd._conf = conf
httpd.serve_forever()
except Exception as e:
error.value = str(e)
def serve_forever(self, poll_interval=0.5):
"""Handle one request at a time until shutdown.
Polls for shutdown every poll_interval seconds. Ignores
self.timeout. If you need to do periodic tasks, do them in
another thread.
"""
self._serving_event.set()
self._shutdown_request_event.clear()
TCPServer.serve_forever(self, poll_interval=poll_interval)
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()
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 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 serve(self):
cwd = os.getcwd()
os.chdir(self.directory)
httpd = TCPServer(("", self.port), SimpleHTTPRequestHandler)
try:
self.logger.log(
"server running on http://localhost:{0}".format(self.port)
)
httpd.serve_forever()
except KeyboardInterrupt:
self.logger.log("shutting down server\n")
os.chdir(cwd)
def main():
global KADECOT_IP_ADDRESS
PORT = 31338
if len(sys.argv) > 1:
KADECOT_IP_ADDRESS = sys.argv[1]
else:
KADECOT_IP_ADDRESS = input("Kadeoct JSONServer IP: ")
Handler = SnapKadecotHTTPRequestHandler
print("KadecotServer: " + KADECOT_IP_ADDRESS + ":" + str(PORT))
httpd = TCPServer(("", PORT), Handler)
print("serving at port", PORT)
print("http://snap.berkeley.edu/snapsource/snap.html#open:http://localhost:"+str(PORT)+"/block")
httpd.serve_forever()
def main():
ap = argparse.ArgumentParser()
ap.add_argument('port', nargs='?', type=int, default='8000')
args = ap.parse_args()
port = args.port
try:
httpd = TCPServer(("", port), Handler)
url = 'http://127.0.0.1:{}/crowdmap'.format(port)
print ("Open this url in your browser: {}".format(url))
webbrowser.open_new(url)
httpd.serve_forever()
except KeyboardInterrupt:
print ('port {} closed'.format(port))
def cmd_serve(self, *args):
'''Serve the bin directory via SimpleHTTPServer
'''
try:
from http.server import SimpleHTTPRequestHandler
from socketserver import TCPServer
except ImportError:
from SimpleHTTPServer import SimpleHTTPRequestHandler
from SocketServer import TCPServer
os.chdir(self.bin_dir)
handler = SimpleHTTPRequestHandler
httpd = TCPServer(("", SIMPLE_HTTP_SERVER_PORT), handler)
print("Serving via HTTP at port {}".format(SIMPLE_HTTP_SERVER_PORT))
print("Press Ctrl+c to quit serving.")
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()
def main(*args):
""" Function invoked when the server is run as a script"""
import argparse
desc = "nframe server"
parser = argparse.ArgumentParser(description=desc)
parser.add_argument("-i", "--ip", default="0.0.0.0",
help="IP address of server")
parser.add_argument("-p", "--port", default=7645,
help="Port of server")
parser.add_argument("--import", action="store",
default=False, dest="import_file",
help="Import data before starting server")
parser.add_argument("--export", action="store",
default=False, dest="export_file",
help="Export data then exits")
parser.add_argument("--force-unlock", action="store_true", default=False,
help="Remove lock file without discretion",
dest="force_unlock")
parser.add_argument("--exit", action="store_true", default=False,
help="perform action then exit (don't run server)",
dest="exit")
pargs = parser.parse_args(args) if args else parser.parse_args()
if pargs.force_unlock:
Lock().force_release()
if pargs.import_file:
with Data(timeout=5) as import_data:
import_data.import_data(pargs.import_file)
if pargs.export_file:
with Data(timeout=5) as export_data:
export_data.export_data(pargs.export_file)
return
server = TCPServer((pargs.ip, pargs.port), Server)
if pargs.exit:
return pargs
with Lock(timeout=5):
try:
server.serve_forever()
except (SystemError, SystemExit, KeyboardInterrupt):
server.server_close()
class HttpServer(Thread):
"""A simple HTTP Server in its own thread"""
def __init__(self, port):
super(HttpServer, self).__init__()
self.daemon = True
handler = SimpleHTTPRequestHandler
self.httpd = TCPServer(("", port), handler)
def run(self):
"""Start the server"""
print('Start HTTP server')
self.httpd.serve_forever()
def stop(self):
"""Stop the server"""
print('Stop HTTP server')
self.httpd.socket.close()
def run_server(self):
handler = MyHTTPRequestHandler
#httpd = TCPServer(("", self.port), handler)
started = False
while not started:
try:
httpd = TCPServer(("", self.port), handler)
started = True
except error as e:
if e.errno in [48, 98]:
logger.warn("Starting Server failed. Address already in use. Retrying.")
sleep(1)
else:
raise
webbrowser.open("http://localhost:{port}/info.html".format(port=self.port))
logger.info("Started serving web interface at port {port}.".format(port=self.port))
httpd.processor = self
httpd.serve_forever()
def main(argv=None):
if argv is None:
argv = sys.argv[1:]
if not argv:
sys.stderr.write('Usage: testing_server.py port [auth]\n')
return 1
port = int(argv[0])
if len(argv) > 1:
Handler.auth = True
httpd = TCPServer(('', port), Handler)
try:
sys.stderr.write('Serving forever on %d.\n' % port)
httpd.serve_forever()
finally:
sys.stderr.write('Goodbye.\n')
def _main(self):
""" The main procedure of the thread. Runs server and is expected to be
either stopped by the user with KeyboardInterrupt or killed when the
program exits.
Exceptions are passed to the main thread through queue passed to
the constructor.
"""
try:
httpd = TCPServer(("", self.port), ReportingHTTPRequestHandler)
logger.info("Starting HTTP server at port %d\n", self.port)
httpd.probe_data_provider = self.probe_data_provider
httpd.serve_forever()
except:
logger.debug("An exception has interrupted the server thread (passed to the main thread)")
self.exception_queue.put(sys.exc_info())
class WebColorSourceThread(threading.Thread):
"""A thread that contantly listens for incoming web requests from the dashboard and
sets the LED colors accordingly.
"""
def __init__(self, color_callback, set_accepting_dynamic_color):
"""
:param color_callback: a function that will be run with the argument as an (r,g,b)
tuple when a color comes in from any client
:param set_accepting_dynamic_color: a function that will be run when the user requests
dynamic colors to be enabled/disabled from the web dashboard
"""
super(WebColorSourceThread, self).__init__()
# we can't pass arguments into the BaseHTTPRequestHandler subclass, so
# modify an instance first
color_source_instance = WebColorSource
color_source_instance.color_callback = color_callback
color_source_instance.set_accepting_dynamic_color = set_accepting_dynamic_color
self.http_server = TCPServer(('0.0.0.0', 1422), color_source_instance)
def run(self):
print('HTTP server now running on port 1422')
self.http_server.serve_forever()
"""
SOLUTION
"""
from socketserver import StreamRequestHandler
from socketserver import TCPServer
import socket
class EchoHandler(StreamRequestHandler):
timeout = 5
rbufsize = -1
wbufsize = 0
disable_nagle_algorithm = False
def handler(self):
print('Got connection from', self.client_address)
# self.rfile is a file-like object for reading
try:
for line in self.rfile:
# self.wfile is a file-like object for writing
self.wfile.write(line)
except socket.timeout:
print('Time out!')
if __name__ == '__main__':
serv = TCPServer(('', 20000), EchoHandler)
print('Echo server running on port 20000')
serv.serve_forever()
def startServer():
serv = TCPServer(('localhost', 24000), RequestHandler)
serv.serve_forever()
def main():
server = TCPServer((MySimpleChat.HOST, MySimpleChat.PORT), MySimpleChat)
server.serve_forever()
def simpel():
server = TCPServer(('', 1234), Handler)
server.serve_forever()
from socketserver import (TCPServer, StreamRequestHandler)
from time import ctime
host = ''
port = 21000
address = (host, port)
class MyRequestHandler(StreamRequestHandler):
# the StreamRequestHandler class treats input and output sockets
# as file-like objects, so we will use
# readline() to get the client message and
# write() to send a string back to the client
def handle(self):
print("connected from:", self.client_address)
#if the received data have no NEWLINE character next line halts
data = self.rfile.readline().strip()
#self.wfile.write(data)
self.wfile.write(bytes('[{0}] {1}'.format(ctime(), data.decode("utf-8")), 'utf-8'))
if __name__=='__main__':
#create a tcp socket and pass all the receives to a handler class
server_socket = TCPServer(address, MyRequestHandler)
print('waiting...just waiting')
server_socket.serve_forever()
# SocketServer receives a client connection, responds and then closes it
# this means TCP server acts more like a UDP
# this can be changed by overriding the appropriate methods
# in our request handler classes
def main():
print("Start Server")
tcpServ = TCPServer(ADDR, ServerHandler)
tcpServ.serve_forever();
def StartSampleTCPServer():
srv = TCPServer(('', 20000), EchoHandler)
print("Sampler Server Start...");
srv.serve_forever()
from random import choice
from http.server import SimpleHTTPRequestHandler
from socketserver import TCPServer
class RequestHandler(SimpleHTTPRequestHandler):
def write(self, s):
self.wfile.write(bytes(s, "utf-8"))
def do_GET(self):
if self.path == "/":
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
user_agent = self.headers.get('User-Agent')
messages = ('Have a nice day', 'So long', 'Come again soon')
self.write("""
Hello person from %s.
Your user agent is %s.
%s.
""" % (self.client_address[0], user_agent or "unknown", choice(messages)))
return
SimpleHTTPRequestHandler.do_GET(self)
httpd = TCPServer(("", 8000), RequestHandler)
httpd.serve_forever()
#!/usr/bin/env python3
'''
使用SocketServer 里的TCPServer 和StreamRequestHandler 类创建一个时间戳TCP 服务器
'''
from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 21567
ADDR = (HOST, PORT)
class MyRequestHandler(SRH):
def handle(self):
print ('...connected from:', self.client_address)
self.wfile.write(('[%s] %s' % (ctime(),self.rfile.readline().decode())).encode())
tcpServ = TCP(ADDR, MyRequestHandler)
print ('waiting for connection...')
tcpServ.serve_forever()
