Быстрая навигация:

• От автора
• О подходе к современным приложениям
• Формулировка задачи
• Имитация работы WSGI-сервера
• Как работать с декораторами
• Как настроить вложенность декораторов

От автора

Алексей Бледнов

Разработчик в Яндекс Образовании

Привет!

Я Алексей, автор задачи. Решая её, вы погрузитесь в устройство современных веб-приложений и напишете имитацию сервера, который получает запросы от пользователей и перенаправляет их дальше.

Не переживайте — работать будем на уровне знаний из тем, которые вы недавно прошли. А когда решите задачу, покажу, как решал её я. Приглашаю вас пройти этот путь вместе со мной!

О подходе к современным приложениям

В разработке ПО важны скорость доставки новой функциональности до пользователя и качество кода.

Это влияет как на устройство рабочих команд, так и на организацию процесса разработки. Мы работаем в небольших командах по спринтам. Спринт — фиксированный отрезок времени от одной до четырёх недель, за который команда должна выкатить небольшую, но готовую функциональность.

Как правило, над одним продуктом параллельно работает несколько команд разработчиков. Чтобы они не «толкались локтями» и не мешали друг другу, умные люди придумали микросервисную архитектуру.

Архитектура — это способ организовать код в проекте. Таких способов может быть много: например, в предыдущей задаче наше приложение было спроектировано по трёхзвенной архитектуре (интерфейс/клиент, веб-сервер, база данных).

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

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

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

Вот как это всё работает:

• Сначала поступает запрос от клиента (это веб- или мобильное приложение).
• API Gateway как секретарь — изучает запрос и направляет его в нужный сервис.
• Сервис обрабатывает запрос по своей логике, используя свою базу данных.
• Обработав — возвращает ответ.
• API Gateway этот ответ получает и отправляет клиенту.

Давайте мысленно погрузимся на уровень глубже — в один из сервисов.

Внутри каждого сервиса есть структура, похожая на API Gateway. Она называется ASGI/WSGI-сервер (англ. Asynchronous Server Gateway Interface / Web Server Gateway Interface).

Эта структура передаёт запросы обработчикам (их ещё называют «ручки» или «хендлеры»). А они уже расшифровывают, что хотел клиент, и «ходят» в базу за данными.

Вот схема одного из сервисов:

Теперь поговорим о запросах.

Запрос — это строка, составленная по конкретной структуре, которая активизирует работу определённой ручки.

Запрос обычно выглядит так:

1[HTTP-метод]/[маршрут]

Например:

1GET /categories/123

Сопоставим сущности:

Кроме того, в запросе могут быть уточняющие параметры:

1GET /categories/123/products?price_range=1000-5000&attributes=color:red

В зависимости от каждой части запроса ASGI/WSGI-сервер передаёт его на реализацию в определённую ручку. Для примера «Сервис каталога» с картинки выше описание и назначение запроса может выглядеть следующим образом:

И вот мы наконец подобрались к сути задачи.

Вам нужно будет написать структуру, которая имитирует работу WSGI-сервера. Будете на вход получать запрос, определять, какая ручка его обрабатывает, вызывать функцию — обработчик запроса и возвращать ответ.

Формулировка задачи

Вы работаете разработчиком в компании, которая готовит школьников к ЕГЭ. Продукт компании — веб-приложение, в котором школьники могут проходить варианты тестов.

Команда уже подготовила и протестировала несколько функциональных блоков (ручек). Вам передали задачу собрать WSGI-сервер, который ловит запросы, обрабатывает их и передаёт в уже готовые ручки.

Вы посидели над задачей и поняли, что в один присест её не решить. Нужно декомпозировать — то есть разделить на несколько задачек поменьше. Получились три следующие последовательные задачи:

1. Сначала напишем генератор и обработчик запросов.
2. Затем с помощью декораторов соберём логи работы сервиса и проверку, авторизован ли пользователь.
3. А в конце проанализируем логи работы сервера и соберём небольшое summary о его использовании.

Помимо описания задачи, технический директор оставил иллюстрацию устройства работы WSGI-сервера для нашего сервиса.

Также он оставил уточнения по формату запросов.

Запросы приходят в формате:

[HTTP-метод] /[маршрут]?[параметр1]=[значение1]&[параметр2]=[значение2]

Например:

1GET /user?name=John&session=15
2POST /attempt?name=Max&task=Snake

И оставил ссылку на документацию, где описаны ручки, с которыми работает наш сервис. Там была эта таблица:

Вот как-то так. В целом стало понятнее, что нужно сделать.

Но на всякий случай мы подготовили три шпаргалки, которые расскажут о важных нюансах.

Имитация работы WSGI-сервера

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

