В этой статье мы погрузимся в мир веб-протоколов, в частности HTTP, а также рассмотрим связь HTTP с TCP и UDP. Попутно, в качестве примеров, мы приведем примеры реализации на Python клиентов и серверов, использующих эти протоколы.

HTTP (Hypertext Transfer Protocol) является основой мира Интернета. Когда вы посещаете какой-нибудь сайт, ваш браузер посылает HTTP-запросы на сервер, который в ответ выдает веб-страницы. Это похоже на разговор между браузером и сервером. Например, если послать запрос с текстом “Joe”, то сервер может ответить “Hi there, Joe”.

Ниже приведен базовый пример работы такого HTTP-сервера в Python3. Мы будем использовать встроенные модули http.client и http.server. Это простой пример, поэтому он не строго соответствует стандартам HTTP и не рекомендуется для использования в производстве, поскольку реализует только базовые проверки безопасности. Но для наших целей это подойдет.

import http.server
import http.client

PORT = 8001

class Store:
    def __init__(self):
        self.requestBody = ''
        self.responseBody = ''

store = Store()

class MyHTTPRequestHandler(http.server.BaseHTTPRequestHandler):
    def do_POST(self):
        content_length = int(self.headers['Content-Length'])
        content = self.rfile.read(content_length).decode('utf-8')
        store.requestBody = content

        response_content = f'Hi there, {content}'.encode('utf-8')
        self.send_response(200)
        self.send_header('Content-Type', 'text/plain')
        self.send_header('Content-Length', len(response_content))
        self.end_headers()
        self.wfile.write(response_content)

def server_listen():
    with http.server.HTTPServer(('localhost', PORT), MyHTTPRequestHandler) as server:
        print(f'HTTP server listening on {PORT}')
        http_request()

def http_request():
    conn = http.client.HTTPConnection('localhost', PORT)
    content = 'Joe'
    headers = {
        'Content-Type': 'text/plain',
        'Content-Length': str(len(content))
    }
    conn.request('POST', '/greet', body=content, headers=headers)
    response = conn.getresponse()
    data = response.read().decode('utf-8')
    store.responseBody = data
    close_connections()

def close_connections():
    server.server_close()

    print(store.requestBody)  # Joe
    print(store.responseBody)  # Hi there, Joe

server_listen()

TCP-соединение

Теперь познакомимся с TCP  (Transmission Control Protocol). TCP является базовым протоколом, на котором построен HTTP, как видно из официальных спецификаций последнего. И хотя я уже об этом сказал, я попрошу вас сделать вид, что вы этого еще не знаете. Давайте докажем, что HTTP базируется на TCP!

В Python имеются встроенные модули threading и socket, которые помогают нам создавать TCP-клиенты и серверы.

Следует знать, что TCP отличается от HTTP по нескольким параметрам:

• Запросы не могут отправляться спонтанно. Сначала должно быть установлено соединение.
• После установки соединения сообщения могут передаваться в обоих направлениях.
• Установленное соединение должно быть закрыто вручную.

Ниже приведена простая реализация TCP-клиента, который желает получить приветствие от сервера:

import socket
import threading

PORT = 8001
MAXIMUM_BYTES_RECEIVABLE = 1024

class Store:
    def __init__(self):
        self.requestBody = ''
        self.responseBody = ''

store = Store()

def handle_client(client_socket):
    request_data = client_socket.recv(MAXIMUM_BYTES_RECEIVABLE).decode('utf-8')
    store.requestBody = request_data

    response_data = f'Hi there, {request_data}'.encode('utf-8')
    client_socket.send(response_data)

    response = client_socket.recv(MAXIMUM_BYTES_RECEIVABLE).decode('utf-8')
    store.responseBody = response

    client_socket.close()

def server_listen():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # When the socket type is socket.SOCK_STREAM the protocol being used is TCP by default.
    server.bind(('0.0.0.0', PORT))
    server.listen(5)
    print(f'TCP server listening on {PORT}')

    while True:
        client_socket, addr = server.accept() # Blocks execution and waits for an incoming connection.
        client_handler = threading.Thread(target=handle_client, args=(client_socket,))
        client_handler.start()

def http_request():
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect(('localhost', PORT))
    content = 'Joe'
    client.send(content.encode('utf-8'))
    client.shutdown(socket.SHUT_WR)
    response = client.recv(MAXIMUM_BYTES_RECEIVABLE).decode('utf-8')
    store.responseBody = response
    client.close()
    close_connections()

def close_connections():
    server.close()

    print(store.requestBody)  # Joe
    print(store.responseBody)  # Hi there, Joe

if __name__ == '__main__':
    server_listen()
    http_request()

