tor-commits July 2020

tor-commits@lists.torproject.org

17 participants
2100 discussions

[stem/master] Implement public methods of `BaseController` in the synchronous wrapper
by atagar＠torproject.org 16 Jul '20

16 Jul '20

commit 1e97d19d55f1ebd42dc04c442bb217141299a09d Author: Illia Volochii <illia.volochii(a)gmail.com> Date: Thu Apr 23 20:58:40 2020 +0300 Implement public methods of `BaseController` in the synchronous wrapper --- stem/control.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/stem/control.py b/stem/control.py index 50dff89f..7d0d517e 100644 --- a/stem/control.py +++ b/stem/control.py @@ -3903,6 +3903,9 @@ class Controller(_ControllerClassMethodMixin, _BaseControllerSocketMixin): def msg(self, message: str) -> stem.response.ControlMessage: return self._execute_async_method('msg', message) + def is_authenticated(self) -> bool: + return self._async_controller.is_authenticated() + def connect(self) -> None: self._execute_async_method('connect') @@ -3913,6 +3916,15 @@ class Controller(_ControllerClassMethodMixin, _BaseControllerSocketMixin): self._asyncio_thread.join() self._asyncio_loop.close() + def get_latest_heartbeat(self) -> float: + return self._async_controller.get_latest_heartbeat() + + def add_status_listener(self, callback: Callable[['stem.control.BaseController', 'stem.control.State', float], None], spawn: bool = True) -> None: + self._async_controller.add_status_listener(callback, spawn) + + def remove_status_listener(self, callback: Callable[['stem.control.Controller', 'stem.control.State', float], None]) -> bool: + self._async_controller.remove_status_listener(callback) + def __enter__(self) -> 'stem.control.Controller': return self

1 0

[stem/master] Implement a basic version of a synchronous wrapper of the controller
by atagar＠torproject.org 16 Jul '20

16 Jul '20

commit 7ba32adba08b83c85f7ec9b76db144e960798b79 Author: Illia Volochii <illia.volochii(a)gmail.com> Date: Thu Apr 23 20:35:54 2020 +0300 Implement a basic version of a synchronous wrapper of the controller --- stem/control.py | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/stem/control.py b/stem/control.py index cc5c9bd7..e264e4b5 100644 --- a/stem/control.py +++ b/stem/control.py @@ -3883,6 +3883,43 @@ class AsyncController(BaseController): return (set_events, failed_events) +class Controller(_ControllerClassMethodMixin, _BaseControllerSocketMixin): + def __init__(self, control_socket: 'stem.socket.ControlSocket', is_authenticated: bool = False) -> None: + self._asyncio_loop = asyncio.get_event_loop() + + self._asyncio_thread = threading.Thread(target=self._asyncio_loop.run_forever, name='asyncio') + self._asyncio_thread.setDaemon(True) + self._asyncio_thread.start() + + self._async_controller = AsyncController(control_socket, is_authenticated) + self._socket = self._async_controller._socket + + def _execute_async_method(self, method_name: str, *args: Any, **kwargs: Any) -> Any: + return asyncio.run_coroutine_threadsafe( + getattr(self._async_controller, method_name)(*args, **kwargs), + self._asyncio_loop, + ).result() + + def msg(self, message: str) -> stem.response.ControlMessage: + return self._execute_async_method('msg', message) + + def connect(self) -> None: + self._execute_async_method('connect') + + def close(self) -> None: + self._execute_async_method('close') + self._asyncio_loop.call_soon_threadsafe(self._asyncio_loop.stop) + if self._asyncio_thread.is_alive(): + self._asyncio_thread.join() + self._asyncio_loop.close() + + def __enter__(self) -> 'stem.control.Controller': + return self + + def __exit__(self, exit_type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]) -> None: + self.close() + + def _parse_circ_path(path: str) -> Sequence[Tuple[str, str]]: """ Parses a circuit path as a list of **(fingerprint, nickname)** tuples. Tor

1 0

[stem/master] Await a coroutine
by atagar＠torproject.org 16 Jul '20

16 Jul '20

commit 7ec57569d9ad912b444942c89ec4b1c22a872398 Author: Illia Volochii <illia.volochii(a)gmail.com> Date: Thu Apr 23 20:20:30 2020 +0300 Await a coroutine --- stem/control.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stem/control.py b/stem/control.py index b7050626..b0535b08 100644 --- a/stem/control.py +++ b/stem/control.py @@ -1426,7 +1426,7 @@ class AsyncController(BaseController): Listener.CONTROL: 'ControlListenAddress', }[listener_type] - port_value = self._get_conf_single(port_option).split()[0] + port_value = (await self._get_conf_single(port_option)).split()[0] for listener in (await self.get_conf(listener_option, multiple = True)): if ':' in listener:

1 0

[stem/master] Fix `AsyncController`
by atagar＠torproject.org 16 Jul '20

16 Jul '20

commit 8c875fd242436485e1ddf7e10489bb4753b2074a Author: Illia Volochii <illia.volochii(a)gmail.com> Date: Thu Apr 23 22:32:48 2020 +0300 Fix `AsyncController` --- stem/control.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stem/control.py b/stem/control.py index 7d0d517e..de8e24bb 100644 --- a/stem/control.py +++ b/stem/control.py @@ -1048,7 +1048,7 @@ class _ControllerClassMethodMixin: return cls(control_socket) -class AsyncController(BaseController): +class AsyncController(_ControllerClassMethodMixin, BaseController): """ Connection with Tor's control socket. This is built on top of the BaseController and provides a more user friendly API for library users.

