While looking for a good python wiki, i found http://wiki.w4py.org/thiswiki.html (wiki.Webware) really interesting. And once again this is webware so :

• you don’t have a tgz .. but a direct fight with Subversion
• this is a really little piece of code ..
• you don’t have any ‘howto install’ ( nor any doc in fact)
• it use the LoginKit which is somewhere i don’t know .. (even the wiki.webware search don’t know this:)
• the install should be hard for a non-webware-developper because:
• it came w/ a lib/ folder .. what should i do w/ that ???
• and a Context .. ?? (why not a wiki/ folder ??)
• I think I missed the new webware developper guides ..

I don’t want to use something else so .. somebody can help me ?

But on the other side, i really think some part of webware should be left out. Look at the standard webware packages:

• CGIWrapper
• WebKit
• WebUtils
• MiscUtils
• COMKit
• MiddleKit
• PSP
• TaskKit
• UserKit

Only CGIWrapper / WebKit / WebUtils are used in Webware core. (+ TaskKit) All other stuff are not webware centric, even if they are usually working only by webware developpers:
- COMKit is win32 COM object related (nothing to do w/ webware core)
- MiddleKit is a DB abstraction layer
- PSP is a template language
- UserKit is a user framework ..( someone ever used it ???)

I really think we should provide only a simple package w/ webware core, and find a way to install third parties code as ‘Products’. This is definitly the main feature of Zope.

The recent post of Ian on the webware-discuss mailing list show that we shall write webware component like Wiki .. or AuthModule .. and provide them to the community.

I worked on Zope for about 2 years.. and right now when i want to build a simple website for the lab. Webware never come to my mind simply because it enforce me to rewrite the wheel for everything. In common web project we need some core components like auth, or photo gallery .. things that are really simple and provided w/ simple Zope Products. but for webware we only provide some _unusefull_ / _unmaintained_ Kit.

This is not a contestation post! but a open letter to the webware community.

The current webware package try to enforce developper to use some tools (like PSP / MiddleKit) but this is the wrong way. I never used PSP (i hate this syntax).. and MiddleKit has serious competitor, right now. I usually use SQLObject and ZPTPage. But there is no place on the web where a newbie can find that you can write ZPT in webware .. Webware really need a clean way to build Products and a website that present all this stuff to users.

# put this in your context __init__.py file

class CustomParser(URLParser.URLParser):
"""
Class to do the dispatch of Request it should return a servlet instance
if we return nothing the default Webware behaviour is used
"""

def parse(self,trans,requestPath):
values=string.split(requestPath,'/')

if values[-2] == 'Article':
restPart = '/'
name = 'blog/Article.py'

req = trans.request()
req.setField('id',values[-1])

req._extraURLPath = restPart
req._serverSidePath = name
return URLParser.ServletFactoryManager.servletForFile(trans, name)

# we use the default url handling
return None

urlParser=CustomParser()

So now url like http://alias.larsen-b.com/Article/1 will map to the servlet Article.py and argument id=1 (http://alias.larsen-b.com/Article?id=1).
Of course this is a really simple example, but you can do things really more funny.

To test: Just copy the WebKit/Adapters/HTTPAdapter.py in your current Webware instance, edit this file to feet w/ your need ( mainly the 2 first vars ), and run it directly.
Now point your mozilla to http://localhost:8080/ and enjoy :)

I haven’t play w/ Webware since a while.. and i don’t know the real difference between this and ‘Standalone Webkit’ .. but this is pretty kool ..

Now i need to look at the URLHandler as Ian tell me..

This sound amaizing since i have already done several things like this, using ww and Modeling but i found that using a RDBDM for a little blog ( < 1000 post) isn’t a good idea. Need a lot of works for DB management, developpement and lot of trouble for migration. In this other side, using plain old fashion text file isn’t a good way too since you can’t introduce feature easily .. and writing text file need a lot of work to take care about author and date and so on..

I finally conclude the best way to have something that is usefull ( as a long time process ) it to have a ‘object oriented’ store backend. So i choose ZODB, but MetaKit can be a good challenger too.

Another thing that i found usefull in Zope, is the handly of URL. I don’t need to scratch my hairs playing w/ Apache Rewrite Rules .. and other stuff. I read recently that Webware is to be rewriten.. I hope the dev team will tray to fix this in webware too.

I really think that it should be possible to declare some kind of URL to be handled by a certain Webware Servlet. Perhaps using the same type <=> class mapping as Zope do.. This can of course done w/ Apache Rewrite but i don’t find this really nice, having to tweak apache config while i’m developping is awfull for me. ( Even using apache is a bit crudy for me ..)

import os,time

from ZPTPage import ZPTPage

class A:
    def __init__(self):
        self.a = 'B' * 50
        self.willChange()

    def getA(self):
        self.willRead()
        return self.a

    def setA(self,value):
        self.a=value
        self.willChange()

    def willRead(self):
        #print "Read %s" % self
        pass

    def willChange(self):
        self.lastChange = time.time()

class HereProxy(dict):
     def __init__(self,orig):
        print "New Here"
        self.orig = orig

     def __getitem__(self,key):
         result=getattr(self.orig,key)
         print "*** %-10s : %s " % ( key,result)
         cache = self.orig.application().cache[self.orig.hashCache()]

         if result not in cache:
             cache.update( {result:result.lastChange })
         return result

class Main(ZPTPage):
    def __init__(self):
        self.a = A()
        ZPTPage.__init__(self)
        self.here = HereProxy(self)
        self.validCache = False

    def writeHTML(self):
        if self.request().hasField('A'):
            self.a.setA(self.request().value('A') )

        cachedFileName=os.path.join('/tmp/w/',self.hashCache() +'.html')
        try:
            cache = self.application().cache[self.hashCache()]
        except KeyError:
            self.application().cache[self.hashCache()] = {}
            cache = self.application().cache[self.hashCache()]

        needUpdate = 0

        #import pdb;pdb.set_trace()
        for obj in cache.keys():
            try:
                print obj.lastChange
                if obj.lastChange !=  cache[obj]:
                    needUpdate = 1
                    break
            except AttributeError:
                needUpdate = 1
                break

        if needUpdate == 0:
            print "*** Serving cache %s ***"  % self.hashCache()
            try:
                data = open(cachedFileName,'r').read()
            except IOError:
                needUpdate = 1

        if needUpdate:
            print "*** Regerating %s ***"  % self.hashCache()
            self.buildContext()
            data = self.template.render()
            open(cachedFileName,'w').write(data)
        self.response().setHeader('Content-type', 'text/html; charset=UTF-8')
        self.writeln(data)

    def buildContext(self):
        self.updateContext('text','Toto')

    def getTime(self):
        import time
        return time.time()

    def getHere(self):
        #return {'a':A()}
        return self.here

    def sleep(self,context):
        print self.application().cache
        ZPTPage.sleep(self,context)

    ### cache ###
    def hashCache(self):
        return "MainTemplate"