Теперь представьте, что у вас есть TCP-прокси, который может передавать сообщения между HTTP-клиентами и серверами. Даже если этот прокси не понимает HTTP, он все равно может передавать запросы и ответы.

Вот как будет выглядеть его реализация:

import socket
import http.client
import threading

HTTP_PORT = 8001
PROXY_TCP_PORT = 8002
MAXIMUM_BYTES_RECEIVABLE = 1024

class Store:
    def __init__(self):
        self.requestBody = ''
        self.responseBody = ''

store = Store()

def proxy_handler(local_socket):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as remote_socket:
        remote_socket.connect(('localhost', HTTP_PORT))
        
        def forward(src, dst):
            while True:
                data = src.recv(MAXIMUM_BYTES_RECEIVABLE)
                if not data:
                    break
                dst.send(data)
        
        threading.Thread(target=forward, args=(local_socket, remote_socket)).start()
        threading.Thread(target=forward, args=(remote_socket, local_socket)).start()

def http_server_handler(client_socket):
    data = client_socket.recv(MAXIMUM_BYTES_RECEIVABLE).decode('utf-8')
    store.requestBody = data

    response_data = f'Hi there, {data}'.encode('utf-8')
    client_socket.send(response_data)

    response = client_socket.recv(MAXIMUM_BYTES_RECEIVABLE).decode('utf-8')
    store.responseBody = response

