Maks live

Web исключения в Django

2017-06-10T15:00:00+03:00

Как и положено веб фраймворку, Django позволяет возвращать в ответ на запрос HttpResponse с любым статус кодом из диапазона [100 .. 599]. Этот ответ должен быть явно отправлен через return во вьюхе обрабатывающей запрос. Однако pythonyc way предусматривает не только явный return, но и гибкую обработку исключений. Рассмотрим веб исключения в Django.

Стандартные исключения

Django допускает ограниченный набор http ответов через выбрасывание исключений.

400 SuspiciousOperation
403 PermissionDenied
404 Http404
500 Любое другое неперехваченное исключение

Настройка http ответа

Ответ возвращаемый каждым из этих исключений можно персонализировать через перегрузку соответствующих хендлеров в файле urls.py.

# views.py
from django.views.generic import TemplateView

class ErrorHandler(TemplateView):

    """ Render error template """

    error_code = 404
    template_name = 'index/error.html'

    def dispatch(self, request, *args, **kwargs):
        """ For error on any methods return just GET """
        return self.get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['error_code'] = self.error_code
        return context

    def render_to_response(self, context, **response_kwargs):
        """ Return correct status code """
        response_kwargs = response_kwargs or {}
        response_kwargs.update(status=self.error_code)
        return super().render_to_response(context, **response_kwargs)

# urls.py
from index.views import ErrorHandler

# error handing handlers - fly binding
for code in (400, 403, 404, 500):
    vars()['handler{}'.format(code)] = ErrorHandler.as_view(error_code=code)

Тестирование хендлеров

Проверить работу хендлеров, можно явно выбросив соответствующие исключения. Перегрузив какую либо из существующих вьюх через mock. Но этот способ не позволяет проверить ответ со статусом 500, т.к. в тестах общие исключения не перехватываются. Полностью убедится в корректности обработки ошибки сервера — можно только через LiveServerTestCase.

# tests.py
from unittest import mock

from django.test import TestCase
from django.core.exceptions import SuspiciousOperation, PermissionDenied
from django.http import Http404
from index import views

class ErrorHandlersTestCase(TestCase):

    """ Check is correct error handlers work """

    def raise_(exception):
        def wrapped(*args, **kwargs):
            raise exception('Test exception')
        return wrapped

    def test_index_page(self):
        """ Should check is 200 on index page """
        response = self.client.get('/')
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, 'index/index.html')

    @mock.patch('index.views.IndexView.get', raise_(Http404))
    def test_404_page(self):
        """ Should check is 404 page correct """
        response = self.client.get('/')
        self.assertEqual(response.status_code, 404)
        self.assertTemplateUsed(response, 'index/error.html')
        self.assertIn('404 Page not found', response.content.decode('utf-8'))

    @mock.patch('index.views.IndexView.get', views.ErrorHandler.as_view(error_code=500))
    def test_500_page(self):
        """ Should check is 500 page correct """
        response = self.client.get('/')
        self.assertEqual(response.status_code, 500)
        self.assertTemplateUsed(response, 'index/error.html')
        self.assertIn('500 Server Error', response.content.decode('utf-8'))

    @mock.patch('index.views.IndexView.get', raise_(SuspiciousOperation))
    def test_400_page(self):
        """ Should check is 400 page correct """
        response = self.client.get('/')
        self.assertEqual(response.status_code, 400)
        self.assertTemplateUsed(response, 'index/error.html')
        self.assertIn('400 Bad request', response.content.decode('utf-8'))

    @mock.patch('index.views.IndexView.get', raise_(PermissionDenied))
    def test_403_page(self):
        """ Should check is 403 page correct """
        response = self.client.get('/')
        self.assertEqual(response.status_code, 403)
        self.assertTemplateUsed(response, 'index/error.html')
        self.assertIn('403 Permission Denied', response.content.decode('utf-8'))

Расширенные исключения

В AioHTTP, любой HttpResponse можно выбрасывать как исключение. Это действительно круто. Но если попробовать такое в Django, получаем ошибку типа, т.к. исключение должно быть наследником базового класса исключений.

>>> from django.http import HttpResponse
>>> raise HttpResponse()
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: exceptions must derive from BaseException

С пакетом Django web exceptions можно выбрасывать любой http ответ как исключение.

>>> from web_exceptions import exceptions
>>> raise exceptions.HTTPOk()
Traceback (most recent call last):
  File "<console>", line 1, in <module>
web_exceptions.exceptions.HTTPOk: OK

Быстрый старт

1 Устанавливаем через pip

pip install django-web-exceptions

2 Подключаем middleware

# settings.py
MIDDLEWARE = (
    # ...
    'web_exceptions.middleware.WebExceptionsMiddleware',
    # ...
)

3 Вызываем исключение

# views.py
from web_exceptions import exceptions

# ...

def index(request):
    """ Simple view raise redirectexception """
    raise exceptions.HTTPMovedPermanently('/foo')

Как это работает

Для того чтобы выбрасывать http ответ как исключение, в базовом классе наследуемся сразу от HttpResponse и Exception.

from django.http import HttpResponse

class HTTPException(HttpResponse, Exception):

    """
    Base Web explanation
    In subclasses should set status_code attr
    """

    status_code = None
    empty_body = False
    reason = None

    def __init__(self, *, content=None, headers=None, **kwargs):
        HttpResponse.__init__(self, content or "", status=self.status_code, **kwargs)
        headers = headers or {}
        for key, value in headers.items():
            self[key] = value
        self._reason_phrase = self._reason_phrase or self.reason
        if not (self.content or self.empty_body):
            self.content = "{}: {}".format(self.status_code, self.reason_phrase).encode(self.charset)
        Exception.__init__(self, self.reason_phrase)

200x status code

200 HTTPOk
201 HTTPCreated
202 HTTPAccepted
203 HTTPNonAuthoritativeInformation
204 HTTPNoContent
205 HTTPResetContent
206 HTTPPartialContent

300x status code

300 HTTPMultipleChoices
301 HTTPMovedPermanently
302 HTTPFound
303 HTTPSeeOther
304 HTTPNotModified
305 HTTPUseProxy
307 HTTPTemporaryRedirect
308 HTTPPermanentRedirect

400x status code

400 HTTPBadRequest
401 HTTPUnauthorized
402 HTTPPaymentRequired
403 HTTPForbidden
404 HTTPNotFound
405 HTTPMethodNotAllowed
406 HTTPNotAcceptable
407 HTTPProxyAuthenticationRequired
408 HTTPRequestTimeout
409 HTTPConflict
410 HTTPGone
411 HTTPLengthRequired
412 HTTPPreconditionFailed
413 HTTPRequestEntityTooLarge
414 HTTPRequestURITooLong
415 HTTPUnsupportedMediaType
416 HTTPRequestRangeNotSatisfiable
417 HTTPExpectationFailed
421 HTTPMisdirectedRequest
426 HTTPUpgradeRequired
428 HTTPPreconditionRequired
429 HTTPTooManyRequests
431 HTTPRequestHeaderFieldsTooLarge
451 HTTPUnavailableForLegalReasons

500x status code

500 HTTPInternalServerError
501 HTTPNotImplemented
502 HTTPBadGateway
503 HTTPServiceUnavailable
504 HTTPGatewayTimeout
505 HTTPVersionNotSupported
506 HTTPVariantAlsoNegotiates
510 HTTPNotExtended
511 HTTPNetworkAuthenticationRequired

Web exceptions links

Source code on GH — samael500/web-exceptions
Pypi package — django-web-exceptions
Docs on readthedocs — web-exceptions.readthedocs.io
Example usage proj on GH — samael500/web-exceptions/example

Кластеризация маркеров в GeoServer

2017-05-10T15:00:00+03:00

На одном из текущих проектов мы строим геоинформационную систему. Работаем с геоданными через PostGIS и GeoServer. Объектов на карте достаточно много и в перспективе будет всё больше. Отрисовка всех маркеров на крупном масштабе заставляет геосервер нагружать систему на 100%. Для оптимизации работы системы, а также повышения наглядности для пользователя. Отдельные маркеры на карте необходимо группировать в кластеры.

Как оказалось, сделать это силами геосервeра очень просто, но пока этот способ был найден, пришлось перерыть всю документацию по геосерверу и весь Gis StackExchange. В результате группировка точек в кластеры осуществляется с помощью векторной трансформации vec:PointStacker.

Кластеризация точек

Для объединения объектов в один кластер необходимо в стиле слоя объявить векторную трансформацию vec:PointStacker.

Данная трансформация принимает следующие параметры:

cellSize — Размер ячейки в пределах которой точки будут объединяться в кластер.
outputBBOX — Координаты углов результирующего тайла.
outputWidth — Ширина результирующего тайла.
outputHeight — Высота результирующего тайла.

На выходе получаем кластеры с информацие о количестве объектов.

geom — геометрия кластера.
count — число объектов вошедших в кластер.
countUnique — число уникальных объектов в кластере.

Размер ячейки выбираем “на глаз”, чтобы объекты красиво группировались с точки зрения пользователя. Чем больше ячейка, тем меньше кластеров получается в результате.

Остальные параметры передаем из исходного тайла через функцию env входящего wms запроса.

<Transformation>
    <ogc:Function name="vec:PointStacker">
        <ogc:Function name="parameter">
            <ogc:Literal>data</ogc:Literal>
        </ogc:Function>
        <ogc:Function name="parameter">
            <ogc:Literal>cellSize</ogc:Literal>
            <ogc:Literal>99</ogc:Literal>
        </ogc:Function>
        <ogc:Function name="parameter">
            <ogc:Literal>outputBBOX</ogc:Literal>
            <ogc:Function name="env">
                <ogc:Literal>wms_bbox</ogc:Literal>
            </ogc:Function>
        </ogc:Function>
        <ogc:Function name="parameter">
            <ogc:Literal>outputWidth</ogc:Literal>
            <ogc:Function name="env">
                <ogc:Literal>wms_width</ogc:Literal>
            </ogc:Function>
        </ogc:Function>
        <ogc:Function name="parameter">
            <ogc:Literal>outputHeight</ogc:Literal>
            <ogc:Function name="env">
                <ogc:Literal>wms_height</ogc:Literal>
            </ogc:Function>
        </ogc:Function>
    </ogc:Function>
</Transformation>

Далее для кластеров необходимо задать стиль отображения. Будем отображать кластеры на карте в виде кругов с текстом соответствующим количеству объектов вошедших в кластер. Размер круга выбираем в зависимости от числа объектов вошедших в него, например по формуле:

25 + log (count) * 5

Стиль состоит из описания текста TextSymbolizer и точки PointSymbolizer.

<Rule>
    <Name>Point group cluster</Name>
    <Title>Realties group</Title>
    <TextSymbolizer>
        <Label>
            <ogc:PropertyName>count</ogc:PropertyName>
        </Label>
        <Font>
            <CssParameter name="font-family">Arial</CssParameter>
            <CssParameter name="font-size">12</CssParameter>
            <CssParameter name="font-weight">bold</CssParameter>
        </Font>
        <LabelPlacement>
            <PointPlacement>
                <AnchorPoint>
                    <AnchorPointX>0.5</AnchorPointX>
                    <AnchorPointY>0.8</AnchorPointY>
                </AnchorPoint>
            </PointPlacement>
        </LabelPlacement>
        <Fill>
            <CssParameter name="fill">#000</CssParameter>
            <CssParameter name="fill-opacity">1.0</CssParameter>
        </Fill>
        <VendorOption name="partials">true</VendorOption>
    </TextSymbolizer>
    <PointSymbolizer>
        <Graphic>
            <Mark>
                <WellKnownName>circle</WellKnownName>
                <Fill>
                    <CssParameter name="fill">#1E90FF</CssParameter>
                    <CssParameter name="fill-opacity">0.75</CssParameter>
                </Fill>
            </Mark>
            <Size>
                <ogc:Add>
                    <ogc:Literal>25</ogc:Literal>
                    <ogc:Mul>
                        <ogc:Function name="log">
                           <ogc:PropertyName>count</ogc:PropertyName>
                        </ogc:Function>
                        <ogc:Literal>5</ogc:Literal>
                    </ogc:Mul>
                </ogc:Add>
            </Size>
        </Graphic>
    </PointSymbolizer>
</Rule>

Для описания стиля текста кластера важно указать опцию partials, иначе любой текст на границе тайла не будет отображаться и, возможно, возникновение кластеров без подписи числа объектов.

<VendorOption name="partials">true</VendorOption>

В одном слое у нас отображаются объекты разных торговых сетей и стиль иконок должен быть различным для них. Но при кластеризации сохраняется только информация о количестве объектов, но никак не о качестве (индивидуальных особенностях). Даже для кластера из одного объекта нельзя получить свойства этого объекта. Поэтому будем запускать кластеризацию, начиная с некоторого масштаба. А для меньшего масштаба отображать все точки отдельно.

Разделить отображения можно с помощью задания минимального и максимального масштаба отображения.

<!-- Стиль отдельного объекта для масштабов меньше заданного максимальной величиной -->
<MaxScaleDenominator>70000</MaxScaleDenominator>

<!-- Стиль кластера для всех масштабов больше чем минимальная величина -->
<MinScaleDenominator>70000</MinScaleDenominator>

Результат

Весь стиль объектов

<?xml version="1.0" encoding="UTF-8"?>
<StyledLayerDescriptor version="1.0.0"
    xmlns="http://www.opengis.net/sld"
    xmlns:ogc="http://www.opengis.net/ogc"
    xmlns:xlink="http://www.w3.org/1999/xlink"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd">
    <NamedLayer>
        <Name>Realties</Name>
        <UserStyle>
            <Name>Realties</Name>
            <Title>Realties objects icons</Title>
            <Abstract>SVG styles for realties objects</Abstract>

            <FeatureTypeStyle>
                <Rule>
                    <MaxScaleDenominator>70000</MaxScaleDenominator>
                    <Title>Realty</Title>
                    <PointSymbolizer>
                        <Graphic>
                            <ExternalGraphic>
                                <OnlineResource
                                    xlink:type="simple"
                                    xlink:href="./img/${logo_name}.svg" />
                                <Format>image/svg+xml</Format>
                            </ExternalGraphic>
                            <Size>
                                <ogc:Literal>35</ogc:Literal>
                            </Size>
                        </Graphic>
                    </PointSymbolizer>
                </Rule>
            </FeatureTypeStyle>

            <FeatureTypeStyle>
                <Transformation>
                    <ogc:Function name="vec:PointStacker">
                        <ogc:Function name="parameter">
                            <ogc:Literal>data</ogc:Literal>
                        </ogc:Function>
                        <ogc:Function name="parameter">
                            <ogc:Literal>cellSize</ogc:Literal>
                            <ogc:Literal>99</ogc:Literal>
                        </ogc:Function>
                        <ogc:Function name="parameter">
                            <ogc:Literal>outputBBOX</ogc:Literal>
                            <ogc:Function name="env">
                                <ogc:Literal>wms_bbox</ogc:Literal>
                            </ogc:Function>
                        </ogc:Function>
                        <ogc:Function name="parameter">
                            <ogc:Literal>outputWidth</ogc:Literal>
                            <ogc:Function name="env">
                                <ogc:Literal>wms_width</ogc:Literal>
                            </ogc:Function>
                        </ogc:Function>
                        <ogc:Function name="parameter">
                            <ogc:Literal>outputHeight</ogc:Literal>
                            <ogc:Function name="env">
                                <ogc:Literal>wms_height</ogc:Literal>
                            </ogc:Function>
                        </ogc:Function>
                    </ogc:Function>
                </Transformation>

                <Rule>
                    <MinScaleDenominator>70000</MinScaleDenominator>
                    <Name>Point group cluster</Name>
                    <Title>Realties group</Title>
                    <TextSymbolizer>
                        <Label>
                            <ogc:PropertyName>count</ogc:PropertyName>
                        </Label>
                        <Font>
                            <CssParameter name="font-family">Arial</CssParameter>
                            <CssParameter name="font-size">12</CssParameter>
                            <CssParameter name="font-weight">bold</CssParameter>
                        </Font>
                        <LabelPlacement>
                            <PointPlacement>
                                <AnchorPoint>
                                    <AnchorPointX>0.5</AnchorPointX>
                                    <AnchorPointY>0.8</AnchorPointY>
                                </AnchorPoint>
                            </PointPlacement>
                        </LabelPlacement>
                        <Fill>
                            <CssParameter name="fill">#000</CssParameter>
                            <CssParameter name="fill-opacity">1.0</CssParameter>
                        </Fill>
                        <VendorOption name="partials">true</VendorOption>
                    </TextSymbolizer>
                    <PointSymbolizer>
                        <Graphic>
                            <Mark>
                                <WellKnownName>circle</WellKnownName>
                                <Fill>
                                    <CssParameter name="fill">#1E90FF</CssParameter>
                                    <CssParameter name="fill-opacity">0.75</CssParameter>
                                </Fill>
                            </Mark>
                            <Size>
                                <ogc:Add>
                                    <ogc:Literal>25</ogc:Literal>
                                    <ogc:Mul>
                                        <ogc:Function name="log">
                                           <ogc:PropertyName>count</ogc:PropertyName>
                                        </ogc:Function>
                                        <ogc:Literal>5</ogc:Literal>
                                    </ogc:Mul>
                                </ogc:Add>
                            </Size>
                        </Graphic>
                    </PointSymbolizer>
                </Rule>
            </FeatureTypeStyle>

        </UserStyle>
    </NamedLayer>
</StyledLayerDescriptor>

Для сравнения представлены изображения с кластеризацией объектов и без неё.

