+++ /dev/null
-#!/usr/bin/env python
-
-# Copyright 2012 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# Modified by Linus Nielsen Feltzing for inclusion in the libcurl test
-# framework
-#
-try:
- import socketserver
-except:
- import SocketServer as socketserver
-import argparse
-import re
-import select
-import socket
-import time
-import pprint
-import os
-
-INFO_MESSAGE = '''
-This is a test server to test the libcurl pipelining functionality.
-It is a modified version if Google's HTTP pipelining test server. More
-information can be found here:
-
-https://dev.chromium.org/developers/design-documents/network-stack/http-pipelining
-
-Source code can be found here:
-
-https://code.google.com/archive/p/http-pipelining-test/
-'''
-MAX_REQUEST_SIZE = 1024 # bytes
-MIN_POLL_TIME = 0.01 # seconds. Minimum time to poll, in order to prevent
- # excessive looping because Python refuses to poll for
- # small timeouts.
-SEND_BUFFER_TIME = 0.5 # seconds
-TIMEOUT = 30 # seconds
-
-
-class Error(Exception):
- pass
-
-
-class RequestTooLargeError(Error):
- pass
-
-
-class ServeIndexError(Error):
- pass
-
-
-class UnexpectedMethodError(Error):
- pass
-
-
-class RequestParser(object):
- """Parses an input buffer looking for HTTP GET requests."""
-
- global logfile
-
- LOOKING_FOR_GET = 1
- READING_HEADERS = 2
-
- HEADER_RE = re.compile('([^:]+):(.*)\n')
- REQUEST_RE = re.compile('([^ ]+) ([^ ]+) HTTP/(\d+)\.(\d+)\n')
-
- def __init__(self):
- """Initializer."""
- self._buffer = ""
- self._pending_headers = {}
- self._pending_request = ""
- self._state = self.LOOKING_FOR_GET
- self._were_all_requests_http_1_1 = True
- self._valid_requests = []
-
- def ParseAdditionalData(self, data):
- """Finds HTTP requests in |data|.
-
- Args:
- data: (String) Newly received input data from the socket.
-
- Returns:
- (List of Tuples)
- (String) The request path.
- (Map of String to String) The header name and value.
-
- Raises:
- RequestTooLargeError: If the request exceeds MAX_REQUEST_SIZE.
- UnexpectedMethodError: On a non-GET method.
- Error: On a programming error.
- """
- logfile = open('log/server.input', 'a')
- logfile.write(data)
- logfile.close()
- self._buffer += data.replace('\r', '')
- should_continue_parsing = True
- while should_continue_parsing:
- if self._state == self.LOOKING_FOR_GET:
- should_continue_parsing = self._DoLookForGet()
- elif self._state == self.READING_HEADERS:
- should_continue_parsing = self._DoReadHeader()
- else:
- raise Error('Unexpected state: ' + self._state)
- if len(self._buffer) > MAX_REQUEST_SIZE:
- raise RequestTooLargeError(
- 'Request is at least %d bytes' % len(self._buffer))
- valid_requests = self._valid_requests
- self._valid_requests = []
- return valid_requests
-
- @property
- def were_all_requests_http_1_1(self):
- return self._were_all_requests_http_1_1
-
- def _DoLookForGet(self):
- """Tries to parse an HTTTP request line.
-
- Returns:
- (Boolean) True if a request was found.
-
- Raises:
- UnexpectedMethodError: On a non-GET method.
- """
- m = self.REQUEST_RE.match(self._buffer)
- if not m:
- return False
- method, path, http_major, http_minor = m.groups()
-
- if method != 'GET':
- raise UnexpectedMethodError('Unexpected method: ' + method)
- if path in ['/', '/index.htm', '/index.html']:
- raise ServeIndexError()
-
- if http_major != '1' or http_minor != '1':
- self._were_all_requests_http_1_1 = False
-
-# print method, path
-
- self._pending_request = path
- self._buffer = self._buffer[m.end():]
- self._state = self.READING_HEADERS
- return True
-
- def _DoReadHeader(self):
- """Tries to parse a HTTP header.
-
- Returns:
- (Boolean) True if it found the end of the request or a HTTP header.
- """
- if self._buffer.startswith('\n'):
- self._buffer = self._buffer[1:]
- self._state = self.LOOKING_FOR_GET
- self._valid_requests.append((self._pending_request,
- self._pending_headers))
- self._pending_headers = {}
- self._pending_request = ""
- return True
-
- m = self.HEADER_RE.match(self._buffer)
- if not m:
- return False
-
- header = m.group(1).lower()
- value = m.group(2).strip().lower()
- if header not in self._pending_headers:
- self._pending_headers[header] = value
- self._buffer = self._buffer[m.end():]
- return True
-
-
-class ResponseBuilder(object):
- """Builds HTTP responses for a list of accumulated requests."""
-
- def __init__(self):
- """Initializer."""
- self._max_pipeline_depth = 0
- self._requested_paths = []
- self._processed_end = False
- self._were_all_requests_http_1_1 = True
-
- def QueueRequests(self, requested_paths, were_all_requests_http_1_1):
- """Adds requests to the queue of requests.
-
- Args:
- requested_paths: (List of Strings) Requested paths.
- """
- self._requested_paths.extend(requested_paths)
- self._were_all_requests_http_1_1 = were_all_requests_http_1_1
-
- def Chunkify(self, data, chunksize):
- """ Divides a string into chunks
- """
- return [hex(chunksize)[2:] + "\r\n" + data[i:i+chunksize] + "\r\n" for i in range(0, len(data), chunksize)]
-
- def BuildResponses(self):
- """Converts the queue of requests into responses.
-
- Returns:
- (String) Buffer containing all of the responses.
- """
- result = ""
- self._max_pipeline_depth = max(self._max_pipeline_depth,
- len(self._requested_paths))
- for path, headers in self._requested_paths:
- if path == '/verifiedserver':
- body = "WE ROOLZ: {}\r\n".format(os.getpid());
- result += self._BuildResponse(
- '200 OK', ['Server: Apache',
- 'Content-Length: {}'.format(len(body)),
- 'Cache-Control: no-store'], body)
-
- elif path == '/alphabet.txt':
- body = 'abcdefghijklmnopqrstuvwxyz'
- result += self._BuildResponse(
- '200 OK', ['Server: Apache',
- 'Content-Length: 26',
- 'Cache-Control: no-store'], body)
-
- elif path == '/reverse.txt':
- body = 'zyxwvutsrqponmlkjihgfedcba'
- result += self._BuildResponse(
- '200 OK', ['Content-Length: 26', 'Cache-Control: no-store'], body)
-
- elif path == '/chunked.txt':
- body = ('7\r\nchunked\r\n'
- '8\r\nencoding\r\n'
- '2\r\nis\r\n'
- '3\r\nfun\r\n'
- '0\r\n\r\n')
- result += self._BuildResponse(
- '200 OK', ['Transfer-Encoding: chunked', 'Cache-Control: no-store'],
- body)
-
- elif path == '/cached.txt':
- body = 'azbycxdwevfugthsirjqkplomn'
- result += self._BuildResponse(
- '200 OK', ['Content-Length: 26', 'Cache-Control: max-age=60'], body)
-
- elif path == '/connection_close.txt':
- body = 'azbycxdwevfugthsirjqkplomn'
- result += self._BuildResponse(
- '200 OK', ['Content-Length: 26', 'Cache-Control: max-age=60', 'Connection: close'], body)
- self._processed_end = True
-
- elif path == '/1k.txt':
- body = '0123456789abcdef' * 64
- result += self._BuildResponse(
- '200 OK', ['Server: Apache',
- 'Content-Length: 1024',
- 'Cache-Control: max-age=60'], body)
-
- elif path == '/10k.txt':
- body = '0123456789abcdef' * 640
- result += self._BuildResponse(
- '200 OK', ['Server: Apache',
- 'Content-Length: 10240',
- 'Cache-Control: max-age=60'], body)
-
- elif path == '/100k.txt':
- body = '0123456789abcdef' * 6400
- result += self._BuildResponse(
- '200 OK',
- ['Server: Apache',
- 'Content-Length: 102400',
- 'Cache-Control: max-age=60'],
- body)
-
- elif path == '/100k_chunked.txt':
- body = self.Chunkify('0123456789abcdef' * 6400, 20480)
- body.append('0\r\n\r\n')
- body = ''.join(body)
-
- result += self._BuildResponse(
- '200 OK', ['Transfer-Encoding: chunked', 'Cache-Control: no-store'], body)
-
- elif path == '/stats.txt':
- results = {
- 'max_pipeline_depth': self._max_pipeline_depth,
- 'were_all_requests_http_1_1': int(self._were_all_requests_http_1_1),
- }
- body = ','.join(['%s:%s' % (k, v) for k, v in results.items()])
- result += self._BuildResponse(
- '200 OK',
- ['Content-Length: %s' % len(body), 'Cache-Control: no-store'], body)
- self._processed_end = True
-
- else:
- result += self._BuildResponse('404 Not Found', ['Content-Length: 7'], 'Go away')
- if self._processed_end:
- break
- self._requested_paths = []
- return result
-
- def WriteError(self, status, error):
- """Returns an HTTP response for the specified error.
-
- Args:
- status: (String) Response code and descrtion (e.g. "404 Not Found")
-
- Returns:
- (String) Text of HTTP response.
- """
- return self._BuildResponse(
- status, ['Connection: close', 'Content-Type: text/plain'], error)
-
- @property
- def processed_end(self):
- return self._processed_end
-
- def _BuildResponse(self, status, headers, body):
- """Builds an HTTP response.
-
- Args:
- status: (String) Response code and descrtion (e.g. "200 OK")
- headers: (List of Strings) Headers (e.g. "Connection: close")
- body: (String) Response body.
-
- Returns:
- (String) Text of HTTP response.
- """
- return ('HTTP/1.1 %s\r\n'
- '%s\r\n'
- '\r\n'
- '%s' % (status, '\r\n'.join(headers), body))
-
-
-class PipelineRequestHandler(socketserver.BaseRequestHandler):
- """Called on an incoming TCP connection."""
-
- def _GetTimeUntilTimeout(self):
- return self._start_time + TIMEOUT - time.time()
-
- def _GetTimeUntilNextSend(self):
- if not self._last_queued_time:
- return TIMEOUT
- return self._last_queued_time + SEND_BUFFER_TIME - time.time()
-
- def handle(self):
- self._request_parser = RequestParser()
- self._response_builder = ResponseBuilder()
- self._last_queued_time = 0
- self._num_queued = 0
- self._num_written = 0
- self._send_buffer = ""
- self._start_time = time.time()
- try:
- while not self._response_builder.processed_end or self._send_buffer:
-
- time_left = self._GetTimeUntilTimeout()
- time_until_next_send = self._GetTimeUntilNextSend()
- max_poll_time = min(time_left, time_until_next_send) + MIN_POLL_TIME
-
- rlist, wlist, xlist = [], [], []
- fileno = self.request.fileno()
- if max_poll_time > 0:
- rlist.append(fileno)
- if self._send_buffer:
- wlist.append(fileno)
- rlist, wlist, xlist = select.select(rlist, wlist, xlist, max_poll_time)
-
- if self._GetTimeUntilTimeout() <= 0:
- return
-
- if self._GetTimeUntilNextSend() <= 0:
- self._send_buffer += self._response_builder.BuildResponses()
- self._num_written = self._num_queued
- self._last_queued_time = 0
-
- if fileno in rlist:
- self.request.setblocking(False)
- new_data = self.request.recv(MAX_REQUEST_SIZE)
- self.request.setblocking(True)
- if not new_data:
- return
- new_requests = self._request_parser.ParseAdditionalData(new_data)
- self._response_builder.QueueRequests(
- new_requests, self._request_parser.were_all_requests_http_1_1)
- self._num_queued += len(new_requests)
- self._last_queued_time = time.time()
- elif fileno in wlist:
- num_bytes_sent = self.request.send(self._send_buffer[0:4096])
- self._send_buffer = self._send_buffer[num_bytes_sent:]
- time.sleep(0.05)
-
- except RequestTooLargeError as e:
- self.request.send(self._response_builder.WriteError(
- '413 Request Entity Too Large', e))
- raise
- except UnexpectedMethodError as e:
- self.request.send(self._response_builder.WriteError(
- '405 Method Not Allowed', e))
- raise
- except ServeIndexError:
- self.request.send(self._response_builder.WriteError(
- '200 OK', INFO_MESSAGE))
- except Exception as e:
- print(e)
- self.request.close()
-
-
-class PipelineServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
- pass
-
-
-parser = argparse.ArgumentParser()
-parser.add_argument("--port", action="store", default=0,
- type=int, help="port to listen on")
-parser.add_argument("--verbose", action="store", default=0,
- type=int, help="verbose output")
-parser.add_argument("--pidfile", action="store", default=0,
- help="file name for the PID")
-parser.add_argument("--logfile", action="store", default=0,
- help="file name for the log")
-parser.add_argument("--srcdir", action="store", default=0,
- help="test directory")
-parser.add_argument("--id", action="store", default=0,
- help="server ID")
-parser.add_argument("--ipv4", action="store_true", default=0,
- help="IPv4 flag")
-args = parser.parse_args()
-
-if args.pidfile:
- pid = os.getpid()
- f = open(args.pidfile, 'w')
- f.write('{}'.format(pid))
- f.close()
-
-server = PipelineServer(('0.0.0.0', args.port), PipelineRequestHandler)
-server.allow_reuse_address = True
-server.serve_forever()
projects / curl / commitdiff