def http_server_listen():
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
        server.bind(('0.0.0.0', HTTP_PORT)
        server.listen(5)
        print(f'HTTP server listening on {HTTP_PORT}')

        while True:
            client_socket, addr = server.accept()
            threading.Thread(target=http_server_handler, args=(client_socket,)).start()

def proxy_listen():
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as proxy_server:
        proxy_server.bind(('0.0.0.0', PROXY_TCP_PORT))
        proxy_server.listen(5)
        print(f'TCP proxy listening on {PROXY_TCP_PORT}')

        while True:
            local_socket, addr = proxy_server.accept()
            threading.Thread(target=proxy_handler, args=(local_socket,)).start()

def http_request():
    conn = http.client.HTTPConnection('localhost', PROXY_TCP_PORT)
    content = 'Joe'
    headers = {
        'Content-Type': 'text/plain',
        'Content-Length': str(len(content))
    }
    conn.request('POST', '/greet', body=content, headers=headers)
    response = conn.getresponse()
    data = response.read().decode('utf-8')
    close_connections()

def close_connections():
    http_server_listen_thread.join()
    proxy_listen_thread.join()

    print(store.requestBody)  # Joe
    print(store.responseBody)  # Hi there, Joe

if __name__ == '__main__':
    http_server_listen_thread = threading.Thread(target=http_server_listen)
    proxy_listen_thread = threading.Thread(target=proxy_listen)
    http_server_listen_thread.start()
    http_server_listen_thread.join()
    proxy_listen_thread.start()
    http_request()

Как уже говорилось, хотя TCP-прокси-сервер не знает, что такое HTTP, запросы и ответы полностью проходят через него.

Понимание особенностей TCP

Прежде чем мы продолжим, несколько фактов о TCP:

• Он надежен, т.е. обеспечивает подтверждение сообщений, их повторную передачу и тайминг при необходимости.
• Он гарантирует, что данные поступают в правильном порядке.

Неудивительно, что TCP так распространен, но… Вы же знали, что будет какое-то “но”, верно?

TCP может быть несколько тяжеловат. Чтобы сокетное соединение могло разрешить отправку данных, требуется установить три пакета. В мире HTTP это означает, что для выполнения параллельных запросов HTTP/1.1 требуется несколько TCP-соединений, что может потребовать значительных ресурсов.

HTTP/2 пытается улучшить эту ситуацию, обрабатывая параллельные запросы через одно соединение. Однако при этом возникают проблемы. Когда один пакет задерживается или приходит не по порядку, это приводит к остановке всех запросов.

А теперь представьте, что есть альтернатива TCP, позволяющая параллельные HTTP-сообщения без этих последствий. Звучит неплохо, не так ли? Эта альтернатива – UDP (User Datagram Protocol).

UDP-соединение

Начнем с того, чем UDP отличается от TCP:

• Здесь нет понятия соединения. Вы отправляете данные и надеетесь, что кто-то их получит.
• Вы можете передавать только небольшие фрагменты данных, которые не обязательно представляют собой целое сообщение (подробнее об этом можно почитать в статье Википедии), а встроенные разделители отсутствуют, если они не включены в явном виде.
• В результате создание даже базового механизма запрос/ответ становится более сложным (но все же возможным).

Давайте рассмотрим пример UDP-клиента, который хочет взаимодействовать с сервером. На этот раз мы определим наш сокет как SOCK_DGRAM:

import socket

PORT = 8001
EOS = b'{$content}'  # End of stream
MAXIMUM_BYTES_RECEIVABLE = 1024

class Store:
    def __init__(self):
        self.requestBody = ''
        self.responseBody = ''

store = Store()

def slice_but_last(data, encoding='utf-8'):
    return data[:-1].decode(encoding)

def server_listen():
    sender = None

    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as server:
        server.bind(('0.0.0.0', PORT))
        print(f'UDP server listening on {PORT}')

        while True:
            chunk, addr = server.recvfrom(MAXIMUM_BYTES_RECEIVABLE)
            sender = addr if sender is None else sender
            store.requestBody += slice_but_last(chunk)

            if chunk[-1:] == EOS:
                response_data = f'Hi there, {store.requestBody}'.encode('utf-8') + EOS
                server.sendto(response_data, sender)

                # Note: You can choose to close the server here if needed
                break

def http_request():
    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as client:
        content = 'Joe'.encode('utf-8') + EOS
        client.sendto(content, ('localhost', PORT))
        response_data, _ = client.recvfrom(MAXIMUM_BYTES_RECEIVABLE)
        store.responseBody = slice_but_last(response_data)

        close_connections()

def close_connections():
    print(store.requestBody)  # Joe
    print(store.responseBody)  # Hi there, Joe

if __name__ == '__main__':
    server_listen()
    http_request()

Итак, учитывая, что у нас есть парсер HTTP (http-parser, например), вот как можно реализовать HTTP-решение через UDP:

import socket
from http_parser.parser import HttpParser

PORT = 8001
CRLF = 'rn'
MAXIMUM_BYTES_RECEIVABLE = 1024

class Store:
    def __init__(self):
        self.requestBody = ''
        self.responseBody = ''

store = Store()

def server_listen():
    parser = HttpParser()

    def on_body(data):
        store.requestBody += data

    def on_message_complete():
        content = f'Hi there, {store.requestBody}'
        response = f'HTTP/1.1 200 OK{CRLF}' 
                   f'Content-Type: text/plain{CRLF}' 
                   f'Content-Length: {len(content)}{CRLF}' 
                   f'{CRLF}' 
                   f'{content}'
        server.sendto(response.encode('utf-8'), sender)

    parser.on_body = on_body
    parser.on_message_complete = on_message_complete

    sender = None

    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as server:
        server.bind(('0.0.0.0', PORT))
        print(f'UDP server listening on {PORT}')

        while True:
            chunk, sender = server.recvfrom(MAXIMUM_BYTES_RECEIVABLE)
            parser.execute(chunk)

def http_request():
    parser = HttpParser()

    def on_body(data):
        store.responseBody += data

    def on_message_complete():
        close_connections()

    parser.on_body = on_body
    parser.on_message_complete = on_message_complete

    content = 'Joe'
    request = f'POST /greet HTTP/1.1{CRLF}' 
              f'Content-Type: text/plain{CRLF}' 
              f'Content-Length: {len(content)}{CRLF}' 
              f'{CRLF}' 
              f'{content}'

    client.sendto(request.encode('utf-8'), ('localhost', PORT))

def close_connections():
    server.close()
    client.close()

    print(store.requestBody)  # Joe
    print(store.responseBody)  # Hi there, Joe

if __name__ == '__main__':
    client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    server_listen()
    http_request()

Выглядит неплохо. У нас есть полноценная реализация с использованием UDP. Но пока не стоит слишком радоваться. UDP имеет ряд существенных недостатков:

• Ненадежность. Вы не можете быть уверены, что ваше сообщение дойдет до адресата.
• Пакеты приходят не по порядку, поэтому нельзя гарантировать порядок следования сообщений.

Возникновение QUIC и HTTP/3

Для устранения недостатков UDP был создан новый протокол – QUIC . Он построен на основе UDP и использует “умные” алгоритмы для его реализации. Отличительные особенности QUIC:

• Надежность
• Обеспечение упорядоченной доставки пакетов
• Легкость

Это приводит нас прямо к HTTP/3, который все еще является относительно новым и экспериментальным. В нем используется QUIC для устранения проблем, возникших в HTTP/2. В HTTP/3 нет соединений, поэтому сессии не влияют друг на друга.

HTTP/3 – перспективное направление развития веб-протоколов, использующее сильные стороны QUIC и UDP.

Хотя встроенная поддержка протокола QUIC отсутствует, можно воспользоваться модулем aioquic, который поддерживает реализацию как QUIC, так и HTTP/3.

Пример с использованием протокола QUIC

Рассмотрим простой пример сервера, использующего QUIC:

import asyncio
import ssl
from aioquic.asyncio import connect, connect_udp, Connection, serve
from aioquic.asyncio.protocol import BaseProtocol, DatagramProtocol
from aioquic.asyncio.protocol.stream import DataReceived

class HTTPServerProtocol(BaseProtocol):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    async def data_received(self, data):
        await super().data_received(data)
        if isinstance(self._quic, Connection):
            for stream_id, buffer in self._quic._events[DataReceived]:
                data = buffer.read()
                response = f'HTTP/1.1 200 OKrnContent-Length: {len(data)}rnrn{data.decode("utf-8")}'
                self._quic.send_stream_data(stream_id, response.encode('utf-8'))

async def main():
    loop = asyncio.get_event_loop()

    # Create QUIC server context
    quic_server = await loop.create_server(HTTPServerProtocol, 'localhost', 8001)

    async with quic_server:
        await quic_server.serve_forever()

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

А это – клиент:

import asyncio
import ssl
from aioquic.asyncio import connect, connect_udp, Connection
from aioquic.asyncio.protocol import BaseProtocol

class HTTPClientProtocol(BaseProtocol):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.connected_event = asyncio.Event()

    def quic_event_received(self, event):
        super().quic_event_received(event)
        if event.matches('connected'):
            self.connected_event.set()

    async def request(self, path, data=None):
        stream_id = self._quic.get_next_available_stream_id()
        self._quic.send_stream_data(stream_id, data)
        await self.connected_event.wait()
        response = await self._quic.receive_data(stream_id)
        return response

async def main():
    loop = asyncio.get_event_loop()

    # Create QUIC client context
    quic = connect('localhost', 8001)

    async with quic as protocol:
        client_protocol = HTTPClientProtocol(quic, protocol._session_id, None)
        await client_protocol.connected_event.wait()
        
        data = 'Hello, Joe!'
        response = await client_protocol.request('/greet', data.encode('utf-8'))
        print(response.decode('utf-8'))

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

Пример с использованием протокола HTTP/3

А чтобы вы получили полное представление, приведем пример с использованием протокола HTTP/3 (с помощью модуля aioquic).

Сервер:

import asyncio
from aioquic.asyncio.protocol import connect, connect_udp, serve, QuicProtocol
from aioquic.asyncio.protocol.stream import DataReceived
from h11 import Response, Connection
from h11._events import Data

class HTTP3ServerProtocol(QuicProtocol):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.conn = Connection()

    def quic_event_received(self, event):
        super().quic_event_received(event)
        if event.matches('handshake_completed'):
            self.conn.initiate_upgrade_for_http2()

    async def data_received(self, data):
        await super().data_received(data)
        if isinstance(self._quic, QuicProtocol):
            for stream_id, buffer in self._quic._events[DataReceived]:
                data = buffer.read()
                response = Response(status_code=200, headers=[('content-length', str(len(data)))], content=data)
                data = self.conn.send(response)
                self._quic.transmit_data(stream_id, data)

async def main():
    loop = asyncio.get_event_loop()

    # Create QUIC server context
    quic_server = await loop.create_server(HTTP3ServerProtocol, 'localhost', 8001)

    async with quic_server:
        await quic_server.serve_forever()

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

И клиент:

import asyncio
from aioquic.asyncio.protocol import connect, connect_udp, QuicProtocol
from h11 import Request, Response, Connection
from h11._events import Data

class HTTP3ClientProtocol(QuicProtocol):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.conn = Connection()

    async def request(self, path, data=None):
        stream_id = self._quic.get_next_available_stream_id()
        request = Request(method='POST', target=path, headers=[('content-length', str(len(data)))]
            if data else [])
        data = self.conn.send(request)
        self._quic.transmit_data(stream_id, data)

        while True:
            event = self.conn.next_event()
            if isinstance(event, Data):
                self._quic.transmit_data(stream_id, event.data)
            elif event == h11.EndOfMessage():
                break

        response = await self._quic.receive_data(stream_id)
        return response

async def main():
    loop = asyncio.get_event_loop()

    # Create QUIC client context
    quic = connect('localhost', 8001)

    async with quic as protocol:
        client_protocol = HTTP3ClientProtocol(quic, protocol._session_id, None)
        
        data = 'Hello, Joe!'
        response = await client_protocol.request('/greet', data.encode('utf-8'))
        print(response.content.decode('utf-8'))

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

Итоги

Такая эволюция ставит вопрос о том, сможем ли мы в будущем распрощаться с TCP, но это уже тема для другой статьи и, возможно, для будущего.

На этом мы завершаем наше путешествие по HTTP, TCP и UDP в Python3! Тема может показаться сложной, но под поверхностью каждого посещаемого вами сайта скрывается увлекательный мир веб-коммуникаций, с которым стоит познакомиться.

Перевод статьи «Introduction to HTTP in Python3».

Сообщение Введение в HTTP в Python3 появились сначала на pythonturbo.

Source: pythonturbo.ru