Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2014/oss M1456 kdv

2014-10-29T17:24:07Z

Djzager:

='''Implement MIME sniffing - spec'''=

This article is about the open source project M 1456: Implement MIME<ref>https://mimesniff.spec.whatwg.org/</ref> sniffing - spec <ref>https://github.com/servo/servo/issues/3144</ref>, which is part of the Servo Parallel Browser Project. Servo is prototype web browser engine which is currently under development and is written in [http://doc.rust-lang.org/guide.html Rust] language. Here you can find a brief Background information about MIME sniffing in servo, rust programming language, the initial step and the first step implemented in the project.

__TOC__

== '''Background Information''' ==
When we do a HTTP web request which declares the type of its content (using the Content-Type header), it's very easy to decide how to present it - if it's an image, decode it; if it's an HTML page, parse and display it. When no such header is present, Servo currently falters (such as loading an image file or video file from disk, as in [https://github.com/servo/servo/pull/3131 #3131]). In this case, we want to implement the "sniffing" specification, which looks at the starting byte content of the resource and guesses what manner of content is being received. For example, If its an image we can use image rendering and a video rendering can be used for a video file.

==='''What is Servo?'''===
Servo<ref>https://www.mozilla.org/en-US/research/projects/</ref> is an experimental browser layout engine supported by Mozilla Research. It is being actively developed in the Rust programming language with the main purpose being to rethink what the modern browser layout engine should do, how it performs, and how well it renders pages.

The use of the Rust programming language, discussed later, allows the engine to break down the problem of page layout into small isolated tasks that can be performed in parallel, for speed and efficiency, and isolated from each other. With the security features of the Rust programming language like memory safety, an important goal for the Servo project is to build on top of a solid, secure, and safe computing base

