CherryPy — Введение

CherryPy — это веб-фреймворк Python, который предоставляет дружественный интерфейс для HTTP-протокола для разработчиков Python. Это также называют библиотекой веб-приложения.

CherryPy использует сильные стороны Python в качестве динамического языка для моделирования и связывания протокола HTTP в API. Это одна из старейших веб-платформ для Python, которая обеспечивает чистый интерфейс и надежную платформу.

История CherryPy

Remi Delon выпустила первую версию CherryPy в конце июня 2002 года. Это была отправная точка успешной веб-библиотеки Python. Remi — французский хакер, который доверяет Python как одну из лучших альтернатив для разработки веб-приложений.

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

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

CherryPy был близок к шаблону модель-представление-контроллер.

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

CherryPy может отобразить URL и его строку запроса в вызов метода Python, например:

http://somehost.net/echo?message=hello would map to echo(message='hello')

В течение двух лет разработки проекта CherryPy он был поддержан сообществом, и Remi выпустила несколько улучшенных версий.

В июне 2004 года началось обсуждение будущего проекта и следует ли продолжать его с той же архитектурой. Мозговой штурм и обсуждение нескольких постоянных участников проекта привели к концепции движка и фильтров публикации объектов, которые вскоре стали основной частью CherryPy2.Later. В октябре 2004 года была выпущена первая версия CherryPy 2 alpha в качестве доказательства концепции эти основные идеи. CherryPy 2.0 был настоящим успехом; Тем не менее, было признано, что его дизайн все еще может быть улучшен и нуждается в рефакторинге.

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

Сильные стороны CherryPy

Следующие особенности CherryPy считаются его сильными сторонами —

Простота

Разработка проекта в CherryPy — это простая задача с несколькими строками кода, разработанными в соответствии с соглашениями и отступами Python.

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

Мощность

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

Открытый исходный код

CherryPy — это Python Web Framework с открытым исходным кодом (лицензируется по лицензии BSD с открытым исходным кодом), что означает, что эта платформа может использоваться в коммерческих целях по нулевой цене.

Помощь Сообщества

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

развертывание

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

CherryPy — настройка среды

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

Использование тарбола
Использование easy_install
Использование Subversion

Требования

Основные требования для установки фреймворка CherryPy включают —

Python с версией 2.4 или выше
CherryPy 3.0

Установка модуля Python считается простым процессом. Установка включает в себя использование следующих команд.

python setup.py build
python setup.py install

Пакеты Python хранятся в следующих каталогах по умолчанию —

В UNIX или Linux,

/usr/local/lib/python2.4/site-packages
or
/usr/lib/python2.4/site-packages

В Microsoft Windows,

C:\Python or C:\Python2x

В Mac OS

Python:Lib:site-package

Установка с использованием Tarball

Tarball — это сжатый архив файлов или директория. Платформа CherryPy предоставляет Tarball для каждого из своих выпусков (альфа, бета и стабильный).

Содержит полный исходный код библиотеки. Название происходит от утилиты, используемой в UNIX и других операционных системах.

Вот шаги, которые необходимо выполнить для установки CherryPy с использованием tar ball —

Шаг 1 — Загрузите версию в соответствии с требованиями пользователя с http://download.cherrypy.org/

Шаг 2 — Найдите каталог, в который был загружен Tarball, и распакуйте его. Для операционной системы Linux введите следующую команду —

tar zxvf cherrypy-x.y.z.tgz

Для Microsoft Windows пользователь может использовать утилиту, такую как 7-Zip или Winzip, чтобы распаковать архив через графический интерфейс.

Шаг 3 — Перейдите во вновь созданный каталог и используйте следующую команду для сборки CherryPy —

python setup.py build

Для глобальной установки должна использоваться следующая команда:

python setup.py install

Установка с использованием easy_install

Python Enterprise Application Kit (PEAK) предоставляет модуль python с именем Easy Install. Это облегчает развертывание пакетов Python. Этот модуль упрощает процедуру загрузки, сборки и развертывания приложений и продуктов Python.

Easy Install необходимо установить в систему перед установкой CherryPy.

Шаг 1 — Загрузите модуль ez_setup.py с http://peak.telecommunity.com и запустите его, используя права администратора на компьютере: python ez_setup.py.

Шаг 2 — Следующая команда используется для установки Easy Install.

easy_install product_name

Шаг 3 — easy_install будет искать в индексе пакетов Python (PyPI), чтобы найти данный продукт. PyPI является централизованным хранилищем информации для всех продуктов Python.

Используйте следующую команду для развертывания последней доступной версии CherryPy —

easy_install cherrypy

Шаг 4 — easy_install загрузит CherryPy, соберет и установит его глобально в вашу среду Python.

Установка с использованием Subversion

Установка CherryPy с использованием Subversion рекомендуется в следующих ситуациях:

Функция существует или ошибка была исправлена и доступна только в разрабатываемом коде.
Когда разработчик работает над CherryPy.
Когда пользователю нужна ветка из главной ветки в репозитории контроля версий.
Для исправления ошибок предыдущего выпуска.

Функция существует или ошибка была исправлена и доступна только в разрабатываемом коде.

Когда разработчик работает над CherryPy.

Когда пользователю нужна ветка из главной ветки в репозитории контроля версий.

Для исправления ошибок предыдущего выпуска.

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

Выполните следующие шаги, чтобы понять установку CherryPy с использованием Subversion-

Шаг 1 — Чтобы использовать самую последнюю версию проекта, необходимо проверить папку ствола, найденную в хранилище Subversion.

Шаг 2 — Введите следующую команду из оболочки —

svn co http://svn.cherrypy.org/trunk cherrypy

Шаг 3 — Теперь создайте каталог CherryPy и загрузите в него полный исходный код.

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

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

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

import cherrypy

cherrypy.__version__
'3.0.0'

Если CherryPy не установлен глобально в среду Python локальной системы, вам необходимо установить переменную среды PYTHONPATH, иначе она будет отображать ошибку следующим образом:

import cherrypy

Traceback (most recent call last):
File "<stdin>", line 1, in ?
ImportError: No module named cherrypy

CherryPy — Словарь

Есть несколько важных ключевых слов, которые необходимо определить, чтобы понять работу CherryPy. Ключевые слова и определения следующие —

