Category: CherryPy

Pages: << 1 2 3 4 5 6 >>

10/25/05

Permalink 01:33:07 pm, by fumanchu Email , 2897 words   English (US)
Categories: IT, Python, CherryPy

Customization vs handler dispatch in web application servers

[10/25/05 Update: changed some terms to make it more clear.]

At its most basic, a web-application server can be said to map a set of URI's to a set of handlers. From Roy Fielding's REST dissertation:

The resource is a conceptual mapping -- the server receives the identifier (which identifies the mapping) and applies it to its current mapping implementation (usually a combination of collection-specific deep tree traversal and/or hash tables) to find the currently responsible handler implementation and the handler implementation then selects the appropriate action+response based on the request content.

In an HTTP server, the "identifier" is the URI (which includes the query string, as I learned recently). The "handler implementation" is almost always a function in some programming language; for many HTTP servers written with scripting languages, these handlers will be written in the same language as the server. CherryPy 2.1, Django 1.0, and Quixote 2.3 are Python examples of this. mod_python 3.1 is an example of a Python web-application tool where the HTTP server is written in some other language (Apache, written in C). In a moment, we'll take a look at how each of these manages URI-to-handler mappings, which we'll call "dispatch".

Every web-application server, whether tied to a larger framework (Django) or not (CherryPy, Quixote, mod_python), must also address the need for customization. By "customization", I mean modifications to the per-request behavior of the server. I do not mean the behavior of the application, although the same techniques are often employed for both. I also do not mean end-user settings, which are properly stored in an application database. I also want to make it absolutely clear that I don't mean "data which exist in configuration files"—the concept of customization is distinct from the medium.

Now let's look at our four servers, and see how they manage URI-to-handler dispatch, and how they provide customization:

CherryPy

CherryPy takes the "deep tree traversal" route in order to map URI's to handlers. There is a cherrypy.root object which the developer creates, which always maps to the root URI "/". Subpaths are attached as attributes to the root object. Since the path portion of a URI is also heirarchical, there is a relatively straightforward mapping.

CherryPy allows some flexibility by providing a default method; if the mapper reaches the end of its search without finding a matching handler, it will then reverse direction, looking for a parent method named "default", which it then calls, passing any child path info as arguments. That is, a URI of "/path/to/parent/child/repr?color=red", if handled by cherrypy.root.path.to.parent.default, will be called as default("child", "repr", color="red").

CherryPy manages customization primarily via an internal Python dict (a key->value map); each key is a URI, and each value is another dict of (name, setting) pairs. This is often specified in an "ini-style" config file.

Django

Django might be said to epitomize the "hash tables" approach to handler dispatch, using an ordered set of regular expressions. The urlpatterns object is a tuple of tuples, where each inner tuple is of the form: ("pattern", "handler"). The pattern-handler pairs are evaluated in order until the URI matches a pattern, at which point the handler is looked up (converted from a string to the function which it identifies) and called. By using regular expressions, Django is free to map any set of URI's to a given handler.

Django keeps global customization data in a settings module; each global variable in that module can be used as a named value. Per-request customization, however, is managed entirely within the handlers, in code.

Quixote

Quixote has a mapping strategy apparently designed for maximum flexibility. Applications create a Publisher object, to which the server passes each HTTP request. The default Publisher will call self.root_directory._q_traverse(), passing the value of the PATH_INFO environment variable (split into chunks by each "/" in the URI). The _q_traverse method may then "do what it likes" with that path info; the common Directory object tries to map URI's to local methods, or to _q_traverse methods of successive child objects.

Quixote manages global customizations with a Config class; each attribute of that class is a constant which the server uses to customize its request-response process. The data can be read from a file (more properly, executed from a Python file). But like Django, per-request customization is managed entirely within the handlers, in code.

mod_python

Mod_python plugs right into Apache, and can control much more of the HTTP conversation than most of the other frameworks. Here, let's just talk about the PythonHandler directive; it's used as follows:

<Location /myapp>
    SetHandler python-program
    PythonHandler wsgiref.modpython_gateway::handler
</Location>

That is, the mapping between URI's and handlers is performed with Apache's Location, LocationMatch, Directory, Files, and similar directives. That's usually not the whole story, however; many modpython applications define few Handlers, or even just one, choosing instead to implement their own additional dispatch and customization layers within those handlers. I believe this tendency is one of the factors which have led so many Python web-framework developers, even the above three, to build on top of modpython as a deployment option.

