On Tuesday, July 30, 2002, at 09:19 AM, Mukhsein Johari wrote:
The project: I would like to serve a dynamic website using the twisted web server. I understand that the webserver's 'root' directory can be set at a file? I may have a misunderstanding of the code and docs but if so, feel free to set me straight.
When you create a tap file using "bin/mktap web --path /foo/bar/baz", mktap creates a File instance, which is a Resource subclass, which knows to look in "/foo/bar/baz" as the root directory of the site. However, mktap is just a "helper" script that instanciates, configures, and persists various common application types. If you want the root object of your web site to be a custom Resource subclass that only serves dynamic pages, you're free to do that.
The website (not real): http://www.mywebsite.com/
This is the root of the site, which is in reality a erm..rpy? program? Which means that there are _no_ static pages at all. And no other 'file' - everything goes through that .rpy file. (or whatever else I should be using)
So, as I just said, what you should do is create your own Application instance, create an instance of twisted.web.server.Site, and create your own custom Resource subclass to act as the root of that site. Your Resource subclass should override getChild(name, request) and render(request), as I will describe below. Here's how you would go about starting your custom server:
from twisted.web import server from twisted.internet import reactor
root = myGreatResourceSubclass.MyRoot()
site = server.Site(root)
reactor.listenTCP(8080, site) reactor.run()
In a browser, entering this would get a dynamically 'constructed' page which is in fact:
In the example above, visiting the root page would end up invoking root.render(request).
From here on, something like: http://www.mywebsite.com/projects/project_ako
would actually be (in the code) something like:
If these semantics are what you *really* want (i.e. transparency, getitem, or getattr being used for traversal), I suggest looking at Zope or Quixote, as Itamar suggested. However, here's how the following would look in twisted:
root.getChild("projects", request).getChild("project_ako", request).render(request)
In your root Resource subclass, you can define getChild to do whatever you wish such as dynamically generate a new Resource subclass to handle the "projects" portion, which in turn has a getChild that knows how to create an object to handle the "project_ako" portion, which in turn has a render() method that returns a string, which will be sent to the browser.
which returns an html page suitable for the browser's consumption. On the other hand this:
(for http GET. POST should be handled as well...how? I am guessing the request object?)
Would call: myobject.projects["project_ako"].index(myvar='bold')
It would be exactly the same call as above, except request.args would be a dictionary that looked like this:
Note that every value in the args dictionary is always a list, to make handling lists and non lists more uniform.
Any other subobject of project_ako would 'call' a method on that object.
Would call: myobject.projects["project_ako"].getSize()
The return value being sent back to the browser. Calls to non-existing methods get a "No such method or object" error returned - formatted, of course.
If you want automatic getChild traversal to stop at the object representing "project_ako", set isLeaf = 1 on the object representing "project_ako". This will cause render(request) to be called on "project_ako" with the remaining elements of the path in request.postpath. You can then implement the semantics described above in your render() method.
However, I find it much easier to divide functionality into separate classes and always use render() to do the html generation.
The question is of course, how do you differentiate between an object and a method? This is done by the application itself. It would check to see if that object has a method with that name, if not check to see if it has a child object with that name. Else return error.
If this is *really* the functionality that you want, again, this is far more similar to the traversal semantics of Zope or Quixote. Twisted has taken a far more explicit tack, where there is a specific api that your objects must implement to provide object-publishing functionality.
The thing is, I know I need to use twisted.web.resource but I'm not sure _how_. How does this fit in with the .rpy file? I think I need to create my modules and classes and then create an .rpy which acts as the erm..'interface' to the modules and classes. Could someone give me some hints and tips?
Conceptually, it's quite simple but I can't seem to figure out how to do it with twisted...Anyway, thanks for any help, in advance.
Hope this helps!