示例#1
0
文件: har.py 项目: optionalg/redbot
    def add_entry(self, resource: HttpResource, page_ref: int=None) -> None:
        entry = {
            "startedDateTime": isoformat(resource.request.start_time),
            "time": int((resource.response.complete_time - resource.request.start_time) * 1000),
            "_red_messages": self.format_notes(resource)
        }
        if page_ref:
            entry['pageref'] = "page%s" % page_ref

        request = {
            'method': resource.request.method,
            'url': resource.request.uri,
            'httpVersion': "HTTP/1.1",
            'cookies': [],
            'headers': self.format_headers(resource.request.headers),
            'queryString': [],
            'headersSize': -1,
            'bodySize': -1,
        }

        response = {
            'status': resource.response.status_code,
            'statusText': resource.response.status_phrase,
            'httpVersion': "HTTP/%s" % resource.response.version,
            'cookies': [],
            'headers': self.format_headers(resource.response.headers),
            'content': {
                'size': resource.response.decoded_len,
                'compression': resource.response.decoded_len - resource.response.payload_len,
                'mimeType': (get_header(resource.response.headers, 'content-type') or [""])[0],
            },
            'redirectURL': (
                get_header(resource.response.headers, 'location') or [""])[0],
            'headersSize': resource.response.header_length,
            'bodySize': resource.response.payload_len,
        }

        cache = {}  # type: Dict[None, None]
        timings = {
            'dns': -1,
            'connect': -1,
            'blocked': 0,
            'send': 0,
            'wait': int((resource.response.start_time - resource.request.start_time) * 1000),
            'receive': int((resource.response.complete_time - resource.response.start_time) * 1000),
        }

        entry.update({
            'request': request,
            'response': response,
            'cache': cache,
            'timings': timings,
        })
        self.har['log']['entries'].append(entry) # type: ignore
示例#2
0
文件: har.py 项目: faulkner/redbot
    def add_entry(self, red, page_ref=None):
        entry = {
            "startedDateTime": isoformat(red.req_ts),
            "time": int((red.res_done_ts - red.req_ts) * 1000),
            "_red_messages": self.format_messages(red)
        }
        if page_ref:
            entry['pageref'] = "page%s" % page_ref
        
        request = {
            'method': red.method,
            'url': red.uri,
            'httpVersion': "HTTP/1.1",
            'cookies': [],
            'headers': self.format_headers(red.req_hdrs),
            'queryString': [],
            'headersSize': -1,
            'bodySize': -1,
        }
        
        response = {
            'status': red.res_status,
            'statusText': red.res_phrase,
            'httpVersion': "HTTP/%s" % red.res_version, 
            'cookies': [],
            'headers': self.format_headers(red.res_hdrs),
            'content': {
                'size': red.res_body_decode_len,
                'compression': red.res_body_decode_len - red.res_body_len,
                'mimeType': (get_header(red.res_hdrs, 'content-type') or [""])[0],
            },
            'redirectURL': (get_header(red.res_hdrs, 'location') or [""])[0],
            'headersSize': red.header_length,
            'bodySize': red.res_body_len,
        }
        
        cache = {}
        timings = {
            'dns': -1,
            'connect': -1,
            'blocked': 0,
            'send': 0, 
            'wait': int((red.res_ts - red.req_ts) * 1000),
            'receive': int((red.res_done_ts - red.res_ts) * 1000),
        }

        entry.update({
            'request': request,
            'response': response,
            'cache': cache,
            'timings': timings,
        })
        self.har['log']['entries'].append(entry)
示例#3
0
 def status100(self):        # Continue
     if self.request and not "100-continue" in get_header(
         self.request.headers, 'expect'):
         self.add_note('', rs.UNEXPECTED_CONTINUE)
示例#4
0
    def __init__(
        self,
        config: SectionProxy,
        method: str,
        query_string: bytes,
        req_headers: RawHeaderListType,
        req_body: bytes,
        exchange: HttpResponseExchange,
        error_log: Callable[[str], int] = sys.stderr.write,
    ) -> None:
        self.config = config  # type: SectionProxy
        self.query_string = parse_qs(
            query_string.decode(self.config["charset"], "replace"))
        self.req_headers = req_headers
        self.req_body = req_body
        self.body_args = {}
        self.exchange = exchange
        self.error_log = error_log  # function to log errors to

        # query processing
        self.test_uri = self.query_string.get("uri", [""])[0]
        self.test_id = self.query_string.get("id", [None])[0]
        self.req_hdrs = [
            tuple(h.split(":", 1))  # type: ignore
            for h in self.query_string.get("req_hdr", []) if h.find(":") > 0
        ]  # type: StrHeaderListType
        self.format = self.query_string.get("format", ["html"])[0]
        self.descend = "descend" in self.query_string
        self.check_name = None  # type: str
        if not self.descend:
            self.check_name = self.query_string.get("check_name", [None])[0]

        self.charset_bytes = self.config["charset"].encode("ascii")

        self.save_path = None  # type: str
        self.timeout = None  # type: Any

        self.start = time.time()

        if method == "POST":
            req_ct = get_header(self.req_headers, b"content-type")
            if req_ct and req_ct[-1].lower(
            ) == b"application/x-www-form-urlencoded":
                self.body_args = parse_qs(
                    req_body.decode(self.config["charset"], "replace"))

            if ("save" in self.query_string
                    and self.config.get("save_dir", "") and self.test_id):
                extend_saved_test(self)
            elif "slack" in self.query_string:
                slack_run(self)
            elif "client_error" in self.query_string:
                self.dump_client_error()
            elif self.test_uri:
                self.run_test()
            else:
                self.show_default()
        elif method in ["GET", "HEAD"]:
            if self.test_id:
                load_saved_test(self)
            elif "code" in self.query_string:
                slack_auth(self)
            else:
                self.show_default()
        else:
            self.error_response(
                find_formatter("html")(self.config, None, self.output),
                b"405",
                b"Method Not Allowed",
                "Method Not Allowed",
            )