Python trio.run() Examples

def get_sign(self, token, query):
        '''使用拼装参数签名
        post https://api.appsign.vip:2688/sign -->
        {
            "token":"TOKEN",
            "query":"通过参数生成的加签字符串"
        }
        >>> data, res = trio.run(SignUtil().get_sign, 'aaa', {"aaa":"aaa"})
        >>> print(res)
        {'success': False, 'error': 'token is error'}
        '''
        assert isinstance(query, dict)
        url = f"{_API}/sign"
        resp = await self.s.post(url, json={"token": token, "query": params2str(query)}, verify=False)
        logging.debug(f"post response from {url} is {resp} with body: {trim(resp.text)}")
        return resp.json().get('data', {}), resp.json() 

def monitor(options=None):
    import trio
    from burpui_monitor.engines.monitor import MonitorPool
    from burpui_monitor.utils import lookup_file

    if not options:
        options = parse_args(name='bui-monitor')

    conf = ['buimonitor.cfg', 'buimonitor.sample.cfg']
    if options.config:
        conf = lookup_file(options.config, guess=False)
    else:
        conf = lookup_file(conf)
    check_config(conf)

    monitor = MonitorPool(conf, options.log, options.logfile)
    trio.run(monitor.run) 

def restore_files(self, name=None, backup=None, files=None, strip=None,
                      archive='zip', password=None, agent=None):
        return trio.run(self._async_restore_files, name, backup, files, strip, archive, password, agent)

    # Same as in Burp1 backend

    # def read_conf_cli(self, agent=None):

    # def read_conf_srv(self, agent=None):

    # def store_conf_cli(self, data, agent=None):

    # def store_conf_srv(self, data, agent=None):

    # def get_parser_attr(self, attr=None, agent=None):


# Make every "Burp" method async 

def restore_files(self, name=None, backup=None, files=None, strip=None,
                      archive='zip', password=None, agent=None):
        return trio.run(self._async_restore_files, name, backup, files, strip, archive, password, agent)

    # Same as in Burp1 backend

    # def read_conf_cli(self, agent=None):

    # def read_conf_srv(self, agent=None):

    # def store_conf_cli(self, data, agent=None):

    # def store_conf_srv(self, data, agent=None):

    # def get_parser_attr(self, attr=None, agent=None):


# Make every "Burp" method async 

def agent(options=None):
    import trio
    from burpui_agent.engines.agent import BUIAgent as Agent
    from burpui_agent.utils import lookup_file
    from burpui_agent._compat import patch_json

    patch_json()

    if not options:
        options = parse_args(name='bui-agent')

    conf = ['buiagent.cfg', 'buiagent.sample.cfg']
    if options.config:
        conf = lookup_file(options.config, guess=False)
    else:
        conf = lookup_file(conf)
    check_config(conf)

    agent = Agent(conf, options.log, options.logfile)
    trio.run(agent.run) 

def test_sans_io_exception():
    class BrokenSender(AsyncHTTPSender):
        async def send(self, request, **config):
            raise ValueError("Broken")

        async def __aexit__(self, exc_type, exc_value, traceback):
            """Raise any exception triggered within the runtime context."""
            return None

    pipeline = AsyncPipeline([SansIOHTTPPolicy()], BrokenSender())

    req = ClientRequest('GET', '/')
    with pytest.raises(ValueError):
        await pipeline.run(req)

    class SwapExec(SansIOHTTPPolicy):
        def on_exception(self, requests, **kwargs):
            exc_type, exc_value, exc_traceback = sys.exc_info()
            raise NotImplementedError(exc_value)

    pipeline = AsyncPipeline([SwapExec()], BrokenSender())
    with pytest.raises(NotImplementedError):
        await pipeline.run(req) 

def monitor(options=None):
    import trio
    from burpui.engines.monitor import MonitorPool
    from burpui.utils import lookup_file

    if not options:
        options, _ = parse_args(mode=False, name='bui-agent')

    conf = ['buimonitor.cfg', 'buimonitor.sample.cfg']
    if options.config:
        conf = lookup_file(options.config, guess=False)
    else:
        conf = lookup_file(conf)
    check_config(conf)

    monitor = MonitorPool(conf, options.log, options.logfile)
    trio.run(monitor.run) 

def agent(options=None):
    import trio
    from burpui.engines.agent import BUIAgent as Agent
    from burpui.utils import lookup_file

    if not options:
        options, _ = parse_args(mode=False, name='bui-agent')

    conf = ['buiagent.cfg', 'buiagent.sample.cfg']
    if options.config:
        conf = lookup_file(options.config, guess=False)
    else:
        conf = lookup_file(conf)
    check_config(conf)

    agent = Agent(conf, options.log, options.logfile)
    trio.run(agent.run) 

def restore_files(self, name=None, backup=None, files=None, strip=None,
                      archive='zip', password=None, agent=None):
        return trio.run(self._async_restore_files, name, backup, files, strip, archive, password, agent)

    # Same as in Burp1 backend

    # def read_conf_cli(self, agent=None):

    # def read_conf_srv(self, agent=None):

    # def store_conf_cli(self, data, agent=None):

    # def store_conf_srv(self, data, agent=None):

    # def get_parser_attr(self, attr=None, agent=None):


# Make every "Burp" method async 