S.No	Ключевое слово и определение
1.	Веб сервер Это интерфейс, работающий с протоколом HTTP. Его цель — преобразовать HTTP-запросы к серверу приложений, чтобы они получали ответы.
2.	заявка Это часть программного обеспечения, которая собирает информацию.
3.	Сервер приложений Это компонент, содержащий одно или несколько приложений
4.	Сервер веб-приложений Это комбинация веб-сервера и сервера приложений.

Веб сервер

Это интерфейс, работающий с протоколом HTTP. Его цель — преобразовать HTTP-запросы к серверу приложений, чтобы они получали ответы.

заявка

Это часть программного обеспечения, которая собирает информацию.

Сервер приложений

Это компонент, содержащий одно или несколько приложений

Сервер веб-приложений

Это комбинация веб-сервера и сервера приложений.

пример

В следующем примере показан пример кода CherryPy —

import cherrypy

class demoExample:
   def index(self):
   return "Hello World!!!"
   index.exposed = True
cherrypy.quickstart(demoExample())

Давайте теперь поймем, как работает код —

Пакет с именем CherryPy всегда импортируется в указанный класс для обеспечения правильной работы.
В приведенном выше примере функция с именем index возвращает параметр «Hello World !!!».
Последняя строка запускает веб-сервер и вызывает указанный класс (здесь demoExample) и возвращает значение, указанное в индексе функции по умолчанию.

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

В приведенном выше примере функция с именем index возвращает параметр «Hello World !!!».

Последняя строка запускает веб-сервер и вызывает указанный класс (здесь demoExample) и возвращает значение, указанное в индексе функции по умолчанию.

Пример кода возвращает следующий вывод —

Встроенный Http-сервер и внутренний движок

CherryPy поставляется с собственным веб-сервером (HTTP). Вот почему CherryPy является автономным и позволяет пользователям запускать приложение CherryPy в течение нескольких минут после получения библиотеки.

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

Чтобы запустить веб-сервер, пользователь должен сделать следующий вызов —

cherryPy.server.quickstart()

Внутренний движок CherryPy отвечает за следующие действия:

Создание и управление объектами запросов и ответов.
Контроль и управление процессом CherryPy.

CherryPy — Конфигурация

Фреймворк поставляется с собственной системой конфигурации, позволяющей параметризовать HTTP-сервер. Настройки для конфигурации могут быть сохранены в текстовом файле с синтаксисом, близким к формату INI, или в виде полного словаря Python.

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

global_conf = {
   'global': {
      'server.socket_host': 'localhost',
      'server.socket_port': 8080,
   },
}

application_conf = {
   '/style.css': {
      'tools.staticfile.on': True,
      'tools.staticfile.filename': os.path.join(_curdir, 'style.css'),
   }
}

This could be represented in a file like this:
[global]
server.socket_host = "localhost"
server.socket_port = 8080
[/style.css]
tools.staticfile.on = True
tools.staticfile.filename = "/full/path/to.style.css"

Соответствие HTTP

CherryPy развивался медленно, но он включает в себя компиляцию спецификаций HTTP с поддержкой HTTP / 1.0, позже перенесенных с поддержкой HTTP / 1.1.

CherryPy считается условно совместимым с HTTP / 1.1, поскольку он реализует все обязательные и требуемые уровни, но не все обязательные уровни спецификации. Поэтому CherryPy поддерживает следующие функции HTTP / 1.1:

Если клиент утверждает, что поддерживает HTTP / 1.1, он должен отправить поле заголовка в любом запросе, выполненном с указанной версией протокола. Если этого не сделано, CherryPy немедленно прекратит обработку запроса.
CherryPy генерирует поле заголовка Date, которое используется во всех конфигурациях.
CherryPy может обрабатывать код статуса ответа (100) при поддержке клиентов.
Встроенный в CherryPy HTTP-сервер поддерживает постоянные соединения, которые по умолчанию используются в HTTP / 1.1, с помощью заголовка Connection: Keep-Alive.
CherryPy правильно обрабатывает фрагментированные запросы и ответы.
CherryPy поддерживает запросы двумя разными способами — заголовками If-Modified-Since и If-Unmodified-Since и отправляет ответы согласно запросам соответственно.
CherryPy допускает любой метод HTTP.
CherryPy обрабатывает комбинации версий HTTP между клиентом и настройками, установленными для сервера.

Если клиент утверждает, что поддерживает HTTP / 1.1, он должен отправить поле заголовка в любом запросе, выполненном с указанной версией протокола. Если этого не сделано, CherryPy немедленно прекратит обработку запроса.

CherryPy генерирует поле заголовка Date, которое используется во всех конфигурациях.

CherryPy может обрабатывать код статуса ответа (100) при поддержке клиентов.

Встроенный в CherryPy HTTP-сервер поддерживает постоянные соединения, которые по умолчанию используются в HTTP / 1.1, с помощью заголовка Connection: Keep-Alive.

CherryPy правильно обрабатывает фрагментированные запросы и ответы.

CherryPy поддерживает запросы двумя разными способами — заголовками If-Modified-Since и If-Unmodified-Since и отправляет ответы согласно запросам соответственно.

CherryPy допускает любой метод HTTP.

CherryPy обрабатывает комбинации версий HTTP между клиентом и настройками, установленными для сервера.

Многопоточный сервер приложений

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

И cherrypy.request, и cherrypy.response являются контейнерами потоковых данных, которые подразумевают, что ваше приложение вызывает их независимо, зная, какой запрос передается через них во время выполнения.

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

Другие альтернативы включают в себя —

Многопроцессный шаблон

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

Асинхронная картина

Здесь принятие новых соединений и отправка данных обратно клиенту выполняется асинхронно из процесса запроса. Этот метод известен своей эффективностью.

URL-рассылка

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

Приложения, используемые для разработки методов HTTP. (GET, POST, PUT и т. Д.)
Тот, который определяет маршруты в URL — Routes Dispatcher

Диспетчер методов HTTP

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

Например, http://xyz.com/album/delete/10

URI содержит операцию, которую клиент желает выполнить.

По умолчанию диспетчер CherryPy будет отображаться следующим образом:

album.delete(12)

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

http://xyz.com/album/10

Пользователь может задаться вопросом, как сервер отправляет точную страницу. Эта информация переносится самим HTTP-запросом. Когда есть запрос от клиента к серверу, CherryPy выглядит наилучшим подходящим обработчиком, обработчиком является представление ресурса, на который нацелен URI.

DELETE /album/12 HTTP/1.1

Диспетчер маршрутов

Вот список параметров для метода, требуемого при диспетчеризации —