1 0

[stem/master] Move three methods out of `BaseController` to reuse them
by atagar＠torproject.org 16 Jul '20

16 Jul '20

commit 72614091b6891fc35056e55fb2a6733f54993978 Author: Illia Volochii <illia.volochii(a)gmail.com> Date: Thu Apr 23 20:22:43 2020 +0300 Move three methods out of `BaseController` to reuse them --- stem/control.py | 74 +++++++++++++++++++++++++++++---------------------------- 1 file changed, 38 insertions(+), 36 deletions(-) diff --git a/stem/control.py b/stem/control.py index b0535b08..76849dcf 100644 --- a/stem/control.py +++ b/stem/control.py @@ -553,7 +553,44 @@ def event_description(event: str) -> str: return EVENT_DESCRIPTIONS.get(event.lower()) -class BaseController(object): +class _BaseControllerSocketMixin: + def is_alive(self) -> bool: + """ + Checks if our socket is currently connected. This is a pass-through for our + socket's :func:`~stem.socket.BaseSocket.is_alive` method. + + :returns: **bool** that's **True** if our socket is connected and **False** otherwise + """ + + return self._socket.is_alive() + + def is_localhost(self) -> bool: + """ + Returns if the connection is for the local system or not. + + .. versionadded:: 1.3.0 + + :returns: **bool** that's **True** if the connection is for the local host and **False** otherwise + """ + + return self._socket.is_localhost() + + def connection_time(self) -> float: + """ + Provides the unix timestamp for when our socket was either connected or + disconnected. That is to say, the time we connected if we're currently + connected and the time we disconnected if we're not connected. + + .. versionadded:: 1.3.0 + + :returns: **float** for when we last connected or disconnected, zero if + we've never connected + """ + + return self._socket.connection_time() + + +class BaseController(_BaseControllerSocketMixin): """ Controller for the tor process. This is a minimal base class for other controllers, providing basic process communication and event listing. Don't @@ -689,41 +726,6 @@ class BaseController(object): await self.close() raise - def is_alive(self) -> bool: - """ - Checks if our socket is currently connected. This is a pass-through for our - socket's :func:`~stem.socket.BaseSocket.is_alive` method. - - :returns: **bool** that's **True** if our socket is connected and **False** otherwise - """ - - return self._socket.is_alive() - - def is_localhost(self) -> bool: - """ - Returns if the connection is for the local system or not. - - .. versionadded:: 1.3.0 - - :returns: **bool** that's **True** if the connection is for the local host and **False** otherwise - """ - - return self._socket.is_localhost() - - def connection_time(self) -> float: - """ - Provides the unix timestamp for when our socket was either connected or - disconnected. That is to say, the time we connected if we're currently - connected and the time we disconnected if we're not connected. - - .. versionadded:: 1.3.0 - - :returns: **float** for when we last connected or disconnected, zero if - we've never connected - """ - - return self._socket.connection_time() - def is_authenticated(self) -> bool: """ Checks if our socket is both connected and authenticated.

