def __init__(self, app, hostname, io_loop=None, ssl_options=None, **kwargs):
     log.warn('Graphite listener is started -- if you do not need graphite, turn it off in datadog.conf.')
     log.warn('Graphite relay uses pickle to transport messages. Pickle is not secured against remote execution exploits.')
     log.warn('See http://blog.nelhage.com/2011/03/exploiting-pickle/ for more details')
     self.app = app
     self.hostname = hostname
     TCPServer.__init__(self, io_loop=io_loop, ssl_options=ssl_options, **kwargs)

 def initialize(
     self,
     request_callback,
     no_keep_alive=False,
     io_loop=None,
     xheaders=False,
     ssl_options=None,
     protocol=None,
     decompress_request=False,
     chunk_size=None,
     max_header_size=None,
     idle_connection_timeout=None,
     body_timeout=None,
     max_body_size=None,
     max_buffer_size=None,
 ):
     self.request_callback = request_callback
     self.no_keep_alive = no_keep_alive
     self.xheaders = xheaders
     self.protocol = protocol
     self.conn_params = HTTP1ConnectionParameters(
         decompress=decompress_request,
         chunk_size=chunk_size,
         max_header_size=max_header_size,
         header_timeout=idle_connection_timeout or 3600,
         max_body_size=max_body_size,
         body_timeout=body_timeout,
     )
     TCPServer.__init__(
         self, io_loop=io_loop, ssl_options=ssl_options, max_buffer_size=max_buffer_size, read_chunk_size=chunk_size
     )
     self._connections = set()

 def __init__(self, connect_cb, disconnect_cb, data_cb, port=12345, host=''):
     TCPServer.__init__(self)
     self.connect_callback = connect_cb
     self.disconnect_callback = disconnect_cb
     self.data_callback = data_cb
     self.clients = []
     self.listen(port, host)
     logging.info('Listening on port: %i', port)

 def __init__(self, storage, sender, io_loop=None, **kwargs):
     TCPServer.__init__(self, io_loop=io_loop, **kwargs)
     self.storage = storage
     if not os.path.exists(self.storage):
         os.mkdir(self.storage)
     self.loop = io_loop or ioloop.IOLoop.current()
     self.send_mail = sender
     self.loop.call_later(10, self.send_mails)

 def __init__(self, request_callback, io_loop=None, auth_password=None, **kwargs):
     self.request_callback = request_callback
     self.stats = Stats()
     self.auth_password = auth_password
     self.require_auth = False
     if self.auth_password:
         self.require_auth = True
     TCPServer.__init__(self, io_loop=io_loop, **kwargs)

 def __init__(self, request_callback, no_keep_alive=False, io_loop=None,
              xheaders=False, ssl_options=None, protocol=None, **kwargs):
     self.request_callback = request_callback
     self.no_keep_alive = no_keep_alive
     self.xheaders = xheaders
     self.protocol = protocol
     TCPServer.__init__(self, io_loop=io_loop, ssl_options=ssl_options,
                        **kwargs)

    def __init__(self, port, prt_types, prt_types_handlers):

        PNFPServer.__init__(self, prt_types, prt_types_handlers)
        TCPServer.__init__(self)

        self.port = int(port)
        self.connection = None

        self.listen(self.port)

 def __init__(self, io_loop=None, ssl_options=None, gp_module=False, **kwargs):
     self.logger = logging.getLogger(self.__class__.__name__)
     self.gp_module = gp_module
     try:
         TCPServer.__init__(self, ssl_options=ssl_options, **kwargs)
     except:
         etype, evalue, etb = sys.exc_info()
         self.logger.error("Could not create tcp server. Exception: %s, Error: %s." % (etype, evalue))
         self.gp_module.shutDown()

    def __init__ (self, db_conn, cursor, role):
        self.conn = db_conn
        self.cur = cursor
        self.role = role

        if self.role == 'ota':
            self.conn_pool = DeviceServer.accepted_ota_conns
        else:
            self.conn_pool = DeviceServer.accepted_xchange_conns

        TCPServer.__init__(self)

    def __init__(self, port, pt_types, pt_types_handlers):

        PNFPServer.__init__(self, pt_types, pt_types_handlers)
        TCPServer.__init__(self)

        self.port = int(port)
        self.connection = None

        self.listen(self.port)

        self.lvaps = {}
        self.__assoc_id = 0

    def __init__(self, torrent, max_peers=50, download_path='downloads', peer_id=peer_id(), storage_class=DiskStorage):
        TCPServer.__init__(self)

        self.peer_id = peer_id
        self.torrent = torrent

        self.max_peers = max_peers
        self.connected_peers = set()
        self.connecting_peers = set()
        self.unconnected_peers = set()

        self.storage = storage_class.from_torrent(torrent, base_path=download_path)

    def __init__(self, config, agentType):
        self._config = config
        self._log = getLogger()
        self._client = AsyncHTTPClient()
        self._syncClient = HTTPClient()

        self._agentType = agentType 
        self._parseConfig()

        self._tunnel = 0
        self._hangUp = False

        self._stream = None

        TCPServer.__init__(self)

    def __init__(self, env):
        self._env = env
        
        self._client = AsyncHTTPClient()

        self._syncClient = HTTPClient()


        config = env.config

        self._cid = config.channel
        self._url = '%s://%s' % (config.protocol, config.server)

        self._hangUp = False

        TCPServer.__init__(self)

 def initialize(
     self,
     request_callback: Union[
         httputil.HTTPServerConnectionDelegate,
         Callable[[httputil.HTTPServerRequest], None],
     ],
     no_keep_alive: bool = False,
     xheaders: bool = False,
     ssl_options: Union[Dict[str, Any], ssl.SSLContext] = None,
     protocol: str = None,
     decompress_request: bool = False,
     chunk_size: int = None,
     max_header_size: int = None,
     idle_connection_timeout: float = None,
     body_timeout: float = None,
     max_body_size: int = None,
     max_buffer_size: int = None,
     trusted_downstream: List[str] = None,
 ) -> None:
     # This method's signature is not extracted with autodoc
     # because we want its arguments to appear on the class
     # constructor. When changing this signature, also update the
     # copy in httpserver.rst.
     self.request_callback = request_callback
     self.xheaders = xheaders
     self.protocol = protocol
     self.conn_params = HTTP1ConnectionParameters(
         decompress=decompress_request,
         chunk_size=chunk_size,
         max_header_size=max_header_size,
         header_timeout=idle_connection_timeout or 3600,
         max_body_size=max_body_size,
         body_timeout=body_timeout,
         no_keep_alive=no_keep_alive,
     )
     TCPServer.__init__(
         self,
         ssl_options=ssl_options,
         max_buffer_size=max_buffer_size,
         read_chunk_size=chunk_size,
     )
     self._connections = set()  # type: Set[HTTP1ServerConnection]
     self.trusted_downstream = trusted_downstream

    def start(self):
        """Starts the service on the configured port and host, or uses an
        OS-assigned port if not provided.
        """
        sock, port, host = self.build_socket()
        self.port = port
        self.host = host

        self.server = TCPServer()
        self.server.handle_stream = self.handle_stream
        self.server.add_socket(sock)
        self.server.start(self.procs)

    def __init__(self, request_callback, no_keep_alive=False, io_loop=None,
                 xheaders=False, ssl_options=None, protocol=None, gzip=False,
                 chunk_size=None, max_header_size=None,
                 idle_connection_timeout=None, body_timeout=None,
                 max_body_size=None, max_buffer_size=None):

        # 回调对象，一个application对象，具有handlers的list
        self.request_callback = request_callback

        self.no_keep_alive = no_keep_alive
        self.xheaders = xheaders
        self.protocol = protocol
        self.conn_params = HTTP1ConnectionParameters(  # 基本的连接参数
            use_gzip=gzip,
            chunk_size=chunk_size,
            max_header_size=max_header_size,
            header_timeout=idle_connection_timeout or 3600,
            max_body_size=max_body_size,
            body_timeout=body_timeout)
        TCPServer.__init__(self, io_loop=io_loop, ssl_options=ssl_options,
                           max_buffer_size=max_buffer_size,
                           read_chunk_size=chunk_size)
        self._connections = set()  # 保存全部的连接

 def start(self):
     self.tcp_server = TCPServer(max_buffer_size=MAX_BUFFER_SIZE,
                                 **self.server_args)
     self.tcp_server.handle_stream = self._handle_stream
     backlog = int(dask.config.get('distributed.comm.socket-backlog'))
     for i in range(5):
         try:
             # When shuffling data between workers, there can
             # really be O(cluster size) connection requests
             # on a single worker socket, make sure the backlog
             # is large enough not to lose any.
             sockets = netutil.bind_sockets(self.port, address=self.ip,
                                            backlog=backlog)
         except EnvironmentError as e:
             # EADDRINUSE can happen sporadically when trying to bind
             # to an ephemeral port
             if self.port != 0 or e.errno != errno.EADDRINUSE:
                 raise
             exc = e
         else:
             self.tcp_server.add_sockets(sockets)
             break
     else:
         raise exc

 def __init__(self):
     TCPServer.__init__(self)
     self.client_list = []

 def __init__(self, no_keep_alive=False, protocol=None, **kwargs):
     self.no_keep_alive = no_keep_alive
     self.protocol = protocol
     TCPServer.__init__(self, **kwargs)

 def __init__ (self, db_conn, cursor, role):
     self.conn = db_conn
     self.cur = cursor
     self.role = role
     TCPServer.__init__(self)