= Документация к веб-серверу Tornado =

{{http://www.tornadoweb.org/static/tornado.png}}

[[http://www.tornadoweb.org|Tornado]] - открытая версия масштабируемого, неблокирующего веб сервера, а также набор инструментов, которые используются сервисом [[http://friendfeed.com|FriendFeed]]. Приложение [[http://friendfeed.com|FriendFeed]] написано с использованием фреймворка, который выглядит как web.py или веб приложение Google, но имеет ряд дополнительных инструментов и оптимизаций, добавленых с целью получения всех выгод от низлежащей неблокирующей инфраструктуры.

<<TableOfContents()>>

= Обзор =

Веб-сервер, который обслуживает сервис [[http://friendfeed.com|FriendFeed]] - относительно простой, неблокирующий веб сервер, написанный на языке Python.

[[http://www.tornadoweb.org|Tornado]] - открытая версия масштабируемого, неблокирующего веб сервера, а также набор инструментов, которые используются сервисом [[http://friendfeed.com|FriendFeed]]. Данный фреймворк отличается от большинства мейнстримовских (и, определенно, от большинства Python фреймворков), потому что использование неблокирующего принципа дает порядочное ускорение. Благодаря этому, а также благодаря использованию [[http://www.kernel.org/doc/man-pages/online/pages/man4/epoll.4.html|epoll]], он может обрабатывать тысячи одновременных соединений, а это значит, что этот фреймворк идеален для создания веб сервисов реального времени. Мы построили веб сервер конкретно для того, чтобы обрабатывать функции сервиса [[http://friendfeed.com|FriendFeed]] в реальном времени: каждый активный пользователь поддерживает открытое соединение с серверами. (Для получения дополнительной информации о масштабировании серверов для поддержки тысяч клиентов, прочитайте о [[http://www.kegel.com/c10k.html|проблеме C10K]].)

= Загрузка =

Загрузите последнюю версию Tornado с !GitHub:

 [[http://www.tornadoweb.org/static/tornado-0.2.tar.gz|tornado-0.2.tar.gz]]

На !GitHub Вы также можете просмореть [[http://github.com/facebook/tornado/|исходный код]], включающий в себя [[http://github.com/facebook/tornado/tree/master/demos/|демонстрационные приложения]]. Чтобы установить Tornado:

{{{#!highlight bash
tar xvzf tornado-0.2.tar.gz
cd tornado-0.2
python setup.py build
sudo python setup.py install
}}}

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

{{{#!highlight bash
./demos/helloworld/helloworld.py
}}}

== Подготовка ==

Tornado тестировался на Python 2.5 и 2.6. Для того, чтобы использовать все функции Tornado, вам нужны библиотеки [[http://pycurl.sourceforge.net/|PycURL]] и JSON, например [[http://pypi.python.org/pypi/simplejson|simplejson]]. Полные инструкции по установке на Mac OS X и Ubuntu показаны ниже.

'''Mac OS X 10.5/10.6'''

{{{#!highlight bash
sudo easy_install setuptools pycurl==7.16.2.1 simplejson
}}}

'''Ubuntu Linux'''

{{{#!highlight bash
sudo apt-get install python-dev python-pycurl python-simplejson
}}}

= Список модулей =

Наиболее важный модуль - ''web''. Он является фреймворком, включающим в себя большинство функций пакета Tornado. Другие модули - это инструменты, которые делают модуль ''web'' богаче. Смотрите [[#Руководство|Руководство по Tornado]] ниже для получения более полной информации о пакете ''web''.

== Основные модули ==

 * [[http://github.com/facebook/tornado/blob/master/tornado/web.py|web]] - веб фреймворк, на котором построен !FriendFeed. '''web''' содержит большинство важных функций Tornado
 * [[http://github.com/facebook/tornado/blob/master/tornado/escape.py|escape]] - методы кодирования/декодирования XHTML, JSON и URL
 * [[http://github.com/facebook/tornado/blob/master/tornado/database.py|database]] - Простая обертка вокруг MySQLdb для упрощения спользования СУБД MySQL
 * [[http://github.com/facebook/tornado/blob/master/tornado/template.py|template]] - язык шаблонов, в основу которого положен синтаксис языка Python
 * [[http://github.com/facebook/tornado/blob/master/tornado/httpclient.py|httpclient]] - неблокирующий HTTP клиент для работы с модулями '''web''' и '''httpserver'''
 * [[http://github.com/facebook/tornado/blob/master/tornado/auth.py|auth]] - реализация схем аутентификации и авторизации от третих разработчиков (Google OpenID/OAuth, Facebook Platform, Yahoo BBAuth, !FriendFeed OpenID/OAuth, Twitter OAuth)
 * [[http://github.com/facebook/tornado/blob/master/tornado/locale.py|locale]] - поддержка локализации/интернационализации
 * [[http://github.com/facebook/tornado/blob/master/tornado/options.py|options]] - синтаксический анализатор файлов настроек и аргументов коммандной строки, оптимизированный для использования в среде сервера

== Низкоуровневые модули ==

 * [[http://github.com/facebook/tornado/blob/master/tornado/httpserver.py|httpserver]] - очень простой HTTP сервер, на основе которого построен модуль '''web'''
 * [[http://github.com/facebook/tornado/blob/master/tornado/iostream.py|iostream]] - простая обертка вокруг неблокирующих сокетов для обеспечения общих шаблонов считывания и записи
 * [[http://github.com/facebook/tornado/blob/master/tornado/ioloop.py|ioloop]] - основная петля ввода/вывода

== Другие модули ==

 * [[http://github.com/facebook/tornado/blob/master/tornado/s3server.py|s3server]] - веб сервер, который реализует большую часть интерфейса Amazon S3, с локальным файловым хранилищем данных

= Руководство =

== Обработчики и параметры запросов ==

Веб Приложение Tornado отображает (maps) URL или шаблоны URL в подклассы '''tornado.web.!RequestHandler'''. Эти классы определяют '''get()''' и '''post()''' методы для обработки запросов HTTP GET и POST по заданному URL.

Код, что приводится ниже, отображает корневой URL '''/''' в '''!MainHandler''', а шаблон URL '''/story/([0-9]+)''' в '''!StoryHandler'''. Регулярные выражения передаются в качестве аргументов методам класса '''!RequestHandler''':

{{{#!highlight python
class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("You requested the main page")

class StoryHandler(tornado.web.RequestHandler):
    def get(self, story_id):
        self.write("You requested the story " + story_id)

application = tornado.web.Application([
    (r"/", MainHandler),
    (r"/story/([0-9]+)", StoryHandler),
])
}}}

С помощью метода '''get_argument()''' вы можете получить аргументы строки запроса и распарсить тело POST запроса:

{{{#!highlight python
class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write('<html><body><form action="/" method="post">'
                   '<input type="text" name="message">'
                   '<input type="submit" value="Submit">'
                   '</form></body></html>')

    def post(self):
        self.set_header("Content-Type", "text/plain")
        self.write("You wrote " + self.get_argument("message"))
}}}

Если вы хотите отправить сообщение об ошибке клиенту, например, '''403 Unauthorized''', вам достаточно вызвать исключение '''tornado.web.HTTPError''':

{{{#!highlight python
if not self.user_is_logged_in():
    raise tornado.web.HTTPError(403)
}}}

Обработчик запросов имеет доступ к объекту, который отражает состояние текущего запроса через атрибут '''self.request'''. Объект HTTPRequest object содержит ряд полезных атрибутов, среди них:

 * '''arguments''' - все аргументы GET и POST запроса
 * '''files''' - все загруженные файлы (через запросы '''multipart/form-data POST''')
 * '''path''' - путь запроса (все, что находится в строке запроса перед '''?''')
 * '''headers''' - заголовки запроса

Смотрите определение класса HTTPRequest в модуле '''httpserver''' для получения полного списка атрибутов.

== Шаблоны ==

Вы можете использовать любой язык шаблонов, поддерживаемый языком Python, но Tornado имеет свой собственный, который намного быстрее и гибче, чем множество популярных систем шаблонов. Для получения полной информации обратитесь к документации по модулю [[http://github.com/facebook/tornado/blob/master/tornado/template.py|template]].

Шаблон Tornado - простой HTML (или другой текстовый формат), содержащий вложенные управляющие последовательности, которые являются выражениями, заключенными в разметку:

{{{#!highlight html
<html>
   <head>
      <title>{{ title }}</title>
   </head>
   <body>
     <ul>
       {% for item in items %}
         <li>{{ escape(item) }}</li>
       {% end %}
     </ul>
   </body>
 </html>
}}}

Если вы сохранили этот шаблон как "template.html", и положили в ту же папку, что и файл Python, отобразите этот шаблон следующим образом:

{{{#!highlight python
class MainHandler(tornado.web.RequestHandler):
    def get(self):
        items = ["Item 1", "Item 2", "Item 3"]
        self.render("template.html", title="My title", items=items)
}}}

Шаблоны Tornado поддерживают управляющие последовательности и выражения. Управляющие последовательности заключены в символы '''{%''' и '''%}''', например, '''{% if len(items) > 2 %}'''. Выражения заключены в символы '''{ { и } }''', например, '''{ { items[0] } }'''.

Управляющие последовательности более менее точно соответствуют предложениям языка Python. Мы поддерживаем '''if''', '''for''', '''while''', и '''try''', каждое из которых заканчивается последовательностью символов '''{% end %}'''. Мы также поддерживаем наследование шаблонов через предложения '''extends''' и '''block''', которые более детально описаны в документации к модулю '''template'''.

Выражения могут быть любыми, соответствующими языку Python, включая вызовы функций. Мы поддерживаем функции '''escape''', '''url_escape''', и '''json_encode''' по молчанию, но вы можете передать любые другие функции в шаблон через ключевые аргументы функции '''render''' модуля '''template''':

{{{#!highlight python
class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.render("template.html", add=self.add)

    def add(self, x, y):
        return x + y
}}}

Когда вы разрабатываете реальное приложение, возможно вы захотите использовать все функции шаблонов Tornado, особенно наследование. Почитайте о всех функциях шаблонов в документации к модулю  [[http://github.com/facebook/tornado/blob/master/tornado/template.py|template]].

Под капотом шаблоны Tornado транслируются прямо в Python. Выражения из шаблонов копируются без изменений в Python функцию, которая представляет шаблон. Мы не пытаемся предостеречь вас от каких либо действий в языке шаблонов; мы создали его для того, чтобы обеспечивать гибкость, которая не свойственна другим, более строгим языкам шаблонов. Следовательно, если вы напишите внутри выражений какую-нибудь несуразицу, то получите ошибки Python во время выполнения.

== Cookies и защищенные cookies ==

cookies можно установить в обозревателе пользователя с помощью метода '''set_cookie''':

{{{#!highlight python
class MainHandler(tornado.web.RequestHandler):
    def get(self):
        if not self.get_cookie("mycookie"):
            self.set_cookie("mycookie", "myvalue")
            self.write("Your cookie was not set yet!")
        else:
            self.write("Your cookie was set!")
}}}

Часто бывает, что cookies очень просто подделываются зловредными клиентами. Если вам нужно установить cookies чтобы, например, сохранить идентификатор авторизованного пользователя, вам следует их подписать для предотвращения подделки. Tornado предоставляет такую возможность из коробки через использование методов '''set_secure_cookie''' и '''get_secure_cookie'''. Чтобы использовать эти методы, вы должны указать секретный ключ, который называется '''cookie_secret''', когда создаете приложение. Для реализации этого вам нужно передать его в настройках приложения как ключевой аргумент:

{{{#!highlight python
application = tornado.web.Application([
    (r"/", MainHandler),
], cookie_secret="61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=")
}}}

Подписанные cookies содержат закодированное значение cookie плюс timestamp и подпись (сигнатуру) HMAC. Если cookie устарела, или подпись не совпадает, метод '''get_secure_cookie''' вернет '''None''', как будто cookie не была установлена. Вот защищенная версия примера, приводимого выше:

{{{#!highlight python
class MainHandler(tornado.web.RequestHandler):
    def get(self):
        if not self.get_secure_cookie("mycookie"):
            self.set_secure_cookie("mycookie", "myvalue")
            self.write("Your cookie was not set yet!")
        else:
            self.write("Your cookie was set!")
}}}

== Аутентификация пользователей ==

Проверка подлинности пользователя доступна в каждом обработчике запроса как '''self.current_user''', и в каждом шаблоне как '''current_user'''. По умолчанию '''current_user''' имеет значение None.

Для осуществления аутентификации в вашем приложении вам нужно переопределить метод '''get_current_user()''' в вашем обработчике запроса, чтобы определить текущего пользователя, например, значение куки. Ниже приведен пример, который позволяет пользователям войти в приложение просто указав ник, который потом сохраняется в куке:

{{{#!highlight python
class BaseHandler(tornado.web.RequestHandler):
    def get_current_user(self):
        return self.get_secure_cookie("user")

class MainHandler(BaseHandler):
    def get(self):
        if not self.current_user:
            self.redirect("/login")
            return
        name = tornado.escape.xhtml_escape(self.current_user)
        self.write("Hello, " + name)

class LoginHandler(BaseHandler):
    def get(self):
        self.write('<html><body><form action="/login" method="post">'
                   'Name: <input type="text" name="name">'
                   '<input type="submit" value="Sign in">'
                   '</form></body></html>')

    def post(self):
        self.set_secure_cookie("user", self.get_argument("name"))
        self.redirect("/")

application = tornado.web.Application([
    (r"/", MainHandler),
    (r"/login", LoginHandler),
], cookie_secret="61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=")
}}}

Вы можете потребовать, чтобы пользователь аутентифицировался в приложении используя декоратор '''tornado.web.authenticated'''. Если запрос передается методу с этим декоратором и пользователь не залогинен он будет перенаправлен на '''login_url''' (который вы указываете в настройках приложения). Перепишем пример выше с использованием этого декоратора:

{{{#!highlight python
class MainHandler(BaseHandler):
    @tornado.web.authenticated
    def get(self):
        name = tornado.escape.xhtml_escape(self.current_user)
        self.write("Hello, " + name)

settings = {
    "cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
    "login_url": "/login",
}
application = tornado.web.Application([
    (r"/", MainHandler),
    (r"/login", LoginHandler),
], **settings)
}}}

Если вы используете этот декоратор аутентификации для метода '''post()''' и пользователь не залогинен, то сервер пошлет в ответ ошибку 403.

Tornado поставляется со встроенной поддержкой схем аутентификации сторонних производителей, например [[http://code.google.com/intl/ru-RU/apis/accounts/docs/OAuth.html|Google OAuth]]. Посмотрите документуацию по модулю [[http://github.com/facebook/tornado/blob/master/tornado/auth.py|auth]] для получения подробной информации, либо раздел документации посвященный аутентификации с помощью сторонних разработчиков.

Также рекомендуем ознакомиться с демонстрационным приложением [[http://github.com/facebook/tornado/tree/master/demos/blog/|Blog]], идущим в комплекте с Tornado, чтобы получить представление об устройстве приложения, использующего аутентификацию и сохраняющего пользовательские данные в БД [[http://www.mysql.com/|MySQL]]

== Защита от CSRF ==

[[http://en.wikipedia.org/wiki/Cross-site_request_forgery|Cross-site request forgery]], или XSRF (CSRF) - обычная проблема персонализированных веб приложений. Суть этой уязвимости сводится к тому, что размещенная злоумышленником внешняя ссылка на сайт или форма, отправляя внешний GET или POST запрос может использовать активную аутентифицированную сессию пользователя на атакуемом сайте, чтобы отправить определенный запрос "от его имени".
Смотрите [[http://en.wikipedia.org/wiki/Cross-site_request_forgery|статью в википедии]] для получения более полной информации о, как работает XSRF.

Общепринятое решение для предотвращения XSRF - устанавливать cookie для каждого пользователя с непредсказуемым значением и включать это значение как дополнительный аргумент в каждую форму на вашем сайте. Если cookie и ее значение при отправке формы не совпадают, то запрос определяется как подделанный.

Tornado содержит встроенную защиту от XSRF. Для ее активирования, включите опцию '''xsrf_cookies''' в настройках приложения:

{{{#!highlight python
settings = {
    "cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
    "login_url": "/login",
    "xsrf_cookies": True,
}
application = tornado.web.Application([
    (r"/", MainHandler),
    (r"/login", LoginHandler),
], **settings)
}}}

Если '''xsrf_cookies''' установлена, веб приложение Tornado будет устанавливать '''_xsrf''' cookie для всех пользователей и отклонять все POST запросы, которые не содержать верного значения '''_xsrf'''. Если вы включите эту опцию, вы должны включить поле во все формы, которые отправляются на сервер посредством POST запроса. Сделать это можно специальной функцией '''xsrf_form_html()''', которая доступна во всех шаблонах по умолчанию:

{{{#!highlight html
<form action="/login" method="post">
  {{ xsrf_form_html() }}
  <div>Username: <input type="text" name="username"/></div>
  <div>Password: <input type="password" name="password"/></div>
  <div><input type="submit" value="Sign in"/></div>
</form>
}}}

Если вы отправляете AJAX POST запросы, вам также следует включить в !JavaScript значение '''_xsrf''' при выполнении каждого запроса. Нже показана функция jQuery, которая используется в !FriendFeed для AJAX POST запросов, автоматически добавляя значение '''_xsrf''' во все запросы:

{{{#!highlight javascript
function getCookie(name) {
    var r = document.cookie.match("\\b" + name + "=([^;]*)\\b");
    return r ? r[1] : undefined;
}

jQuery.postJSON = function(url, args, callback) {
    args._xsrf = getCookie("_xsrf");
    $.ajax({url: url, data: $.param(args), dataType: "text", type: "POST",
        success: function(response) {
        callback(eval("(" + response + ")"));
    }});
};
}}}

== Статические файлы и агрессивное кеширование файлов ==

Вы можете обслуживать статические файлы с помощью Tornado, через указание настройки '''static_path''' в вашем приложении.

{{{#!highlight python
settings = {
    "static_path": os.path.join(os.path.dirname(__file__), "static"),
    "cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
    "login_url": "/login",
    "xsrf_cookies": True,
}
application = tornado.web.Application([
    (r"/", MainHandler),
    (r"/login", LoginHandler),
], **settings)
}}}

Эта настройка автомтически сделает все запросы, которые начинаются со '''/static/''' обслуживаемыми из директории для статичных файлов, например [[http://localhost:8888/static/foo.png|http://localhost:8888/static/foo.png]] использует '''foo.png''' из директории '''static_path'''. Также Tornado автоматически обслужвает файлы '''/robots.txt''' и '''/favicon.ico''' из директории статики (даже если перфикс '''/static/''' не указан).

В случае с браузерами, то неплохой идеей для увеличения производительности является агрессивное кэширование ресурсов, так чтобы не посылать ненужные запросы '''If-Modified-Since''' или '''Etag''', ожидание обработки которых блокирует отображение страницы. Торнадо, будучи развернутым, сразу предоставляет такую возможность с помощью контроля версий статического контента.

Чтобы использовать эту особенность нужно вызвать метод '''static_url()''' из вашего шаблона вместо того, чтобы вводить напрямую путь к статичному файлу в HTML:

{{{#!highlight html
<html>
   <head>
      <title>FriendFeed - {{ _("Home") }}</title>
   </head>
   <body>
     <div><img src="{{ static_url("images/logo.png") }}"/></div>
   </body>
 </html>
 }}}
 
Функция '''static_url()''' преобразует относительный путь в URI вроде '''/static/images/logo.png?v=aae54'''. Аргумент '''v''' - это хэш содержимого '''logo.png''', и его наличие говорит Tornado отослать заголовки браузеру пользователя, что, в свою очередь, заставляет браузер кэшировать статичный файл на неопределенно долгове время.
 
Так как аргумент '''v''' основан на содержимом файла, то если вы изменяете файл и перезапускаете сервер, начинает передаваться новое значение '''v''' и браузер пользователя загрузит новую версию файла. Если содержимое файла не изменилось, браузер продолжит использовать локальный кэш даже не проверяя изменения на сервере, что существенно увеличивает скорость отображения страницы.
 
В производстве вы возможно захотите обслуживать статику более оптимизированным для этой цели сервером вроде [[http://nginx.net/|nginx]]. Вы можете сконфигурировать почти любой web-сервер так, чтобы он поддерживал подобную семантику кэширования. Вот пример конфигурации nginx, который мы изпользуем в проекте [[http://friendfeed.com|FriendFeed]]
 
{{{#!highlight bash
location /static/ {
   root /var/friendfeed/static;
   if ($query_string) {
       expires max;
   }
}
}}}

== Локализация ==

Локаль каждого пользователя (неважно вошел он в приложение он или нет) доступна всегда как атрибут '''self.locale''' обработчика запросов и как '''locale''' в шаблонах. Название локали (например, '''en_US''') доступно через '''locale.name''', а переводить строки вы можете методом '''locale.translate'''. Шаблоны также содержат глобальную функцию '''_()''', с помощью которой также можно выполнять переводы строк. Функция '''translate''' имеет две формы:

{{{#!highlight python
_("Translate this string")
}}}

которая переводит строку используя текущую локаль, и

{{{#!highlight python
_("A person liked this", "%(num)d people liked this", len(people)) % {"num": len(people)}
}}}

которая переводит строку, которая может быть единичной или множественной, основываясь на значении третьего аргумента. В примере выше перевод первой строки будет осуществлен, если '''len(people)''' равно 1, в противном случае будет выполнен перевод второй строки.

Наиболее общий шаблон для переводов - использовать именованные заполнители (placeholders) Python для переменных, (например, как '''%(num)d''' в примере the example above).

Вот правильно локализованный шаблон:

{{{#!highlight html
<html>
   <head>
      <title>FriendFeed - {{ _("Sign in") }}</title>
   </head>
   <body>
     <form action="{{ request.path }}" method="post">
       <div>{{ _("Username") }} <input type="text" name="username"/></div>
       <div>{{ _("Password") }} <input type="password" name="password"/></div>
       <div><input type="submit" value="{{ _("Sign in") }}"/></div>
       {{ xsrf_form_html() }}
     </form>
   </body>
 </html>
}}}

По умолчанию мы определяем пользовательскую локаль используя заголовок '''Accept-Language''', который отсылается обозревателем. Если такого заголовка нет, то устанавливается локаль '''en_US'''. Если вы разрешите пользователям устанавливать свои предпочтения к локали, переопределите выборку локали по умолчанию, переопределив метод '''get_user_locale''' в обработчике запросов:

{{{#!highlight python
class BaseHandler(tornado.web.RequestHandler):
    def get_current_user(self):
        user_id = self.get_secure_cookie("user")
        if not user_id: return None
        return self.backend.get_user_by_id(user_id)

    def get_user_locale(self):
        if "locale" not in self.current_user.prefs:
            # Use the Accept-Language header
            return None
        return self.current_user.prefs["locale"]
}}}

Если '''get_user_locale''' возвращает '''None''', мы обращаемся к заголовку запроса '''Accept-Language'''.

Вы можете загрузить все переводы приложения используя метод '''tornado.locale.load_translations'''. Он берет из папки, которая должна содержать CSV файлы, файлы, которые названы за именем локали, например, '''es_GT.csv''' или '''fr_CA.csv'''. Метод загружает все переводы из этих CSV файлов и  files and выводит список поддерживаемых локалей исходя из наличия CSV файлов. Обычно вы будете вызывать этот метод один раз в теле метода '''main()''' своего сервера:

{{{#!highlight python
def main():
    tornado.locale.load_translations(
        os.path.join(os.path.dirname(__file__), "translations"))
    start_server()
}}}

Вы можете получить список поддерживаемых локалей в приложении с помощью '''tornado.locale.get_supported_locales()'''. Пользовательская локаль выбирается из всех доступных так, чтобы как можно лучше подходить пользователю. Например, если локаль пользователя - '''es_GT''', а локаль '''es''' поддерживается, то '''self.locale''' для этого запроса будет '''es'''. Если же подходящей локали не найдено, мы устанавливаем '''en_US'''.

Посмотрите документацию к модулю [[http://github.com/facebook/tornado/blob/master/tornado/locale.py|locale]] для получения более полной информации о формате CSV и других методов локализации.

== Модули пользовательского интерфейса ==

Для облегчения поддержки стандартных и многократно используемых виджетов вашими приложениями, в торнадо включена поддержка модулей пользовательского интерфейса (UI Modules).  По сути, они являются особыми функциональными запросами на отображение компонентов вашей страницы и они идут в комплекте с собственными таблицами CSS и функциями JavaScript.

Допустим, что у нас есть блог и мы хотим, чтобы записи этого блога присутствовали как на главной странице, так и на отдельных страницах записей. Для этого вы можете сделать класс '''Entry''', унаследовав его от '''tornado.web.UIModule''', вызывая который вы сможете отображать модуль записи на любой типе страницы. 
Для начала, создайте отдельный файл python в котором мы будем хранить модули интерфейса: '''uimodules.py''' и разместите в него следующий код:

{{{#!highlight python
class Entry(tornado.web.UIModule):
    def render(self, entry, show_comments=False):
        return self.render_string(
            "module-entry.html", show_comments=show_comments)
}}}


В настройках приложения укажите '''uimodules.py''' в качестве файла с модулями интерфейса, используя опцию '''ui_modules'''.

{{{#!highlight python
class HomeHandler(tornado.web.RequestHandler):
    def get(self):
        entries = self.db.query("SELECT * FROM entries ORDER BY date DESC")
        self.render("home.html", entries=entries)

class EntryHandler(tornado.web.RequestHandler):
    def get(self, entry_id):
        entry = self.db.get("SELECT * FROM entries WHERE id = %s", entry_id)
        if not entry: raise tornado.web.HTTPError(404)
        self.render("entry.html", entry=entry)

settings = {
    "ui_modules": uimodules,
}
application = tornado.web.Application([
    (r"/", HomeHandler),
    (r"/entry/([0-9]+)", EntryHandler),
], **settings)
}}}

В основном шаблоне '''home.html''' вы не включаете html-код напрямую, а ссылаетесь на модуль '''Entry'''

{{{#!highlight html
{% for entry in entries %}
  {{ modules.Entry(entry) }}
{% end %}
}}}

В шаблоне отдельной записи '''entry.html''' вы также ссылаетесь на модуль '''Entry''', но уже с аргументом '''show_comments''' , чтобы показать расширенный вариант модуля записи:

{{{#!highlight html
{{ modules.Entry(entry, show_comments=True) }}
}}}

В модули могут включаться произвольные CSS таблицы стилей и функции JavaScript посредством переопределеня методов '''embedded_css''', '''embedded_javascript''', '''javascript_files''' или '''css_files'''.

{{{#!highlight python
class Entry(tornado.web.UIModule):
    def embedded_css(self):
        return ".entry { margin-bottom: 1em; }"

    def render(self, entry, show_comments=False):
        return self.render_string(
            "module-entry.html", show_comments=show_comments)
}}}

Модули CSS и JavaScript будут подключены к итоговой странице единократно, вне зависимости от количества вызовов модуля пользовательского интерфейса в пределах нее. CSS будет включена в элемент '''<head>''' страницы, а JavaScript будет размещен прямо перед тегом '''</body>''' в конце страницы.

== Неблокирующие, асинхронные запросы ==

Обычно, когда заканчивается выполнение обработчика HTTP запроса, запрос автоматически завершается. Так как Tornado использует неблокирующий стиль ввода-вывода, но вы можете переназначить стандартное поведение, если хотите чтобы запрос оставался открытым после возврата из основного метода обработчика, используя декоратор класса-обработчика '''tornado.web.asynchronous'''.

При его использовании вы должны сами вызвать self.finish(), чтобы завершить HTTP запрос, или вы создадите лишнюю нагрузку на браузер пользователя или "повесите" его.

{{{#!highlight python
class MainHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    def get(self):
        self.write("Hello, world")
        self.finish()
}}}
		
Ниже приведен рабочий пример, который делает обращение к !FriendFeed API, используя встроенный асинхронный HTTP клиент Торнадо:

{{{#!highlight python
class MainHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    def get(self):
        http = tornado.httpclient.AsyncHTTPClient()
        http.fetch("http://friendfeed-api.com/v2/feed/bret",
                   callback=self.async_callback(self.on_response))

    def on_response(self, response):
        if response.error: raise tornado.web.HTTPError(500)
        json = tornado.escape.json_decode(response.body)
        self.write("Fetched " + str(len(json["entries"])) + " entries "
                   "from the FriendFeed API")
        self.finish()
}}}

Когда метод '''get()''' возвращает управление, HTTP запрос остается незавершенным. Когда, наконец, вызывается метод '''on_responce()''', запрос все еще открыт. В конце метода ответа мы должны отдать браузеру результат выполнения обработчика и закрыть соединение посредством вызова '''self.finish()'''.

Если вы вызываете асинхронные библиотечные функции, которые требуют ответа (например функция HTTP fetch в примере выше), вы должны обязательно обернуть их '''self.async_callback'''. Эта простая обертка гарантирует, что если ваша функция создаст исключение или программную ошибку, то браузеру будет послан соответствующий HTTP-ответ с кодом ошибки и соединение будет корректно завершено.

В качестве более развернутого примера вы можете посмотреть приложение [[http://github.com/facebook/tornado/tree/master/demos/chat/|chat]], идущее в качестве примера с Tornado, которое является чатом на основе AJAX и использует т.н. [[http://en.wikipedia.org/wiki/Push_technology#Long_polling|длинные запросы]] (long polling)

== Аутентификация с помощью сторонних разработчиков ==

Модуль '''auth''' Tornado предоставляет протоколы авторизации и аутентификации для ряда наиболее популярных веб-сайтов, включая [[http://google.com|Google/Gmail]], [[http://facebook.com|Facebook]], [[http://twitter.com|Twitter]], [[http://yahoo.com|Yahoo]] и [[http://friendfeed.com|FriendFeed]]. Модуль включает методы авторизации пользователей через эти сайты и, где это возможно, методы доступа к сервисам, так что вы можете, например, загрузить пользовательские контакты или опубликовать сообщение в Твиттере, используя учетную запись пользователя.

Вот пример обработчика, котрый использует Google для аутентификации, сохраняя полномочия в cookie для дальнейшего доступа:

{{{#!highlight python
class GoogleHandler(tornado.web.RequestHandler, tornado.auth.GoogleMixin):
    @tornado.web.asynchronous
    def get(self):
        if self.get_argument("openid.mode", None):
            self.get_authenticated_user(self.async_callback(self._on_auth))
            return
        self.authenticate_redirect()

    def _on_auth(self, user):
        if not user:
            self.authenticate_redirect()
            return
        # Save the user with, e.g., set_secure_cookie()
}}}

Обратите внимание, что обработчик использует декоратор асинхронного ввода-вывода, который осуществляет перенаправление на сайт google для аутентификации, сохраняя при этом открытый HTTP запрос.

Более подробно вы можете узнать про это из документации к модулю [[http://github.com/facebook/tornado/blob/master/tornado/auth.py|auth]].

= Производительность =

Производительность web-приложений в первую очередь ограничена архитектурой, а не производительностью frontend-а. И тем не менее Tornado весьма быстр по отношению к большинству популярных web-фреймворков на Python.

Мы запустили несколько тестов на нагрузку, используя простое приложение типа "Hello, world!" на каждом из наиболее популярных Python web-фреймворков ([[http://www.djangoproject.com/|Django]], [[http://webpy.org/|web.py]] и [[http://www.cherrypy.org/|CherryPy]]) чтобы получить общее представление о производительности каждого из них по отношению к Tornado. Мы использовали Apache/mod_wsgi для Django и web.py, CherryPy был запущен на отдельном сервере, что соответствовало нашим представлениям о типичном окружении производственных решений каждого из фреймворков. Мы запустили 4 однопоточных Tornado фронтэнда за обратным прокси [[http://nginx.net/|nginx]], что соответствует нашим рекомендациям по запуску Tornado в производство. (наш тестовый сервер был четырехядерным и мы рекомендуем по одному фронтэнду на ядро).

Тест каждого решения на нагрузку осуществлялся с помощью Apache Benchmark ([[http://httpd.apache.org/docs/2.0/programs/ab.html|ab]]) на отдельной машине с помощью команды

{{{#!highlight bash
ab -n 100000 -c 25 http://10.0.1.x/
}}}

Результаты (обработанных запросов в секунду) на четырехядерном процессоре  2.4GHz AMD Opteron:
||Tornado (nginx; 4 frontends)||8213||
||Tornado (1 single-threaded frontend)||3353||
||Django (Apache/mod_wsgi)||2223||
||web.py (Apache/mod_wsgi)||2066||
||CherryPy (standalone)||785||

По результатам наших тестов Tornado четырехкратно превосходил следующий по производительности фреймворк, и даже в однопоточном варианте (с использованием только одного ядра из четырех) оказался на 33% быстрее его.

Методика не то чтобы научная, но в целом мы хотим донести до вас, что позаботились о производительности в процессе разработки Tornado, и он не создаст особых задержек в работе ваших приложений, характерных для большинства web-фреймворков на Python.


= Запуск Tornado на производстве =

В проекте !FriendFeed мы используем [[http://nginx.net/|nginx]] в качестве балансировщика нагрузки и сервера статики. У нас запущено множество экземпляров web-сервера Tornado на множестве серверов, обслуживающих фронтэнд. Обычно мы запускаем один фронтэнд Tornado на аппаратное ядро (иногда больше, в зависимости от ситуации).

Это готовый конфигурационный файл nginx, который структурно схож с тем, что мы используем в проекте !FriendFeed. В данном случае предполагается, что nginx и Tornado запущены на одной машине и четыре сервера Tornado запущены на портах с 8000 по 8003:

{{{#!highlight bash
user nginx;
worker_processes 1;

error_log /var/log/nginx/error.log;
pid /var/run/nginx.pid;

events {
    worker_connections 1024;
    use epoll;
}

http {
    # Enumerate all the Tornado servers here
    upstream frontends {
        server 127.0.0.1:8000;
        server 127.0.0.1:8001;
        server 127.0.0.1:8002;
        server 127.0.0.1:8003;
    }

    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    access_log /var/log/nginx/access.log;

    keepalive_timeout 65;
    proxy_read_timeout 200;
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    gzip on;
    gzip_min_length 1000;
    gzip_proxied any;              
    gzip_types text/plain text/html text/css text/xml
               application/x-javascript application/xml
               application/atom+xml text/javascript;

    # Only retry if there was a communication error, not a timeout
    # on the Tornado server (to avoid propagating "queries of death"
    # to all frontends)
    proxy_next_upstream error;

    server {
        listen 80;

        # Allow file uploads
        client_max_body_size 50M;

        location ^~ /static/ {
            root /var/www;
            if ($query_string) {
                expires max;
            }
        }
        location = /favicon.ico {
            rewrite (.*) /static/favicon.ico;
        }
        location = /robots.txt {
            rewrite (.*) /static/robots.txt;
        }

        location / {
            proxy_pass_header Server;
            proxy_set_header Host $http_host;
            proxy_redirect false;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Scheme $scheme;
            proxy_pass http://frontends;
        }
    }
}
}}}
= WSGI и Google AppEngine =

Торнадо поставляется с ограниченной поддержкой [[http://wsgi.org/|WSGI]]. Тем не менее, так как WSGI не поддерживает неблокирующие запросы вы не сможете использовать какие либо асинхронные/неблокирующие функции Tornado в вашем приложении, если вы предпочтете использовать WSGI вместо HTTP сервера Tornado. Некоторые возможности, недоступные для использования в WSGI приложениях: '''@tornado.web.asynchronous''', '''httpclient''' и '''auth'''.

Вы можете создать рабочее WSGI приложение с обработчиками запросов Tornado, используя '''WSGIApplication''' в модуле '''wsgi''' вместо '''tornado.web.Application'''. Далее приведен пример который использует встроенный WSGI '''CGIHandler''' для создания рабчего приложения [[http://code.google.com/appengine/|Google AppEngine]]:

{{{#!highlight python
import tornado.web
import tornado.wsgi
import wsgiref.handlers

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

if __name__ == "__main__":
    application = tornado.wsgi.WSGIApplication([
        (r"/", MainHandler),
    ])
    wsgiref.handlers.CGIHandler().run(application)
}}}

Посмотрите пример [[http://github.com/facebook/tornado/tree/master/demos/appengine/|appengine]] для того, чтобы ознакомиться с полноценным приложением !AppEngine, построенным на Tornado.

= Предостережения и поддержка =

Tornado является переработанным движком !FriendFeed у которого были убранны специфичные для проекта зависимости. Рефакторинг мог породить ошибки. Так как серверы !FriendFeed всегда работали за nginx, Tornado не был тщательно протестирован с клиентами HTTP/1.1 кроме Firefox. На данный момент Tornado не обрабатывает многострочные заголовки и некоторые варианты неправильно сформированных запросов.

Вы можете обсудить Tornado и сообщить об ошибках в [[http://groups.google.com/group/python-tornado|рассылке для разработчиков Tornado]]

'''Перевод: Ростислав Дзинько, Илья Кутуков'''