1 0

[stem/master] Move class methods out of `AsyncController` to reuse them
by atagar＠torproject.org 16 Jul '20

16 Jul '20

commit ced9564eed196988160d445b94c349c9f530cdbe Author: Illia Volochii <illia.volochii(a)gmail.com> Date: Thu Apr 23 20:33:07 2020 +0300 Move class methods out of `AsyncController` to reuse them --- stem/control.py | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/stem/control.py b/stem/control.py index 76849dcf..cc5c9bd7 100644 --- a/stem/control.py +++ b/stem/control.py @@ -997,14 +997,9 @@ class BaseController(_BaseControllerSocketMixin): self._event_notice.clear() -class AsyncController(BaseController): - """ - Connection with Tor's control socket. This is built on top of the - BaseController and provides a more user friendly API for library users. - """ - - @staticmethod - def from_port(address: str = '127.0.0.1', port: Union[int, str] = 'default') -> 'stem.control.Controller': +class _ControllerClassMethodMixin: + @classmethod + def from_port(address: str = '127.0.0.1', port: Union[int, str] = 'default') -> 'stem.control._ControllerClassMethodMixin': """ Constructs a :class:`~stem.socket.ControlPort` based Controller. @@ -1035,10 +1030,10 @@ class AsyncController(BaseController): else: control_port = stem.socket.ControlPort(address, int(port)) - return AsyncController(control_port) + return cls(control_port) - @staticmethod - def from_socket_file(path: str = '/var/run/tor/control') -> 'stem.control.Controller': + @classmethod + def from_socket_file(cls: Type, path: str = '/var/run/tor/control') -> 'stem.control.Controller': """ Constructs a :class:`~stem.socket.ControlSocketFile` based Controller. @@ -1050,7 +1045,14 @@ class AsyncController(BaseController): """ control_socket = stem.socket.ControlSocketFile(path) - return AsyncController(control_socket) + return cls(control_socket) + + +class AsyncController(BaseController): + """ + Connection with Tor's control socket. This is built on top of the + BaseController and provides a more user friendly API for library users. + """ def __init__(self, control_socket: stem.socket.ControlSocket, is_authenticated: bool = False) -> None: self._is_caching_enabled = True

1 0

[stem/master] Return the previous behavior when socket was automatically connected
by atagar＠torproject.org 16 Jul '20

16 Jul '20

commit 74bb5df6edfdb92cf504b86c4d9253e4cc6a5c96 Author: Illia Volochii <illia.volochii(a)gmail.com> Date: Thu Apr 23 22:54:26 2020 +0300 Return the previous behavior when socket was automatically connected --- stem/control.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/stem/control.py b/stem/control.py index bd9e7d30..94b368de 100644 --- a/stem/control.py +++ b/stem/control.py @@ -3884,6 +3884,18 @@ class AsyncController(_ControllerClassMethodMixin, BaseController): class Controller(_ControllerClassMethodMixin, _BaseControllerSocketMixin): + @classmethod + def from_port(cls: Type, address: str = '127.0.0.1', port: Union[int, str] = 'default') -> 'stem.control.Controller': + instance = super().from_port(address, port) + instance.connect() + return instance + + @classmethod + def from_socket_file(cls: Type, path: str = '/var/run/tor/control') -> 'stem.control.Controller': + instance = super().from_socket_file(path) + instance.connect() + return instance + def __init__(self, control_socket: 'stem.socket.ControlSocket', is_authenticated: bool = False) -> None: self._asyncio_loop = asyncio.get_event_loop()

