def __enter__(self):
for server_number in range(self.number_of_servers):
self.mock_server_address, mock_server_port = get_free_port()
mock_server = TCPServer(('localhost', mock_server_port),
MockEpoServerRequestHandler)
mock_server.socket = ssl.wrap_socket(
mock_server.socket,
certfile=MOCK_EPOHTTPSERVER_CERTNAME,
keyfile=MOCK_EPOHTTPSERVER_KEYNAME,
server_side=True)
mock_server_thread = Thread(target=mock_server.serve_forever)
self.servers[server_number] = {
"server": mock_server,
"thread": mock_server_thread
}
self.servers[server_number]["thread"].setDaemon(True)
self.servers[server_number]["thread"].start()
self.server_info_list.append({
SERVER_INFO_SERVER_NAME_KEY:
TEST_EPONAME_BASE + str(server_number),
SERVER_INFO_SERVER_PORT_KEY:
mock_server_port,
})
return self.server_info_list
def open(self):
self.netAdapter = TCPServer((self.address, self.port), jeedom_socket_handler)
if self.netAdapter:
logging.debug("Socket interface started")
threading.Thread(target=self.loopNetServer, args=()).start()
else:
logging.debug("Cannot start socket interface")
def serve(self, on_progress: Callable):
# Make sure it is accessible to the subclass
local_path = self.local_path
class SocketWrapper:
def __init__(self, sock):
self.s = sock
def read(self, n: int):
try:
return self.s.recv(n)
except socket.timeout:
return b""
# Class to handle incoming connections
class ReceiveFile(BaseRequestHandler):
def handle(self):
self.request.settimeout(1)
with open(local_path, "wb") as fp:
util.copyfileobj(SocketWrapper(self.request), fp,
on_progress)
self.request.close()
self.server = TCPServer(("0.0.0.0", 0), ReceiveFile)
thread = threading.Thread(target=lambda: self.server.serve_forever(),
daemon=True)
thread.start()
def test_withaction(self):
# set up http server
TCPServer.allow_reuse_address = True
http_server = TCPServer(('127.0.0.1', 8090), TCPAcceptHandler)
http_server.last_payload = b''
server_thread = threading.Thread(target=http_server.serve_forever)
server_thread.daemon = True
server_thread.start()
print('http server started')
# set up the forwarder
fw = forwarder.Forwarder(path='tests/test.config.json')
fw.connect()
fw.start()
time.sleep(1)
print('forwarder started')
# create a MQTT client to publish events
client = mqtt.Client()
client.connect('127.0.0.1', 1883)
payload = 'foo'
client.publish('hello/world', payload=payload)
print('mqtt client published')
time.sleep(1)
self.assertEqual(payload, http_server.last_payload)
client.disconnect()
print('mqtt client disconnected')
fw.stop()
print('forwarder stopped')
http_server.shutdown()
print('httpserver shut down')
http_server.server_close()
print('http server stopped')
self.assertTrue(True)
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')
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 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()
def webserve():
parser = argparse.ArgumentParser(
description='Serve files from the current directory',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-v',
'--verbose',
action='store_true',
help='provide verbose output on progress')
parser.add_argument('-p',
'--port',
type=int,
default=2020,
help='port number to use')
parser.add_argument('--logpath',
type=str,
metavar='PATH',
help='Path where logging output should be written')
args = parser.parse_args()
# Configure logging.
logging.basicConfig(
filename=args.logpath,
level=logging.INFO if args.verbose else logging.WARNING,
format='%(asctime)s %(levelname)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S')
with TCPServer(('', args.port), LoggingHandler) as httpd:
logging.info('serving at port {0}'.format(args.port))
httpd.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()
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
def main():
port = int(os.environ.get("PORT", "3000"))
with TCPServer(("", port), Handler) as server:
try:
server.serve_forever()
except KeyboardInterrupt:
server.shutdown()
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.')
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 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 _create_socket_server(handler: BaseRequestHandler,
base_port: int,
max_port_offset: int = 10) -> TCPServer:
"""
Convenience method for starting a TCP socket server, selecting an open
port based on the initial port given. If no open socket can be found on which to
host the server, an exception is thrown.
"""
tries = 0
while tries < max_port_offset:
port = base_port + tries
try:
logger.debug("Opening 'server' port: {}".format(port))
server = TCPServer((socket.gethostname(), port), handler)
return server
except:
logger.debug("Problems opening port, trying another")
tries = tries + 1
# When we have exhausted the range of ports, we go here
if tries >= max_port_offset:
raise
# Another one of those "this should not happen" scenarios that are bound to happen
raise Exception("Reached faulty state when trying to start socket server")
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 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 start_web_server(port_num: int, test_class_name: str):
"""テスト用のWEBサーバを起動する"""
document_root: str = f'document_roots/{test_class_name}'
if not exists(document_root):
raise FileNotFoundError(
f'document root is not exists. document_root: {document_root}')
class __Handler(SimpleHTTPRequestHandler):
def __init__(self, *args, **kwargs):
super().__init__(*args, directory=document_root, **kwargs)
def do_POST(self):
if self.path.startswith('/kill_server'):
def kill_me_please(server):
server.shutdown()
_thread.start_new_thread(kill_me_please, (httpd, ))
self.send_error(500)
print(
f'webserver stopped. port_num: {port_num}, document_root: {document_root}'
)
TCPServer.allow_reuse_address = True
with TCPServer(('', port_num), __Handler) as httpd:
print(
f'webserver started. port_num: {port_num}, document_root: {document_root}'
)
httpd.serve_forever()
def serve(directory, port):
"See https://docs.python.org/2/library/simplehttpserver.html"
Handler = partial(SimpleHTTPRequestHandler, directory=directory)
with TCPServer((HOST, port), Handler) as httpd:
print(f"serving {directory} at http://{HOST}:{port}")
httpd.serve_forever()
def launch_d3po(path):
"""Start a server to view an exported D3PO bundle, and open a browser.
:param path: The TLD of the bundle
"""
from socketserver import TCPServer
from http.server import SimpleHTTPRequestHandler
from random import randrange
from socket import error
import webbrowser
from threading import Thread
os.chdir(path)
while True:
try:
PORT = randrange(8000, 9000)
server = TCPServer(("", PORT), SimpleHTTPRequestHandler, False)
server.allow_reuse_address = True
server.server_bind()
break
except error: # port already taken
pass
print('Serving D3PO on port 0.0.0.0:%i' % PORT)
server.server_activate()
thread = Thread(target=server.serve_forever)
thread.setDaemon(True) # do not prevent shutdown
thread.start()
webbrowser.open('http://0.0.0.0:%i' % PORT)
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 run(self):
"""
:return:
"""
remote_control_server = TCPServer((host, port), TcpHandler)
remote_control_server.serve_forever()
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 __init__(self, server_address):
self.server_address = server_address
self.tcp_server = TCPServer(server_address, self.request_handler)
self._terminate = False
self.server_capability = {
"document_completion": DOCUMENT_COMPLETION,
"document_hover": DOCUMENT_HOVER,
"document_formatting": DOCUMENT_FORMATTING,
"document_publish_diagnostic": DOCUMENT_PUBLISH_DIAGNOSTIC,
}
self.service_map = {
"ping": self.ping,
"shutdown": self.shutdown,
#
# project
"initialize": self.initialize,
"change_workspace": self.change_workspace,
"exit": self.exit,
#
# features
"document_completion": self.document_completion,
"document_hover": self.document_hover,
"document_formatting": self.document_formatting,
"document_publish_diagnostic": self.document_publish_diagnostic,
}
self.project_settings = {}
self.jedi_svc = jedi_service.Service()
def setUp(self):
self.new_dist = None
self.port = random.randint(1025, 65535)
self.httpd = TCPServer(("", self.port), SillyProxyRequestHandler)
self.httpd_process = multiprocessing.Process(
target=self.httpd.serve_forever)
self.httpd_process.start()
def receive_raw_file(
dest_path: str, name: str, port: int = 0, progress: Callable = None
) -> TCPServer:
""" Serve a file on the given port """
class SocketWrapper:
def __init__(self, sock):
self.s = sock
def read(self, n: int):
try:
return self.s.recv(n)
except socket.timeout:
return b""
class ReceiveFile(BaseRequestHandler):
def handle(self):
# We shouldn't block that long during a streaming transfer
self.request.settimeout(1)
with open(dest_path, "wb") as fp:
copyfileobj(SocketWrapper(self.request), fp, progress)
server = TCPServer(("0.0.0.0", port), ReceiveFile)
thread = threading.Thread(target=lambda: server.serve_forever(), daemon=True)
thread.start()
return server
def run(host, port):
server = TCPServer((host, port), RequestHandler)
try:
server.serve_forever()
except KeyboardInterrupt:
print("bye")
server.server_close()
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 main():
with TCPServer(("", G.PORT), ReqHandler) as httpd:
url = f"http://localhost:{G.PORT}"
print(f"Task Manager Server Started: '{url}'")
print(f"Static Dir: {G.STATIC_DIR}")
Timer(2, open_webpage, [url]).start()
httpd.serve_forever()
