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 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.")
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()
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 main():
# tcpServ = TCP(ADDR,MyRequestHandler) #单线程
tcpServ = TCPThead(ADDR, MyRequestHandler) #多线程
tcpServ.allow_reuse_address = True #重用地址，即使客户端还没断开
print('waiting for connection...')
tcpServ.serve_forever()
tcpServ.server_close()
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 launch_server(host, port, input, show=True):
print('launching server at {0:s}:{1:d} showing "{2:s}"'.format(
host, port, input))
ThreadingTCPServer.allow_reuse_address = True
httpd = ThreadingTCPServer((host, port), NotexHandler)
if show:
thrd = Thread(target=partial(
open_in_browser, url='http://{0:s}:{1:d}'.format(host, port)))
thrd.start()
try:
httpd.serve_forever()
except KeyboardInterrupt:
httpd.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()
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()
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()
def main():
global world
world = World()
z = ThreadingTCPServer(("", 4000), MudHandler)
try:
z.serve_forever()
except KeyboardInterrupt:
world.global_message("World is shutting down")
for plr in world.players_at_location(None):
try:
plr.parse("quit")
except Exception as e:
print(f"ERROR: {plr.name} could not quit gracefully: {e!r}")
traceback.print_exc()
z.server_close()
world.save()
def start_server():
if platform.python_version_tuple()[0] == '3' and int(
platform.python_version_tuple()[1]) >= 6:
with ThreadingTCPServer(('127.0.0.1', LOCAL_PORT),
Handler,
bind_and_activate=False) as server:
server.allow_reuse_address = True
server.server_bind()
server.server_activate()
server.serve_forever()
else:
server = ThreadingTCPServer(('127.0.0.1', LOCAL_PORT),
Handler,
bind_and_activate=False)
server.allow_reuse_address = True
server.server_bind()
server.server_activate()
server.serve_forever()
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 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()
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)
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()
break
client.sendall(request)
except:
self.request.close()
client.close()
break
if __name__ == '__main__':
if len(sys.argv) != 2:
print("usage: proxy port", file=sys.stderr)
sys.exit(1)
black_file = open('black-list')
black_re = black_file.readlines()
if black_re:
black_re = [r.strip() for r in black_re]
black_re = '|'.join(black_re)
RE_BLACK = re.compile(black_re)
# TODO should also check if integer
server_port = int(sys.argv[1])
server = ThreadingTCPServer(('', server_port), ReqHandler)
try:
server.serve_forever()
except KeyboardInterrupt:
server.server_close()
print('server closed, clean up down.', file=sys.stderr)
sys.exit(0)
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
def close_server(server: ThreadingTCPServer) -> None:
server.shutdown()
server.server_close()
nwd))
chdir(
nwd
) # If files are to be served, change the working directory to the document root folder
meters = dict()
LoadSettings() # Initial load of definition file
Shutdown = Event() # The flag which will shutdown the auto-updating thread
AutoPoll = Thread(
target=RegularUpdate,
args=(meters, config.getfloat('DEFAULT', 'autopollsec'), Shutdown),
name='AutoPollThread',
daemon=True) # Daemon Thread to auto-update certain items
AutoPoll.start()
httpd = ThreadingTCPServer(
(config.get('DEFAULT', 'httphost'), config.getint(
'DEFAULT', 'httpport')), CustomHandler) # Start the HTTP Server
print('Server Running "{}:{}"'.format(config.get('DEFAULT', 'httphost'),
config.get('DEFAULT', 'httpport')))
print('To shut down, visit "/command?{}"'.format(
config.get('DEFAULT', 'shutdowncmd')))
signal.signal(signal.SIGTERM, Killer)
try:
httpd.serve_forever()
except KeyboardInterrupt: # Allow Ctrl+C locally to close it gracefully
Killer(0, None) # Envoke the signal handler
httpd.server_close() # Finally close everything off
chdir(
cwd
) # Change the working directory back to what it was when it started.
raise SystemExit # Ensure explicit termination at this point
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()
version=self.buffer["version"],
user_cron=self._get_user_cron(),
crontab_file=self._get_crontab_file())
def ins_agent(self):
agent_id, *_ = Agent.objects.get_or_create(ip=self.buffer["ip"],
hostname=self.buffer["hostname"])
self.ins_system_info(agent_id)
self.ins_crontab_info(agent_id)
self.buffer = None
def handle(self):
while True:
buf = self.request.recv(4)
length, *_ = struct.unpack("<l", buf)
mid_data = self.request.recv(length)
data, *_ = struct.unpack("<{}s".format(length), mid_data)
self.buffer = _decode_data(data)
print(self.buffer)
self.ins_agent()
if not data:
break
if __name__ == '__main__':
serv = ThreadingTCPServer(("", 15888), CollectionServer)
try:
serv.serve_forever()
except KeyboardInterrupt:
serv.server_close()
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)
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
def main():
import getopt
import os
import sys
try:
opts, args = getopt.getopt(
sys.argv[1:], "vhH:l:",
["version", "help", "ip-addresses=", "language="])
except getopt.GetoptError:
print(__usage__)
sys.exit(2)
lang = os.getenv("GNOTIFY_LANG", "")
ips = [ip for ip in os.getenv("GNOTIFY_IPS", "").split(',') if ip]
tts = " ".join(args)
for opt, arg in opts:
if opt in ("-h", "--help"):
print(__usage__)
sys.exit(2)
elif opt in ("-v", "--version"):
print("Version: {}".format(__version__))
sys.exit(2)
elif opt in ("-l", "--language"):
lang = arg
elif opt in ("-H", "--ip-addresses"):
ips = [ip for ip in arg.split(',') if ip]
import re
errors = []
if len(ips) == 0:
errors.append(
'Please enter one or more ip addresses separated by commas as an option.'
)
if str(lang) == "":
errors.append('Please enter a language code (ISO 639-1) as an option.')
elif not re.match(r"^\w{2}$", lang):
errors.append(
'Please enter a valid language code (ISO 639-1) as an option.')
if not tts or str(tts) == "":
errors.append('Please enter a text-to-speech as arguments.')
elif len(tts) > 5000:
errors.append('The requested text-to-speech is too long (> 5000).')
if errors:
print(__usage__ + '\n')
print('\n'.join(errors))
sys.exit(2)
import time
from pychromecast import Chromecast
from pychromecast.error import ChromecastConnectionError
from socketserver import ThreadingTCPServer
from http.server import SimpleHTTPRequestHandler
from threading import Thread
from cachier import cachier
@cachier()
def get_tts_mp3(tl, q):
from urllib.error import HTTPError
from urllib.parse import urlencode
from urllib.request import Request
from urllib.request import urlopen
request = Request("{}?{}".format(
"https://translate.google.com/translate_tts",
urlencode({
"ie": "UTF-8",
"q": q,
"tl": tl,
"client": "tw-ob"
})))
request.add_header("Referer", "http://translate.google.com/")
request.add_header("User-Agent", "stagefright/1.2 (Linux;Android 5.0)")
try:
response = urlopen(request)
except HTTPError:
print("Google Translate error")
sys.exit(2)
return response.read()
class FileHTTPRequestHandler(SimpleHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.end_headers()
self.wfile.write(get_tts_mp3(lang, tts))
def log_message(self, format, *args):
return
for ip in ips:
try:
cast = Chromecast(ip)
except ChromecastConnectionError as e:
print(e)
sys.exit(2)
server_ip = cast.socket_client.socket.getsockname()[0]
server = ThreadingTCPServer((server_ip, 0), FileHTTPRequestHandler)
server_port = str(server.server_address[1])
thread = Thread(target=server.serve_forever)
thread.daemon = True
thread.start()
cast.wait()
mc = cast.media_controller
mc.play_media("http://{}:{}".format(server_ip, server_port),
"audio/mpeg")
time.sleep(.5)
while mc.status.player_state != "IDLE":
try:
time.sleep(0.05)
except KeyboardInterrupt:
mc.stop()
break
server.shutdown()
server.server_close()