Параметр name — это уникальное имя маршрута для подключения.
Маршрут является шаблоном для сопоставления URI.
Контроллер — это экземпляр, содержащий обработчики страниц.
Использование диспетчера маршрутов соединяет шаблон, соответствующий URI, и связывает определенный обработчик страницы.

Параметр name — это уникальное имя маршрута для подключения.

Маршрут является шаблоном для сопоставления URI.

Контроллер — это экземпляр, содержащий обработчики страниц.

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

пример

Давайте возьмем пример, чтобы понять, как это работает —

import random
import string
import cherrypy

class StringMaker(object):
   @cherrypy.expose
   def index(self):
      return "Hello! How are you?"
   
   @cherrypy.expose
   def generate(self, length=9):
      return ''.join(random.sample(string.hexdigits, int(length)))
		
if __name__ == '__main__':
   cherrypy.quickstart(StringMaker ())

Выполните шаги, приведенные ниже, чтобы получить вывод приведенного выше кода —

Шаг 1 — Сохраните вышеупомянутый файл как tutRoutes.py .

Шаг 2 — Посетите следующий URL —

http://localhost:8080/generate?length=10

Шаг 3 — Вы получите следующий вывод —

CherryPy — Панель инструментов

В CherryPy встроенные инструменты предлагают единый интерфейс для вызова библиотеки CherryPy. Инструменты, определенные в CherryPy, могут быть реализованы следующими способами:

Из настроек конфигурации
Как декоратор Python или через специальный атрибут _cp_config обработчика страницы
Как вызываемый Python, который может быть применен из любой функции

Базовый инструмент аутентификации

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

аргументы

Этот инструмент использует следующие аргументы —

название	По умолчанию	Описание
область	N / A	Строка, определяющая значение области.
пользователи	N / A	Словарь в форме — имя пользователя: пароль или вызываемая функция Python, возвращающая такой словарь.
шифровать	Никто	Вызываемый Python используется для шифрования пароля, возвращаемого клиентом, и сравнения его с зашифрованным паролем, предоставленным в словаре пользователей.

пример

Давайте возьмем пример, чтобы понять, как это работает —

import sha
import cherrypy

class Root:
@cherrypy.expose
def index(self):

return """
<html>
   <head></head>
   <body>
      <a href = "admin">Admin </a>
   </body>
</html>
""" 

class Admin:

@cherrypy.expose
def index(self):
return "This is a private area"

if __name__ == '__main__':
def get_users():
# 'test': 'test'
return {'test': 'b110ba61c4c0873d3101e10871082fbbfd3'}
def encrypt_pwd(token):

return sha.new(token).hexdigest()
   conf = {'/admin': {'tools.basic_auth.on': True,
      tools.basic_auth.realm': 'Website name',
      'tools.basic_auth.users': get_users,
      'tools.basic_auth.encrypt': encrypt_pwd}}
   root = Root()
root.admin = Admin()
cherrypy.quickstart(root, '/', config=conf)

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

Базовый инструмент аутентификации не совсем безопасен, так как пароль может быть закодирован и расшифрован злоумышленником.

Инструмент кеширования

Цель этого инструмента — обеспечить кеширование памяти сгенерированного контента CherryPy.

аргументы

Этот инструмент использует следующие аргументы —

название	По умолчанию	Описание
invalid_methods	(«POST», «PUT», «DELETE»)	Кортежи строк HTTP-методов не должны кэшироваться. Эти методы также аннулируют (удаляют) любую кэшированную копию ресурса.
cache_Class	MemoryCache	Объект класса, который будет использоваться для кэширования

Инструмент декодирования

Цель этого инструмента — декодировать параметры входящего запроса.

аргументы

Этот инструмент использует следующие аргументы —

название	По умолчанию	Описание
кодирование	Никто	Он ищет заголовок типа контента
default_encoding	«UTF-8»	Кодировка по умолчанию, которая будет использоваться, когда ничего не предоставлено или не найдено.

пример

Давайте возьмем пример, чтобы понять, как это работает —

import cherrypy
from cherrypy import tools

class Root:
@cherrypy.expose
def index(self):

return """ 
<html>
   <head></head>
   <body>
      <form action = "hello.html" method = "post">
         <input type = "text" name = "name" value = "" />
         <input type = ”submit” name = "submit"/>
      </form>
   </body>
</html>
"""

@cherrypy.expose
@tools.decode(encoding='ISO-88510-1')
def hello(self, name):
return "Hello %s" % (name, )
if __name__ == '__main__':
cherrypy.quickstart(Root(), '/')

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

Вывод вышеуказанного кода выглядит следующим образом:

hello.html

CherryPy — рабочее приложение

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

Рассмотрим приложения Python, такие как web2py framework; весь проект / приложение создано в рамках MVC. Кроме того, CherryPy позволяет пользователю устанавливать и настраивать макет кода в соответствии с их требованиями.

В этой главе мы подробно узнаем, как создать приложение CherryPy и выполнить его.

Файловая система

Файловая система приложения показана на следующем снимке экрана —

Вот краткое описание различных файлов, которые мы имеем в файловой системе —

config.py — Каждому приложению нужен файл конфигурации и способ его загрузки. Эта функциональность может быть определена в config.py.
controllers.py — MVC — популярный шаблон проектирования, которым следуют пользователи. В controllers.py реализованы все объекты, которые будут смонтированы на cherrypy.tree .
models.py — этот файл взаимодействует с базой данных напрямую для некоторых служб или для хранения постоянных данных.
server.py — этот файл взаимодействует с готовым к работе веб-сервером, который корректно работает с прокси-сервером балансировки нагрузки.
Статический — включает в себя все CSS и файлы изображений.
Представления — включает в себя все файлы шаблонов для данного приложения.

config.py — Каждому приложению нужен файл конфигурации и способ его загрузки. Эта функциональность может быть определена в config.py.

controllers.py — MVC — популярный шаблон проектирования, которым следуют пользователи. В controllers.py реализованы все объекты, которые будут смонтированы на cherrypy.tree .

models.py — этот файл взаимодействует с базой данных напрямую для некоторых служб или для хранения постоянных данных.

server.py — этот файл взаимодействует с готовым к работе веб-сервером, который корректно работает с прокси-сервером балансировки нагрузки.

Статический — включает в себя все CSS и файлы изображений.

Представления — включает в себя все файлы шаблонов для данного приложения.

пример

Давайте подробно изучим шаги по созданию приложения CherryPy.

