[Zope] RE: ACS data schemas with Zope presentation

Sat, 7 Apr 2001 02:58:06 +1000

[fred]
On Thu, Apr 05, 2001 at 07:45:49AM +1000, Albert Langer wrote:
> There's nothing much that could or should be "ported" in
> the OpenACS Tcl. All DC needs to do is standardize
> python/Zope interfaces to the underlying SQL engine
> (I don't mean DAs to the database engine, but a Zopish
> replacement, not port, for the fairly thin layers done
> in Tcl).

At last, an actionable statement.  (I've long been intrigued about
using the ACS data model from a Zope front end, but all the whinging
on this thread is enough to sour one on the idea.)

Although I messed around with ACS3 a while back, I don't understand
the scope of what you mean by "the fairly thin layers" that need to be
standardized.  Could you refer to some specific Tcl code in the ACS
core that encompasses this layer.

[albert]
At last an actionable response. No need for me to whinge about the
lack of one ;-)

My advice would be to forget ACS3 completely as that's the official
ACS recommendation and it's much harder to disentangle the actual
database API from the Tcl line noise. ACS4 is a dramatically
different system with a clean API and much more object oriented.

The core of ACS consists of a kernel data model mainly accessed
directly by the other core modules. I'd study the sql for that first.

All modules now work through a small set of Tcl database api calls that
could fairly easily be replaced. Most of them have a fairly thin
layer above that. To understand the scope you'll need to go look at it.
*Much* easier than for ACS3, and greatly simplified by the approach
to porting with a Query Dispatcher (and SQL extractor) used by
OpenACS.

Note that the initial kernel only just released for internal
OpenACS development and core modules will be a while. But could
take that long to get familiar with what both ACS4 and OpenACS 4
are all about, so start catching up now to be able to use it when
it's ready.

[fred]
I'm currently doing some simple community websites using Zope and I've
borrowed from ACS to build "user" schemas (in PostgreSQL) that
underlie a LoginManager front end.  It's tempting to move on from that
basis and build additional features into the sites using a similar
scheme of Zope front-end to ACS data, and I'd like to explore Albert's
idea of an interface layer as opposed to direct Z SQL Method access of
the data.

[albert]
Definately the way to start! Note that the "user" schemas are now *heavily*
dependent on the kernel with group memberships etc generalized into handling
all kinds of relationships and permissions built into kernel.

There is of course much more needed but I'd say head on down there and start
looking at it now before discussion of that.

Please note that I am not even a participant in OpenACS project.

Get any further advice from people who actually know by joining the OpenACS
bboards.

Make sure you read their bboards first and then ask any questions there.

cvs address is mentioned within the bboards ;-)

Use that cvs - not the downloads from arsDigita (there are no downloads
from OpenACS yet).

I *strongly* recommend reading the docs *before* getting bogged down
in the Tcl - and work from the OpenACS version *not* the original ACS
version. Also read about the Query Dispatcher first and checkout
the python automatic extractor for the SQL.

Current version of extractor is at:
http://sindev.dyndns.org/openacs-tools.tgz

But has not been announced yet and will probably be replaced tomorrow.

This will make porting for both Tcl and python versions much easier.

(In general, ignore *anything* said by Chris when claiming to interpret
anything I am saying. Also I'd recommend not saying much about Zope
as Chris was there nearly a year ago and the impression he left
was distinctly unfavorable.)

Here's the relevant extracts from my original posting buried among
many other things, with URLs:

vvvvvvvvvvvvvvvvvv
ACS 4 provides an Oracle based web application server framework
with LDAP integration. The kernel has a finely grained permissions
system, with a role/party/group framework compatible with the
"Accountability" pattern and an object model compatible with
the "Domain Object Model" pattern. This is very appropriate
for a sophisticated LDAP directory backend (as well as being
necessary for the industrial strength RDBMS essential for
serious Zope ecommerce).

http://developer.arsdigita.com/doc/kernel-doc.html

http://www.martinfowler.com/ap2/index.html
http://www.martinfowler.com/apsupp/accountability.pdf
http://st-www.cs.uiuc.edu/users/johnson/DOM.html

ACS4 also provides an excellent workflow engine:
http://developer.arsdigita.com/doc/acs-workflow/

This can add the missing "strategy" side of the
Domain Object Model together with Transwarp.
Zope can provide much better UI and management
stuff to work with the engine.

It can also be a basis for reliable distributed
workflow/transactions/replication:

http://www.distribution.cs.ncl.ac.uk/projects/WorkflowSystem/index.html

This is a better approach for some types of database
replication than that currently proposed for ZEO or
the usual approaches described in Chapter 8 of:
http://research.microsoft.com/pubs/ccontrol/

ACS4 is being ported to PostgreSQL by OpenACS which
has previously ported ACS3:
http://openacs.org/4/
http://openacs.org/bboard/q-and-a.tcl?topic_id=12&topic=OpenACS%204%2e0%20De
sign

Initial version of kernel already out.

[...]
BTW, while I'm at it with all the links above, I'd like to draw
attention to some earlier postings re the need for Zope and ACS
to combined for viable ecommerce:

http://lists.codeit.com/pipermail/zcommerce/2000-June/000265.html
http://lists.codeit.com/pipermail/zcommerce/2000-June/000259.html
http://lists.codeit.com/pipermail/zcommerce/2000-June/000257.html

Right now arsDigita is going through a major upheaval and it looks
like OpenACS will provide an umbrella home for various ports of
ACS 4, including python/Zope as well as their main orientation
to Tcl. The data model of ACS4 is now much better separated from
the Tcl side and they are doing a Query Dispatcher for supporting
multiple RDBMS ports (with some tools in python for extracting
SQL from the Tcl code completely ;-).

http://developer.arsdigita.com/commerce-project-central/

http://www.arsdigita.com/bboard/q-and-a-fetch-msg?msg%5fid=000b5M&topic%5fid
=web%2fdb&topic=

http://www.arsdigita.com/bboard/q-and-a-fetch-msg?msg%5fid=000ZGz&topic%5fid
=web%2fdb&topic=

A Zopista involved in OpenACS has mentioned working on port of data
models of ecommerce module. That could result in a Zope port if there
is active support from DC.

http://openacs.org/bboard/q-and-a-fetch-msg.tcl?msg_id=0001AP&topic_id=12&to
pic=OpenACS%204%2e0%20Design

At the same time there seems to be some problems with an AOLserver
fork that could result in greater interest in using Zserver (don't
know much about that - just speculating).

If June 2000 was "premature", perhaps this is a better time to
hope for some serious DC interest both in enabling an industrial
strength ecommerce and workflow system for Zope [...]
^^^^^^^^^^^^^^