def __init__(self, tcp_conn: TcpConnection, server: HttpServer) -> None:
HttpMessageHandler.__init__(self)
EventEmitter.__init__(self)
self.tcp_conn = tcp_conn
self.server = server
self.ex_queue = [] # type: list[HttpServerExchange] # queue of exchanges
self.output_paused = False
def __init__(self, tcp_conn, server):
HttpMessageHandler.__init__(self)
EventEmitter.__init__(self)
self.tcp_conn = tcp_conn
self.server = server
self.ex_queue = [] # queue of exchanges
self.output_paused = False
def __init__(self, http_conn, method, uri, req_hdrs, req_version):
EventEmitter.__init__(self)
self.http_conn = http_conn
self.method = method
self.uri = uri
self.req_hdrs = req_hdrs
self.req_version = req_version
self.started = False
def __init__(self, exchange: EventEmitter) -> None:
self.exchange = exchange
self.method = b""
self.uri = b""
self.req_hdrs = [] # type: RawHeaderListType
self.req_body = b""
exchange.on("request_start", self.request_start)
exchange.on("request_body", self.request_body)
exchange.on("request_done", self.request_done)
def __init__(self, session, ping_timeout):
EventEmitter.__init__(self)
self._session = session
self._ping_timeout = ping_timeout if int(ping_timeout or 0) > 0 else None
self._ping_timeout_ev = None
self._ping_id = None
self._ping_timestamp = None
self._pong_timestamp = None
self._is_active = False
def __init__(self, http_conn, method: bytes, uri: bytes, req_hdrs: RawHeaderListType,
req_version: bytes) -> None:
EventEmitter.__init__(self)
self.http_conn = http_conn
self.method = method
self.uri = uri
self.req_hdrs = req_hdrs
self.req_version = req_version
self.started = False
def __init__(self, precision: float=None) -> None:
EventEmitter.__init__(self)
self.precision = precision or .5 # of running scheduled queue (secs)
self.running = False # whether or not the loop is running (read-only)
self.__sched_events = [] # type: list[Tuple[float, Callable]]
self._fd_targets = {} # type: dict[int, EventEmitter]
self.__now = None # type: float
self._eventlookup = dict([(v, k) for (k, v) in self._event_types.items()])
self.__event_cache = {} # type: dict[int, set[str]]
def __init__(self):
EventEmitter.__init__(self)
self.session = None
self.timestamp = time.time()
self.stream_id = None
self.priority = Priority.MIN
self._stream_assoc_id = None
self._req_state = ExchangeStates.WAITING
self._res_state = ExchangeStates.WAITING
self._pushed = False # is it a server pushed stream?
def __init__(self, header):
"""
Given an IP address and port, try the magic on it, emitting a 'result' event.
"""
EventEmitter.__init__(self)
self.header = header.lower()
self.client = HttpClient()
self.client.connect_timeout = self.connect_timeout
self.client.read_timeout = self.wait_timeout
self.client.idle_timeout = 0 # Don't need no steenkin pconns
def __init__(self, precision=None):
EventEmitter.__init__(self)
self.precision = precision or .5 # of running scheduled queue (secs)
self.running = False # whether or not the loop is running (read-only)
self.__sched_events = []
self._fd_targets = {}
self.__now = None
self._eventlookup = dict(
[(v,k) for (k,v) in self._event_types.items()]
)
self.__event_cache = {}
def __init__(self, exchange: EventEmitter, server: RedBotServer) -> None:
self.exchange = exchange
self.config = server.config
self.static_files = server.static_files
self.method = b""
self.uri = b""
self.req_hdrs = [] # type: RawHeaderListType
self.req_body = b""
exchange.on("request_start", self.request_start)
exchange.on("request_body", self.request_body)
exchange.on("request_done", self.request_done)
def __init__(self, config: SectionProxy, output: Callable[[str], None], **kw: Any) -> None:
"""
Formatter for the given URI, writing
to the callable output(uni_str). Output is Unicode; callee
is responsible for encoding correctly.
"""
EventEmitter.__init__(self)
self.config = config
self.lang = config['lang']
self.output = output # output file object
self.kw = kw # extra keyword arguments
self.resource = None # type: HttpResource
def __init__(self, ui_uri: str, lang: str, output: Callable[[str], None], **kw: Any) -> None:
"""
Formatter for the given URI, writing
to the callable output(uni_str). Output is Unicode; callee
is responsible for encoding correctly.
"""
EventEmitter.__init__(self)
self.ui_uri = ui_uri # the URI of the UI itself
self.lang = lang
self.output = output # output file object
self.kw = kw # extra keyword arguments
self.resource = None # type: HttpResource
def __init__(self, ui_uri: str, lang: str, output: Callable[[str], None],
**kw: Any) -> None:
"""
Formatter for the given URI, writing
to the callable output(uni_str). Output is Unicode; callee
is responsible for encoding correctly.
"""
EventEmitter.__init__(self)
self.ui_uri = ui_uri # the URI of the UI itself
self.lang = lang
self.output = output # output file object
self.kw = kw # extra keyword arguments
self.resource = None # type: HttpResource
def __init__(self):
EventEmitter.__init__(self)
self.foo_count = 0
self.bar_count = 0
self.rem1_count = 0
self.rem2_count = 0
self.on('foo', self.handle_foo)
self.once('bar', self.handle_bar)
self.on('baz', self.handle_baz)
self.on('rem1', self.handle_rem1)
self.on('rem1', self.handle_rem1a)
self.on('rem2', self.handle_rem2)
self.on('rem2', self.handle_rem2a)
def __init__(self, config: SectionProxy, output: Callable[[str], None],
**kw: Any) -> None:
"""
Formatter for the given URI, writing
to the callable output(uni_str). Output is Unicode; callee
is responsible for encoding correctly.
"""
EventEmitter.__init__(self)
self.config = config
self.lang = config["lang"]
self.output = output # output file object
self.kw = kw # extra keyword arguments
self.resource = None # type: HttpResource
def __init__(self, magic):
"""
Given an IP address and port, try the magic on it, emitting a 'result' event.
"""
EventEmitter.__init__(self)
self.magic = magic + "\n"
self.timeouts = []
self.conn = None
self.output = ''
self.start = 0
self.latency = 0
self.client = TcpClient()
self.client.on("connect", self.connect)
self.client.on("connect_error", self.connect_error)
def __init__(self,
connect_timeout=None, # seconds to wait for connect until throwing error
read_timeout=None, # seconds to wait for a response to request from server
idle_timeout=None, # seconds a conn is kept open until a frame is received
tls_config=None,
loop=None):
EventEmitter.__init__(self)
self._connect_timeout = connect_timeout if int(connect_timeout or 0) > 0 else None
self._read_timeout = read_timeout if int(read_timeout or 0) > 0 else None
self._idle_timeout = idle_timeout if int(idle_timeout or 0) > 0 else None
self._tls_config = tls_config
self._sessions = dict()
self._loop = loop or global_loop
self._loop.on('stop', self.shutdown)
def __init__(self, is_client, idle_timeout=None, loop=None):
EventEmitter.__init__(self)
self.tcp_conn = None
self._loop = loop or global_loop
self._idle_timeout = idle_timeout if int(idle_timeout or 0) > 0 else None
self._idle_timeout_ev = None
self._is_client = is_client
self._origin = None # (host, port)
self.frame_handlers = defaultdict(list)
self.frame_handlers[FrameTypes.PING] = [self._frame_ping]
self.frame_handlers[FrameTypes.GOAWAY] = [self._frame_goaway]
self.frame_handlers[FrameTypes.SETTINGS] = [self._frame_settings]
self.frame_handlers[FrameTypes.CREDENTIAL] = [self._frame_credential]
self.frame_handlers[FrameTypes.WINDOW_UPDATE] = [self._frame_window_update]
SpdySession._reset(self)
def __init__(self, client):
HttpMessageHandler.__init__(self)
EventEmitter.__init__(self)
self.client = client
self.method = None
self.uri = None
self.req_hdrs = None
self.req_target = None
self.scheme = None
self.authority = None
self.res_version = None
self.tcp_conn = None
self._conn_reusable = False
self._req_body = False
self._req_started = False
self._retries = 0
self._read_timeout_ev = None
self._output_buffer = []
def __init__(self, client) -> None:
HttpMessageHandler.__init__(self)
EventEmitter.__init__(self)
self.client = client
self.careful = client.careful
self.method = None # type: bytes
self.uri = None # type: bytes
self.req_hdrs = None # type: RawHeaderListType
self.req_target = None # type: bytes
self.scheme = None # type: bytes
self.authority = None # type: bytes
self.res_version = None # type: bytes
self.tcp_conn = None # type: TcpConnection
self.origin = None # type: OriginType
self._conn_reusable = False
self._req_body = False
self._req_started = False
self._retries = 0
self._read_timeout_ev = None # type: ScheduledEvent
self._output_buffer = [] # type: list[bytes]
def __init__(self, loop: 'LoopBase'=None) -> None:
EventEmitter.__init__(self)
self._loop = loop or _loop
self._interesting_events = set() # type: set[str]
self._fd = None # type: int
def __init__(self, host, port, loop=None):
EventEmitter.__init__(self)
self.tcp_server = self.tcp_server_class(host, port, loop=loop)
self.tcp_server.on('connect', self.handle_conn)
schedule(0, self.emit, 'start')
def __init__(self, loop=None):
EventEmitter.__init__(self)
self._loop = loop or _loop
self._interesting_events = set()
self._fd = None
def __init__(self, host: bytes, port: int, loop: LoopBase=None) -> None:
EventEmitter.__init__(self)
self.tcp_server = self.tcp_server_class(host, port, loop=loop)
self.tcp_server.on('connect', self.handle_conn)
schedule(0, self.emit, 'start')
