Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2014/OSS S1454 ccc

2014-10-29T03:34:01Z

Cehaith2:

= Sahana Eden: Extract The Progress Details =
== Introduction to Sahana Eden ==
Sahana is a software foundation with the express intent of “saving lives by providing information management solutions that enable organizations and communities to better prepare for and respond to disasters.” [http://sahanafoundation.org/about-us/] This is achieved
by developing free and open source software to make disaster response coordination more efficient. Eden (or Emergency Development ENvironment for Rapid Deployment Humanitarian Response Management), one of their main products is a feature-rich and rapidly customizable humanitarian platform that allows its modules to be specialized for particular organizations and management needs. Eden has been used to help address the wildfires in Chile, earthquakes and tsunamis in Japan, flooding in Colombia, flooding in Venezuela, flooding in Pakistan, and hurricane in Veracruz, Mexico [http://sahanafoundation.org/products/eden/]. The idea is to
mix and match several modules that Eden has to best suit the needs and context of an organization. The main modules are an Organization Registry, which can create databases of organizations to help facilitate coordination; Project Tracking, which tells who is doing what where and when and can tell who is working on similar projects to help facilitate collaboration; Human Resources, a tool that helps track and manage the people involved including what skills those people have; Inventory Management, which allows for recording and automating shipments and deliveries of supplies; Asset Management, which helps facilitate management of assets like vehicles, communication equipment, and generators as well as tell to whom each are assigned; Assessments, which can be used to collect and analyze information; Shelter Management, which helps facilitate the management of temporary shelters including required resources, staff and volunteer assignments, and check-in/check-out systems; Scenario and Event planning, which helps facilitate planning for various emergency scenarios; Mapping, which enables location-based visualization on maps; and Messaging, which facilitates communications over various protocol and social media mediums. Eden’s WebSetup is the tool that facilitates the setup process of a new Eden tool. The process of setting up a new Eden project entails many moving parts, so detecting bugs and troubleshooting issues in the process can be tricky. A developer created a New Enhancement ticket that requested work on being able to extract the progress details of the setup into a single local file, not dissimilar to a log file. [http://eden.sahanafoundation.org/ticket/1468]
== Web2Py Tasks and Task Scheduler ==
Sahana Eden uses the Web2Py; an application development framework written in Python that uses a typical MVC pattern. In order to best manage work on large and complicated functionality in the background, Web2Py implemented a scheduler that allows control over processes. A task is a function defined in a model:

def task_getParity(i):
if i % 2 == 0:
return “even”
return “odd”
===== Queuing Tasks =====
Tasks can then be queued up with additional meta-parameters for running the function, such as when the task should die, how long can the process run until timeout occurs, how many times to repeat the function, what parameters to send to the task (if applicable), et cetera.
scheduler.queue_task(‘task_getParity’, [8], …)
===== Scheduler Creation =====
The scheduler is the manager for the tasks and workers. Creating a scheduler requires a database at the least in order to store the states of tasks. However, the scheduler can be instantiated with additional parameters that allow specifications for the time between each check of the queue, specific names of functions to queue, the amount of times the queue is checked before a worker must be terminated, et cetera.
from gluon.scheduler import Scheduler
scheduler = Scheduler(database [,…])
===== Task Lifecycle [http://www.web2py.com/books/default/chapter/29/04/the-core#web2py-Scheduler] =====

Similar to Java threads and Linux processes, a Web2Py process (interchangeable at this point with task) lifecycle is as follows:
* '''Queued''' a task is queued to be picked up by a worker.
* '''Expired''' the task died in the queue (the amount of time designated to cause the task to die has passed).
* '''Assigned''' a worker is assigned to this task.
* '''Running''' the task is being carried out.
* '''Timeout''' the task timed out (the amount of time designated to case the task to timeout during processing has passed).
* '''Failed''' an error was detected or an exception was thrown.
* '''Completed''' the task finished correctly.
===== Worker Management =====
Also similar to Linux is the ability to control the workers (processes in Linux are manageable via jobs, synonymous with workers managing Web2Py tasks). Workers can be controlled with the following functions:
disable() # Put the worker to sleep
terminate() # The worker dies gracefully as soon as possible
kill() # The worker dies immediately
== Sahana Eden-specific Tasks ==
The Sahana Eden developers created a wrapper class for the Web2Py tasks. The wrapper, s3task.py, is a very “thin” and adds only minimal functionality to the Web2Py tasks.
Specifically, it allows a task to be run asynchronously, the database to handle CRUD actions including setting defaults and hiding unnecessary fields, duplicate task checking, determination
of whether or not at least one worker is alive, and requeueing failed tasks. At the request of the mentors for this ticket, the functionality was generalized to all processes. Due to limitations of reporting the details of the progress of tasks, the logging is based on the status available via the scheduler. Explicit logging of steps would need to be on a per function basis, with each function logging their own progress.

The functionality of logging was added to the s3task.py and a timer was added to the s3utils.py file. If report_progress was set to true when scheduling a new task (default is false), then a logfile is created whose name contains the date and time the task was started and the task name. A timer is created. While this timer is running, it will check the status of the task and log the status of the task to the log file. The default is currently to log every second for ten seconds.
===== The Repeated Timer =====
class RepeatedTimer(object):
# Create a timer and start a timer. Any additional arguments are
# passed to the task for the tasks to handle
def __init__(self, interval, function, *args, **kwargs):
self._timer = None
self.interval = interval
self.function = function
self.args = args
self.kwargs = kwargs
self.is_running = False
self.start()
# Start the timer and the task
def _run(self):
self.is_running = False
self.start()
self.function(*self.args, **self.kwargs)
# Start the timer and the task if the timer is currently not running
def start(self):
if not self.is_running:
self._timer = Timer(self.interval, self._run)
self._timer.start()
self.is_running = True
# Stop the timer
def stop(self):
self._timer.cancel()
self.is_running = False
===== Logging the Status of a Task =====
def check_status(user_id, log_name, task_id, scheduler, task_name):
# The log file’s parent directory
log_path = "/home/dev/web2py/applications/eden/logs/tasks/"
# Connect to the task status database
from gluon import DAL, Field
db = DAL('sqlite://storage.db', folder='applications/eden/databases', auto_import=True)
# Grab the status of the current task from the database connection
table = db.scheduler_task
query = (table.id == task_id)
task_status = db(query).select(table.status).first().status
# Make the log directory if it doesn’t exist
import os
if not os.path.exists(log_path):
os.makedirs(log_path)
# Open the log and write the status
with open(log_path + log_name, "a+") as log:
log.write('%s is currently in the %s state\n' % (task_name, task_status))
=====Constructing and Running the Timer=====
if report_progress:
# Construct the name of the log with current time, date, and task name
log_name = datetime.datetime.now().strftime("%y-%m-%d-%H-%M") + "_" + task + ".txt"
# Import the sleep module
from time import sleep
# Create the timer that runs check_status on the task every 1 second
rt = RepeatedTimer(1, self.check_status, log_name, record.id, self.scheduler, task)
# Allow the timer to run 10 seconds then stop it.
try:
sleep(10)
finally:
rt.stop()

CSC/ECE 517 Fall 2014/OSS S1454 ccc

2014-10-29T03:21:45Z

Cehaith2:

CSC/ECE 517 Fall 2014/OSS S1454 ccc

2014-10-29T03:15:35Z

Cehaith2: Created page with "= Sahana Eden: Extract The Progress Details = == Introduction to Sahana Eden == Sahana is a software foundation with the express intent of “saving lives by providing informati..."

CSC/ECE 517 Fall 2014

2014-10-29T03:00:14Z

Cehaith2:

*[[CSC/ECE_517_Fall_2014/sample_page]]
*[[CSC/ECE_517_Fall_2014/ch1a 22 as]]
*[[CSC/ECE 517 Fall 2014/ch1a 19 mx]]
*[[CSC/ECE 517 Fall 2014/ch1a 3 zq]]
*[[CSC/ECE 517 Fall 2014/ch1a 4 lf]]
*[[CSC/ECE 517 Fall 2014/ch1a 4 wl]]
*[[CSC/ECE 517 Fall 2014/ch1a a7 ch]]
*[[CSC/ECE 517 Fall 2014/ch1a 25 rs]]
*[[CSC/ECE 517 Fall 2014/ch1a 25 jf]]
*[[CSC/ECE 517 Fall 2014/ch1a 8 os]]
*[[CSC/ECE 517 Fall 2014/ch1a 8 sn]]
*[[CSC/ECE 517 Fall 2014/ch1a 15 gs]]
*[[CSC/ECE 517 Fall 2014/ch1a 10 hu]]
*[[CSC/ECE 517 Fall 2014/ch1a 20 kv]]
*[[CSC/ECE 517 Fall 2014/ch1a 21 as]]
*[[CSC/ECE 517 Fall 2014/ch1a 24 sa]]
*[[CSC/ECE 517 Fall 2014/ch1a 26 sn]]
*[[CSC/ECE 517 Fall 2014/ch1a 6 rl]]
*[[CSC/ECE 517 Fall 2014/ch1a 2 ss]]
*[[CSC/ECE 517 Fall 2014/ch1a 16 av]]
*[[CSC/ECE 517 Fall 2014/ch1a 1 rm]]
*[[CSC/ECE 517 Fall 2014/ch1a 1 sj]]
*[[CSC/ECE 517 Fall 2014/ch1a 23 ss]]
*[[CSC/ECE 517 Fall 2014/ch1a 20 rn]]
*[[CSC/ECE 517 Fall 2014/ch1a 22 sp]]
*[[CSC/ECE 517 Fall 2014/oss M1454 rss]]

*[[CSC/ECE 517 Fall 2014/ch1a 26 gn]]

*[[CSC/ECE 517 Fall 2014/ch1a 13 va]]
*[[CSC/ECE 517 Fall 2014/ch1a 9 aa]]
*[[CSC/ECE 517 Fall 2014/ch1a 9 kn]]
*[[CSC/ECE 517 Fall 2014/ch1a 11 ap]]
*[[CSC/ECE 517 Fall 2014/ch1a 25 ks]]
*[[CSC/ECE 517 Fall 2014/ch1a 7 kz]]
*[[CSC/ECE_517_Fall_2014/ch1a_6_bn]]
*[[CSC/ECE_517_Fall_2014/ch1a 10 zz]]
*[[CSC/ECE_517_Fall_2014/ch1a 16 va]]
*[[CSC/ECE_517_Fall_2014/ch1a F1415 rv]]
*[[CSC/ECE_517_Fall_2014/ch1a_3_cp]]
*[[CSC/ECE 517 Fall 2014/ch1b 26 sa]]
*[[CSC/ECE_517_Fall_2014/ch1b_28_cg]]
*[[CSC/ECE_517_Fall_2014/ch1b 29 ry]]
*[[CSC/ECE_517_Fall_2014/ch1b 30 cs]]
*[[CSC/ECE_517_Fall_2014/ch1b_33_jy]]
*[[CSC/ECE_517_Fall_2014/ch1b_27_js]]
*[[CSC/ECE 517 Fall 2014/oss E1463 vpd]]
*[[CSC/ECE 517 Fall 2014/oss E1465 oak]]
*[[CSC/ECE 517 Fall 2014/oss_M1456_kdv]]
*[[CSC/ECE 517 Fall 2014/oss_M1453_sst]]
*[[CSC/ECE 517 Fall 2014/oss_E1456_akk]]
*[[CSC/ECE_517_Fall_2014/oss_M1455_asa]]
*[[CSC/ECE_517_Fall_2014/oss_E1458_sst]]
*[[CSC/ECE_517_Fall_2014/oss_E1457_ags]]
*[[CSC/ECE_517_Fall_2014/OSS_E1466_gjf]]
*[[CSC/ECE_517_Fall_2014/oss_M1452_jns]]
*[[CSC/ECE_517_Fall_2014/oss_E1462_nms]]
*[[CSC/ECE_517_Fall_2014/OSS_S1455_ajp]]
*[[CSC/ECE_517_Fall_2014/OSS_S1454_ccc]]

CSC/ECE 517 Fall 2014/ch1a 3 cp

2014-09-24T21:21:43Z

Cehaith2: /* CherryPy */

='''CherryPy'''=

__TOC__

==Overview==
[http://www.cherrypy.org/ CherryPy] is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented] [http://en.wikipedia.org/wiki/Web_application_framework Web Application Framework] meant to be [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]-like (sparse and clean code). 
It is important to note that it is not a complete stack such as [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails], [http://en.wikipedia.org/wiki/Laravel Laravel], or [http://en.wikipedia.org/wiki/Django Django]. Complete stack web frameworks offer frontend utilities and storage communications along with other abilities. These aspects that make the frameworks so powerful, however, also contribute to the framework being bulky making development of small web applications such as blogs a bit cumbersome. CherryPy instead prefers to defer decisions such as storage management and interface utilities to the developer <ref>http://docs.cherrypy.org/en/latest/intro.html</ref>

==Installation==

===Overview===
Because CherryPy is nothing more than a Python library, it needs a Python environment (Python 2.3 through to 3.4) and can also run on various implementations of Python including [http://en.wikipedia.org/wiki/IronPython IronPython] for [http://en.wikipedia.org/wiki/.NET_Framework .NET] and [http://en.wikipedia.org/wiki/Jython Jython] for [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java].<ref>http://docs.cherrypy.org/en/latest/install.html</ref>

===Requirements===
CherryPy requires a Python version between 2.3 and 3.4 inclusively. Certain features require packages but none are mandatory for installation.<ref>http://docs.cherrypy.org/en/latest/install.html</ref>
*[http://routes.readthedocs.org/en/latest/ routes] for declarative URL mapping dispatcher
*[http://pythonhosted.org//psycopg2/ psycopg2] for [http://en.wikipedia.org/wiki/PostgreSQL PostgreSQL] database backend session
*[http://sourceforge.net/projects/pywin32/ pywin32] for Windows services
*[https://github.com/linsomniac/python-memcached python-memcached] for [http://en.wikipedia.org/wiki/Memcached Memcached] backend session
*[https://github.com/simplejson/simplejson simplejson] for a better [http://en.wikipedia.org/wiki/JSON JSON] support
*[https://github.com/pyca/pyopenssl pyOpenSSL] if your Python environment does not have the built in [http://en.wikipedia.org/wiki/Transport_Layer_Security ssl] module

===Installing===
CherryPy can be installed through common Python package managers with the following commands:<ref>http://docs.cherrypy.org/en/latest/install.html</ref> 

Install (choose on of the following commands appropriately):
$ easy_install cherrypy
$ pip install cherrypy
$ yum install python-cherrypy
$ apt-get install python python-dev

===Install via yum===
CherryPy is provided by the fedora base repository. In [http://en.wikipedia.org/wiki/Fedora_%28operating_system%29 Fedora] (and other [http://en.wikipedia.org/wiki/RPM_Package_Manager RPM] based Linux distributions, such as [http://en.wikipedia.org/wiki/CentOS CentOS] and [http://en.wikipedia.org/wiki/Red_Hat_Enterprise_Linux Red Hat Enterprise Linux]): 
$ yum install python-cherrypy

===Install via apt-get===
CherryPy is also provided in the [http://en.wikipedia.org/wiki/Ubuntu_(operating_system) Ubuntu] base repository. In Ubuntu (and other [http://en.wikipedia.org/wiki/Debian Debian]-based Linux distributions such as Debian and [http://en.wikipedia.org/wiki/Linux_Mint Linux Mint]):
$ apt-get install python python-dev

===Installation from source===
The source code is hosted on [http://en.wikipedia.org/wiki/Bitbucket BitBucket] and requires [http://en.wikipedia.org/wiki/Mercurial Mercurial] to pull and install from the site itself.
$ hg clone https://bitbucket.org/cherrypy/cherrypy
$ cd cherrypy
$ python setup.py install

Alternatively, the source can be manually downloaded from [https://bitbucket.org/cherrypy/cherrypy/downloads here] in a tarball.
$ tar -xvf CherryPy-#.#.#.tar.gz
$ cd CherryPy-#.#.#
$ python setup.py install

===Install for Windows===
*If you are using Windows, install Linux and follow any of the a forementioned methods.
*If you absolutely must use windows, you can download the .exe file to install CherryPy from [https://bitbucket.org/cherrypy/cherrypy/downloads here].

==Interface==

CherryPy is meant to be pythonic, meaning that development time is meant to be minimized and code is meant to be sparse and clean <ref>http://docs.cherrypy.org/en/latest/intro.html</ref>

===Basic Example===
Lets look at a hello world example<ref>https://cherrypy.readthedocs.org/en/3.2.6/concepts/basics.html</ref><ref>http://stackoverflow.com/questions/419163/what-does-if-name-main-do</ref>
<pre>
#Use the cherrypy python library
import cherrypy

#Hello World project
class HelloWorld(object):

# index page
def index(self):
# Return the page contents
return “Hello World!”

# Allow the page to be visible
index.exposed = True

#designates this module as main
if __name__ == ‘__main__’:

# instantiates app and starts server
cherrypy.quickstart(HelloWorld())

</pre>
The above script sets up a basic Hello World application, by defining the index page (http://localhost:8080/) as an object that returns the string “Hello World!”. The page is exposed, meaning that the method can be called to answer a [http://en.wikipedia.org/wiki/Representational_state_transfer RESTful] request. Otherwise, the method is internal only. This is similar to making a method public in Java. <ref>http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html</ref>

===Routing, Parameters, and Exposure===
Routing is the act of finding the appropriate code to handle a request. CherryPy uses a dispatcher to perform most of these, but premade dispatchers exist to handle more sophisticated handling of request. The most common is a page handler (the name of the object). Parameters can be passed into the handler via http query strings. These strings are appended to the URL of a site after a "?". Exposure is just the way CherryPy prevents access to objects from the users. Without the exposed attribute set to true, an object won't be accessible to the user.
<pre>
#import python library
import cherrypy

#More Routes application
class MoreRoutes(object):

# Method decorator for index and equates to index.exposed = True
@cherrypy.expose
def index(self):
return "Hello world!"

# http://localhost:8080/route1
def route1(self, id=”charles”):
# http://localhost:8080/route1?id=somestring
return “Your name is ” + id

# Params passed as a GET request.
# Default string is “charles”
route1.exposed = True

# No explicit indication of exposure so calling this route will generate a 404 error
def route2(self):
return “Still another one”

if __name__ == '__main__':
cherrypy.quickstart(MoreRoutes())

</pre>

The above shows how multiple routes are handled from the Hello World application and the expose decorator. Since route2 is not exposed, the user can not access it and will be shown a 404 HTTP status code (Not Found error).

===Multiple Applications===

<pre>
import cherrypy
#blog module
class Blog(object):
...<blog code>...
#forum module
class Forum(object):
...<forum code>...
#”main” method
if __name__ == '__main__':
#designates the blog to be under /blog route
cherrypy.tree.mount(Blog(), ‘/blog’, “blog.conf”)
#designates the forum to be under /forum route
cherrypy.tree.mount(Forum(), ‘/forum’, “forum.conf”)
</pre> <ref>http://docs.cherrypy.org/en/latest/basics.html#multiple-applications</ref>
In the above example, the blog would be found under /blog in the URL, wheras the forum will be mounted at /forum in the application tree. The XXX.conf files are configuration files, which are dictionaries containing string keys and polymorphic values and can be used to set attributes on the engine, server, request, response, and log objects. <ref>https://cherrypy.readthedocs.org/en/3.2.6/concepts/config.html</ref>

===Database Support===
CherryPy offers multiple database integration possibilities including
*[http://en.wikipedia.org/wiki/Relational_database Relational]: [http://en.wikipedia.org/wiki/PostgreSQL PostgreSQL], [http://en.wikipedia.org/wiki/SQLite SQLite], [http://en.wikipedia.org/wiki/MariaDB MariaDB], [http://en.wikipedia.org/wiki/Firebird_%28database_server%29 Firebird]
*[http://en.wikipedia.org/wiki/Column-oriented_DBMS Column-Oriented]: [http://en.wikipedia.org/wiki/Apache_HBase HBase], [http://en.wikipedia.org/wiki/Apache_Cassandra Cassandra]
*[http://en.wikipedia.org/wiki/NoSQL#Key.E2.80.93value_stores Key-Store]: [http://en.wikipedia.org/wiki/Redis Redis], [http://en.wikipedia.org/wiki/Memcached Memcached]
*[http://en.wikipedia.org/wiki/Document-oriented_database Document-Oriented]: [http://en.wikipedia.org/wiki/CouchDB Couchdb], [http://en.wikipedia.org/wiki/MongoDB MongoDB]
*[http://en.wikipedia.org/wiki/Graph_database Graph-Oriented]: [http://en.wikipedia.org/wiki/Neo4j Neo4j] 
Unfortunately, unlike [https://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails], CherryPy does not have a sophisticated [https://en.wikipedia.org/wiki/Active_record_pattern#Ruby Active Record Pattern] based class for database abstraction, and the database connection has to be established manually. The queries are constructed as static [https://en.wikipedia.org/wiki/SQL SQL] strings with values concatenated during function calls. 

Here is an example of how it would look like<ref>http://cherrypy.readthedocs.org/en/latest/tutorials.html#tutorial-9-data-is-all-my-life</ref>
<pre>

# import the Handles
import MySQLdb
import cherrypy

# defining the connection function
def connect(thread_index):
# Create a connection and store it in the current thread
cherrypy.thread_data.db = MySQLdb.connect('host', 'user', 'password', 'dbname')

# tell cherrypy to call connect function for each thread
cherrypy.engine.subscribe('start_thread', connect)

# example query function
@cherrypy.expose
def count(val)
# fetching instance of db connection
c = cherrypy.thread_data.db.cursor()
# executing query
c.execute( 'select count(‘ + val + ’) from table' )
# fetching results from db
res = c.fetchone()
# releasing instance of the connection
c.close()
# returning the count value
return res

</pre>

==RESTful CherryPy==
[http://en.wikipedia.org/wiki/Representational_state_transfer REST] (Representational State Transfer) is an abstraction of the architectural elements within a distributed hypermedia system. It ignores the details of component implementation and protocol syntax in order to focus on the roles of components, the constraints upon their interaction with other components, and their interpretation of significant data elements. It encompasses the fundamental constraints upon components, connectors, and data that define the basis of the Web architecture, and thus the essence of its behavior as a network-based application. <ref>http://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm</ref> 
In othe words, REST is defined by four interface constraints: identification of resources, manipulation of resources through representations, self-descriptive messages, and hypermedia as the engine of application state.<ref>https://cherrypy.readthedocs.org/en/3.2.6/progguide/REST.html</ref>

===Identification of Resources===
Since Cherrypy is an HTTP service provider, resources are referenced by HTTP URIs (Uniform Resource Identifiers), which consist of a scheme, hierarchical identitfier, query, and fragment.<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#implementing-rest-in-cherrypy</ref> 
*Scheme: in [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol http], the scheme is always http or [http://en.wikipedia.org/wiki/HTTP_Secure https].
*Hierarchical Identifier: consists of an authority and a path (host/port and a path similar to the system file path but not the actual path). The path is mapped to Python Objects via a dispatch mechanism.

===Manipulation of Resources Through Representations===
The standard [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html HTTP methods] are as follows<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#manipulation-of-resources-through-representations</ref>
*<code>GET</code> retrieves the state of a specific resource
*<code>PUT</code> creates or replaces the state of a specific resource
*<code>POST</code> passes information to a resource to use as it sees fit
*<code>DELETE</code> removes resources

===Self-Descriptive Messages===
REST requires messages to be self-descriptive, meaning everything about a message is within the message itself. Such information can be found in the method headers or the definitions of the message’s media type. cherrypy.request.headers and cherrypy.response.headers are used to get this information. Custom-Types are allowed as well.<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#self-descriptive-messages</ref>

===Hypermedia as the Engine of the Application State===
Since REST is stateless and the state is maintained by the application in question, sessions are not maintained by REST, so, by association, CherryPy does not enable sessions by default. However, the REST server helps clients maintain a meaningful state through meaningful URIs<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#hypermedia-as-the-engine-of-application-state</ref>

==Crash Course==

===Development===
Create an application. Application requirements:
*The module needs to define a <code>__main__ </code>
*<code>cherrypy.quickstart(<Application Name>())</code> for hosting a single application. For example: cherrypy.quickstart(Blog())
*<code>cherrypy.tree.mount(<Application Name>(), ‘/<hosting path segment>’, <configuration>)</code> for hosting multiple applications. For example: <code>cherrypy.tree.mount(Blog(), ‘/blog’, blog_conf) </code>
*All parts the users will see must be exposed with either the decorator <code>@cherrypy.expose or attribues exposed = True</code> or <code>route.exposed = True.</code>

<pre>
import cherrypy
class HelloWorld(object):
def index(self):
return “Hello World!”
index.exposed = True
if __name__ == ‘__main__’:
cherrypy.quickstart(HelloWorld())
</pre>

===Deployment===
The application can be run as a python script in the Python interpreter.
$ python <app file>.py
It will hosted at http://127.0.0.1:8080/
It can also be run as a daemon process with
$cherryd -c <config file> -d -p <PID file>

==Extensions==

CherryPy provides a flexible open framework. Similar to [http://en.wikipedia.org/wiki/RubyGems RubyGems] in [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails] which add a range of functionality to the framework CherryPy also supports plugins in the the following forms

===Server Wide Functions (Plugins)===
This type of extension is typically used to provide the application server itself with additional functionality. Such functions are executed with respect to events in the server even when there is no client request processing taking place.<ref>http://docs.cherrypy.org/en/latest/extend.html#id13</ref> 
Typical use case involve
*Background Tasks (Tasks which involve server mentainance, data management etc. which are independent of user requests)
*External Connections (For establishing and maintaining threaded connections to external database or other servers)
*Delayed/Queued Processing (Cases when certain tasks are required by the user request which take a long time process and the HTTP response should not be blocked.) 
These function utilize the [http://en.wikipedia.org/wiki/Publish–subscribe_pattern Publish-Subscribe Framework] implementation of CherryPy. Each function subscribes to one or more events on the bus which are published by the CherryPy engine. The database connection is a good example of such a function 

<pre>
# import the Handles
import MySQLdb
import cherrypy
# defining the connection function
def connect(thread_index):
# Create a connection and store it in the current thread
cherrypy.thread_data.db = MySQLdb.connect('host', 'user', 'password', 'dbname')

# tell cherrypy to call connect function for each thread
cherrypy.engine.subscribe('start_thread', connect)
</pre>

Here the function connect subscribes to the <code>start_thread</code> channel. An event is published on the <code>start_thread</code> channel whenever a server thread is started. Here <code>engine</code> is the central bus of the CherryPy server. 
Similarly it is also possible to create new channels and even buses themselves.

===Per-Request Functions (Tools)===
This type of extension is typically used to insert functionality between stages of request processing. Also known as [http://docs.cherrypy.org/en/latest/extend.html#tools Tools] these are simple call-back functions registered with a [http://docs.cherrypy.org/en/latest/extend.html#hookpoint Hook Point]. Hook Points are predefined stages of request processing. CherryPy provides a [http://tools.cherrypy.org/ Default ToolBox] containing many tools. Users have the freedom to create their own tools and add them to the default toolbox or create a new one.<ref>http://docs.cherrypy.org/en/latest/extend.html#per-request-functions</ref> 
An example for creating a tool

<pre>
# defining the function to be called
def my_tool():
# put tool functunality here
print (“Super Amazing Tool”);

# creating the decorator for the tool
# specifying the hook point and function to be called
cherrypy.tools.mytool = cherrypy.Tool(‘on_end_request’, my_tool())

#Sample Usage

class Root(object):
@cherrypy.expose()
@cherrypy.tools.mytool()
def index()
return “Hello World”
</pre>

==Watch It In Action==

CherryPy is used as a building block for [http://www.hulu.com/ Hulu]<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu</ref> and [https://www.netflix.com/ Netflix]<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>

==References==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 cp

2014-09-24T20:44:38Z

Cehaith2: /* Multiple Applications */

='''CherryPy'''=

__TOC__

==Overview==
[http://www.cherrypy.org/ CherryPy] is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented] [http://en.wikipedia.org/wiki/Web_application_framework Web Application Framework] meant to be [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]-like (sparse and clean code). 
It is important to note that it is not a complete stack such as [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails], [http://en.wikipedia.org/wiki/Laravel Laravel], or [http://en.wikipedia.org/wiki/Django Django]. Complete stack web frameworks offer frontend utilities and storage communications along with other abilities. These aspects that make the frameworks so powerful, however, also contribute to the framework being bulky making development of small web applications such as blogs a bit cumbersome. CherryPy instead prefers to defer decisions such as storage management and interface utilities to the developer <ref>http://docs.cherrypy.org/en/latest/intro.html</ref>

==Installation==

===Overview===
Because CherryPy is nothing more than a Python library, it needs a Python environment (Python 2.3 through to 3.4) and can also run on various implementations of Python including [http://en.wikipedia.org/wiki/IronPython IronPython] for [http://en.wikipedia.org/wiki/.NET_Framework .NET] and [http://en.wikipedia.org/wiki/Jython Jython] for [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java].<ref>http://docs.cherrypy.org/en/latest/install.html</ref>

===Requirements===
CherryPy requires a Python version between 2.3 and 3.4 inclusively. Certain features require packages but none are mandatory for installation.<ref>http://docs.cherrypy.org/en/latest/install.html</ref>
*[http://routes.readthedocs.org/en/latest/ routes] for declarative URL mapping dispatcher
*[http://pythonhosted.org//psycopg2/ psycopg2] for [http://en.wikipedia.org/wiki/PostgreSQL PostgreSQL] database backend session
*[http://sourceforge.net/projects/pywin32/ pywin32] for Windows services
*[https://github.com/linsomniac/python-memcached python-memcached] for [http://en.wikipedia.org/wiki/Memcached Memcached] backend session
*[https://github.com/simplejson/simplejson simplejson] for a better [http://en.wikipedia.org/wiki/JSON JSON] support
*[https://github.com/pyca/pyopenssl pyOpenSSL] if your Python environment does not have the built in [http://en.wikipedia.org/wiki/Transport_Layer_Security ssl] module

===Installing===
CherryPy can be installed through common Python package managers with the following commands:<ref>http://docs.cherrypy.org/en/latest/install.html</ref> 

Install (choose on of the following commands appropriately):
$ easy_install cherrypy
$ pip install cherrypy
$ yum install python-cherrypy
$ apt-get install python python-dev

Refer [[#Additional Installation Instructions| Additional Instructions]] for more details.

==Interface==

CherryPy is meant to be pythonic, meaning that development time is meant to be minimized and code is meant to be sparse and clean <ref>http://docs.cherrypy.org/en/latest/intro.html</ref>

===Basic Example===
Lets look at a hello world example<ref>https://cherrypy.readthedocs.org/en/3.2.6/concepts/basics.html</ref><ref>http://stackoverflow.com/questions/419163/what-does-if-name-main-do</ref>
<pre>
#Use the cherrypy python library
import cherrypy

#Hello World project
class HelloWorld(object):

# index page
def index(self):
# Return the page contents
return “Hello World!”

# Allow the page to be visible
index.exposed = True

#designates this module as main
if __name__ == ‘__main__’:

# instantiates app and starts server
cherrypy.quickstart(HelloWorld())

</pre>
The above script sets up a basic Hello World application, by defining the index page (http://localhost:8080/) as an object that returns the string “Hello World!”. The page is exposed, meaning that the method can be called to answer a [http://en.wikipedia.org/wiki/Representational_state_transfer RESTful] request. Otherwise, the method is internal only. This is similar to making a method public in Java. <ref>http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html</ref>

===Routing, Parameters, and Exposure===
Routing is the act of finding the appropriate code to handle a request. CherryPy uses a dispatcher to perform most of these, but premade dispatchers exist to handle more sophisticated handling of request. The most common is a page handler (the name of the object). Parameters can be passed into the handler via http query strings. These strings are appended to the URL of a site after a "?". Exposure is just the way CherryPy prevents access to objects from the users. Without the exposed attribute set to true, an object won't be accessible to the user.
<pre>
#import python library
import cherrypy

#More Routes application
class MoreRoutes(object):

# Method decorator for index and equates to index.exposed = True
@cherrypy.expose
def index(self):
return "Hello world!"

# http://localhost:8080/route1
def route1(self, id=”charles”):
# http://localhost:8080/route1?id=somestring
return “Your name is ” + id

# Params passed as a GET request.
# Default string is “charles”
route1.exposed = True

# No explicit indication of exposure so calling this route will generate a 404 error
def route2(self):
return “Still another one”

if __name__ == '__main__':
cherrypy.quickstart(MoreRoutes())

</pre>

The above shows how multiple routes are handled from the Hello World application and the expose decorator. Since route2 is not exposed, the user can not access it and will be shown a 404 HTTP status code (Not Found error).

===Multiple Applications===

<pre>
import cherrypy
#blog module
class Blog(object):
...<blog code>...
#forum module
class Forum(object):
...<forum code>...
#”main” method
if __name__ == '__main__':
#designates the blog to be under /blog route
cherrypy.tree.mount(Blog(), ‘/blog’, “blog.conf”)
#designates the forum to be under /forum route
cherrypy.tree.mount(Forum(), ‘/forum’, “forum.conf”)
</pre> <ref>http://docs.cherrypy.org/en/latest/basics.html#multiple-applications</ref>
In the above example, the blog would be found under /blog in the URL, wheras the forum will be mounted at /forum in the application tree. The XXX.conf files are configuration files, which are dictionaries containing string keys and polymorphic values and can be used to set attributes on the engine, server, request, response, and log objects. <ref>https://cherrypy.readthedocs.org/en/3.2.6/concepts/config.html</ref>

===Database Support===
CherryPy offers multiple database integration possibilities including
*[http://en.wikipedia.org/wiki/Relational_database Relational]: [http://en.wikipedia.org/wiki/PostgreSQL PostgreSQL], [http://en.wikipedia.org/wiki/SQLite SQLite], [http://en.wikipedia.org/wiki/MariaDB MariaDB], [http://en.wikipedia.org/wiki/Firebird_%28database_server%29 Firebird]
*[http://en.wikipedia.org/wiki/Column-oriented_DBMS Column-Oriented]: [http://en.wikipedia.org/wiki/Apache_HBase HBase], [http://en.wikipedia.org/wiki/Apache_Cassandra Cassandra]
*[http://en.wikipedia.org/wiki/NoSQL#Key.E2.80.93value_stores Key-Store]: [http://en.wikipedia.org/wiki/Redis Redis], [http://en.wikipedia.org/wiki/Memcached Memcached]
*[http://en.wikipedia.org/wiki/Document-oriented_database Document-Oriented]: [http://en.wikipedia.org/wiki/CouchDB Couchdb], [http://en.wikipedia.org/wiki/MongoDB MongoDB]
*[http://en.wikipedia.org/wiki/Graph_database Graph-Oriented]: [http://en.wikipedia.org/wiki/Neo4j Neo4j] 
Unfortunately, unlike [https://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails], CherryPy does not have a sophisticated [https://en.wikipedia.org/wiki/Active_record_pattern#Ruby Active Record Pattern] based class for database abstraction, and the database connection has to be established manually. The queries are constructed as static [https://en.wikipedia.org/wiki/SQL SQL] strings with values concatenated during function calls. 

Here is an example of how it would look like<ref>http://cherrypy.readthedocs.org/en/latest/tutorials.html#tutorial-9-data-is-all-my-life</ref>
<pre>

# import the Handles
import MySQLdb
import cherrypy

# defining the connection function
def connect(thread_index):
# Create a connection and store it in the current thread
cherrypy.thread_data.db = MySQLdb.connect('host', 'user', 'password', 'dbname')

# tell cherrypy to call connect function for each thread
cherrypy.engine.subscribe('start_thread', connect)

# example query function
@cherrypy.expose
def count(val)
# fetching instance of db connection
c = cherrypy.thread_data.db.cursor()
# executing query
c.execute( 'select count(‘ + val + ’) from table' )
# fetching results from db
res = c.fetchone()
# releasing instance of the connection
c.close()
# returning the count value
return res

</pre>

==RESTful CherryPy==
[http://en.wikipedia.org/wiki/Representational_state_transfer REST] (Representational State Transfer) is an abstraction of the architectural elements within a distributed hypermedia system. It ignores the details of component implementation and protocol syntax in order to focus on the roles of components, the constraints upon their interaction with other components, and their interpretation of significant data elements. It encompasses the fundamental constraints upon components, connectors, and data that define the basis of the Web architecture, and thus the essence of its behavior as a network-based application. <ref>http://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm</ref> 
In othe words, REST is defined by four interface constraints: identification of resources, manipulation of resources through representations, self-descriptive messages, and hypermedia as the engine of application state.<ref>https://cherrypy.readthedocs.org/en/3.2.6/progguide/REST.html</ref>

===Identification of Resources===
Since Cherrypy is an HTTP service provider, resources are referenced by HTTP URIs (Uniform Resource Identifiers), which consist of a scheme, hierarchical identitfier, query, and fragment.<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#implementing-rest-in-cherrypy</ref> 
*Scheme: in [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol http], the scheme is always http or [http://en.wikipedia.org/wiki/HTTP_Secure https].
*Hierarchical Identifier: consists of an authority and a path (host/port and a path similar to the system file path but not the actual path). The path is mapped to Python Objects via a dispatch mechanism.

===Manipulation of Resources Through Representations===
The standard [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html HTTP methods] are as follows<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#manipulation-of-resources-through-representations</ref>
*<code>GET</code> retrieves the state of a specific resource
*<code>PUT</code> creates or replaces the state of a specific resource
*<code>POST</code> passes information to a resource to use as it sees fit
*<code>DELETE</code> removes resources

===Self-Descriptive Messages===
REST requires messages to be self-descriptive, meaning everything about a message is within the message itself. Such information can be found in the method headers or the definitions of the message’s media type. cherrypy.request.headers and cherrypy.response.headers are used to get this information. Custom-Types are allowed as well.<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#self-descriptive-messages</ref>

===Hypermedia as the Engine of the Application State===
Since REST is stateless and the state is maintained by the application in question, sessions are not maintained by REST, so, by association, CherryPy does not enable sessions by default. However, the REST server helps clients maintain a meaningful state through meaningful URIs<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#hypermedia-as-the-engine-of-application-state</ref>

==Crash Course==

===Development===
Create an application. Application requirements:
*The module needs to define a <code>__main__ </code>
*<code>cherrypy.quickstart(<Application Name>())</code> for hosting a single application. For example: cherrypy.quickstart(Blog())
*<code>cherrypy.tree.mount(<Application Name>(), ‘/<hosting path segment>’, <configuration>)</code> for hosting multiple applications. For example: <code>cherrypy.tree.mount(Blog(), ‘/blog’, blog_conf) </code>
*All parts the users will see must be exposed with either the decorator <code>@cherrypy.expose or attribues exposed = True</code> or <code>route.exposed = True.</code>

<pre>
import cherrypy
class HelloWorld(object):
def index(self):
return “Hello World!”
index.exposed = True
if __name__ == ‘__main__’:
cherrypy.quickstart(HelloWorld())
</pre>

===Deployment===
The application can be run as a python script in the Python interpreter.
$ python <app file>.py
It will hosted at http://127.0.0.1:8080/
It can also be run as a daemon process with
$cherryd -c <config file> -d -p <PID file>

==Extensions==

CherryPy provides a flexible open framework. Similar to [http://en.wikipedia.org/wiki/RubyGems RubyGems] in [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails] which add a range of functionality to the framework CherryPy also supports plugins in the the following forms

===Server Wide Functions (Plugins)===
This type of extension is typically used to provide the application server itself with additional functionality. Such functions are executed with respect to events in the server even when there is no client request processing taking place.<ref>http://docs.cherrypy.org/en/latest/extend.html#id13</ref> 
Typical use case involve
*Background Tasks (Tasks which involve server mentainance, data management etc. which are independent of user requests)
*External Connections (For establishing and maintaining threaded connections to external database or other servers)
*Delayed/Queued Processing (Cases when certain tasks are required by the user request which take a long time process and the HTTP response should not be blocked.) 
These function utilize the [http://en.wikipedia.org/wiki/Publish–subscribe_pattern Publish-Subscribe Framework] implementation of CherryPy. Each function subscribes to one or more events on the bus which are published by the CherryPy engine. The database connection is a good example of such a function 

<pre>
# import the Handles
import MySQLdb
import cherrypy
# defining the connection function
def connect(thread_index):
# Create a connection and store it in the current thread
cherrypy.thread_data.db = MySQLdb.connect('host', 'user', 'password', 'dbname')

# tell cherrypy to call connect function for each thread
cherrypy.engine.subscribe('start_thread', connect)
</pre>

Here the function connect subscribes to the <code>start_thread</code> channel. An event is published on the <code>start_thread</code> channel whenever a server thread is started. Here <code>engine</code> is the central bus of the CherryPy server. 
Similarly it is also possible to create new channels and even buses themselves.

===Per-Request Functions (Tools)===
This type of extension is typically used to insert functionality between stages of request processing. Also known as [http://docs.cherrypy.org/en/latest/extend.html#tools Tools] these are simple call-back functions registered with a [http://docs.cherrypy.org/en/latest/extend.html#hookpoint Hook Point]. Hook Points are predefined stages of request processing. CherryPy provides a [http://tools.cherrypy.org/ Default ToolBox] containing many tools. Users have the freedom to create their own tools and add them to the default toolbox or create a new one.<ref>http://docs.cherrypy.org/en/latest/extend.html#per-request-functions</ref> 
An example for creating a tool

<pre>
# defining the function to be called
def my_tool():
# put tool functunality here
print (“Super Amazing Tool”);

# creating the decorator for the tool
# specifying the hook point and function to be called
cherrypy.tools.mytool = cherrypy.Tool(‘on_end_request’, my_tool())

#Sample Usage

class Root(object):
@cherrypy.expose()
@cherrypy.tools.mytool()
def index()
return “Hello World”
</pre>

==Watch It In Action==

CherryPy is used as a building block for [http://www.hulu.com/ Hulu]<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu</ref> and [https://www.netflix.com/ Netflix]<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>

==Additional Instructions==

===Install via yum===
CherryPy is provided by the fedora base repository. In [http://en.wikipedia.org/wiki/Fedora_%28operating_system%29 Fedora] (and other [http://en.wikipedia.org/wiki/RPM_Package_Manager RPM] based Linux distributions, such as [http://en.wikipedia.org/wiki/CentOS CentOS] and [http://en.wikipedia.org/wiki/Red_Hat_Enterprise_Linux Red Hat Enterprise Linux]): 
$ yum install python-cherrypy

===Install via apt-get===
CherryPy is also provided in the [http://en.wikipedia.org/wiki/Ubuntu_(operating_system) Ubuntu] base repository. In Ubuntu (and other [http://en.wikipedia.org/wiki/Debian Debian]-based Linux distributions such as Debian and [http://en.wikipedia.org/wiki/Linux_Mint Linux Mint]):
$ apt-get install python python-dev

===Installation from source===
The source code is hosted on [http://en.wikipedia.org/wiki/Bitbucket BitBucket] and requires [http://en.wikipedia.org/wiki/Mercurial Mercurial] to pull and install from the site itself.
$ hg clone https://bitbucket.org/cherrypy/cherrypy
$ cd cherrypy
$ python setup.py install

Alternatively, the source can be manually downloaded from [https://bitbucket.org/cherrypy/cherrypy/downloads here] in a tarball.
$ tar -xvf CherryPy-#.#.#.tar.gz
$ cd CherryPy-#.#.#
$ python setup.py install

===Install for Windows===
*If you are using Windows, install Linux and follow any of the a forementioned methods.
*If you absolutely must use windows, you can download the .exe file to install CherryPy from [https://bitbucket.org/cherrypy/cherrypy/downloads here].

==References==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 cp

2014-09-24T20:44:24Z

Cehaith2: /* Multiple Applications */

='''CherryPy'''=

__TOC__

==Overview==
[http://www.cherrypy.org/ CherryPy] is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented] [http://en.wikipedia.org/wiki/Web_application_framework Web Application Framework] meant to be [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]-like (sparse and clean code). 
It is important to note that it is not a complete stack such as [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails], [http://en.wikipedia.org/wiki/Laravel Laravel], or [http://en.wikipedia.org/wiki/Django Django]. Complete stack web frameworks offer frontend utilities and storage communications along with other abilities. These aspects that make the frameworks so powerful, however, also contribute to the framework being bulky making development of small web applications such as blogs a bit cumbersome. CherryPy instead prefers to defer decisions such as storage management and interface utilities to the developer <ref>http://docs.cherrypy.org/en/latest/intro.html</ref>

==Installation==

===Overview===
Because CherryPy is nothing more than a Python library, it needs a Python environment (Python 2.3 through to 3.4) and can also run on various implementations of Python including [http://en.wikipedia.org/wiki/IronPython IronPython] for [http://en.wikipedia.org/wiki/.NET_Framework .NET] and [http://en.wikipedia.org/wiki/Jython Jython] for [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java].<ref>http://docs.cherrypy.org/en/latest/install.html</ref>

===Requirements===
CherryPy requires a Python version between 2.3 and 3.4 inclusively. Certain features require packages but none are mandatory for installation.<ref>http://docs.cherrypy.org/en/latest/install.html</ref>
*[http://routes.readthedocs.org/en/latest/ routes] for declarative URL mapping dispatcher
*[http://pythonhosted.org//psycopg2/ psycopg2] for [http://en.wikipedia.org/wiki/PostgreSQL PostgreSQL] database backend session
*[http://sourceforge.net/projects/pywin32/ pywin32] for Windows services
*[https://github.com/linsomniac/python-memcached python-memcached] for [http://en.wikipedia.org/wiki/Memcached Memcached] backend session
*[https://github.com/simplejson/simplejson simplejson] for a better [http://en.wikipedia.org/wiki/JSON JSON] support
*[https://github.com/pyca/pyopenssl pyOpenSSL] if your Python environment does not have the built in [http://en.wikipedia.org/wiki/Transport_Layer_Security ssl] module

===Installing===
CherryPy can be installed through common Python package managers with the following commands:<ref>http://docs.cherrypy.org/en/latest/install.html</ref> 

Install (choose on of the following commands appropriately):
$ easy_install cherrypy
$ pip install cherrypy
$ yum install python-cherrypy
$ apt-get install python python-dev

Refer [[#Additional Installation Instructions| Additional Instructions]] for more details.

==Interface==

CherryPy is meant to be pythonic, meaning that development time is meant to be minimized and code is meant to be sparse and clean <ref>http://docs.cherrypy.org/en/latest/intro.html</ref>

===Basic Example===
Lets look at a hello world example<ref>https://cherrypy.readthedocs.org/en/3.2.6/concepts/basics.html</ref><ref>http://stackoverflow.com/questions/419163/what-does-if-name-main-do</ref>
<pre>
#Use the cherrypy python library
import cherrypy

#Hello World project
class HelloWorld(object):

# index page
def index(self):
# Return the page contents
return “Hello World!”

# Allow the page to be visible
index.exposed = True

#designates this module as main
if __name__ == ‘__main__’:

# instantiates app and starts server
cherrypy.quickstart(HelloWorld())

</pre>
The above script sets up a basic Hello World application, by defining the index page (http://localhost:8080/) as an object that returns the string “Hello World!”. The page is exposed, meaning that the method can be called to answer a [http://en.wikipedia.org/wiki/Representational_state_transfer RESTful] request. Otherwise, the method is internal only. This is similar to making a method public in Java. <ref>http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html</ref>

===Routing, Parameters, and Exposure===
Routing is the act of finding the appropriate code to handle a request. CherryPy uses a dispatcher to perform most of these, but premade dispatchers exist to handle more sophisticated handling of request. The most common is a page handler (the name of the object). Parameters can be passed into the handler via http query strings. These strings are appended to the URL of a site after a "?". Exposure is just the way CherryPy prevents access to objects from the users. Without the exposed attribute set to true, an object won't be accessible to the user.
<pre>
#import python library
import cherrypy

#More Routes application
class MoreRoutes(object):

# Method decorator for index and equates to index.exposed = True
@cherrypy.expose
def index(self):
return "Hello world!"

# http://localhost:8080/route1
def route1(self, id=”charles”):
# http://localhost:8080/route1?id=somestring
return “Your name is ” + id

# Params passed as a GET request.
# Default string is “charles”
route1.exposed = True

# No explicit indication of exposure so calling this route will generate a 404 error
def route2(self):
return “Still another one”

if __name__ == '__main__':
cherrypy.quickstart(MoreRoutes())

</pre>

The above shows how multiple routes are handled from the Hello World application and the expose decorator. Since route2 is not exposed, the user can not access it and will be shown a 404 HTTP status code (Not Found error).

===Multiple Applications===

<pre>
import cherrypy
#blog module
class Blog(object):
...<blog code>...
#forum module
class Forum(object):
...<forum code>...
#”main” method
if __name__ == '__main__':
#designates the blog to be under /blog route
cherrypy.tree.mount(Blog(), ‘/blog’, “blog.conf”)
#designates the forum to be under /forum route
cherrypy.tree.mount(Forum(), ‘/forum’, “forum.conf”)
</pre> <ref>http://docs.cherrypy.org/en/latest/basics.html#multiple-applications</ref>

In the above example, the blog would be found under /blog in the URL, wheras the forum will be mounted at /forum in the application tree. The XXX.conf files are configuration files, which are dictionaries containing string keys and polymorphic values and can be used to set attributes on the engine, server, request, response, and log objects. <ref>https://cherrypy.readthedocs.org/en/3.2.6/concepts/config.html</ref>

===Database Support===
CherryPy offers multiple database integration possibilities including
*[http://en.wikipedia.org/wiki/Relational_database Relational]: [http://en.wikipedia.org/wiki/PostgreSQL PostgreSQL], [http://en.wikipedia.org/wiki/SQLite SQLite], [http://en.wikipedia.org/wiki/MariaDB MariaDB], [http://en.wikipedia.org/wiki/Firebird_%28database_server%29 Firebird]
*[http://en.wikipedia.org/wiki/Column-oriented_DBMS Column-Oriented]: [http://en.wikipedia.org/wiki/Apache_HBase HBase], [http://en.wikipedia.org/wiki/Apache_Cassandra Cassandra]
*[http://en.wikipedia.org/wiki/NoSQL#Key.E2.80.93value_stores Key-Store]: [http://en.wikipedia.org/wiki/Redis Redis], [http://en.wikipedia.org/wiki/Memcached Memcached]
*[http://en.wikipedia.org/wiki/Document-oriented_database Document-Oriented]: [http://en.wikipedia.org/wiki/CouchDB Couchdb], [http://en.wikipedia.org/wiki/MongoDB MongoDB]
*[http://en.wikipedia.org/wiki/Graph_database Graph-Oriented]: [http://en.wikipedia.org/wiki/Neo4j Neo4j] 
Unfortunately, unlike [https://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails], CherryPy does not have a sophisticated [https://en.wikipedia.org/wiki/Active_record_pattern#Ruby Active Record Pattern] based class for database abstraction, and the database connection has to be established manually. The queries are constructed as static [https://en.wikipedia.org/wiki/SQL SQL] strings with values concatenated during function calls. 

Here is an example of how it would look like<ref>http://cherrypy.readthedocs.org/en/latest/tutorials.html#tutorial-9-data-is-all-my-life</ref>
<pre>

# import the Handles
import MySQLdb
import cherrypy

# defining the connection function
def connect(thread_index):
# Create a connection and store it in the current thread
cherrypy.thread_data.db = MySQLdb.connect('host', 'user', 'password', 'dbname')

# tell cherrypy to call connect function for each thread
cherrypy.engine.subscribe('start_thread', connect)

# example query function
@cherrypy.expose
def count(val)
# fetching instance of db connection
c = cherrypy.thread_data.db.cursor()
# executing query
c.execute( 'select count(‘ + val + ’) from table' )
# fetching results from db
res = c.fetchone()
# releasing instance of the connection
c.close()
# returning the count value
return res

</pre>

==RESTful CherryPy==
[http://en.wikipedia.org/wiki/Representational_state_transfer REST] (Representational State Transfer) is an abstraction of the architectural elements within a distributed hypermedia system. It ignores the details of component implementation and protocol syntax in order to focus on the roles of components, the constraints upon their interaction with other components, and their interpretation of significant data elements. It encompasses the fundamental constraints upon components, connectors, and data that define the basis of the Web architecture, and thus the essence of its behavior as a network-based application. <ref>http://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm</ref> 
In othe words, REST is defined by four interface constraints: identification of resources, manipulation of resources through representations, self-descriptive messages, and hypermedia as the engine of application state.<ref>https://cherrypy.readthedocs.org/en/3.2.6/progguide/REST.html</ref>

===Identification of Resources===
Since Cherrypy is an HTTP service provider, resources are referenced by HTTP URIs (Uniform Resource Identifiers), which consist of a scheme, hierarchical identitfier, query, and fragment.<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#implementing-rest-in-cherrypy</ref> 
*Scheme: in [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol http], the scheme is always http or [http://en.wikipedia.org/wiki/HTTP_Secure https].
*Hierarchical Identifier: consists of an authority and a path (host/port and a path similar to the system file path but not the actual path). The path is mapped to Python Objects via a dispatch mechanism.

===Manipulation of Resources Through Representations===
The standard [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html HTTP methods] are as follows<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#manipulation-of-resources-through-representations</ref>
*<code>GET</code> retrieves the state of a specific resource
*<code>PUT</code> creates or replaces the state of a specific resource
*<code>POST</code> passes information to a resource to use as it sees fit
*<code>DELETE</code> removes resources

===Self-Descriptive Messages===
REST requires messages to be self-descriptive, meaning everything about a message is within the message itself. Such information can be found in the method headers or the definitions of the message’s media type. cherrypy.request.headers and cherrypy.response.headers are used to get this information. Custom-Types are allowed as well.<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#self-descriptive-messages</ref>

===Hypermedia as the Engine of the Application State===
Since REST is stateless and the state is maintained by the application in question, sessions are not maintained by REST, so, by association, CherryPy does not enable sessions by default. However, the REST server helps clients maintain a meaningful state through meaningful URIs<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#hypermedia-as-the-engine-of-application-state</ref>

==Crash Course==

===Development===
Create an application. Application requirements:
*The module needs to define a <code>__main__ </code>
*<code>cherrypy.quickstart(<Application Name>())</code> for hosting a single application. For example: cherrypy.quickstart(Blog())
*<code>cherrypy.tree.mount(<Application Name>(), ‘/<hosting path segment>’, <configuration>)</code> for hosting multiple applications. For example: <code>cherrypy.tree.mount(Blog(), ‘/blog’, blog_conf) </code>
*All parts the users will see must be exposed with either the decorator <code>@cherrypy.expose or attribues exposed = True</code> or <code>route.exposed = True.</code>

<pre>
import cherrypy
class HelloWorld(object):
def index(self):
return “Hello World!”
index.exposed = True
if __name__ == ‘__main__’:
cherrypy.quickstart(HelloWorld())
</pre>

===Deployment===
The application can be run as a python script in the Python interpreter.
$ python <app file>.py
It will hosted at http://127.0.0.1:8080/
It can also be run as a daemon process with
$cherryd -c <config file> -d -p <PID file>

==Extensions==

CherryPy provides a flexible open framework. Similar to [http://en.wikipedia.org/wiki/RubyGems RubyGems] in [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails] which add a range of functionality to the framework CherryPy also supports plugins in the the following forms

===Server Wide Functions (Plugins)===
This type of extension is typically used to provide the application server itself with additional functionality. Such functions are executed with respect to events in the server even when there is no client request processing taking place.<ref>http://docs.cherrypy.org/en/latest/extend.html#id13</ref> 
Typical use case involve
*Background Tasks (Tasks which involve server mentainance, data management etc. which are independent of user requests)
*External Connections (For establishing and maintaining threaded connections to external database or other servers)
*Delayed/Queued Processing (Cases when certain tasks are required by the user request which take a long time process and the HTTP response should not be blocked.) 
These function utilize the [http://en.wikipedia.org/wiki/Publish–subscribe_pattern Publish-Subscribe Framework] implementation of CherryPy. Each function subscribes to one or more events on the bus which are published by the CherryPy engine. The database connection is a good example of such a function 

<pre>
# import the Handles
import MySQLdb
import cherrypy
# defining the connection function
def connect(thread_index):
# Create a connection and store it in the current thread
cherrypy.thread_data.db = MySQLdb.connect('host', 'user', 'password', 'dbname')

# tell cherrypy to call connect function for each thread
cherrypy.engine.subscribe('start_thread', connect)
</pre>

Here the function connect subscribes to the <code>start_thread</code> channel. An event is published on the <code>start_thread</code> channel whenever a server thread is started. Here <code>engine</code> is the central bus of the CherryPy server. 
Similarly it is also possible to create new channels and even buses themselves.

===Per-Request Functions (Tools)===
This type of extension is typically used to insert functionality between stages of request processing. Also known as [http://docs.cherrypy.org/en/latest/extend.html#tools Tools] these are simple call-back functions registered with a [http://docs.cherrypy.org/en/latest/extend.html#hookpoint Hook Point]. Hook Points are predefined stages of request processing. CherryPy provides a [http://tools.cherrypy.org/ Default ToolBox] containing many tools. Users have the freedom to create their own tools and add them to the default toolbox or create a new one.<ref>http://docs.cherrypy.org/en/latest/extend.html#per-request-functions</ref> 
An example for creating a tool

<pre>
# defining the function to be called
def my_tool():
# put tool functunality here
print (“Super Amazing Tool”);

# creating the decorator for the tool
# specifying the hook point and function to be called
cherrypy.tools.mytool = cherrypy.Tool(‘on_end_request’, my_tool())

#Sample Usage

class Root(object):
@cherrypy.expose()
@cherrypy.tools.mytool()
def index()
return “Hello World”
</pre>

==Watch It In Action==

CherryPy is used as a building block for [http://www.hulu.com/ Hulu]<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu</ref> and [https://www.netflix.com/ Netflix]<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>

==Additional Instructions==

===Install via yum===
CherryPy is provided by the fedora base repository. In [http://en.wikipedia.org/wiki/Fedora_%28operating_system%29 Fedora] (and other [http://en.wikipedia.org/wiki/RPM_Package_Manager RPM] based Linux distributions, such as [http://en.wikipedia.org/wiki/CentOS CentOS] and [http://en.wikipedia.org/wiki/Red_Hat_Enterprise_Linux Red Hat Enterprise Linux]): 
$ yum install python-cherrypy

===Install via apt-get===
CherryPy is also provided in the [http://en.wikipedia.org/wiki/Ubuntu_(operating_system) Ubuntu] base repository. In Ubuntu (and other [http://en.wikipedia.org/wiki/Debian Debian]-based Linux distributions such as Debian and [http://en.wikipedia.org/wiki/Linux_Mint Linux Mint]):
$ apt-get install python python-dev

===Installation from source===
The source code is hosted on [http://en.wikipedia.org/wiki/Bitbucket BitBucket] and requires [http://en.wikipedia.org/wiki/Mercurial Mercurial] to pull and install from the site itself.
$ hg clone https://bitbucket.org/cherrypy/cherrypy
$ cd cherrypy
$ python setup.py install

Alternatively, the source can be manually downloaded from [https://bitbucket.org/cherrypy/cherrypy/downloads here] in a tarball.
$ tar -xvf CherryPy-#.#.#.tar.gz
$ cd CherryPy-#.#.#
$ python setup.py install

===Install for Windows===
*If you are using Windows, install Linux and follow any of the a forementioned methods.
*If you absolutely must use windows, you can download the .exe file to install CherryPy from [https://bitbucket.org/cherrypy/cherrypy/downloads here].

==References==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 cp

2014-09-24T20:20:21Z

Cehaith2: /* CherryPy */

='''CherryPy'''=

__TOC__

==Overview==
[http://www.cherrypy.org/ CherryPy] is an [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented] [http://en.wikipedia.org/wiki/Web_application_framework Web Application Framework] meant to be [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]-like (sparse and clean code). 
It is important to note that it is not a complete stack such as [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails], [http://en.wikipedia.org/wiki/Laravel Laravel], or [http://en.wikipedia.org/wiki/Django Django]. Complete stack web frameworks offer frontend utilities and storage communications along with other abilities. These aspects that make the frameworks so powerful, however, also contribute to the framework being bulky making development of small web applications such as blogs a bit cumbersome. CherryPy instead prefers to defer decisions such as storage management and interface utilities to the developer <ref>http://docs.cherrypy.org/en/latest/intro.html</ref>

==Installation==

===Overview===
Because CherryPy is nothing more than a Python library, it needs a Python environment (Python 2.3 through to 3.4) and can also run on various implementations of Python including [http://en.wikipedia.org/wiki/IronPython IronPython] for [http://en.wikipedia.org/wiki/.NET_Framework .NET] and [http://en.wikipedia.org/wiki/Jython Jython] for [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java].<ref>http://docs.cherrypy.org/en/latest/install.html</ref>

===Requirements===
CherryPy requires a Python version between 2.3 and 3.4 inclusively. Certain features require packages but none are mandatory for installation.<ref>http://docs.cherrypy.org/en/latest/install.html</ref>
*[http://routes.readthedocs.org/en/latest/ routes] for declarative URL mapping dispatcher
*[http://pythonhosted.org//psycopg2/ psycopg2] for [http://en.wikipedia.org/wiki/PostgreSQL PostgreSQL] database backend session
*[http://sourceforge.net/projects/pywin32/ pywin32] for Windows services
*[https://github.com/linsomniac/python-memcached python-memcached] for [http://en.wikipedia.org/wiki/Memcached Memcached] backend session
*[https://github.com/simplejson/simplejson simplejson] for a better [http://en.wikipedia.org/wiki/JSON JSON] support
*[https://github.com/pyca/pyopenssl pyOpenSSL] if your Python environment does not have the built in [http://en.wikipedia.org/wiki/Transport_Layer_Security ssl] module

===Installing===
CherryPy can be installed through common Python package managers with the following commands:<ref>http://docs.cherrypy.org/en/latest/install.html</ref> 

Install (choose on of the following commands appropriately):
$ easy_install cherrypy
$ pip install cherrypy
$ yum install python-cherrypy
$ apt-get install python python-dev

Refer [[#Additional Installation Instructions| Additional Instructions]] for more details.

==Interface==

CherryPy is meant to be pythonic, meaning that development time is meant to be minimized and code is meant to be sparse and clean <ref>http://docs.cherrypy.org/en/latest/intro.html</ref>

===Basic Example===
Lets look at a hello world example<ref>https://cherrypy.readthedocs.org/en/3.2.6/concepts/basics.html</ref><ref>http://stackoverflow.com/questions/419163/what-does-if-name-main-do</ref>
<pre>
#Use the cherrypy python library
import cherrypy

#Hello World project
class HelloWorld(object):

# index page
def index(self):
# Return the page contents
return “Hello World!”

# Allow the page to be visible
index.exposed = True

#designates this module as main
if __name__ == ‘__main__’:

# instantiates app and starts server
cherrypy.quickstart(HelloWorld())

</pre>
The above script sets up a basic Hello World application, by defining the index page (http://localhost:8080/) as an object that returns the string “Hello World!”. The page is exposed, meaning that the method can be called to answer a [http://en.wikipedia.org/wiki/Representational_state_transfer RESTful] request. Otherwise, the method is internal only. This is similar to making a method public in Java. <ref>http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html</ref>

===Routing, Parameters, and Exposure===
Routing is the act of finding the appropriate code to handle a request. CherryPy uses a dispatcher to perform most of these, but premade dispatchers exist to handle more sophisticated handling of request. The most common is a page handler (the name of the object). Parameters can be passed into the handler via http query strings. These strings are appended to the URL of a site after a "?". Exposure is just the way CherryPy prevents access to objects from the users. Without the exposed attribute set to true, an object won't be accessible to the user.
<pre>
#import python library
import cherrypy

#More Routes application
class MoreRoutes(object):

# Method decorator for index and equates to index.exposed = True
@cherrypy.expose
def index(self):
return "Hello world!"

# http://localhost:8080/route1
def route1(self, id=”charles”):
# http://localhost:8080/route1?id=somestring
return “Your name is ” + id

# Params passed as a GET request.
# Default string is “charles”
route1.exposed = True

# No explicit indication of exposure so calling this route will generate a 404 error
def route2(self):
return “Still another one”

if __name__ == '__main__':
cherrypy.quickstart(MoreRoutes())

</pre>

The above shows how multiple routes are handled from the Hello World application and the expose decorator. Since route2 is not exposed, the user can not access it and will be shown a 404 HTTP status code (Not Found error).

===Multiple Applications===

<pre>
import cherrypy
#blog module
class Blog(object):
...<blog code>...
#forum module
class Forum(object):
...<forum code>...
#”main” method
if __name__ == '__main__':
#designates the blog to be under /blog route
cherrypy.tree.mount(Blog(), ‘/blog’, “blog.conf”)
#designates the forum to be under /forum route
cherrypy.tree.mount(Forum(), ‘/forum’, “forum.conf”)
</pre>

<ref>http://docs.cherrypy.org/en/latest/basics.html#multiple-applications</ref>

===Database Support===
CherryPy offers multiple database integration possibilities including
*[http://en.wikipedia.org/wiki/Relational_database Relational]: [http://en.wikipedia.org/wiki/PostgreSQL PostgreSQL], [http://en.wikipedia.org/wiki/SQLite SQLite], [http://en.wikipedia.org/wiki/MariaDB MariaDB], [http://en.wikipedia.org/wiki/Firebird_%28database_server%29 Firebird]
*[http://en.wikipedia.org/wiki/Column-oriented_DBMS Column-Oriented]: [http://en.wikipedia.org/wiki/Apache_HBase HBase], [http://en.wikipedia.org/wiki/Apache_Cassandra Cassandra]
*[http://en.wikipedia.org/wiki/NoSQL#Key.E2.80.93value_stores Key-Store]: [http://en.wikipedia.org/wiki/Redis Redis], [http://en.wikipedia.org/wiki/Memcached Memcached]
*[http://en.wikipedia.org/wiki/Document-oriented_database Document-Oriented]: [http://en.wikipedia.org/wiki/CouchDB Couchdb], [http://en.wikipedia.org/wiki/MongoDB MongoDB]
*[http://en.wikipedia.org/wiki/Graph_database Graph-Oriented]: [http://en.wikipedia.org/wiki/Neo4j Neo4j] 
Unfortunately, unlike [https://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails], CherryPy does not have a sophisticated [https://en.wikipedia.org/wiki/Active_record_pattern#Ruby Active Record Pattern] based class for database abstraction, and the database connection has to be established manually. The queries are constructed as static [https://en.wikipedia.org/wiki/SQL SQL] strings with values concatenated during function calls. 

Here is an example of how it would look like<ref>http://cherrypy.readthedocs.org/en/latest/tutorials.html#tutorial-9-data-is-all-my-life</ref>
<pre>

# import the Handles
import MySQLdb
import cherrypy

# defining the connection function
def connect(thread_index):
# Create a connection and store it in the current thread
cherrypy.thread_data.db = MySQLdb.connect('host', 'user', 'password', 'dbname')

# tell cherrypy to call connect function for each thread
cherrypy.engine.subscribe('start_thread', connect)

# example query function
@cherrypy.expose
def count(val)
# fetching instance of db connection
c = cherrypy.thread_data.db.cursor()
# executing query
c.execute( 'select count(‘ + val + ’) from table' )
# fetching results from db
res = c.fetchone()
# releasing instance of the connection
c.close()
# returning the count value
return res

</pre>

==RESTful CherryPy==
[http://en.wikipedia.org/wiki/Representational_state_transfer REST] (Representational State Transfer) is an abstraction of the architectural elements within a distributed hypermedia system. It ignores the details of component implementation and protocol syntax in order to focus on the roles of components, the constraints upon their interaction with other components, and their interpretation of significant data elements. It encompasses the fundamental constraints upon components, connectors, and data that define the basis of the Web architecture, and thus the essence of its behavior as a network-based application. <ref>http://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm</ref> 
In othe words, REST is defined by four interface constraints: identification of resources, manipulation of resources through representations, self-descriptive messages, and hypermedia as the engine of application state.<ref>https://cherrypy.readthedocs.org/en/3.2.6/progguide/REST.html</ref>

===Identification of Resources===
Since Cherrypy is an HTTP service provider, resources are referenced by HTTP URIs (Uniform Resource Identifiers), which consist of a scheme, hierarchical identitfier, query, and fragment.<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#implementing-rest-in-cherrypy</ref> 
*Scheme: in [http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol http], the scheme is always http or [http://en.wikipedia.org/wiki/HTTP_Secure https].
*Hierarchical Identifier: consists of an authority and a path (host/port and a path similar to the system file path but not the actual path). The path is mapped to Python Objects via a dispatch mechanism.

===Manipulation of Resources Through Representations===
The standard [http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html HTTP methods] are as follows<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#manipulation-of-resources-through-representations</ref>
*<code>GET</code> retrieves the state of a specific resource
*<code>PUT</code> creates or replaces the state of a specific resource
*<code>POST</code> passes information to a resource to use as it sees fit
*<code>DELETE</code> removes resources

===Self-Descriptive Messages===
REST requires messages to be self-descriptive, meaning everything about a message is within the message itself. Such information can be found in the method headers or the definitions of the message’s media type. cherrypy.request.headers and cherrypy.response.headers are used to get this information. Custom-Types are allowed as well.<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#self-descriptive-messages</ref>

===Hypermedia as the Engine of the Application State===
Since REST is stateless and the state is maintained by the application in question, sessions are not maintained by REST, so, by association, CherryPy does not enable sessions by default. However, the REST server helps clients maintain a meaningful state through meaningful URIs<ref>https://cherrypy.readthedocs.org/en/3.3.0/progguide/REST.html#hypermedia-as-the-engine-of-application-state</ref>

==Crash Course==

===Development===
Create an application. Application requirements:
*The module needs to define a <code>__main__ </code>
*<code>cherrypy.quickstart(<Application Name>())</code> for hosting a single application. For example: cherrypy.quickstart(Blog())
*<code>cherrypy.tree.mount(<Application Name>(), ‘/<hosting path segment>’, <configuration>)</code> for hosting multiple applications. For example: <code>cherrypy.tree.mount(Blog(), ‘/blog’, blog_conf) </code>
*All parts the users will see must be exposed with either the decorator <code>@cherrypy.expose or attribues exposed = True</code> or <code>route.exposed = True.</code>

<pre>
import cherrypy
class HelloWorld(object):
def index(self):
return “Hello World!”
index.exposed = True
if __name__ == ‘__main__’:
cherrypy.quickstart(HelloWorld())
</pre>

===Deployment===
The application can be run as a python script in the Python interpreter.
$ python <app file>.py
It will hosted at http://127.0.0.1:8080/
It can also be run as a daemon process with
$cherryd -c <config file> -d -p <PID file>

==Extensions==

CherryPy provides a flexible open framework. Similar to [http://en.wikipedia.org/wiki/RubyGems RubyGems] in [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby on Rails] which add a range of functionality to the framework CherryPy also supports plugins in the the following forms

===Server Wide Functions (Plugins)===
This type of extension is typically used to provide the application server itself with additional functionality. Such functions are executed with respect to events in the server even when there is no client request processing taking place.<ref>http://docs.cherrypy.org/en/latest/extend.html#id13</ref> 
Typical use case involve
*Background Tasks (Tasks which involve server mentainance, data management etc. which are independent of user requests)
*External Connections (For establishing and maintaining threaded connections to external database or other servers)
*Delayed/Queued Processing (Cases when certain tasks are required by the user request which take a long time process and the HTTP response should not be blocked.) 
These function utilize the [http://en.wikipedia.org/wiki/Publish–subscribe_pattern Publish-Subscribe Framework] implementation of CherryPy. Each function subscribes to one or more events on the bus which are published by the CherryPy engine. The database connection is a good example of such a function 

<pre>
# import the Handles
import MySQLdb
import cherrypy
# defining the connection function
def connect(thread_index):
# Create a connection and store it in the current thread
cherrypy.thread_data.db = MySQLdb.connect('host', 'user', 'password', 'dbname')

# tell cherrypy to call connect function for each thread
cherrypy.engine.subscribe('start_thread', connect)
</pre>

Here the function connect subscribes to the <code>start_thread</code> channel. An event is published on the <code>start_thread</code> channel whenever a server thread is started. Here <code>engine</code> is the central bus of the CherryPy server. 
Similarly it is also possible to create new channels and even buses themselves.

===Per-Request Functions (Tools)===
This type of extension is typically used to insert functionality between stages of request processing. Also known as [http://docs.cherrypy.org/en/latest/extend.html#tools Tools] these are simple call-back functions registered with a [http://docs.cherrypy.org/en/latest/extend.html#hookpoint Hook Point]. Hook Points are predefined stages of request processing. CherryPy provides a [http://tools.cherrypy.org/ Default ToolBox] containing many tools. Users have the freedom to create their own tools and add them to the default toolbox or create a new one.<ref>http://docs.cherrypy.org/en/latest/extend.html#per-request-functions</ref> 
An example for creating a tool

<pre>
# defining the function to be called
def my_tool():
# put tool functunality here
print (“Super Amazing Tool”);

# creating the decorator for the tool
# specifying the hook point and function to be called
cherrypy.tools.mytool = cherrypy.Tool(‘on_end_request’, my_tool())

#Sample Usage

class Root(object):
@cherrypy.expose()
@cherrypy.tools.mytool()
def index()
return “Hello World”
</pre>

==Watch It In Action==

CherryPy is used as a building block for [http://www.hulu.com/ Hulu]<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu</ref> and [https://www.netflix.com/ Netflix]<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>

==Additional Instructions==

===Install via yum===
CherryPy is provided by the fedora base repository. In [http://en.wikipedia.org/wiki/Fedora_%28operating_system%29 Fedora] (and other [http://en.wikipedia.org/wiki/RPM_Package_Manager RPM] based Linux distributions, such as [http://en.wikipedia.org/wiki/CentOS CentOS] and [http://en.wikipedia.org/wiki/Red_Hat_Enterprise_Linux Red Hat Enterprise Linux]): 
$ yum install python-cherrypy

===Install via apt-get===
CherryPy is also provided in the [http://en.wikipedia.org/wiki/Ubuntu_(operating_system) Ubuntu] base repository. In Ubuntu (and other [http://en.wikipedia.org/wiki/Debian Debian]-based Linux distributions such as Debian and [http://en.wikipedia.org/wiki/Linux_Mint Linux Mint]):
$ apt-get install python python-dev

===Installation from source===
The source code is hosted on [http://en.wikipedia.org/wiki/Bitbucket BitBucket] and requires [http://en.wikipedia.org/wiki/Mercurial Mercurial] to pull and install from the site itself.
$ hg clone https://bitbucket.org/cherrypy/cherrypy
$ cd cherrypy
$ python setup.py install

Alternatively, the source can be manually downloaded from [https://bitbucket.org/cherrypy/cherrypy/downloads here] in a tarball.
$ tar -xvf CherryPy-#.#.#.tar.gz
$ cd CherryPy-#.#.#
$ python setup.py install

===Install for Windows===
*If you are using Windows, install Linux and follow any of the a forementioned methods.
*If you absolutely must use windows, you can download the .exe file to install CherryPy from [https://bitbucket.org/cherrypy/cherrypy/downloads here].

==References==
<references/>