Чтобы ASGI/WSGI-сервер оставался в рабочем состоянии и в любой момент мог принимать запросы, вы будете использовать метод .send().

1# Имитация работы сервера
2app = wsgi_server()
3app.send(None)
4
5for request in sys.stdin:
6    print(app.send(request))

Рассмотрим эти сущности подробнее.

• wsgi_server() — это генератор, который вы реализуете.
• app.send(value) — метод генератора app, который возобновляет выполнение генератора и передаёт значение value в текущее выражение yield внутри него.

А дальше в цикле передаются все запросы и по итогам обработки каждого выводится ответ.

1for request in sys.stdin:
2    print(app.send(request))

Обратите внимание, что этот цикл может работать «вечно». Главное, что он будет продолжать работу после отправки каждого запроса app.send(). Чего мы и хотим достичь.

Как мы уже сказали выше, самим прописывать и использовать метод .send() вам не нужно. Подробнее про метод .send() можете прочитать в документации.

Как работать с декораторами

Чтобы логи запросов и обработки сервера представляли ценность, важно сохранять название запускавшихся ручек, переданные им параметры и возвращённый результат. Этому будет посвящена вторая задача.

Пример логов:

1{"handler": "home_handler", "params": {}, "response": [200, "Home Page"]}
2{"handler": "not_found_handler", "params": {}, "response": [404, "Not Found"]}
3{"handler": "attempt_handler", "params": {"name": "Max", "task": "Snake"}, "response": [200, "Good try, Max! Your attempt on task 'Snake' is accepted!"]}

Расшифруем:

• handler — название ручки;
• params — параметры, которые передали ручке;
• response — ответ, который вернула ручка после обработки.

Сохранять название ручек и параметры помогают декораторы, которые в общем виде выглядят так:

1def log_call(func):
2    def wrapper(*args, **kwargs):
3        …
4        return func(*args, **kwargs)
5    return wrapper

Вместо wrapper может быть любое название функции. Но чтобы другой разработчик понимал, что это обёртка, её обычно так и называют — wrapper.

Аргумент, с которым работает декоратор, это функция. Значит, мы можем обращаться к определённым атрибутам, характерным для функции.

Например:

Чтобы наша обёртка вывела название функции, можем воспользоваться атрибутом __name__. Применим его для простой функции greet(name), которая получает на вход имя и здоровается с пользователем.

1def log_call(func):
2    def wrapper(*args, **kwargs):
3        print(f"Вызвана функция: {func.__name__}")
4        return func(*args, **kwargs)
5    return wrapper
6
7@log_call
8def greet(name):
9    return f"Hello, {name}"
10
11greet("Max")

Вывод будет следующий:

1Вызвана функция: greet

Далее научимся обращаться к переданным параметрам функции. Можно обращаться отдельно к *args и **kwargs, как в примере, гибко передавая параметры в виде любого количества аргументов.

1def log_call(func):
2    def wrapper(*args, **kwargs):
3        print(f"Вызвана функция: {func.__name__}")
4        if args:
5            print(f"Имя: {args[0]}")
6            if len(args) > 1:
7                print(f"Возраст: {args[1]}")
8        if "name" in kwargs:
9            print(f"Имя (по ключу): {kwargs['name']}")
10        if "age" in kwargs:
11            print(f"Возраст (по ключу): {kwargs['age']}")
12        return func(*args, **kwargs)
13    return wrapper
14
15@log_call
16def greet(name, age):
17    return f"Hello, {name}! You are {age} years old."
18
19greet("Max", 18)
20greet(name="Alice", age=25)

Вывод:

1Вызвана функция: greet
2Имя: Max
3Возраст: 18
4Вызвана функция: greet
5Имя (по ключу): Alice
6Возраст (по ключу): 25

Однако, чтобы упростить себе жизнь, можно передавать в функцию определённый объект, будь то список, словарь, JSON, класс и так далее. Главное, чтобы параметры были заданы в определённой структуре.

Например, здесь передаём аргументы в формате словаря {params}. И намного удобнее обращаться к его параметрам.

1def log_call(func):
2    def wrapper(params):
3        print(f"Вызвана функция: {func.__name__}")
4        if "name" in params:
5            print(f"Имя: {params['name']}")
6        if "age" in params:
7            print(f"Возраст: {params['age']}")
8        return func(params)
9    return wrapper
10
11@log_call
12def greet(params):
13    return f"Привет, {params['name']}! Тебе {params['age']} лет."
14
15greet({"name": "Макс", "age": 18})
16greet({"name": "Алиса", "age": 25})

Вывод:

1Вызвана функция: greet
2Имя: Макс
3Возраст: 18
4Вызвана функция: greet
5Имя: Алиса
6Возраст: 25

Выше мы использовали одно и то же обозначение параметров params и для функции greet, и для декоратора. Это для удобства, они необязательно должны совпадать.