Также кластеризация позволила значительно увеличить производительность системы. Рендер большого числа отдельных маркеров выполнялся медленно и существенно нагружал процессор. Часто соединение обрывалось по 504. Объединение в кластеры работает очень быстро без нагрузки на систему.

Кластеризованный результат (полная карта) загружается в среднем за 1.6 секунд. Тогда как отдельные маркеры грузились порядка 130 секунд.

Загрузка кластеризированных маркеров

Load Time	First Byte	Start Render	Speed Index	Interactive (beta)	Time	Requests	Bytes In
1.647s	1.557s	3.718s	3718	> 3.763s	1.677s	2	9 KB

Загрузка отдельных маркеров

Load Time	First Byte	Start Render	Speed Index	Interactive (beta)	Time	Requests	Bytes In
130.397s	8.268s	21.934s	57691	8.445s	130.397s	1	960 KB

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

Простой чат на AioHTTP

2017-04-10T15:00:00+03:00

В повседневной работе я тесно связан с Python 3, но такие его замечательные возможности, как асинхронность asyncio и синтаксический сахар PEP 492 использовать не приходиться. Из асинхронных задач сталкиваюсь только с Celery, но это не совсем та асинхронность, скорее бэкграунд с очередью задач выполняемых воркерами синхронно. Пришло время исправить это и поближе познакомится с асинхронностью в Python 3.5+. Сделаем это на примере простого чата с комнатами.

Постановка задачи

Реализовать простой асинхронный чат с комнатами на WebSocket-ах.

Необходимый функционал:

Создать пользователя или авторизоваться под существующим.
Создать комнату или подключиться к уже существующей.
Иметь возможность видеть всю историю чат комнаты. В том числе подключения и отключения пользователей от комнаты.
Администрирование комнаты.

Технологии

Для реализации чата будем использовать Python 3.6 и фреймворк AioHTTP, данные хранить в базе PostgreSQL, текущие сессии в Redis, запросы проксировать через Nginx.

Асинхронный фреймворк

Текущая версия AioHTTP 2.0.6, однако оказалось, что с ней несовместима текущая версия AioHTTP debugtoolbar issue #115. Так что будем использовать предыдущую версию AioHTTP 1.3.5.

Простейшее приложение на AioHTTP выглядит так:

from aiohttp import web

async def handler(request):
    name = request.match_info.get('name', "Anonymous")
    text = "Hello, " + name
    return web.Response(text=text)

app = web.Application()
app.router.add_route('GET', '/', handler)
app.router.add_route('GET', '/{name}', handler)

web.run_app(app)

Как можно заметить, роуты конфигурируются после инициализации приложения. Url аргументы задаются подобно форматированию строк {slug}.

В момент создания приложения можно указать middlewares, передав их в конструктор приложения.

app = web.Application(loop=loop, middlewares=middlewares)

База данных и модели

В качестве базы данных используем PostgreSQL, для работы с которой воспользуемся PeeWee ORM и асинхронным менеджером, PeeWee Async.

Создадим базовую модель с неинициализированной базой. Саму базу инициализируем в момент конфигурирования приложения.

import peewee
import peewee_async


database = peewee_async.PostgresqlDatabase(None)


class BaseModel(peewee.Model):

    """ Base model with db Meta """

    class Meta:
        database = database

import peewee_async
from helpers.models import database

DATABASE = {
    'database': 'aiochat',
    'password': 'supersecret',
    'user': 'aiochat_user',
    'host': 'localhost',
}

# ...

database.init(**DATABASE)
app.database = database
app.database.set_allow_sync(False)
app.objects = peewee_async.Manager(app.database)

Сама идея Менеджера базы данных взята из Django, но в PeeWee Async работает это немного по-другому и с непривычки вызывает недоумение.

High-level API provides a single point for all async ORM calls. Meet the Manager class! The idea of Manager originally comes from Django, but it’s redesigned to meet new asyncio patterns.

# Django manager
user = User.objects.get(username__iexact='Alice')

# Pee Wee manager
user = await objects.get(User, User.username ** 'Alice')

Через менеджер вызываются асинхронные запросы, но через контекст можно провести синхронный запрос, например, создание таблицы.

with objects.allow_sync():
    User.create_table(True)

Шаблоны и пути

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

import jinja2
import aiohttp_jinja2

# ...

jinja_env = aiohttp_jinja2.setup(
    app, loader=jinja2.FileSystemLoader(settings.TEMPLATE_DIR),
    context_processors=[aiohttp_jinja2.request_processor], )

Рендер шаблона изящно спрятан в декоратор для вьюхи.

import aiohttp_jinja2
from aiohttp import web

class Index(web.View):

    @aiohttp_jinja2.template('template_name.html')
    async def get(self):
        # return context for render
        return {'foo': 'boo'}

Routes, как уже было сказано выше, конфигурируются после инициализации приложения. Через функциию app.router.add_route. Несмотря на то, что статику у нас будет отдавать Nginx, задаем её специальным роутом add_static, чтобы в шаблонах иметь возможность подключать статические файлы.

# urls.py
from accounts.urls import routes as accounts_routes
from chat.urls import routes as chat_routes

from views import Index

routes = (
    dict(method='GET', path='/', handler=Index, name='index'),
    * accounts_routes,
    * chat_routes,
)

# app.py
from urls import routes
for route in routes:
    app.router.add_route(**route)
app.router.add_static('/static', settings.STATIC_DIR, name='static')

В шаблоне получаем доступ к роутам, через объект app.

<a href="{{ app.router['index'].url_for() }}">Main page</a>

<link href="{{ app.router.static.url(filename='chat.css') }}" rel="stylesheet">
<script src="{{ app.router.static.url(filename='chat.js') }}"></script>

Сессии

Для работы с сессиями будем использовать aiohttp session. Данная библиотека позволяет на выбор работать с cookies или redis хранилищами. Мне больше нравится redis. Для подключения потребуется библиотека aioredis.

Подключим сессии и редис.

import aioredis

from aiohttp_session import session_middleware
from aiohttp_session.redis_storage import RedisStorage

# ...

redis_pool = await aioredis.create_pool(settings.REDIS_CON, loop=loop)
middlewares = [session_middleware(RedisStorage(redis_pool))]

Чтобы получить текущюю сессию, нужно дождаться ответа из корутины get_session. Мне нравится подход в джанго, когда в каждом объекте Запрос есть прямой доступ к сессии и пользователю. Сделаем подобное в aiohttp с помощью middlewares.

from aiohttp_session import get_session
from accounts.models import User


async def request_user_middleware(app, handler):
    async def middleware(request):
        request.session = await get_session(request)
        request.user = None
        user_id = request.session.get('user')
        if user_id is not None:
            request.user = await request.app.objects.get(User, id=user_id)
        return await handler(request)
    return middleware

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

from aiohttp import web
from helpres.tools import redirect

def login_required(func):
    """ Allow only auth users """
    async def wrapped(self, *args, **kwargs):
        if self.request.user is None:
            redirect(self.request, 'login')
        return await func(self, *args, **kwargs)
    return wrapped


def anonymous_required(func):
    """ Allow only anonymous users """
    async def wrapped(self, *args, **kwargs):
        if self.request.user is not None:
            redirect(self.request, 'index')
        return await func(self, *args, **kwargs)
    return wrapped

В данных декораторах используем функцию redirect, она вызывает исключение, которое пораждает редирект. В AioHTTP можно вызвать лобой из web исключений это сделано круче, чем в Django, где есть возможность вернуть только 404, 403 и 400 через исключения Http404, PermissionDenied, SuspiciousOperation соответсвенно, а редирект должен быть отдан явным ответом.

from aiohttp import web

def redirect(request, router_name, *, permanent=False, **kwargs):
    """ Redirect to given URL name """
    url = request.app.router[router_name].url(**kwargs)
    if permanent:
        raise web.HTTPMovedPermanently(url)
    raise web.HTTPFound(url)

WebSockets

В AioHTTP реализованы вебсокеты через web.WebSocketResponse(), работа с ними практически не отличается от обычных вьюх, разве что добавляется асинхронный цикл пока соединение активно.

async def wshandler(request):
    ws = web.WebSocketResponse()
    await ws.prepare(request)

    async for msg in ws:
        if msg.type == web.MsgType.text:
            await ws.send_str("Hello, {}".format(msg.data))
        elif msg.type == web.MsgType.binary:
            await ws.send_bytes(msg.data)
        elif msg.type == web.MsgType.close:
            break

    return ws

Для хранения текущих соединений и рассылки бродкаст сообщений, будем использовать объект app.

ws = web.WebSocketResponse()
await ws.prepare(self.request)
request.app.wslist.append(ws)

# ...

async def broadcast(self, message):
    """ Send messages to all in this room """
    for peer in self.request.app.wslist:
        peer.send_json(message.as_dict())

По умолчанию Nginx не проксирует заголовки Upgrade и Connection, которые используются при переключении на WS запрос.

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

server {
    # ...

    location / {
        proxy_pass          http://localhost:8000;
        proxy_set_header    Host $host;
        proxy_set_header    X-Real-IP $remote_addr;

        # ws support
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_read_timeout 1h;
    }
}

Тестирование

Тестировать приложение AioHTTP можно разными способами. Мне нравится подход Unittest. Единственная особенность: нужно добавить метод get_application и объявлять асинхронные тесты, декарируя их через unittest_run_loop.

from aiohttp.test_utils import AioHTTPTestCase, unittest_run_loop
from app import create_app


class AioChatTestCase(AioHTTPTestCase):

    """ Base test case for aiochat """

    async def get_application(self, loop):
        """ Return current app """
        serv_generator, handler, app = await create_app(loop)
        return app


class IndexTestCase(AioChatTestCase):

    """ Testing index app views """

    url_name = 'index'

    def setUp(self):
        super().setUp()
        self.url = self.app.router[self.url_name].url_for()

    @unittest_run_loop
    async def test_url_reversed(self):
        """ Url should be / """
        self.assertEqual(str(self.app.router[self.url_name].url_for()), '/')
        self.assertEqual(str(self.url), '/')

    @unittest_run_loop
    async def test_index(self):
        """ Should get 200 on index page """
        response = await self.client.get('/')
        self.assertEqual(response.status, 200)
        content = await response.text()
        self.assertIn('Simple asyncio chat', content)

Cоздание тестовой базы данных через PeeWee Async оказалось не очень удобно, поэтому тесты будут весьма поверхностные, только чтобы обозначить общий подход к тестированию приложения на AioHTTP.

Функциональная часть

Основная функциональность чата — передача сообщений клиентам в пределах комнаты.

class WebSocket(web.View):

    """ Process WS connections """

    async def broadcast(self, message):
        """ Send messages to all in this room """
        for peer in self.request.app.wslist[self.room.id].values():
            peer.send_json(message.as_dict())

    async def get(self):
        self.room = await get_object_or_404(
            self.request, Room, name=self.request.match_info['slug'].lower())
        user = self.request.user
        app = self.request.app

        # При подключении создаем WebSocketResponse
        ws = web.WebSocketResponse()
        await ws.prepare(self.request)
        if self.room.id not in app.wslist:
            # Создаем пустую комнату если ещё нет
            app.wslist[self.room.id] = {}

        # Сохраняем соединение в объекте app и создаем сервисное сообщение
        app.wslist[self.room.id][user.username] = ws
        message = await app.objects.create(
            Message, room=self.room, user=None, text=f'{user} join chat room')

        # Рассылка всем подключенным клиентам
        await self.broadcast(message)

        # В асинхронном цикле слушаем сообщения от текущего сокета
        async for msg in ws:
            if msg.tp == MsgType.text:
                if msg.data == 'close':
                    await ws.close()
                else:
                    # Сохраняем сообщение в базу и шлем бродкаст
                    message = await app.objects.create(
                        Message, room=self.room, user=user, text=text)
                    await self.broadcast(message)

        # Когда соединение закрывается, удаляем пользователя из сохраненных соединений
        app.wslist.pop(user.username, None)

        # Сервисное сообщение об отключении в бродкаст
        message = await app.objects.create(
            Message, room=self.room, user=None, text=f'{user} left chat room')
        await self.broadcast(message)

        # возвращаем WebSocketResponse
        return ws

В качестве администрирования комнаты, добавим возможность выполнять команды пользователей. Возьмем две простые команды: очистить историю комнаты и удалить пользователя из комнаты.

async def command(self, cmd):
    """ Run chat command """
    app = self.request.app
    if cmd.startswith('/kill'):
        # unconnect user from room
        try:
            target = cmd.split(' ')[1]
            # Найдем пользователя по имени и отключим от чата
            peer = app.wslist[self.room.id][target]
            await self.disconnect(target, peer, silent=True)
        except KeyError:
            pass
    elif cmd == '/clear':
        # Удалим все сообщения из комнаты
        count = await app.objects.execute(
            Message.delete().where(Message.room == self.room))
        # В бродкаст вышлем пользователям команды для очистки истории на клиенте
        for peer in app.wslist[self.room.id].values():
            peer.send_json({'cmd': 'empty'})
    elif cmd == '/help':
        # Вспомогательная команда для отображения справки
        return {'text': dedent('''\
            - /help - display this msg
            - /kill {username} - remove user from room
            - /clear - empty all messages in room
            ''')}
    else:
        return {'text': 'wrong cmd {cmd}'}

В асинхронном цикле будем сравнивать, если сообщение начинается с / значит обрабатывать его как команду.

async for msg in ws:
    # ...
    text = msg.data.strip()
    if text.startswith('/'):
        ans = await self.command(text)
        if ans is not None:
            ws.send_json(ans)
    else:
        message = await app.objects.create(Message, room=self.room, user=user, text=text)
        await self.broadcast(message)

Клиент

Браузерный клиент это простое WebSocket подключение с определенными командами на отправку и отображение сообщений.

var sock = new WebSocket('ws://' + window.location.host + WS_URL);

function showMessage(message) {
    /* Append message to chat area */
    console.log(message);
    var data = jQuery.parseJSON(message.data);
    $messagesContainer.append('<li class="media">' + data.text + '</li>');
    $chatArea.scrollTop($messagesContainer.height());
}

// ...

$('#send').on('submit', function (event) {
    event.preventDefault();
    var $message = $(event.target).find('input[name="text"]');
    sock.send($message.val());
    $message.val('').focus();
});

sock.onopen = function (event) {
    console.log(event);
    console.log('Connection to server started');
};

sock.onclose = function (event) {
    console.log(event);
    if(event.wasClean){
        console.log('Clean connection end');
    } else {
        console.log('Connection broken');
    }
    window.location.assign('/');
};

sock.onerror = function (error) {
    console.log(error);
};

sock.onmessage = showMessage;

Результат и критика

Как выяснилось, асинхронный код в Python 3 практически не отличается от синхронного. Работать с ним легко и весело. WebSocket вызывает отдельный восторг, позволяя отправлять сообщения клиентам со стороны сервера без явного запроса.

AioHTTP позволяет легко реализовать простой асинхронный сервер с WebSocketами, но что-то большое я бы не стал на на нем писать, иначе всё начнет превращаться в сплошную рутину-корутины.

Полный пример чата можно посмотреть в репозитории на github Samael500/aiochat, а при желании поиграться, запустив настроенный Vagrant.

Данный чат создан исключительно в ознакомительных целях, поэтому имеет ряд допущений:

Регистрация и авторизация пользователей без паролей и каких-либо подтверждений.
Каждый пользователь имеет полные права администрирования комнат.
Нет нормальной валидации форм на создание пользователя или комнаты.
Команды чата реализованы без валидации формата команды.
История комнаты отдается без паджинации вся полностью, при хоть сколь-либо большом числе комнат/пользователей/сообщение, эти запросы будут выполнятmся долго, создавая нагрузку как на сервер, так и на клиент.
Подключения вебсокетов хранятся в едином объекте APP, что тоже создает лишние проблеммы при большом числе полдключений и комнат. Рационально в данном случае разпараллеливать комнаты между разными инстансами приложения.

Обработка вебхуков GitHub с помощью Nginx и Lua

2017-03-31T15:00:00+03:00

После того как принимается pull-request и наработки кода попадают в мастер, нужно обновить сервер, выполнив на нем команды деплоя. Обычно у нас эта обязанность возложена на сервер CI TeamCity, который в случае успешного билда мастер ветки накатывает изменения на продакшен сервера. Но иногда не нужно такое сложное взаимодействие, а достаточно просто знать факт пуша в мастер и обработать его самостоятельно. С помощью вебхуков GitHub может уведомлять о push событиях в репозитории. Но для валидации и обработки этих запросов нужен какой-либо бекенд. В этом мне помогает знакомая связка Nginx + Lua.

Предварительная настройка

Нам понадобятся Nginx с модулем lua-nginx-module. И две дополнительные библиотеки для lua. Для того чтобы прочесть json тело запроса используем JSON4Lua, а для валидации подписи LuaCrypto. Установим их через менеджер пакетов luarocks.

$ sudo luarocks install JSON4Lua
$ sudo luarocks install luacrypto

Подробнее о том как настроить Nginx и Lua можно прочитать в статье.

Наш сервер

Сконфигурируем локейшн для принятия вебхука.

server {

    # ...

    location /deploy {
        client_body_buffer_size 3M;
        client_max_body_size  3M;
        content_by_lua_file /path/to/handler.lua;
    }
}

Важно установить значения client_body_buffer_size и client_max_body_size одинаковыми. Для корректного чтения тела запроса и предотвращения ошибки работы с временным файлом.

lua entry thread aborted: runtime error: requesty body in temp file not supported

GitHub hooks

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

Валидация запроса

Проверка корректности запроса. В первую очередь нужно убедиться, что запрос действительно POST. Сделаем это с помощью функции req.get_method.