1 0

[stem/master] Optimize adding event listeners during controller initialization
by atagar＠torproject.org 16 Jul '20

16 Jul '20

commit 12e29a554b61076146a4d08d8ace620deaa4a513 Author: Illia Volochii <illia.volochii(a)gmail.com> Date: Thu Apr 23 23:16:19 2020 +0300 Optimize adding event listeners during controller initialization --- stem/control.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/stem/control.py b/stem/control.py index 94b368de..d055058e 100644 --- a/stem/control.py +++ b/stem/control.py @@ -1077,8 +1077,6 @@ class AsyncController(_ControllerClassMethodMixin, BaseController): self.clear_cache() self._notify_status_listeners(State.RESET) - self._asyncio_loop.create_task(self.add_event_listener(_sighup_listener, EventType.SIGNAL)) - def _confchanged_listener(event: stem.response.events.ConfChangedEvent) -> None: if self.is_caching_enabled(): to_cache_changed = dict((k.lower(), v) for k, v in event.changed.items()) @@ -1092,15 +1090,20 @@ class AsyncController(_ControllerClassMethodMixin, BaseController): self._confchanged_cache_invalidation(to_cache) - self._asyncio_loop.create_task(self.add_event_listener(_confchanged_listener, EventType.CONF_CHANGED)) - def _address_changed_listener(event: stem.response.events.StatusEvent) -> None: if event.action in ('EXTERNAL_ADDRESS', 'DNS_USELESS'): self._set_cache({'exit_policy': None}) self._set_cache({'address': None}, 'getinfo') self._last_address_exc = None - self._asyncio_loop.create_task(self.add_event_listener(_address_changed_listener, EventType.STATUS_SERVER)) + async def _add_event_listeners(): + await asyncio.gather( + self.add_event_listener(_sighup_listener, EventType.SIGNAL), + self.add_event_listener(_confchanged_listener, EventType.CONF_CHANGED), + self.add_event_listener(_address_changed_listener, EventType.STATUS_SERVER), + ) + + self._asyncio_loop.create_task(_add_event_listeners()) async def close(self) -> None: self.clear_cache()

1 0

[stem/master] Create a synchronous version of `recv_message`
by atagar＠torproject.org 16 Jul '20

16 Jul '20

