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

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

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

История CherryPy

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

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

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

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

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

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

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

В июне 2004 г. началась дискуссия о будущем проекта и о том, следует ли продолжать его с той же архитектурой. Мозговой штурм и обсуждение нескольких постоянных участников проекта затем привели к концепции механизма публикации объектов и фильтров, которая вскоре стала основной частью CherryPy2. Позднее, в октябре 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 с открытым исходным кодом (под лицензией BSD с открытым исходным кодом), что означает, что этот фреймворк можно использовать в коммерческих целях при НУЛЕВОЙ стоимости.

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

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

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

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

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

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

Требования

Основные требования для установки CherryPy framework включают:

• 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:

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

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

tar zxvf cherrypy-x.y.z.tgz

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

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

python setup.py build

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

python setup.py install

Установка с помощью easy_install

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

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

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

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

easy_install product_name

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

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

easy_install cherrypy

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

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

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

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

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

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

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

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

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

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

Step 2 - Введите следующую команду из оболочки:

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

Step 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. Ключевые слова и определения следующие:

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

пример

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

import cherrypy

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

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

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

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

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

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

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

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

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

cherryPy.server.quickstart()

В internal engine of 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) при поддержке клиентов.

• Встроенный HTTP-сервер CherryPy поддерживает постоянные соединения, которые используются по умолчанию в 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, и связывает определенный обработчик страницы.

пример

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

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 ())

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

Step 1 - Сохраните указанный выше файл как tutRoutes.py.

Step 2 - Посетите следующий URL -

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

Step 3 - Вы получите следующий вывод -

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

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

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

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

Аргументы

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

имя	По умолчанию	Описание
царство	Нет данных	Строка, определяющая значение области.
пользователи	Нет данных	Словарь формы - имя пользователя: пароль или вызываемая функция 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	ПамятьКэш	Объект класса, который будет использоваться для кеширования

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

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

Аргументы

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

имя	По умолчанию	Описание
кодирование	Никто	Ищет заголовок типа содержимого
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

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

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

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

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

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

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

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

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

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

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

• Static - Он включает в себя все файлы CSS и изображений.

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

пример

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

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

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

Step 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])

Step 4- Рассмотрим приложение, в котором пользователь вводит значение через форму. Включим в приложение две формы - index.html и submit.html.

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

Step 6 - Реализация index() метод можно изменить следующим образом -

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

Step 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>

Step 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')

Step 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>

Step 10 - Вы получите следующий вывод -

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

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

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

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

REST - передача репрезентативного состояния

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

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

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

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

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

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

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

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

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

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

• cherrypy.engine - Он контролирует запуск / завершение процесса и обработку событий.

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

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

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

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

• Authentication
• Authorization
• Structure
• Encapsulation
• Обработка ошибок

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

Аутентификация помогает в проверке подлинности пользователей, с которыми мы взаимодействуем. 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 framework должна иметь следующее:

• Учетные записи и пользователь
• Autoresponder
• Contact
• File
• Folder
• Список и поле
• Сообщение и пакет

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

Инкапсуляция помогает в создании 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.	HEAD Извлекает метаданные ресурса.
2.	GET Извлекает метаданные и контент ресурса.
3.	POST Запрашивает сервер создать новый ресурс с использованием данных, содержащихся в теле запроса.
4.	PUT Запрашивает сервер заменить существующий ресурс на тот, который заключен в теле запроса.
5.	DELETE Запрашивает сервер удалить ресурс, идентифицированный этим URI.
6.	OPTIONS Запрашивает сервер вернуть подробные сведения о возможностях глобально или конкретно по отношению к ресурсу.

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

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

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

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

пример

Давайте рассмотрим пример, чтобы продемонстрировать, как работает 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 поддерживает работу уровня представления с помощью различных механизмов шаблонов.

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

Малыш - движок шаблонов

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

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

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

Класс шаблона предоставляет следующий набор команд -

S.No	Команда и описание
1.	serialize Он возвращает выходной контент в виде строки.
2.	generate Он возвращает выходной контент как итератор.
3.	write Он выгружает выходной контент в файловый объект.

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

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

пример

Давайте рассмотрим пример, чтобы понять, как kid работает -

<!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 предлагает схему подстановки переменных и простой подход - $ {имя-переменной}.

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

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

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

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

<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')

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

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

Таким образом, произошел рост rich client applications которые раньше встраивали в них 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», которая находится в папке мультимедиа.

<!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.

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

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

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

• Film
• Photo
• Album

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

Тестирование определяется как ряд аспектов, которые необходимо проверить в системе или приложении. Ниже приводится списокcommon test approaches -

• Unit testing- Обычно этим занимаются сами разработчики. Это направлено на проверку того, работает ли модуль кода так, как ожидалось.

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

• Functional/Acceptance testing - В то время как тестирование удобства использования проверяет, можно ли использовать приложение или систему, функциональное тестирование гарантирует, что все указанные функции реализованы.

• Load and performance testing- Это делается для того, чтобы понять, может ли система адаптироваться к проводимым нагрузочным испытаниям и испытаниям производительности. Это может привести к изменениям в оборудовании, оптимизации SQL-запросов и т. Д.

• Regression testing - Он проверяет, что последовательные выпуски продукта не нарушают ни одну из предыдущих функций.

• Reliability and resilience testing - Тестирование надежности помогает проверить приложение системы при поломке одного или нескольких компонентов.

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

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

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

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.

• Каждый метод в приведенном выше коде начинается с проверки слова. Все эти методы вызываются обработчиком 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 () просто вызываются у сервера для получения ответа.

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

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

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

• Web server - Настройки, связанные с HTTP-сервером

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

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

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

Развертывание приложения 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 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 дней.

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

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()

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

HTTP Serving HTTPS on https://localhost:8443/