def request_callable(request): request.connection.write_headers( ResponseStartLine("HTTP/1.1", 200, "OK"), HTTPHeaders({"Content-Length": "2"}), ) request.connection.write(b"OK") request.connection.finish()
def finish(self): response_body = b"OK" self.connection.write_headers( ResponseStartLine("HTTP/1.1", 200, "OK"), HTTPHeaders({"Content-Length": str(len(response_body))})) self.connection.write(response_body) self.connection.finish()
def test_400_parse_error(self): proxy = mock.Mock() plugin = JSONRPC(proxy, {}) connection = mock.Mock(spec=[]) connection.write_headers = mock.MagicMock() connection.finish = mock.MagicMock() request = HTTPServerRequest(method='PUT', uri='/', version='HTTP/1.1', headers={ 'X-Cocaine-JSON-RPC': 'Enable', }, connection=connection, body='{', host='localhost') request.logger = NULLLOGGER yield plugin.process(request) connection.write_headers.assert_called_with( ResponseStartLine(version='HTTP/1.1', code=400, reason='Bad JSON-RPC request'), mock.ANY, '{"message": "Parse error: Invalid JSON was received by the server.", "code": -32700}' )
def _start_request(self, pseudo_headers, headers): if "connection" in headers: raise ConnectionError(constants.ErrorCode.PROTOCOL_ERROR, "connection header should not be present") if "te" in headers and headers["te"] != "trailers": raise StreamError(self.stream_id, constants.ErrorCode.PROTOCOL_ERROR) if self.conn.is_client: status = int(pseudo_headers[':status']) start_line = ResponseStartLine('HTTP/2.0', status, responses.get(status, '')) else: for k in (':method', ':scheme', ':path'): if k not in pseudo_headers: raise StreamError(self.stream_id, constants.ErrorCode.PROTOCOL_ERROR) start_line = RequestStartLine(pseudo_headers[':method'], pseudo_headers[':path'], 'HTTP/2.0') self._request_start_line = start_line if (self.conn.is_client and (self._request_start_line.method == 'HEAD' or start_line.code == 304)): self._incoming_content_remaining = 0 elif "content-length" in headers: self._incoming_content_remaining = int(headers["content-length"]) if not self.conn.is_client or status >= 200: self._phase = constants.HTTPPhase.BODY self._delegate_started = True self.delegate.headers_received(start_line, headers)
def test_400_invalid_request_error(self): proxy = mock.Mock() plugin = JSONRPC(proxy, {}) connection = mock.Mock(spec=[]) connection.write_headers = mock.MagicMock() connection.finish = mock.MagicMock() request = HTTPServerRequest( method='PUT', uri='/', version='HTTP/1.1', headers={ 'X-Cocaine-JSON-RPC': 'Enable', }, connection=connection, body='{"jsonrpc": 2.0, "method": "method", "params_": [], "id": 1}', host='localhost') request.logger = NULLLOGGER yield plugin.process(request) connection.write_headers.assert_called_with( ResponseStartLine(version='HTTP/1.1', code=400, reason='Bad JSON-RPC request'), mock.ANY, '{"message": "The JSON sent is not a valid Request object.", "code": -32600}' )
def finish(self): self.connection.write_headers( ResponseStartLine("HTTP/1.1", 200, "OK"), HTTPHeaders({"Content-Length": "2"}), b"OK", ) self.connection.finish()
def finish(self): response_body = utf8(json_encode(self.chunk_lengths)) self.connection.write_headers( ResponseStartLine('HTTP/1.1', 200, 'OK'), HTTPHeaders({'Content-Length': str(len(response_body))})) self.connection.write(response_body) self.connection.finish()
def finish(self): response_body = utf8(json_encode(self.chunk_lengths)) self.connection.write_headers( ResponseStartLine("HTTP/1.1", 200, "OK"), HTTPHeaders({"Content-Length": str(len(response_body))}), ) self.connection.write(response_body) self.connection.finish()
def respond_100(self, request): self.http1 = request.version.startswith('HTTP/1.') if not self.http1: request.connection.write_headers(ResponseStartLine('', 200, 'OK'), HTTPHeaders()) request.connection.finish() return self.request = request self.request.connection.stream.write(b"HTTP/1.1 100 CONTINUE\r\n\r\n", self.respond_200)
def respondToConnection(self, request, response_json): headers = { "Access-Control-Allow-Origin": request.headers["Origin"], # "Content-Type":"application/json", "Content-Length": "%d" % len(response_json), } request.connection.write_headers( ResponseStartLine(request.version, 200, 'OK'), HTTPHeaders(**headers)) request.connection.write(response_json)
def respond_100(self, request): self.http1 = request.version.startswith("HTTP/1.") if not self.http1: request.connection.write_headers(ResponseStartLine("", 200, "OK"), HTTPHeaders()) request.connection.finish() return self.request = request fut = self.request.connection.stream.write( b"HTTP/1.1 100 CONTINUE\r\n\r\n") fut.add_done_callback(self.respond_200)
def respondWithJSON(self, request, response_json): headers = { "Content-Type": "application/json", "Content-Length": "%d" % len(response_json) } if "Origin" in request.headers: origin = request.headers["Origin"] headers["Access-Control-Allow-Origin"] = origin request.connection.write_headers( ResponseStartLine(request.version, 200, 'OK'), HTTPHeaders(**headers)) request.connection.write(response_json)
def handle_request(request): self.http1 = request.version.startswith("HTTP/1.") if not self.http1: # This test will be skipped if we're using HTTP/2, # so just close it out cleanly using the modern interface. request.connection.write_headers( ResponseStartLine("", 200, "OK"), HTTPHeaders()) request.connection.finish() return message = b"Hello world" request.connection.write( utf8("HTTP/1.1 200 OK\r\n" "Content-Length: %d\r\n\r\n" % len(message))) request.connection.write(message) request.connection.finish()
def respond_204(self, request): self.http1 = request.version.startswith('HTTP/1.') if not self.http1: # Close the request cleanly in HTTP/2; it will be skipped anyway. request.connection.write_headers(ResponseStartLine('', 200, 'OK'), HTTPHeaders()) request.connection.finish() return # A 204 response never has a body, even if doesn't have a content-length # (which would otherwise mean read-until-close). Tornado always # sends a content-length, so we simulate here a server that sends # no content length and does not close the connection. # # Tests of a 204 response with a Content-Length header are included # in SimpleHTTPClientTestMixin. stream = request.connection.detach() stream.write(b"HTTP/1.1 204 No content\r\n\r\n") stream.close()
def handle_http_connection(self, conn): # Read the trailing HTTP request and process it with protocol_switcher. # We can't rely on ioloop to trigger read because it has been already # triggered for SSL handshake. addr, port = conn.stream.socket.getsockname() try: # This is not blocking. Just read available bytes. payload = conn.stream.socket.recv(1024) except Exception: # Exception includes EWOULDBLOCK, when no bytes are available. In # this case just skip. payload = "" else: logger.debug("Received %r", payload[:128]) # Simulate conn._read_message side effect. This is required by # HTTP1Connection.write_headers() conn._request_start_line = parse_request_start_line('GET / HTTP/1.1') conn._request_headers = HTTPHeaders() try: start_line, headers = parse_http_headers(payload) conn._request_start_line = start_line request = HTTPRequest( connection=conn, headers=headers, start_line=start_line, ) request.config = self.request_callback.config response = protocol_switcher(request) except Exception as e: logger.error("Failed to switch to HTTPS: %s", e) response = HTTPResponse( request=object(), code=500, headers=HTTPHeaders({'Content-Length': '0'}), effective_url='https://useless_effective_url') yield conn.write_headers( start_line=ResponseStartLine( 'HTTP/1.1', response.code, response.reason, ), headers=response.headers, )
def __call__(self, request): # decode request variables into a dictionary #request_dict = self.requestAsDict(request) # compose JSON response string from default location response_json = '{"locations":%s' % self.tool.locations_js loc_name = self.tool.default_location response_json = '%s,"selected":"%s"}' % (response_json, loc_name) headers = { "Content-Type": "application/json", "Content-Length": "%d" % len(response_json) } if "Origin" in request.headers: origin = request.headers["Origin"] headers["Access-Control-Allow-Origin"] = origin request.connection.write_headers( ResponseStartLine(request.version, 200, 'OK'), HTTPHeaders(**headers)) request.connection.write(response_json)
def _check_header_length(self): if (sum(len(f.data) for f in self._header_frames) > self.conn.params.max_header_size): if self.conn.is_client: # TODO: Need tests for client side of headers-too-large. # What's the best way to send an error? self.delegate.on_connection_close() else: # write_headers needs a start line so it can tell # whether this is a HEAD or not. If we're rejecting # the headers we can't know so just make something up. # Note that this means the error response body MUST be # zero bytes so it doesn't matter whether the client # sent a HEAD or a GET. self._request_start_line = RequestStartLine( 'GET', '/', 'HTTP/2.0') start_line = ResponseStartLine('HTTP/2.0', 431, 'Headers too large') self.write_headers(start_line, HTTPHeaders()) self.finish() return
def respond_204(self, request): self.http1 = request.version.startswith("HTTP/1.") if not self.http1: # Close the request cleanly in HTTP/2; it will be skipped anyway. request.connection.write_headers(ResponseStartLine("", 200, "OK"), HTTPHeaders()) request.connection.finish() return # A 204 response never has a body, even if doesn't have a content-length # (which would otherwise mean read-until-close). We simulate here a # server that sends no content length and does not close the connection. # # Tests of a 204 response with no Content-Length header are included # in SimpleHTTPClientTestMixin. stream = request.connection.detach() stream.write(b"HTTP/1.1 204 No content\r\n") if request.arguments.get_products("error", [False])[-1]: stream.write(b"Content-Length: 5\r\n") else: stream.write(b"Content-Length: 0\r\n") stream.write(b"\r\n") stream.close()
def respondToOptionsRequest(self, request): allowed = list(ALLOWED_HEADERS) requested = request.headers['Access-Control-Request-Headers'] if ',' in requested: for header in requested.split(','): if not header in allowed: allowed.append(header) else: if not requested in allowed: allowed.append(requested) headers = { "Access-Control-Allow-Origin": request.headers["Origin"], "Access-Control-Allow-Credentials": "true", 'Access-Control-Allow-Headers': ','.join(allowed), 'Access-Control-Max-Age': '1728000', "Access-Control-Allow-Methods": "GET,POST,OPTIONS", "Content-Length": '0', "Content-Type": "text/html; charset=UTF-8" } request.connection.write_headers( ResponseStartLine(request.version, 204, 'OK'), HTTPHeaders(**headers)) request.connection.write('') request.connection.finish()
async def handle(): if request.method != 'POST': await request.connection.write_headers( ResponseStartLine('1.1', 400, 'Bad Request'), HTTPHeaders(HEADERS_ERROR)) await request.connection.write('Bad request.'.encode()) request.connection.finish() return bot = self.__bots.get(request.path) if not bot: logger.warning("Bot not found for request `%s`.", request.path) await request.connection.write_headers( ResponseStartLine('1.1', 404, 'Not Found'), HTTPHeaders(HEADERS_ERROR)) await request.connection.write('Not found.'.encode()) request.connection.finish() return try: parsed = Update.parse(json.loads(request.body)) except Exception: logger.exception("Got exception while parsing update:") await request.connection.write_headers( ResponseStartLine('1.1', 500, 'Internal Server Error'), HTTPHeaders(HEADERS_ERROR)) await request.connection.write('Server error.'.encode()) request.connection.finish() return if bot not in self.__tasks: self.__tasks[bot] = set() task = asyncio.create_task(bot.process(self, parsed)) self.__tasks[bot].add(task) try: response: Request = await task except Exception: logger.exception("Got exception while processing update:") await request.connection.write_headers( ResponseStartLine('1.1', 500, 'Internal Server Error'), HTTPHeaders(HEADERS_ERROR)) await request.connection.write('Server error.'.encode()) request.connection.finish() return await request.connection.write_headers( ResponseStartLine('1.1', 200, 'Ok'), HTTPHeaders(HEADERS)) if response: data = json.dumps(response.render(with_method=True)) await request.connection.write(data.encode()) request.connection.finish() self.__tasks[bot] = { t for t in self.__tasks[bot] if not t.done() }
def get(self, tail): if tail == '/stats': allstats = {} allstats["Start Time"] = g_stats_handler.get_start_time() allstats["Up Time"] = g_stats_handler.get_up_time() allstats[ "Bytes Transmitted (MB)"] = g_stats_handler.get_bytes_transmitted( ) allstats[ "Number of Get Requests Handled"] = g_stats_handler.requests_handled( ) self.render("templates/stats.html", stats=allstats, counters=g_stats_handler.get_counters()) return g_stats_handler.set_requests_handled() hash_key = self.get_hash_params(self.request) # save the instance of the application handler that is handing this request. if hash_key not in self.incoming_conns: self.incoming_conns[hash_key] = self.request.connection logging.info("save connection object against key %s" % hash_key) if not (self.check_for_range_params()): self.send_error(416, message="Range not satisfiable") self.finish() return response = yield self.send_request_to_origin(self.request) logging.info('got response with code %s' % response.code) path = self.request.path remote_ip = self.request.remote_ip hash_key = self.get_hash_params(response.request, path, remote_ip) if hash_key not in self.incoming_conns: logging.error( "No incoming connection exists for remote_ip %s and path %s" % (remote_ip, path)) else: in_conn = self.incoming_conns[hash_key] logging.info( "Found HTTPConnection object for remote_ip %s and path %s" % (remote_ip, path)) g_stats_handler.set_response_type_counter(str(response.code)) if response.code in [200, 304, 206]: content_length = response.headers.get('Content-Length', None) accept_ranges = response.headers.get('Accept-Ranges', None) logging.info("Origin server at %s returned response code %s " % (path, response.code)) logging.info("Got content_length %s with accept_ranges %s" % (content_length, accept_ranges)) g_stats_handler.set_bytes_transmitted(content_length) if response.code == 206: logging.info("Received Content-Range %s for Content-Type %s " % (response.headers.get('Content-Range', None), response.headers.get('Content-Type', None))) resource = self.request.path.split("/")[-1] resource_details = self.resource_cache.get(resource, None) if resource_details is None: self.resource_cache[resource] = { "path": path, "content-length": content_length } # send accept ranges back to the client start_line = ResponseStartLine("HTTP/1.1", str(response.code), response.reason) in_conn.write_headers(start_line, response.headers) in_conn.write(response.body) elif response.code == 416: logging.info("Origin server at %s returned response code %s " % (path, response.code)) start_line = ResponseStartLine("HTTP/1.1", str(response.code), response.error.message) in_conn.write_headers(start_line, response.headers) else: logging.error( "Origin server at %s returned error code %s with message %s" % (path, response.code, response.error.message)) start_line = ResponseStartLine("HTTP/1.1", str(response.code), response.error.message) in_conn.write_headers(start_line, response.headers) in_conn.finish()