commit 1fc0535bf3d423f361755c03ba5ff51c4c91593b Author: Illia Volochii <illia.volochii(a)gmail.com> Date: Sat Apr 25 19:08:07 2020 +0300 Create a synchronous version of `recv_message` --- stem/socket.py | 120 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 120 insertions(+) diff --git a/stem/socket.py b/stem/socket.py index a82c4892..e8ae492b 100644 --- a/stem/socket.py +++ b/stem/socket.py @@ -690,6 +690,126 @@ async def recv_message(reader: asyncio.StreamReader, arrived_at: Optional[float] raise stem.ProtocolError("Unrecognized divider type '%s': %s" % (divider, stem.util.str_tools._to_unicode(line))) +def recv_message_from_bytes_io(reader: asyncio.StreamReader, arrived_at: Optional[float] = None) -> 'stem.response.ControlMessage': + """ + Pulls from a control socket until we either have a complete message or + encounter a problem. + + :param file control_file: file derived from the control socket (see the + socket's makefile() method for more information) + + :returns: :class:`~stem.response.ControlMessage` read from the socket + + :raises: + * :class:`stem.ProtocolError` the content from the socket is malformed + * :class:`stem.SocketClosed` if the socket closes before we receive + a complete message + """ + + parsed_content, raw_content, first_line = None, None, True + + while True: + try: + line = reader.readline() + except AttributeError: + # if the control_file has been closed then we will receive: + # AttributeError: 'NoneType' object has no attribute 'recv' + + log.info(ERROR_MSG % ('SocketClosed', 'socket file has been closed')) + raise stem.SocketClosed('socket file has been closed') + except (OSError, ValueError) as exc: + # when disconnected this errors with... + # + # * ValueError: I/O operation on closed file + # * OSError: [Errno 107] Transport endpoint is not connected + # * OSError: [Errno 9] Bad file descriptor + + log.info(ERROR_MSG % ('SocketClosed', 'received exception "%s"' % exc)) + raise stem.SocketClosed(exc) + + # Parses the tor control lines. These are of the form... + # <status code><divider><content>\r\n + + if not line: + # if the socket is disconnected then the readline() method will provide + # empty content + + log.info(ERROR_MSG % ('SocketClosed', 'empty socket content')) + raise stem.SocketClosed('Received empty socket content.') + elif not MESSAGE_PREFIX.match(line): + log.info(ERROR_MSG % ('ProtocolError', 'malformed status code/divider, "%s"' % log.escape(line))) + raise stem.ProtocolError('Badly formatted reply line: beginning is malformed') + elif not line.endswith(b'\r\n'): + log.info(ERROR_MSG % ('ProtocolError', 'no CRLF linebreak, "%s"' % log.escape(line))) + raise stem.ProtocolError('All lines should end with CRLF') + + status_code, divider, content = line[:3], line[3:4], line[4:-2] # strip CRLF off content + + status_code = stem.util.str_tools._to_unicode(status_code) + divider = stem.util.str_tools._to_unicode(divider) + + # Most controller responses are single lines, in which case we don't need + # so much overhead. + + if first_line: + if divider == ' ': + _log_trace(line) + return stem.response.ControlMessage([(status_code, divider, content)], line, arrived_at = arrived_at) + else: + parsed_content, raw_content, first_line = [], bytearray(), False + + raw_content += line + + if divider == '-': + # mid-reply line, keep pulling for more content + parsed_content.append((status_code, divider, content)) + elif divider == ' ': + # end of the message, return the message + parsed_content.append((status_code, divider, content)) + _log_trace(bytes(raw_content)) + return stem.response.ControlMessage(parsed_content, bytes(raw_content), arrived_at = arrived_at) + elif divider == '+': + # data entry, all of the following lines belong to the content until we + # get a line with just a period + + content_block = bytearray(content) + + while True: + try: + line = reader.readline() + raw_content += line + except socket.error as exc: + log.info(ERROR_MSG % ('SocketClosed', 'received an exception while mid-way through a data reply (exception: "%s", read content: "%s")' % (exc, log.escape(bytes(raw_content))))) + raise stem.SocketClosed(exc) + + if not line.endswith(b'\r\n'): + log.info(ERROR_MSG % ('ProtocolError', 'CRLF linebreaks missing from a data reply, "%s"' % log.escape(bytes(raw_content)))) + raise stem.ProtocolError('All lines should end with CRLF') + elif line == b'.\r\n': + break # data block termination + + line = line[:-2] # strips off the CRLF + + # lines starting with a period are escaped by a second period (as per + # section 2.4 of the control-spec) + + if line.startswith(b'..'): + line = line[1:] + + content_block += b'\n' + line + + # joins the content using a newline rather than CRLF separator (more + # conventional for multi-line string content outside the windows world) + + parsed_content.append((status_code, divider, bytes(content_block))) + else: + # this should never be reached due to the prefix regex, but might as well + # be safe... + + log.warn(ERROR_MSG % ('ProtocolError', "\"%s\" isn't a recognized divider type" % divider)) + raise stem.ProtocolError("Unrecognized divider type '%s': %s" % (divider, stem.util.str_tools._to_unicode(line))) + + def send_formatting(message: str) -> str: """ Performs the formatting expected from sent control messages. For more

1 0

[stem/master] Implement public methods of `AsyncController` in the synchronous wrapper
by atagar＠torproject.org 16 Jul '20

16 Jul '20

commit d58820b705cfb841117f4bce25e95775778a855d Author: Illia Volochii <illia.volochii(a)gmail.com> Date: Thu Apr 23 22:33:58 2020 +0300 Implement public methods of `AsyncController` in the synchronous wrapper --- stem/control.py | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 185 insertions(+) diff --git a/stem/control.py b/stem/control.py index de8e24bb..bd9e7d30 100644 --- a/stem/control.py +++ b/stem/control.py @@ -3900,6 +3900,17 @@ class Controller(_ControllerClassMethodMixin, _BaseControllerSocketMixin): self._asyncio_loop, ).result() + def _execute_async_generator_method(self, method_name: str, *args: Any, **kwargs: Any) -> Any: + async def convert_async_generator(generator): + return iter([d async for d in generator]) + + return asyncio.run_coroutine_threadsafe( + convert_async_generator( + getattr(self._async_controller, method_name)(*args, **kwargs), + ), + self._asyncio_loop, + ).result() + def msg(self, message: str) -> stem.response.ControlMessage: return self._execute_async_method('msg', message) @@ -3909,6 +3920,9 @@ class Controller(_ControllerClassMethodMixin, _BaseControllerSocketMixin): def connect(self) -> None: self._execute_async_method('connect') + def reconnect(self, *args: Any, **kwargs: Any) -> None: + self._execute_async_method('reconnect', *args, **kwargs) + def close(self) -> None: self._execute_async_method('close') self._asyncio_loop.call_soon_threadsafe(self._asyncio_loop.stop) @@ -3925,6 +3939,177 @@ class Controller(_ControllerClassMethodMixin, _BaseControllerSocketMixin): def remove_status_listener(self, callback: Callable[['stem.control.Controller', 'stem.control.State', float], None]) -> bool: self._async_controller.remove_status_listener(callback) + def authenticate(self, *args: Any, **kwargs: Any) -> None: + self._execute_async_method('authenticate', *args, **kwargs) + + def get_info(self, params: Union[str, Sequence[str]], default: Any = UNDEFINED, get_bytes: bool = False) -> Union[str, Dict[str, str]]: + return self._execute_async_method('get_info', params, default, get_bytes) + + def get_version(self, default: Any = UNDEFINED) -> stem.version.Version: + return self._execute_async_method('get_version', default) + + def get_exit_policy(self, default: Any = UNDEFINED) -> stem.exit_policy.ExitPolicy: + return self._execute_async_method('get_exit_policy', default) + + def get_ports(self, listener_type: 'stem.control.Listener', default: Any = UNDEFINED) -> Sequence[int]: + return self._execute_async_method('get_ports', listener_type, default) + + def get_listeners(self, listener_type: 'stem.control.Listener', default: Any = UNDEFINED) -> Sequence[Tuple[str, int]]: + return self._execute_async_method('get_listeners', listener_type, default) + + def get_accounting_stats(self, default: Any = UNDEFINED) -> 'stem.control.AccountingStats': + return self._execute_async_method('get_accounting_stats', default) + + def get_protocolinfo(self, default: Any = UNDEFINED) -> stem.response.protocolinfo.ProtocolInfoResponse: + return self._execute_async_method('get_protocolinfo', default) + + def get_user(self, default: Any = UNDEFINED) -> str: + return self._execute_async_method('get_user', default) + + def get_pid(self, default: Any = UNDEFINED) -> int: + return self._execute_async_method('get_pid', default) + + def get_start_time(self, default: Any = UNDEFINED) -> float: + return self._execute_async_method('get_start_time', default) + + def get_uptime(self, default: Any = UNDEFINED) -> float: + return self._execute_async_method('get_uptime', default) + + def is_user_traffic_allowed(self) -> 'stem.control.UserTrafficAllowed': + return self._execute_async_method('is_user_traffic_allowed') + + def get_microdescriptor(self, relay: Optional[str] = None, default: Any = UNDEFINED) -> stem.descriptor.microdescriptor.Microdescriptor: + return self._execute_async_method('get_microdescriptor', relay, default) + + def get_microdescriptors(self, default: Any = UNDEFINED) -> Iterator[stem.descriptor.microdescriptor.Microdescriptor]: + return self._execute_async_generator_method('get_microdescriptors', default) + + def get_server_descriptor(self, relay: Optional[str] = None, default: Any = UNDEFINED) -> stem.descriptor.server_descriptor.RelayDescriptor: + return self._execute_async_method('get_server_descriptor', relay, default) + + def get_server_descriptors(self, default: Any = UNDEFINED) -> Iterator[stem.descriptor.server_descriptor.RelayDescriptor]: + return self._execute_async_generator_method('get_server_descriptors', default) + + def get_network_status(self, relay: Optional[str] = None, default: Any = UNDEFINED) -> stem.descriptor.router_status_entry.RouterStatusEntryV3: + return self._execute_async_method('get_network_status', relay, default) + + def get_network_statuses(self, default: Any = UNDEFINED) -> Iterator[stem.descriptor.router_status_entry.RouterStatusEntryV3]: + return self._execute_async_generator_method('get_network_statuses', default) + + def get_hidden_service_descriptor(self, address: str, default: Any = UNDEFINED, servers: Optional[Sequence[str]] = None, await_result: bool = True, timeout: Optional[float] = None) -> stem.descriptor.hidden_service.HiddenServiceDescriptorV2: + return self._execute_async_method('get_hidden_service_descriptor', address, default, servers, await_result, timeout) + + def get_conf(self, param: str, default: Any = UNDEFINED, multiple: bool = False) -> Union[str, Sequence[str]]: + return self._execute_async_method('get_conf', param, default, multiple) + + def get_conf_map(self, params: Union[str, Sequence[str]], default: Any = UNDEFINED, multiple: bool = True) -> Dict[str, Union[str, Sequence[str]]]: + return self._execute_async_method('get_conf_map', params, default, multiple) + + def is_set(self, param: str, default: Any = UNDEFINED) -> bool: + return self._execute_async_method('is_set', param, default) + + def set_conf(self, param: str, value: Union[str, Sequence[str]]) -> None: + self._execute_async_method('set_conf', param, value) + + def reset_conf(self, *params: str) -> None: + self._execute_async_method('reset_conf', *params) + + def set_options(self, params: Union[Mapping[str, Union[str, Sequence[str]]], Sequence[Tuple[str, Union[str, Sequence[str]]]]], reset: bool = False) -> None: + self._execute_async_method('set_options', params, reset) + + def get_hidden_service_conf(self, default: Any = UNDEFINED) -> Dict[str, Any]: + return self._execute_async_method('get_hidden_service_conf', default) + + def set_hidden_service_conf(self, conf: Mapping[str, Any]) -> None: + self._execute_async_method('set_hidden_service_conf', conf) + + def create_hidden_service(self, path: str, port: int, target_address: Optional[str] = None, target_port: Optional[int] = None, auth_type: Optional[str] = None, client_names: Optional[Sequence[str]] = None) -> 'stem.control.CreateHiddenServiceOutput': + return self._execute_async_method('create_hidden_service', path, port, target_address, target_port, auth_type, client_names) + + def remove_hidden_service(self, path: str, port: Optional[int] = None) -> bool: + return self._execute_async_method('remove_hidden_service', path, port) + + def list_ephemeral_hidden_services(self, default: Any = UNDEFINED, our_services: bool = True, detached: bool = False) -> Sequence[str]: + return self._execute_async_method('list_ephemeral_hidden_services', default, our_services, detached) + + def create_ephemeral_hidden_service(self, ports: Union[int, Sequence[int], Mapping[int, str]], key_type: str = 'NEW', key_content: str = 'BEST', discard_key: bool = False, detached: bool = False, await_publication: bool = False, timeout: Optional[float] = None, basic_auth: Optional[Mapping[str, str]] = None, max_streams: Optional[int] = None) -> stem.response.add_onion.AddOnionResponse: + return self._execute_async_method('create_ephemeral_hidden_service', ports, key_type, key_content, discard_key, detached, await_publication, timeout, basic_auth, max_streams) + + def remove_ephemeral_hidden_service(self, service_id: str) -> bool: + return self._execute_async_method('remove_ephemeral_hidden_service', service_id) + + def add_event_listener(self, listener: Callable[[stem.response.events.Event], None], *events: 'stem.control.EventType') -> None: + self._execute_async_method('add_event_listener', listener, *events) + + def remove_event_listener(self, listener: Callable[[stem.response.events.Event], None]) -> None: + self._execute_async_method('remove_event_listener', listener) + + def is_caching_enabled(self) -> bool: + return self._async_controller.is_caching_enabled() + + def set_caching(self, enabled: bool) -> None: + self._async_controller.set_caching(enabled) + + def clear_cache(self) -> None: + self._async_controller.clear_cache() + + def load_conf(self, configtext: str) -> None: + self._execute_async_method('load_conf', configtext) + + def save_conf(self, force: bool = False) -> None: + return self._execute_async_method('save_conf', force) + + def is_feature_enabled(self, feature: str) -> bool: + return self._async_controller.is_feature_enabled(feature) + + def enable_feature(self, features: Union[str, Sequence[str]]) -> None: + self._async_controller.enable_feature(features) + + def get_circuit(self, circuit_id: int, default: Any = UNDEFINED) -> stem.response.events.CircuitEvent: + return self._execute_async_method('get_circuit', circuit_id, default) + + def get_circuits(self, default: Any = UNDEFINED) -> List[stem.response.events.CircuitEvent]: + return self._execute_async_method('get_circuits', default) + + def new_circuit(self, path: Union[None, str, Sequence[str]] = None, purpose: str = 'general', await_build: bool = False, timeout: Optional[float] = None) -> str: + return self._execute_async_method('new_circuit', path, purpose, await_build, timeout) + + def extend_circuit(self, circuit_id: str = '0', path: Union[None, str, Sequence[str]] = None, purpose: str = 'general', await_build: bool = False, timeout: Optional[float] = None) -> str: + return self._execute_async_method('extend_circuit', circuit_id, path, purpose, await_build, timeout) + + def repurpose_circuit(self, circuit_id: str, purpose: str) -> None: + self._execute_async_method('repurpose_circuit', circuit_id, purpose) + + def close_circuit(self, circuit_id: str, flag: str = '') -> None: + self._execute_async_method('close_circuit', circuit_id, flag) + + def get_streams(self, default: Any = UNDEFINED) -> List[stem.response.events.StreamEvent]: + return self._execute_async_method('get_streams', default) + + def attach_stream(self, stream_id: str, circuit_id: str, exiting_hop: Optional[int] = None) -> None: + self._execute_async_method('attach_stream', stream_id, circuit_id, exiting_hop) + + def close_stream(self, stream_id: str, reason: stem.RelayEndReason = stem.RelayEndReason.MISC, flag: str = '') -> None: + self._execute_async_method('close_stream', stream_id, reason, flag) + + def signal(self, signal: stem.Signal) -> None: + self._execute_async_method('signal', signal) + + def is_newnym_available(self) -> bool: + return self._async_controller.is_newnym_available() + + def get_newnym_wait(self) -> float: + return self._async_controller.get_newnym_wait() + + def get_effective_rate(self, default: Any = UNDEFINED, burst: bool = False) -> int: + return self._execute_async_method('get_effective_rate', default, burst) + + def map_address(self, mapping: Mapping[str, str]) -> Dict[str, str]: + return self._execute_async_method('map_address', mapping) + + def drop_guards(self) -> None: + self._execute_async_method('drop_guards') + def __enter__(self) -> 'stem.control.Controller': return self

1 0

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits July 2020