Шаг 1 — Создайте приложение, которое должно содержать приложение.

Шаг 2 — Внутри каталога создайте пакет python, соответствующий проекту. Создайте каталог gedit и включите в него файл _init_.py.

Шаг 3 — Внутри пакета включите файл controllers.py со следующим содержимым —

#!/usr/bin/env python

import cherrypy

class Root(object):

   def __init__(self, data):
      self.data = data

   @cherrypy.expose
   def index(self):
      return 'Hi! Welcome to your application'

def main(filename):
   data = {} # will be replaced with proper functionality later

   # configuration file
   cherrypy.config.update({
      'tools.encode.on': True, 'tools.encode.encoding': 'utf-8',
      'tools.decode.on': True,
      'tools.trailing_slash.on': True,
      'tools.staticdir.root': os.path.abspath(os.path.dirname(__file__)),
   })

   cherrypy.quickstart(Root(data), '/', {
      '/media': {
         'tools.staticdir.on': True,
         'tools.staticdir.dir': 'static'
      }
   })
	
if __name__ == '__main__':
main(sys.argv[1])

Шаг 4 — Рассмотрим приложение, в котором пользователь вводит значение через форму. Давайте включим в приложение две формы — index.html и submit.html.

Шаг 5 — В приведенном выше коде для контроллеров у нас есть index () , который является функцией по умолчанию и загружается первым, если вызывается конкретный контроллер.

Шаг 6 — Реализация метода index () может быть изменена следующим образом:

@cherrypy.expose
   def index(self):
      tmpl = loader.load('index.html')
	 
      return tmpl.generate(title='Sample').render('html', doctype='html')

Шаг 7 — Это загрузит index.html при запуске данного приложения и направит его в указанный поток вывода. Файл index.html выглядит следующим образом:

index.html

<!DOCTYPE html >
<html>
   <head>
      <title>Sample</title>
   </head>
	
   <body class = "index">
      <div id = "header">
         <h1>Sample Application</h1>
      </div>
		
      <p>Welcome!</p>
		
      <div id = "footer">
         <hr>
      </div>
		
   </body>
	
</html>

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

@cherrypy.expose
   def submit(self, cancel = False, **value):
	
      if cherrypy.request.method == 'POST':
         if cancel:
            raise cherrypy.HTTPRedirect('/') # to cancel the action
         link = Link(**value)
         self.data[link.id] = link
         raise cherrypy.HTTPRedirect('/')
      tmp = loader.load('submit.html')
      streamValue = tmp.generate()
		
      return streamValue.render('html', doctype='html')

Шаг 9 — код, который будет включен в submit.html, —

<!DOCTYPE html>
   <head>
      <title>Input the new link</title>
   </head>
	
   <body class = "submit">
      <div id = " header">
         <h1>Submit new link</h1>
      </div>
		
      <form action = "" method = "post">
         <table summary = "">
            <tr>
               <th><label for = " username">Your name:</label></th>
               <td><input type = " text" id = " username" name = " username" /></td>
            </tr>
				
            <tr>
               <th><label for = " url">Link URL:</label></th>
               <td><input type = " text" id=" url" name= " url" /></td>
            </tr>
				
            <tr>
               <th><label for = " title">Title:</label></th>
               <td><input type = " text" name = " title" /></td>
            </tr>
				
            <tr>
               <td></td>
               <td>
                  <input type = " submit" value = " Submit" />
                  <input type = " submit" name = " cancel" value = "Cancel" />
               </td>
            </tr>
				
         </table>
			
      </form>
      <div id = "footer">
      </div>
		
   </body>
	
</html>

Шаг 10 — Вы получите следующий вывод —

Здесь имя метода определяется как «POST». Всегда важно перепроверить метод, указанный в файле. Если метод включает метод «POST», значения должны быть перепроверены в базе данных в соответствующих полях.

Если метод включает метод «GET», значения, которые будут сохранены, будут видны в URL.

CherryPy — веб-сервисы

Веб-сервис — это набор веб-компонентов, которые помогают в обмене данными между приложением или системами, которые также включают открытые протоколы и стандарты. Он может быть опубликован, использован и найден в Интернете.

Веб-сервисы бывают разных типов, такие как RWS (RESTfUL Web Service), WSDL, SOAP и многие другие.

REST — представительский государственный трансферт

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

Не определяет какую-либо конкретную кодировку или структуру и способы возврата полезных сообщений об ошибках.
Использует HTTP «глаголы» для выполнения операций передачи состояния.
Ресурсы однозначно идентифицируются с помощью URL.
Это не API, а транспортный уровень API.

Не определяет какую-либо конкретную кодировку или структуру и способы возврата полезных сообщений об ошибках.

Использует HTTP «глаголы» для выполнения операций передачи состояния.

Ресурсы однозначно идентифицируются с помощью URL.

Это не API, а транспортный уровень API.

REST поддерживает номенклатуру ресурсов в сети и предоставляет унифицированный механизм для выполнения операций с этими ресурсами. Каждый ресурс идентифицируется как минимум одним идентификатором. Если инфраструктура REST реализована на основе HTTP, эти идентификаторы называются унифицированными идентификаторами ресурса (URI) .

Ниже приведены два общих подмножества набора URI:

Подмножество	Полная форма	пример
URL	Унифицированный указатель ресурса	http://www.gmail.com/
URN	Единое имя ресурса	urn: isbn: 0-201-71088-9 urn: uuid: 13e8cf26-2a25-11db-8693-000ae4ea7d46

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

CherryPy включает в себя следующие три компонента —

cherrypy.engine — Он управляет запуском / остановом процесса и обработкой событий.
cherrypy.server — настраивает и контролирует сервер WSGI или HTTP.
cherrypy.tools — Набор утилит, которые ортогональны обработке HTTP-запроса.

cherrypy.engine — Он управляет запуском / остановом процесса и обработкой событий.

cherrypy.server — настраивает и контролирует сервер WSGI или HTTP.

cherrypy.tools — Набор утилит, которые ортогональны обработке HTTP-запроса.

Интерфейс REST через CherryPy

Веб-сервис RESTful реализует каждый раздел архитектуры CherryPy с помощью следующего:

Аутентификация
авторизация
Состав
Инкапсуляция
Обработка ошибок

Аутентификация

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

def authenticate():
   if not hasattr(cherrypy.request, 'user') or cherrypy.request.user is None:
      # < Do stuff to look up your users >
		
      cherrypy.request.authorized = False # This only authenticates. 
         Authz must be handled separately.
		
      cherrypy.request.unauthorized_reasons = []
      cherrypy.request.authorization_queries = []
		