Теперь поднимемся на уровень выше. Разберём, как в целом используются декораторы на уровне программы.

Во второй задаче у вас будет шаблон со следующей конструкцией. Каждая ручка обёрнута одним или несколькими декораторами:

1# Ручки для разных маршрутов
2@log_call
3def home_handler(params):
4    return 200, "Home Page"
5
6@log_call
7def admin_handler(params):
8    return 200, "Admin Panel"
9
10@log_call
11@require_auth
12def user_handler(params):
13    # Должен использовать параметр name из URL
14    return 200, f"Hello, {params['name']}!"
15
16
17@log_call
18@require_auth
19def attempt_handler(params):
20    # Должен использовать параметр name из URL
21    return (
22        200,
23        f"Good try, {params['name']}! Your attempt on task '{params['task']}' is accepted!",
24    )
25
26@log_call
27def not_found_handler(params):
28    return 404, "Not Found"

В зависимости от того, что мы хотим логировать в определённой ручке, создаётся цепочка декораторов. Для ручки home_handler сохраняем только логи вызова (@log_call). А для user_handler дополнительно сохраняем параметры авторизации (@log_call и @require_auth).

Это делает логирование более гибким.

Как настроить вложенность декораторов

Добавим к примеру с приветствием ещё один декоратор. И посмотрим, как будет происходить взаимодействие с параметрами функций, когда попробуем обернуть функцию в два декоратора.

Например, давайте проверим, есть ли 18 лет нашему пользователю.

1def check_age(func):
2    def wrapper(params):
3        if params.get("age", 0) < 18:
4            return "Ошибка: доступ запрещён для несовершеннолетних"
5        return func(params)
6    return wrapper
7
8def log_call(func):
9    def wrapper(params):
10        print(f"Вызвана функция: {func.__name__}")
11        if "name" in params:
12            print(f"Имя: {params['name']}")
13        if "age" in params:
14            print(f"Возраст: {params['age']}")
15        return func(params)
16    return wrapper
17
18@log_call
19@check_age
20def greet(params):
21    return f"Привет, {params['name']}! Тебе {params['age']} лет."
22
23print(greet({"name": "Макс", "age": 18}))
24print(greet({"name": "Коля", "age": 16}))

Вывод будет следующим:

1Вызвана функция: wrapper
2Имя: Макс
3Возраст: 18
4Привет, Макс! Тебе 18 лет.
5Вызвана функция: wrapper
6Имя: Коля
7Возраст: 16
8Ошибка: доступ запрещён для несовершеннолетних

Как можно увидеть, вместо названия функции greet, которую оборачивали в декоратор, программа вывела название функции в декораторе wrapper. Это происходит потому, что декоратор @log_call получает на вход не функцию greet, а функцию wrapper из декоратора @check_age. Чтобы метаданные функции greet сохранялись через цепочку декораторов, используют декоратор для декораторов @wraps.

Суть @wraps — перенести все атрибуты функции func во wrapper, чтобы их можно было использовать дальше по цепочке.

Импортируем его:

1from functools import wraps

Таким образом, код станет следующим:

1from functools import wraps
2
3def check_age(func):
4    @wraps(func)
5    def wrapper(params):
6        if params.get("age", 0) < 18:
7            return "Ошибка: доступ запрещён для несовершеннолетних"
8        return func(params)
9    return wrapper
10
11def log_call(func):
12    @wraps(func)
13    def wrapper(params):
14        print(f"Вызвана функция: {func.__name__}")
15        if "name" in params:
16            print(f"Имя: {params['name']}")
17        if "age" in params:
18            print(f"Возраст: {params['age']}")
19        return func(params)
20    return wrapper
21
22@log_call
23@check_age
24def greet(params):
25    return f"Привет, {params['name']}! Тебе {params['age']} лет."
26
27print(greet({"name": "Макс", "age": 18}))
28print(greet({"name": "Коля", "age": 16}))

Получается, с помощью @wraps(func) обернули функцию внутри декоратора. Теперь, в какой последовательности сколько бы декораторов ни запускали — атрибуты первоначальной функции не будут пропадать. Что позволит нам не потерять их при логировании, а также не терять гибкости при использовании декораторов.

Вывод кода выше:

1Вызвана функция: greet
2Имя: Макс
3Возраст: 18
4Привет, Макс! Тебе 18 лет.
5Вызвана функция: greet
6Имя: Коля
7Возраст: 16
8Ошибка: доступ запрещён для несовершеннолетних

Подробнее про использование wraps и модуль functools можете посмотреть в документации.

Ура, вы разобрались, как с помощью декораторов выстроить логирование любой вложенности декораторов с гибким подходом! Теперь точно можно переходить к задачам.