예제 #1
0
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()
예제 #2
0
파일: accesser.py 프로젝트: LCinHK/Accesser
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()
예제 #3
0
    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.")
예제 #4
0
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()
예제 #5
0
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()
예제 #6
0
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()
예제 #7
0
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()
예제 #8
0
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()
예제 #9
0
파일: accesser.py 프로젝트: exbug/Accesser
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()
예제 #10
0
    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()
예제 #11
0
    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()
예제 #12
0
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.")
예제 #13
0
    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()
예제 #14
0
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()
예제 #15
0
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()
예제 #16
0
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')
예제 #17
0
파일: server.py 프로젝트: XLSForm/pyxform
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()
예제 #18
0
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()
예제 #19
0
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()
예제 #20
0
        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
예제 #21
0
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)
예제 #22
0
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()
예제 #23
0
                        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)
예제 #24
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
예제 #25
0
def close_server(server: ThreadingTCPServer) -> None:
    server.shutdown()
    server.server_close()
예제 #26
0
                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
예제 #27
0
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()
예제 #28
0
파일: server.py 프로젝트: peshow/CoFact
                                    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()

예제 #29
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)
예제 #30
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
예제 #31
0
파일: gnotify.py 프로젝트: bierdok/gnotify
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()