cherrypy.tools.authenticate = \
   cherrypy.Tool('before_handler', authenticate, priority=10)

Вышеуказанная функция authenticate () поможет проверить существование клиентов или пользователей. Встроенные инструменты помогают выполнять процесс систематически.

авторизация

Авторизация помогает поддерживать работоспособность процесса через URI. Этот процесс также помогает преобразовывать объекты по токенам пользователей.

def authorize_all():
   cherrypy.request.authorized = 'authorize_all'
	
cherrypy.tools.authorize_all = cherrypy.Tool('before_handler', authorize_all, priority=11)

def is_authorized():
   if not cherrypy.request.authorized:
      raise cherrypy.HTTPError("403 Forbidden",
         ','.join(cherrypy.request.unauthorized_reasons))
			
cherrypy.tools.is_authorized = cherrypy.Tool('before_handler', is_authorized, 
priority = 49)

cherrypy.config.update({
   'tools.is_authorized.on': True,
   'tools.authorize_all.on': True
})

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

Состав

Поддержание структуры API помогает снизить нагрузку на отображение URI приложения. Всегда необходимо поддерживать доступность и чистоту API. Базовая структура API для фреймворка CherryPy должна иметь следующую структуру:

Аккаунты и Пользователь
Автоответчик
контакт
файл
скоросшиватель
Список и поле
Сообщение и Пакет

Инкапсуляция

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

Обработка ошибок

Этот процесс обрабатывает ошибки, если таковые имеются, если API не выполняется на конкретном инстинкте. Например, 400 для плохого запроса и 403 для неавторизованного запроса.

пример

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

import cherrypy
import json

def error_page_default(status, message, traceback, version):
   ret = {
      'status': status,
      'version': version,
      'message': [message],
      'traceback': traceback
   }
	
   return json.dumps(ret)
	
class Root:
   _cp_config = {'error_page.default': error_page_default}
	
@cherrypy.expose
   def index(self):
      raise cherrypy.HTTPError(500, "Internal Sever Error")
cherrypy.quickstart(Root())

Приведенный выше код выдаст следующий вывод:

Управлять API (Application Programming Interface) легко с помощью CherryPy благодаря встроенным инструментам доступа.

Методы HTTP

Список методов HTTP, которые работают с ресурсами, выглядит следующим образом:

S.No	HTTP метод и работа
1.	ГОЛОВА Получает метаданные ресурса.
2.	ПОЛУЧИТЬ Получает метаданные и контент ресурса.
3.	СООБЩЕНИЕ Запрашивает у сервера создание нового ресурса с использованием данных, содержащихся в теле запроса.
4.	ПОЛОЖИЛ Запрашивает у сервера заменить существующий ресурс на тот, который вложен в тело запроса.
5.	УДАЛЯТЬ Запрашивает сервер на удаление ресурса, идентифицированного этим URI.
6.	ОПЦИИ Запрашивает у сервера информацию о возможностях в глобальном или конкретном отношении к ресурсу.

ГОЛОВА

Получает метаданные ресурса.

ПОЛУЧИТЬ

Получает метаданные и контент ресурса.

СООБЩЕНИЕ

Запрашивает у сервера создание нового ресурса с использованием данных, содержащихся в теле запроса.

ПОЛОЖИЛ

Запрашивает у сервера заменить существующий ресурс на тот, который вложен в тело запроса.

УДАЛЯТЬ

Запрашивает сервер на удаление ресурса, идентифицированного этим URI.

ОПЦИИ

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

Протокол публикации Atom (APP)

APP возникла из сообщества Atom как протокол уровня приложения поверх HTTP, позволяющий публиковать и редактировать веб-ресурсы. Блок сообщений между сервером APP и клиентом основан на формате XML-документа Atom.

Протокол публикации Atom определяет набор операций между службой APP и агентом пользователя, использующим HTTP и его механизмы, и формат XML-документа Atom в качестве единицы сообщений.

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

пример

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

<?xml version = "1.0" encoding = "UTF-8"?>
<service xmlns = "http://purl.org/atom/app#" xmlns:atom = "http://www.w3.org/2005/Atom">
   
   <workspace>
      <collection href = "http://host/service/atompub/album/">
         <atom:title> Albums</atom:title>
         <categories fixed = "yes">
            <atom:category term = "friends" />
         </categories>
      </collection>
      
      <collection href = "http://host/service/atompub/film/">
         <atom:title>Films</atom:title>
         <accept>image/png,image/jpeg</accept>
      </collection>
   </workspace>
	
</service>

APP определяет, как выполнять базовые операции CRUD для члена коллекции или самой коллекции, используя методы HTTP, как описано в следующей таблице:

операция	HTTP метод	Код состояния	содержание
извлекать	ПОЛУЧИТЬ	200	Запись Atom, представляющая ресурс
Создайте	СООБЩЕНИЕ	201	URI вновь созданного ресурса через заголовки Location и Content-Location
Обновить	ПОЛОЖИЛ	200	Запись Atom, представляющая ресурс
удалять	УДАЛЯТЬ	200	Никто

CherryPy — презентационный слой

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

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

Малыш — Шаблонный движок

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

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

Функция kid.Template возвращает экземпляр класса шаблона, который можно использовать для визуализации выходного содержимого.

Шаблонный класс предоставляет следующий набор команд —

S.No	Команда и описание
1.	сериализации Возвращает содержимое вывода в виде строки.
2.	генерировать Возвращает содержимое вывода как итератор.
3.	записывать Он выводит содержимое вывода в файл объекта.

S.No

Команда и описание

сериализации

Возвращает содержимое вывода в виде строки.

генерировать

Возвращает содержимое вывода как итератор.

записывать

Он выводит содержимое вывода в файл объекта.

сериализации

Возвращает содержимое вывода в виде строки.

генерировать

Возвращает содержимое вывода как итератор.

записывать

Он выводит содержимое вывода в файл объекта.

Параметры, используемые этими командами, следующие:

S.No	Команда и описание
1.	кодирование Он сообщает, как кодировать выходной контент
2.	фрагмент Это логическое значение, которое сообщает прологу XML или Doctype
3.	выход Этот тип сериализации используется для визуализации контента

S.No

Команда и описание

кодирование

Он сообщает, как кодировать выходной контент

фрагмент

Это логическое значение, которое сообщает прологу XML или Doctype