The only generic, server-provided means of managing customization data for mod_python is the PythonOption key value directive (although other directives exist and may even be inspected; much of the customization in a modpython application is done entirely within Apache, or via other modules). Each PythonOption applies to the same set of URI's for which the given handler will be invoked.

Customization referents

All of the above designs, as described, have an additional detail in common: they can map multiple URI's to a given handler, but cannot (or tend not to) do the reverse: map a given URI to multiple handlers [1]. This is a surjective, not injective, mapping (click on the image to learn more):

Surjective, not injective, map. 1=D, 2=B, 3=A, 4=A

The central question then arises: is per-request customization data bound to the URI's, or to the handlers? Let's answer that for each of our four examples:

  • CherryPy customizations are definitely associated with URI's. Each section in the config dict is directly mapped from a URI key (note that a single key may match multiple URI's).
  • Django customizations are definitely associated with/defined by handlers. Any customization is written into the View objects themselves, in Python.
  • Quixote customizations are also definitely associated with handlers, just like in Django.
  • Mod_python customizations are associated with URI's; each PythonOption (or other Apache directive) applies to a given Location.

In the two frameworks (CherryPy and mod_python) where per-request customization data is associated more closely with URI's, the implementation is declarative as opposed to imperative; the server is free to use the data as it sees fit, in order to meet the perceived goal of the user. In the other two servers, Django and Quixote, the implementation is ad-hoc; developers may choose to use declarative implementations (for example, global constants), or they may "hard-code" the behavior.

This difference shouldn't be a surprise. Django is already a full-stack framework like Ruby on Rails or Spring. CherryPy, in contrast, was designed to (optionally) act as a base component for larger, "full-stack" frameworks like Subway or TurboGears. That is, CherryPy must be customizable both by end-applications and by intermediate frameworks. That would be difficult to achieve with imperative customization. Mod_python goes even further, since Django, Quixote, and even CherryPy can optionally use it to connect to Apache.

Access roles and customization

We need to pause, here, and make a distinction between application developers and application deployers. For many small applications, these two roles are played by the same person (who cannot understand why everyone is so picky about config architecture ;) ). But for larger applications or megaframeworks, the two are very distinct. Frequently, the following division of roles is expected:

ImperativeDeclarative
Server code Framework developer App developer
Application code App developer App developer
(often default values)
Config files Deployer
(a Programmer)
Deployer

Much of this is a direct result of the state of programming tools and languages. For example, "imperative server code" is the domain of framework developers, because only they have CVS/SVN privileges; if anyone else makes changes to that code, they fear losing their changes on the next update (although distributed RCS like Arch or Bazaar, can help ameliorate this a little). Similarly, config files exist outside the CVS/SVN of the application code, and are therefore the only domain of the deployer. But note that config files which use the same language as the application code are often assumed to be too difficult for non-programmers to use.

The Customization Maturity Vector

When developing applications (both new or existing), many developers tend to start with all behaviors embedded in imperative code. After a time, the developers notice a need for varying behaviors, and decide to provide a switch, in code, for it. This may take the form of constant values or subclassing or composition or some other pattern. Once the behavior set is reduced to a small number of variants, control over its customization may be placed in a config file. This results in a fairly predictable vector:

Imperative Code (IC) -> Declarative Code (DC) -> Declarative Text (DT)

Server and framework authors do the same, of course, preferring to start with imperative implementations in code, and moving slowly, but predictably, to declarative implementations in text. And they are right to move slowly; the decisions about where to store and retrieve such data are critical to proper isolation and encapsulation, key ingredients of multi-layered software.

However, what is often not addressed is that the different mechanisms not only implement access control, but directly affect program readability and server architecture, as well. For example, a server author who wishes to make a new, customizable feature available has several options. They may:

  1. IC: Provide a separate method for each possible behavior, expecting the application developer to call the correct one when required.
  2. IC: Provide a default method, which they expect to be overridden in a subclass (or otherwise replaced/superseded; some might call this Declarative, depending on the syntax).
  3. DC: Provide a standard location by which the application developer may declare a method to be called (plugin style).
  4. DC: Provide a method which is configured via a constant; the value may be placed in a variety of scopes.
  5. DT: Provide a method which is configured via a "config entry", whether in code or in a text file.

