def serve(handler):
server = ThreadingTCPServer(('localhost', 0), handler)
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
yield server.server_address
server.shutdown()
server.server_close()
def main():
if len(sys.argv) < 2:
print("Usage: {} binFile [port]\n\t".format(sys.argv[0]))
exit(-1)
binFile = sys.argv[1]
port = DEFAULT_PORT if len(sys.argv) < 3 else int(sys.argv[2])
print('binFile:', binFile, 'port:', port)
server = ThreadingTCPServer(('', port), EncodeHandler)
def sigint_handler(signum, frame):
print('sig {} raised: {}'.format(signum, frame))
server.socket.close()
server.shutdown()
sys.exit(0)
signal.signal(signal.SIGINT,
sigint_handler) # main thread will handle signals
try:
EncodeHandler.bitmapList = load_video_bin(binFile)
waiterThread = Thread(target=server.serve_forever, args=())
waiterThread.start()
waiterThread.join()
except Exception as e:
print('exception raised:', e)
finally:
server.socket.close()
server.shutdown()
class Proxy():
def __init__(self):
if hasattr(subprocess, 'STARTUPINFO'):
self.si = subprocess.STARTUPINFO()
self.si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
else:
self.si = None
def winrun(self, cmd):
subprocess.check_output(cmd, stdin=subprocess.PIPE, stderr=subprocess.PIPE \
, startupinfo=self.si, env=os.environ)
def start(self, address, port):
try:
self.server = ThreadingTCPServer((address, int(port)),
ProxyHandler)
logger.info("server started at {}:{}".format(address, port))
if setting.config['setproxy'] and sys.platform.startswith('win'):
self.winrun(
os.path.join(basepath, 'sysproxy.exe') +
' pac http://localhost:' +
str(setting.config['webuiport']) + '/pac/?t=' +
str(random.randrange(2**16)))
self.server.serve_forever()
except socket.error as e:
logger.error(e)
def shutdown(self):
self.server.shutdown()
def server_close(self):
self.server.server_close()
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.")
class WebUI(object):
version = "Bitcoin WebUI v0.0.1"
def __init__(self, config):
self.config = config
credentials = config.rpcusername + ":" + config.rpcpassword
self.rpcauth = "Basic " + base64.b64encode(
credentials.encode("utf_8")).decode("ascii")
self.httpd = None
def start(self):
self.httpd = ThreadingTCPServer(
(self.config.bindip, self.config.bindport), RequestHandler, False)
self.httpd.webui = self
self.httpd.allow_reuse_address = True
self.httpd.daemon_threads = True
tcp_socket = socket.socket(self.httpd.address_family,
self.httpd.socket_type)
self.httpd.socket = ssl.wrap_socket(tcp_socket,
self.config.privkeyfile,
self.config.pubkeyfile, True)
self.httpd.server_bind()
self.httpd.server_activate()
self.serverthread = Thread(None, self.httpd.serve_forever, "httpd")
self.serverthread.start()
def stop(self):
self.httpd.shutdown()
self.serverthread.join(5)
self.httpd.server_close()
class WebUI(object):
version = "Bitcoin WebUI v0.0.1"
def __init__(self, config):
self.config = config
credentials = config.rpcusername + ":" + config.rpcpassword
self.rpcauth = "Basic " + base64.b64encode(credentials.encode("utf_8")).decode("ascii")
self.httpd = None
def start(self):
self.httpd = ThreadingTCPServer((self.config.bindip, self.config.bindport), RequestHandler, False)
self.httpd.webui = self
self.httpd.allow_reuse_address = True
self.httpd.daemon_threads = True
tcp_socket = socket.socket(self.httpd.address_family, self.httpd.socket_type)
self.httpd.socket = ssl.wrap_socket(tcp_socket, self.config.privkeyfile, self.config.pubkeyfile, True)
self.httpd.server_bind()
self.httpd.server_activate()
self.serverthread = Thread(None, self.httpd.serve_forever, "httpd")
self.serverthread.start()
def stop(self):
self.httpd.shutdown()
self.serverthread.join(5)
self.httpd.server_close()
def shutdown(self):
"""
Safely shutdown server and thread
:return: None
"""
ThreadingTCPServer.shutdown(self)
Thread.join(self)
class Server:
def __init__(self, port):
server_logger.info('listening to connections...')
ThreadingTCPServer.allow_reuse_address = True
self.serve = ThreadingTCPServer(('', port), ServerRequestHandler)
def run(self):
self.serve.serve_forever()
def stop(self):
self.serve.shutdown()
class tcp_server(QThread): # 为了Handle能够发送Qt信号 所以使用Qthread
dataChanged = pyqtSignal(dict) # 自定义发送信号
def __init__(self, port, mode): # mode = 'grc' or 'hcr'
super().__init__()
self.serv = None
self.port = port
self.mode = mode
def run(self):
if self.mode == 'grc':
self.serv = ThreadingTCPServer(('', self.port),
GRC_Handler,
bind_and_activate=False)
self.serv.socket.settimeout(1) # 设置超时, 以便能够退出线程
self.serv.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
True) # 设置端口重用, 以便异常socket断开后的重建
self.serv.qthread = self # 这里让Handle里面有信号的发射口
elif self.mode == 'hcr':
self.serv = ThreadingTCPServer(('', self.port),
HCR_Handler,
bind_and_activate=False)
self.serv.socket.settimeout(1) # 设置超时, 以便能够退出线程
self.serv.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
True) # 设置端口重用, 以便异常socket断开后的重建
else:
print("error")
return
# Bind and activate
# self.setName("tcp_server " + self.mode)
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):
for client in client_socket:
client.shutdown(1)
shutdown_flag[0] = True
self.serv.socket.close()
self.serv.shutdown()
self.serv.server_close()
def run(self):
server = ThreadingTCPServer(self.addr, _TcpConnection, bind_and_activate=True)
server.mux = self
Thread(target=server.serve_forever, name="TcpServerTransport_Listen").start()
if self.announcer:
self.announcer.transport.start()
MuxTransport.run(self)
if self.announcer:
self.announcer.transport.stop()
server.shutdown()
class SockListener(BaseListener):
handlerCls = SockServiceHandler
def __init__(self, *args, **kwargs):
super(SockListener, self).__init__(*args, **kwargs)
# inject service_handler
SockBoltHandler.service_handler = self.handler
self.server = ThreadingTCPServer(self.address, SockBoltHandler)
def run_forever(self):
self.server.serve_forever()
def shutdown(self):
self.server.shutdown()
def test_nopassword(self):
try:
server = ThreadingTCPServer((ADDRESS, PORT), _TelnetNoUsernamePasswordRequestHandler)
_, port = server.server_address
self.port = port
thread = Thread(target=server.serve_forever)
thread.start()
ch = TelnetCredentialChecker()
self.assertTrue(ch.check(ADDRESS, self.port))
finally:
server.shutdown()
server.server_close()
class Proxy():
def start(self, address, port):
try:
self.server = ThreadingTCPServer((address, int(port)), ProxyHandler)
logger.info("server started at {}:{}".format(address, port))
if sys.platform.startswith('win'):
os.system(os.path.join(basepath, 'sysproxy.exe')+' pac http://localhost:7654/pac/?t=%random%')
self.server.serve_forever()
except socket.error as e:
logger.error(e)
def shutdown(self):
self.server.shutdown()
def server_close(self):
self.server.server_close()
class Master:
def __init__(self, zk_hosts, zk_root, address):
self.zk = KazooClient(zk_hosts)
self.root = zk_root
self.server = ThreadingTCPServer(address, MasterHandler)
self.server.zk = self.zk
self.server.root = self.root
def start(self):
self.zk.start()
self.server.serve_forever()
def shutdown(self):
self.server.shutdown()
self.zk.close()
def test_error(self):
"""Test what happens when TelnetCredsChecker is being run against something that is not telnet"""
try:
server = ThreadingTCPServer((ADDRESS, PORT), _NotTelnetRequestHandler)
_, port = server.server_address
self.port = port
thread = Thread(target=server.serve_forever)
thread.start()
ch = TelnetCredentialChecker()
self.assertFalse(ch.check(ADDRESS, self.port))
finally:
server.shutdown()
server.server_close()
def main(address=None):
try:
LOGGER.info("Server up.")
if address is None:
ip = socket.gethostbyname(socket.gethostname())
port = params.controller_port
address = ip + ':' + str(port)
LOGGER.info("Server listening address %s." % address)
ip = address.split(':')[0]
port = int(address.split(':')[1])
server = ThreadingTCPServer((ip, port), request_handler)
server.socket = secure_socket(sock=server.socket, server_side=True)
server.daemon_threads = True
LOGGER.info("Creating work thread...")
serv_thread = threading.Thread(target=server.serve_forever)
serv_thread.setDaemon(True)
serv_thread.start()
LOGGER.info("server is running at %s." % address)
a_table = access_table()
while True:
time.sleep(5)
# LOGGER.critical(a_table.print())
except KeyboardInterrupt:
LOGGER.info("Receive keyboard interrupt, shut down...")
except BaseException:
LOGGER.error("Catch unhandled exception.")
traceback.print_exc()
finally:
try:
LOGGER.info("Exit handle loop...")
server.shutdown()
LOGGER.info("Close socket...")
server.server_close()
except:
pass
try:
LOGGER.info("Wait all request handler threads...")
serv_thread.join()
except:
pass
LOGGER.info("Server down.")
def test_fail(self):
try:
server = ThreadingTCPServer((ADDRESS, PORT), _TelnetRequestHandler)
_, port = server.server_address
self.port = port
server.telnet_username = INVALID_USERNAME
server.telnet_password = INVALID_PASSWORD
thread = Thread(target=server.serve_forever)
thread.start()
ch = TelnetCredentialChecker()
self.assertFalse(ch.check(ADDRESS, self.port))
finally:
server.shutdown()
server.server_close()
class Server(Thread):
def __init__(self, host, port, dispatcher):
Thread.__init__(self)
self.daemon = True
self.server = ThreadingTCPServer((host, port), RequestHandler, bind_and_activate=False)
self.server.allow_reuse_address = True
self.server.server_bind()
self.server.server_activate()
self.server.dispatcher = dispatcher
def run(self):
logging.debug('server thread is running...')
self.server.serve_forever()
def stop(self):
logging.debug('server thread will be stopped')
self.server.shutdown()
self.server.server_close()
logging.debug('server thread is killed')
class ThreadingServerInThread(object):
"""
Context manager for running a threading http server in a thread.
Since the Thread is not using "daemon=True", it will keep Python running
until the context manager exits, which means until request completion.
"""
def __init__(self, port=8000):
self._server_address = ("127.0.0.1", port)
self._handler = SimpleHTTPRequestHandlerHere
self.httpd = ThreadingTCPServer(
self._server_address, self._handler, bind_and_activate=False
)
def _bind_and_activate(self):
try:
self.httpd.server_bind()
self.httpd.server_activate()
except Exception as e:
self.httpd.server_close()
raise e
def start(self):
self._bind_and_activate()
thread = threading.Thread(target=self.httpd.serve_forever)
thread.start()
def stop(self):
self.httpd.shutdown()
self.httpd.server_close()
def __enter__(self):
self.start()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.stop()
def run_server(_,
address=CONFIG.SERVER_ADDR,
port=CONFIG.SERVER_PORT,
log_level='INFO'):
""" Launches 'WG Forge' TCP server.
"""
log.setLevel(log_level)
ThreadingTCPServer.allow_reuse_address = True
server = ThreadingTCPServer((address, port), GameServerRequestHandler)
log.info('Serving on {}'.format(server.socket.getsockname()))
try:
server.serve_forever()
except KeyboardInterrupt:
log.warn('Server stopped by keyboard interrupt, shutting down...')
finally:
try:
GameServerRequestHandler.shutdown_all_sockets()
Game.stop_all_games()
if log.is_queued:
log.stop()
finally:
server.shutdown()
server.server_close()
class Tunnel():
"""Open SOCKS tunnel to a :class:`Host`
Each tunnel is opened in distinct thread so that BabooSSH is still usable
while the tunnel is open.
Attributes:
connection (:class:`.Connection`): the tunnel exit
port (int): the tunnel entrance (local) port. Uses a random port if
none is provided.
"""
def __init__(self, connection, port=None):
self.connection = connection
if port is None:
port = 0
self.connection.open()
self.connection.used_by_tunnels.append(self)
self.server = ThreadingTCPServer(('127.0.0.1', port), SocksProxy)
self.server.output = self.connection.transport
ip, newport = self.server.server_address
self.port = newport
self.thread = threading.Thread(target=self.server.serve_forever)
self.thread.start()
print("Tunnel to " + str(self.connection) + " open on port " +
str(self.port))
def close(self):
"""Close a previously opened port"""
try:
self.connection.used_by_tunnels.remove(self)
except:
pass
self.server.shutdown()
print("Tunnel port " + str(self.port) + " closed")
def __str__(self):
return str(self.port) + "->" + str(self.connection)
class ThreadingServerInThread(object):
"""
Context manager for running a threading http server in a thread.
Since the Thread is not using "daemon=True", it will keep Python running
until the context manager exits, which means until request completion.
"""
def __init__(self, port=8000):
self._server_address = ("127.0.0.1", port)
self._handler = SimpleHTTPRequestHandlerHere
self.httpd = ThreadingTCPServer(
self._server_address, self._handler, bind_and_activate=False)
def _bind_and_activate(self):
try:
self.httpd.server_bind()
self.httpd.server_activate()
except Exception as e:
self.httpd.server_close()
raise e
def start(self):
self._bind_and_activate()
thread = threading.Thread(target=self.httpd.serve_forever)
thread.start()
def stop(self):
self.httpd.shutdown()
self.httpd.server_close()
def __enter__(self):
self.start()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.stop()
def EchoServer():
server = ThreadingTCPServer(('127.0.0.1', 9999), EchoHandler)
server_thread = threading.Thread(target=server.serve_forever,
name='EchoServer',
daemon=True)
server_thread.start()
try:
while True:
cmd = input('>>')
if cmd.strip() == 'quit':
server.shutdown()
break
print(threading.enumerate())
except Exception as e:
print(e)
except KeyboardInterrupt:
pass
finally:
print('exit')
sys.exit(0)
pass
def ChatServer():
FOMAT = '%(asctime)s %(thread)s %(threadName)s %(message)s'
logging.basicConfig(level=logging.INFO, format=FOMAT)
laddr = ('127.0.0.1', 9988)
server = ThreadingTCPServer(laddr, ChatServerHanlder)
print(server.socket)
threading.Thread(target=server.serve_forever, name='server').start()
try:
while True:
cmd = input(">>>>")
if cmd == 'quit':
server.shutdown()
break
print(threading.enumerate())
except Exception as e:
print(e)
except KeyboardInterrupt:
pass
finally:
print('exit')
sys.exit(0)
class WebUI(BaseFrontend):
version = "theseven.webui v0.1.0"
default_name = "WebUI"
can_log = True
can_configure = True
can_autodetect = True
settings = dict(
BaseFrontend.settings,
**{
"port": {"title": "HTTP port", "type": "int", "position": 1000},
"users": {
"title": "Users",
"type": "dict",
"key": {"title": "User:Password", "type": "string"},
"value": {
"title": "Privilege level",
"type": "enum",
"values": [
{"value": "readonly", "title": "Read only access"},
{"value": "admin", "title": "Full access"},
],
},
"position": 2000,
},
"log_buffer_max_length": {"title": "Maximum log buffer length", "type": "int", "position": 3000},
"log_buffer_purge_size": {"title": "Log buffer purge size", "type": "int", "position": 3010},
}
)
@classmethod
def autodetect(self, core):
core.add_frontend(self(core))
def __init__(self, core, state=None):
super(WebUI, self).__init__(core, state)
self.log_lock = RLock()
def apply_settings(self):
super(WebUI, self).apply_settings()
if not "port" in self.settings:
self.settings.port = 8832
if not "users" in self.settings:
self.settings.users = {"admin:mpbm": "admin"}
if not "uiconfig" in self.settings:
self.settings.uiconfig = {"loggadget": {"loglevel": self.core.default_loglevel}}
if not "log_buffer_max_length" in self.settings:
self.settings.log_buffer_max_length = 1000
if not "log_buffer_purge_size" in self.settings:
self.settings.log_buffer_purge_size = 100
if self.started and self.settings.port != self.port:
self.async_restart(3)
def _reset(self):
self.log_buffer = []
self.log_listeners = []
def _start(self):
super(WebUI, self)._start()
self.httpd = ThreadingTCPServer(("", self.settings.port), RequestHandler, False)
self.httpd.webui = self
self.httpd.allow_reuse_address = True
self.httpd.daemon_threads = True
self.httpd.server_bind()
self.httpd.server_activate()
self.serverthread = Thread(None, self.httpd.serve_forever, self.settings.name + "_httpd")
self.serverthread.daemon = True
self.serverthread.start()
self.port = self.settings.port
def _stop(self):
self.httpd.shutdown()
self.serverthread.join(10)
self.httpd.server_close()
super(WebUI, self)._stop()
def write_log_message(self, source, timestamp, loglevel, messages):
if not self.started:
return
data = {
"timestamp": time.mktime(timestamp.timetuple()) * 1000 + timestamp.microsecond / 1000.0,
"loglevel": loglevel,
"source": source.settings.name,
"message": [{"data": data, "format": format} for data, format in messages],
}
with self.log_lock:
for queue in self.log_listeners:
queue.put(data)
self.log_buffer.append(data)
if len(self.log_buffer) > self.settings.log_buffer_max_length:
self.log_buffer = self.log_buffer[self.settings.log_buffer_purge_size :]
def register_log_listener(self, listener):
with self.log_lock:
if not listener in self.log_listeners:
self.log_listeners.append(listener)
for data in self.log_buffer:
listener.put(data)
def unregister_log_listener(self, listener):
with self.log_lock:
while listener in self.log_listeners:
self.log_listeners.remove(listener)
# coding:utf-8
from socketserver import ThreadingTCPServer,StreamRequestHandler
class LogRequestHandler(StreamRequestHandler):
def handle(self):
print('client {} is online!'.format(self.client_address))
filename = self.rfile.readline().decode().strip()
fd = open('/logs/{0}'.format(filename),'a')
while True:
data = self.rfile.readline()
if not data.strip():
break
fd.write(data.decode())
fd.flush()
print('close connection')
fd.close()
if __name__ == '__main__':
addr = ('192.168.2.53',8080)
server = ThreadingTCPServer(addr,LogRequestHandler)
try:
server.serve_forever()
except KeyboardInterrupt:
server.shutdown()
handler.serve_forever()
except Exception as e:
Script.log(e, lvl=Script.DEBUG)
pass
ThreadingTCPServer.allow_reuse_address = True
_PORT = 48996
handler = ThreadingTCPServer(("", _PORT), proxy.JioTVProxy)
t = threading.Thread(target=serveForever, args=(handler, ))
t.setDaemon(True)
t.start()
if not Settings.get_boolean("popup"):
xbmcgui.Dialog().ok(
"JioTV Notification",
"Now you can create your custom playlist from BotAllen Dashboard. [CR]Find out more at [B]https://botallen.com/#dashboard[/B] [CR][CR]If you like this add-on then consider donating from [B]https://botallen.com/#donate[/B] [CR][CR]Github: [B]https://github.com/botallen/repository.botallen[/B] [CR]Discord: [B]https://botallen.com/discord[/B] [CR][CR][I]You can disable this popup from settings[/I]"
)
if Settings.get_boolean("m3ugen"):
executebuiltin(
"RunPlugin(plugin://plugin.video.jiotv/resources/lib/main/m3ugen/?notify=no)"
)
monitor = Monitor()
while not monitor.abortRequested():
if monitor.waitForAbort(10):
handler.shutdown()
handler.server_close()
break
class WebUI(BaseFrontend):
version = "theseven.webui v0.1.0beta"
default_name = "WebUI"
can_log = True
can_configure = True
can_autodetect = True
settings = dict(
BaseFrontend.settings, **{
"port": {
"title": "HTTP port",
"type": "int",
"position": 1000
},
"users": {
"title": "Users",
"type": "dict",
"key": {
"title": "User:Password",
"type": "string"
},
"value": {
"title":
"Privilege level",
"type":
"enum",
"values": [
{
"value": "readonly",
"title": "Read only access"
},
{
"value": "admin",
"title": "Full access"
},
],
},
"position": 2000
},
"log_buffer_max_length": {
"title": "Maximum log buffer length",
"type": "int",
"position": 3000
},
"log_buffer_purge_size": {
"title": "Log buffer purge size",
"type": "int",
"position": 3010
},
})
@classmethod
def autodetect(self, core):
core.add_frontend(self(core))
def __init__(self, core, state=None):
super(WebUI, self).__init__(core, state)
self.log_lock = RLock()
def apply_settings(self):
super(WebUI, self).apply_settings()
if not "port" in self.settings: self.settings.port = 8832
if not "users" in self.settings:
self.settings.users = {"admin:mpbm": "admin"}
if not "uiconfig" in self.settings:
self.settings.uiconfig = {
"loggadget": {
"loglevel": self.core.default_loglevel
}
}
if not "log_buffer_max_length" in self.settings:
self.settings.log_buffer_max_length = 1000
if not "log_buffer_purge_size" in self.settings:
self.settings.log_buffer_purge_size = 100
if self.started and self.settings.port != self.port:
self.async_restart(3)
def _reset(self):
self.log_buffer = []
self.log_listeners = []
def _start(self):
super(WebUI, self)._start()
self.httpd = ThreadingTCPServer(("", self.settings.port),
RequestHandler, False)
self.httpd.webui = self
self.httpd.allow_reuse_address = 1
self.httpd.server_bind()
self.httpd.server_activate()
self.serverthread = Thread(None, self.httpd.serve_forever,
self.settings.name + "_httpd")
self.serverthread.daemon = True
self.serverthread.start()
self.port = self.settings.port
def _stop(self):
self.httpd.shutdown()
self.serverthread.join(10)
self.httpd.server_close()
super(WebUI, self)._stop()
def write_log_message(self, timestamp, loglevel, messages):
if not self.started: return
data = {
"timestamp":
time.mktime(timestamp.timetuple()) * 1000 +
timestamp.microsecond / 1000,
"loglevel":
loglevel,
"message": [{
"data": data,
"format": format
} for data, format in messages],
}
with self.log_lock:
for queue in self.log_listeners:
queue.put(data)
self.log_buffer.append(data)
if len(self.log_buffer) > self.settings.log_buffer_max_length:
self.log_buffer = self.log_buffer[self.settings.
log_buffer_purge_size:]
def register_log_listener(self, listener):
with self.log_lock:
if not listener in self.log_listeners:
self.log_listeners.append(listener)
for data in self.log_buffer:
listener.put(data)
def unregister_log_listener(self, listener):
with self.log_lock:
while listener in self.log_listeners:
self.log_listeners.remove(listener)
def close_server(server: ThreadingTCPServer) -> None:
server.shutdown()
server.server_close()
import sys
from socketserver import BaseRequestHandler, ThreadingTCPServer
class EchoHandler(BaseRequestHandler):
def handle(self):
print("Got connection from", self.client_address)
while True:
msg = self.request.recv(8192)
if not msg:
break
print("Replying:", msg)
self.request.send(msg)
if __name__ == '__main__':
if len(sys.argv) < 2:
print("Usage: python main.py port")
sys.exit(1)
port = int(sys.argv[1])
try:
serv = ThreadingTCPServer(('', port), EchoHandler)
serv.serve_forever()
except KeyboardInterrupt:
serv.shutdown()
serv.server_close()
class ModbusServer(object):
"""Modbus TCP server"""
class ModbusService(BaseRequestHandler):
def recv_all(self, size):
if hasattr(socket, "MSG_WAITALL"):
data = self.request.recv(size, socket.MSG_WAITALL)
else:
# Windows lacks MSG_WAITALL
data = b''
while len(data) < size:
data += self.request.recv(size - len(data))
return data
def handle(self):
while True:
rx_head = self.recv_all(7)
# close connection if no standard 7 bytes header
if not (rx_head and len(rx_head) == 7):
break
# decode header
(rx_hd_tr_id, rx_hd_pr_id,
rx_hd_length, rx_hd_unit_id) = struct.unpack('>HHHB', rx_head)
# close connection if frame header content inconsistency
if not ((rx_hd_pr_id == 0) and (2 < rx_hd_length < 256)):
break
# receive body
rx_body = self.recv_all(rx_hd_length - 1)
# close connection if lack of bytes in frame body
if not (rx_body and (len(rx_body) == rx_hd_length - 1)):
break
# body decode: function code
rx_bd_fc = struct.unpack('B', rx_body[0:1])[0]
# close connection if function code is inconsistent
if rx_bd_fc > 0x7F:
break
# default except status
exp_status = const.EXP_NONE
# functions Read Coils (0x01) or Read Discrete Inputs (0x02)
if rx_bd_fc in (const.READ_COILS, const.READ_DISCRETE_INPUTS):
(b_address, b_count) = struct.unpack('>HH', rx_body[1:])
# check quantity of requested bits
if 0x0001 <= b_count <= 0x07D0:
bits_l = DataBank.get_bits(b_address, b_count)
if bits_l:
# allocate bytes list
b_size = int(b_count / 8)
b_size += 1 if (b_count % 8) else 0
bytes_l = [0] * b_size
# populate bytes list with data bank bits
for i, item in enumerate(bits_l):
if item:
byte_i = int(i/8)
bytes_l[byte_i] = set_bit(bytes_l[byte_i], i % 8)
# format body of frame with bits
tx_body = struct.pack('BB', rx_bd_fc, len(bytes_l))
# add bytes with bits
for byte in bytes_l:
tx_body += struct.pack('B', byte)
else:
exp_status = const.EXP_DATA_ADDRESS
else:
exp_status = const.EXP_DATA_VALUE
# functions Read Holding Registers (0x03) or Read Input Registers (0x04)
elif rx_bd_fc in (const.READ_HOLDING_REGISTERS, const.READ_INPUT_REGISTERS):
(w_address, w_count) = struct.unpack('>HH', rx_body[1:])
# check quantity of requested words
if 0x0001 <= w_count <= 0x007D:
words_l = DataBank.get_words(w_address, w_count)
if words_l:
# format body of frame with words
tx_body = struct.pack('BB', rx_bd_fc, w_count * 2)
for word in words_l:
tx_body += struct.pack('>H', word)
else:
exp_status = const.EXP_DATA_ADDRESS
else:
exp_status = const.EXP_DATA_VALUE
# function Write Single Coil (0x05)
elif rx_bd_fc is const.WRITE_SINGLE_COIL:
(b_address, b_value) = struct.unpack('>HH', rx_body[1:])
f_b_value = bool(b_value == 0xFF00)
if DataBank.set_bits(b_address, [f_b_value]):
# send write ok frame
tx_body = struct.pack('>BHH', rx_bd_fc, b_address, b_value)
else:
exp_status = const.EXP_DATA_ADDRESS
# function Write Single Register (0x06)
elif rx_bd_fc is const.WRITE_SINGLE_REGISTER:
(w_address, w_value) = struct.unpack('>HH', rx_body[1:])
if DataBank.set_words(w_address, [w_value]):
# send write ok frame
tx_body = struct.pack('>BHH', rx_bd_fc, w_address, w_value)
else:
exp_status = const.EXP_DATA_ADDRESS
# function Write Multiple Coils (0x0F)
elif rx_bd_fc is const.WRITE_MULTIPLE_COILS:
(b_address, b_count, byte_count) = struct.unpack('>HHB', rx_body[1:6])
# check quantity of updated coils
if (0x0001 <= b_count <= 0x07B0) and (byte_count >= (b_count/8)):
# allocate bits list
bits_l = [False] * b_count
# populate bits list with bits from rx frame
for i, item in enumerate(bits_l):
b_bit_pos = int(i/8)+6
b_bit_val = struct.unpack('B', rx_body[b_bit_pos:b_bit_pos+1])[0]
bits_l[i] = test_bit(b_bit_val, i % 8)
# write words to data bank
if DataBank.set_bits(b_address, bits_l):
# send write ok frame
tx_body = struct.pack('>BHH', rx_bd_fc, b_address, b_count)
else:
exp_status = const.EXP_DATA_ADDRESS
else:
exp_status = const.EXP_DATA_VALUE
# function Write Multiple Registers (0x10)
elif rx_bd_fc is const.WRITE_MULTIPLE_REGISTERS:
(w_address, w_count, byte_count) = struct.unpack('>HHB', rx_body[1:6])
# check quantity of updated words
if (0x0001 <= w_count <= 0x007B) and (byte_count == w_count * 2):
# allocate words list
words_l = [0] * w_count
# populate words list with words from rx frame
for i, item in enumerate(words_l):
w_offset = i * 2 + 6
words_l[i] = struct.unpack('>H', rx_body[w_offset:w_offset + 2])[0]
# write words to data bank
if DataBank.set_words(w_address, words_l):
# send write ok frame
tx_body = struct.pack('>BHH', rx_bd_fc, w_address, w_count)
else:
exp_status = const.EXP_DATA_ADDRESS
else:
exp_status = const.EXP_DATA_VALUE
else:
exp_status = const.EXP_ILLEGAL_FUNCTION
# check exception
if exp_status != const.EXP_NONE:
# format body of frame with exception status
tx_body = struct.pack('BB', rx_bd_fc + 0x80, exp_status)
# build frame header
tx_head = struct.pack('>HHHB', rx_hd_tr_id, rx_hd_pr_id, len(tx_body) + 1, rx_hd_unit_id)
# send frame
self.request.send(tx_head + tx_body)
self.request.close()
def __init__(self, host='localhost', port=const.MODBUS_PORT, no_block=False, ipv6=False):
"""Constructor
Modbus server constructor.
:param host: hostname or IPv4/IPv6 address server address (optional)
:type host: str
:param port: TCP port number (optional)
:type port: int
:param no_block: set no block mode, in this mode start() return (optional)
:type no_block: bool
:param ipv6: use ipv6 stack
:type ipv6: bool
"""
# public
self.host = host
self.port = port
self.no_block = no_block
self.ipv6 = ipv6
# private
self._running = False
self._service = None
self._serve_th = None
def start(self):
"""Start the server.
Do nothing if server is already running.
This function will block if no_block is not set to True.
"""
if not self.is_run:
# set class attribute
ThreadingTCPServer.address_family = socket.AF_INET6 if self.ipv6 else socket.AF_INET
ThreadingTCPServer.daemon_threads = True
# init server
self._service = ThreadingTCPServer((self.host, self.port), self.ModbusService, bind_and_activate=False)
# set socket options
self._service.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self._service.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
# TODO test no_delay with bench
self._service.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
# bind and activate
self._service.server_bind()
self._service.server_activate()
# serve request
if self.no_block:
self._serve_th = Thread(target=self._serve)
self._serve_th.daemon = True
self._serve_th.start()
else:
self._serve()
def stop(self):
"""Stop the server.
Do nothing if server is already not running.
"""
if self.is_run:
self._service.shutdown()
self._service.server_close()
@property
def is_run(self):
"""Return True if server running.
"""
return self._running
def _serve(self):
try:
self._running = True
self._service.serve_forever()
except:
self._service.server_close()
raise
finally:
self._running = False
import sys
from socketserver import BaseRequestHandler, ThreadingTCPServer
class EchoHandler(BaseRequestHandler):
def handle(self):
print("Got connection from", self.client_address)
while True:
msg = self.request.recv(8192)
if not msg:
break
print("Replying:", msg)
self.request.send(msg)
if __name__ == '__main__':
if len(sys.argv) < 2:
print("Usage: python main.py port")
sys.exit(1)
port = int(sys.argv[1])
try:
serv = ThreadingTCPServer(('', port), EchoHandler)
serv.serve_forever()
except KeyboardInterrupt:
serv.shutdown()
serv.server_close()
def stop(srv: socketserver.ThreadingTCPServer):
srv.shutdown()
srv.close()
class TcpServerTransport(MuxTransport):
'''transport that accepts TCP connections as transports.
Basically a mux transport coupled with a TcpServer. Each time somebody
connects, the connection is wrapped into a transport and added to the
muxer.
There is (for now) no explicit notification about connects/disconnects;
use the API for that.
Use .close() for server-side disconnect.
You can optionally pass an announcer (as returned by announcer_api.make_udp_announcer).
It will be started/stopped together with the TcpServerTransport.
Optionally, a keepalive message can be configured. On each connection,
``keepalive_msg`` is sent verbatim every ``keepalive_interval`` seconds
while the connection is idle. Any sending or receiving resets the timer.
You can change the attributes directly while transport is stopped.
Threads:
- TcpServerTransport.run() blocks (use .start() for automatic extra Thread)
- .run() starts a new thread for listening to connections
- each incoming connection will start another Thread.
'''
shorthand = 'tcpserv'
@classmethod
def fromstring(cls, expression):
'''tcpserv:<interface>:<port>
Leave <interface> empty to listen on all interfaces.
'''
_, iface, port = expression.split(':')
return cls(port=int(port), interface=iface)
def __init__(self,
port,
interface='',
announcer=None,
keepalive_msg=b'',
keepalive_interval=10,
buffersize=1024):
self.addr = (interface, port)
self.name = '%s:%s' % self.addr
self.announcer = announcer
self.keepalive_msg = keepalive_msg
self.keepalive_interval = keepalive_interval
self.buffersize = buffersize
MuxTransport.__init__(self)
def open(self):
self.server = ThreadingTCPServer(self.addr,
_TcpConnection,
bind_and_activate=True)
self.server.mux = self
Thread(target=self.server.serve_forever,
name="TcpServerTransport_Listen").start()
if self.announcer:
try:
self.announcer.transport.start()
finally:
self.server.shutdown()
def run(self):
MuxTransport.run(self)
if self.announcer:
self.announcer.transport.stop()
self.server.shutdown()
self.server.server_close()
def close(self, name):
'''close the connection with the given sender/receiver name.
'''
for transport in self.transports:
if transport.name == name:
transport.transport_running.clear()
class MainUI(Ui_ASTM_Clent):
def _del_(self):
if hasattr(self, "server"):
self.server.shutdown()
self.server = None
self.t._stop()
def searchClicked(self):
sid = self.txtSearch.text()
result = OperationDB().selectTest((sid,))
print(result)
self.searchCallBack(result)
def testConnClicked(self):
sendIP = self.txtSendIP.text()
sendPort = self.txtSendPort.text()
try:
TCPClient(sendIP, sendPort).send(("testConn", ()), self.testConnCallBack)
except Exception as e:
print(e)
self.txtConsole.append(str(e))
def testConnCallBack(self, params):
print(params)
if params == "success":
print(params)
self.txtConsole.append(params)
def listening(self):
if hasattr(self, "server"):
self.server.shutdown()
self.server = None
self.t._stop()
listenIP = self.txtLocalIP.text()
listenPort = self.txtLocalPort.text()
try:
self.server = ThreadingTCPServer((listenIP, int(listenPort)), EchoRequestHandler)
print("server running at", listenIP, listenPort)
self.txtConsole.append("server running at " + listenIP + " " + listenPort)
self.t = Thread(target=self.server.serve_forever)
self.t.start()
except Exception as e:
print(e)
self.txtConsole.append(str(e))
def connClicked(self):
sendIP = self.txtSendIP.text()
sendPort = self.txtSendPort.text()
try:
TCPClient(sendIP, sendPort).send(("testConn", ()), self.connCallBack)
except Exception as e:
print(e)
self.txtConsole.append(str(e))
def connCallBack(self, params):
print(params)
if params == "success":
self.sendIP = self.txtSendIP.text()
self.sendPort = self.txtSendPort.text()
self.txtConsole.append(self.sendIP + ":" + self.sendPort + " connected.")
else:
self.txtConsole.append(self.sendIP + ":" + self.sendPort + " connect failed.")
def orderButClicked(self):
sid = self.txt_sid.text()
pid = self.txt_pid.text()
pname = self.txt_pname.text()
page = self.txt_page.text()
pgender = self.txt_gender.text()
status = self.txt_status.text()
if sid == "":
self.txtConsole.append("please type sid")
return
if pid == "":
self.txtConsole.append("please type pid")
return
if pname == "":
self.txtConsole.append("please type name")
return
if page == "":
self.txtConsole.append("please type age")
return
if pgender == "":
self.txtConsole.append("please type gender")
return
if status == "":
self.txtConsole.append("please type status")
return
albchecked = self.chk_ALB.isChecked()
altchecked = self.chk_ALT.isChecked()
astchecked = self.chk_AST.isChecked()
alpchecked = self.chk_ALP.isChecked()
mgchecked = self.chk_MG.isChecked()
ggtchecked = self.chk_GGT.isChecked()
hcychecked = self.chk_HCY.isChecked()
uricchecked = self.chk_URIC.isChecked()
bunchecked = self.chk_BUN.isChecked()
cholchecked = self.chk_CHOL.isChecked()
sycschecked = self.chk_SYCS.isChecked()
glucchecked = self.chk_GLUC.isChecked()
testnames = []
if albchecked:
testnames.append(self.chk_ALB.text())
if altchecked:
testnames.append(self.chk_ALT.text())
if astchecked:
testnames.append(self.chk_AST.text())
if alpchecked:
testnames.append(self.chk_ALP.text())
if mgchecked:
testnames.append(self.chk_MG.text())
if ggtchecked:
testnames.append(self.chk_GGT.text())
if hcychecked:
testnames.append(self.chk_HCY.text())
if uricchecked:
testnames.append(self.chk_URIC.text())
if bunchecked:
testnames.append(self.chk_BUN.text())
if cholchecked:
testnames.append(self.chk_CHOL.text())
if sycschecked:
testnames.append(self.chk_SYCS.text())
if glucchecked:
testnames.append(self.chk_GLUC.text())
if len(testnames) == 0:
self.txtConsole.append("please a test at least.")
return
params = (sid, pid, pname, page, pgender, status, testnames)
result = OperationDB().orderEntry(params)
self.orderEntryCallBack(result)
def orderEntryCallBack(self, params):
print(params)
self.txtConsole.append(params)
# transform data
# TCPClient(self.sendIP, self.sendPort).send(("orderEntry", params), self.orderEntryCallBack)
def searchCallBack(self, params):
print(params)
index = 0
for param in params:
if not param is None:
_translate = QtCore.QCoreApplication.translate
self.table_test.setRowCount(index + 1)
if param[0] == "P":
item = QtWidgets.QTableWidgetItem()
self.table_test.setItem(index, 1, item)
item.setText(param[1])
item = QtWidgets.QTableWidgetItem()
self.table_test.setItem(index, 2, item)
item.setText(param[2])
item = QtWidgets.QTableWidgetItem()
self.table_test.setItem(index, 3, item)
item.setText(param[3])
item = QtWidgets.QTableWidgetItem()
self.table_test.setItem(index, 4, item)
item.setText(param[4])
elif param[0] == "O":
item = QtWidgets.QTableWidgetItem()
self.table_test.setItem(index, 0, item)
item.setText(param[1])
item = QtWidgets.QTableWidgetItem()
self.table_test.setItem(index, 5, item)
item.setText(param[2])
elif param[0] == "R":
item = QtWidgets.QTableWidgetItem()
self.table_test.setItem(index, 6, item)
item.setText(param[1])
item = QtWidgets.QTableWidgetItem()
self.table_test.setItem(index, 7, item)
item.setText(param[2])
index += 1
def closeWindown(self):
if hasattr(self, "server"):
self.server.shutdown()
self.server = None
self.t.stop()
class ModbusServer(object):
"""Modbus TCP server"""
class ModbusService(BaseRequestHandler):
def recv_all(self, size):
if hasattr(socket, "MSG_WAITALL"):
data = self.request.recv(size, socket.MSG_WAITALL)
else:
# Windows lacks MSG_WAITALL
data = b''
while len(data) < size:
data += self.request.recv(size - len(data))
return data
def handle(self):
while True:
rx_head = self.recv_all(7)
# close connection if no standard 7 bytes header
if not (rx_head and len(rx_head) == 7):
break
# decode header
(rx_hd_tr_id, rx_hd_pr_id, rx_hd_length,
rx_hd_unit_id) = struct.unpack('>HHHB', rx_head)
# close connection if frame header content inconsistency
if not ((rx_hd_pr_id == 0) and (2 < rx_hd_length < 256)):
break
# receive body
rx_body = self.recv_all(rx_hd_length - 1)
# close connection if lack of bytes in frame body
if not (rx_body and (len(rx_body) == rx_hd_length - 1)):
break
# body decode: function code
rx_bd_fc = struct.unpack('B', rx_body[0:1])[0]
# close connection if function code is inconsistent
if rx_bd_fc > 0x7F:
break
# default except status
exp_status = const.EXP_NONE
# functions Read Coils (0x01) or Read Discrete Inputs (0x02)
if rx_bd_fc in (const.READ_COILS, const.READ_DISCRETE_INPUTS):
(b_address, b_count) = struct.unpack('>HH', rx_body[1:])
# check quantity of requested bits
if 0x0001 <= b_count <= 0x07D0:
bits_l = DataBank.get_bits(b_address, b_count)
if bits_l:
# allocate bytes list
b_size = int(b_count / 8)
b_size += 1 if (b_count % 8) else 0
bytes_l = [0] * b_size
# populate bytes list with data bank bits
for i, item in enumerate(bits_l):
if item:
byte_i = int(i / 8)
bytes_l[byte_i] = set_bit(
bytes_l[byte_i], i % 8)
# format body of frame with bits
tx_body = struct.pack('BB', rx_bd_fc, len(bytes_l))
# add bytes with bits
for byte in bytes_l:
tx_body += struct.pack('B', byte)
else:
exp_status = const.EXP_DATA_ADDRESS
else:
exp_status = const.EXP_DATA_VALUE
# functions Read Holding Registers (0x03) or Read Input Registers (0x04)
elif rx_bd_fc in (const.READ_HOLDING_REGISTERS,
const.READ_INPUT_REGISTERS):
(w_address, w_count) = struct.unpack('>HH', rx_body[1:])
# check quantity of requested words
if 0x0001 <= w_count <= 0x007D:
words_l = DataBank.get_words(w_address, w_count)
if words_l:
# format body of frame with words
tx_body = struct.pack('BB', rx_bd_fc, w_count * 2)
for word in words_l:
tx_body += struct.pack('>H', word)
else:
exp_status = const.EXP_DATA_ADDRESS
else:
exp_status = const.EXP_DATA_VALUE
# function Write Single Coil (0x05)
elif rx_bd_fc is const.WRITE_SINGLE_COIL:
(b_address, b_value) = struct.unpack('>HH', rx_body[1:])
f_b_value = bool(b_value == 0xFF00)
if DataBank.set_bits(b_address, [f_b_value]):
# send write ok frame
tx_body = struct.pack('>BHH', rx_bd_fc, b_address,
b_value)
else:
exp_status = const.EXP_DATA_ADDRESS
# function Write Single Register (0x06)
elif rx_bd_fc is const.WRITE_SINGLE_REGISTER:
(w_address, w_value) = struct.unpack('>HH', rx_body[1:])
if DataBank.set_words(w_address, [w_value]):
# send write ok frame
tx_body = struct.pack('>BHH', rx_bd_fc, w_address,
w_value)
else:
exp_status = const.EXP_DATA_ADDRESS
# function Write Multiple Coils (0x0F)
elif rx_bd_fc is const.WRITE_MULTIPLE_COILS:
(b_address, b_count,
byte_count) = struct.unpack('>HHB', rx_body[1:6])
# check quantity of updated coils
if (0x0001 <= b_count <= 0x07B0) and (byte_count >=
(b_count / 8)):
# allocate bits list
bits_l = [False] * b_count
# populate bits list with bits from rx frame
for i, item in enumerate(bits_l):
b_bit_pos = int(i / 8) + 6
b_bit_val = struct.unpack(
'B', rx_body[b_bit_pos:b_bit_pos + 1])[0]
bits_l[i] = test_bit(b_bit_val, i % 8)
# write words to data bank
if DataBank.set_bits(b_address, bits_l):
# send write ok frame
tx_body = struct.pack('>BHH', rx_bd_fc, b_address,
b_count)
else:
exp_status = const.EXP_DATA_ADDRESS
else:
exp_status = const.EXP_DATA_VALUE
# function Write Multiple Registers (0x10)
elif rx_bd_fc is const.WRITE_MULTIPLE_REGISTERS:
(w_address, w_count,
byte_count) = struct.unpack('>HHB', rx_body[1:6])
# check quantity of updated words
if (0x0001 <= w_count <= 0x007B) and (byte_count
== w_count * 2):
# allocate words list
words_l = [0] * w_count
# populate words list with words from rx frame
for i, item in enumerate(words_l):
w_offset = i * 2 + 6
words_l[i] = struct.unpack(
'>H', rx_body[w_offset:w_offset + 2])[0]
# write words to data bank
if DataBank.set_words(w_address, words_l):
# send write ok frame
tx_body = struct.pack('>BHH', rx_bd_fc, w_address,
w_count)
else:
exp_status = const.EXP_DATA_ADDRESS
else:
exp_status = const.EXP_DATA_VALUE
else:
exp_status = const.EXP_ILLEGAL_FUNCTION
# check exception
if exp_status != const.EXP_NONE:
# format body of frame with exception status
tx_body = struct.pack('BB', rx_bd_fc + 0x80, exp_status)
# build frame header
tx_head = struct.pack('>HHHB', rx_hd_tr_id, rx_hd_pr_id,
len(tx_body) + 1, rx_hd_unit_id)
# send frame
self.request.send(tx_head + tx_body)
self.request.close()
def __init__(self,
host='localhost',
port=const.MODBUS_PORT,
no_block=False,
ipv6=False):
"""Constructor
Modbus server constructor.
:param host: hostname or IPv4/IPv6 address server address (optional)
:type host: str
:param port: TCP port number (optional)
:type port: int
:param no_block: set no block mode, in this mode start() return (optional)
:type no_block: bool
:param ipv6: use ipv6 stack
:type ipv6: bool
"""
# public
self.host = host
self.port = port
self.no_block = no_block
self.ipv6 = ipv6
# private
self._running = False
self._service = None
self._serve_th = None
def start(self):
"""Start the server.
Do nothing if server is already running.
This function will block if no_block is not set to True.
"""
if not self.is_run:
# set class attribute
ThreadingTCPServer.address_family = socket.AF_INET6 if self.ipv6 else socket.AF_INET
ThreadingTCPServer.daemon_threads = True
# init server
self._service = ThreadingTCPServer((self.host, self.port),
self.ModbusService,
bind_and_activate=False)
# set socket options
self._service.socket.setsockopt(socket.SOL_SOCKET,
socket.SO_REUSEADDR, 1)
self._service.socket.setsockopt(socket.SOL_SOCKET,
socket.SO_KEEPALIVE, 1)
# TODO test no_delay with bench
self._service.socket.setsockopt(socket.IPPROTO_TCP,
socket.TCP_NODELAY, 1)
# bind and activate
self._service.server_bind()
self._service.server_activate()
# serve request
if self.no_block:
self._serve_th = Thread(target=self._serve)
self._serve_th.daemon = True
self._serve_th.start()
else:
self._serve()
def stop(self):
"""Stop the server.
Do nothing if server is already not running.
"""
if self.is_run:
self._service.shutdown()
self._service.server_close()
@property
def is_run(self):
"""Return True if server running.
"""
return self._running
def _serve(self):
try:
self._running = True
self._service.serve_forever()
except:
self._service.server_close()
raise
finally:
self._running = False
server_port = 7000
gLock = threading.Lock()
class EchoHandler(BaseRequestHandler):
def handle(self):
self.data = None
while True:
self.data = self.request.recv(1024)
if not self.data: break
gLock.acquire()
print(
"Server received {0} bytes on thread {1} from {2}:{3}".format(
len(self.data),
threading.current_thread().name, *self.client_address))
print(' {0}'.format(self.data))
gLock.release()
self.request.send(self.data)
try:
s = ThreadingTCPServer((server_addr, server_port), EchoHandler)
s.allow_reuse_address = True
print("Server started")
s.serve_forever()
except (KeyboardInterrupt, SystemExit):
pass
finally:
s.shutdown()
print("Server stopped")