выход

Этот тип сериализации используется для визуализации контента

кодирование

Он сообщает, как кодировать выходной контент

фрагмент

Это логическое значение, которое сообщает прологу XML или Doctype

выход

Этот тип сериализации используется для визуализации контента

пример

Давайте возьмем пример, чтобы понять, как работает ребенок —

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html xmlns:py = "http://purl.org/kid/ns#">
   <head>
      <title>${title}</title>
      <link rel = "stylesheet" href = "style.css" />
   </head>
	
   <body> 
      <p>${message}</p>
   </body>
</html>

The next step after saving the file is to process the template via the Kid engine.

import kid

params = {'title': 'Hello world!!', 'message': 'CherryPy.'}
t = kid.Template('helloworld.kid', **params)
print t.serialize(output='html')

Атрибуты ребенка

Ниже приведены атрибуты Kid —

Основанный на XML язык шаблонов

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

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

<p py:if = "...">...</p>

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

Kid поставляется со схемой подстановки переменных и простым подходом — $ {variable-name}.

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

Если пользователю требуется вывод буквенной строки как $ {что-то}, его можно избежать с помощью подстановки переменных, удвоив знак доллара.

Условный оператор

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

<tag py:if = "expression">...</tag>

Здесь tag — это имя элемента, например, DIV или SPAN.

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

Петлевой механизм

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

<tag py:for = "expression">...</tag>

Здесь tag — это имя элемента. Выражение является выражением Python, например, для значения в […].

пример

Следующий код показывает, как работает механизм зацикливания —

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
   <head>
      <title>${title}</title>
      <link rel = "stylesheet" href = "style.css" />
   </head>
	
   <body>
      <table>
         <caption>A few songs</caption>
         <tr>
            <th>Artist</th>
            <th>Album</th>
            <th>Title</th>
         </tr>
			
         <tr py:for = "info in infos">
            <td>${info['artist']}</td>
            <td>${info['album']}</td>
            <td>${info['song']}</td>
         </tr>
      </table>
   </body>
</html>

import kid

params = discography.retrieve_songs()
t = kid.Template('songs.kid', **params)
print t.serialize(output='html')

Выход для вышеуказанного кода с механизмом зацикливания выглядит следующим образом:

CherryPy — использование Ajax

До 2005 года во всех веб-приложениях использовалась схема управления одним HTTP-запросом на страницу. Переход с одной страницы на другую требовал загрузки всей страницы. Это снизит производительность на более высоком уровне.

Таким образом, возросло число клиентских приложений с расширенными возможностями, которые использовали для встраивания в них AJAX, XML и JSON.

AJAX

Асинхронный JavaScript и XML (AJAX) — это техника для создания быстрых и динамических веб-страниц. AJAX позволяет асинхронно обновлять веб-страницы, обмениваясь небольшими объемами данных с сервером. Это означает, что можно обновить части веб-страницы, не перезагружая всю страницу.

Карты Google, Gmail, YouTube и Facebook представляют собой несколько примеров приложений AJAX.

Ajax основан на идее отправки HTTP-запросов с использованием JavaScript; более конкретно, AJAX использует объект XMLHttpRequest и его API для выполнения этих операций.

JSON

JSON — это способ переноса сериализованных объектов JavaScript таким образом, чтобы приложение JavaScript могло их оценивать и преобразовывать в объекты JavaScript, которыми можно будет управлять позже.

Например, когда пользователь запрашивает у сервера объект альбома, отформатированный в формате JSON, сервер возвращает результат в следующем виде:

{'description': 'This is a simple demo album for you to test', 'author': ‘xyz’}

Теперь данные являются ассоциативным массивом JavaScript, и к полю описания можно получить доступ через —

data ['description'];

Применение AJAX к приложению

Рассмотрим приложение, которое включает в себя папку с именем «media» с index.html и плагином Jquery, а также файл с реализацией AJAX. Давайте рассмотрим имя файла как «ajax_app.py»

ajax_app.py

import cherrypy
import webbrowser
import os
import simplejson
import sys

MEDIA_DIR = os.path.join(os.path.abspath("."), u"media")

class AjaxApp(object):
   @cherrypy.expose
   def index(self):
      return open(os.path.join(MEDIA_DIR, u'index.html'))

   @cherrypy.expose
   def submit(self, name):
      cherrypy.response.headers['Content-Type'] = 'application/json'
      return simplejson.dumps(dict(title="Hello, %s" % name))
		
config = {'/media':
   {'tools.staticdir.on': True,
   'tools.staticdir.dir': MEDIA_DIR,}
}
			
def open_page():
webbrowser.open("http://127.0.0.1:8080/")
cherrypy.engine.subscribe('start', open_page)
cherrypy.tree.mount(AjaxApp(), '/', config=config)
cherrypy.engine.start()

Класс «AjaxApp» перенаправляет на веб-страницу «index.html», которая находится в папке media.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
   " http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
	
<html xmlns = "http://www.w3.org/1999/xhtml" lang = "en" xml:lang = "en">
   <head>
      <title>AJAX with jQuery and cherrypy</title>
      <meta http-equiv = " Content-Type" content = " text/html; charset=utf-8" />
      <script type = " text/javascript" src = " /media/jquery-1.4.2.min.js"></script>
		
      <script type = " text/javascript">
         $(function() {
         
            // When the testform is submitted...
            $("#formtest").submit(function() {
         
               // post the form values via AJAX...
               $.post('/submit', {name: $("#name").val()}, function(data) {
         
                  // and set the title with the result
                  $("#title").html(data['title']) ;
               });
               return false ;
            });
         });
      </script>
		
   </head>
	
   <body>
      <h1 id = "title">What's your name?</h1>
      <form id = " formtest" action = " #" method = " post">
         <p>
            <label for = " name">Name:</label>
            <input type = " text" id = "name" /> <br />
            <input type = " submit" value = " Set" />
         </p>
      </form>
   </body>
	
</html>

Функция для AJAX включена в теги <script>.

Выход

Приведенный выше код выдаст следующий вывод:

Как только значение отправлено пользователем, реализуется функциональность AJAX, и экран перенаправляется на форму, как показано ниже:

CherryPy — Демо-приложение

В этой главе мы сосредоточимся на том, как создается приложение в CherryPy.

Рассмотрим приложение Photoblog для демонстрационного приложения CherryPy. Приложение Photoblog — это обычный блог, но основным текстом будут фотографии вместо текста. Основным преимуществом приложения Photoblog является то, что разработчик может сосредоточиться на разработке и реализации.