In my limited experience, their decision will most likely be motivated by the roles defined in the previous section, and by the "Maturity Vector" above. I'd like to hear from some other authors about their experience. But for now, let's move on to the architectural implications.

Issues for declarative mechanisms

CherryPy and Apache-configured-mod_python share a common weakness: customization data is stored in config files, in a declarative language which is not that of the application code. However, developers like to think of customizations as applying to handlers, not to URI's, and they often gripe when the effects of configuration files are divorced in time and space from their corresponding handler code.

For example, CherryPy has a plugin mechanism consisting of filters: classes with a set of methods which are called at various points in the request process. Until version 2.1, all filters were declared in code; each object on the cherrypy.root tree could define its own _cpFilterList attribute, a list of filter instances. Such filters apply to that object and its children, and therefore any URI's which map to that object or its children. CherryPy provided some filters in the standard distribution, but many were created by app developers to meet their specific needs.

Beginning in version 2.1, however, the builtin filters changed their declaration method, from an in-code list to configuration files, and therefore, changed from being associated with handlers to being associated with URI's. Interestingly, user-defined filters did not. Developers, especially CherryPy veterans, therefore, become confused between the two mechanisms. When configuration is bound to URI's instead of handlers, it is easy to delay the actual handler dispatch; in some cases, it may be delayed too long, limiting the customization which developers can perform, both in the handlers themselves and via any filter/plugin hooks provided by the server.

The effect is not limited to the filters themselves. Since some app developers see filters as a catch-all for customization needs, they place customizations in filters which don't really belong there, because they naively expect user-defined filters to be automatically declarable and configurable via the config file (they're not). On the other hand, filters are perceived to be black magic by many app developers, and some behaviors are hard-coded in handlers which belong more properly in filters (Python decorators seem to be a Strange Attractor for this).

Another problem arises because text-config-file declarations in both of these tools map to URI's, and not handlers. Server and app developers are at a loss in those rare cases when they need to allow deployers to specifically customize a handler as opposed to a URI. For example, a deployer for a site which internally redirects an arbitrary number of paths (e.g. http://www.site.com/~[user]/help -> /help) to a common, customizable handler would much rather write a single config entry, but the config file format forces them to write one entry for each virtual path.

Issues for imperative mechanisms

Django and Quixote, by contrast, seem to handle all per-request customization in code, imperatively. At least, there is no central, server-managed repository for declarative settings—any app developer could decide to implement their own; some do. Some simply expect customization to be done directly on the source files (example).

The first problem with this approach is that deployers (who are not programmers) have a significant psychological, if not educational, hurdle to overcome when configuring their copy of the application. [This isn't a religious treatise, so I'll stop there.]

The second problem is that it's difficult to really extend the framework itself. It's not expected, of course, that anyone would write a framework on top of Django, but neither is there any facility for extending per-request Django behavior, other than in imperative code. That is, if a site needed to gzip only some of their HTTP responses, a developer would have to implement that behavior, for each handler, in imperative code.

Finally, when customization is bound to handlers instead of URI's, the timing of the handler dispatch is of utmost importance; it must occur very early in the request-handling process, so that any per-request customization data can be available as soon as possible. Often, the mapping from URI to handler must be done absolutely first, so that the server itself has access to such data, even before calling the main handler. Django, for example, resolves the URI to the handler right away; the only serious action it takes first is to call global middleware (which has no per-request config). Quixote takes a hybrid approach; the _q_traverse methods act as "server code" (providing dispatch, and possibly configuration) but are instantiated in application objects.

Conclusion

The choice of where to store per-request customization data in a web application server is never a trivial one. It is constrained by project maturity and social expectations, as well as the architecture of both the server and each application. These concerns often compete; occasionally, they produce unresolvable conflicts.

When designing a web application server, the design of any configuration system is of utmost importance, and will affect the design of the entire server and any applications or frameworks which are built on the server. If a configuration system is not flexible, it may resist (or deny) applying the server to some application domains, or limit the extensibility of the server.

The customization system must also be designed to work in concert with the handler-dispatch mechanism. Customizations of all kinds should be analyzed and explicitly designed to be bound to either handlers or URI's. Pretending that handlers and URI's are synonymous will only hide implementation conflicts, delaying them from design time to deployment time.

Any feedback on this document is welcome. I'd like to learn a lot more about this from other server/framework authors' experiences, and from the analysis of any developers and/or deployers. Add your comments below, and I'll work on keeping this document updated.


