Web Servers Product

HostForFree Free Webhosting

Hostforfree is one the best free hosting company that offers quality support to all of their customer's despite to their type, free or paid. It has a great user interface that helps to set up your site more easily and quickly. They are popular as a free hosting service provider where you can host your site within 30 seconds. They are running a quality service and providing the same quality of service in both free and paid service. Their network will be up and running at least 99.9% of the time (excluding scheduled maintenance work).This product can help to increase the security of your site, it offers security and quality to their users, whereby mitigate security problem. Don't ignore them as they provide free service. Some of their services is better than paid hosting service. They remain updated with many themes and tools. They offer many different services in their free hosting plan. In a very small period of time, they became a well-known free hosting service provider.

HostForFree Free Webhosting Summary

Rating:

4.6 stars out of 11 votes

Contents: Webhosting
Price: $97.00

My HostForFree Free Webhosting Review

Highly Recommended

Maintaining your trust is number one. Therefore I try to provide as much reliable information as possible.

I personally recommend to buy this product. The quality is excellent and for this low price and 100% Money back guarantee, you have nothing to lose.

Download Now

Testing Internal Web Server Performance

If you type 2 at the main menu and press Enter to test internal web server performance, you'll get the following prompt WEB PERFORMANCE TESTER - INTERNAL WEBSERVER CHECK Enter the ip addresses of the web servers running the Python Webserver, seperated by spaces For example, if you had two servers running the Python web server and their IP addresses were 192.168.1.102 and 192.168.1.103, at the prompt you would type the following WEB PERFORMANCE TESTER - INTERNAL WEBSERVER CHECK Enter the ip addresses of the web servers running the Python Webserver, seperated by spaces Enter the port the web server is listening on As you can see, the program downloads both a text file and a binary file from each web server (both text files and binary files are supplied and need to be kept in the same directory as webserver.py). The program reports on the amount of time each file took to load, for each web server indicated.

Running the Python Web Server

Before you run the Python web server, you'll need to determine what port you want to run it on. It needs to be a port that isn't being used by some other program. This chapter's example uses port 8006. You will want to run the Python web server from any server that you want to monitor for HTTP response performance. To run it, you just need to open a command prompt window and navigate to the Chapter 4 application directory and type python webserver.py 8006. To test the web server, bring up your browser and type the following in your browser's address control This is a test page for the Python Web Server. The web server window should show a line like the following At this point, the web server is now up and running. Start this for all the servers on your network on which you'd like to test HTTP performance.

Check InternalWeb Serversserverlist port

The next block of code is a for loop, similar in some ways to the one in the CheckExternalSites() function. Again, a try except construct is used. For each server, it connects to the web server and attempts to download each type of file via HTTP. If successful, it writes to the screen how long it takes. If an error occurs, then that is handled through an exception (again, either through a socket timeout or a generic exception)

Client and Web Server Interaction