Базовая структура — дизайн сущностей

Сущности проектируют базовую структуру приложения. Ниже приведены объекты для приложения Photoblog —

фильм
Фото
Альбом

Ниже приведена базовая диаграмма классов для отношения сущности:

Структура дизайна

Как обсуждалось в предыдущей главе, структура проекта будет такой, как показано на следующем снимке экрана —

Рассмотрим данное приложение, в котором есть подкаталоги для приложения Photoblog. Подкаталогами являются Photo, Album и Film, в которые входят controllers.py, models.py и server.py.

Функционально приложение Photoblog предоставит API для управления этими объектами через традиционный интерфейс CRUD — Create, Retrieve, Update и Delete.

Подключение к базе данных

Модуль хранения включает в себя набор операций; соединение с базой данных является одной из операций.

Поскольку это законченное приложение, соединение с базой данных является обязательным для API и для поддержки функциональности Create, Retrieve, Update и Delete.

import dejavu

arena = dejavu.Arena()
from model import Album, Film, Photo
def connect():

conf = {'Connect': "host=localhost dbname=Photoblog user=test password=test"}
arena.add_store("main", "postgres", conf)
arena.register_all(globals())

Арена в приведенном выше коде будет нашим интерфейсом между базовым менеджером хранилища и уровнем бизнес-логики.

Функция подключения добавляет диспетчер хранилища к объекту арены для СУБД PostgreSQL.

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

Самое важное перед созданием любого приложения — это сопоставление сущностей и проектирование структуры приложения.

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

Тестирование — это процесс, во время которого приложение проводится с разных точек зрения, чтобы:

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

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

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

Тестирование определяется как ряд аспектов, которые должны быть проверены в системе или приложении. Ниже приведен список общих подходов к тестированию:

Модульное тестирование — это обычно выполняется самими разработчиками. Это нацелено на проверку того, работает ли единица кода как ожидалось или нет.
Юзабилити-тестирование. Разработчики обычно могут забыть, что они пишут приложение для конечных пользователей, которые не имеют знаний о системе. Юзабилити-тестирование проверяет плюсы и минусы продукта.
Функциональное / приемочное тестирование. В то время как юзабилити-тестирование проверяет работоспособность приложения или системы, функциональное тестирование обеспечивает реализацию всех указанных функциональных возможностей.
Тестирование нагрузки и производительности — это делается для того, чтобы понять, может ли система адаптироваться к нагрузочным и тестам производительности, которые необходимо провести. Это может привести к изменениям в оборудовании, оптимизации запросов SQL и т. Д.
Регрессионное тестирование — оно проверяет, что последовательные выпуски продукта не нарушают ни одну из предыдущих функций.
Проверка надежности и устойчивости — Проверка надежности помогает при проверке системного приложения с разбивкой одного или нескольких компонентов.

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

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

Функциональное / приемочное тестирование. В то время как юзабилити-тестирование проверяет работоспособность приложения или системы, функциональное тестирование обеспечивает реализацию всех указанных функциональных возможностей.

Тестирование нагрузки и производительности — это делается для того, чтобы понять, может ли система адаптироваться к нагрузочным и тестам производительности, которые необходимо провести. Это может привести к изменениям в оборудовании, оптимизации запросов SQL и т. Д.

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

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

Модульное тестирование

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

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

Python поставляется со стандартным модулем unittest, предлагающим другой подход к модульному тестированию.

Модульный тест

unittest основан на JUnit, пакете модульных тестов Java, разработанном Кентом Беком и Эрихом Гаммой. Модульные тесты просто возвращают определенные данные. Ложные объекты могут быть определены. Эти объекты позволяют проводить тестирование на интерфейсе нашего проекта, не полагаясь на общее приложение. Они также предоставляют способ запуска тестов в режиме изоляции, включая другие тесты.

Давайте определим фиктивный класс следующим образом —

import unittest

class DummyTest(unittest.TestCase):
def test_01_forward(self):
dummy = Dummy(right_boundary=3)
   self.assertEqual(dummy.forward(), 1)
   self.assertEqual(dummy.forward(), 2)
   self.assertEqual(dummy.forward(), 3)
   self.assertRaises(ValueError, dummy.forward)

def test_02_backward(self):
dummy = Dummy(left_boundary=-3, allow_negative=True)
   self.assertEqual(dummy.backward(), -1)
   self.assertEqual(dummy.backward(), -2)
   self.assertEqual(dummy.backward(), -3)
   self.assertRaises(ValueError, dummy.backward)

def test_03_boundaries(self):
dummy = Dummy(right_boundary=3, left_boundary=-3,allow_negative=True)
   self.assertEqual(dummy.backward(), -1)
   self.assertEqual(dummy.backward(), -2)
   self.assertEqual(dummy.forward(), -1)
   self.assertEqual(dummy.backward(), -2)
   self.assertEqual(dummy.backward(), -3)

Объяснение кода следующее:

Модуль unittest должен быть импортирован, чтобы обеспечить возможности модульного тестирования для данного класса.
Класс должен быть создан путем подкласса unittest.
Каждый метод в приведенном выше коде начинается со слова test. Все эти методы вызываются обработчиком unittest.
Методы assert / fail вызываются тестовым примером для управления исключениями.

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

Класс должен быть создан путем подкласса unittest.

Каждый метод в приведенном выше коде начинается со слова test. Все эти методы вызываются обработчиком unittest.

Методы assert / fail вызываются тестовым примером для управления исключениями.

Рассмотрим это как пример для запуска тестового примера —

if __name__ == '__main__':
unittest.main()

Результат (выход) для запуска контрольного примера будет следующим:

----------------------------------------------------------------------
Ran 3 tests in 0.000s
OK

Функциональное тестирование

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

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

Нагрузочное тестирование

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

В этом разделе не будет подробно описано, как проводить тестирование производительности или нагрузку, поскольку оно выходит из пакета FunkLoad.

Самый простой пример FunkLoad выглядит следующим образом:

from funkload.FunkLoadTestCase 
import FunkLoadTestCase

class LoadHomePage(FunkLoadTestCase):
def test_homepage(self):

server_url = self.conf_get('main', 'url')
nb_time = self.conf_getInt('test_homepage', 'nb_time')
home_page = "%s/" % server_url

for i in range(nb_time):
self.logd('Try %i' % i)
self.get(home_page, description='Get gome page')
if __name__ in ('main', '__main__'):