[1] Mod_python has the best facilities for doing this, since many Apache handlers are designed to be run in series, or to cascade. An enterprising Quixote developer could, in theory, write a Publisher which called multiple handlers (but then, any of these tools' handlers could implement their own additional layer of dispatch, as well). But the vast majority of applications tend to remain surjective.

10/21/05

Permalink 03:37:20 pm, by fumanchu Email , 227 words   English (US)
Categories: CherryPy

Short list of things CherryPy should do

Sylvain just reminded me of one of Ryan Tomayko's early rants on HTTP and REST, On HTTP Abuse. It was probably the one post that jump-started my exploration of REST, which has been guiding my contributions to CherryPy.

In that post, he presented a short list of things which a "web framework" should provide:

For instance, which frameworks ...
  1. ... help implement content negotiation properly?
  2. ... provide facilities for implementing a smart caching strategy for dynamic content? (proper use of If-Modified-Since, Expires, Cache-Control, etc.)
  3. ... make dealing with media types easy?
  4. ... make dealing with character encodings easy?
  5. ... encourage the use of standard HTTP authentication schemes?
  6. ... have a sane mechanism for attaching different behavior to different verbs for a single resource?
  7. ... help ensure that URIs stay cool?
  8. ... make dealing with transfer encodings (gzip, compress, etc.) easy?
  9. ... help you use response status codes properly? (e.g. Nearly all dynamic content returns either a 200 or 500).

Even if CherryPy isn't a framework, it should do most of these. The latest release of CherryPy, version 2.1, addresses some of these (3, 4, 5, 8, and 9). The others are possible, but not as easy as they could be; 1, 2, and 6 are top priorities (for me, anyway) to work into version 2.2. Items 3 and 4 could use more work, too.

10/20/05

Permalink 09:00:23 pm, by fumanchu Email , 332 words   English (US)
Categories: Python, CherryPy, WSGI

Is CherryPy a web framework?

Guido van Rossum recently wrote:

Python, in its design philosophy, tries hard not to be a framework. (This sets it apart from Java, which is hostile to non-Java code.) Python tries to be helpful when you want to solve part of your problem using a different tool. It tries to work well even if Python is only a small part of your total solution. It tries to be agnostic of platform-specific frameworks, optionally working with them (e.g. fork and pipes on Unix) but not depending or relying on them. Even threads are quite optional to Python.

Oddly enough, this is how I feel about CherryPy, that it tries hard not to be a framework. It tries to be helpful, recognizing that it's most likely only part of your solution. It tries to be agnostic of templating and persistence systems, and has little to say about markup languages, content-types, site architecture, or RPC formats.

Guido was responding to Phillip J. Eby, who wrote:

A Pythonic framework shouldn't load you down with new management burdens and keep you from using other frameworks. It should make life easier, and make your code more interoperable, not less. Indeed, I've pretty much come to agreement with the part of the Python developer community that has says Frameworks Are Evil.

Not wanting to be Evil, I've tried to make CherryPy 2.1 a system which doesn't load you down with new management burdens. Instead, it exposes the functionality of HTTP by presenting it in a Pythonic way. I and many others think it makes life easier—CherryPy appears to have an underscore-shaped learning curve. ;) And as for interoperability, CherryPy was one of the first Python web-application servers to grow a WSGI interface.

I suppose that CherryPy will always have to bear the moniker of "framework", if only because it calls your code, instead of the other way around. But let's keep it a Pythonic framework as long as we can.

Permalink 08:45:35 pm, by fumanchu Email , 14 words   English (US)
Categories: CherryPy

CherryPy in epydoc format

Link: http://www.turbogears.org/docs/api/cherrypy-module.html

Thanks, Kevin! Can we get a new one when CP 2.1 final is released? Please? :)

10/19/05

Permalink 12:37:37 am, by fumanchu Email , 159 words   English (US)
Categories: General, CherryPy

A severe shortfall in the motivational index

I can't seem to finish or maintain anything lately. I never can, but recently it's been more acute. Maybe it has to do with the pending release of CherryPy, which means we're in "feature freeze" mode; I miss writing the sweeping redesigns that I was able to shove into 2.1 before the beta.

But it's apparent in other areas, as well. I have about 80 hours of video transfer to DVD to do for various friends (and some personal projects). I haven't touched any of them in months. I also have a company to officially close, which is moving at a glacial pace. I've got a bunch of papers in triplicate that I need to mail off to the State, but can't seem to work up the drive to buy a large envelope for the purpose.