def server_version(self):
        return trio.run(self.get_server_version) 

def test_conf_async_trio_requests():

    async def do():
        conf = Configuration("http://bing.com/")
        request = ClientRequest("GET", "http://bing.com/")
        policies = [
            UserAgentPolicy("myusergant")
        ]
        async with AsyncPipeline(policies, AsyncPipelineRequestsHTTPSender(AsyncTrioRequestsHTTPSender(conf))) as pipeline:
            return await pipeline.run(request)

    response = trio.run(do)
    assert response.http_response.status_code == 200 

def test_basic_aiohttp():

    request = ClientRequest("GET", "http://bing.com")
    policies = [
        UserAgentPolicy("myusergant")
    ]
    async with AsyncPipeline(policies) as pipeline:
        response = await pipeline.run(request)

    assert pipeline._sender.driver._session.closed
    assert response.http_response.status_code == 200 

def test_basic_async_requests():

    request = ClientRequest("GET", "http://bing.com")
    policies = [
        UserAgentPolicy("myusergant")
    ]
    async with AsyncPipeline(policies, AsyncPipelineRequestsHTTPSender()) as pipeline:
        response = await pipeline.run(request)

    assert response.http_response.status_code == 200 

def get_counters(self, name=None, agent=None):
        """See :func:`burpui.misc.backend.interface.BUIbackend.get_counters`"""
        return trio.run(self._async_get_counters, name) 

def test_conf_async_requests():

    conf = Configuration("http://bing.com/")
    request = ClientRequest("GET", "http://bing.com/")
    policies = [
        UserAgentPolicy("myusergant")
    ]
    async with AsyncPipeline(policies, AsyncPipelineRequestsHTTPSender(AsyncRequestsHTTPSender(conf))) as pipeline:
        response = await pipeline.run(request)

    assert response.http_response.status_code == 200 

def get_clients_report(self, clients, agent=None):
        """See :func:`burpui.misc.backend.interface.BUIbackend.get_clients_report`"""
        return trio.run(self._async_get_clients_report, clients) 

def get_client(self, name=None, agent=None):
        """See :func:`burpui.misc.backend.interface.BUIbackend.get_client`"""
        return trio.run(self._async_get_client, name) 

def _parse_backup_log(self, number, client):
        """The :func:`burpui.misc.backend.burp2.Burp._parse_backup_log`
        function helps you determine if the backup is protocol 2 or 1 and various
        useful details.

        :param number: Backup number to work on
        :type number: int

        :param client: Client name to work on
        :type client: str

        :returns: a dict with some useful details
        """
        return trio.run(self._async_parse_backup_log, number, client) 

def get_token(self):
        '''获取Token: 有效期60分钟
        get https://api.appsign.vip:2688/token/douyin -> 
        {
            "token":"5826aa5b56614ea798ca42d767170e74",
            "success":true
        }
        >>> token = trio.run(SignUtil().get_token) # doctest: +ELLIPSIS
        >>> print(len(token))
        32
        '''
        url = f"{_API}/token/douyin/version/{self.version}" if self.version else f"{_API}/token/douyin"
        resp = await self.s.get(url, verify=False)
        logging.debug(f"get response from {url} is {resp} with body: {trim(resp.text)}")
        return resp.json().get('token', '') 

def status(self, query='c:\n', timeout=None, cache=True, agent=None):
        """See :func:`burpui.misc.backend.interface.BUIbackend.status`"""
        return trio.run(self._async_status, query, timeout, cache) 

def get_server_version(self, agent=None):
        if self._server_version is None:
            try:
                self._server_version = trio.run(self._async_request, 'server_version')
            except BUIserverException:
                return ''
        return self._server_version or '' 

def get_client_version(self, agent=None):
        if self._client_version is None:
            try:
                self._client_version = trio.run(self._async_request, 'client_version')
            except BUIserverException:
                return ''
        return self._client_version or '' 

def statistics(self, agent=None):
        return json.loads(trio.run(self._async_request, 'statistics')) 

def batch_list_supported(self):
        if self._batch_list_supported is None:
            self._batch_list_supported = json.loads(trio.run(self._async_request, 'batch_list_supported'))
        return self._batch_list_supported 

def server_version(self):
        return trio.run(self.get_server_version) 

def client_version(self):
        return trio.run(self.get_client_version) 

def get_client_labels(self, client=None, agent=None):
        """See
        :func:`burpui.misc.backend.interface.BUIbackend.get_client_labels`
        """
        return trio.run(self._async_get_client_labels, client) 

def is_backup_deletable(self, name=None, backup=None, agent=None):
        """See
        :func:`burpui.misc.backend.interface.BUIbackend.is_backup_deletable`
        """
        return trio.run(self._async_is_backup_deletable, name, backup) 

def get_client_filtered(self, name=None, limit=-1, page=None, start=None, end=None, agent=None):
        """See :func:`burpui.misc.backend.interface.BUIbackend.get_client_filtered`"""
        return trio.run(self._async_get_client_filtered, name, limit, page, start, end) 

def _get_last_backup(self, name, working=True):
        """Return the last backup of a given client

        :param name: Name of the client
        :type name: str

        :param working: Also return uncomplete backups
        :type working: bool

        :returns: The last backup
        """
        return trio.run(self._async_get_last_backup, name, working)