import unittest

unittest.main()

Вот подробное объяснение приведенного выше кода —

Тестовый пример должен наследоваться от класса FunkLoadTestCase, чтобы FunkLoad мог выполнять свою внутреннюю работу по отслеживанию того, что происходит во время теста.
Имя класса важно, так как FunkLoad будет искать файл на основе имени класса.
Разработанные тестовые наборы имеют прямой доступ к файлам конфигурации. Методы Get () и post () просто вызываются против сервера, чтобы получить ответ.

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

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

Разработанные тестовые наборы имеют прямой доступ к файлам конфигурации. Методы Get () и post () просто вызываются против сервера, чтобы получить ответ.

CherryPy — Развертывание приложения

В этой главе основное внимание будет уделено SSL-приложению на основе CherryPy, включенному через встроенный HTTP-сервер CherryPy.

конфигурация

В веб-приложении требуются разные уровни настроек конфигурации —

Веб-сервер — настройки, связанные с HTTP-сервером
Engine — Настройки, связанные с хостингом движка
Приложение — приложение, которое используется пользователем

Веб-сервер — настройки, связанные с HTTP-сервером

Engine — Настройки, связанные с хостингом движка

Приложение — приложение, которое используется пользователем

развертывание

Развертывание приложения CherryPy считается довольно простым способом, когда все необходимые пакеты доступны по системному пути Python. В общедоступной веб-среде веб-сервер будет находиться во внешнем интерфейсе, что позволяет провайдеру хоста выполнять действия по фильтрации. Внешний сервер может быть Apache или lighttpd .

В этом разделе будет представлено несколько решений для запуска приложения CherryPy на веб-серверах Apache и lighttpd.

cherrypy
def setup_app():

class Root:
@cherrypy.expose
def index(self):
   # Return the hostname used by CherryPy and the remote
   # caller IP address
	
return "Hello there %s from IP: %s " %
(cherrypy.request.base, cherrypy.request.remote.ip)
cherrypy.config.update({'server.socket_port': 9091,
   'environment': 'production',
   'log.screen': False,
   'show_tracebacks': False})
	
cherrypy.tree.mount(Root())
if __name__ == '__main__':

setup_app()
cherrypy.server.quickstart()
cherrypy.engine.start()

SSL

SSL (Secure Sockets Layer) может поддерживаться в приложениях на основе CherryPy. Чтобы включить поддержку SSL, должны быть выполнены следующие требования:

Установите пакет PyOpenSSL в среде пользователя
Наличие SSL-сертификата и закрытого ключа на сервере

Создание сертификата и закрытого ключа

Давайте разберемся с требованиями сертификата и закрытого ключа —

Сначала пользователю нужен закрытый ключ —

openssl genrsa -out server.key 2048

Этот ключ не защищен паролем и поэтому имеет слабую защиту.
Следующая команда будет выполнена —

openssl genrsa -des3 -out server.key 2048

Программа потребует пароль. Если ваша версия OpenSSL позволяет вам предоставить пустую строку, сделайте это. В противном случае введите парольную фразу по умолчанию, а затем удалите ее из сгенерированного ключа следующим образом:

Программа потребует пароль. Если ваша версия OpenSSL позволяет вам предоставить пустую строку, сделайте это. В противном случае введите парольную фразу по умолчанию, а затем удалите ее из сгенерированного ключа следующим образом:

openssl rsa -in server.key -out server.key

Создание сертификата происходит следующим образом —

openssl req -new -key server.key -out server.csr

Этот процесс попросит вас ввести некоторые детали. Для этого необходимо ввести следующую команду:

Этот процесс попросит вас ввести некоторые детали. Для этого необходимо ввести следующую команду:

openssl x509 -req -days 60 -in server.csr -signkey
server.key -out server.crt

Вновь подписанный сертификат будет действителен в течение 60 дней.

Вновь подписанный сертификат будет действителен в течение 60 дней.

Следующий код показывает его реализацию —

import cherrypy
import os, os.path

localDir = os.path.abspath(os.path.dirname(__file__))
CA = os.path.join(localDir, 'server.crt')
KEY = os.path.join(localDir, 'server.key')
def setup_server():

class Root:
@cherrypy.expose
def index(self):
   return "Hello there!"
	
cherrypy.tree.mount(Root())
if __name__ == '__main__':

setup_server()
cherrypy.config.update({'server.socket_port': 8443,
   'environment': 'production',
   'log.screen': True,
   'server.ssl_certificate': CA,
   'server.ssl_private_key': KEY})
	
cherrypy.server.quickstart()
cherrypy.engine.start()

Следующим шагом является запуск сервера; Если вы добились успеха, вы увидите следующее сообщение на вашем экране —

CherryPy — Краткое руководство

CherryPy — Введение

История CherryPy

Сильные стороны CherryPy

Простота

Мощность

Открытый исходный код

Помощь Сообщества

развертывание

CherryPy — настройка среды

Требования

Установка с использованием Tarball

Установка с использованием easy_install

Установка с использованием Subversion

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

CherryPy — Словарь

пример

Встроенный Http-сервер и внутренний движок

CherryPy — Конфигурация

Соответствие HTTP

Многопоточный сервер приложений

Многопроцессный шаблон

Асинхронная картина

URL-рассылка

Диспетчер методов HTTP

Диспетчер маршрутов

пример

CherryPy — Панель инструментов

Базовый инструмент аутентификации

аргументы

пример

Инструмент кеширования

аргументы

Инструмент декодирования

аргументы

пример

CherryPy — рабочее приложение

Файловая система

пример

index.html

CherryPy — веб-сервисы

REST — представительский государственный трансферт

Интерфейс REST через CherryPy

Аутентификация

авторизация

Состав

Инкапсуляция

Обработка ошибок

пример

Методы HTTP

Протокол публикации Atom (APP)

пример

CherryPy — презентационный слой

Малыш — Шаблонный движок

пример

Атрибуты ребенка

Основанный на XML язык шаблонов

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

Условный оператор

Петлевой механизм

пример

CherryPy — использование Ajax

AJAX

JSON

Применение AJAX к приложению

ajax_app.py

Выход

CherryPy — Демо-приложение

Базовая структура — дизайн сущностей

Структура дизайна

Подключение к базе данных

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

Модульное тестирование

Модульный тест

Функциональное тестирование

Нагрузочное тестирование

CherryPy — Развертывание приложения

конфигурация

развертывание

SSL