But then, having everything "done" is a much worse state. Maybe I should count my busy blessings.

10/06/05

Permalink 05:52:07 pm, by fumanchu Email , 359 words   English (US)
Categories: CherryPy

Eat less, exercise more

Dave Warnock muses:

I am not about to argue that [TurboGears and Subway] should merge, instead I feel they can improve most by making sure that they each stay thin putting all the improvements they can back into the components eg CherryPy (which they both have been doing) and into the deployment elements (setuptools and paste).

That's a good point, and I think it's at the heart of what CherryPy is trying to be: non-fattening. So there's definitely going to be some pushback from CherryPy itself trying to "stay thin".

I often say that CherryPy is not a "web framework"; it is an "HTTP framework". That is, it doesn't try to provide tools for every facet of web development. Instead, it concentrates on wrapping HTTP up in a Pythonic way.

IMO, working to stay thin is an important factor in getting CherryPy "more exercise": it gets used in more meta/mega-frameworks like Subway and TurboGears precisely because it hasn't gobbled up every good idea, just because it's web-related, or even just because it's Python. For example, CherryPy 2.1 is deprecating the Aspect module that was in 2.0, because it isn't related to the HTTP-focus of CherryPy.

David goes on:

Another project that is the next level down from these frameworks but that is also moving fast is Quixote, I feel the differences between Quixote and CherryPy are also becoming smaller (shown by the recent blog posts on Python Web Controllers). Whether they could ever merge is a different matter. Probably not possible (or even desireable) for the moment.

I would have to agree. There's a decisive difference in architectural style between CherryPy and Quixote. That doesn't mean there aren't components that are common to each, and there are certainly some which are unique to each which deserve to be ported! If the Quixote coders are willing to give up all the method names starting with set_ and get_ we're ready to have a conversation about merging. ;)

10/04/05

Permalink 04:09:43 pm, by admin Email , 65 words   English (US)
Categories: CherryPy

The medusa called autoreload

This is what I spent my weekend working on (among other things). It's the "autoreload" functionality in CherryPy. It was so complicated that it took me 15 minutes to understand it again, anytime I got distracted; having the diagram makes it quicker, at least. They say the human brain can handle about 7 things simultaneously, and this snake-pit takes about 4 at a minimum:

09/19/05

Permalink 11:52:49 am, by fumanchu Email , 193 words   English (US)
Categories: CherryPy

CherryPy 2.1 RC1 is out

The official mailing-list announcement is here.

The big change from 2.1 beta is the session filter—it's been completely rewritten.

Minor updates/fixes:

  • Server-side image maps (ISMAP) now supported.
  • More documentation in the official CherryPy book.
  • Improved coverage tool output.
  • Support for partial GET requests.
  • New HTTPError(status) exception, plus pretty HTML pages for 4xx-5xx responses.(which are customizable).
  • Separate access and error logs.
  • % HEX HEX decoding now works for URL's, not just params.
  • New cptools.serveFile function.
  • New config entries which allow you to limit the size of request headers and body (to avoid denial-of-service attacks).
  • Tracebacks can now be inserted into the CherryPy log via "server.logTracebacks" config entry (True by default).
  • New expose() function/decorator, which allows you to alias any page handler method.
  • HTTPRedirect can now be raised in _cpOnError or error filter methods.
  • Other minor bugs in the beta were fixed.

Way to go, team. I'm pleased as punch to be a part of this powerful, Pythonic product. :)

09/18/05

Permalink 10:04:45 pm, by fumanchu Email , 119 words   English (US)
Categories: CherryPy

mod_python wrapper for CherryPy

I wrote a WSGI wrapper for modpython a while back, but nobody's gotten it to work yet with Apache2 on Linux (at least, nobody in the CherryPy community). The current theory is that it's due to the differences in MPM's between Windows (mpm_winnt, which is one process with multiple threads) and Linux (worker, threadpool).

If you're stuck wanting CherryPy + modpython on Linux, have a look at Jamie Turner's new mpcp.py, which skips the WSGI layer and directly connects CherryPy to modpython. Then let everyone on #cherrypy know how it went. ;)

<< 1 2 3 4 5 6 >>

March 2017
Sun Mon Tue Wed Thu Fri Sat
 << <   > >>
      1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31  

Search

The requested Blog doesn't exist any more!

XML Feeds

free blog software