In this section, we discuss the interactions between a Web server and a client application. A Web page, in its simplest form, is either a Hypertext Markup Language (HTML) document or an Extensible Hypertext Markup Language (XHTML) document. (In this chapter, we use XHTML.) An XHTML document is a plain-text file that contains markup, or tags, which describe how the document should be displayed by a Web browser. For example, the XHTML markup The first part of the address, http , indicates that the resource is to be obtained using the Hypertext Transfer Protocol (HTTP). During this interaction, the Web server and the client communicate using the platform-independent HTTP, a protocol for transferring requests and files over the Internet (e.g., between Web servers and Web browsers). Section 6.2.3 discusses HTTP. The remainder of the URL specifies the requested resource books down-loads.html. This portion of the URL specifies both the name of the resource (down-loads.html an HTML XHTML...

Using the web server gateway interface

In the early days of Python web frameworks, there was little standardization of how web applications interacted with web servers. Consequently, the choice of a web framework often limited the possible web servers you could use and made migration from one to the other difficult. The WSGI (whiz-ghee), or web server gateway interface, specification was created to provide a standard for the interaction of web server and applications, so that it would be easier to use a web application and framework on different web servers. Figure 24.1 is a simple schematic of how a WSGI application combines with a server. You need to know the details of WSGI design only if you're writing web servers or web application frameworks, but it's useful to understand the basic idea of how a WSGI application is set up.

Webserverpy

As mentioned earlier, webserver.py is run on your server. It starts a lightweight Python-based web server at the port you designate. As usual, we'll look at the entire program, and then go through it section by section print Python Web Server, serving at port + PORT httpd.serve_forever() print There was a problem starting the webserver at port 1

The Web Server Apache

The most popular use of Python in the corporate world is for writing scripts to be called from Web pages. In order to use a Web page, of course, you must somehow serve up that page to the user, so that he can interact with your scripts. The serving up of pages is accomplished by a Web server. The most popular open source Web server is the Apache Web Server from the Apache Software Foundation. You can find the Apache Web server at www.apache.org or httpd.apache.org. The Web server itself is free, although there are various organizations that sell versions of it. For our purposes, the free basic server will be fine. We often refer to the combination of Web server, scripting language, and database as either the LAMP or WAMP system. The L stands for Linux, while the W stands for Windows. In either case, the A is the Apache Web server, while the database is normally MySQL (thus, the M) and the scripting language is either Python or Perl, completing the acronym. In the next few chapters, we...

AOLserver Web Server

This is a Web Server created and used by AOL. Note that anyone using AOLserver would be better off learning TCL. For details, see The project that embeds Python in the AOLServer Web Server, is now semi-stable for simple CGI-style operations, and provides a 4-5x speedup over the straight CGI. You can set up both Microsoft IIS Server and Personal Web Server (PWS) to call the Python interpreter to handle Python CGI scripts.

Creating a Quick CGI Form

Once you've got your web server working correctly, you can move on to getting user input, as shown in Listing 8-4. Input is supplied to the CGI script by an HTML form. You can retrieve the data from the form's fields using the FieldStorage class from the cgi module. I'll explain how classes work fully in the next chapter. For now, all you need to know is that cgi.FieldStorage returns a dictionary-like interface, which allows you to access the form fields by name. The items in the FieldStorage dictionary contain more than just the value, so you have to explicitly ask for the value. There are several ways you could do this the best is to use the getvalue(key, default value) method, which is provided by the FieldStorage object.

Setup mocLwsgi on Linux

Download and unzip web2py source on the machine where you installed the web server above. defines a daemon process group in context of web2py.example.com. By defining this inside of the virtual host, only this virtual host, including any virtual host for same server name but on a different port, can access this using WSGIProcessGroup. The user and group options should be set to the user who has write access to the directory where web2py was setup. You do not need to set user and group if you made the web2py installation directory writable to the user that Apache runs as by default. The display-name option is so that process name appears in ps output as (wsgi web2py) instead of as name of Apache web server executable. As no processes or threads options specified, the daemon process group will have a single process with 15 threads running within that process. This is usually more than adequate for most sites and should be left as is. If overriding it, do not use processes 1 as doing so...

Streaming Virtual Files

It is common for malicious attackers to scan web sites for vulnerabilities. They use security scanners like Nessus to explore the target web sites for scripts that are known to have vulnerabilities. An analysis of web server logs from a scanned machine or directly of the Nessus database reveals that most of the known vulnerabilities are in PHP scripts and ASP scripts. Since

Your First Python CGI Script Hello Apache

The CGI (Common Gateway Interface) protocol is a standard way for external programs and application environments to interact with Web servers. While a plain HTML file on the Web is static, a CGI program (or script) is executed at the time that the request is made from the user, and the content is created on the fly. To see how this works, let's create a simple script in Python and have it executed by the Apache Web server.

Setup Cherokee with FastGGI

Cherokee is a very fast web server and, like web2py, it provides an AJAX-enabled web-based interface for its configuration. Its web interface is written in Python. In addition, there is no restart required for most of the changes. Here are the steps required to setup web2py with Cherokee

Zope Web Application Server

You don't need to use Apache (PyApache Httpdapy) in conjunction with Zope. In fact, Zope comes with a fast Web server of its own, which supports multiple protocols. On the other hand, it can also work with other Web servers as well. Most users do put Apache in front of Zope for reasons of flexibility. Because Zope is a long running process, they implement Persistent CGI, FastCGI, or ProxyPass. If you need to find Web Hosting companies that support Zope, this might help http www.zope.org Resources ZSP.

What just happened

We're not limited to goofing around on slashdot.org. We can use the Twill language to describe any interaction between a web browser and a web server. That means, we can use it to describe the expected behavior of our own web applications. If we can describe expected behavior, we can write tests.

Environment Variables

Environment variables are one of the methods that Web servers use to pass information to a CGI script. They are created and assigned appropriate values within the environment that the server produces for the CGI script. The following is a list of environment variables used by Web Servers PATH_TRANSLATED Translated version of PATH_INFO, which maps it onto DOCUMENT_ROOT. Usually PATH_INFO is used to pass a path argument to the script. For example, a counter might be passed the path to the file where counts should be stored. The server also makes a mapping of the PATH_INFO variable onto the document root path and stores it in PATH_TRANSLATED, which can be used directly as an absolute path file. You should use PATH_TRANSLATED rather than concatenating DOCUMENT_ROOT and PATH_INFO because the documents on the Web Server might be spread over more than just one directory (for instance, user directories under their home directories). SERVER_NAME The Web server's hostname, DNS alias, or IP...

Automated Information Gathering

The first step of information sharing is gathering the information. There are two other chapters in this book dedicated to gathering data Text Processing (Chapter 3) and SNMP (Chapter 7). Text processing contains examples of the ways to parse and extract various pieces of data from a larger body of text. One specific example in that chapter is parsing the client IP address, number of bytes transmitted, and HTTP status code out of each line in an Apache web server log. And SNMP contains examples of system queries for information ranging from amount of installed RAM to the speed of network interfaces. Gathering information can be more involved than just locating and extracting certain pieces of data. Often, it can be a process that involves taking information from one format, such as an Apache logfile, and storing it in some intermediate format to be used at a later time. For example, if you wanted to create a chart that showed the number of bytes that each unique IP address downloaded...

Running the Performance Profiler Client

2 - Test internal web server performance You have four options Connect to external websites and observe the performance from your client machine connect to internal Python web servers to observe internal HTTP network performance display the log file in Notepad and exit. The following sections examine each option.

How This Book Is Structured

This book is framed around the code itself. This is because developers are typically looking for how to do something and, as with many activities, you learn how to do something by watching how others do it and trying it yourself. If you want to know how a for loop works, you'll find for loops in my code, but that's not the thrust of the book. Instead, this book shows you how to do things how to build a content management system, how to build a test management system, how to set up a system for tracking customer follow-up, and so on. Along the way, you'll learn how to communicate with a SQL database, how to act as a web server or communicate with one, how to access operating system services, and more. This project shows how to communicate with a Python web server and retrieve information regarding how long it takes to receive requested items from the web server. Although writing Python programs to work on a single computer can be useful, the real power of Python can be seen when it is...

Entering Comments at the Website

Assuming your Apache web server is running on your local machine, type http loaIhost test form.html into the address area of your web browser. Figure 5-13 shows the feedback dialog that appears. The application assumes you have an SMTP server running on the web server machine. If you don't, you'll get an error right at this point, but don't worry about it we'll modify the script later to point to your SMTP server.

Well Supported in Third Party Tools

When you are trying to implement a new application, it is good to know if the existing third-party tools out there will help you out. Python is well supported in such third-party tools as MySQL, an open-source database package, and Apache, an open-source Web server. These are two of the most popular packages for using scripting tools with, and as such, using a well-supported scripting tool is a definite bonus.

Receiving Data from an HTML File

While one-sided conversations between a Web server and a Python script are often useful, it is considerably more interesting and useful to be able to supply a Python script with information from a Web page, and to generate output based on that input. In Python, the CGI module provides access to information sent by HTML pages containing input fields. These pages, called forms in the HTML world, can do the job of obtaining input from the user in a clean and user-friendly manner, and then pass them on to a simple script to do further processing.

Putting It All Together

At this point in the book, you have learned all about the basic syntax of Python. You've learned how to write scripts that can be called from Web servers, and how to write scripts that work with databases. It's time to put all of this together into a nice package that uses all of the pieces in one place. We will be creating a reference application that is run from a Web server, uses a database, and shows you the steps involved in putting together a complete Python application for the Web.

How This Book Is Organized

Chapter 13 covers working with the Apache Web server, receiving information from HTML forms, generating HTML on the fly, and working with cookies. Chapter 15 creates a full-blown Web application utilizing HTML pages, Python scripting code, database technology, and the Apache Web server.

Getting Information on Python

If you are working on the Apache Web server and want information related to Python, how to use it, where to get the modpython (we'll discuss this later) modules and how to configure things, the www. modpython .org Web site is the place to be. There's some general Python discussion here as well.

Script for Displaying the Environment

Save the file into the cgi-bin directory under the Apache Web server root directory. In this example, the file is called ch13_2.py, but you can call it whatever you like. When you run the script in the IDLE interpreter, or on the command line, you are running it under your own account. When a script runs in the Web server, however, it is running under a special account dedicated to the Web server. As a result, the environment that you are operating under is different. In addition, the environment within the Web server is different than that of the system environment. While things like this rarely make a huge difference, you do have to be aware of them when writing code that might be executed within the Web server environment and without.

When to Consider Asynchronous Networking

Coroutines are more modern but less commonly understood and used since they were only first introduced in Python 2.5. An important feature of coroutines is that you can write programs that look more like threaded programs in their overall control flow. For instance, the web server in the example does not use any callback functions and looks almost identical to what you would write if you were using threads you just have to become comfortable with the use of the yield statement. Stackless Python (http www.stackless.com) takes this idea even further. Even though this improved response time might look like a win, there are still horrible problems associated with trying to implement your own concurrency. For example, tasks need to be especially careful when performing any kind of blocking operation. In the web server example, there is a fragment of code that opens and reads data from a file.When this operation occurs, the entire program will be frozen potentially for a long period of time...

When should we use properties

Custom setters are useful for validation, as we've already seen, but they can also be used to proxy a value to another location. For example, we could add a content setter to the WebPage class that automatically logs into our web server and uploads a new page whenever the value is set.

Serializing web objects

Because JSON can be easily interpreted by JavaScript engines, it is most often used for transmitting data from a web server to a JavaScript-capable web browser. If the web application serving the data is written in Python, it needs a way to convert internal data into the JSON format.

Generator expressions

Log files for popular web servers, databases, or e-mail servers can contain many gigabytes of data. If we want to process each line in the log, we don't want to use a list comprehension on those lines it would create a list containing every line in the file. This probably wouldn't fit in memory and could bring the computer to its knees, depending on the operating system.

Site Management Tools

WebDAV (World Wide Web Distributed Authoring and Versioning) is a set of extensions to the HTTP 1.1 protocol, which allows users to collaboratively edit, manage, and update files safely on remote Web servers. It was developed by the WebDAV working group of the Internet Engineering Task Force (IETF).

Httpwwwdigicoolcom Persistent CGI

Persistent CGI architecture provides a reasonably high-performance, transparent method of publishing objects as long running processes via the World Wide Web (WWW). The current alternatives to CGI that allow the publishing of long-running processes, such as FastCGI and ILU, have some level of Web server and platform dependencies. Persistent CGI allows a long running process to be published via the WWW on any server that supports CGI, and requires no specific support in the published application.

ASP and Microsoft ActiveX Scripting

Active Server Pages, commonly referred to as ASP, is Microsoft's solution to server-side scripting applications. The difference between Active Server Pages and HTML pages is that with simple HTML pages, the client browser requests a Web page from a Web server. The server sends the file to the client, and the page is shown on the client's browser. On the other hand, with Active Server Pages, the server gets a chance to alter the file before sending it to the user. So, for every request for a file with an .asp extension, the server runs the file through a interpreter that parses the ASP commands. You can have your ASP code connect to any ODBC-compliant database, and dynamically insert the data into your HTML pages. To use Active Server Pages, you must be running a Microsoft Web Server, specifically Internet Information Server (IIS) 3.0 or up Microsoft's Internet Information Server is a Web Server that supports both CGI and ASP. If your Web site runs on a UNIX system, you can still use...

An Introduction to CGI

CGI (Common Gateway Interface) is a standardized way for the Web Server to invoke an external program to handle the client request. It is possible for the external program to access databases, documents, and other programs as part of the request, as well, and present customized data to viewers via the Web. A CGI script can be written in any language, but here, of course, we are using only Python. In order to execute it, place it on a executable directory on your Web server and call it from your Web browser. If you are working on a UNIX-like OS, you need to run chmod a+x scriptname.

Using Django in Netbeans Josh Juneau

In this next step, we will configure the Netbeans project Run option so that it starts up the Django web server for us. To do so, right-click (Cntrl+Click) on the newly created project and go to Properties. From there, choose the Python option in the left-hand menu and add the Django directory (containing the bin, conf, contrib, core, and so on files) to your path. For this tutorial we will also make use of the PostgreSQL database, so you'll want to also add the postgresql.jar to your Python path. Next, select the Run option from the left-hand menu and add manage.py as the main module, and add runserver as the application argument. This will essentially hook up the Run project option to the Django manage.py such that it will invoke the Django web server to start up. At this point, we are ready to begin developing our Django application. So with a little minor setup and some use of the terminal or command-line we are able to easily use Netbeans for developing Django projects. There are...

Starting With an SDK Demo

We will start by running the demo application known as guestbook that comes with the Google App Engine SDK. This is a very simple Java application that allows one to sign in using an email address and post messages to the screen. In order to start the SDK web server and run the guestbook application, open up a terminal and traverse into the directory where you expanded the Google App Engine .zip file and run the following command Of course, if you are running on windows there is a corresponding .bat script for you to run that will start the web server. Once you've issued the preceding command it will only take a second or two before the web server starts. You can then open a browser and traverse to http localhost 8080 to invoke the guestbook application. This is a basic JSP-based Java web application, but we can deploy a Jython application and use it in the same manner as we will see in a few moments. You can stop the web server by pressing CTRL+C.

Example Jython Servlet Application for App Engine

Note that when using the PyServlet implementation you should exclude those portions in the web.xml above that are used for the object factory implementation. The PyServlet mapping can be contained within the web.xml in both implementations without issue. That's it, now you can deploy the application to your Google App Engine development environment, and it should run without any issues. You can also choose to deploy to another web server to test for compatibility if you wish. You can deploy directly to the cloud by right-clicking the application and choosing the Deploy to App Engine option.

Applets and Java Web Start

Another option for distributing GUI-based applications on the web is to make use of the Java Web Start technology. The only disadvantage of creating a web start application is that it cannot be embedded directly into any web page. A web start application downloads content to the client's desktop and then runs on the client's local JVM. Development of a Java Web Start application is no different than development of a standalone desktop application. The user interface can be coded using Jython and the Java Swing API, much like the coding for an applet user interface. Once you're ready to deploy a web start application then you need to create a Java Network Launching Protocol (JNLP) file that is used for deployment and bundle it with the application. After that has been done, you need to copy the bundle to a web server and create a web page that can be used to launch the application.

Using frameworks to create advanced web apps

The WSGI specification goes a long way toward standardizing the way that Python web applications can interact with web servers and handle HTTP requests and responses. It doesn't specify how applications behave internally, however, nor does it mandate what the application does with the requests it receives or how it generates its responses. This means that with a bare WSGI application a lot must be implemented. And a lot of that is repetitive handling URLs, extracting the information from web forms, creating HTML pages, inserting dynamic content into those pages, and the like. Although it's possible to code everything by hand or to assemble and or write a custom collection of modules to handle these chores, for most projects it's preferable to use an existing

Creating a Python web application

Although the http. server module has the basics of a web server, you need more than the basics to write a full-featured web application. You need to manage users, authentication, and sessions you need a way to generate HTML pages. The solution to this is to use a web framework, and over the years many frameworks have been created in Python, leading to the present generation, which includes Zope and Plone, Django, TurboGears, web2py, and many more. One thing to keep in mind in considering web applications is that the web server functionality the part that processes HTTP requests and returns responses isn't necessarily (or even usually) closely tied to the web application itself. Most web frameworks today can either run their own HTTP servers or rely on an external server, depending on the situation. For development, it's often preferred to use the application's internal server, because there's less to install and set up. For heavy traffic in production, often an external server handles...

The XML Tools Dictionary

Unfortunately, AppleScript is not the ideal solution to able to handle XML-RPC requests on the server side. We can't use it to service requests from remote machines, even when combined with a suitable web server such as Webstar or Apple's AppleShare IP web service. If you want to support XML-RPC services on your machine, use Python or Perl.

Apache XML Project httpxmlapacheorg

The Apache group, famous for its web server software, has been developing a suite of XML tools. The project consists of five main tools Xerces, an XML parser in Java and C++ with Perl bindings Xalan, an XSLT stylesheet processor (Java and C++) Cocoon, an XML-based web publishing environment (Java) Xang, a tool for rapid development of dynamic server pages, written in JavaScript and SOAP, a suite for working with SOAP services, primarily in the area of SOAP servers that integrate with Apache.

Thread Pools

The first strategy is to leverage managed thread pools in the JavaEE container. When your web application is running within Glassfish, each HTTP request is processed by the HTTP Service, which contains a threadpool. You can change the number of threads to affect the performance of the webserver. Glassfish will also let you create your own threadpools to execute arbitrary work units for you.

CherryPy

CherryPy is a very powerful web server that uses a simple design for building web applications. Let's jump in head-first with a simple example that serves the HTML file we developed in the previous section If we run this program, we can visit http localhost 8 08 0 in a web browser to see the web page in action. All we've done here is create a class to pass to the quickstart function. That function starts a web server and serves pages from that class. Any methods of the class we created that have been marked as exposed will be made available via HTTP at a URL with the same name as the method. Any method not explicitly marked as exposed can be used internally as a helper method, but cannot be accessed at any URL. As we discussed, CherryPy is just a web application server it is not a web framework. It provides a complete web server and the basic features to map HTTP requests to code that must be executed when those requests are made. It also provides, with a bit of configuration,...

Web Programming

Ython is widely used when building websites and serves several different roles in this capacity. First, Python scripts are often a useful way to simply generate a set of static HTML pages to be delivered by a web server. For example, a script can be used to take raw content and decorate it with additional features that you typically see on a website (navigation bars, sidebars, advertisements, stylesheets, etc.).This is mainly just a matter of file handling and text processing topics that have been covered in other sections of the book. Second, Python scripts are used to generate dynamic content. For example, a website might operate using a standard webserver such as Apache but would use Python scripts to dynamically handle certain kinds of requests. This use of Python is primarily associated with form processing. For example, an HTML page might include a form like this Another common scenario involving dynamic content generation is with AJAX (Asynchronous Javascript and XML).With...

Setup PostgreSQL

It is wise to run the web server(s) and the database server on different machines. In this case, the machines running the web servers should be connected with a secure internal (physical) network, or should establish SSL tunnels to securely connect with the database server.

Voting and Rating

Ajax callbacks can be used to perform computations in the background, but we reccomment using CRON instead (discussed in chapter 4), since the web server enforces a timeout on threads. If the computation takes too long, the web server kills it. Refer to your web server parameters to set the timeout value.

Http Package

The first line of the server response indicates the HTTP protocol version, a success code, and a return message. Following the response line is a series of header fields that contain information about the type of the returned document, the document size, web server software, cookies, and so forth. The header is terminated by a single blank line followed by the raw data of the requested document. SimpleHTTPRequestHandler and CGIHTTPRequestHandler Two prebuilt web server handler classes can be used if you want to quickly set up a simple stand-alone web server.These classes operate independently of any third-party web server such as Apache. Here is an example of using these handler classes to run a stand-alone web server capable of running CGI scripts

Installing Apache

Apache is the most popular web server on the Internet. It is available for multiple operating systems, including Windows and Linux. Although Apache itself is extremely customizable, the installation of the web server is fairly straightforward. Keep in mind that these instructions are for installing a version of Apache for Windows that will give you the functionality you need to run this chapter's application. Apache is a very robust and configurable web server, and a complete treatment of it is beyond the scope of this book.

Webclientpy

The webclient.py module connects to either external websites or internal web servers based on which function is called, and presents the results both to the screen and to the log file. Table 4-3 shows the functions of the webclient module. Takes a list of internal web servers (passed to it from the main program in webperf.py) and attempts to connect to each site, reporting to the screen and the log file success or failure, and how long the connection took.

System

All the applications examined thus far have involved a character-based user interface, based on characters viewed and typed in a terminal. In this chapter, you will explore using mod_python, an add-on module for the popular open-source Apache web server, to use Python to interact with client users through a web browser. For each comment submitted, it will enter a log entry to a csv file stored on the web server machine. This log can then be queried and sorted like any other spreadsheet file.

Run Server

RunServer() is the main part of the Python web server. As I said earlier, this could have been part of the main program, but sometimes it is nice to encapsulate code in functions simply so that you can call that function later from another program, should you want to. print Python Web Server, serving at port, PORT httpd.serve_forever() except print There was a problem starting the webserver at port + PORT As you can see, the running of the web server is encapsulated inside a try except block. This is because anytime you start a server process, issues can arise (for example, the port you've selected could already be in use). Therefore, it's a good idea to use the try except block. You then output a message to the screen indicating that you are starting the service, and run the TCP server's serve_forever() method, which actually starts the web server 'Python Web Server, serving at port, print There was a problem starting the webserver at port + PORT

Preliminaries

Before you can use the application, an Apache web server needs to be running, on which mod_python is installed and configured. mod_python has several different handlers, and in the example for this chapter the Publisher handler is used. In Apache, a handler is simply an instruction to the web server to do certain things when it encounters a file of a certain type. For example, there might be a handler that launches Adobe Acrobat Reader when a PDF file is encountered. There are implicit handlers that are built into the web server, and explicit handlers that are configurable through the < web server root> conf httpd.conf file. mod_python uses explicit handlers to tell Apache how to handle files with a .py extension.

Installing modpython

Mod_python is an Apache module that embeds a Python interpreter within the Apache web server. It enables you to integrate the Python language with web content. Using mod_python, you can develop web applications that will often run faster than Common Gateway Interface (CGI) applications and that provide access to advanced features such as maintaining connections to databases and parsing XML. Moreover, all this can be done with the Python language.

Uploading Files

If you happen to be writing a Web server application that does things like customer support, source code control, or file sharing, you have likely run into the issue of allowing the user to upload a file to store on the server. Downloading a file is a simple process just hand the link to the browser and off it goes. How do you manage to get a file from the user machine to the server, however The answer, surprisingly, is quite easily. The majority of the work is done by the HTML on the client side. The processing of the file is handled by the browser and server, and all you need to do is acquire the file data and write it back to the place you want it stored on the server.

Setting Up Apache

In the Windows world, setting up the Apache Web server is one of the simplest jobs you will ever have. Download the installer (MSI file) from the Apache Software Foundation Web site and run it on the box on which you want to install the software. It is perfectly acceptable to run the software on your local machine, using the local address (127.0.0.1, or localhost). For our purposes, you can accept pretty much every default available, specifying only the directory that you want to install the program in. Note that you must be an administrator on the computer that you are trying to install Apache for in order for it to work properly. Please be sure to install the system as a Windows service, so that it will load and run properly at startup, and will be available at all times. If, for some reason, you do not want to install it as a service, you will need to run the command line version of the software (or launch it via the Start button) to bring it

Other Software

As we begin to discuss other segments of the programming world with respect to Python, you will need to obtain and download other software for use with the language. Specifically, you will probably want to download and install the MySQL database system and the Apache Web server system. These two packages are available on the Internet free of charge. The Apache Web server has become the standard open source Web server for creating and maintaining Web sites. Since Python has become so closely associated with creating CGI scripts and Web pages, it only makes sense for us to discuss the building of various components for the Web. You can find Apache at www.apache. org. The actual Web server (http server) is found at http proj ects. apache ,org projects http_server.html. In this book, we will be using Version 2.2.3, which is available for download. You will also need to download the mod_python module for use with the server. You can download this at www.modpython.org.

Creating a New User

The next optional step is to create a new user for the database. You do not actually have to create a user, because you already have one called root. It is a bad idea, however, to use the root user when working with the database from your Python script. For one thing, the root user has access to everything in the database and can cause all sorts of harm if you were to mess up a statement in your script. For another, and more important reason, you will likely be embedding the user name and password of your user in the script information. Even though that information never makes it to the Web page user, it can be found if there are holes in your Web server security. For this reason, and many more, it makes sense to create a new user.

Testing Apache

After you have installed the Apache software, the first step is to make sure that it is working properly. Apache ships with an index.html file that is located in the root htdocs directory, where root is the root of the installation system. For example, if you used the default install options, the root of the system will be Program Files Apache Foundation Apache 2.2 (for the 2.2 version of the Web server, your directory could be slightly different). Fortunately, the Web server really doesn't care where you place the files it just cares about the URL (uniform resource locator) that you provide it to find files. To test the Web server, you enter the following line on the navigation line of your favorite Web browser http localhost. The Web server will find the index.htm file in the htdocs directory of the installation tree and will display the contents on the screen. What you see varies, depending on the installation version you have, but you should see something that makes it obvious...

SlotsClass Attribute

Python's dynamism enables programmers to write applications that can change as they execute. Often, this is useful for software development purposes. For example, during the development cycle, a graphical-application programmer might create software that enables the programmer to change the application's appearance (i.e., some of the application's code) without terminating the application. This technique also is valuable for applications like Web servers that must continue executing for long periods of time, but that may need to change periodically to incorporate new features. Dynamism also has drawbacks usual-ly dynamic applications or applications programmed in a dynamic language exhibit poorer performance than do their non-dynamic counterparts.

Simple CGI Script

Scripts executed on the server usually generate custom responses for clients. For example, a client might connect to an airline's Web server and request a list of all flights from Boston to San Antonio between September 19th and November 5th. The server queries the database, dynamically generates XHTML content containing the flight list and sends the XHTML to the client. This technology allows clients to obtain the most current flight information from the database by connecting to an airline's Web server. Server-side scripts also have access to server-side software that extends server functionality. These pieces of software are called COM components for Microsoft Web servers and modules for Apache Web servers. Components and modules range from programming language support to counting the number of times a Web page has been visited (known as the number of hits). Forgetting to put the directive ( ) in the first line of a CGI script is an error if the Web server running the script does...

Wsgiref

WSGI (Python Web Server Gateway Interface) is a standardized interface between webservers and web applications that is designed to promote portability of applications across different webservers and frameworks. An official description of the standard is found in PEP 333 More information about the standard and its use can also be found at http www.wsgi.org.The wsgiref package is a reference implementation that can be used for testing, validation, and simple deployments.

Why Python

Or do you need to parse through a logfile, extract every piece of information that it provides, compare usage from each IP address in this logfile to usage in each logfile (which are stored in a relational database, by the way) from the past three months, and then store the results to a relational database Sure, Python can do that as well. Python is being used on some pretty complex problems, such as analysis of genomic sequences, multithreaded web servers, and heavy duty statistical analysis. You may never have to work on anything like that, but it's nice to know that when you need to do complex things, the language is able to work with you.

Web Development

Nowadays, some of the most important applications in the Internet are based on the HTTP protocol. Python's support to HTTP, which is the basic communication protocol underlying the Web, allows it to implement HTTP Servers (Web Servers) and clients (Web browsers). Python has been successfully used to implement an HTTP client called Grail, which is a Web browser full of features. On the other hand, Python has many options for HTTP Servers, also known as Web Servers. Python's standard library of modules comes with some basic HTTP Server implementations, such as BaseHTTPServer and SimpleHTTPServer. The advantage of using Python as a Web Server is that you have total control about what is going on in your application. Configuring Web Servers for Python CGI Scripts The next topics show you how to configure the most used Web servers in the market. Mostly you will see how to handle Python CGI scripts within Apache and Microsoft IIS Web servers.

Python in Apache

Apache comes with a predefined set of handlers for basic routine tasks. However, there are several third-party handler applications that can be very useful as well, such as the mod_python and mod_pyapache modules. Using these modules is not strictly necessary, but it reduces the overhead of your server and increases the speed of your application. Both of these reasons occur because the Python interpreter is not called for every single connection anymore. You can create Apache Handlers by building them into the Web Server, adding them to the Action directive, or implementing a module.

Reading Applet Files

For security reasons, ysu can't read biles prom as apy in they're on the clipsS's hard driva (unless you configure Java security to allow this). However, you cay aead them from the Web server than serves the applet to the client. We won't cover Java se cerity here, but I do recomme nd bhat you yead the online security documaIe atron as the Javasoft Web site. The Python Web Server Python's Web server can ba found in the SimpleHTTPServer module. Here's what to do to get it up and running SimpleHTTPServer delivers HTML panes from tbe current working directory, so to run the Web server for our HTML page we have to start a DO prompc asd run the module in the . scripts chap18 context subdirectory. Then we can access the applet with Netscape Navigator by entering the URL If you're running the PythoP Web server and the browser on the same machine, use the URL However, you'll be better off using the IP address or the domain name service (DNS) enta . On Windows NT 98, she DNS entry us ually...

WSGI and Modjy

WSGI, also known as the Web Server Gateway Interface, is a low-level API that provides communication between a web server and a web application. Actually, WSGI is a lot more than that and you can actually write complete web applications using WSGI. However, WSGI is more of a standard interface to call python methods and functions. Python PEP 333 specifies the proposed standard interface between web servers and Python web applications or frameworks, to promote web application portability across a variety of web servers.

Tomcat

Deploying a web start application is as easy as copying the necessary files to a location on the web server that is accessible via the web. In the case of Tomcat, you will need to copy the contents of your web start application to a single directory contained within the directory. For instance, if you have a web-start application entitled JythonWebStart, then you would package the JAR file along with the JNLP and HTML file for the application into a directory entitled JythonWebStart and then place that directory into the directory.

Google App Engine

Application will run in the environment. You can download the SDK by visiting this link along with viewing the extensive documentation available on the Google App Engine site. The SDK comes complete with a development web server that can be used for testing your code before deploying, and several demo applications ranging from easy JSP programs to sophisticated demos that use Google authentication. No doubt about it, Google has done a good job at creating an easy learning environment for the App Engine so that developers can get up and running quickly.

Glassfish

Deploying a web start application is basically the same as any other web server, you simply make the web start JAR, JNLP, and HTML file accessible via the web. On Glassfish, you need to traverse into your domain directory and you will find a docroot inside. The path should be similar to Anything placed within the docroot area is visible to the web, so of course this is where you will place any web-start application directories. Again, a typical web start application will consist of your application JAR file, a JNLP file, and an HTML page used to open the JNLP. All of these files should typically be placed inside a directory appropriately named per your application, and then you can copy this directory into docroot.

Bonus The Admin

Note The development web server is an easy way to test your web project. It will run indefinitely until you abort it (for example, hitting Ctrl + C) and it will reload itself when you change a source file already loaded by the server, thus giving almost instant feedback. But, be advised that using this development server in production is a really, really bad idea, because it can't handle multiple simultaneous connections and just has poor performance in general.