Master the Art of Web Development with Tornado: A Comprehensive Guide
Python is one of the most popular programming languages in the world. Known for its simplicity and readability, it has become a preferred choice for web development. When it comes to building web applications with Python, Tornado is a powerful framework that allows developers to create scalable and high-performance applications. In this comprehensive guide, we will explore the ins and outs of Tornado and master the art of web development with it.
What is Tornado?
Tornado is an open-source web framework and asynchronous networking library for Python. It was developed by FriendFeed, a social media start-up that was later acquired by Facebook. Tornado is known for its high-performance capabilities and ability to handle a large number of simultaneous connections. It is often used for building real-time web applications, such as chat apps, game servers, and streaming services.
Why Tornado?
There are several reasons why Tornado is a popular choice for web development:
Asynchronous and Non-blocking
Tornado is built on top of an asynchronous networking library, which allows it to handle thousands of simultaneous connections with low memory usage. This makes it a great choice for building real-time applications that require high performance and responsiveness.
Scalability
With built-in support for non-blocking I/O, Tornado can scale horizontally to handle large numbers of concurrent requests. It can handle more than 10,000 simultaneous connections on a single server, making it suitable for high-traffic applications.
Simplicity
Tornado follows the “batteries included” philosophy of Python, providing a simple and straightforward API for building web applications. It has a small codebase and a minimalistic design, making it easy to understand and use.
Websockets and Long-polling
Tornado has built-in support for WebSockets and long-polling, making it ideal for building real-time web applications. It allows bi-directional communication between the server and the client, enabling the creation of interactive and dynamic web interfaces.
Community and Ecosystem
Tornado has a supportive community and an active ecosystem with a wide range of third-party libraries and extensions. It is well-documented and has a large user base, which means you can easily find help and resources when working with Tornado.
Getting Started with Tornado
Before diving into Tornado, you need to have a basic understanding of Python and web development concepts. Familiarize yourself with concepts such as HTTP, request/response cycle, and MVC architecture. Once you have a good grasp of these concepts, you can start exploring Tornado.
The first step is to install Tornado. You can install it using pip, the Python package manager. Open your terminal or command prompt and run the following command:
pip install tornado
Once Tornado is installed, you can start building your first Tornado application. Let’s create a simple “Hello, World!” application to get started.
Hello, World!
Create a new Python file called hello.py and open it in your text editor. Add the following code:
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Hello, World!")
def make_app():
return tornado.web.Application([(r"/", MainHandler),])
if __name__ == "__main__":
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
In this code, we import the necessary modules from the Tornado library, define a request handler class called MainHandler, and create a Tornado application using the make_app function. We then start the Tornado server on port 8888 using the listen method and start the event loop using the IOLoop class.
To run the Tornado server, open your terminal or command prompt, navigate to the directory where hello.py is located, and run the following command:
python hello.py
You should see the following output:
Starting server at http://localhost:8888
Now open your web browser and visit http://localhost:8888. You should see the “Hello, World!” message displayed on the webpage. Congratulations! You have built your first Tornado application.
Handling Requests
In Tornado, request handlers are used to handle incoming requests and generate responses. Let’s modify our “Hello, World!” application to handle different URLs and HTTP methods.
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Hello, World!")
class AboutHandler(tornado.web.RequestHandler):
def get(self):
self.write("This is the About page.")
class ContactHandler(tornado.web.RequestHandler):
def get(self):
self.write("Contact us at [email protected]")
def make_app():
return tornado.web.Application([
(r"/", MainHandler),
(r"/about", AboutHandler),
(r"/contact", ContactHandler),
])
if __name__ == "__main__":
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
In this code, we define three different request handlers: MainHandler, AboutHandler, and ContactHandler. Each handler class extends the tornado.web.RequestHandler class and overrides the get method to generate the appropriate response.
The URL patterns and their corresponding handlers are defined in the make_app function. We use regular expressions to match the URLs. For example, (r"/about", AboutHandler) matches the URL /about and maps it to the AboutHandler class.
Restart the Tornado server and visit the following URLs to see the corresponding responses:
http://localhost:8888– “Hello, World!”http://localhost:8888/about– “This is the About page.”http://localhost:8888/contact– “Contact us at [email protected]”
By defining different request handlers and mapping them to different URLs, you can easily handle different types of requests in your Tornado application.
Templates and Static Files
Tornado allows you to use templates to generate dynamic HTML content. Templates are separate files that contain a mixture of HTML and placeholders for dynamic content. Tornado uses the popular Jinja2 template engine by default, but you can also use other template engines if you prefer.
Let’s create a simple template to display a list of items. Create a new directory called templates in the same directory as your Tornado application. Inside the templates directory, create a new file called index.html and add the following code:
<html>
<head>
<title>My Items</title>
</head>
<body>
<h1>My Item List</h1>
<ul>
{% for item in items %}
<li>{{ item }}</li>
{% endfor %}
</ul>
</body>
</html>
In this code, we use the template tags {% ... %} to denote control structures and {{ ... }} to output values. We define a for loop to iterate over a list of items and display them in an unordered list (<ul>). The value of each item is inserted using the {{ item }} placeholder.
To render this template in our Tornado application, we need to modify the MainHandler class:
import tornado.ioloop
import tornado.web
import os
class MainHandler(tornado.web.RequestHandler):
def get(self):
items = ["Item 1", "Item 2", "Item 3"]
self.render("index.html", items=items)
def make_app():
return tornado.web.Application([
(r"/", MainHandler),
], template_path=os.path.join(os.path.dirname(__file__), "templates"))
if __name__ == "__main__":
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
In this code, we define a list of items in the MainHandler class and pass it to the render method along with the template filename. The render method takes care of rendering the template and generating the final HTML output.
Restart the Tornado server and visit http://localhost:8888. You should see the list of items displayed on the webpage. By using templates, you can separate the presentation logic from the application logic, making your code more maintainable and easier to read.
In addition to templates, Tornado also supports serving static files, such as CSS, JavaScript, and images. Create a new directory called static in the same directory as your Tornado application. Inside the static directory, add your static files.
To serve static files in Tornado, you need to modify the make_app function:
import tornado.ioloop
import tornado.web
import os
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.render("index.html")
def make_app():
return tornado.web.Application([
(r"/", MainHandler),
],
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static")
)
if __name__ == "__main__":
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
In this code, we add the static_path parameter to the Application constructor and specify the path to the static directory. Tornado will automatically serve static files from this directory.
Restart the Tornado server and visit http://localhost:8888/static/style.css. If you have a CSS file called style.css inside the static directory, you should see the CSS rules being applied to the webpage. Similarly, you can reference other static files (e.g., JavaScript files, images) in your HTML templates.
Asynchronous and Non-blocking Operations
One of the key features of Tornado is its ability to handle asynchronous and non-blocking operations. By default, Tornado runs in a single-threaded event loop, allowing it to handle multiple connections simultaneously without blocking the execution of other code.
Let’s take a look at a simple example of making an asynchronous HTTP request using the tornado.httpclient module:
import tornado.ioloop
import tornado.web
import tornado.httpclient
class MainHandler(tornado.web.RequestHandler):
async def get(self):
http_client = tornado.httpclient.AsyncHTTPClient()
response = await http_client.fetch("https://www.example.com")
self.write(response.body)
def make_app():
return tornado.web.Application([
(r"/", MainHandler),
])
if __name__ == "__main__":
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
In this code, we import the tornado.httpclient module, which provides a non-blocking HTTP client. In the MainHandler class, we define an async version of the get method and use the tornado.httpclient.AsyncHTTPClient class to make an asynchronous HTTP request to https://www.example.com. We then write the response body to the client.
Tornado uses coroutines and the await keyword to simplify asynchronous programming. The await keyword allows us to wait for an asynchronous operation to complete without blocking the event loop. This allows us to write asynchronous code that looks and behaves like synchronous code.
By using asynchronous and non-blocking operations, you can enhance the performance and scalability of your Tornado applications, especially when dealing with I/O-bound tasks, such as network requests and database queries.
Advanced Topics in Tornado
Tornado offers many advanced features and capabilities for building web applications. In this section, we will explore some of these topics.
Tornado and Authentication
Authentication is an essential aspect of web applications. Tornado provides built-in support for various authentication mechanisms.
Let’s take a look at an example of implementing basic HTTP authentication in Tornado:
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get_current_user(self):
return self.get_secure_cookie("user")
def get(self):
user = self.current_user
if user:
self.write("Hello, {}".format(user))
else:
self.set_status(401)
self.set_header("WWW-Authenticate", "Basic realm=Login")
self.write("Authentication Required")
def make_app():
return tornado.web.Application([
(r"/", MainHandler),
],
cookie_secret="my_secret_key")
if __name__ == "__main__":
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
In this code, we define a MainHandler class that extends the tornado.web.RequestHandler class. We override the get_current_user method to retrieve the current user from the secure cookie. This method is called automatically by Tornado to get the authenticated user.
In the get method, we check if the user is authenticated by calling self.current_user. If the user is authenticated, we display a personalized greeting. If the user is not authenticated, we set the response status to 401 (Unauthorized) and set the WWW-Authenticate header to indicate that the client needs to provide credentials.
To enable secure cookies in Tornado, we need to set the cookie_secret parameter in the Application constructor. The cookie_secret is used to sign the cookies and prevent tampering.
Restart the Tornado server and visit http://localhost:8888. You will see the “Authentication Required” message. Tornado will prompt you to enter your credentials. Enter any username and password, and you should see the personalized greeting for that user.
Tornado supports other authentication mechanisms, such as OAuth, token-based authentication, and third-party authentication providers. You can choose the authentication mechanism that fits your requirements and integrate it into your Tornado applications.
Tornado and Database Access
Web applications often require interactions with databases to store and retrieve data. Tornado provides support for various database systems, including MySQL, PostgreSQL, and SQLite.
Let’s take a look at an example of accessing a MySQL database in Tornado:
import tornado.ioloop
import tornado.web
import tornado.gen
import tornado_mysql
class MainHandler(tornado.web.RequestHandler):
async def get(self):
conn = await tornado_mysql.connect(host="localhost", port=3306, user="root", password="password", db="mydb")
cursor = conn.cursor()
await cursor.execute("SELECT * FROM users")
result = await cursor.fetchall()
self.write("Users: {}".format(result))
cursor.close()
conn.close()
def make_app():
return tornado.web.Application([
(r"/", MainHandler),
])
if __name__ == "__main__":
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
In this code, we import the tornado_mysql module and use it to connect to a MySQL database. We define an async version of the get method and use tornado_mysql.connect to establish a connection to the database. We then execute a SELECT query to retrieve all users from the “users” table and display the result.
Tornado’s asynchronous programming model allows us to write non-blocking database code. We use the await keyword to wait for the asynchronous operations to complete, allowing the event loop to continue processing other requests in the meantime.
Tornado supports other database systems as well. You can use libraries like tornado_postgresql or tornado_sqlalchemy to access PostgreSQL or SQLAlchemy, respectively. Choose the database system that best fits your needs and integrate it into your Tornado applications.
Conclusion
In this comprehensive guide, we have explored the powerful Tornado framework for web development in Python. We discussed the benefits of using Tornado, such as its asynchronous and non-blocking capabilities, scalability, simplicity, and support for real-time web applications. We also walked through building a simple Tornado application, handling requests, using templates and static files, and performing asynchronous operations.
Tornado is a versatile framework that empowers developers to build high-performance web applications. Its simplicity and powerful features make it an excellent choice for various use cases, from simple websites to complex real-time applications.