The best resource to learn more about Servo, and the Servo Project is the GitHub project page: [https://github.com/servo/servo Servo] Project.

==='''Rust Programming Language'''===
Rust<ref>https://www.mozilla.org/en-US/research/projects/</ref> is a research project supported by Mozilla Research. It is a systems programming language designed to take full advantage of modern hardware. What makes Rust special is its emphasis on security and parallelism. The language has syntax similar to C and C++, as can be seen in the snippet below.

<pre>
fn main() {
println!("hello, world");
}
</pre>

The rust programming language supports object-orientation and the language's design has refined through the development of Servo, previously mentioned. As was said previously, it is the security features that set Rust apart. First of all, Rust is designed to be memory-safe, meaning that it does not allow null or dangling pointers. Second, Rust has an ownership system existing entirely at compile time adding safety without inhibiting run time efficiency. Third, the Rust programming language assumes that things are immutable unless specifically stated otherwise. As an example, below we create a variable x and store the integer value of 5 and attempt to reassign it the integer value of 10:

<pre>
let x = 5i;
x = 10i;
</pre>

This would result in an error at compile time because you are not allowed to reassign the values of immutable variables. The beauty of this is that variables are only mutable when the programmer specifically states that they should be.

The best resource for more about the Rust programming language is the documentation: [http://doc.rust-lang.org/guide.html Rust Documentation]<ref>http://doc.rust-lang.org/guide.html</ref> or the GitHub project page: [https://github.com/rust-lang/rust Rust language].

=='''Implement MIME sniffing'''==

==='''Initial Step'''===
As part of initial step we first [https://github.com/servo/servo Build Servo]. Learned how to create tasks in Rust, then spawn a new sniffer [http://doc.rust-lang.org/guide.html#tasks task] in the load method in resource_task.rs, by creating a sender and receiver pair as well - this task would read all the available data from the new receiver, and send it immediately via the original sender, while the new sender gets handed off to the factory function that is executed. All web pages continued to load unchanged after rebuilding our code.

==='''Classes'''===
As part of OSS Servo project we worked on below Class files.

'''Modify'''
* components/net/resource_task.rs

'''Create'''
* components/net/sniffer_task.rs

'''Delete'''
* none

==='''Step 1'''===
* For every resource request (Example: file, http, data or any kind of request) in load method, it would interpose a sniffer task which sniffs all the data, parse the headers if required and return it. Below is the code snippet of the modified <code> resouce_task.rs </code> file.

<pre>
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
let mut load_data = load_data;
load_data.headers.user_agent = self.user_agent.clone();

// Create new communication channel, create new sniffer task,
// send all the data to the new sniffer task with the send
// end of the pipe, receive all the data.

let sniffer_task = sniffer_task::new_sniffer_task(start_chan.clone());

let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());

loader(load_data, sniffer_task);
}
</pre>

* The function which gets called in the load method is <code> new_sniffer_task</code>. The sniffer task creates a channel and then call <code> SnifferManager </code> which creates SnifferManager struct with channel information. <code> SnifferManager </code> waits for input on the new receiver and passes it on to the old sender, while handing off the new sender to the factory function. Below is the code snippet of the new <code>sniffer_task.rs</code> file.

<pre>
struct SnifferManager {
data_receiver: Receiver<LoadResponse>,
}

impl SnifferManager {
fn new(data_receiver: Receiver <LoadResponse>) -> SnifferManager {
SnifferManager {
data_receiver: data_receiver,
}
}
}

impl SnifferManager {
fn start(&self, next_rx: Sender<LoadResponse>) {
loop {
self.load(next_rx.clone(), self.data_receiver.recv());
}
}

fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
}

</pre>

==Design Patterns==

We used the [http://en.wikipedia.org/wiki/Command_pattern command design pattern] in our project. As Wikipedia states, command pattern is a design pattern that in which an "object is used to represent and encapsulate all the information needed to call a method at a later time". <ref name="commandDesignPatternWiki">http://en.wikipedia.org/wiki/Command_pattern</ref>.

In our specific case, the object is the Sniffer Task. A new Sniffer Task is created via the <code> new_sniffer_task</code> function. When the sniffer task is created, it is isolated and it encapsulates all the information needed to sniff the MIME data out of the URI/file. Since it's isolated, the only way to communicate between the Sniffer Task and the main servo process is by using channels and using <code>send</code> and <code>receive</code> functions to pass data around. For example, in the load function in SnifferManager in <code>sniffer_task.rs</code>, we use <code>send</code> to send the data back to the next processing pipeline.

<pre>
fn load(&self, next_rx: Sender<LoadResponse>, snif_data: LoadResponse) {
next_rx.send(snif_data);
}
</pre>

There are a few benefits that command design pattern provides. Firstly, since the code block is encapsulated, it is independent and can be modified and switched out easily. This makes maintaining the code very easy. Secondly, because the code blocks has all the resources it needs to perform it's task (in our case, sniffing the MIME), we can easily take it and run it in a different process parallel to the main servo process.

==Sniffer Task Project Build==

* After the code changes we Build servo project by running below command.

<pre> ./mach build </pre>

* Tested the code by passing html webpage request.

<pre>./mach run tests/html/about-mozilla.html </pre>

==Conclusion==
As part of OSS Servo project we have created a new <code>sniffer_task.rs</code> and modified <code>resource_task.rs</code> load method. Then created a merge request [https://github.com/servo/servo/pull/3766 M1456-Implement MIME sniffing initial Step] and got feedback from Josh were we addressed the issues. Few open issues would be addressed as part of Final OSS project.

==Future Development Scope==

==='''Step 2'''===
Move from a 1:1 sniffer:request task model to a shared sniffer task - create the sniffing task in ResourceTask::start, store the created sender in a field, and hand off clones of this sender to the factory function. The sniffer task will now also have to be sent the original sender as well, since it is not available at task creation.

==='''Step 3'''===
When the headers are received, implement the [https://mimesniff.spec.whatwg.org/#handling-a-resource sniffing heuristic algorithm].

==='''Step 4'''===
Implement the mime type matching algorithm, one category at a time - look for a good way to store the patterns and resulting types to minimize code duplication.

==='''Step 5'''===
Ensure that the resulting mime type is present in the load that the consumer receives

==='''Step 6'''===
Write tests that demonstrate working sniffing (for example, loading images with no/wrong extension)

=='''Appendix'''==
==='''Setting up Servo'''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/servo/servo Build Servo] <ref> https://github.com/servo/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2014/ch1a 7 kz

2014-09-26T00:36:00Z

Djzager: /* Background */

== Background ==
“Web2py is an open source web application framework written in the Python programming language.”<ref>[http://en.wikipedia.org/wiki/Web2py ], ''Web2py''. Retrieved 18 September 2014.</ref> Web2py originally started as an educational tool when, in October 2007, Massimo Di Pierro developed web2py as a way to introduce his students to web programming. From this, it quickly grew through user adoption to become a strong competitor to Django, another python based web framework. Web2py has design principles similar to that of other popular web application frameworks. Simply put, web2py embraces the principles of don't repeat yourself <ref name="dryWiki">[http://en.wikipedia.org/wiki/Don't_repeat_yourself],"Wikipedia entry for Don't Repeat Yourself". Retrieved 25 September 2014.</ref>, there should only be one way of doing things (form processing, managing sessions, and handling cookies), and explicit is better than implicit. <ref name="web2PyOnlineBook">[http://www.web2py.com/books/default/chapter/29/01/introduction],"Web2py's Free Online Book". Retrieved 18 September 2014.</ref> [http://www.web2py.com/book/default/chapter/01 Web2py Online Book] is an excellent start for those who wish to learn more.

Web2py is considered a full-stack framework, which simply means that the individual components of the framework were designed and built to work together. <ref name="webAppFrameworkwiki">[http://en.wikipedia.org/wiki/Web_application_framework], "Web Application Framework Wiki". Retrieved 25 September 2014.</ref> "Almost all of its components are built from scratch and are designed to work together, but they function just as well outside of the complete web2py framework. For example, the Database Abstraction Layer (DAL) or the template language can be used independently of the web2py framework by importing gluon.dal or gluon.template into your own Python applications. gluon is the name of the web2py module that contains system libraries. Some web2py libraries, such as building and processing forms from database tables, have dependencies on other portions of web2py. web2py can also work with third-party Python libraries, including other template languages and DALs, but they will not be as tightly integrated as the original components." <ref name="web2PyOnlineBook"/>

Some popular websites powered by web2py are<ref name="web2PyPoweredWebsites">[http://web2py.com/poweredby ], ''Sites Powered by Web2py''. Retrieved 25 September 2014.</ref>:
* [http://eden.sahanafoundation.org SahanaEden]
* [https://chique.pt/?lang=en CHIQUE]
* [http://campus.tableless.com.br Campus]
<div style="float: right;">
[[File:Web2pySampleWorkflow.png|frame|Fig 1: Typical workflow in web2py ]]<ref name="web2PyOnlineBook" />
</div>

== Key Features ==

==== Security ====
Web2py addresses many issues related to security vulnerabilities.
# Validates all input to prevent database injections
# Escapes all output to prevent cross-site scripting
# Renames uploaded files to prevent directory traversal attacks
By following established web security practices, web2py helps prevent some of the most popular security attack, “so developers have less chances of introducing vulnerabilities”. <ref name="web2PyOnlineBook" />

==== Database Abstraction Layer ====
Web2py includes, by default, a Database Abstraction Layer (DAL) that is capable of dynamically writing SQL for the most popular database management systems (DBMS) including, among others:
# SQLite
# MySqL
# Oracle

==== Web 2.0 ====
According to web2py’s own documentation, it is the only web framework to fully embrace the Web 2.0 paradigm. Web 2.0 describes changes to the way that web pages are created and used rather than an update to any technical specification.<ref>[http://en.wikipedia.org/wiki/Web_2.0], "Web 2.0". Retrieved 18 September 2014.</ref> Web2py accomplishes this by not requiring any installation or configuration and running on any architecture that can run python.

== Examples ==

After downloading web2py, starting the server, and navigating to http://localhost:8000 you will be greeted by web2py's default home page. An excellent feature of web2py, the admin interface (pictured below) can quickly be accessed by clicking, "administrative interface" from the default home page.

[[File:Web2py_admin_interface.png]]

=== Model Example ===
Through the use of a DAL, web2py provides for simple ways to create database tables for web applications.

<pre>
db.define_table(
'person',
Field('name'),
Field('email'),
format = '%(name)s')

# ONE (person) TO MANY (products)

db.define_table(
'product',
Field('seller_id',db.person),
Field('name'),
Field('description', 'text'),
Field('picture', 'upload', default=''),
format = '%(name)s')

# MANY (persons) TO MANY (purchases)

db.define_table(
'purchase',
Field('buyer_id', db.person),
Field('product_id', db.product),
Field('quantity', 'integer'),
format = '%(quantity)s %(product_id)s -> %(buyer_id)s')

purchased = (db.person.id==db.purchase.buyer_id)&(db.product.id==db.purchase.product_id)

db.person.name.requires = IS_NOT_EMPTY()
db.person.email.requires = [IS_EMAIL(), IS_NOT_IN_DB(db, 'person.email')]
db.product.name.requires = IS_NOT_EMPTY()
db.purchase.quantity.requires = IS_INT_IN_RANGE(0, 10)
</pre>

From web2py's online reference <ref name="web2pyExamples">[http://www.web2py.com/init/default/examples#database_examples], "Web2py Quick Examples", Retrieved 19 September 2014.</ref>
<blockquote>
Tables are created if they do not exist (try... except). Here "purchased" is an Query object, "db(purchased)" would be a Set objects. A Set object can be selected, updated, deleted. Sets can also be intersected. Allowed field types are string, integer, password, text, blob, upload, date, time, datetime, references(*), and id(*). The id field is there by default and must not be declared. references are for one to many and many to many as in the example above. For strings you should specify a length or you get length=32.

You can use db.tablename.fieldname.requires= to set restrictions on the field values. These restrictions are automatically converted into widgets when generating forms from the table with SQLFORM(db.tablename).

define_tables creates the table and attempts a migration if table has changed or if database name has changed since last time. If you know you already have the table in the database and you do not want to attempt a migration add one last argument to define_table migrate=False.
</blockquote>

=== Wiki Creation Example ===
The following example code embeds a fully working wiki.

<pre>
def index(): return auth.wiki()
</pre>

=== Authorization Example ===
The following example prevents a visitor from accessing a function unless the member has read permissions.

<pre>
@auth.requires_permission('read','person')
def f(): ....
</pre>

== Architecture ==
=== Model View Controller ===
Like most popular web frameworks, web2py uses a Model View Controller (MVC) architecture. <ref name="aboutWeb2Py">[http://www.web2py.com/init/default/what], "What is web2py?". Retrieved 18 September 2014.</ref> In an MVC architecture the user’s request goes through the controller, which requests information from the model (usually some type of database) and then passes it along to the view for renderer. This type of architecture separates the data, logic and the user interfaces into separate components, making them more modular and maintainable.

==== Model ====
In web2py, the model is the <code>db.py</code> file. This is where you define the type of database engine you are using and any table and fields. For example, if you wanted to define a <code>sqlite</code> database with a table with car make and models, you would have the following code:

<pre>
db = DAL('sqlite://production.sqlite')
db.define_table('cars',
Field('make'),
Field('model'))
</pre>

==== Controller ====
Controllers are functions that will be run when a user tries to access a certain URL. A controller can have different actions it can call. For example, if you want to define a <code>cars</code> controller that has an <code>all</code> action, your <code>cars.py</code> would look like this:

<pre>
def all():
grid=SQLFORM.grid(db.cars, user_signature=False)
return locals()
</pre>

==== View ====
The final portion of the user request pipeline is the view. When the <code>all()</code> function in <code>cars.py</code> finishes running it calls a view to render the data. In our case, since our controller is <code>car</code> and our action is <code>all</code>, the view file would be <code>cars/all.html</code> and this is how it could look like:

<pre>
<h1>Car Make and Models</h1>
{{=grid}}
</pre>

=== Portability ===
The framework itself is very portable. It can run on any operating system that supports Python which means it will work on most cloud services like Amazon EC2 and Google App Engine. It also supports numerous databases including SQLite, MySQL, MSSQL, MariaDB, Oracle etc.. <ref name="aboutWeb2Py" />. Not only that, it can speak multiple protocols like REST, XML/HTML, and JSON among others. <ref name="aboutWeb2Py" /> This is a great example of web2py’s MVC architecture coming into play. The database (model) or the protocol (view) can be switched around with very little work.

=== Components ===
<div style="float: right;">
[[File:Web2PyArchSlide.png|frame|Fig 2: Overview of the architecture of web2py]]<ref name="web2PyArchSlide">[https://dl.dropboxusercontent.com/u/18065445/Slides/PySFTalkSlides.pdf], "web2py, ideas we stole - ideas we had". Retrieved 18 September 2014.</ref>
</div>

According to the slide seen on the right, web2Py is split into a few major components. <ref name="web2PyArchSlide" />The lowest component in the python interpreter. Right above that there is a web server to serve web pages. By default, web2py comes with rocket, but it can be switched for third party web server like Apache or nginx. Running on top of that are the web2py core libraries. This contains the code that handles HTTP requests, responses, cookies, the database APIs (ORM), templating engine and other helpers. Finally, on top of that is where all the applications the developer writes will go. By default, web2py comes with a few example and admin applications, but they can be removed and new ones can be added either through the admin GUI or through the actual codebase itself.

== Comparison ==
Web2py most often gets associated with Django, another Python web framework, and Rails, a web framework based on Ruby. Web2py is heavily inspired by both of those frameworks. <ref name="aboutWeb2Py"/> Like Rails and Django, web2py also follows a MVC architecture, has a templating engine and an ORM (Object Relational Mapper). Web2py has a few unique features that it’s competitors don’t have. One of the most appealing features of web2py is that web2py “applications” can be created and imported into the server via a admin web interface. <ref name="aboutWeb2Py" /> Unlike Rails and Django, you do not have to open up a text editor and create models by hand, you can do it using a graphical interface. You can also package and download applications from the server so you can import it elsewhere. Web2py is also one of the few frameworks to properly adopt the Web 2.0 paradigm. It is also very lightweight compared to most other web frameworks that have similar feature lists.

=== Django ===
Django and web2py have a lot of things in common. Firstly, they are both Python web MVC frameworks, which means the basic flow of control is the same. A user request gets routed to the controller, which will consult the model(s) and generate some kind of output. Django is the more popular framework out of the two. A few popular sites built using Django are Mozilla, Pinterest and Instagram. <ref name="djangoWeb2PyCompare">[http://news.dice.com/2014/05/28/three-popular-python-frameworks/], "Comparing Django, TurboGears2 and Web2py". Retrieved 18 September 2014.</ref> However, Web2py supports a more variety of database engines than Django does and is a lot more lightweight to install and run. <ref name="djangoWeb2PyCompare" />

=== Rails ===
Rails and web2py both follow the MVC architectural pattern. However, Rails applications are written in Ruby and web2py applications are written in Python. One of the main advantages of web2py vs Rails is the installation process. To install Rails, you have to install Ruby, gems and other database and database plugins; installation of web2py is as easy and installing Python and unzipping a zip file. <ref name="railsVsWeb2Py">[http://www.slideshare.net/jonromero/rails-vs-web2py], "Rails vs Web2py". Retrieved 18 September 2014.</ref> Other things such as user/role support, uploading files are supported by web2py but plugins are needed for them for Rails. <ref name="railsVsWeb2Py" />

In summary, web2py has a lot of things common with other framework like Rails and Django. The syntax for the ORM and the templating might be different between the different frameworks, but they all use the MVC framework and have the same underlying concept. Where web2py really beats the other frameworks is it’s size; it’s very lightweight, but still contains all the features the other ORMs have!

== Hyperlinks to important terms ==
* [http://en.wikipedia.org/wiki/Python_(programming_language) Python]
* [http://en.wikipedia.org/wiki/Web_application_framework Web Application Framework]
* [http://en.wikipedia.org/wiki/Django_(web_framework) Django]
* [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby-On-Rails]
* [http://en.wikipedia.org/wiki/Database_abstraction_layer Database Abstraction Layer (DAL)]
* [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model-View-Controller (MVC)]
* [http://en.wikipedia.org/wiki/Database Database Management System (DBMS)]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 7 kz

2014-09-26T00:35:24Z

Djzager: /* Background */

== Background ==
“Web2py is an open source web application framework written in the Python programming language.”<ref>[http://en.wikipedia.org/wiki/Web2py ], ''Web2py''. Retrieved 18 September 2014.</ref> Web2py originally started as an educational tool when, in October 2007, Massimo Di Pierro developed web2py as a way to introduce his students to web programming. From this, it quickly grew through user adoption to become a strong competitor to Django, another python based web framework. Web2py has design principles similar to that of other popular web application frameworks. Simply put, web2py embraces the principles of don't repeat yourself <ref name="dryWiki">[http://en.wikipedia.org/wiki/Don't_repeat_yourself],"Wikipedia entry for Don't Repeat Yourself". Retrieved 25 September 2014.</ref>, there should only be one way of doing things (form processing, managing sessions, and handling cookies), and explicit is better than implicit. <ref name="web2PyOnlineBook">[http://www.web2py.com/books/default/chapter/29/01/introduction],"Web2py Online Book". Retrieved 18 September 2014.</ref> [http://www.web2py.com/book/default/chapter/01 Web2py Online Book] is an excellent start for those who wish to learn more.

Web2py is considered a full-stack framework, which simply means that the individual components of the framework were designed and built to work together. <ref name="webAppFrameworkwiki">[http://en.wikipedia.org/wiki/Web_application_framework], "Web Application Framework Wiki". Retrieved 25 September 2014.</ref> "Almost all of its components are built from scratch and are designed to work together, but they function just as well outside of the complete web2py framework. For example, the Database Abstraction Layer (DAL) or the template language can be used independently of the web2py framework by importing gluon.dal or gluon.template into your own Python applications. gluon is the name of the web2py module that contains system libraries. Some web2py libraries, such as building and processing forms from database tables, have dependencies on other portions of web2py. web2py can also work with third-party Python libraries, including other template languages and DALs, but they will not be as tightly integrated as the original components." <ref name="web2PyOnlineBook"/>

Some popular websites powered by web2py are<ref name="web2PyPoweredWebsites">[http://web2py.com/poweredby ], ''Sites Powered by Web2py''. Retrieved 25 September 2014.</ref>:
* [http://eden.sahanafoundation.org SahanaEden]
* [https://chique.pt/?lang=en CHIQUE]
* [http://campus.tableless.com.br Campus]
<div style="float: right;">
[[File:Web2pySampleWorkflow.png|frame|Fig 1: Typical workflow in web2py ]]<ref name="web2PyOnlineBook" />
</div>

== Key Features ==

==== Security ====
Web2py addresses many issues related to security vulnerabilities.
# Validates all input to prevent database injections
# Escapes all output to prevent cross-site scripting
# Renames uploaded files to prevent directory traversal attacks
By following established web security practices, web2py helps prevent some of the most popular security attack, “so developers have less chances of introducing vulnerabilities”. <ref name="web2PyOnlineBook" />

==== Database Abstraction Layer ====
Web2py includes, by default, a Database Abstraction Layer (DAL) that is capable of dynamically writing SQL for the most popular database management systems (DBMS) including, among others:
# SQLite
# MySqL
# Oracle

==== Web 2.0 ====
According to web2py’s own documentation, it is the only web framework to fully embrace the Web 2.0 paradigm. Web 2.0 describes changes to the way that web pages are created and used rather than an update to any technical specification.<ref>[http://en.wikipedia.org/wiki/Web_2.0], "Web 2.0". Retrieved 18 September 2014.</ref> Web2py accomplishes this by not requiring any installation or configuration and running on any architecture that can run python.

== Examples ==

After downloading web2py, starting the server, and navigating to http://localhost:8000 you will be greeted by web2py's default home page. An excellent feature of web2py, the admin interface (pictured below) can quickly be accessed by clicking, "administrative interface" from the default home page.

[[File:Web2py_admin_interface.png]]

=== Model Example ===
Through the use of a DAL, web2py provides for simple ways to create database tables for web applications.

<pre>
db.define_table(
'person',
Field('name'),
Field('email'),
format = '%(name)s')

# ONE (person) TO MANY (products)

db.define_table(
'product',
Field('seller_id',db.person),
Field('name'),
Field('description', 'text'),
Field('picture', 'upload', default=''),
format = '%(name)s')

# MANY (persons) TO MANY (purchases)

db.define_table(
'purchase',
Field('buyer_id', db.person),
Field('product_id', db.product),
Field('quantity', 'integer'),
format = '%(quantity)s %(product_id)s -> %(buyer_id)s')

purchased = (db.person.id==db.purchase.buyer_id)&(db.product.id==db.purchase.product_id)

db.person.name.requires = IS_NOT_EMPTY()
db.person.email.requires = [IS_EMAIL(), IS_NOT_IN_DB(db, 'person.email')]
db.product.name.requires = IS_NOT_EMPTY()
db.purchase.quantity.requires = IS_INT_IN_RANGE(0, 10)
</pre>

From web2py's online reference <ref name="web2pyExamples">[http://www.web2py.com/init/default/examples#database_examples], "Web2py Quick Examples", Retrieved 19 September 2014.</ref>
<blockquote>
Tables are created if they do not exist (try... except). Here "purchased" is an Query object, "db(purchased)" would be a Set objects. A Set object can be selected, updated, deleted. Sets can also be intersected. Allowed field types are string, integer, password, text, blob, upload, date, time, datetime, references(*), and id(*). The id field is there by default and must not be declared. references are for one to many and many to many as in the example above. For strings you should specify a length or you get length=32.

You can use db.tablename.fieldname.requires= to set restrictions on the field values. These restrictions are automatically converted into widgets when generating forms from the table with SQLFORM(db.tablename).

define_tables creates the table and attempts a migration if table has changed or if database name has changed since last time. If you know you already have the table in the database and you do not want to attempt a migration add one last argument to define_table migrate=False.
</blockquote>

=== Wiki Creation Example ===
The following example code embeds a fully working wiki.

<pre>
def index(): return auth.wiki()
</pre>

=== Authorization Example ===
The following example prevents a visitor from accessing a function unless the member has read permissions.

<pre>
@auth.requires_permission('read','person')
def f(): ....
</pre>

== Architecture ==
=== Model View Controller ===
Like most popular web frameworks, web2py uses a Model View Controller (MVC) architecture. <ref name="aboutWeb2Py">[http://www.web2py.com/init/default/what], "What is web2py?". Retrieved 18 September 2014.</ref> In an MVC architecture the user’s request goes through the controller, which requests information from the model (usually some type of database) and then passes it along to the view for renderer. This type of architecture separates the data, logic and the user interfaces into separate components, making them more modular and maintainable.

==== Model ====
In web2py, the model is the <code>db.py</code> file. This is where you define the type of database engine you are using and any table and fields. For example, if you wanted to define a <code>sqlite</code> database with a table with car make and models, you would have the following code:

<pre>
db = DAL('sqlite://production.sqlite')
db.define_table('cars',
Field('make'),
Field('model'))
</pre>

==== Controller ====
Controllers are functions that will be run when a user tries to access a certain URL. A controller can have different actions it can call. For example, if you want to define a <code>cars</code> controller that has an <code>all</code> action, your <code>cars.py</code> would look like this:

<pre>
def all():
grid=SQLFORM.grid(db.cars, user_signature=False)
return locals()
</pre>

==== View ====
The final portion of the user request pipeline is the view. When the <code>all()</code> function in <code>cars.py</code> finishes running it calls a view to render the data. In our case, since our controller is <code>car</code> and our action is <code>all</code>, the view file would be <code>cars/all.html</code> and this is how it could look like:

<pre>
<h1>Car Make and Models</h1>
{{=grid}}
</pre>

=== Portability ===
The framework itself is very portable. It can run on any operating system that supports Python which means it will work on most cloud services like Amazon EC2 and Google App Engine. It also supports numerous databases including SQLite, MySQL, MSSQL, MariaDB, Oracle etc.. <ref name="aboutWeb2Py" />. Not only that, it can speak multiple protocols like REST, XML/HTML, and JSON among others. <ref name="aboutWeb2Py" /> This is a great example of web2py’s MVC architecture coming into play. The database (model) or the protocol (view) can be switched around with very little work.

=== Components ===
<div style="float: right;">
[[File:Web2PyArchSlide.png|frame|Fig 2: Overview of the architecture of web2py]]<ref name="web2PyArchSlide">[https://dl.dropboxusercontent.com/u/18065445/Slides/PySFTalkSlides.pdf], "web2py, ideas we stole - ideas we had". Retrieved 18 September 2014.</ref>
</div>

According to the slide seen on the right, web2Py is split into a few major components. <ref name="web2PyArchSlide" />The lowest component in the python interpreter. Right above that there is a web server to serve web pages. By default, web2py comes with rocket, but it can be switched for third party web server like Apache or nginx. Running on top of that are the web2py core libraries. This contains the code that handles HTTP requests, responses, cookies, the database APIs (ORM), templating engine and other helpers. Finally, on top of that is where all the applications the developer writes will go. By default, web2py comes with a few example and admin applications, but they can be removed and new ones can be added either through the admin GUI or through the actual codebase itself.

== Comparison ==
Web2py most often gets associated with Django, another Python web framework, and Rails, a web framework based on Ruby. Web2py is heavily inspired by both of those frameworks. <ref name="aboutWeb2Py"/> Like Rails and Django, web2py also follows a MVC architecture, has a templating engine and an ORM (Object Relational Mapper). Web2py has a few unique features that it’s competitors don’t have. One of the most appealing features of web2py is that web2py “applications” can be created and imported into the server via a admin web interface. <ref name="aboutWeb2Py" /> Unlike Rails and Django, you do not have to open up a text editor and create models by hand, you can do it using a graphical interface. You can also package and download applications from the server so you can import it elsewhere. Web2py is also one of the few frameworks to properly adopt the Web 2.0 paradigm. It is also very lightweight compared to most other web frameworks that have similar feature lists.

=== Django ===
Django and web2py have a lot of things in common. Firstly, they are both Python web MVC frameworks, which means the basic flow of control is the same. A user request gets routed to the controller, which will consult the model(s) and generate some kind of output. Django is the more popular framework out of the two. A few popular sites built using Django are Mozilla, Pinterest and Instagram. <ref name="djangoWeb2PyCompare">[http://news.dice.com/2014/05/28/three-popular-python-frameworks/], "Comparing Django, TurboGears2 and Web2py". Retrieved 18 September 2014.</ref> However, Web2py supports a more variety of database engines than Django does and is a lot more lightweight to install and run. <ref name="djangoWeb2PyCompare" />

=== Rails ===
Rails and web2py both follow the MVC architectural pattern. However, Rails applications are written in Ruby and web2py applications are written in Python. One of the main advantages of web2py vs Rails is the installation process. To install Rails, you have to install Ruby, gems and other database and database plugins; installation of web2py is as easy and installing Python and unzipping a zip file. <ref name="railsVsWeb2Py">[http://www.slideshare.net/jonromero/rails-vs-web2py], "Rails vs Web2py". Retrieved 18 September 2014.</ref> Other things such as user/role support, uploading files are supported by web2py but plugins are needed for them for Rails. <ref name="railsVsWeb2Py" />

In summary, web2py has a lot of things common with other framework like Rails and Django. The syntax for the ORM and the templating might be different between the different frameworks, but they all use the MVC framework and have the same underlying concept. Where web2py really beats the other frameworks is it’s size; it’s very lightweight, but still contains all the features the other ORMs have!

== Hyperlinks to important terms ==
* [http://en.wikipedia.org/wiki/Python_(programming_language) Python]
* [http://en.wikipedia.org/wiki/Web_application_framework Web Application Framework]
* [http://en.wikipedia.org/wiki/Django_(web_framework) Django]
* [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby-On-Rails]
* [http://en.wikipedia.org/wiki/Database_abstraction_layer Database Abstraction Layer (DAL)]
* [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model-View-Controller (MVC)]
* [http://en.wikipedia.org/wiki/Database Database Management System (DBMS)]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 7 kz

2014-09-25T23:47:27Z

Djzager: /* Narration */

== Background ==
“Web2py is an open source web application framework written in the Python programming language.”<ref>[http://en.wikipedia.org/wiki/Web2py ], ''Web2py''. Retrieved 18 September 2014.</ref> Web2py originally started as an educational tool when, in October 2007, Massimo Di Pierro developed web2py as a way to introduce his students to web programming. From this, it quickly grew through user adoption to become a strong competitor to Django, another python based web framework. Web2py is described as a “full-stack framework” which means that everything to necessary to build a functioning web application is contained in the framework.<ref name="web2PyOnlineBook">[http://www.web2py.com/books/default/chapter/29/01/introduction],"Web2py Online Book". Retrieved 18 September 2014.</ref> Some popular websites powered by web2py are<ref name="web2PyPoweredWebsites">[http://web2py.com/poweredby ], ''Sites Powered by Web2py''. Retrieved 25 September 2014.</ref>:
* [http://eden.sahanafoundation.org SahanaEden]
* [https://chique.pt/?lang=en CHIQUE]
* [http://campus.tableless.com.br Campus]

<div style="float: right;">
[[File:Web2pySampleWorkflow.png|frame|Fig 1: Typical workflow in web2py ]]<ref name="web2PyOnlineBook" />
</div>

=== Key Features ===

==== Security ====
Web2py addresses many issues related to security vulnerabilities.
# Validates all input to prevent database injections
# Escapes all output to prevent cross-site scripting
# Renames uploaded files to prevent directory traversal attacks
By following established web security practices, web2py helps prevent some of the most popular security attack, “so developers have less chances of introducing vulnerabilities”. <ref name="web2PyOnlineBook" />

==== Database Abstraction Layer ====
Web2py includes, by default, a Database Abstraction Layer (DAL) that is capable of dynamically writing SQL for the most popular database management systems (DBMS) including, among others:
# SQLite
# MySqL
# Oracle

==== Web 2.0 ====
According to web2py’s own documentation, it is the only web framework to fully embrace the Web 2.0 paradigm. Web 2.0 describes changes to the way that web pages are created and used rather than an update to any technical specification.<ref>[http://en.wikipedia.org/wiki/Web_2.0], "Web 2.0". Retrieved 18 September 2014.</ref> Web2py accomplishes this by not requiring any installation or configuration and running on any architecture that can run python.

== Examples ==

After downloading web2py, starting the server, and navigating to http://localhost:8000 you will be greeted by web2py's default home page. An excellent feature of web2py, the admin interface (pictured below) can quickly be accessed by clicking, "administrative interface" from the default home page.

[[File:Web2py_admin_interface.png]]

=== Model Example ===
Through the use of a DAL, web2py provides for simple ways to create database tables for web applications.

<pre>
db.define_table(
'person',
Field('name'),
Field('email'),
format = '%(name)s')

# ONE (person) TO MANY (products)

db.define_table(
'product',
Field('seller_id',db.person),
Field('name'),
Field('description', 'text'),
Field('picture', 'upload', default=''),
format = '%(name)s')

# MANY (persons) TO MANY (purchases)

db.define_table(
'purchase',
Field('buyer_id', db.person),
Field('product_id', db.product),
Field('quantity', 'integer'),
format = '%(quantity)s %(product_id)s -> %(buyer_id)s')

purchased = (db.person.id==db.purchase.buyer_id)&(db.product.id==db.purchase.product_id)

db.person.name.requires = IS_NOT_EMPTY()
db.person.email.requires = [IS_EMAIL(), IS_NOT_IN_DB(db, 'person.email')]
db.product.name.requires = IS_NOT_EMPTY()
db.purchase.quantity.requires = IS_INT_IN_RANGE(0, 10)
</pre>

From web2py's online reference <ref name="web2pyExamples">[http://www.web2py.com/init/default/examples#database_examples], "Web2py Quick Examples", Retrieved 19 September 2014.</ref>
<blockquote>
Tables are created if they do not exist (try... except). Here "purchased" is an Query object, "db(purchased)" would be a Set objects. A Set object can be selected, updated, deleted. Sets can also be intersected. Allowed field types are string, integer, password, text, blob, upload, date, time, datetime, references(*), and id(*). The id field is there by default and must not be declared. references are for one to many and many to many as in the example above. For strings you should specify a length or you get length=32.

You can use db.tablename.fieldname.requires= to set restrictions on the field values. These restrictions are automatically converted into widgets when generating forms from the table with SQLFORM(db.tablename).

define_tables creates the table and attempts a migration if table has changed or if database name has changed since last time. If you know you already have the table in the database and you do not want to attempt a migration add one last argument to define_table migrate=False.
</blockquote>

=== Wiki Creation Example ===
The following example code embeds a fully working wiki.

<pre>
def index(): return auth.wiki()
</pre>

=== Authorization Example ===
The following example prevents a visitor from accessing a function unless the member has read permissions.

<pre>
@auth.requires_permission('read','person')
def f(): ....
</pre>

== Architecture ==
Like most popular web frameworks, web2py uses a Model View Controller (MVC) architecture. <ref name="aboutWeb2Py">[http://www.web2py.com/init/default/what], "What is web2py?". Retrieved 18 September 2014.</ref> In an MVC architecture the user’s request goes through the controller, which requests information from the model (usually some type of database) and then passes it along to the view for renderer. This type of architecture separates the data, logic and the user interfaces into separate components, making them more modular and maintainable.

The framework itself is very portable. It can run on any operating system that supports Python which means it will work on most cloud services like Amazon EC2 and Google App Engine. It also supports numerous databases including SQLite, MySQL, MSSQL, MariaDB, Oracle etc.. <ref name="aboutWeb2Py" />. Not only that, it can speak multiple protocols like REST, XML/HTML, and JSON among others. <ref name="aboutWeb2Py" /> This is a great example of web2py’s MVC architecture coming into play. The database (model) or the protocol (view) can be switched around with very little work.

<div style="float: right;">
[[File:Web2PyArchSlide.png|frame|Fig 2: Overview of the architecture of web2py]]<ref name="web2PyArchSlide">[https://dl.dropboxusercontent.com/u/18065445/Slides/PySFTalkSlides.pdf], "web2py, ideas we stole - ideas we had". Retrieved 18 September 2014.</ref>
</div>

According to the slide seen on the right, web2Py is split into a few major components. <ref name="web2PyArchSlide" />The lowest component in the python interpreter. Right above that there is a web server to serve web pages. By default, web2py comes with rocket, but it can be switched for third party web server like Apache or nginx. Running on top of that are the web2py core libraries. This contains the code that handles HTTP requests, responses, cookies, the database APIs (ORM), templating engine and other helpers. Finally, on top of that is where all the applications the developer writes will go. By default, web2py comes with a few example and admin applications, but they can be removed and new ones can be added either through the admin GUI or through the actual codebase itself.

== Comparison ==
Web2py most often gets associated with Django, another Python web framework, and Rails, a web framework based on Ruby. Web2py is heavily inspired by both of those frameworks. <ref name="aboutWeb2Py"/> Like Rails and Django, web2py also follows a MVC architecture, has a templating engine and an ORM (Object Relational Mapper). Web2py has a few unique features that it’s competitors don’t have. One of the most appealing features of web2py is that web2py “applications” can be created and imported into the server via a admin web interface. <ref name="aboutWeb2Py" /> Unlike Rails and Django, you do not have to open up a text editor and create models by hand, you can do it using a graphical interface. You can also package and download applications from the server so you can import it elsewhere. Web2py is also one of the few frameworks to properly adopt the Web 2.0 paradigm. It is also very lightweight compared to most other web frameworks that have similar feature lists.

=== Django ===
Django and web2py have a lot of things in common. Firstly, they are both Python web MVC frameworks, which means the basic flow of control is the same. A user request gets routed to the controller, which will consult the model(s) and generate some kind of output. Django is the more popular framework out of the two. A few popular sites built using Django are Mozilla, Pinterest and Instagram. <ref name="djangoWeb2PyCompare">[http://news.dice.com/2014/05/28/three-popular-python-frameworks/], "Comparing Django, TurboGears2 and Web2py". Retrieved 18 September 2014.</ref> However, Web2py supports a more variety of database engines than Django does and is a lot more lightweight to install and run. <ref name="djangoWeb2PyCompare" />

=== Rails ===
Rails and web2py both follow the MVC architectural pattern. However, Rails applications are written in Ruby and web2py applications are written in Python. One of the main advantages of web2py vs Rails is the installation process. To install Rails, you have to install Ruby, gems and other database and database plugins; installation of web2py is as easy and installing Python and unzipping a zip file. <ref name="railsVsWeb2Py">[http://www.slideshare.net/jonromero/rails-vs-web2py], "Rails vs Web2py". Retrieved 18 September 2014.</ref> Other things such as user/role support, uploading files are supported by web2py but plugins are needed for them for Rails. <ref name="railsVsWeb2Py" />

In summary, web2py has a lot of things common with other framework like Rails and Django. The syntax for the ORM and the templating might be different between the different frameworks, but they all use the MVC framework and have the same underlying concept. Where web2py really beats the other frameworks is it’s size; it’s very lightweight, but still contains all the features the other ORMs have!

== Hyperlinks to important terms ==
* [http://en.wikipedia.org/wiki/Python_(programming_language) Python]
* [http://en.wikipedia.org/wiki/Web_application_framework Web Application Framework]
* [http://en.wikipedia.org/wiki/Django_(web_framework) Django]
* [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby-On-Rails]
* [http://en.wikipedia.org/wiki/Database_abstraction_layer Database Abstraction Layer (DAL)]
* [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model-View-Controller (MVC)]
* [http://en.wikipedia.org/wiki/Database Database Management System (DBMS)]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 7 kz

2014-09-19T20:45:25Z

Djzager: /* Examples */

== Background ==
“Web2py is an open source web application framework written in the Python programming language.”<ref>[http://en.wikipedia.org/wiki/Web2py ], ''Web2py''. Retrieved 18 September 2014.</ref> Web2py originally started as an educational tool when, in October 2007, Massimo Di Pierro developed web2py as a way to introduce his students to web programming. From this, it quickly grew through user adoption to become a strong competitor to Django, another python based web framework. Web2py is described as a “full-stack framework” which means that everything to necessary to build a functioning web application is contained in the framework.<ref name="web2PyOnlineBook">[http://www.web2py.com/books/default/chapter/29/01/introduction],"Web2py Online Book". Retrieved 18 September 2014.</ref>

<div style="float: right;">
[[File:Web2pySampleWorkflow.png|frame|Fig 1: Typical workflow in web2py ]]<ref name="web2PyOnlineBook" />
</div>

=== Key Features ===

==== Security ====
Web2py addresses many issues related to security vulnerabilities.
# Validates all input to prevent database injections
# Escapes all output to prevent cross-site scripting
# Renames uploaded files to prevent directory traversal attacks
By following established web security practices, web2py helps prevent some of the most popular security attack, “so developers have less chances of introducing vulnerabilities”. <ref name="web2PyOnlineBook" />

==== Database Abstraction Layer ====
Web2py includes, by default, a Database Abstraction Layer (DAL) that is capable of dynamically writing SQL for the most popular database management systems (DBMS) including, among others:
# SQLite
# MySqL
# Oracle

==== Web 2.0 ====
According to web2py’s own documentation, it is the only web framework to fully embrace the Web 2.0 paradigm. Web 2.0 describes changes to the way that web pages are created and used rather than an update to any technical specification.<ref>[http://en.wikipedia.org/wiki/Web_2.0], "Web 2.0". Retrieved 18 September 2014.</ref> Web2py accomplishes this by not requiring any installation or configuration and running on any architecture that can run python.

== Examples ==

After downloading web2py, starting the server, and navigating to http://localhost:8000 you will be greeted by web2py's default home page. An excellent feature of web2py, the admin interface (pictured below) can quickly be accessed by clicking, "administrative interface" from the default home page.

[[File:Web2py_admin_interface.png]]

=== Model Example ===
Through the use of a DAL, web2py provides for simple ways to create database tables for web applications.

<pre>
db.define_table(
'person',
Field('name'),
Field('email'),
format = '%(name)s')

# ONE (person) TO MANY (products)

db.define_table(
'product',
Field('seller_id',db.person),
Field('name'),
Field('description', 'text'),
Field('picture', 'upload', default=''),
format = '%(name)s')

# MANY (persons) TO MANY (purchases)

db.define_table(
'purchase',
Field('buyer_id', db.person),
Field('product_id', db.product),
Field('quantity', 'integer'),
format = '%(quantity)s %(product_id)s -> %(buyer_id)s')

purchased = (db.person.id==db.purchase.buyer_id)&(db.product.id==db.purchase.product_id)

db.person.name.requires = IS_NOT_EMPTY()
db.person.email.requires = [IS_EMAIL(), IS_NOT_IN_DB(db, 'person.email')]
db.product.name.requires = IS_NOT_EMPTY()
db.purchase.quantity.requires = IS_INT_IN_RANGE(0, 10)
</pre>

From web2py's online reference <ref name="web2pyExamples">[http://www.web2py.com/init/default/examples#database_examples], "Web2py Quick Examples", Retrieved 19 September 2014.</ref>
<blockquote>
Tables are created if they do not exist (try... except). Here "purchased" is an Query object, "db(purchased)" would be a Set objects. A Set object can be selected, updated, deleted. Sets can also be intersected. Allowed field types are string, integer, password, text, blob, upload, date, time, datetime, references(*), and id(*). The id field is there by default and must not be declared. references are for one to many and many to many as in the example above. For strings you should specify a length or you get length=32.

You can use db.tablename.fieldname.requires= to set restrictions on the field values. These restrictions are automatically converted into widgets when generating forms from the table with SQLFORM(db.tablename).

define_tables creates the table and attempts a migration if table has changed or if database name has changed since last time. If you know you already have the table in the database and you do not want to attempt a migration add one last argument to define_table migrate=False.
</blockquote>

=== Wiki Creation Example ===
The following example code embeds a fully working wiki.

<pre>
def index(): return auth.wiki()
</pre>

=== Authorization Example ===
The following example prevents a visitor from accessing a function unless the member has read permissions.

<pre>
@auth.requires_permission('read','person')
def f(): ....
</pre>

== Narration ==
=== Architecture ===
Like most popular web frameworks, web2py uses a Model View Controller (MVC) architecture. <ref name="aboutWeb2Py">[http://www.web2py.com/init/default/what], "What is web2py?". Retrieved 18 September 2014.</ref> In an MVC architecture the user’s request goes through the controller, which requests information from the model (usually some type of database) and then passes it along to the view for renderer. This type of architecture separates the data, logic and the user interfaces into separate components, making them more modular and maintainable.

The framework itself is very portable. It can run on any operating system that supports Python which means it will work on most cloud services like Amazon EC2 and Google App Engine. It also supports numerous databases including SQLite, MySQL, MSSQL, MariaDB, Oracle etc.. <ref name="aboutWeb2Py" />. Not only that, it can speak multiple protocols like REST, XML/HTML, and JSON among others. <ref name="aboutWeb2Py" /> This is a great example of web2py’s MVC architecture coming into play. The database (model) or the protocol (view) can be switched around with very little work.

<div style="float: right;">
[[File:Web2PyArchSlide.png|frame|Fig 2: Overview of the architecture of web2py]]<ref name="web2PyArchSlide">[https://dl.dropboxusercontent.com/u/18065445/Slides/PySFTalkSlides.pdf], "web2py, ideas we stole - ideas we had". Retrieved 18 September 2014.</ref>
</div>

According to the slide seen on the right, web2Py is split into a few major components. <ref name="web2PyArchSlide" />The lowest component in the python interpreter. Right above that there is a web server to serve web pages. By default, web2py comes with rocket, but it can be switched for third party web server like Apache or nginx. Running on top of that are the web2py core libraries. This contains the code that handles HTTP requests, responses, cookies, the database APIs (ORM), templating engine and other helpers. Finally, on top of that is where all the applications the developer writes will go. By default, web2py comes with a few example and admin applications, but they can be removed and new ones can be added either through the admin GUI or through the actual codebase itself.

=== Comparison ===
Web2py most often gets associated with Django, another Python web framework, and Rails, a web framework based on Ruby. Web2py is heavily inspired by both of those frameworks. [x] Like Rails and Django, web2py also follows a MVC architecture, has a templating engine and an ORM (Object Relational Mapper). Web2py has a few unique features that it’s competitors don’t have. One of the most appealing features of web2py is that web2py “applications” can be created and imported into the server via a admin web interface. [x] Unlike Rails and Django, you do not have to open up a text editor and create models by hand, you can do it using a graphical interface. You can also package and download applications from the server so you can import it elsewhere. Web2py is also one of the few frameworks to properly adopt the Web 2.0 paradigm. It is also very lightweight compared to most other web frameworks that have similar feature lists.

==== Django ====
Django and web2py have a lot of things in common. Firstly, they are both Python web MVC frameworks, which means the basic flow of control is the same. A user request gets routed to the controller, which will consult the model(s) and generate some kind of output. Django is the more popular framework out of the two. A few popular sites built using Django are Mozilla, Pinterest and Instagram. <ref name="djangoWeb2PyCompare">[http://news.dice.com/2014/05/28/three-popular-python-frameworks/], "Comparing Django, TurboGears2 and Web2py". Retrieved 18 September 2014.</ref> However, Web2py supports a more variety of database engines than Django does and is a lot more lightweight to install and run. <ref name="djangoWeb2PyCompare" />

==== Rails ====
Rails and web2py both follow the MVC architectural pattern. However, Rails applications are written in Ruby and web2py applications are written in Python. One of the main advantages of web2py vs Rails is the installation process. To install Rails, you have to install Ruby, gems and other database and database plugins; installation of web2py is as easy and installing Python and unzipping a zip file. <ref name="railsVsWeb2Py">[http://www.slideshare.net/jonromero/rails-vs-web2py], "Rails vs Web2py". Retrieved 18 September 2014.</ref> Other things such as user/role support, uploading files are supported by web2py but plugins are needed for them for Rails. <ref name="railsVsWeb2Py" />

In summary, web2py has a lot of things common with other framework like Rails and Django. The syntax for the ORM and the templating might be different between the different frameworks, but they all use the MVC framework and have the same underlying concept. Where web2py really beats the other frameworks is it’s size; it’s very lightweight, but still contains all the features the other ORMs have!

== Hyperlinks to important terms ==
* [http://en.wikipedia.org/wiki/Python_(programming_language) Python]
* [http://en.wikipedia.org/wiki/Web_application_framework Web Application Framework]
* [http://en.wikipedia.org/wiki/Django_(web_framework) Django]
* [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby-On-Rails]
* [http://en.wikipedia.org/wiki/Database_abstraction_layer Database Abstraction Layer (DAL)]
* [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model-View-Controller (MVC)]
* [http://en.wikipedia.org/wiki/Database Database Management System (DBMS)]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 7 kz

2014-09-19T20:44:00Z

Djzager: /* Examples */

== Background ==
“Web2py is an open source web application framework written in the Python programming language.”<ref>[http://en.wikipedia.org/wiki/Web2py ], ''Web2py''. Retrieved 18 September 2014.</ref> Web2py originally started as an educational tool when, in October 2007, Massimo Di Pierro developed web2py as a way to introduce his students to web programming. From this, it quickly grew through user adoption to become a strong competitor to Django, another python based web framework. Web2py is described as a “full-stack framework” which means that everything to necessary to build a functioning web application is contained in the framework.<ref name="web2PyOnlineBook">[http://www.web2py.com/books/default/chapter/29/01/introduction],"Web2py Online Book". Retrieved 18 September 2014.</ref>

<div style="float: right;">
[[File:Web2pySampleWorkflow.png|frame|Fig 1: Typical workflow in web2py ]]<ref name="web2PyOnlineBook" />
</div>

=== Key Features ===

==== Security ====
Web2py addresses many issues related to security vulnerabilities.
# Validates all input to prevent database injections
# Escapes all output to prevent cross-site scripting
# Renames uploaded files to prevent directory traversal attacks
By following established web security practices, web2py helps prevent some of the most popular security attack, “so developers have less chances of introducing vulnerabilities”. <ref name="web2PyOnlineBook" />

==== Database Abstraction Layer ====
Web2py includes, by default, a Database Abstraction Layer (DAL) that is capable of dynamically writing SQL for the most popular database management systems (DBMS) including, among others:
# SQLite
# MySqL
# Oracle

==== Web 2.0 ====
According to web2py’s own documentation, it is the only web framework to fully embrace the Web 2.0 paradigm. Web 2.0 describes changes to the way that web pages are created and used rather than an update to any technical specification.<ref>[http://en.wikipedia.org/wiki/Web_2.0], "Web 2.0". Retrieved 18 September 2014.</ref> Web2py accomplishes this by not requiring any installation or configuration and running on any architecture that can run python.

== Examples ==

After downloading web2py, starting the server, and navigating to http://localhost:8000 you will be greeted by web2py's default home page. An excellent feature of web2py, the admin interface (pictured below) can quickly be accessed by clicking, "administrative interface" from the default home page.

[[File:Web2py_admin_interface.png]]

Through the use of a DAL, web2py provides for simple ways to create database tables for web applications.

<pre>
db.define_table(
'person',
Field('name'),
Field('email'),
format = '%(name)s')

# ONE (person) TO MANY (products)

db.define_table(
'product',
Field('seller_id',db.person),
Field('name'),
Field('description', 'text'),
Field('picture', 'upload', default=''),
format = '%(name)s')

# MANY (persons) TO MANY (purchases)

db.define_table(
'purchase',
Field('buyer_id', db.person),
Field('product_id', db.product),
Field('quantity', 'integer'),
format = '%(quantity)s %(product_id)s -> %(buyer_id)s')

purchased = (db.person.id==db.purchase.buyer_id)&(db.product.id==db.purchase.product_id)

db.person.name.requires = IS_NOT_EMPTY()
db.person.email.requires = [IS_EMAIL(), IS_NOT_IN_DB(db, 'person.email')]
db.product.name.requires = IS_NOT_EMPTY()
db.purchase.quantity.requires = IS_INT_IN_RANGE(0, 10)
</pre>

From web2py's online reference <ref name="web2pyExamples">[http://www.web2py.com/init/default/examples#database_examples], "Web2py Quick Examples", Retrieved 19 September 2014.</ref>
<blockquote>
Tables are created if they do not exist (try... except). Here "purchased" is an Query object, "db(purchased)" would be a Set objects. A Set object can be selected, updated, deleted. Sets can also be intersected. Allowed field types are string, integer, password, text, blob, upload, date, time, datetime, references(*), and id(*). The id field is there by default and must not be declared. references are for one to many and many to many as in the example above. For strings you should specify a length or you get length=32.

You can use db.tablename.fieldname.requires= to set restrictions on the field values. These restrictions are automatically converted into widgets when generating forms from the table with SQLFORM(db.tablename).

define_tables creates the table and attempts a migration if table has changed or if database name has changed since last time. If you know you already have the table in the database and you do not want to attempt a migration add one last argument to define_table migrate=False.
</blockquote>
The following example code embeds a fully working wiki.

<pre>
def index(): return auth.wiki()
</pre>

The following example prevents a visitor from accessing a function unless the member has read permissions.

<pre>
@auth.requires_permission('read','person')
def f(): ....
</pre>

== Narration ==
=== Architecture ===
Like most popular web frameworks, web2py uses a Model View Controller (MVC) architecture. <ref name="aboutWeb2Py">[http://www.web2py.com/init/default/what], "What is web2py?". Retrieved 18 September 2014.</ref> In an MVC architecture the user’s request goes through the controller, which requests information from the model (usually some type of database) and then passes it along to the view for renderer. This type of architecture separates the data, logic and the user interfaces into separate components, making them more modular and maintainable.

The framework itself is very portable. It can run on any operating system that supports Python which means it will work on most cloud services like Amazon EC2 and Google App Engine. It also supports numerous databases including SQLite, MySQL, MSSQL, MariaDB, Oracle etc.. <ref name="aboutWeb2Py" />. Not only that, it can speak multiple protocols like REST, XML/HTML, and JSON among others. <ref name="aboutWeb2Py" /> This is a great example of web2py’s MVC architecture coming into play. The database (model) or the protocol (view) can be switched around with very little work.

<div style="float: right;">
[[File:Web2PyArchSlide.png|frame|Fig 2: Overview of the architecture of web2py]]<ref name="web2PyArchSlide">[https://dl.dropboxusercontent.com/u/18065445/Slides/PySFTalkSlides.pdf], "web2py, ideas we stole - ideas we had". Retrieved 18 September 2014.</ref>
</div>

According to the slide seen on the right, web2Py is split into a few major components. <ref name="web2PyArchSlide" />The lowest component in the python interpreter. Right above that there is a web server to serve web pages. By default, web2py comes with rocket, but it can be switched for third party web server like Apache or nginx. Running on top of that are the web2py core libraries. This contains the code that handles HTTP requests, responses, cookies, the database APIs (ORM), templating engine and other helpers. Finally, on top of that is where all the applications the developer writes will go. By default, web2py comes with a few example and admin applications, but they can be removed and new ones can be added either through the admin GUI or through the actual codebase itself.

=== Comparison ===
Web2py most often gets associated with Django, another Python web framework, and Rails, a web framework based on Ruby. Web2py is heavily inspired by both of those frameworks. [x] Like Rails and Django, web2py also follows a MVC architecture, has a templating engine and an ORM (Object Relational Mapper). Web2py has a few unique features that it’s competitors don’t have. One of the most appealing features of web2py is that web2py “applications” can be created and imported into the server via a admin web interface. [x] Unlike Rails and Django, you do not have to open up a text editor and create models by hand, you can do it using a graphical interface. You can also package and download applications from the server so you can import it elsewhere. Web2py is also one of the few frameworks to properly adopt the Web 2.0 paradigm. It is also very lightweight compared to most other web frameworks that have similar feature lists.

==== Django ====
Django and web2py have a lot of things in common. Firstly, they are both Python web MVC frameworks, which means the basic flow of control is the same. A user request gets routed to the controller, which will consult the model(s) and generate some kind of output. Django is the more popular framework out of the two. A few popular sites built using Django are Mozilla, Pinterest and Instagram. <ref name="djangoWeb2PyCompare">[http://news.dice.com/2014/05/28/three-popular-python-frameworks/], "Comparing Django, TurboGears2 and Web2py". Retrieved 18 September 2014.</ref> However, Web2py supports a more variety of database engines than Django does and is a lot more lightweight to install and run. <ref name="djangoWeb2PyCompare" />

==== Rails ====
Rails and web2py both follow the MVC architectural pattern. However, Rails applications are written in Ruby and web2py applications are written in Python. One of the main advantages of web2py vs Rails is the installation process. To install Rails, you have to install Ruby, gems and other database and database plugins; installation of web2py is as easy and installing Python and unzipping a zip file. <ref name="railsVsWeb2Py">[http://www.slideshare.net/jonromero/rails-vs-web2py], "Rails vs Web2py". Retrieved 18 September 2014.</ref> Other things such as user/role support, uploading files are supported by web2py but plugins are needed for them for Rails. <ref name="railsVsWeb2Py" />

In summary, web2py has a lot of things common with other framework like Rails and Django. The syntax for the ORM and the templating might be different between the different frameworks, but they all use the MVC framework and have the same underlying concept. Where web2py really beats the other frameworks is it’s size; it’s very lightweight, but still contains all the features the other ORMs have!

== Hyperlinks to important terms ==
* [http://en.wikipedia.org/wiki/Python_(programming_language) Python]
* [http://en.wikipedia.org/wiki/Web_application_framework Web Application Framework]
* [http://en.wikipedia.org/wiki/Django_(web_framework) Django]
* [http://en.wikipedia.org/wiki/Ruby_on_Rails Ruby-On-Rails]
* [http://en.wikipedia.org/wiki/Database_abstraction_layer Database Abstraction Layer (DAL)]
* [http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller Model-View-Controller (MVC)]
* [http://en.wikipedia.org/wiki/Database Database Management System (DBMS)]

== References ==
<references/>

CSC/ECE 517 Fall 2014/ch1a 7 kz

2014-09-19T20:38:43Z

Djzager: /* Examples */

CSC/ECE 517 Fall 2014/ch1a 7 kz

2014-09-19T20:38:13Z

Djzager: /* Examples */

File:Web2py admin interface.png

2014-09-19T20:35:52Z

Djzager:

File:En500.png

2014-09-19T20:30:05Z

Djzager: Welcome page for web2py

Welcome page for web2py

CSC/ECE 517 Fall 2014/ch1a 7 kz

2014-09-19T20:22:13Z