-- should be POST method
if ngx.req.get_method() ~= "POST" then
    ngx.log(ngx.ERR, "wrong event request method: ", ngx.req.get_method())
    return ngx.exit (ngx.HTTP_NOT_ALLOWED)
end

Следующим шагом проверим, что этот запрос содержит заголовок с хук методом. Получив все заголовки с помощью функции req.get_headers.

local event = 'push'

-- ...

local headers = ngx.req.get_headers()
-- with correct header
if headers['X-GitHub-Event'] ~= event then
    ngx.log(ngx.ERR, "wrong event type: ", headers['X-GitHub-Event'])
    return ngx.exit (ngx.HTTP_NOT_ACCEPTABLE)
end

Так как мы будем слушать вебхуки в формате json, проверим контент тип запроса.

-- should be json encoded request
if headers['Content-Type'] ~= 'application/json' then
    ngx.log(ngx.ERR, "wrong content type header: ", headers['Content-Type'])
    return ngx.exit (ngx.HTTP_NOT_ACCEPTABLE)
end

По первичным признакам запрос корректный. Проанализируем тело запроса. С помощью функций req.read_body и req.get_body_data.

-- read request body
ngx.req.read_body()
local data = ngx.req.get_body_data()

if not data then
    ngx.log(ngx.ERR, "failed to get request body")
    return ngx.exit (ngx.HTTP_BAD_REQUEST)
end

Проверим корректность подписи запроса, которая передается в заголовке X-Hub-Signature, используя функцию verify_signature.

-- validate GH signature
if not verify_signature(headers['X-Hub-Signature'], data) then
    ngx.log(ngx.ERR, "wrong webhook signature")
    return ngx.exit (ngx.HTTP_FORBIDDEN)
end

Последний шаг - убедиться, что этот push был в интересующей нас ветке. Разобрав тело запроса в таблицу lua с помощью функции json.decode.

local branch = 'refs/heads/master'

-- ...

data = json.decode(data)
-- on master branch
if data['ref'] ~= branch then
    ngx.say("Skip branch ", data['ref'])
    return ngx.exit (ngx.HTTP_OK)
end

Проверка подписи

Для подтверждения корректности запроса, GitHub использует HMAC SHA1 подпись и передает её в заголовке X-Hub-Signature, пример в документации.

Вызовем функцию crypto.hmac.digest и сравним её результат с полученным заголовком.

local secret = '<MY SUPER SECRET>'

-- ...

local function verify_signature (hub_sign, data)
    local sign = 'sha1=' .. crypto.hmac.digest('sha1', data, secret)
    return hub_sign == sign
end

Константное сравнение строк

Простое сравнение строк на == использовать не рекомендуется, т.к. злоумышленник может провести атаку по времени.

В lua нельзя просто так взять и обратиться к строке по индексу. Так что для удобства внедрим данную функцию в метакласс строки.

getmetatable('').__index = function (str, i)
    return string.sub(str, i, i)
end

Напишем функцию сравнения строк за “константное” время. Строки равны тогда и только тогда, когда равны посимвольно.

local function const_eq (a, b)
    -- Check is string equals, constant time exec
    local equal = string.len(a) == string.len(b)
    for i = 1, math.max(string.len(a), string.len(b)) do
        equal = (a[i] == b[i]) and equal
    end
    return equal
end

Автоматический деплой

В случае, если webhook прошел все валидации, можно ему доверять. Через системный вызов io.popen выполним необходимые команды деплоя. В данном примере осуществляется простой pull из репозитория.

local function deploy ()
    local handle = io.popen("cd /path/to/repo && sudo -u username git pull")
    local result = handle:read("*a")
    handle:close()

    ngx.say (result)
    return ngx.exit (ngx.HTTP_OK)
end

Полный пример handler.lua можно посмотреть в gist или вопросе на StackOverflow.

Сам себе почтальон

2017-02-28T15:00:00+03:00

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

На этапе разработки проекта в качестве почтового сервера мы используем DebugMail сервис, который позволяет без настройки своего smtp сервера отправлять тестовые письма.

Письма, письма лично на почту ношу…

Установим свой почтовый сервер, будем использовать простой и удобный PostFix.

$ sudo apt-get install postfix

В интерактивном режиме указываем тип и домен нашего сервера.

Для дальнейшей настройки скопируем базовый конфигурационный файл для debian. И добавим доступ только из локального хоста.

$ sudo cp /usr/share/postfix/main.cf.debian /etc/postfix/main.cf
$ echo "
mynetworks = 127.0.0.0/8 [::ffff:127.0.0.0]/104 [::1]/128
mydestination = localhost
" | sudo tee -a /etc/postfix/main.cf
$ sudo service postfix reload

По умолчанию у postfix открыт 25 порт из внешнего мира, закроем его, отредактировав /etc/postfix/master.cf.

--- /etc/postfix/master.cf
+++ /etc/postfix/master.cf
@@ -10,7 +10,7 @@
 #               (yes)   (yes)   (yes)   (never) (100)
 # ==========================================================================
 # smtp      inet  n       -       -       -       -       smtpd
-smtp               inet  n       -       n       -       -       smtpd
+127.0.0.1:smtp     inet  n       -       n       -       -       smtpd
 #smtp      inet  n       -       -       -       1       postscreen
 #smtpd     pass  -       -       -       -       -       smtpd
 #dnsblog   unix  -       -       -       -       0       dnsblog

Теперь можем попробовать отправить свое первое письмо с собственного сервера. Воспользуемся для этого стандартной библиотекой python SMTPLib.

import smtplib

from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

text_part = MIMEText('There are test mail text content', 'plain')
html_part = MIMEText('''
<html>
  <head></head>
  <body>
    <h1>Hello from Earth<h1>
    <p>There are test mail html content.</p>
    <p style="color:red">have a good day ;)</p>
  </body>
</html>
''', 'html')

from_, to_ = 'from@some.com', 'to@other.org'

msg = MIMEMultipart('alternative')

msg['Subject'] = 'Hello from Earth'
msg['From'] = from_
msg['To'] = to_

msg.attach(text_part)
msg.attach(html_part)

host = 'localhost'
conn = smtplib.SMTP(host)
conn.sendmail(from_, [to_], msg.as_string())
conn.quit()

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

Подключим tls шифрование писем, добавив следующие строки в /etc/postfix/main.cf

smtpd_tls_security_level = may
smtp_tls_security_level = may
smtp_tls_loglevel = 1
smtpd_tls_loglevel = 1

smtpd_tls_CAfile = /etc/letsencrypt/live/example.com/chain.pem
smtpd_tls_cert_file = /etc/letsencrypt/live/example.com/cert.pem
smtpd_tls_key_file = /etc/letsencrypt/live/example.com/privkey.pem

smtp_tls_session_cache_database = btree:/var/lib/postfix/smtp_scache

smtp_tls_mandatory_exclude_ciphers = aNULL, MD5 , DES, ADH, RC4, PSD, SRP, 3DES, eNULL
smtp_tls_mandatory_protocols = !SSLv2, !SSLv3, !TLSv1, !TLSv1.1
smtp_tls_protocols=!SSLv2, !SSLv3, !TLSv1, !TLSv1.1
smtp_tls_mandatory_ciphers=high
tls_high_cipherlist=EDH+CAMELLIA:EDH+aRSA:EECDH+aRSA+AESGCM:EECDH+aRSA+SHA384:EECDH+aRSA+SHA256:EECDH:+CAMELLIA256:+AES256:+CAMELLIA128:+AES128:+SSLv3:!aNULL:!eNULL:!LOW:!3DES:!MD5:!EXP:!PSK:!DSS:!RC4:!SEED:!ECDSA:CAMELLIA256-SHA:AES256-SHA:CAMELLIA128-SHA:AES128-SHA
tls_random_source = dev:/dev/urandom

Здесь нам понадобятся сертификаты, можно подписать их самостоятельно, но проще и надежнее использовать бесплатные сертификаты от Let’s Encrypt. Подробнее о том как их получать в статье Давайте шифровать.

После настройки перезапускаем postfix и проверяем доступность tls.

$ openssl s_client -starttls smtp -showcerts -connect localhost:25

CONNECTED(00000003)
depth=1 C = US, O = Let's Encrypt, CN = Let's Encrypt Authority X3
verify error:num=20:unable to get local issuer certificate
---
Certificate chain
 0 s:/CN=example.com
   i:/C=US/O=Let's Encrypt/CN=Let's Encrypt Authority X3
-----BEGIN CERTIFICATE-----
<cert content>
-----END CERTIFICATE-----
 1 s:/C=US/O=Let's Encrypt/CN=Let's Encrypt Authority X3
   i:/O=Digital Signature Trust Co./CN=DST Root CA X3
-----BEGIN CERTIFICATE-----
<cert content>
-----END CERTIFICATE-----
---
Server certificate
subject=/CN=example.com
issuer=/C=US/O=Let's Encrypt/CN=Let's Encrypt Authority X3
---
No client certificate CA names sent
Peer signing digest: SHA512
Server Temp Key: ECDH, P-256, 256 bits
---
SSL handshake has read 3884 bytes and written 468 bytes
---
New, TLSv1/SSLv3, Cipher is ECDHE-RSA-AES256-GCM-SHA384
Server public key is 4096 bit
Secure Renegotiation IS supported
Compression: NONE
Expansion: NONE
No ALPN negotiated
SSL-Session:
    Protocol  : TLSv1.2
    Cipher    : ECDHE-RSA-AES256-GCM-SHA384
    Session-ID: 9C05050D143CE1474438AEC0A57BD8303953053608ECD5775B565A26455EDADB
    Session-ID-ctx: 
    Master-Key: D6A09F3AC016E489542EAA11E9EFF7B56118D24F849FD480B26E219322E8D97D43DE7C537E9B928A67DDCAD3F9397EC6
    Key-Arg   : None
    PSK identity: None
    PSK identity hint: None
    SRP username: None
    TLS session ticket lifetime hint: 7200 (seconds)
    TLS session ticket:
    0000 - cd a5 c1 43 13 c9 2c 4b-7e 14 f6 53 92 86 89 29   ...C..,K~..S...)
    0010 - 88 dc ae cc d4 61 a1 4c-ec 05 b1 61 94 0c b1 6c   .....a.L...a...l
    0020 - 13 57 84 63 0f e4 6a d7-da 08 45 7e 80 3e fd d7   .W.c..j...E~.>..
    0030 - 16 82 70 d5 e4 8a bd ba-6f 9d b9 6f d9 49 56 b7   ..p.....o..o.IV.
    0040 - d4 41 5a c7 27 53 82 b5-8d 5d 22 08 38 3c a5 59   .AZ.'S...]".8<.Y
    0050 - 6b 06 e7 5f ba 36 2f 91-44 85 7a 5d 1c e4 da d9   k.._.6/.D.z]....
    0060 - 90 78 64 10 63 6a df c9-79 8d d9 10 66 dc 24 74   .xd.cj..y...f.$t
    0070 - fb 5a f6 f5 02 14 c5 d5-b0 b3 65 57 24 01 f2 bd   .Z........eW$...
    0080 - 06 31 f9 a9 e3 32 42 ad-f0 3b b5 3d 39 77 2c 95   .1...2B..;.=9w,.
    0090 - 8f fd e9 4f c9 4c 1d 77-8e 23 e4 ca 48 e8 9f ed   ...O.L.w.#..H...

    Start Time: 1489229346
    Timeout   : 300 (sec)
    Verify return code: 20 (unable to get local issuer certificate)
---
250 DSN

QUIT
DONE

Подписываюсь под каждым словом…

На сегодняшний день, считается обязательной подпись электронных писем с помощью DKIM. Это делается для того, чтобы почтовый сервер получателя мог удостоверится в том, что почта отправлена именно с сервера указанного в поле From.

Установка и настройка OpenDKIM

Устанавливаем необходимые пакеты, OpenDKIM.

$ sudo apt-get install opendkim opendkim-tools

Генерируем ключи и сохраняем их доступными для чтения группе opendkim, а также добавляем в эту группу postfix.

