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()