Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2014/oss E1459 jjr

2014-10-30T01:56:29Z

Jmkubasc: /* External Links */

= E1459 - Refactoring the signup_controller =

__TOC__

== Introduction ==

[http://expertiza.ncsu.edu/ Expertiza] is a web based application used by students and professors to create, select, submit and review assignments. Selection of assignments may be individual assignments or group assignments. The assignment is configured by the professor. Peer reviews can be conducted by fellow students in the class. Additionally the professor can review the assignments submitted by the students. Assignments are what Expertiza calls learning objects. Learning objects consist of such things as articles, websites or web applications, or code.

The Expertiza project is open source with many programmers contributing to the code base. The source code is available at [https://github.com/expertiza/expertiza github]. Due to the open source nature of this application the code is not always as clear, concise and as standardized as it could be. This project seeks to resolve some of these issues by applying sound object oriented design principles along with standard RESTful naming conventions where possible.

== Scope ==

This project is focused on the signup_controller and its fringe classes. The role of the signup_controller is to process requests from the user to sign up for an assignment. The purpose of the controller is to process actions from the user; however, in many cases the controller is doing functions that should be provided by the model. Any calculations should appear in the model rather than the controller. The code should use RESTful names such as new, create, edit, and delete. In many cases it does not. Methods should be no more than 30-40 lines long. Any longer and the reader needs to rely on their working memory to remember what code that is outside of their view does which is an inefficient and error prone way to read code. Other classes that are involved in this process include the sign_up_sheet_controller a number of views that pertain to assignments, topics and fixtures and functional tests and model classes such as sign_up_sheet.rb and sign_up_topic.rb. The sign_up_sheet_controller handles actions pertaining to creating assignments.

== Formatting Changes ==

On the first round of refinement the code was simply cleaned up by untabifying the code and using the Rails and Expertiza coding standard of using two spaces for indentation. Untabifying the code eliminates variations in tab stop configuration in programmers editors. This makes the code more readable to those who view the source code so that blocks don’t look like run together.

== Rails Naming Conventions ==

Some methods were renamed to ones that more closely align with Rails naming conventions. In the app/controllers/sign_up_sheet_controller.rb the index and add_signup_topics actions were changed to index_signup and index actions respectively. These two actions did similar functions and were made clearer by merging them.

{first image here}

The design of the SignUpSheetController class controls two different behaviors of the SignUpTopics model: creation of topics for an assignment by the instructor, and allowing students to sign up for a topic. To clearly distinguish between these two different behaviors, all actions performed by the instructor to manage a topic (index/create/update/destroy) were renamed to follow the standard Rails naming convention. All actions performed by the student (index/create/destroy) to sign up for a topic have the suffix _signup.

The issue with these methods were that they didn’t follow Rails naming conventions for displaying a list of items and they were not representative of the the functions that they performed. The add_signup_topics method displayed a list of topics for the teacher to modify the topics. The index method although following Rails convention in naming the function name did describe its purpose with respect to the scope of the controller in which it lives. The index method originally listed the topics for the student to sign up from. This however is the sign up sheet controller and therefore the index method would have been expected to list topics and perform actions on them at a higher level. The teacher is concerned with the assignment as a whole. That is the teacher is concerned with listing and acting on a large number if not all of the topics on the assignment and better aligns with the name of the controller (signup_sheet_controller). Therefore the add_signup_topics method was renamed to index and the original index method was renamed to index_signup. The latter was renamed using the index convention but with the _signup suffix. The original index method displayed the list of topics that the user could sign up for. In this case the student is interested in acting only one one topic therefore the signup suffix reflects intent.

In the following example from the sign_up_sheet_controller.rb file, the original programmers did not employ the DRY principle to their code.

== Moving logic code to the Model ==

In the Model View Controller (MVC) paradigm code pertaining to the business logic of an application belongs in the model layer of the program. This paradigm was broken in several places in sign_up_sheet_controller.rb file. For instance, the confirm_topic method is used in the sign_up_sheet_controller.rb file to assign a topic to a user after performing several model layer checks to make sure that the user can, in fact, be assigned a topic. This code is better moved to the model layer as its performing business logic and not simple validation or control statements. The decision was made to move this method into the SignUpTopic model.

== General Cleanup and Deletion ==
There were also several “utility” methods that we believe were added to the controller at some earlier point and are now obfuscated due to the efforts of previous groups of students to improve the code. For instance, the otherConfirmedTopicforUser(assignment_id, creator_id) and slotAvailable?(topic_id) methods did nothing other than call a method in the model and return the result, this sort of complexity is unnecessary. We removed these methods from the controller as they achieved nothing and did not make the code any easier to read.

{image 2 here}

== File change list ==

The following is a complete list of files that were changed.
<ul>
<li>M Gemfile.lock</li>
<li>M app/controllers/sign_up_sheet_controller.rb</li>
<li>M app/controllers/signup_controller.rb</li>
<li>M app/models/sign_up_sheet.rb</li>
<li>M app/models/sign_up_topic.rb</li>
<li>M app/models/signed_up_user.rb</li>
<li>M app/models/system_settings.rb</li>
<li>M app/models/team.rb</li>
<li>M app/views/assignments/_reserve_topic.html.erb</li>
<li>M app/views/assignments/edit/_rubrics.html.erb</li>
<li>M app/views/bookmarks/add_tag_bookmark.erb</li>
<li>M app/views/bookmarks/view_topic_bookmarks.rhtml</li>
<li>D app/views/sign_up_sheet/_add_signup_topcis.html.erb</li>
<li>D app/views/sign_up_sheet/_add_signup_topics.html.erb</li>
<li>A app/views/sign_up_sheet/_index.html.erb</li>
<li>A app/views/sign_up_sheet/_index_staggered.html.erb</li>
<li>M app/views/sign_up_sheet/_reserve_topic.html.erb</li>
<li>D app/views/sign_up_sheet/add_signup_topics.html.erb</li>
<li>D app/views/sign_up_sheet/add_signup_topics_staggered.html.erb</li>
<li>M app/views/sign_up_sheet/edit.html.erb</li>
<li>A app/views/sign_up_sheet/index.html.erb</li>
<li>A app/views/sign_up_sheet/index_signup.html.erb</li>
<li>D app/views/sign_up_sheet/list.html.erb</li>
<li>M app/views/sign_up_sheet/new.html.erb</li>
<li>M app/views/student_task/view.html.erb</li>
<li>M app/views/tree_display/actions/_assignments_actions.html.erb</li>
<li>M config/routes.rb</li>
<li>M db/migrate/053_create_nodes.rb</li>
<li>M db/schema.rb</li>
<li>M test/fixtures/assignments.yml</li>
<li>M test/fixtures/invitations.yml</li>
<li>M test/fixtures/participants.yml</li>
<li>M test/fixtures/question_types.yml</li>
<li>M test/fixtures/questionnaires.yml</li>
<li>M test/fixtures/questions.yml</li>
<li>M test/fixtures/response_maps.yml</li>
<li>M test/fixtures/responses.yml</li>
<li>M test/fixtures/roles.yml</li>
<li>M test/fixtures/scores.yml</li>
<li>M test/fixtures/sign_up_topics.yml</li>
<li>M test/fixtures/signed_up_users.yml</li>
<li>M test/fixtures/teams.yml</li>
<li>M test/fixtures/teams_users.yml</li>
<li>M test/fixtures/topic_deadlines.yml</li>
<li>M test/fixtures/users.yml</li>
<li>M test/functional/sign_up_sheet_controller_test.rb</li>
<li>M test/functional/signup_controller_test.rb</li>
</ul>

== References ==

<references/>

== Project Links ==
[https://github.com/jmkubasc/expertiza Forked GitHub Repository] 
[http://152.1.13.96:3000/ VCL Instance] May be invalid after a few weeks 
[https://docs.google.com/document/d/1iU1FyPgfn5LmILBxnmcBW7kOrv3zC_FYmhRgVuj9ct0/edit?usp=sharing README]

CSC/ECE 517 Fall 2014/oss E1459 jjr

2014-10-30T01:50:40Z

Jmkubasc: /* External Links */

= E1459 - Refactoring the signup_controller =

__TOC__

== Introduction ==

[http://expertiza.ncsu.edu/ Expertiza] is a web based application used by students and professors to create, select, submit and review assignments. Selection of assignments may be individual assignments or group assignments. The assignment is configured by the professor. Peer reviews can be conducted by fellow students in the class. Additionally the professor can review the assignments submitted by the students. Assignments are what Expertiza calls learning objects. Learning objects consist of such things as articles, websites or web applications, or code.

The Expertiza project is open source with many programmers contributing to the code base. The source code is available at [https://github.com/expertiza/expertiza github]. Due to the open source nature of this application the code is not always as clear, concise and as standardized as it could be. This project seeks to resolve some of these issues by applying sound object oriented design principles along with standard RESTful naming conventions where possible.

== Scope ==

This project is focused on the signup_controller and its fringe classes. The role of the signup_controller is to process requests from the user to sign up for an assignment. The purpose of the controller is to process actions from the user; however, in many cases the controller is doing functions that should be provided by the model. Any calculations should appear in the model rather than the controller. The code should use RESTful names such as new, create, edit, and delete. In many cases it does not. Methods should be no more than 30-40 lines long. Any longer and the reader needs to rely on their working memory to remember what code that is outside of their view does which is an inefficient and error prone way to read code. Other classes that are involved in this process include the sign_up_sheet_controller a number of views that pertain to assignments, topics and fixtures and functional tests and model classes such as sign_up_sheet.rb and sign_up_topic.rb. The sign_up_sheet_controller handles actions pertaining to creating assignments.

== Formatting Changes ==

On the first round of refinement the code was simply cleaned up by untabifying the code and using the Rails and Expertiza coding standard of using two spaces for indentation. Untabifying the code eliminates variations in tab stop configuration in programmers editors. This makes the code more readable to those who view the source code so that blocks don’t look like run together.

== Rails Naming Conventions ==

Some methods were renamed to ones that more closely align with Rails naming conventions. In the app/controllers/sign_up_sheet_controller.rb the index and add_signup_topics actions were changed to index_signup and index actions respectively. These two actions did similar functions and were made clearer by merging them.

{first image here}

The design of the SignUpSheetController class controls two different behaviors of the SignUpTopics model: creation of topics for an assignment by the instructor, and allowing students to sign up for a topic. To clearly distinguish between these two different behaviors, all actions performed by the instructor to manage a topic (index/create/update/destroy) were renamed to follow the standard Rails naming convention. All actions performed by the student (index/create/destroy) to sign up for a topic have the suffix _signup.

The issue with these methods were that they didn’t follow Rails naming conventions for displaying a list of items and they were not representative of the the functions that they performed. The add_signup_topics method displayed a list of topics for the teacher to modify the topics. The index method although following Rails convention in naming the function name did describe its purpose with respect to the scope of the controller in which it lives. The index method originally listed the topics for the student to sign up from. This however is the sign up sheet controller and therefore the index method would have been expected to list topics and perform actions on them at a higher level. The teacher is concerned with the assignment as a whole. That is the teacher is concerned with listing and acting on a large number if not all of the topics on the assignment and better aligns with the name of the controller (signup_sheet_controller). Therefore the add_signup_topics method was renamed to index and the original index method was renamed to index_signup. The latter was renamed using the index convention but with the _signup suffix. The original index method displayed the list of topics that the user could sign up for. In this case the student is interested in acting only one one topic therefore the signup suffix reflects intent.

In the following example from the sign_up_sheet_controller.rb file, the original programmers did not employ the DRY principle to their code.

== Moving logic code to the Model ==

In the Model View Controller (MVC) paradigm code pertaining to the business logic of an application belongs in the model layer of the program. This paradigm was broken in several places in sign_up_sheet_controller.rb file. For instance, the confirm_topic method is used in the sign_up_sheet_controller.rb file to assign a topic to a user after performing several model layer checks to make sure that the user can, in fact, be assigned a topic. This code is better moved to the model layer as its performing business logic and not simple validation or control statements. The decision was made to move this method into the SignUpTopic model.

== General Cleanup and Deletion ==
There were also several “utility” methods that we believe were added to the controller at some earlier point and are now obfuscated due to the efforts of previous groups of students to improve the code. For instance, the otherConfirmedTopicforUser(assignment_id, creator_id) and slotAvailable?(topic_id) methods did nothing other than call a method in the model and return the result, this sort of complexity is unnecessary. We removed these methods from the controller as they achieved nothing and did not make the code any easier to read.

{image 2 here}

== File change list ==

The following is a complete list of files that were changed.
<ul>
<li>M Gemfile.lock</li>
<li>M app/controllers/sign_up_sheet_controller.rb</li>
<li>M app/controllers/signup_controller.rb</li>
<li>M app/models/sign_up_sheet.rb</li>
<li>M app/models/sign_up_topic.rb</li>
<li>M app/models/signed_up_user.rb</li>
<li>M app/models/system_settings.rb</li>
<li>M app/models/team.rb</li>
<li>M app/views/assignments/_reserve_topic.html.erb</li>
<li>M app/views/assignments/edit/_rubrics.html.erb</li>
<li>M app/views/bookmarks/add_tag_bookmark.erb</li>
<li>M app/views/bookmarks/view_topic_bookmarks.rhtml</li>
<li>D app/views/sign_up_sheet/_add_signup_topcis.html.erb</li>
<li>D app/views/sign_up_sheet/_add_signup_topics.html.erb</li>
<li>A app/views/sign_up_sheet/_index.html.erb</li>
<li>A app/views/sign_up_sheet/_index_staggered.html.erb</li>
<li>M app/views/sign_up_sheet/_reserve_topic.html.erb</li>
<li>D app/views/sign_up_sheet/add_signup_topics.html.erb</li>
<li>D app/views/sign_up_sheet/add_signup_topics_staggered.html.erb</li>
<li>M app/views/sign_up_sheet/edit.html.erb</li>
<li>A app/views/sign_up_sheet/index.html.erb</li>
<li>A app/views/sign_up_sheet/index_signup.html.erb</li>
<li>D app/views/sign_up_sheet/list.html.erb</li>
<li>M app/views/sign_up_sheet/new.html.erb</li>
<li>M app/views/student_task/view.html.erb</li>
<li>M app/views/tree_display/actions/_assignments_actions.html.erb</li>
<li>M config/routes.rb</li>
<li>M db/migrate/053_create_nodes.rb</li>
<li>M db/schema.rb</li>
<li>M test/fixtures/assignments.yml</li>
<li>M test/fixtures/invitations.yml</li>
<li>M test/fixtures/participants.yml</li>
<li>M test/fixtures/question_types.yml</li>
<li>M test/fixtures/questionnaires.yml</li>
<li>M test/fixtures/questions.yml</li>
<li>M test/fixtures/response_maps.yml</li>
<li>M test/fixtures/responses.yml</li>
<li>M test/fixtures/roles.yml</li>
<li>M test/fixtures/scores.yml</li>
<li>M test/fixtures/sign_up_topics.yml</li>
<li>M test/fixtures/signed_up_users.yml</li>
<li>M test/fixtures/teams.yml</li>
<li>M test/fixtures/teams_users.yml</li>
<li>M test/fixtures/topic_deadlines.yml</li>
<li>M test/fixtures/users.yml</li>
<li>M test/functional/sign_up_sheet_controller_test.rb</li>
<li>M test/functional/signup_controller_test.rb</li>
</ul>

== References ==

<references/>

== External Links ==
[https://github.com/jmkubasc/expertiza Forked GitHub Repository] 
[http://152.1.13.96:3000/ VCL Instance] May be invalid after a few weeks 
[https://docs.google.com/document/d/1iU1FyPgfn5LmILBxnmcBW7kOrv3zC_FYmhRgVuj9ct0/edit?usp=sharing README]

CSC/ECE 517 Fall 2014/oss E1459 jjr

2014-10-30T01:44:32Z

Jmkubasc: /* External Links */

= E1459 - Refactoring the signup_controller =

__TOC__

== Introduction ==

[http://expertiza.ncsu.edu/ Expertiza] is a web based application used by students and professors to create, select, submit and review assignments. Selection of assignments may be individual assignments or group assignments. The assignment is configured by the professor. Peer reviews can be conducted by fellow students in the class. Additionally the professor can review the assignments submitted by the students. Assignments are what Expertiza calls learning objects. Learning objects consist of such things as articles, websites or web applications, or code.

The Expertiza project is open source with many programmers contributing to the code base. The source code is available at [https://github.com/expertiza/expertiza github]. Due to the open source nature of this application the code is not always as clear, concise and as standardized as it could be. This project seeks to resolve some of these issues by applying sound object oriented design principles along with standard RESTful naming conventions where possible.

== Scope ==

This project is focused on the signup_controller and its fringe classes. The role of the signup_controller is to process requests from the user to sign up for an assignment. The purpose of the controller is to process actions from the user; however, in many cases the controller is doing functions that should be provided by the model. Any calculations should appear in the model rather than the controller. The code should use RESTful names such as new, create, edit, and delete. In many cases it does not. Methods should be no more than 30-40 lines long. Any longer and the reader needs to rely on their working memory to remember what code that is outside of their view does which is an inefficient and error prone way to read code. Other classes that are involved in this process include the sign_up_sheet_controller a number of views that pertain to assignments, topics and fixtures and functional tests and model classes such as sign_up_sheet.rb and sign_up_topic.rb. The sign_up_sheet_controller handles actions pertaining to creating assignments.

== Formatting Changes ==

On the first round of refinement the code was simply cleaned up by untabifying the code and using the Rails and Expertiza coding standard of using two spaces for indentation. Untabifying the code eliminates variations in tab stop configuration in programmers editors. This makes the code more readable to those who view the source code so that blocks don’t look like run together.

== Rails Naming Conventions ==

Some methods were renamed to ones that more closely align with Rails naming conventions. In the app/controllers/sign_up_sheet_controller.rb the index and add_signup_topics actions were changed to index_signup and index actions respectively. These two actions did similar functions and were made clearer by merging them.

{first image here}

The design of the SignUpSheetController class controls two different behaviors of the SignUpTopics model: creation of topics for an assignment by the instructor, and allowing students to sign up for a topic. To clearly distinguish between these two different behaviors, all actions performed by the instructor to manage a topic (index/create/update/destroy) were renamed to follow the standard Rails naming convention. All actions performed by the student (index/create/destroy) to sign up for a topic have the suffix _signup.

The issue with these methods were that they didn’t follow Rails naming conventions for displaying a list of items and they were not representative of the the functions that they performed. The add_signup_topics method displayed a list of topics for the teacher to modify the topics. The index method although following Rails convention in naming the function name did describe its purpose with respect to the scope of the controller in which it lives. The index method originally listed the topics for the student to sign up from. This however is the sign up sheet controller and therefore the index method would have been expected to list topics and perform actions on them at a higher level. The teacher is concerned with the assignment as a whole. That is the teacher is concerned with listing and acting on a large number if not all of the topics on the assignment and better aligns with the name of the controller (signup_sheet_controller). Therefore the add_signup_topics method was renamed to index and the original index method was renamed to index_signup. The latter was renamed using the index convention but with the _signup suffix. The original index method displayed the list of topics that the user could sign up for. In this case the student is interested in acting only one one topic therefore the signup suffix reflects intent.

In the following example from the sign_up_sheet_controller.rb file, the original programmers did not employ the DRY principle to their code.

== Moving logic code to the Model ==

In the Model View Controller (MVC) paradigm code pertaining to the business logic of an application belongs in the model layer of the program. This paradigm was broken in several places in sign_up_sheet_controller.rb file. For instance, the confirm_topic method is used in the sign_up_sheet_controller.rb file to assign a topic to a user after performing several model layer checks to make sure that the user can, in fact, be assigned a topic. This code is better moved to the model layer as its performing business logic and not simple validation or control statements. The decision was made to move this method into the SignUpTopic model.

General Cleanup and Deletion
There were also several “utility” methods that we believe were added to the controller at some earlier point and are now obfuscated due to the efforts of previous groups of students to improve the code. For instance, the otherConfirmedTopicforUser(assignment_id, creator_id) and slotAvailable?(topic_id) methods did nothing other than call a method in the model and return the result, this sort of complexity is unnecessary. We removed these methods from the controller as they achieved nothing and did not make the code any easier to read.

{image 2 here}

== File change list ==

The following is a complete list of files that were changed.
<ul>
<li>M Gemfile.lock</li>
<li>M app/controllers/sign_up_sheet_controller.rb</li>
<li>M app/controllers/signup_controller.rb</li>
<li>M app/models/sign_up_sheet.rb</li>
<li>M app/models/sign_up_topic.rb</li>
<li>M app/models/signed_up_user.rb</li>
<li>M app/models/system_settings.rb</li>
<li>M app/models/team.rb</li>
<li>M app/views/assignments/_reserve_topic.html.erb</li>
<li>M app/views/assignments/edit/_rubrics.html.erb</li>
<li>M app/views/bookmarks/add_tag_bookmark.erb</li>
<li>M app/views/bookmarks/view_topic_bookmarks.rhtml</li>
<li>D app/views/sign_up_sheet/_add_signup_topcis.html.erb</li>
<li>D app/views/sign_up_sheet/_add_signup_topics.html.erb</li>
<li>A app/views/sign_up_sheet/_index.html.erb</li>
<li>A app/views/sign_up_sheet/_index_staggered.html.erb</li>
<li>M app/views/sign_up_sheet/_reserve_topic.html.erb</li>
<li>D app/views/sign_up_sheet/add_signup_topics.html.erb</li>
<li>D app/views/sign_up_sheet/add_signup_topics_staggered.html.erb</li>
<li>M app/views/sign_up_sheet/edit.html.erb</li>
<li>A app/views/sign_up_sheet/index.html.erb</li>
<li>A app/views/sign_up_sheet/index_signup.html.erb</li>
<li>D app/views/sign_up_sheet/list.html.erb</li>
<li>M app/views/sign_up_sheet/new.html.erb</li>
<li>M app/views/student_task/view.html.erb</li>
<li>M app/views/tree_display/actions/_assignments_actions.html.erb</li>
<li>M config/routes.rb</li>
<li>M db/migrate/053_create_nodes.rb</li>
<li>M db/schema.rb</li>
<li>M test/fixtures/assignments.yml</li>
<li>M test/fixtures/invitations.yml</li>
<li>M test/fixtures/participants.yml</li>
<li>M test/fixtures/question_types.yml</li>
<li>M test/fixtures/questionnaires.yml</li>
<li>M test/fixtures/questions.yml</li>
<li>M test/fixtures/response_maps.yml</li>
<li>M test/fixtures/responses.yml</li>
<li>M test/fixtures/roles.yml</li>
<li>M test/fixtures/scores.yml</li>
<li>M test/fixtures/sign_up_topics.yml</li>
<li>M test/fixtures/signed_up_users.yml</li>
<li>M test/fixtures/teams.yml</li>
<li>M test/fixtures/teams_users.yml</li>
<li>M test/fixtures/topic_deadlines.yml</li>
<li>M test/fixtures/users.yml</li>
<li>M test/functional/sign_up_sheet_controller_test.rb</li>
<li>M test/functional/signup_controller_test.rb</li>
</ul>

== External Links ==
https://github.com/jmkubasc/expertiza
http://152.1.13.96:3000/

CSC/ECE 517 Fall 2014/oss E1459 jjr

2014-10-30T01:42:43Z

Jmkubasc: /* E1459 - Refactoring the signup_controller */

= E1459 - Refactoring the signup_controller =

__TOC__

== Introduction ==

[http://expertiza.ncsu.edu/ Expertiza] is a web based application used by students and professors to create, select, submit and review assignments. Selection of assignments may be individual assignments or group assignments. The assignment is configured by the professor. Peer reviews can be conducted by fellow students in the class. Additionally the professor can review the assignments submitted by the students. Assignments are what Expertiza calls learning objects. Learning objects consist of such things as articles, websites or web applications, or code.

The Expertiza project is open source with many programmers contributing to the code base. The source code is available at [https://github.com/expertiza/expertiza github]. Due to the open source nature of this application the code is not always as clear, concise and as standardized as it could be. This project seeks to resolve some of these issues by applying sound object oriented design principles along with standard RESTful naming conventions where possible.

== Scope ==

This project is focused on the signup_controller and its fringe classes. The role of the signup_controller is to process requests from the user to sign up for an assignment. The purpose of the controller is to process actions from the user; however, in many cases the controller is doing functions that should be provided by the model. Any calculations should appear in the model rather than the controller. The code should use RESTful names such as new, create, edit, and delete. In many cases it does not. Methods should be no more than 30-40 lines long. Any longer and the reader needs to rely on their working memory to remember what code that is outside of their view does which is an inefficient and error prone way to read code. Other classes that are involved in this process include the sign_up_sheet_controller a number of views that pertain to assignments, topics and fixtures and functional tests and model classes such as sign_up_sheet.rb and sign_up_topic.rb. The sign_up_sheet_controller handles actions pertaining to creating assignments.

== Formatting Changes ==

On the first round of refinement the code was simply cleaned up by untabifying the code and using the Rails and Expertiza coding standard of using two spaces for indentation. Untabifying the code eliminates variations in tab stop configuration in programmers editors. This makes the code more readable to those who view the source code so that blocks don’t look like run together.

== Rails Naming Conventions ==

Some methods were renamed to ones that more closely align with Rails naming conventions. In the app/controllers/sign_up_sheet_controller.rb the index and add_signup_topics actions were changed to index_signup and index actions respectively. These two actions did similar functions and were made clearer by merging them.

{first image here}

The design of the SignUpSheetController class controls two different behaviors of the SignUpTopics model: creation of topics for an assignment by the instructor, and allowing students to sign up for a topic. To clearly distinguish between these two different behaviors, all actions performed by the instructor to manage a topic (index/create/update/destroy) were renamed to follow the standard Rails naming convention. All actions performed by the student (index/create/destroy) to sign up for a topic have the suffix _signup.

The issue with these methods were that they didn’t follow Rails naming conventions for displaying a list of items and they were not representative of the the functions that they performed. The add_signup_topics method displayed a list of topics for the teacher to modify the topics. The index method although following Rails convention in naming the function name did describe its purpose with respect to the scope of the controller in which it lives. The index method originally listed the topics for the student to sign up from. This however is the sign up sheet controller and therefore the index method would have been expected to list topics and perform actions on them at a higher level. The teacher is concerned with the assignment as a whole. That is the teacher is concerned with listing and acting on a large number if not all of the topics on the assignment and better aligns with the name of the controller (signup_sheet_controller). Therefore the add_signup_topics method was renamed to index and the original index method was renamed to index_signup. The latter was renamed using the index convention but with the _signup suffix. The original index method displayed the list of topics that the user could sign up for. In this case the student is interested in acting only one one topic therefore the signup suffix reflects intent.

In the following example from the sign_up_sheet_controller.rb file, the original programmers did not employ the DRY principle to their code.

== Moving logic code to the Model ==

In the Model View Controller (MVC) paradigm code pertaining to the business logic of an application belongs in the model layer of the program. This paradigm was broken in several places in sign_up_sheet_controller.rb file. For instance, the confirm_topic method is used in the sign_up_sheet_controller.rb file to assign a topic to a user after performing several model layer checks to make sure that the user can, in fact, be assigned a topic. This code is better moved to the model layer as its performing business logic and not simple validation or control statements. The decision was made to move this method into the SignUpTopic model.

General Cleanup and Deletion
There were also several “utility” methods that we believe were added to the controller at some earlier point and are now obfuscated due to the efforts of previous groups of students to improve the code. For instance, the otherConfirmedTopicforUser(assignment_id, creator_id) and slotAvailable?(topic_id) methods did nothing other than call a method in the model and return the result, this sort of complexity is unnecessary. We removed these methods from the controller as they achieved nothing and did not make the code any easier to read.

{image 2 here}

== File change list ==

The following is a complete list of files that were changed.
<ul>
<li>M Gemfile.lock</li>
<li>M app/controllers/sign_up_sheet_controller.rb</li>
<li>M app/controllers/signup_controller.rb</li>
<li>M app/models/sign_up_sheet.rb</li>
<li>M app/models/sign_up_topic.rb</li>
<li>M app/models/signed_up_user.rb</li>
<li>M app/models/system_settings.rb</li>
<li>M app/models/team.rb</li>
<li>M app/views/assignments/_reserve_topic.html.erb</li>
<li>M app/views/assignments/edit/_rubrics.html.erb</li>
<li>M app/views/bookmarks/add_tag_bookmark.erb</li>
<li>M app/views/bookmarks/view_topic_bookmarks.rhtml</li>
<li>D app/views/sign_up_sheet/_add_signup_topcis.html.erb</li>
<li>D app/views/sign_up_sheet/_add_signup_topics.html.erb</li>
<li>A app/views/sign_up_sheet/_index.html.erb</li>
<li>A app/views/sign_up_sheet/_index_staggered.html.erb</li>
<li>M app/views/sign_up_sheet/_reserve_topic.html.erb</li>
<li>D app/views/sign_up_sheet/add_signup_topics.html.erb</li>
<li>D app/views/sign_up_sheet/add_signup_topics_staggered.html.erb</li>
<li>M app/views/sign_up_sheet/edit.html.erb</li>
<li>A app/views/sign_up_sheet/index.html.erb</li>
<li>A app/views/sign_up_sheet/index_signup.html.erb</li>
<li>D app/views/sign_up_sheet/list.html.erb</li>
<li>M app/views/sign_up_sheet/new.html.erb</li>
<li>M app/views/student_task/view.html.erb</li>
<li>M app/views/tree_display/actions/_assignments_actions.html.erb</li>
<li>M config/routes.rb</li>
<li>M db/migrate/053_create_nodes.rb</li>
<li>M db/schema.rb</li>
<li>M test/fixtures/assignments.yml</li>
<li>M test/fixtures/invitations.yml</li>
<li>M test/fixtures/participants.yml</li>
<li>M test/fixtures/question_types.yml</li>
<li>M test/fixtures/questionnaires.yml</li>
<li>M test/fixtures/questions.yml</li>
<li>M test/fixtures/response_maps.yml</li>
<li>M test/fixtures/responses.yml</li>
<li>M test/fixtures/roles.yml</li>
<li>M test/fixtures/scores.yml</li>
<li>M test/fixtures/sign_up_topics.yml</li>
<li>M test/fixtures/signed_up_users.yml</li>
<li>M test/fixtures/teams.yml</li>
<li>M test/fixtures/teams_users.yml</li>
<li>M test/fixtures/topic_deadlines.yml</li>
<li>M test/fixtures/users.yml</li>
<li>M test/functional/sign_up_sheet_controller_test.rb</li>
<li>M test/functional/signup_controller_test.rb</li>
</ul>

== External Links ==
https://github.com/jmkubasc/expertiza

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:47:24Z

Jmkubasc: /* Basic Example */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the HTTP server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as Python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Starting the HTTP Server ===
CherryPy provides two ways to start the HTTP server, depending on the developer's needs.

==== Single Application ====
The simplest way is to call the <tt>cherrypy.quickstart()</tt> function. This function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application class 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application class 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for the application. It can either be a dictionary object or a configuration file.

==== Multiple Applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple application classes.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications classes having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the CherryPy framework

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the HTTP server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

A configuration file path instead can be passed as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a Python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Static Content ===
Files with static content, such as binaries, images, or stylesheets, can be served by the HTTP server by adding the following lines to the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== HTTP Server Port ===

The default HTTP server started by CherryPy can be used to host the application only on one socket port (default 8080). However, it is possible to host the HTTP server on multiple ports by binding them to different socket ports.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more HTTP server which runs on port 443. It is possible to create any number of additional HTTP servers.

=== Authentication ===

CherryPy provides two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

The CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:45:04Z

Jmkubasc: /* Test Suite */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the web server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as Python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Starting the HTTP Server ===
CherryPy provides two ways to start the HTTP server, depending on the developer's needs.

==== Single Application ====
The simplest way is to call the <tt>cherrypy.quickstart()</tt> function. This function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application class 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application class 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for the application. It can either be a dictionary object or a configuration file.

==== Multiple Applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple application classes.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications classes having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the CherryPy framework

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the HTTP server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

A configuration file path instead can be passed as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a Python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Static Content ===
Files with static content, such as binaries, images, or stylesheets, can be served by the HTTP server by adding the following lines to the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== HTTP Server Port ===

The default HTTP server started by CherryPy can be used to host the application only on one socket port (default 8080). However, it is possible to host the HTTP server on multiple ports by binding them to different socket ports.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more HTTP server which runs on port 443. It is possible to create any number of additional HTTP servers.

=== Authentication ===

CherryPy provides two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

The CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:44:10Z

Jmkubasc: /* Authentication */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the web server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as Python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Starting the HTTP Server ===
CherryPy provides two ways to start the HTTP server, depending on the developer's needs.

==== Single Application ====
The simplest way is to call the <tt>cherrypy.quickstart()</tt> function. This function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application class 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application class 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for the application. It can either be a dictionary object or a configuration file.

==== Multiple Applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple application classes.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications classes having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the CherryPy framework

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the HTTP server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

A configuration file path instead can be passed as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a Python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Static Content ===
Files with static content, such as binaries, images, or stylesheets, can be served by the HTTP server by adding the following lines to the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== HTTP Server Port ===

The default HTTP server started by CherryPy can be used to host the application only on one socket port (default 8080). However, it is possible to host the HTTP server on multiple ports by binding them to different socket ports.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more HTTP server which runs on port 443. It is possible to create any number of additional HTTP servers.

=== Authentication ===

CherryPy provides two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:43:22Z

Jmkubasc: /* Multiple HTTP Servers */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the web server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as Python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Starting the HTTP Server ===
CherryPy provides two ways to start the HTTP server, depending on the developer's needs.

==== Single Application ====
The simplest way is to call the <tt>cherrypy.quickstart()</tt> function. This function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application class 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application class 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for the application. It can either be a dictionary object or a configuration file.

==== Multiple Applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple application classes.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications classes having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the CherryPy framework

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the HTTP server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

A configuration file path instead can be passed as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a Python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Static Content ===
Files with static content, such as binaries, images, or stylesheets, can be served by the HTTP server by adding the following lines to the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== HTTP Server Port ===

The default HTTP server started by CherryPy can be used to host the application only on one socket port (default 8080). However, it is possible to host the HTTP server on multiple ports by binding them to different socket ports.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more HTTP server which runs on port 443. It is possible to create any number of additional HTTP servers.

=== Authentication ===

CherryPy supports two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:40:10Z

Jmkubasc: /* Publish REST APIs */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the web server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as Python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Starting the HTTP Server ===
CherryPy provides two ways to start the HTTP server, depending on the developer's needs.

==== Single Application ====
The simplest way is to call the <tt>cherrypy.quickstart()</tt> function. This function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application class 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application class 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for the application. It can either be a dictionary object or a configuration file.

==== Multiple Applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple application classes.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications classes having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the CherryPy framework

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the HTTP server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

A configuration file path instead can be passed as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a Python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Static Content ===
Files with static content, such as binaries, images, or stylesheets, can be served by the HTTP server by adding the following lines to the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

The default HTTP server started by CherryPy can only be used to host the application on one port. But, it is also possible to host the application on multiple ports by starting additional servers.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more server, which runs on port 443. It is possible to create any number of additional servers.

=== Authentication ===

CherryPy supports two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:39:02Z

Jmkubasc: /* Serve Static Content */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the web server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as Python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Starting the HTTP Server ===
CherryPy provides two ways to start the HTTP server, depending on the developer's needs.

==== Single Application ====
The simplest way is to call the <tt>cherrypy.quickstart()</tt> function. This function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application class 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application class 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for the application. It can either be a dictionary object or a configuration file.

==== Multiple Applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple application classes.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications classes having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the CherryPy framework

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the HTTP server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

A configuration file path instead can be passed as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a Python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Static Content ===
Files with static content, such as binaries, images, or stylesheets, can be served by the HTTP server by adding the following lines to the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

The default HTTP server started by CherryPy can only be used to host the application on one port. But, it is also possible to host the application on multiple ports by starting additional servers.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more server, which runs on port 443. It is possible to create any number of additional servers.

=== Authentication ===

CherryPy supports two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:36:12Z

Jmkubasc: /* Server Configuration */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the web server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as Python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Starting the HTTP Server ===
CherryPy provides two ways to start the HTTP server, depending on the developer's needs.

==== Single Application ====
The simplest way is to call the <tt>cherrypy.quickstart()</tt> function. This function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application class 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application class 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for the application. It can either be a dictionary object or a configuration file.

==== Multiple Applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple application classes.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications classes having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the CherryPy framework

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the HTTP server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

A configuration file path instead can be passed as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a Python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

The default HTTP server started by CherryPy can only be used to host the application on one port. But, it is also possible to host the application on multiple ports by starting additional servers.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more server, which runs on port 443. It is possible to create any number of additional servers.

=== Authentication ===

CherryPy supports two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:34:31Z

Jmkubasc: /* Built-in HTTP Server to host single or multiple applications */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the web server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as Python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Starting the HTTP Server ===
CherryPy provides two ways to start the HTTP server, depending on the developer's needs.

==== Single Application ====
The simplest way is to call the <tt>cherrypy.quickstart()</tt> function. This function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application class 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application class 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for the application. It can either be a dictionary object or a configuration file.

==== Multiple Applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple application classes.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications classes having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a Python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

The default HTTP server started by CherryPy can only be used to host the application on one port. But, it is also possible to host the application on multiple ports by starting additional servers.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more server, which runs on port 443. It is possible to create any number of additional servers.

=== Authentication ===

CherryPy supports two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:28:39Z

Jmkubasc: /* In-built HTTP Server to host single or multiple applications */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the web server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as Python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Built-in HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <tt>cherrypy.quickstart()</tt> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a Python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

The default HTTP server started by CherryPy can only be used to host the application on one port. But, it is also possible to host the application on multiple ports by starting additional servers.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more server, which runs on port 443. It is possible to create any number of additional servers.

=== Authentication ===

CherryPy supports two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:26:48Z

Jmkubasc: /* Sessions */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the web server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as Python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <tt>cherrypy.quickstart()</tt> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a Python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

The default HTTP server started by CherryPy can only be used to host the application on one port. But, it is also possible to host the application on multiple ports by starting additional servers.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more server, which runs on port 443. It is possible to create any number of additional servers.

=== Authentication ===

CherryPy supports two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:26:31Z

Jmkubasc: /* Cookies */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the web server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as Python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <tt>cherrypy.quickstart()</tt> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

The default HTTP server started by CherryPy can only be used to host the application on one port. But, it is also possible to host the application on multiple ports by starting additional servers.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more server, which runs on port 443. It is possible to create any number of additional servers.

=== Authentication ===

CherryPy supports two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:26:12Z

Jmkubasc: /* Basic Example */

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates a very simple web server using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

The line <code>cherrypy.quickstart(WebApp())</code> tells the CherryPy framework to start the web server, which is defined as a class named <code>WebApp</code>. The method <code>index</code> is exposed as a URL handler by the <code>@cherrypy.expose</code> statement. The return value of the method is what is sent as the HTTP reposne.

Start the application by running the above Python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <tt>cherrypy.quickstart()</tt> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

The default HTTP server started by CherryPy can only be used to host the application on one port. But, it is also possible to host the application on multiple ports by starting additional servers.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more server, which runs on port 443. It is possible to create any number of additional servers.

=== Authentication ===

CherryPy supports two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:20:01Z

Jmkubasc:

'''CherryPy Framework'''

CherryPy is a Python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates the most basic webserver using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

Start the application by running the above python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <tt>cherrypy.quickstart()</tt> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

The default HTTP server started by CherryPy can only be used to host the application on one port. But, it is also possible to host the application on multiple ports by starting additional servers.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more server, which runs on port 443. It is possible to create any number of additional servers.

=== Authentication ===

CherryPy supports two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-18T23:19:50Z

Jmkubasc: /* Background */

'''CherryPy Framework'''

CherryPy is a python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

== Background ==

CherryPy is a lightweight web server framework written in Python. It has an object-oriented design and provides a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development.

CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref> Python comes with a rich library support, so this typically is not an issue.

It is distributed under the BSD License<ref>https://bitbucket.org/cherrypy/cherrypy/src/697c7af588b8/cherrypy/LICENSE.txt</ref>. The latest stable version is 3.6 as of August 19, 2014<ref>https://pypi.python.org/pypi/CherryPy</ref>.

Some of the well known websites using CherryPy are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list can be found [http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy here].

== Basic Example ==

The following code demonstrates the most basic webserver using the CherryPy framework.

'''WebApp.py'''
<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

Start the application by running the above python file "WebApp.py" and open your web browser to http://localhost:8080. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of http://localhost:8080/test?value=5 gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to http://localhost:8080/set?value=test followed by http://localhost:8080/get gives the following

[[File:CherryPyCookieTest.png]]

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <tt>cherrypy.quickstart()</tt> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <tt>cherrypy.tree.mount</tt> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Server Configuration ===

The <tt>cherrypy.config.update</tt> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9999})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow the user to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

CherryPy can be used to expose the APIs as RESTful Web Services. This allows third party applications to easily communicate with the system.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

The above code exposes the GET API with url http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

The default HTTP server started by CherryPy can only be used to host the application on one port. But, it is also possible to host the application on multiple ports by starting additional servers.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts the application with one more server, which runs on port 443. It is possible to create any number of additional servers.

=== Authentication ===

CherryPy supports two authentication mechanisms: Simple and Digest. It follows the specification defined by [http://tools.ietf.org/html/rfc2617.html RFC 2617]

=== WSGI Support ===

CherryPy supports the WSGI (Web Server Gateway Interface) specification defined by [http://www.python.org/dev/peps/pep-0333 PEP 0333] and [http://www.python.org/dev/peps/pep-3333 PEP 3333].

This allows two things:
* Instead of using the default CherryPy server, a CherryPy application can be hosted on an external WSGI server.
* The CherryPy server can be used independently to host an external WSGI application.

=== Test Suite ===

CherryPy framework provides a class, named <tt>helper</tt> which can be used as a base class for writing functional tests.

Running a test will start the complete application and thus can be used to simulate the scenario when a user actually tries to access the server on web.

The sample code to run a test can be found [http://docs.cherrypy.org/en/latest/advanced.html#testing-your-application here]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-15T03:50:38Z

Jmkubasc: /* Background */

'''CherryPy Framework'''

CherryPy is a python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

Some of the popular websites using it are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list of applications using it can be found here.<ref>http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy</ref>

== Background ==

CherryPy is a lightweight web server framework written in python. It has an object-oriented design and provides only a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development. CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref>

Why, when, where and by whom was it developed ? 
Basic Philosophy Behind the project ? 
Which companies are using it ? 
Total number of active users, latest release version number etc. 

== Basic Example ==

The following code demonstrates the most basic webserver using the CherryPy framework.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

Run the application, and open your web browser to [http://localhost:8080 localhost:8080]. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <code>cherrypy.quickstart()</code> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <code>cherrypy.tree.mount</code> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of [http://localhost:8080/test?value=5 localhost:8080/test?value=5] gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to [http://localhost:8080/set?value=test localhost:8080/set?value=test] followed by [http://localhost:8080/get localhost:8080/get] gives the following

[[File:CherryPyCookieTest.png]]

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Server Configuration ===

The <code>cherrypy.config.update</code> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9090})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow us to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

It allows to expose our APIs as Restful Web Services.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

This exposes the REST API "GET": http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

It is possible to host the application with multiple servers, where each server runs on a different port.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts our application with one more server which runs on port 443. We can create any number of additional servers.

=== Test Suite ===

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-15T03:50:04Z

Jmkubasc: /* Background */

'''CherryPy Framework'''

CherryPy is a python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

Some of the popular websites using it are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list of applications using it can be found here.<ref>http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy</ref>

== Background ==

CherryPy is a lightweight web server written in python. It has an object-oriented design and provides only a basic HTTP web server as defined in RFC 7321. It includes built-in profiling, coverage, and testing tools to assist in development. CherryPy does not have any built-in templating or database engines, and instead relies on external libraries and plugins. <ref>http://www.cherrypy.org/</ref>

Why, when, where and by whom was it developed ? 
Basic Philosophy Behind the project ? 
Which companies are using it ? 
Total number of active users, latest release version number etc. 

== Basic Example ==

The following code demonstrates the most basic webserver using the CherryPy framework.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

Run the application, and open your web browser to [http://localhost:8080 localhost:8080]. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <code>cherrypy.quickstart()</code> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <code>cherrypy.tree.mount</code> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of [http://localhost:8080/test?value=5 localhost:8080/test?value=5] gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to [http://localhost:8080/set?value=test localhost:8080/set?value=test] followed by [http://localhost:8080/get localhost:8080/get] gives the following

[[File:CherryPyCookieTest.png]]

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Server Configuration ===

The <code>cherrypy.config.update</code> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9090})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow us to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

It allows to expose our APIs as Restful Web Services.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

This exposes the REST API "GET": http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

It is possible to host the application with multiple servers, where each server runs on a different port.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts our application with one more server which runs on port 443. We can create any number of additional servers.

=== Test Suite ===

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-14T21:39:37Z

Jmkubasc: /* Background */

'''CherryPy Framework'''

CherryPy is a python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

Some of the popular websites using it are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list of applications using it can be found here.<ref>http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy</ref>

== Background ==
Object-oriented, python based 
Basic RFC 7321 (HTTP) 
Built-in profiling 
complete test suite 
No built-in templating or database engines, use external tools 

Why, when, where and by whom was it developed ? 
Basic Philosophy Behind the project ? 
Which companies are using it ? 
Total number of active users, latest release version number etc. 

== Basic Example ==

The following code demonstrates the most basic webserver using the CherryPy framework.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

Run the application, and open your web browser to [http://localhost:8080 localhost:8080]. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <code>cherrypy.quickstart()</code> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <code>cherrypy.tree.mount</code> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of [http://localhost:8080/test?value=5 localhost:8080/test?value=5] gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to [http://localhost:8080/set?value=test localhost:8080/set?value=test] followed by [http://localhost:8080/get localhost:8080/get] gives the following

[[File:CherryPyCookieTest.png]]

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Server Configuration ===

The <code>cherrypy.config.update</code> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9090})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow us to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

It allows to expose our APIs as Restful Web Services.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

This exposes the REST API "GET": http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

It is possible to host the application with multiple servers, where each server runs on a different port.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts our application with one more server which runs on port 443. We can create any number of additional servers.

=== Test Suite ===

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-14T21:35:25Z

Jmkubasc: /* Sessions */

'''CherryPy Framework'''

CherryPy is a python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

Some of the popular websites using it are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list of applications using it can be found here.<ref>http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy</ref>

== Background ==

== Basic Example ==

The following code demonstrates the most basic webserver using the CherryPy framework.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

Run the application, and open your web browser to [http://localhost:8080 localhost:8080]. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <code>cherrypy.quickstart()</code> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <code>cherrypy.tree.mount</code> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of [http://localhost:8080/test?value=5 localhost:8080/test?value=5] gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to [http://localhost:8080/set?value=test localhost:8080/set?value=test] followed by [http://localhost:8080/get localhost:8080/get] gives the following

[[File:CherryPyCookieTest.png]]

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is a python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Server Configuration ===

The <code>cherrypy.config.update</code> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9090})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow us to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

It allows to expose our APIs as Restful Web Services.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

This exposes the REST API "GET": http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

It is possible to host the application with multiple servers, where each server runs on a different port.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts our application with one more server which runs on port 443. We can create any number of additional servers.

=== Test Suite ===

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-14T21:34:56Z

Jmkubasc: /* Sessions */

'''CherryPy Framework'''

CherryPy is a python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

Some of the popular websites using it are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list of applications using it can be found here.<ref>http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy</ref>

== Background ==

== Basic Example ==

The following code demonstrates the most basic webserver using the CherryPy framework.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

Run the application, and open your web browser to [http://localhost:8080 localhost:8080]. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <code>cherrypy.quickstart()</code> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <code>cherrypy.tree.mount</code> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of [http://localhost:8080/test?value=5 localhost:8080/test?value=5] gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to [http://localhost:8080/set?value=test localhost:8080/set?value=test] followed by [http://localhost:8080/get localhost:8080/get] gives the following

[[File:CherryPyCookieTest.png]]

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with <tt>cherrypy.session</tt>, which is accessed as a python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Server Configuration ===

The <code>cherrypy.config.update</code> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9090})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow us to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

It allows to expose our APIs as Restful Web Services.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

This exposes the REST API "GET": http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

It is possible to host the application with multiple servers, where each server runs on a different port.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts our application with one more server which runs on port 443. We can create any number of additional servers.

=== Test Suite ===

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-14T21:34:19Z

Jmkubasc: /* Sessions */

'''CherryPy Framework'''

CherryPy is a python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

Some of the popular websites using it are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list of applications using it can be found here.<ref>http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy</ref>

== Background ==

== Basic Example ==

The following code demonstrates the most basic webserver using the CherryPy framework.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

Run the application, and open your web browser to [http://localhost:8080 localhost:8080]. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <code>cherrypy.quickstart()</code> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <code>cherrypy.tree.mount</code> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of [http://localhost:8080/test?value=5 localhost:8080/test?value=5] gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to [http://localhost:8080/set?value=test localhost:8080/set?value=test] followed by [http://localhost:8080/get localhost:8080/get] gives the following

[[File:CherryPyCookieTest.png]]

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>. <ref>http://docs.cherrypy.org/en/latest/basics.html#using-sessions</ref>

Session variables can be accessed with cherrypy.session, which is accessed as a python dictionary object.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
if 'number' not in cherrypy.session:
cherrypy.session['number'] = 0
else:
cherrypy.session['number'] += 1
return "Number = " + str(cherrypy.session['number'])

cherrypy.config.update({'tools.sessions.on': True})
cherrypy.quickstart(WebApp())
</pre>

This example shows a number that increments by 1 every time the user navigates to [http://localhost:8080 localhost:8080].

=== Server Configuration ===

The <code>cherrypy.config.update</code> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9090})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow us to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

It allows to expose our APIs as Restful Web Services.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

This exposes the REST API "GET": http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

It is possible to host the application with multiple servers, where each server runs on a different port.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts our application with one more server which runs on port 443. We can create any number of additional servers.

=== Test Suite ===

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-14T21:05:04Z

Jmkubasc: /* Sessions */

'''CherryPy Framework'''

CherryPy is a python based, object-oriented web framework that enables developers to quickly create lightweight and fast web applications.<ref>http://www.cherrypy.org/</ref><ref>http://en.wikipedia.org/wiki/CherryPy</ref>

Some of the popular websites using it are Hulu<ref>http://tech.hulu.com/blog/2013/03/13/python-and-hulu/</ref> and Netflix<ref>http://techblog.netflix.com/2013/03/python-at-netflix.html</ref>. The full list of applications using it can be found here.<ref>http://docs.cherrypy.org/en/latest/intro.html#websites-running-atop-cherrypy</ref>

== Background ==

== Basic Example ==

The following code demonstrates the most basic webserver using the CherryPy framework.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.quickstart(WebApp())
</pre>

Run the application, and open your web browser to [http://localhost:8080 localhost:8080]. The following page is displayed

[[File:Screenshot_-_09132014_-_03-26-32_PM.png]]

== Features ==

=== In-built HTTP Server to host single or multiple applications ===
CherryPy comes with its own HTTP server which can be used to host web applications.

==== Single application ====
The easiest way to do that is by calling the <code>cherrypy.quickstart()</code> function. The function takes at least one argument.

<pre>cherrypy.quickstart(WebApp())</pre>
This starts the application 'WebApp' at http://localhost:8080/.

It can also take 2 more arguments.
<pre>cherrypy.quickstart(WebApp(), '/hello', {'/': {'tools.gzip.on': True}})</pre>
This starts the application 'WebApp' at http://localhost:8080/hello.
The third argument defines the configuration for our application. It can either be a dictionary object or a file.

==== Multiple applications ====

The function <code>cherrypy.tree.mount</code> is used to host multiple applications.

<pre>
cherrypy.tree.mount(MyApp1(), '/app1', app1_conf)
cherrypy.tree.mount(MyApp2(), '/app2', app2_conf)

cherrypy.engine.start()
cherrypy.engine.block()
</pre>

This will host two applications having paths http://localhost:8080/app1 and http://localhost:8080/app2.

=== Logging ===

CherryPy provides the following method for application logging

<pre>
cherrypy.log("Hello, CherryPy!")
</pre>

By default, all logging is written to the console. The configuration keys <tt>log.access_file</tt> and <tt>log.error_file</tt> are also available for writing logging and errors to a text file.

=== Query Strings ===

CherryPy will automatically parse the query string of a URL. Fields are passed as method arguments with matching names, and can take advantage of default argument values.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def test(self, value=1):
return "Value = " + str(value)

cherrypy.quickstart(WebApp())
</pre>

A URL of [http://localhost:8080/test?value=5 localhost:8080/test?value=5] gives the following

[[File:Screenshot_-_09132014_-_06-37-27_PM.png]]

=== Cookies ===

CherryPy can set browser cookies with <tt>cherrypy.response.cookie</tt> and read browser cookies with <tt>cherrypy.request.cookie</tt> by accessing these variables as python dictionary objects.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def set(self, value = "Test"):
cookie = cherrypy.response.cookie
cookie['Value'] = value
return "Cookie set"

@cherrypy.expose
def get(self):
cookie = cherrypy.request.cookie
return "Cookie value = " + str(cookie['Value'].value)

cherrypy.quickstart(WebApp())
</pre>

Navigating to [http://localhost:8080/set?value=test localhost:8080/set?value=test] followed by [http://localhost:8080/get localhost:8080/get] gives the following

[[File:CherryPyCookieTest.png]]

=== Sessions ===

In CherryPy, sessions are disabled by default. To enable sessions, set the configuration <tt>tools.sessions.on</tt> to <tt>True</tt>.

=== Server Configuration ===

The <code>cherrypy.config.update</code> function can be used to configure the HTTP server.

<pre>
import cherrypy

class WebApp(object):
@cherrypy.expose
def index(self):
return "Hello, CherryPy!"

cherrypy.config.update({'server.socket_port': 9090})
cherrypy.quickstart(WebApp())

</pre>

This will start the server on port 9999 instead of the default port 8080. The application can then be accessed at http://localhost:9999/.

We can also pass a file (containing configuration) as an argument to this function.
<pre>
cherrypy.config.update("WebAppServer.conf")
</pre>

'''WebAppServer.conf'''
<pre>
[global]
server.socket_port: 9999
</pre>

=== Serve Static Content ===
Static contents like files, images, stylesheets etc. can be easily served by adding the following lines in the the application configuration file.

<pre>
[/images]
tools.staticdir.on = True
tools.staticdir.dir = "/site/public/images"
</pre>

This will allow us to access some file "user.jpg" present in the folder "/site/public/images/user.jpg" using the url http://localhost:8080/images/user.jpg.

=== Publish REST APIs ===

It allows to expose our APIs as Restful Web Services.

<pre>
import cherrypy

class MyAppRestMode(object):
exposed = True

def GET(self):
return "Hello, CherryPy!"

conf = {
'/': {
'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
'tools.response_headers.on': True,
'tools.response_headers.headers': [('Content-Type', 'text/plain')],
}
}
cherrypy.quickstart(MyAppRestMode(), '/', conf)
</pre>

This exposes the REST API "GET": http://localhost:8080/. The API returns the string "Hello, CherryPy!".

=== Multiple HTTP Servers ===

It is possible to host the application with multiple servers, where each server runs on a different port.

<pre>
from cherrypy._cpserver import Server

server = Server()
server.socket_port = 443
server.subscribe()

cherrypy.quickstart(WebApp())
</pre>

The above code hosts our application with one more server which runs on port 443. We can create any number of additional servers.

=== Test Suite ===

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-14T20:38:22Z

Jmkubasc: /* Cookies */

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T23:07:41Z

Jmkubasc: /* Cookies */

File:CherryPyCookieTest.png

2014-09-13T23:07:11Z

Jmkubasc:

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T22:41:10Z

Jmkubasc: /* Query Strings */

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T22:40:44Z

Jmkubasc: /* Query Strings */

File:Screenshot - 09132014 - 06-37-27 PM.png

2014-09-13T22:40:26Z

Jmkubasc: uploaded a new version of "File:Screenshot - 09132014 - 06-37-27 PM.png"

Result of CherryPy query string parsing

File:Screenshot - 09132014 - 06-37-27 PM.png

2014-09-13T22:39:10Z

Jmkubasc: Result of CherryPy query string parsing

Result of CherryPy query string parsing

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T22:37:46Z

Jmkubasc: /* Query Strings */

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T22:17:47Z

Jmkubasc: /* Logging */

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T21:21:24Z

Jmkubasc: /* Features */

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T21:17:32Z

Jmkubasc: /* Features */

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T21:02:52Z

Jmkubasc: /* Basic Example */

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T20:56:48Z

Jmkubasc: /* Basic Example */

File:Screenshot - 09132014 - 03-26-32 PM.png

2014-09-13T20:51:48Z

Jmkubasc: Screenshot of Hello CherryPy output

Screenshot of Hello CherryPy output

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T20:51:19Z

Jmkubasc: /* Basic Example */

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T20:34:46Z

Jmkubasc: /* Basic Example */

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T19:31:54Z

Jmkubasc: /* Basic Example */

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T18:45:10Z

Jmkubasc:

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T18:34:26Z

Jmkubasc:

'''CherryPy Framework'''

CherryPy is a python based web framework that provides <ref>http://www.cherrypy.org/</ref>

== Basic Example ==

== Features ==

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T18:33:49Z

Jmkubasc: /* Background */

'''CherryPy Framework'''

== Background ==
CherryPy is a python based web framework that provides <ref>http://www.cherrypy.org/</ref>

== Basic Example ==

== Features ==

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T18:31:21Z

Jmkubasc: /* References */

'''CherryPy Framework'''

== Background ==

== Basic Example ==

== Features ==

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T18:16:52Z

Jmkubasc:

'''CherryPy Framework'''

== Background ==

== Basic Example ==

== Features ==

== References ==

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T18:16:39Z

Jmkubasc:

CherryPy Framework

== Background ==

== Basic Example ==

== Features ==

== References ==

CSC/ECE 517 Fall 2014/ch1a 3 zq

2014-09-13T18:14:18Z

Jmkubasc: Created page with "== CherryPy Framework =="

== CherryPy Framework ==

CSC/ECE 517 Fall 2014

2014-09-13T18:12:51Z

Jmkubasc:

*[[CSC/ECE_517_Fall_2014/sample_page]]
*[[CSC/ECE_517_Fall_2014/ch1a22as]]
*[[CSC/ECE 517 Fall 2014/ch1a 19 mx]]
*[[CSC/ECE 517 Fall 2014/ch1a 3 zq]]