def __init__(self, Address): """Set up an initially empty mapping between a user' s nickname and the file-like object used to send data to that user.""" TCPServer.__init__(self, Address, RtspServerThread.Server._Rtsp_, bind_and_activate=True)
def __init__(self, address, unit=0, updatetime=True): self.time_updater = None self.aquaero = Aquaero(unit) TCPServer.__init__(self, address, PyquaeroHandler) if updatetime: self.time_updater = PyquaeroTimeUpdater(self.aquaero) self.time_updater.start()
def __init__(self, *, host="0.0.0.0", port=1150, objects={}): TCPServer.allow_reuse_address = True TCPServer.__init__(self, (host, port), ImageHandler) Thread.__init__(self) self.host = host self.port = port self.objects = objects
def __init__(self, port=7767, handler=None, start=False): Handler = handler or AutoUploadHandler TCPServer.__init__(self, ('', port), Handler) TranxFerLogger.info('Serving on %s : %d ' % (self.getNetwork().ip or self.lh, port)) if start: self.start()
def __init__(self, server_address, request_class, numThreads=10, bind_and_activate=True): ThreadPoolMixIn.__init__(self, numThreads=numThreads) TCPServer.__init__( self, server_address, request_class, bind_and_activate)
def __init__(self, address, commands, handler=SteppingParrotRequest): """Create a new AssociationServer, bind a socket and start listening. Parameters ---------- ae : ae.ApplicationEntity The parent AE that's running the server. address : 2-tuple The (host, port) that the server should run on. ssl_context : ssl.SSLContext, optional If TLS is to be used then this should be the ssl.SSLContext used to wrap the client sockets, otherwise if None then no TLS will be used (default). """ self.commands = commands self.event = threading.Event() self.event.set() self.ssl_context = None self.allow_reuse_address = True TCPServer.__init__(self, address, handler, bind_and_activate=True) self.timeout = 60 self.handlers = [] self._gc = [0, 59]
def __init__(self, server_address, RequestHandlerClass=None, timeout=3.0, authenticator=None, queue_manager=None, topic_manager=None, protocol=None): """ Extension to C{TCPServer} constructor to provide mechanism for providing implementation classes. @param server_address: The (address,port) C{tuple} @param RequestHandlerClass: The class to use for handling requests. @param timeout: The timeout for the underlying socket. @keyword authenticator: The configure L{coilmq.auth.Authenticator} object to use. @keyword queue_manager: The configured L{coilmq.queue.QueueManager} object to use. @keyword topic_manager: The configured L{coilmq.topic.TopicManager} object to use. """ self.log = logging.getLogger( '%s.%s' % (self.__module__, self.__class__.__name__)) if not RequestHandlerClass: RequestHandlerClass = StompRequestHandler self.timeout = timeout self.authenticator = authenticator self.queue_manager = queue_manager self.topic_manager = topic_manager self.protocol = protocol self.frames_queue = Queue.Queue() self._serving_event = threading.Event() self._shutdown_request_event = threading.Event() TCPServer.__init__(self, server_address, RequestHandlerClass)
def __init__(self, server_address, router: ServerHandler, secure_connection=True, certificate_file=None, certificate_key_file=None, ssl_version=ssl.PROTOCOL_TLS_SERVER, ca_certs=None, bind_and_activate=True, message_parsers=None): if message_parsers is None: message_parsers = [JsonMessage, ByteMessage] handler = ServerClientConnectionFactory( router=router, message_parsers=message_parsers) Thread.__init__(self) TCPServer.__init__(self, server_address=server_address, RequestHandlerClass=handler.create_with_router, bind_and_activate=bind_and_activate) self.ssl_version = ssl_version self.certificate_file = certificate_file self.certificate_key_file = certificate_key_file self.ca_certs = ca_certs self.secure_connection = secure_connection self.router = router
def __init__(self, server_address, HandlerClass, nametodns, nameserver, ipv6): self.ipv6 = ipv6 self.nametodns = nametodns self.nameserver = nameserver self.address_family = socket.AF_INET6 if self.ipv6 else socket.AF_INET TCPServer.__init__(self, server_address, HandlerClass)
def start(self): TCPServer.__init__(self, ('localhost', int(HTTP_PORT)), CustomHandler) self.RESOURCE_LOCATION = path.abspath(path.dirname(__file__)) print("Server serving from DocumentRoot:" + self.RESOURCE_LOCATION) chdir(self.RESOURCE_LOCATION) server_thread = threading.Thread(name='test_file_server', target=self.serve_forever) server_thread.daemon = True server_thread.start()
def __init__(self): """ Tworzy instancję serwera. """ self.__configuration = Configuration() TCPServer.__init__( self, (self.__configuration.host, self.__configuration.port), ClientServerHandler)
def __init__(self, port, host=SERVER_HOST, loglevel=logging.WARNING): logger.setLevel(loglevel) # Params: server_address, RequestHandlerClass # server_bind(), socket.bind() and server_activate(), socket.listen() TCPServer.__init__(self, (host, port), WebSocketRequestHandler) # socket.getsockname() return server local address self.port = self.socket.getsockname()[1]
def __init__(self, server_address, handler_cls): TCPServer.__init__(self, server_address, handler_cls, bind_and_activate=False) self.socket = socket.fromfd(self.SYSTEMD_FIRST_SOCKET_FD, self.address_family, self.socket_type)
def __init__(self, server_address, handler_cls): # Invoke base but omit bind/listen steps (performed by systemd activation!) TCPServer.__init__(self, server_address, handler_cls, bind_and_activate=False) # Override socket self.socket = socket.fromfd(self.SYSTEMD_FIRST_SOCKET_FD, self.address_family, self.socket_type)
def __init__(self, port, logfile=None): self.port = port Handler = webwin.WebWinHTTPRequestHandler TCPServer.__init__(self, ("", port), Handler) self.timeout = 1 self.patterngenerator = self self._listening = threading.Event() self.logfile = logfile self.pattern = "#808080|#808080|0|0|1|1"
def __init__(self, server_address, base_url, RequestHandlerClass, bind_and_activate=True): TCPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate) self.base_url = base_url
def __init__(self, address, heartbeat_interval = 10000, family = socket.AF_INET): self.address_family = family TCPServer.__init__(self, address, BaseRequestHandler, False) self._clients = dict() self._lock = threading.RLock() self._data_items = [] self._running = False self._heartbeat_interval = heartbeat_interval self._ping_pat = re.compile('\\* PING')
def start(self): TCPServer.__init__(self, ('localhost', int(HTTP_PORT)), CustomHandler) self.RESOURCE_LOCATION = path.abspath(path.dirname(__file__)) print("Server serving from DocumentRoot:" + self.RESOURCE_LOCATION) chdir(self.RESOURCE_LOCATION) server_thread = threading.Thread(name='test_file_server', target=self.serve_forever) server_thread.daemon = True server_thread.start()
def __init__(self, server_address, handler, resolver, bind_and_activate=True): self.resolver = resolver logger.info('starting TCP DNS server at %s:%s' % (server_address[0], server_address[1])) TCPServer.__init__(self, server_address, handler, bind_and_activate)
def __init__(self, server_address, RequestHandlerClass, relay_port=8181): self.lock = threading.Lock() self.reverse_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.reverse_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.reverse_socket.bind(("0.0.0.0", relay_port)) self.reverse_socket.listen(5) self.new_connect, self.new_connect_addr = self.reverse_socket.accept() TCPServer.__init__(self, server_address, RequestHandlerClass) self.allow_reuse_addres = True
def __init__(self, processes=max(2, cpu_count()), threads=64, daemon=False, kill=True, debug=False, log=logger): TCPServer.__init__(self, ('127.0.0.1', 8889), MyTestHandler) self._process_n = processes self._thread_n = threads self._daemon = daemon self._kill = kill self._debug = debug self._logger = log self._init_pool() logger.info("listening on 127.0.0.1:8889")
def __init__(self, server_address, Handler, authFile='bank.auth'): ''' Creates a new bank ip: the ip of the bank. Usually it should be localhost port: the port on which the bank is listening authFile: the auth-File the bank will create. ''' TCPServer.__init__(self, server_address, Handler) TCPServer.allow_reuse_address = True self.createAuthToken(filename=authFile)
def __init__(self, port: int, host: str = '127.0.0.1'): TCPServer.__init__(self, (host, port), WebSocketHandler) self.port = self.socket.getsockname()[1] logging.debug("{}.__init__(port: {}, host: {})".format( self.TAG, self.port, host)) self.new_client = None self.client_left = None self.message_received = None self.ping_received = None self.clients = dict() self.id_counter = -1
def __init__(self, addr=('0.0.0.0', 9001)): TCPServer.__init__(self, addr, WebSocketHandler) self.port = self.socket.getsockname()[1] bigfile = open("test.zip", "rb") tempMsg = bigfile.read() self.fileRead = tempMsg self.fileLength = len(tempMsg) self.hashMD5 = hashlib.md5(tempMsg).hexdigest() bigfile.close() print(self.fileLength)
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True, queue=None, in_queue=None): self.out_queue = queue self.in_queue = in_queue TCPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate=bind_and_activate)
def __init__(self, port, host='127.0.0.1', logger=None): TCPServer.__init__(self, (host, port), WebSocketHandler) self.logger = logging.getLogger(__name__) if logger: self.logger = logger self.port = self.socket.getsockname()[1] self.clients = [] self.id_counter = 0 self.new_client_callback = None self.client_left_callback = None self.message_received_callback = None
def __init__(self, port, host='127.0.0.1', use_ssl = False, ssl_certfile = '', ssl_private_key = ''): self.port = port self.use_ssl = True if use_ssl: BaseServer.__init__(self, (host, port), WebSocketHandler) ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.use_privatekey_file(ssl_private_key) ctx.use_certificate_file(ssl_certfile) self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate() else: TCPServer.__init__(self, (host, port), WebSocketHandler)
def __init__(self, server_address, # Server address (host,port) RequestHandlerClass, certfile, # Certificate path keyfile, # Key path ssl_version=ssl.PROTOCOL_SSLv23, #Comunicatio+n protocol ciphers="DEFAULT", bind_and_activate=True): TCPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate) self.certfile = certfile self.keyfile = keyfile self.ssl_version = ssl_version self.ciphers=ciphers
def __init__(self, server_address, nx_common): """Initializes NetflixTCPServer""" nx_common.log(msg='Constructing netflixTCPServer') netflix_session = NetflixSession( cookie_path=nx_common.cookie_path, data_path=nx_common.data_path, verify_ssl=(nx_common.get_setting('ssl_verification') == 'true'), nx_common=nx_common) self.res_handler = NetflixHttpSubRessourceHandler( nx_common=nx_common, netflix_session=netflix_session) TCPServer.__init__(self, server_address, NetflixHttpRequestHandler)
def __init__(self, server_address, RequestHandlerClass, certfile, keyfile, bind_and_activate=True): TCPServer.__init__(self, server_address, RequestHandlerClass) self.socket = ssl.wrap_socket(socket.socket(self.address_family, self.socket_type), server_side=True, certfile=certfile, keyfile=keyfile, do_handshake_on_connect=False) if bind_and_activate: self.server_bind() self.server_activate()
def __init__(self, server_address, request_handler_class, config): self.config = config self.daemon_threads = True if self.config.ipv6: self.address_family = socket.AF_INET6 self.wpad_counters = {} try: TCPServer.__init__(self, server_address, request_handler_class) except OSError as e: if "already in use" in str(e): LOG.error( 'Could not start DNS server. Address is already in use. To fix this error, specify the interface IP to listen on with --interface-ip' ) else: LOG.error('Could not start DNS server: %s', str(e)) raise e
def __init__(self, server_address, handler, certfile, keyfile, ssl_version=ssl.PROTOCOL_TLSv1, bind_and_activate=True): TCPServer.__init__(self, server_address, handler, bind_and_activate) if not os.path.isfile(certfile): raise FileNotFoundError( f'SSL certificate "{certfile}" file not found!') self.certfile = certfile if not os.path.isfile(keyfile): raise FileNotFoundError(f'SSL key "{keyfile}" not found!') self.keyfile = keyfile self.ssl_version = ssl_version
def __init__(self, file: str, server_address: Tuple, handler_class: BaseRequestHandler, bind_and_activate: bool = True) -> None: """ Creates a new DatabaseServer with the given Database file location :param file: Database file location :param server_address: Address and port of the server :param handler_class: The request handler class :param bind_and_activate: If the server should activate on initialization """ self.pid: int = os.getpid() self.file: str = file self.database: Database = Database(file) TCPServer.__init__(self, server_address, handler_class, bind_and_activate)
def __init__(self, server_address, RequestHandlerClass=None, timeout=3.0, authenticator=None, queue_manager=None, topic_manager=None, protocol=None): """ Extension to C{TCPServer} constructor to provide mechanism for providing implementation classes. @param server_address: The (address,port) C{tuple} @param RequestHandlerClass: The class to use for handling requests. @param timeout: The timeout for the underlying socket. @keyword authenticator: The configure L{coilmq.auth.Authenticator} object to use. @keyword queue_manager: The configured L{coilmq.queue.QueueManager} object to use. @keyword topic_manager: The configured L{coilmq.topic.TopicManager} object to use. """ self.log = logging.getLogger('%s.%s' % ( self.__module__, self.__class__.__name__)) if not RequestHandlerClass: RequestHandlerClass = StompRequestHandler self.timeout = timeout self.authenticator = authenticator self.queue_manager = queue_manager self.topic_manager = topic_manager self.protocol = protocol self._serving_event = threading.Event() self._shutdown_request_event = threading.Event() TCPServer.__init__(self, server_address, RequestHandlerClass)
def __init__(self, do_ssl=False, paypal_mode='valid'): TCPServer.__init__(self, ("", 0), Handler) # old-style base? self.do_ssl = do_ssl self.paypal_mode = paypal_mode self.last_request_body = None self.last_request_content_type = None
def __init__(self, server_address, handler, resolver, bind_and_activate=True): self.resolver = resolver logger.info('starting TCP DNS server at %s:%s' % (server_address[0], server_address[1])) TCPServer.__init__(self, server_address, handler, bind_and_activate)
def __init__(self, address, unit=0, updatetime=True): TCPServer.__init__(self, address, PyquaeroHandler) self.aquaero = Aquaero(unit) if updatetime: self.time_updater = PyquaeroTimeUpdater(self.aquaero) self.time_updater.start()
def __init__(self, host="127.0.0.1", port=12321): TCPServer.__init__(self, (host, port), ClientHandler)
def __init__(self, host, port, name=None): self.allow_reuse_address = True TCPServer.__init__(self, (host, port), self.RequstHandler) if name is None: name = "%s:%s" % (host, port) self.name = name self.poll_interval = 0.5
def __init__(self): """ Tworzy instancję serwera. """ self.__configuration = Configuration() TCPServer.__init__(self, (self.__configuration.host, self.__configuration.port), ClientServerHandler)
def __init__(self, *args, **kwargs): TCPServer.__init__(self, *args, **kwargs) self._server_replies = bytearray(b'') self._client_sends = []
def __init__(self, address, port, requestHandler): self._requestHandler = requestHandler self._port = port self._running = True TCPServer.__init__(self, (address, port), HTTPRequestHandler)