$ sudo mkdir /etc/opendkim
$ sudo opendkim-genkey -D /etc/opendkim -d $(hostname -d) -s $(hostname)
$ sudo chgrp opendkim /etc/opendkim/*
$ sudo chmod g+r /etc/opendkim/*
$ sudo gpasswd -a postfix opendkim

Теперь указываем opendkim где находятся ключи. Для этого дописываем в конфигурационный файл /etc/opendkim.conf следующие строки.

Canonicalization relaxed/relaxed
SyslogSuccess yes
RequireSafeKeys false
KeyTable file:/etc/opendkim/keytable
SigningTable file:/etc/opendkim/signingtable
X-Header yes

Подробнее ознакомится с возможными параметрами можно в документации.

Теперь заполним таблицы ключей в файлах /etc/opendkim/keytable и /etc/opendkim/signingtable. Они указывают соответсвие между доменом и ключем, которым необходимо подписывать письмо.

# /etc/opendkim/keytable
ключ домен:селектор:/путь/до/ключа

# /etc/opendkim/signingtable
домен ключ

Например:

# /etc/opendkim/keytable
mail._domainkey.example.com example.com:mail:/etc/opendkim/mail.private

# /etc/opendkim/signingtable
example.com    mail._domainkey.example.com

Настройка Postfix для работы с OpenDKIM

Указываем о необходимости подписывать все письма с помощью dkim.

$ sudo postconf -e milter_default_action=accept
$ sudo postconf -e milter_protocol=2
$ sudo postconf -e smtpd_milters=unix:/var/run/opendkim/opendkim.sock
$ sudo postconf -e non_smtpd_milters=unix:/var/run/opendkim/opendkim.sock

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

$ sudo service postfix restart
$ sudo service opendkim restart

Настроийки доменной зоны

Чтобы сервер мог удостовериться в корректности подписи, нужно добавить TXT запись содежащую ключ. Сделать это нужно в контрольной панели регистратора. Проверим, что dns зоны обновились.

$ dig +short TXT mail._domainkey.example.com
"v=DKIM1; k=rsa; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCvfTJ37Gqs06fhG0YYj/6HbojCrDp
F8X6u20YUaOax+jrvO0KtItfWYUi6hkCJeKbGTAOmqhWLu1T/DMt0XaICAJ7Q8525Z4ghwfvc5LgYyNSDEODeF
LNPlXgn3IP5o6Og2We/SnO4QCv8drKGf0N2xm5IIzIT8CjsbM6gPQIHTQIDAQAB"

Также хорошо указать разрешенные ip адреса для исходящих писем в запись spf.

$ dig +short TXT example.com
"v=spf1 a:example.com ip4:<ip v4 addr> ip6:<ip v6 addr> ~all"

Все не как у людей

Сегодня мы живем в далеком и почти светлом будущем, когда по бескрайним просторам сети широко распространяется ipv6 адресация. Но, оказывается, абсолютно все письма отправленные с ipv6 всегда воспринимаются гуглом как спам. Даже пройдя верификацию по dkim и spf записям, всеравно уходят в нежелательную почту.

Так что укажем в конфигурации postfix отправку только с использованием ipv4.

$ sudo postconf -e inet_protocols=ipv4

Теперь письма успешно доставляются и проходят все валидации.

Пример письма

Delivered-To: samael500@gmail.com
Received: by 10.182.174.67 with SMTP id bq3csp1452226obc;
        Tue, 28 Feb 2017 08:09:52 -0800 (PST)
X-Received: by 10.46.22.18 with SMTP id w18mr1151641ljd.86.1488298192253;
        Tue, 28 Feb 2017 08:09:52 -0800 (PST)
Return-Path: <info@*********>
Received: from ********* (*********. [**.**.**.**])
        by mx.google.com with ESMTPS id x14si1225569lfd.155.2017.02.28.08.09.51
        for <samael500@gmail.com>
        (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128);
        Tue, 28 Feb 2017 08:09:52 -0800 (PST)
Received-SPF: pass (google.com: domain of info@********* designates **.**.**.** as permitted sender) client-ip=**.**.**.**;
Authentication-Results: mx.google.com;
       dkim=pass header.i=*********;
       spf=pass (google.com: domain of info@********* designates **.**.**.** as permitted sender) smtp.mailfrom=info@*********
Received: from ********* (localhost [127.0.0.1])
    by ********* (Postfix) with ESMTP id D9ED0452AB
    for <samael500@gmail.com>; Tue, 28 Feb 2017 16:09:53 +0000 (UTC)
DKIM-Filter: OpenDKIM Filter v2.9.2 ********* D9ED0452AB
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=*********;
    s=mail; t=1488298193;
    bh=juRoCRHzIAJJ4fKO8VlXEyxNddxTS8ftBnWmLxjdAik=;
    h=Subject:From:To:Date:From;
    b=G0Z6uXOV0LQHscdUOwMg5rjuJA/KWZ7x6Iqx3Z2x01nZ2kD+E1OgyP4zEfqS9XDiS
     fG04P0qpIJyGEmO8hgRDIlH1d5FIDGjGPMAFDynwZ9j7pG1h88yLHThdtesUN7Fjib
     2yL1xxiyw2dZbtfvgXwhj0Nb9RXpphrY+c9v2fW4=
Content-Type: multipart/alternative;
 boundary="===============3211535685628593130=="
MIME-Version: 1.0
Subject: Hello from Earth
From: info@*********
To: samael500@gmail.com
Message-Id: <20170228160953.D9ED0452AB*********>
Date: Tue, 28 Feb 2017 16:09:53 +0000 (UTC)

--===============3211535685628593130==
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit

There are test mail text content
--===============3211535685628593130==
Content-Type: text/html; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit


<html>
  <head></head>
  <body>
    <h1>Hello from Earth<h1>
    <p>There are test mail html content.</p>
    <p style="color:red">have a good day ;)</p>
  </body>
</html>

--===============3211535685628593130==--

Django settings

Теперь можно подключить отправку писем через наш smtp в джанго.

EMAIL_HOST = 'localhost'
EMAIL_PORT = 25
EMAIL_HOST_USER = ''
EMAIL_HOST_PASSWORD = ''
EMAIL_USE_TLS = False
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'

DEFAULT_FROM_EMAIL = 'info@example.com'

Три года в команде

2017-01-18T15:00:00+03:00

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

Встреча WB—Tech в Севастополе. Февраль 2016 г.

Как я попал в WBT

Началось всё в конце 2013 года, я тогда учился на 1-м курсе магистратуры, а знания python были весьма поверхностными. Скажи мне кто тогда, что я буду веб-разработчиком, ни за что не поверил бы. Тогда я воспринимал программный продукт как единую алгоритмическую структуру с четко ограниченными точками входа и выхода. Идея независимых обработчиков с различными точками входа, решающих конкретные подзадачи, казалась мне чуждой.

— Почему обезьяна может программировать на PHP?
— Потому что она всю жизнь прыгает с ветки на ветку, с лианы на лиану, независимые обработчики с различными точками входа — это её повседневное окружение.

Мне предложили пройти стажировку в вебтек, а для поступления выполнить простое тестовое задание: создать сайт на django с парой моделей и несколькими вьюхами. Даже сохранился репозиторий с этим заданием github.com:Samael500/todo-test-task.

Заканчивался семестр, нужно было сдавать зачеты, впереди предстояли новогодние каникулы, на которые я уехал из города, а по возвращению пошел на практику в 1С-Рарус, где занятия проходили с утра до вечера. Так что выполнение тестового задания слегка затянулось… более чем на месяц. Примерно на третий день в рарусе я вспомнил о тестовом задании и наконец решил его сделать, к тому же срок уже поджимал.

В то время, я плохо знал python, не сталкивался с django, не было опыта работы с linux и git. Но взяв за основу django tutorial, за несколько дней тестовое задание было полностью готово. За одним исключением: не было произведено ни одного коммита. Пришло время закоммитить результаты работы и как говорится, ничто не предвещало беды.

$ git add .
$ git status
$ # тут оказался длинный список не нужных файлов, т.к. я забыл доавить .gitignore
$ # я решил удалить лишнее, но вместо git reset, я совершил ошибку
$ git rm -rf
$ git add .
$ git status
$ # всё пропало, всё что нажито непосильным трудом...

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

3 года в команде

За эти три года работы в WB—Tech я узнал много нового и получил практический опыт разработки. Мы делаем аутсорс крупным заказчикам, так что приходилось сталкиваться с интересными и сложными задачами в высоконагруженных проектах. С шардированием больших баз данных. Порой встречалось legacy слепленное из говна и палок, без автоматических тестов и документации. Но были и простые, но не менее интересные задачи. За это время, я поучаствовал в создании и поддержке многих проектов.

Некоторые из которых не ограничены NDA представлены ниже:

Каталог реалитишоу Мир реалити.

Django, PostgreSQL.

Площадка для купли-продажи запчастей для автомобилей в Казани.

Django, PostgreSQL.

Сервис создания скришотов вебстраниц Coment.me.

Flask, PhantomJS.

Спецпроект Ленты к юбилею победы в Великой Отечественной войне. Победа 70.

Django, PostgreSQL.

Сервис проектирования каркасных домов.

Flask, MongoDB, Celery.

Визуализация науки от команды Visual-Science.

Yii, MySQL.

Геоинформационная система поиска оптимальной точки размещения коммерческого объекта.

Django, PostgreSQL, PostGIS, Geoserver, Celery.

Увлекательные путешествия по России и миру. Pro Adventure.

Django, PostgreSQL, Celery.

Научно-популярный форум, посвящённый молекулярным основам современной биологии и практическим применениям научных достижений в биотехнологии.

Django, PostgreSQL, Celery.

Площадка для купли-продаже брендовой одежды. Preloved.

Django, PostgreSQL, Celery.

Пару проектов сделал для себя:

Я — первооткрыватель. Сотри белые пятна с карты.

Django, PostgreSQL.

Мой свадебный информационный сайт.

Django, PostgreSQL.

Сайт-портфолио.

Django, PostgreSQL.

Вебстраница кафедры информационной безопасности СевГУ.

gh-pages, static html.

Мой блог ;).

gh-pages, Pelican.

Вебтек — небольшая компания. Мы работаем удаленно из разных точек планеты. Нас объединяет трудолюбие и энтузиазм.

Мы можем работать в любом месте, в любое время, из любого города.

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

А самое главное, что это нам нравится. Как сказал Конфуций:

Выбери себе работу по душе и тебе не придется работать ни одного дня в своей жизни.

Безусловно подтверждаю эти слова. За выбор профессионального пути, я хотел бы поблагодарить:

SS Team, Севастополь. Первая летняя школа. Август 2010 г.

Михнева Сергея Сергеевича — преподаватель и тренер по спортивному программированию. Ведь именно он увидел мой потенциал и направил в нужное русло.
Пешкурова Романа — друг и наставник по алгоритмам, который поверил в меня раньше, чем я сам.
Гришанина Кирилла и Шиканова Юрия — сооснователи вебтек, спасибо за практический опыт и работу в интересной команде.
Землянова Василия и Захарова Андрея — школьные друзья, а затем и однокурсники, которые выбрали тот же путь.

Собственное хранилище версированных Vagrant боксов с помощью Nginx и Lua

2016-10-25T15:00:00+03:00

Для удобного процесса разработки, быстрого переключения между проектами и эффективного взаимодействия бэкенд и фронтенд команд. Мы, в WB—Tech, работаем в виртуальном окружении Vagrant + VirtualBox. Vagrant — прекрасный менеджер окружения, а для ускорения развертывания виртуальной машины можно использовать компилированные, версированные боксы. Хостить их можно на родном сервере, но триал Vagrant enterprise у нас закончился, в связи с чем было решено хостить боксы самостоятельно. А сделали мы это с помощью Lua.

Версийность боксов в Vagrant описывается при помощи json документа.

{
    "name": "box_name",
    "description": "This box description.",
    "versions": [
        {
            "version": "42.0",
            "providers": [
                {
                    "name": "virtualbox",
                    "url": "http://somewhere.com/precise64_010_virtualbox.box",
                    "checksum_type": "sha1",
                    "checksum": "foo"
                }
            ]
        }
    ]
}

Далее, в самом Vagrantfile нужно указывать путь к метаданным в атрибуте config.vm.box_url:

config.vm.box = "box_name"
config.vm.box_version = "42.0"
config.vm.box_url = "http://somewhere.com/path/to/metadata.json"

Каждый раз при обновлении версии бокса, описывать данный документ вручную, а потом загружать на сервер вместе с новым боксом, было бы слишком скучно. Делать для этого какой либо бэкенд нецелесообразно. Когда можно обойтись одним лишь Nginx с дополнительным модулем. Так что формирование метаданных сделано при помощи простого скрипта на Lua.

Далеко ли до Луны?

Lua (с порт. — ”луна”) — скриптовый язык программирования, разработанный в подразделении Tecgraf Католического университета Рио-де-Жанейро. Интерпретатор языка является свободно распространяемым, с открытыми исходными текстами на языке Си.

По возможностям, идеологии и реализации язык ближе всего к JavaScript, однако Lua отличается более мощными и гораздо более гибкими конструкциями. Хотя Lua не содержит понятия класса и объекта в явном виде, механизмы объектно-ориентированного программирования, включая множественное наследование, легко реализуются с использованием метатаблиц, которые также отвечают за перегрузку операций и т. п. Реализуемая модель объектно-ориентированного программирования — прототипная (как и в JavaScript).

Установка и зависимости

Описание приведено для операционных систем семейства Debian.

Прежде всего нам потребуется Nginx с модулем lua-nginx-module. Собрать его можно вручную, но проще установить готовый пакет nginx-extras, который содержит множество полезных модулей.
Также не будет лишним интерпретатор Lua, чтобы оттестировать скрипт в интерактивной консоли.
Для компиляции модулей, потребуется утилита make.
Время собирать лунные камни, нам будет нужен менеджер пакетов luarocks.
- Для поиска файлов в директории, будем использовать модуль luaposix.
- Ну и для конвертации словаря в JSON установим JSON4Lua.

$ sudo apt-get -y install make nginx-extras lua5.1 luarocks
$ # install lua modules
$ sudo luarocks install luaposix
$ sudo luarocks install JSON4Lua

Здравствуй, подлунный мир!

“Здравствуй, мир!” на Lua, так же прост и прекрасен, как и на Python.

Lua 5.1.5  Copyright (C) 1994-2012 Lua.org, PUC-Rio
> print "Hello world!"
Hello world!

Теперь попробуем тоже самое при помощи полнофункционального Nginx Lua API.

server {
    listen    80;

    location /hello-world {
        content_by_lua '
            ngx.header.content_type = "text/plain"
            ngx.say("Hello world!")
        ';
    }
}

$ curl http://10.1.1.111/hello-world
Hello world!

Для исполнения Lua скрипта, служит директива content_by_lua, для которого Nginx ожидает получить ответ через API. Если скрипт большой, то не обязательно описывать его внутри конфига, достаточно лишь подключить через директиву content_by_lua_file.

Vagrant метаданные

Настройка Nginx

На сервере мы складываем боксы в директорию hosted, создавая поддиректорию для каждого проекта. Сами боксы в которой хранятся файлами со строго указанным форматом имени {provider}-{version.subversion}.box.

Формируя примерно такое дерево:

$ tree hosted/
hosted/
├── foo
│   ├── docker-1.0.box
│   ├── docker-1.3.box
│   ├── virtualbox-1.0.box
│   ├── virtualbox-1.4.box
│   └── virtualbox-1.7.box
└── bar
    ├── virtualbox-1.0.box
    ├── virtualbox-1.1.box
    └── virtualbox-1.2.box

2 directories, 8 files

Настроим nginx так, чтобы для любого бокса — начиналось непосредственное скачивание, а для имени проекта, возвращались вычисленные метаданные.

server {
    listen    80;

    set $box_url 'http://10.1.1.111/%s/%s-%s.box';
    set $box_prefix '/home/vagrant/proj/hosted/';

    location ~ /*\.box$ {
        root /home/vagrant/proj/hosted;
        # just return box
    }

    location ~ /(?<box_name>\w+)/?$ {
        content_by_lua_file /home/vagrant/proj/app/handler.lua;
    }
}

Переменные $box_url и $box_prefix будут использовать при формировании метаданных.

Вычисление метаданных с помощью Lua

Приступим теперь непосредственно к формированию метаданных для версирования Vagrant боксов.

Идея будет заключаться в том, что по запросу, Lua будет осуществлять поиск сохраненных боксов в заданной директории на сервере, вычислять их хешсуммы, и формировать ответ в формате метаданных vagrantа.

Используя glob из библиотеки posix найдем все боксы.

local box_root = ngx.var.box_prefix .. ngx.var.box_name .. '/'
local posix = require "posix"
local glob = posix.glob (box_root .. '*.box')

-- Если боксы не найдены, можно сразу возвращать 404
if not glob then
    ngx.status = ngx.HTTP_NOT_FOUND
    return ngx.exit (ngx.HTTP_NOT_FOUND)
end

Итеративно пройдем по найденным боксам, и сформируем словарь с найденными версиями.

local versions = {}
-- Discover the boxes
for _, box in ipairs (glob) do
    -- Обрабатываем найденый бокс, определяя версию и формируя описание
    local provider, version = make_provider (box)
    if version then
        if versions[version] == nil then
            -- Если версия встречается впервые, создаем запись для новой версии
            versions[version] = {
                version = version,
                providers = {provider}
            }
        else
            -- Если версия уже была описана, обновляем список провайдеров
            table.insert (versions[version]['providers'], provider)
        end
    end
end

Для вычисления хешсуммы больших файлов боксов воспользуемся утилитами операционной системы. Такими как sha1sum, sha256sum, md5sum… Делается это с помощью вызова процесса через io.popen:

local hash = 'sha1'

function get_hash (filepath)
    -- Вычисляем хешсумму используя вызов консольной утилиты sha1sum
    local command = string.format ('%ssum %s | cut -d " " -f1', hash, filepath)
    local hashsum = assert (io.popen (command, 'r'))
    local result = string.gsub (hashsum:read ('*a'), '\n', '')
    hashsum:close ()
    return result
end

Функция make_provider выполняется для каждого найденного бокса. Подразумевается, что боксы хранятся на сервере со строго заданным форматом имени: {provider}-{version.subversion}.box

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

local function make_provider (filepath)
    -- Make vagrant provider from given file
    local box_provider, box_version = string.match (
        filepath, string.format ('%s(%%a+)-(.+).box', box_root))
    return {
        -- Название провайдера virtualbox или docker
        name = box_provider,
        -- Прямая ссылка на бокс, которую будет запрашивать vagrant
        url = string.format (ngx.var.box_url, ngx.var.box_name, box_provider, box_version),
        -- Алгоритм хешсуммы sha1, sha256, md5
        checksum_type = hash,
        -- Строка со значением хешсуммы
        checksum = get_hash(filepath)
    }, box_version
end

Обработав все боксы и сформировав список версий, обернем всё в дополнительный словарь.

-- Make result response
local vagrant = {
    name = ngx.var.box_name,
    description = string.format ("Boxes for %s proj", ngx.var.box_name),
    versions = {}
}
for _, version in pairs (versions) do
    table.insert (vagrant['versions'], version)
end

Ответ сервера JSON с найденными версиями.

ngx.header.content_type = "application/json; charset=utf-8"
local json = require "json"
ngx.say (json.encode (vagrant))

Лунное затмение (вместо заключения)

Полученный скрипт формирует JSON ответ содержащий метаинформацию о боксах.

$ curl http://10.1.1.111/example | jq
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   943    0   943    0     0  13412      0 --:--:-- --:--:-- --:--:-- 13471

{
  "versions": [
    {
      "version": "1.7",
      "providers": [
        {
          "url": "http://10.1.1.111/example/virtualbox-1.7.box",
          "checksum": "3221c0fd58a4b2430efc5eeaf09cb8eaf877f3a9",
          "name": "virtualbox",
          "checksum_type": "sha1"
        }
      ]
    },
    {
      "version": "1.3",
      "providers": [
        {
          "url": "http://10.1.1.111/example/docker-1.3.box",
          "checksum": "def7148aa7ded879dbf5944af4785c2b09aba97a",
          "name": "docker",
          "checksum_type": "sha1"
        }
      ]
    },
    {
      "version": "1.4",
      "providers": [
        {
          "url": "http://10.1.1.111/example/virtualbox-1.4.box",
          "checksum": "63b06d8c065f5c2522c356d4d6ceb718ec3f8198",
          "name": "virtualbox",
          "checksum_type": "sha1"
        }
      ]
    },
    {
      "version": "1.0",
      "providers": [
        {
          "url": "http://10.1.1.111/example/docker-1.0.box",
          "checksum": "65cb550765d251604dcfeedc36ea61f66ce205c4",
          "name": "docker",
          "checksum_type": "sha1"
        },
        {
          "url": "http://10.1.1.111/example/virtualbox-1.0.box",
          "checksum": "c0a9d5c3d6679cfcc4b1374e3ad42465f3dd596e",
          "name": "virtualbox",
          "checksum_type": "sha1"
        }
      ]
    }
  ],
  "name": "example",
  "description": "Boxes for example proj"
}

Полный пример скрипта можно посмотреть в репозитории на github Samael500/ngx-vagrant. А при желании поиграться запустив настроенный Vagrant.

О том, как ещё можно интересно использовать связку Nginx и Lua, можно прочитать в статье Применение Nginx + Lua для обработки контактной формы

Быстрый старт на Джанго

2016-10-10T15:00:00+03:00

Новый проект это всегда интересно, новые задачи, новый опыт, новые знания. Начиная новый проект хочется сразу броситься “в бой”. Но перед этим приходится тратить время на первоначальную настройку окружения, подключения и установку зависимостей, создания структуры, инициализацию проекта. Порой это может занимать целый день. Рутинная и во многом однообразная задача написания fab скриптов для запуска виртуального окружения — охлаждает пыл и отвлекает. Для того чтобы пропускать этот шаг, и сразу приступать к разработке. Был написан простенький fab скрипт для фальстарта нового проекта. Так что теперь, достаточно написать falstart <название проекта>, выпить чашечку чая и приступать к работе над новым проектом.

Мы, в WB—Tech в основном используем следующий стек: Python 3.x + Django + PostgreSQL + Celery + Redis.

А саму разработку ведем в виртуальном окружении Vagrant + VirtualBox под управлением OS Debian.

Falstart позволяет быстро развернуть виртуальное окружение и приступить к работе ответив на десяток простых вопросов.

$ falstart awesome
> Django version ['1.9.5'] 1.10.2
> Debian version (for vagrant box) ['jessie64']
> Python version ['3.5.1'] 3.5.2
> Vagrant box IP-addr ['10.1.1.123'] 10.1.1.111
> Do you nead a POSTGRES? [Y/n]
> Do you nead a CELERY? [y/N] y
> Do you nead a REDIS? [y/N] y
> Do you nead a SENTRY? [y/N]
> Database name ['awesome_db']
> Database user ['awesome_user']
> Database pass ['vFeH1uJVN']

После чего выполняются скрипты и через 10-15 минут будет готова структура проекта.

Пред зависимости

Для работы фальстарта необходим Vagrant и VirtualBox

Установка

Фальстарт доступен для установки через pip

$ pip install falstart

Результат

Пример результата: falstart-example.

Пример итоговой структуры проекта

$ tree
.
├── awesome
│   ├── celery.py
│   ├── __init__.py
│   ├── __pycache__
│   │   ├── celery.cpython-35.pyc
│   │   ├── __init__.cpython-35.pyc
│   │   ├── settings.cpython-35.pyc
│   │   ├── settings_local.cpython-35.pyc
│   │   ├── urls.cpython-35.pyc
│   │   └── wsgi.cpython-35.pyc
│   ├── settings_local.py
│   ├── settings_local.py.example
│   ├── settings.py
│   ├── static
│   │   └── admin
│   │       ├── css
│   │       │   ├── base.css
│   │       │   ├── changelists.css
│   │       │   ├── dashboard.css
│   │       │   ├── fonts.css
│   │       │   ├── forms.css
│   │       │   ├── login.css
│   │       │   ├── rtl.css
│   │       │   └── widgets.css
│   │       ├── fonts
│   │       │   ├── LICENSE.txt
│   │       │   ├── README.txt
│   │       │   ├── Roboto-Bold-webfont.woff
│   │       │   ├── Roboto-Light-webfont.woff
│   │       │   └── Roboto-Regular-webfont.woff
│   │       ├── img
│   │       │   ├── calendar-icons.svg
│   │       │   ├── gis
│   │       │   │   ├── move_vertex_off.svg
│   │       │   │   └── move_vertex_on.svg
│   │       │   ├── icon-addlink.svg
│   │       │   ├── icon-alert.svg
│   │       │   ├── icon-calendar.svg
│   │       │   ├── icon-changelink.svg
│   │       │   ├── icon-clock.svg
│   │       │   ├── icon-deletelink.svg
│   │       │   ├── icon-no.svg
│   │       │   ├── icon-unknown-alt.svg
│   │       │   ├── icon-unknown.svg
│   │       │   ├── icon-yes.svg
│   │       │   ├── inline-delete.svg
│   │       │   ├── LICENSE
│   │       │   ├── README.txt
│   │       │   ├── search.svg
│   │       │   ├── selector-icons.svg
│   │       │   ├── sorting-icons.svg
│   │       │   ├── tooltag-add.svg
│   │       │   └── tooltag-arrowright.svg
│   │       └── js
│   │           ├── actions.js
│   │           ├── actions.min.js
│   │           ├── admin
│   │           │   ├── DateTimeShortcuts.js
│   │           │   └── RelatedObjectLookups.js
│   │           ├── calendar.js
│   │           ├── cancel.js
│   │           ├── change_form.js
│   │           ├── collapse.js
│   │           ├── collapse.min.js
│   │           ├── core.js
│   │           ├── inlines.js
│   │           ├── inlines.min.js
│   │           ├── jquery.init.js
│   │           ├── popup_response.js
│   │           ├── prepopulate_init.js
│   │           ├── prepopulate.js
│   │           ├── prepopulate.min.js
│   │           ├── SelectBox.js
│   │           ├── SelectFilter2.js
│   │           ├── timeparse.js
│   │           ├── urlify.js
│   │           └── vendor
│   │               ├── jquery
│   │               │   ├── jquery.js
│   │               │   ├── jquery.min.js
│   │               │   └── LICENSE-JQUERY.txt
│   │               └── xregexp
│   │                   ├── LICENSE-XREGEXP.txt
│   │                   ├── xregexp.js
│   │                   └── xregexp.min.js
│   ├── urls.py
│   └── wsgi.py
├── Makefile
├── manage.py
├── provision
│   ├── fabric_provisioner.py
│   ├── fabric_provisioner.pyc
│   └── templates
│       ├── environment.j2
│       ├── locale.gen.j2
│       └── nginx-host.j2
├── requirements-remote.txt
├── requirements.txt
├── Vagrantfile
├── var
│   ├── celery_awesome_worker.log
│   ├── celery_awesome_worker.pid
│   ├── celerybeat-schedule
│   └── gunicorn.pid
└── wheels
    ├── amqp-1.4.9-py2.py3-none-any.whl
    ├── anyjson-0.3.3-py3-none-any.whl
    ├── billiard-3.3.0.23-py3-none-any.whl
    ├── celery-3.1.23-py2.py3-none-any.whl
    ├── coverage-4.2-cp35-cp35m-linux_x86_64.whl
    ├── coverage_badge-0.1.2-py3-none-any.whl
    ├── Django-1.10.2-py2.py3-none-any.whl
    ├── django_rainbowtests-0.5.1-py3-none-any.whl
    ├── gunicorn-19.4.5-py2.py3-none-any.whl
    ├── kombu-3.0.37-py2.py3-none-any.whl
    ├── mccabe-0.4.0-py2.py3-none-any.whl
    ├── pep257-0.7.0-py2.py3-none-any.whl
    ├── pep8-1.7.0-py2.py3-none-any.whl
    ├── psycopg2-2.6.1-cp35-cp35m-linux_x86_64.whl
    ├── pyflakes-1.0.0-py2.py3-none-any.whl
    ├── pylama-7.0.7-py2.py3-none-any.whl
    ├── pytz-2016.7-py2.py3-none-any.whl
    └── redis-2.10.5-py2.py3-none-any.whl

Теперь можно перейти по адресу указанному в приветственном сообщении Vagrantа и увидеть начальную страницу Джанго.

==> awesome_vagrant: Machine 'awesome_vagrant' has a post `vagrant up` message. This is a message
==> awesome_vagrant: from the creator of the Vagrantfile, and not from Vagrant itself:
==> awesome_vagrant:
==> awesome_vagrant: awesome dev server successfuly started.
==> awesome_vagrant:     Connect to host with:
==> awesome_vagrant:     http://10.1.1.111/
==> awesome_vagrant:     or over ssh with `vagrant ssh`
==> awesome_vagrant:
==> awesome_vagrant:     Admin user credentials:
==> awesome_vagrant:       login: root
==> awesome_vagrant:       password: 123123
==> awesome_vagrant:

Отчеты coverage в TeamCity

2016-09-26T15:00:00+03:00

Мы, в WB—Tech в качестве системы непрерывной интеграции используем TeamCity. А саму разработку ведем в приватных репозиториях на github. С задачей запуска тестов и публикации статуса выполнения в ветку на github TeamCity справляется отлично. Но выводить отчет по покрытию кода из коробки умеет только для Java и .NET, а это не наш профиль. Хотелось получить собственную систему, похожую на Coveralls работающую с python.

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

Формирование отчета

Первым делом, необходимо сформировать данные о покрытии кода. Делаем это с помощью утилиты Coverage.py. Т.к. для удобства работы с проектом, мы используем Makefile, то пропишем в нем дополнительные команды, для запуска тестов с покрытием кода, и формирования отчета.

VENV_PATH := $(HOME)/venv/bin
PROJ_NAME := my_awesome_project

# ...

ci_test: cover_test cover_report

cover_test:
    $(VENV_PATH)/coverage run --source=$(PROJ_NAME) manage.py test -v 2 --noinput

cover_report:
    $(VENV_PATH)/coverage report -m
    $(VENV_PATH)/coverage html
    $(VENV_PATH)/coverage-badge > htmlcov/coverage.svg

Команда cover_test запускает джанговские тесты, и замеряет покрытие кода. Команда cover_report выводит в консоль отчет о покрытии, а также формирует html отчет и, при помощи утилиты coverage-badge формирует красивый бейджик со статусом покрытия кода .

После того, как исходные данные для отчета подготовлены, мы можем отображать результат. Для этого нужно сконфигурировать сбор артефактов в teamcity. Делается это на вкладке General Settings в настройках проекта. Мы копируем в артефакты папку htmlcov содержащую отчет и бейджик.

После следующего запуска тестов, перейдя во вкладку Artifacts, можно увидеть дерево артефактов данного билда.

Сами артефакты также доступны авторизованным пользователям TeamCity напрямую по ссылкам вида:

/repository/download/%teamcity.project.id%/%teamcity.build.id%:id/htmlcov/index.html
/repository/download/%teamcity.project.id%/.lastFinished/htmlcov/index.html

Более подробно о доступе к артефактам в документации.

Уведомления статуса на Github

Имея готовый отчет будем отправлять вебхуки на github с указанием статуса покрытия кода. Для этого добавим простые build steps.

Coverage pending hook

Заставляем гитхаб ждать отчета по покрытию кода.

Runner type Command Line
Execute step Even if some of the previous steps failed

Custom script

OWNER="<GITHUB OWNER>";
REPO="<REPO NAME>";
SHA="%build.vcs.number%";

curl "https://api.github.com/repos/$OWNER/$REPO/statuses/$SHA" \
    -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: token <GITHUB API TOKEN>" \
    -d '{
        "state": "pending",
        "description": "Coverage pending.",
        "context": "continuous-integration/coverage"
    }'

Badge copy

Копируем сформированный бейджик, в папку доступную напрямую через вебсервер. Для того, чтобы github имел доступ к бейджику без аутентификации в teamcity. Если у вас разрешен гостевой доступ - то этот шаг выполнять не обязательно.

Runner type Command Line
Execute step Even if some of the previous steps failed

Custom script

BADGE="/path/to/public/dir/badges/%teamcity.project.id%/%teamcity.build.branch%-coverage.svg"
DIR=$(dirname "${BADGE}")
mkdir -p $DIR
cp -f htmlcov/coverage.svg $BADGE

Coverage finish hook

По окончанию тестов, отправляем отчет на гитхаб.

Runner type Command Line
Execute step Even if some of the previous steps failed

Custom script

OWNER="<GITHUB OWNER>";
REPO="<REPO NAME>";
SHA="%build.vcs.number%";

REPORT_URL="http://<YOU TEAMCITY DOMAIN>/repository/download/%teamcity.project.id%/%teamcity.build.id%:id/htmlcov/index.html";

COVERAGE=$(cat ./htmlcov/index.html | grep '<span class="pc_cov">' | grep -o '[0-9]\+');

if [ "$COVERAGE" -ge "85" ]; then
    STATUS='success';
else
    STATUS='failure';
fi

curl "https://api.github.com/repos/$OWNER/$REPO/statuses/$SHA" \
    -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: token <GITHUB API TOKEN>" \
    -d '{
        "state": "'$STATUS'",
        "target_url": "'$REPORT_URL'",
        "description": "Coverage '$COVERAGE'%",
        "context": "continuous-integration/coverage"
    }'

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

Бейджик в readme

Для отображения бейджика в README.md добавим ссылку, на последний успешний билд.

[![coverage report](http://<TEAMCITY DOMAIN>/badges/<TEAMCITY PROJ ID>/master-coverage.svg)](http://<TEAMCITY DOMAIN>/repository/download/<TEAMCITY PROJ ID>/.lastFinished/htmlcov/index.html)

Где /badges/<TEAMCITY PROJ ID>/ доступна для анонимных посетителей, чтобы github мог закешировать изображение.

Теперь в README виден кликабельный бейджик с покрытием кода.

Кликнув на который, мы попадаем в отчет по покрытию кода.

Заклинатель змей?

2016-04-17T15:00:00+03:00

Python имеет очень простой синтаксис, и практически всегда ведёт себя предсказуемо. Однако порой происходит нечто невероятное…

Непредсказуемые списки

x = [[]] * 3
x[0].append('a')
x[1].append('b')
x[2].append('c')
x[0] = ['d']
print x

Результат

>>> x = [[]] * 3
>>> x[0].append('a')
>>> x[1].append('b')
>>> x[2].append('c')
>>> x[0] = ['d']
>>> print x
[['d'], ['a', 'b', 'c'], ['a', 'b', 'c']]

a = ([], )
a[0].extend([1])
a[0] += [2]
print a[0]

Результат

>>> a = ([], )
>>> a[0].extend([1])
>>> a[0] += [2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> print a[0]
[1, 2]

# list += str
x = []
x += 'abcd'
print x

# list + str
x = []
x = x + 'abcd'
print x

Результат

>>> # list += str
>>> x = []
>>> x += 'abcd'
>>> print x
['a', 'b', 'c', 'd']
>>>
>>> # list + str
>>> x = []
>>> x = x + 'abcd'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "str") to list
>>> print x
[]

ООП, такое ООП

>>> class A():
...   def foo(self):
...     print "this is A"
... 
>>> class B():
...   def foo(self):
...     print "this is B"
... 
>>> 
>>> a = A()
>>> b = B()
>>> 
>>> a.foo()
this is A
>>> b.foo()
this is B
>>> 
>>> A.foo = B.foo
>>> 
>>> a.foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method foo() must be called with B instance as first argument (got nothing instead)
>>> 
>>> A.foo = b.foo
>>> a.foo()
this is B
>>>

Full year streak!

2016-01-21T20:00:00+03:00

Год непрерывного contribution, как оказывается не так и сложно. В этом году я не только ежедневно коммитил, но и сделал некоторые вещи, например:

Получил диплом о высшем образовании.
Окончил автошколу и сдал на права.
Купил коньки и катаюсь по замерзшему пруду.

А также бесчисленное количество прочих мелочей…

Давайте шифровать!

2016-01-15T15:00:00+03:00

Let's Encrypt представляет собой центр сертификации, который позволяет просто и бесплатно получить TLS / SSL сертификаты, тем самым позволяя использовать зашифрованное соединение HTTPS. В данный момент сервис находится на этапе бета тестирования, и получить сертификат в полностью автоматическом режиме, можно лишь при использовании веб-сервера Apache. Я предпочитаю использовать nginx, поэтому опишу как легко получить сертификат в ручном режиме.

Получение сертификата Let’s Encrypt

Let's Encrypt устанавливается просто клонируя репозиторий.

$ sudo git clone https://github.com/letsencrypt/letsencrypt /opt/letsencrypt
$ cd cd /opt/letsencrypt

Теперь получим сертификат используя следующую команду:

$ ./letsencrypt-auto certonly --standalone

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

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

Что бы освободить порт, можно временно остановить nginx выполнив команду:

$ sudo service nginx stop

letsencrypt запрашивает адрес электронной почты для уведомлений или востановления ключей.

Далее, предлагают согласиться с условиями использования сервиса.

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

При успешном получении сертификата, выдается следующее сообщение:

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at
   /etc/letsencrypt/live/you.domain.com/fullchain.pem. Your cert
   will expire on 2016-15-06. To obtain a new version of the
   certificate in the future, simply run Let's Encrypt again.
 - If you like Let's Encrypt, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

После успешного получения сертификата у вас будут следующие файлы:

cert.pem: Сертификат домена
chain.pem: Let’s Encrypt сертификат
fullchain.pem: cert.pem и chain.pem объединенные
privkey.pem: Ключ сертификата

Что бы проверить что сертификаты успешно созданы и доступны, выведите содержимое директории /etc/letsencrypt/live/your_domain_name, где your_domain_name имя вашего домена.

$ sudo ls /etc/letsencrypt/live/your_domain_name

Подключение сертификата в nginx

Что бы правильно настроить ssl есть такая замечательная шпаргалка от mozilla.

В общем случае достаточно использовать следующие настройки:

server {

    listen 443 ssl;

    server_name example.com www.example.com;

    # certs sent to the client in handshake are concatenated in ssl_certificate
    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:50m;
    ssl_session_tickets off;

    # secure configuration
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers 'EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH';
    ssl_prefer_server_ciphers on;

    # ...

}

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

server {
    listen 80;
    server_name example.com;
    return 301 https://$host$request_uri;
}

После внесения изменений в настройки сервера, нужно не забыть перезагрузить службу nginx.

$ sudo service nginx restart
$ # or
$ sudo nginx -s reload

Готово. Теперь вы можете открыть ваш сайт используя защищенное соединение.

Автоматическое обновление сертификата

Сертификаты, которые выдает Let's Encrypt, действительны всего 90 дней. В сравнениями с другими центрами сертификации, которые выдают сертификаты на год. Данный период кажется подозрительно коротким. Однако, в дальнейшем сроки сертификатов планируют ещё сократить. Это сделано с целью уменьшения угрозы от компрометации приватного ключа, а так же призывает повсеместно использовать автопродление сертификатов, в связи с тем, что через год, можно и забыть его продлить.

Автопродление сертификата проходит с помощью плагина webroot, который для верификации помещает специальный файл в директорию ./well-known доступную для чтения вебсервером.

    location ~ /.well-known {
        root /path/to/root;
        allow all;
    }

Теперь мы можем использовать letsencrypt-auto с дополнительным параметром webroot-path, передавая домены с помощью ключа -d:

$ cd /opt/letsencrypt
$ ./letsencrypt-auto certonly -a webroot --agree-tos --renew-by-default \
    --webroot-path=/path/to/root -d example.com -d www.example.com

В результате обновления сертификата вы получите следующее сообщение:

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at
   /etc/letsencrypt/live/example.com/fullchain.pem. Your cert will
   expire on 2016-05-22. To obtain a new version of the certificate in
   the future, simply run Let's Encrypt again.
 - If you like Let's Encrypt, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

Получив обновленный сертификат, для его использования нужно перезапустить nginx

$ sudo service nginx restart
$ # or
$ sudo nginx -s reload

Теперь создадим конфигурационный файл, для автоматической подстановки параметров. Шаблон конфигурационного файла находится в примерах letsencrypt.

$ cat /opt/letsencrypt/examples/cli.ini
# This is an example of the kind of things you can do in a configuration file.
# All flags used by the client can be configured here. Run Let's Encrypt with
# "--help" to learn more about the available options.

# Use a 4096 bit RSA key instead of 2048
rsa-key-size = 4096

# Uncomment and update to register with the specified e-mail address
# email = foo@example.com

# Uncomment and update to generate certificates for the specified
# domains.
# domains = example.com, www.example.com

# Uncomment to use a text interface instead of ncurses
# text = True

# Uncomment to use the standalone authenticator on port 443
# authenticator = standalone
# standalone-supported-challenges = tls-sni-01

# Uncomment to use the webroot authenticator. Replace webroot-path with the
# path to the public_html / webroot folder being served by your web server.
# authenticator = webroot
# webroot-path = /usr/share/nginx/html

Скопируем его в директорию /usr/local/etc:

$ sudo cp /opt/letsencrypt/examples/cli.ini /usr/local/etc/le-renew-webroot.ini

Далее отредактируем его, изменив параметры email, domains и webroot-path.

$ sudo nano /usr/local/etc/le-renew-webroot.ini

# This is an example of the kind of things you can do in a configuration file.
# All flags used by the client can be configured here. Run Let's Encrypt with
# "--help" to learn more about the available options.

# Use a 4096 bit RSA key instead of 2048
rsa-key-size = 4096

# Uncomment and update to register with the specified e-mail address
email = user@example.com

# Uncomment and update to generate certificates for the specified
# domains.
domains = example.com, www.example.com

# Uncomment to use a text interface instead of ncurses
# text = True

# Uncomment to use the standalone authenticator on port 443
# authenticator = standalone
# standalone-supported-challenges = tls-sni-01

# Uncomment to use the webroot authenticator. Replace webroot-path with the
# path to the public_html / webroot folder being served by your web server.
# authenticator = webroot
webroot-path = /path/to/root

Теперь, вместо того что бы указывать параметры с помощью ключей комманды letsencrypt, мы можем использовать конфигурационный файл:

$ cd /opt/letsencrypt
$ ./letsencrypt-auto certonly -a webroot --renew-by-default \
    --config /usr/local/etc/le-renew-webroot.ini

Скачаем и сделаем исполнимым скрипт автообновления сертификата.

$ sudo curl -L -o /usr/local/sbin/le-renew-webroot \
    https://gist.githubusercontent.com/thisismitch/e1b603165523df66d5cc/raw/fbffbf358e96110d5566f13677d9bd5f4f65794c/le-renew-webroot
$ sudo chmod +x /usr/local/sbin/le-renew-webroot

Теперь если его выполнить, то будет выдано ссобщение, о том, что сертификат не нуждается в обновлении.

$ sudo le-renew-webroot
Checking expiration date for example.com...
The certificate is up to date, no need for renewal (89 days left).

Для того что бы скрипт регулярно проверял состояние сертификата добавим его запуск в таблицу крона:

$ sudo crontab -e

Добавим строчку, которая будет запускать скрипт каждое воскресенье в 5.30 утра, и логировать результат в файл /var/log/le-renewal.log:

30 5 * * 7 /usr/local/sbin/le-renew-webroot >> /var/log/le-renewal.log

Теперь можно не беспокоится о сроке годности сертификата, он будет регулярно обновлятся, когда будет приближаться срок истечения сертификата.

Трехсоточка!

2015-11-16T18:00:00+03:00

Пролетели очередные 100 дней. Вот уже до конца года осталось всего девять недель. Финишь не за горами.

Это Типограф!

2015-10-15T15:00:00+03:00

В одном из проектов была поставлена задача типографировать текст перед публикацией. Для этой задачи было решено использовать «Типограф» Лебедева.

У студии Лебедева есть сервис типографирования текста, который так и называется типограф. Как заявляют сами разработчики, никто не напишет «Типограф» лучше них, в связи с чем они предлагают готовые клиенты для работы c api данного сервиса.

Типограф клиент

Я не смотрел клиенты для других языков, но клиент для Python, который студия Лебедева предлагает, откровенно сказать — ужасен. В нем xml запрос создается с помощью простой конкатенации строк и сомнительно экранирует входные данные, socket подключается без таймлимита, что приводит к бесконечно длительному ожиданию ответа, в случае если сервер недоступен. Что уж говорить о рекомендациях pep8, которые там впринципе не соблюдаются. Но самым существенным было то, что последнее изменение было сделано не вчера, и даже не на прошлой неделе, а всего-ничего, от 24 мая 2007 года, еще до релиза Python 3.0. Соответсвенно данный клиент не поддерживает Python 3.x.

Проект был на Python 3.4.2, в связи с чем пришлось написать собсвтенный клиент для работы с «Типографом». Поскольку адекватного описания api взаимодействия клиент-сервер в «Типографе» не приводится. Так что все было сделано по аналогии со старым клиентом, вплоть до наименований методов, лишь за исключением, что ненавистный мне верблюжийРегистр был заменен змеиным_регистром.

Получившийся клиент для типографа доступен в pypi

Совместимость python 2.x и 3.x

Поскольку клиет типографа предельно простой, не хотелось нагружать его дополнительными зависимостями, вроде six для реализации совместимости версий pythonа, так что было использовано sys.version.startswith.

PY3 = sys.version.startswith('3.')

Единственными различиями между py 2.x и py 3.x, с которыми пришлось столкнутся при написании клиента, это:

Во втором питоне, в сокет и из него отправляются строковые объекты, а в третьем байтовые.
Файлы в памяти во втором питоне представлены объектами StringIO.StringIO, а в третьем io.BytesIO.

Так что вся совместимость версий, свелась к двум-трем условиям вида:

# ... import memory file stream

if PY3:
    from io import BytesIO as Container
else:
    from StringIO import StringIO as Container

# ... calculate a length of request

length = len(soap_body.encode('utf-8')) if PY3 else len(soap_body)

# ... convert to and from bytes for socket connection in py3

if PY3:  # convert to bytes
    soap_request = soap_request.encode('utf-8')

# ...
# take a response via socket
# ...

if PY3:  # convert to str
    response = response.decode()

Socket timeout

Библиотека socket предусматривает возможность установки максимального времени ожидания ответа от сервера. Делается это с помощью метода settimeout.

# send request use soket
connector = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connector.settimeout(self._timeout)
connector.connect((self.HOST, 80))
connector.sendall(soap_request)
# call for response
response = b''
buf = '0'
while len(buf):
    buf = connector.recv(8192)
    response += buf
connector.close()

В случае, если время ожидания превысит установленый таймаут, соединение будет разорвано с вызовом исключения socket.timeout: timed out.

Django Типограф

После реализации совместимого с python 3.x клиента было необходимо прикрутить его к джанге.

Быстрое решение

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

# helpers/service.py

def make_typograf(instance, fields):
    """ For each instance.field in fields - make typograf """
    typograf = RemoteTypograf()
    for field in fields:
        instance.__dict__[field] = typograf.try_process_text(instance.__dict__[field])
    return instance

# articles/signals.py

from django.db.models.signals import pre_save
from articles.models import Article
from helpers.service import make_typograf

def typograf(sender, instance, **kwargs):
    make_typograf(instance, ('title', 'subtitle', ))

pre_save.connect(typograf, sender=Article)

# cards/signals.py

from django.db.models.signals import pre_save
from cards.models import Card
from helpers.service import make_typograf

def typograf(sender, instance, **kwargs):
    make_typograf(instance, ('person_profession', 'soldier_rank', 'history', ))

pre_save.connect(typograf, sender=Card)

Данный подход имел ряд недостатков:

В случае если бы было неоходимо добавить новую модель, то потребовалось бы дописывать ещё один сигнал.
Модель “типографировалась” при каждом сохранении, не зависимо от изменения самого текста, что приводило к лишним запросам на сервис Лебедева при каждом сохранении.
Наиболее существенный недостаток. Модераторы начали жаловаться на то, что текст становится невозможно проверять, из за html сущностей, которые затрудняют чтение. (см. пример ниже)

Пример исходного текста:

"Вы все еще кое-как верстаете в "Ворде"? - Тогда мы идем к вам!"

Пример типографированного текста:

<p>&laquo;Вы&nbsp;все еще кое-как верстаете в&nbsp;&bdquo;Ворде&ldquo;?
&mdash;&nbsp;Тогда мы&nbsp;идем к&nbsp;вам!&raquo;<br />
</p>

Пример результата:

«Вы все еще кое-как верстаете в „Ворде“? — Тогда мы идем к вам!»

Ненавязчивый типограф

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

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

Хешсумма

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

Затраты времени для md5 суммы:

$ time python -c 'from hashlib import md5
for i in xrange(int(1e+6)): md5(str(i)).hexdigest()'

real    0m1.015s
user    0m1.006s
sys 0m0.008s

Затраты времени для sha1 суммы:

$ time python -c 'from hashlib import sha1
for i in xrange(int(1e+6)): sha1(str(i)).hexdigest()'

real    0m1.095s
user    0m1.090s
sys 0m0.004s

Затраты времени для crc32 суммы:

$ time python -c 'from binascii import crc32
for i in xrange(int(1e+6)): crc32(str(i))'

real    0m0.473s
user    0m0.472s
sys 0m0.000s

Затрат времени на стравнение строк:

$ time python -c 'for i in xrange(int(1e+6)): "123" == "321"'

real    0m0.092s
user    0m0.087s
sys 0m0.008s

Затрат времени на стравнение целых чисел:

$ time python -c 'for i in xrange(int(1e+6)): 123 == 321'

real    0m0.088s
user    0m0.080s
sys 0m0.008s

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

Несмотря на то, что целочисленные значения дают дополнительное преимущество в затратах скорости и памяти, на практике всеравно будем использовать строковое представлениет. Так как, в python 3.x алгоритм crc32 возвращает результат в диапазоне unsigned int: 0 .. 4294967295, а в python 2.x в диапазоне int: -2147483648 .. 2147483647. Целочисленное поле PostgreSQL способно разместить только диапазон int, даже джанговское поле PositiveIntegerField не расширяет диапазон до 2 ** 32 - 1, а сокращает его ровно в половину до 0 .. 2147483647.

Скрытые поля

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

    # ...

    @classmethod
    def create_typograf_fields(cls, local_typograf_fields, attrs):
        """Create helpers to the local typografed fields """
        for field_name in local_typograf_fields:
            # check is text field
            field = attrs[field_name]
            if not isinstance(field, (models.CharField, models.TextField)):
                raise TypografFieldError(
                    'Can\'t be typografed field "{field}".'
                    ' This must be a text or char field.'.format(field=field_name))
            # create fields for store typografed text and typografed hash
            typograf_field = models.TextField(blank=True, null=True)
            typograf_field.creation_counter += 0.0001
            typograf_field_hash = models.CharField(max_length=32, blank=True, null=True)
            typograf_field_hash.creation_counter += 0.0001
            # create fields name's
            typograf_field_name = get_typograf_field_name(field_name)
            typograf_field_hash_name = get_typograf_hash_field_name(field_name)
            # update attrs
            attrs.update({
                typograf_field_name: typograf_field,
                typograf_field_hash_name: typograf_field_hash})

        return attrs

В данном методе для каждого поля из спика local_typograf_fields, который задается в атрибутах метакласса модели наследника, создается по два служебных поля, вида typograf_{field} и typograf_{field}_hash.

Для того чтобы эти служебные поля были недоступны в административном интерфейсе, добавим внутренний метод _exclude, который будет возвращать списки скрытых полей.

from django.contrib import admin
from django_typograf.utils import get_typograf_field_name, get_typograf_hash_field_name

class TypografAdmin(admin.ModelAdmin):

    """ Admin class for hide typograf fields from admin site """

    def _exclude(self, obj=None):
        """ Mark typograf fields as exclude """
        exclude = ()
        if obj:
            exclude += tuple((
                get_typograf_field_name(field) for field in obj._meta.typografed_fields))
            exclude += tuple((
                get_typograf_hash_field_name(field) for field in obj._meta.typografed_fields))
        return exclude

    def get_form(self, request, obj=None, **kwargs):
        exclude = self.exclude or ()
        exclude += self._exclude(obj)
        kwargs.update(dict(exclude=exclude))
        return super().get_form(request, obj, **kwargs)

Использования типографа

Теперь, для автоматического типографирования текста, достаточно установить пакет django_typograf из pypi, наследовать модель от TypografModel и указать поля, которые необходимо типографировать.

# articles/models.py

from django.db import models
from django_typograf.models import TypografModel

class Article(TypografModel):

    """ Model for articles """

    title = models.CharField(verbose_name='заголовок', max_length=200)
    subtitle = models.CharField(verbose_name='подзаголовок', max_length=200)
    site_url = models.URLField(verbose_name='URL')

    class Meta(Sortable.Meta):
        typograf = ('title', 'subtitle', )
        verbose_name = 'статья'
        verbose_name_plural = 'статьи'

А также, в шаблоне, не забыть работать с “типографированными” полями.

<h1>{{ article.typograf_title|default_if_none:article.title|safe }}</h1>
<h2>{{ article.typograf_subtitle|default_if_none:article.subtitle|safe }}</h2>

Определение IP адреса посетителя в отчетах Yandex Метрика

2015-09-22T15:00:00+03:00

Обновленная метрика не отображает информацию об ip адресе посетителей сайта, сделано это с целью обезличивания статистики посещений. Данная новость была официально озвучена в клубе метрики. Обезличивание это здорово, но порой хочется узнать действительно ли в статистике отображаются различные посетители, или же это одно и тот же лицо, которое заходит с разных браузеров или устройств. А может быть у Вас несколько счетчиков метрики, и Вам интересно какие из посетителей ресурса A, посещают также ресурсы B или C.

Также различным рекламщикам, может быть интересна информация об ip адресах, например, с целью вычисления ботов скликеров.

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

Параметры визитов yandex.метрика

Сервис параметры визитов позволяет прикрепить к информации о посещении json словарь с дополнительными параметрами. Для этого необходимо в конструктор счетчика добавить аргумент params с необходимыми значениями.

Например, если информация об ip адресе будет содержаться в переменой userip, то словарь параметры может выглядеть следующим образом:

{
    'ip': userip
}

Конструктор счетчика, в таком случае, будет выглядеть так:

    w.yaCounterXXXXXX = new Ya.Metrika({
        id:XXXXXX,
        clickmap:true,
        trackLinks:true,
        accurateTrackBounce:true,
        webvisor:true,
        params:{'ip': userip}
    });

Где XXXXXX идентификатор счетчика.

Чтобы просмотреть полученные результаты необходимо перейти: метрика → отчеты → стандартные отчеты → содержание → параметры визитов

Но, сами по себе ip адреса не столь информативны, интерестнее просмотреть связь посещения и ip адреса в вебвизоре. Для этого в вебвизор нужно добавить столбец “Параметры”.

Определение IP адреса

Выше я упоминал о переменной в которой содержится ip адрес посетителя. Задать эту переменную легко если Вы имеете доступ к бэкэнду.

Например в django, предварительно подключив django.core.context_processors.request:

<script type="text/javascript">
    var userip = "{{ request.META.REMOTE_ADDR }}";
</script>

Или, если Вы используете проксирование:

<script type="text/javascript">
    var userip = "{{ request.META.HTTP_X_REAL_IP }}";
</script>

Или, например, в php:

<script type="text/javascript">
    var userip = "<? echo $_SERVER['REMOTE_ADDR'];?>";
</script>

Но что если сайт статический и какой либо бэкэнд отсутствует? В таком случае можно воспользоваться сервисом l2.io, который позволяет получить ip на клиенте. К примеру Ваш ip адрес:

Чтобы задать ip адрес в переменную, нужно вставить такой скрипт:

<script type="text/javascript" src="https://www.l2.io/ip.js?var=userip"></script>

Полный фрагмент скрипта яндекс метрики будет выглядеть так:

<!-- получаем ip адрес одним из указанных вариантов -->
<script type="text/javascript" src="https://www.l2.io/ip.js?var=userip"></script>
<!-- Yandex.Metrika counter -->
<script type="text/javascript">
    (function (d, w, c) {
        (w[c] = w[c] || []).push(function() {
            try {
                w.yaCounterXXXXXX = new Ya.Metrika({
                    id:XXXXXX,
                    clickmap:true,
                    trackLinks:true,
                    accurateTrackBounce:true,
                    webvisor:true,
                    params:{'ip': userip}
                });
            } catch(e) { }
        });
    // продолжение счетчика
    // ...
</script>
<!-- /Yandex.Metrika counter -->

Вот это поворот…

2015-09-06T15:00:00+03:00

Однажды столкнулся с магическим багом, причину возникновения которого, не удавалось отыскать почти на протяжении месяца. Да что там причину, его даже воспроизвести никак не удавалось. Заказчик постоянно жаловался что изображения обрезаются неправильно, да при том ещё непредсказуемо поворачиваются…

Неуловимая ошибка

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

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

Для обрезки изображений использовалась библиотека django-image-cropping, которая позволяет в админке джанго обрезать изображения при помощи jQuery плагина Jcrop.

Ложные обвинения

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

Тем неменее, усердное тестирование обрезки изображения в различных браузерах выявило сопутствующую ошибку. От браузера, кстати, независящую. Продакшен сервер был оптимизирован под большое количество посетителей. Сам проект представлял из себя регенерируемый, статический сайт, кешированный nginxом; небольшое api для добавления и поиска историй; и административный интерфейс для премодерации историй и перегенерации статического контента.

Так получилось, что nginx слишком усердно справлялся с кешированием, и достаточно часто после обрезки изображения в админке показывал старое (не обрезанное изображение), после чего модератор снова и снова обрезал картинку, а в результате исходное изображение резалось по несуществующим координатам. Соответственно на выходе получалось изкромсаное изображение с черными полосками и когда кеш обновлялся то это становилось заметно.

Данную ошибку с кеширование легко исправить введя случайный GET параметр в адресе изображения перед выводом его в админке. Примерно так:

from random import randint
rand_url = lambda url: '{url}?{num}'.format(url=url, num=randint(10000, 99999))

# ...

return {
    # ...
    'data-thumbnail-url': rand_url(thumbnail(image).url)
    # ...
}

Вследствии чего, проблема отображения старого изображения после обрезки исчезла. В админке выводился следующий html код отображения изображения:

<img id="id_cropping-image"
    src="/src/img/9b/c6/9bc62cfaaf70be365de538b415cbb8df.jpg.800x800_q85_detail_upscale.jpg?80339"
    style="width: 800px; height: 634px;">

Ошибка найдена и ликвидирована. Больше повторятся не должна. Можно торжествовать победу.

Начинаем сначала

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

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

Exif метаданные

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

В графических изображениях дополнительную метаинформацию можно сохранять в формате EXIF. Где среди прочего может содержаться информация об ориентации изображения. Выведя exif данного файла, сразу стало понятно почему ошибка воспроизводится именно на нем.

>>> from PIL import Image
>>> from PIL.ExifTags import TAGS
>>> 
>>> im = Image.open('photo.jpg')
>>> exif = im._getexif()
>>> 
>>> data = {}
>>> 
>>> for tag, value in exif.items():
...   decoded = TAGS.get(tag, tag)
...   data[decoded] = value
... 
>>>
>>> import pprint
>>> pp = pprint.PrettyPrinter(indent=4)
>>>
>>> pp.pprint(data)
{   'ApertureValue': (4281, 1441),
    'ColorSpace': 1,
    'ComponentsConfiguration': '\x01\x02\x03\x00',
    'DateTime': u'2012:09:08 18:10:40',
    'DateTimeDigitized': u'2012:09:08 18:10:40',
    'DateTimeOriginal': u'2012:09:08 18:10:40',
    'ExifImageHeight': 1536,
    'ExifImageWidth': 2048,
    'ExifOffset': 206,
    'ExifVersion': '0221',
    'ExposureMode': 0,
    'ExposureProgram': 2,
    'ExposureTime': (1, 15),
    'FNumber': (14, 5),
    'Flash': 32,
    'FlashPixVersion': '0100',
    'FocalLength': (77, 20),
    'GPSInfo': {   1: u'N',
                   2: ((**, **), (****, ****), (*, *)),
                   3: u'E',
                   4: ((**, **), (****, ****), (*, *)),
                   5: '\x00',
                   6: (25453, 182),
                   7: ((11, 1), (10, 1), (3588, 100)),
                   16: u'M',
                   17: (44274, 191)},
    'ISOSpeedRatings': 100,
    'Make': u'Apple',
    'MeteringMode': 1,
    'Model': u'iPhone 3GS',
    'Orientation': 6,
    'ResolutionUnit': 2,
    'SceneCaptureType': 0,
    'SensingMethod': 2,
    'Sharpness': 1,
    'Software': u'5.1.1',
    'SubjectLocation': (1023, 767, 614, 614),
    'WhiteBalance': 0,
    'XResolution': (72, 1),
    'YCbCrPositioning': 1,
    'YResolution': (72, 1)}
>>>

Как видно из exif данных, изображением является фотография сделанная на iPhone 3GS в сентябре 2012 года. Но это совершенно не важно, главным является информация об ориентации изображения: Orientation 6.

Exif Orientation тег описывает ориентацию изображения при отображении, используя значения от 1 до 8:

  1        2       3      4         5            6           7          8

######  ######      ##  ##      ##########  ##                  ##  ##########
##          ##      ##  ##      ##  ##      ##  ##          ##  ##      ##  ##
####      ####    ####  ####    ##          ##########  ##########          ##
##          ##      ##  ##
##          ##  ######  ######

Наглядно на примере фотокамеры, могут возникать 4 варианта тега ориентации:

PIL & Exif

При сохранении изображения с помощью PIL все метаданные exif стираются, поэтому сохраненная картинка без метаинформации уже не поворачивается при отображении, а остается такая как есть. Тоесть с точки зрения пользователя — непредсказуемо поворачиваются.

>>> # ...
>>> im.save('saved.jpg')
>>> im_saved = Image.open('saved.jpg')
>>> exif = im_saved._getexif()
>>> exif is None
True
>>>

Поворот перед сохранением

Поскольку PIL стирает метаинформацию при сохранении изображения, то будем поворачивать изображение при наличии тега ориентации самостоятельно.

def orient(image_path):
    """ Check are this img oriented """
    img = Image.open(image_path)
    # check is has exif data
    if not hasattr(img, '_getexif') or img._getexif() is None:
        return
    # if has information - try rotate img
    orientation = img._getexif().get(0x112)
    rotate_values = {3: 180, 6: 270, 8: 90}
    if orientation in rotate_values:
        img = img.rotate(rotate_values[orientation])
    img.save(image_path, quality=100)

Данная функция проверяет наличие информации о повороте изображения, и если она присутствует, поворачивает картинку на соответствующий угол. Сохраняя изображение метаинформация стирается, и поэтому, если даже exif orientation тег был не фотоаппаратный (3, 6, 8), а отраженный (2, 4, 5, 7). То картинка будет такой как и есть в действительности, и в случае необходимости, модераторы смогут её повернуть как им нужно.

Вот такой простой функцией решилась эта коварная ошибка.

Наглядный пример

Для большей наглядности, приведем пример неправильной обрезки изображения из-за кеширования, а так же различного поведения изображения с exif ориентацией и без. В качестве исходного изображения будем использовать знаменитую Лену, но для более заметных изменений, не её канонический вариант 512x512, а прямоугольное изображение. Для работы с exif информацией воспользуемся консольной утилитой exiftool.

Ошибка кеширования

Возьмем портретно ориентированное изображение, и попробуем его дважды обрезать на одном и том же превью изображении.

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

Но, на самом деле, изображение в первый раз обрезалось корректно.

Получив повторные координаты для обрезки изображения, происходит следующее.

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

Exif ориентация

Создадим исходное изображение, с ландшафтным соотношение сторон, без заданного тега ориентации.

Отобразим метаинформацию в данном изображении.

$ exiftool lenna_default.jpg
ExifTool Version Number         : 9.46
File Name                       : lenna_default.jpg
Directory                       : .
File Size                       : 79 kB
File Modification Date/Time     : 2015:09:06 10:40:30+03:00
File Access Date/Time           : 2015:09:06 10:49:37+03:00
File Inode Change Date/Time     : 2015:09:06 10:49:12+03:00
File Permissions                : rw-rw-r--
File Type                       : JPEG
MIME Type                       : image/jpeg
JFIF Version                    : 1.01
Exif Byte Order                 : Little-endian (Intel, II)
Orientation                     : Horizontal (normal)
X Resolution                    : 72
Y Resolution                    : 72
Resolution Unit                 : inches
Exif Version                    : 0210
Flashpix Version                : 0100
Color Space                     : Uncalibrated
Exif Image Width                : 463
Exif Image Height               : 584
Image Width                     : 584
Image Height                    : 463
Encoding Process                : Baseline DCT, Huffman coding
Bits Per Sample                 : 8
Color Components                : 3
Y Cb Cr Sub Sampling            : YCbCr4:2:0 (2 2)
Image Size                      : 584x463

Скопируем изображение и установим тег ориентации 6.

$ cp lenna_default.jpg lenna_exif_6.jpg
$ exiftool -n -Orientation=6 lenna_exif_6.jpg
    1 image files updated

Чтобы увидеть поворот откройте изображение в новой вкладке.

Теперь посмотрим какая метаинформация содержится в этом изображении.

$ exiftool lenna_exif_6.jpg
ExifTool Version Number         : 9.46
File Name                       : lenna_exif_6.jpg
Directory                       : .
File Size                       : 79 kB
File Modification Date/Time     : 2015:09:06 10:41:52+03:00
File Access Date/Time           : 2015:09:06 10:49:25+03:00
File Inode Change Date/Time     : 2015:09:06 10:49:18+03:00
File Permissions                : rw-rw-r--
File Type                       : JPEG
MIME Type                       : image/jpeg
JFIF Version                    : 1.01
Exif Byte Order                 : Little-endian (Intel, II)
Orientation                     : Rotate 90 CW
X Resolution                    : 72
Y Resolution                    : 72
Resolution Unit                 : inches
Exif Version                    : 0210
Flashpix Version                : 0100
Color Space                     : Uncalibrated
Exif Image Width                : 463
Exif Image Height               : 584
Image Width                     : 584
Image Height                    : 463
Encoding Process                : Baseline DCT, Huffman coding
Bits Per Sample                 : 8
Color Components                : 3
Y Cb Cr Sub Sampling            : YCbCr4:2:0 (2 2)
Image Size                      : 584x463

Как видно, в тег ориентации установлено значение Rotate 90 CW.

Загрузив данные изображения на сервис - можно увидеть различное поведение:

Изображение без тега ориентации не поворачивается и отображается как есть, с ландшафтным соотношением сторон.

Изображение с тегом ориентации при отображении поворачивается в портретное соотношение сторон.

Второе изображение выглядит как нужно и модератор без сомнений обрезает изображение.

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

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

После использования предварительного поворота изображения, и удаления метаинформации, данное неожиданное поведение исчезает, изображение отображается таким какое оно есть на самом деле. Загружая картинку с тегом ориентации, при сохранении на сервере она сразу сохраняется поворачивается.

Тоесть в случае, если модератор обрезает портретное изображение.

Он получает, правильный портретный результат.

Автоматическое содержание в Pelican

2015-09-02T15:00:00+03:00

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

Якоря в заголовках markdown

Для написания постов блога я использую markdown разметку текста. Для того, чтобы при генерации html заголовкам присваивались якоря - необходимо подключить расширение Table of Contents. Делается это элементарно прописав в pelicanconf.py следующую строчку:

MD_EXTENSIONS = [
    'codehilite(css_class=highlight)', 'extra', 'markdown.extensions.toc' ]

Теперь при генерации html каждому заголовку будет присваиваться id содержащимся текстом. Заголовок:

##Markdown anchors

Будет сгенерирован в такой html:

<h2 id="markdown-anchors">Markdown&nbsp;anchors</h2>

Ссылки в заголовках

Чтобы заголовки были непросто тегами h1 … h6, а содержали ссылку на самих себя нужно добавить аргумент anchorlink. Теперь конфигурация MD_EXTENSIONS выглядит так:

MD_EXTENSIONS = [
    'codehilite(css_class=highlight)', 'extra',
    'markdown.extensions.toc(anchorlink=True)' ]

Заголовок:

##Markdown anchors

Будет сгенерирован в такой html:

<h2 id="markdown-anchors">
    <a class="toclink" href="#markdown-anchors">Markdown&nbsp;anchors</a>
</h2>

Кириллица в заголовках

К сожалению, стандартный slugify который используется в markdown toc не умеет обрабатывать кириллические символы, и поэтому заголовок.

##Ссылка в заголовке

Будет сгенерирован в такой html:

<h2 id="_1">
    <a class="toclink" href="#_1">Ссылка в&nbsp;заголовке</a>
</h2>

Что бы исправить это, можно воспользоваться библиотекой python slugify, задав TocExtension объект slugify. Объект slugify должен быть callable поэтому не обойтись просто строковым указанием аргументов, придется явно импортировать и указывать в конструкторе аргументы для расширения:

from markdown.extensions.toc import TocExtension
from slugify import slugify
MD_EXTENSIONS = [
    'codehilite(css_class=highlight)', 'extra',
    TocExtension(anchorlink=True, slugify=slugify), ]

Меню авто содержания

Для навигации по заголовкам будем использовать jQuery plugin Anchorific.js. Данный плагин умеет самостоятельно присваивать id заголовкам, но поскольку заголовки уже сгенерированы с якорями, то создание ссылок джаваскриптом использоваться не будет, в конструкторе укажем null значения для текста и позиции ссылки в заголовке.

    $('article.content').anchorific({
        anchorClass: null, anchorText: null, spy: true, position: null, anchor: null,
    });

Так же пришлось немного подправить напильником этот плагин, под конкретные задачи, например заставить его искать не все заголовки, а только с идентификаторами.

- self.headers = self.$elem.find( 'h1, h2, h3, h4, h5, h6' );
+ self.headers = self.$elem.find( 'h1[id], h2[id], h3[id], h4[id], h5[id], h6[id]' );

“Липучее” меню

Для того, что бы при скроллинге страницы меню навигации всегда оставалось доступным будем использовать position: fixed;, но присваивать его только при достижении вершины объекта при скроллинге.

Создадим класс sticky и будем навешивать его по событию скролл.

.sticky {
    position: fixed;
    top: 33px;
    z-index: 999;
}

var $window = $(window),
    $sticky = $('div.anchorific'),
    sticky_top = $sticky.offset().top;

$window.scroll(function() {
    $sticky.toggleClass('sticky', $window.scrollTop() > sticky_top - 33);
});

Получилось такое авто содержание:

Загрузка видео на youtube

2015-08-26T18:00:00+03:00

В одном из моих собственных проектов, возникла задача автоматической загрузки видео на канал на youtube. Делается это достаточно просто, при помощи гугловского api клиента для python. Единственное затруднение вызвало полумагическое получение ключей доступа к api.

Авторизация

Все коды доступа и ключи авторизации, использованные в статье, вымышленные.
Любое совпадение с реально существующими или когда-либо существовавшими ключами случайно.

Создание нового проекта

Для авторизации в сервисах google с помощью протокола oauth2 необходимо зарегистрировать приложение и дать ему соответсвующие права. Для этого нужно перейти в консоль разработчика.

Нажимаем на кнопку Create Project, выбираем имя и создаем новое приложение. После того как приложение будет создано, нужно добавить ему необходимые доступы к google API.

Для загрузки видео на youtube нужно добавить YouTube Data API. Для этого переходим во вкладку APIs & auth → APIs. Также во вкладке APIs & auth → Credentials нужно добавить доступы для oauth2 авторизации.

Указываем тип приложения Other. Получаем доступы для авторизации: идентификатор и пароль.

Client ID 230452130504-3uca1rp4ntlh06hdnsdbj50sqagaqfkt.apps.googleusercontent.com
Client secret qawsWCd3J6HTRvnqsjYUpgH9

Права доступа к аккаунту

Получив данные для авторизации, нужно перейти по следующей ссылке, заменив в ней параметр client_id на тот, что Вы получили в предыдущем шаге.

    https://accounts.google.com/o/oauth2/auth?
        client_id=230452130504-3uca1rp4ntlh06hdnsdbj50sqagaqfkt.apps.googleusercontent.com&
        redirect_uri=urn:ietf:wg:oauth:2.0:oob&
        scope=https://www.googleapis.com/auth/youtube&
        response_type=code&
        access_type=offline

Далее выбираем к какому аккаунту гугл будет иметь доступ приложение, и соответсвенно к какому каналу на ютубе.

Соглашаемся с доступом к управлению каналом.

Получаем токен авторизации следующего вида 4/Rw6A9raJQ3PrPWL0Q9z49guYu89FZoz322RySVFtzNc.

Обновляемый токен

После этого необходимо получить, так называемый, refresh_token, для этого нужно отправить POST запрос с токеном авторизации по адресу https://accounts.google.com/o/oauth2/token. Сделать это легко, при помощи консольной утилиты curl.

data=""\
"code=4/Rw6A9raJQ3PrPWL0Q9z49guYu89FZoz322RySVFtzNc&"\
"client_id=230452130504-3uca1rp4ntlh06hdnsdbj50sqagaqfkt.apps.googleusercontent.com&"\
"client_secret=qawsWCd3J6HTRvnqsjYUpgH9&"\
"redirect_uri=urn:ietf:wg:oauth:2.0:oob&"\
"grant_type=authorization_code"

curl --data $data "https://accounts.google.com/o/oauth2/token"

Токен авторизации сработает только один раз, при повторной попытке отправить его будет получено Code was already redeemed.. В ответ на корректный запрос, гугл возвращает json с временным токеном доступа и постоянным обновляемым токеном (собственно он нам и нужен).

{
    "access_token" : "ya29.1wGYJU7NP7Ul69c13aE1Vuvbx0LfxrsgMiBjXdNY3sU3tuE9LmuJ3nOGHeb3e_824LH0",
    "token_type" : "Bearer",
    "expires_in" : 3600,
    "refresh_token" : "1/g1ixyts83iMrtR71oFqwGp3LSGbHz6ByxsBThrHRWCNIgOrJDtdun6zK6XiATCKT"
}

Токен доступа

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

data=""\
"refresh_token=1/g1ixyts83iMrtR71oFqwGp3LSGbHz6ByxsBThrHRWCNIgOrJDtdun6zK6XiATCKT&"\
"client_id=230452130504-3uca1rp4ntlh06hdnsdbj50sqagaqfkt.apps.googleusercontent.com&"\
"client_secret=qawsWCd3J6HTRvnqsjYUpgH9&"\
"grant_type=refresh_token"

curl --data $data "https://accounts.google.com/o/oauth2/token"

В ответ гугл возвращает json с временным токеном доступа.

{
  "access_token" : "ya29.2AHpPjacO0prQkip0svapohuZtoK0wqdh7u0ohH49l0WWwrSyss7CWiwzMy5wX967tWsjQ",
  "token_type" : "Bearer",
  "expires_in" : 3600
}

Автоматическое получение токена доступа

Получать этот токен доступа нужно будет каждые раз, при подключении к api. Для этого напишем простую функцию на python 3 с использованием стандартной библиотеки urllib.request

import json
import urllib
import urllib.request


def get_auth_code():
    """ Get access token for connect to youtube api """
    oauth_url = 'https://accounts.google.com/o/oauth2/token'
    # create post data
    data = dict(
        refresh_token=settings.YOUTUBE_REFRESH_TOKEN,
        client_id=settings.YOUTUBE_CLIENT_ID,
        client_secret=settings.YOUTUBE_CLIENT_SECRET,
        grant_type='refresh_token',
    )

    headers = {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Accept': 'application/json'
    }

    data = urllib.parse.urlencode(data).encode('utf-8')
    # make request and take response
    request = urllib.request.Request(oauth_url, data=data, headers=headers)
    response = urllib.request.urlopen(request)

    # get access_token from response
    response = json.loads(response.read().decode('utf-8'))
    return response['access_token']

Oauth2 авторизация

Вот теперь, мы наконец подошли к самой oauth2 авторизации в сервисах гугл. Для этого необходимо использовать следующие дополнительные библиотеки:

Далее, используя выше описанную функцию получения временного токена, создаем подключение к youtube api.

Вообще в руководстве по работе с youtube api рекомендуют использовать построение oauth2 подключения с использованием объекта flow_from_clientsecrets, примерно так:

def get_authenticated_service(args):
    flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE,
        scope=YOUTUBE_UPLOAD_SCOPE,
        message=MISSING_CLIENT_SECRETS_MESSAGE)

    storage = Storage("%s-oauth2.json" % sys.argv[0])
    credentials = storage.get()

    if credentials is None or credentials.invalid:
        credentials = run_flow(flow, storage, args)

    return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
        http=credentials.authorize(httplib2.Http()))

Но, как выяснилось на практике, такой подход, требует при каждой загрузки, давать разрешение на подключение к аккаунту youtube вручную, это не очень удобно. Учитывая, что можно замечательным образом получать токен авторизации, из обновляемого токена, мы будем использовать для создания oauth2 подключения - объект AccessTokenCredentials.

import httplib2

from oauth2client.client import AccessTokenCredentials
from apiclient.discovery import build


def get_authenticated_service():
    """ Create youtube oauth2 connection """
    # make credentials with refresh_token auth
    credentials = AccessTokenCredentials(
        access_token=get_auth_code(), user_agent='my-awesome-project/1.0'
    )
    # create connection to youtube api
    return build(
        'youtube', 'v3', http=credentials.authorize(httplib2.Http())
    )

Теперь мы имеем созданное подключение, которое можно использовать для работы с api.

Загрузка видео

Имея готовое подключение к api загрузка видео происходит элементарно.

Определим функцию инициализации загрузки, которая принимает в качестве аргументов подключение к youtube api и объект с информацией о видео.

from apiclient.http import MediaFileUpload


def initialize_upload(youtube, card):
    """ Create youtube upload data """
    # create video meta data
    body = card.youtube_meta_data()
    # Call the API's videos.insert method to create and upload the video
    insert_request = youtube.videos().insert(
        part=",".join(body.keys()), body=body,
        media_body=MediaFileUpload(card.video.path, chunksize=-1, resumable=True))
    # wait for file uploading
    return resumable_upload(insert_request)

Метод youtube_meta_data должен возвращать словарь описания видео согласно формату, например:

{
    "snippet": {
        "title": "Summer vacation in California",
        "description": "Had fun surfing in Santa Cruz",
        "tags": ["surfing", "Santa Cruz"],
        "categoryId": "22"
    },
    "status": {
        "privacyStatus": "private"
    }
}

В моем случае данный метод имел следующий вид:

    def youtube_meta_data(self):
        """ Create metadata dict for youtube video upload """
        return dict(
            snippet=dict(
                title=settings.YOUTUBE_TITLE.format(coord=self.position),
                tags=settings.YOUTUBE_TAGS,
                categoryId=settings.YOUTUBE_CATEGORY_ID,
                description='{desc}\n{site_url}/{card_id}'.format(
                    desc=self.description, site_url=settings.SITE_URL, card_id=self.get_absolute_url()),
            ),
            status=dict(
                privacyStatus=settings.YOUTUBE_PRIVACY_STATUS,
            ),
            recordingDetails=dict(
                location=dict(
                    latitude=str(self.position.latitude),
                    longitude=str(self.position.longitude),
                ),
            ),
        )

После инициализации загрузки, необходимо поддерживать соединение и дождаться ответа от ютуба с идентификатором видео. Для этого будем использовать следующую функцию.

import random
import http
import httplib2

# Explicitly tell the underlying HTTP transport library not to retry, since we are handling retry logic ourselves.
httplib2.RETRIES = 1

# Maximum number of times to retry before giving up.
MAX_RETRIES = 10

# Always retry when these exceptions are raised.
RETRIABLE_EXCEPTIONS = (
    httplib2.HttpLib2Error, IOError, http.client.NotConnected,
    http.client.IncompleteRead, http.client.ImproperConnectionState,
    http.client.CannotSendRequest, http.client.CannotSendHeader,
    http.client.ResponseNotReady, http.client.BadStatusLine)

# Always retry when an apiclient.errors.HttpError with one of these status codes is raised.
RETRIABLE_STATUS_CODES = (500, 502, 503, 504)


def resumable_upload(insert_request):
    response = None
    error = None
    retry = 0
    while response is None:
        try:
            status, response = insert_request.next_chunk()
            if 'id' in response:
                return response['id']
        except HttpError as err:
            if err.resp.status in RETRIABLE_STATUS_CODES:
                error = True
            else:
                raise
        except RETRIABLE_EXCEPTIONS:
            error = True

        if error:
            retry += 1
            if retry > MAX_RETRIES:
                raise Exception('Maximum retry are fail')

            sleep_seconds = random.random() * 2 ** retry
            time.sleep(sleep_seconds)

Таким образом, загрузка видео запускается функцией initialize_upload:

video_id = initialize_upload(get_authenticated_service(), card)

Полный код загрузки видео можно посмотреть в gist.

Санкции

Поскольку капиталистический запад, в лице корпорации зла, наложил на меня свои, безосновательные, санкции. Ограничив тем самым мое право доступа к свободной информации. Для работы с youtube api мне необходимо использовать vpn подключение.

VPN соединение

В качестве vpn соединения я использую ssh туннель и локальное socks5 прокси на 1080 порту. Включаю/отключаю ssh тунель при помощи библиотеки subprocess.

import subprocess

# init ssh connection
subprocess.Popen(['ssh', '-fN', '-D', '1080', 'forward@vpn_connection'])

# desctroy ssh connection
subprocess.Popen(['pkill', '-f', 'forward@vpn_connection'])

Не правильно

Что бы подключиться к локальному socks5 прокси, необходимо использовать библиотеку socksipy, как показано в примере работы с httplib2:

import httplib2
import socks

h = httplib2.Http(proxy_info = httplib2.ProxyInfo(socks.PROXY_TYPE_SOCKS5, 'localhost', 1080))
r, c = h.request('https://l2.io/ip')

Правильно

Но, вышеуказанный способ не работает. Библиотека socksipy не поддерживает python 3, поэтому необходимо делать по-другому. Использовать библиотеку socksipy-branch (gist зеркало). И оборачивать httplib2 с помощью метода wrapmodule:

import httplib2
import socks

socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, 'localhost', 1080)
socks.wrapmodule(httplib2)
h = httplib2.Http()
r, c = h.request('https://l2.io/ip')

200 дней кряду…

2015-08-08T18:00:00+03:00

Продолжаю ежедневно коммитить, вот уже 200 дней. До конца года осталось меньше половины, а сначала казалось что это невозможно долго.

Первый стодневный стреак

2015-04-30T21:50:00+03:00

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

Ралли на браузерах

2015-04-05T19:30:00+03:00

Собственный проект WB—Tech по комментированию скриншотов coment.me на сегодняшний день, для получения снимка сайта использует связку selenium + firefox. Данный подход решает задачи получения скриншота, однако тратит достаточно много памяти, и к тому же со временем накапливается большое количество повисших процессов, что в свою очередь приводит к подвисанию сервиса. В связи с этим, необходимо исследовать доступные варианты и определить наилучший из браузеров для автоматического создания скриншотов.

Критерииями для выбора победителя будут являтся:

Качество скриншотов
Скорость работы
Затрачиваемые ресурсы

Участники соревнований

На участие в ралли были отобранны следующие кандидаты:

Firefox 36.0.1
Google Chrome 41.0.2272.89
Chromium Not tested
Splash 1.5
Ghost.py 0.1.1
Zombie.js 0.2.0
Pantom.js 1.9.8, 2.0.0
Slimer.js 0.9.5, 0.10.0pre

Познакомимся с участниками поближе:

Firefox — Наиболее массовый не WebKit браузер на сегодняшний день.
Google Chrome / Chromium — Один из самых быстрых и популярных браузеров.
Splash — легкий браузер с поддержкой javascript реализовыннй на python-е предоставляюший для управления http api.
Ghost.py — python браузер с поддержкой javascript ориентированный на автоматическое функциональное тестирование.
Zombie.js — легкий и быстрый безголовый браузер для автоматического тестирования основаный на node.js.
Phantom.js — быстрый безголовый браузер на движке WebKit со встроенной поддержкой svg. Управляется при помощи javascript api.
Slimer.js — быстрый браузер, похожий на phantom.js, однако использует движок Gecko от firefox. Управляется при помощи javascript api.

Итак, участники отобраны, и готовы показать себя во всей красе, что ж — приступим к соревнованиям.

Трасса

Нашим замечательным конкурсантам предстоит пройти трек по пересеченной местности с четырьмя крутыми поворотами с 16-ю чекпоинтами, а именно: показать свои навыки на следующих ресурсах:

при следующих разрешениях экранов по ширине: 240, 780, 1320, 1920 пикселей.

Заезд первый — “Качество”

Проверка качества скриншотов

Качество — это делать что-либо правильно, даже когда никто не смотрит.

Поскольку, в конечном счете, результат должен быть не хуже, чем имеющийся на настоящий момент — эталоном качества будут выступать снимки firefox-а.

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

Только видимая область

Для связки selenium-а и google chrome необходимо использовать chromedriver текущая стабильная версия 2.14. И, как оказалось, в нем содержится баг, который тянется с 2013 года, известным issue. Хром драйвер не пролистывает окно браузера при захвате изображения, а делает снимок видимой области.

Так что Google Chrome и Chromium не прошли данный этап.

Неверный resize

Безголовый браузер Splash, запускается демоном и слушает localhost:8050, по которому предоставляет http api управления браузером. Для сохранения скриншота необходимо указать адрес сайта и ширину окна браузера.

request = 'http://localhost:8050/render.png?url={url}&width={res}&render_all=1&wait=1'.format(url=url, res=res)
res = subprocess.check_call(['curl', request, '-o', save_as])

Однако, как оказалось, ширина окна браузера всегда 1024px, а параметр width влияет только на фактическую ширину полученного изображения, к тому же сжатого как thumbnail.

240px

780px

Так что splash не прошел данный этап.

Как оказалось, Зомби вообще не умеет делать скриншоты, поэтому выбывает из соревнований.

Фальшивые паспорта — старый гугл

Некоторые из участников соревнований, а именно Phantom.js и Slimer.js не смогли бы пройти все этапы ралли, под своими именами, поэтому пришлось выдать им фальшивые паспорта.

Google выдает различные версии сайта, в зависимости от того: какой user agent у браузера запрашивающего страницу, и если этот агент неизвестный или старый, то выдается старая версия google, с черной полоской меню.

Phantom.js 240px

Slimer.js 240px

Но при использовании поддельных паспортов, от firefox результат такой как нужно.

'Mozilla/5.0 (X11; Linux x86_64) Gecko/20100101 Firefox/36.0'

Пикселизация — выколи глаза.

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

Хоть это и недопустимо, однако, ограничимся предупреждением, и пропустим Ghost.py в следующий тур.

Результаты первого заезда

Во второй тур прошли 4 участника и 4 участника покинули соревнования. Турнирная таблица по окончанию первого этапа.

Firefox
Pantom.js
Slimer.js
Ghost.py
~~Chromium~~
~~Google Chrome~~
~~Splash~~
~~Zombie.js~~

Заезд второй — “Скорость”

Проверка скорости работы браузеров

На данном этапе измерялось время, необходимое для создания браузера, открытия нужной страницы, изменения ширины окна до заданной, сохранения страницы как изображения PNG, закрытия страницы и уничтожения объекта браузера.

Измерения проводились при помощи стандартной библиотеки time, как разница времени между началом запуска функции и её окончания.

import time
# ...
    start = time.time()
    # call test browser fun()
    end = time.time()
# ...
    times.append(end - start)

Легенда:

Time

Результаты второго заезда

В ходе данного этапа участники заняли следующие места:

Phantom.js 2.x
Phantom.js 1.x
Ghost.py
Phantom.js 1.x + selenium
Phantom.js 2.x + selenium
Slimer.js 9.x
Slimer.js 10.x
Firefox + selenium

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

Заезд третий — “Ресурсы”

Анализ затрат ресурсов на создание скриншота

Учитывалась память, которую тратит главный процесс, и все его дочерние процессы. Память измерялась при помощи функции memory_usage библиотеки memory_profiler с указанием параметра include_children.

Измерялась минимальная, средняя и максимальная память для каждого скриншота.

from memory_profiler import memory_usage
# ...
    memory = memory_usage((fun, args), include_children=True)
# ...
    mins.append(min(memory))
    maxs.append(max(memory))
    avgs.append(avg(memory))

Ненасытное привидение

Ghost.py оказался чрезвычайно прожорливым, занимая всю доступную память, доходил до максимума и вылетал. Единственный из участников, кто не сумел пройти все 16 чекпоинтов за один подход.

Учитывая вынесенное ранее предупреждение, призрак вылетает из конкурса!

I ain’t afraid of no ghosts

Двуличный хитрец

Оказалось, что Slimer.js притворяется: запускается дочерний процесс slimerjs, который потребляет не более 3 Mb памяти, но при этом запускает ещё один дочерний процесс с именем firefox, который уже добирает память до 300 Mb.

Общие затраты памяти

Поскольку Ghost.py потребляет уж слишком много ресурсов, на графиках не указывается.

Легенда:

Memory max

Memory avg

Результаты третьего заезда

В ходе данного этапа участники заняли следующие места:

Phantom.js 1.x
Phantom.js 2.x
Phantom.js 1.x + selenium
Phantom.js 2.x + selenium
Slimer.js 9.x
Slimer.js 10.x
Firefox + selenium
Ghost.py

На этом этапе выбывает Ghost.py, турнирная таблица принимает вид:

Pantom.js
Slimer.js
Firefox
~~Ghost.py~~

Заезд четвертый — “Управляемость”

Методы управление браузерами

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

Firefox

Firefox работает в связке с selenium-ом и управляется достаточно просто, единственная особенность — это то, что браузер запускает графическую оболочку, поэтому нужно использовать виртуальный дисплей.

from selenium import webdriver
from pyvirtualdisplay import Display
# ...
with Display(visible=0, size=(1024, 768), backend='xvfb'):
    browser = Browser(**param)
    browser.set_window_size(width, 768)
    browser.get(url)
    browser.save_screenshot(save_as)
    browser.quit()

Phantom

Phantom.js можно использовать, как самостоятельный безголовый браузер, так и в связке с selenium-ом. Работа с selenium-ом аналогична firefox, за тем лишь исключением, что нет необходимости запускать виртуальный дисплей.

Собственная работа phantom.js, заключается в вызове консольной команды, и передаче ей скрипта для выполнения браузером.

var page = require('webpage').create();
page.settings.userAgent = 'Mozilla/5.0 (X11; Linux x86_64) Firefox/36.0';
page.viewportSize = { width:1920, height:768 };
page.open('http://wbtech.pro/', function (status) {
    page.render('img/phantomjs2-no_selenium/wbtech.pro-1920px.png');
    phantom.exit();
});

В python запускаем браузер с помощью стандартной библиотеки subprocess.

import subprocess
# ...
subprocess.check_call([phantom_path, script_path, '--ssl-protocol=any'])

Slimer

Slimer.js работает точно так же, как и phantom.js без selenium-а, но является не совсем безголовым, он запускает графическую оболочку, поэтому требует виртуальный дисплей.

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

var page = require('webpage').create();
page.viewportSize = { width:1024, height:768 };
page.settings.userAgent = 'Mozilla/5.0 (X11; Linux x86_64) Firefox/36.0';
page.open('http://wbtech.pro/', function (status) {
    page.viewportSize = { width:1920, height:768 };
    page.render('img/slimerjs10/wbtech.pro-1920px.png');
    page.close();
    slimer.exit();
});

В python запускаем браузер с помощью стандартной библиотеки subprocess.

from pyvirtualdisplay import Display
import subprocess
# ...
with Display(visible=0, size=(1024, 768), backend='xvfb'):
    subprocess.check_call([slimer_path, script_path, '--ssl-protocol=any'])

Финиш

Гонка завершилась, пришло время подвести итоги и определить победителей.

До финиша доехали всего три команды, так что тройка лидеров очевидна. Учитывая затраты ресурсов и времени, участники занимают следующие места:

Phantom.js 2.x
Phantom.js 1.x
Phantom.js 1.x + selenium
Phantom.js 2.x + selenium
Slimer.js 9.x
Slimer.js 10.x
Firefox + selenium

Безоговорочным лидером гонки стал phantom.js, в качестве награды ему будет предложено занять пост firefox-а на сервисе coment.me.

Ура, меня в гугле забанили…

2015-01-30T15:00:00+03:00

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

Старый анекдот про “в гугле забанили” начинает быть похожим на действительность.

При попытке перейти получаем 403. Некоторые из заблокированных ресурсов:

Так же не работают в целом сайты размещенные на gae, например https://www.udacity.com/.

Не работает обновление google chrome и приложений из плей маркета.

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