Is there an obvious way to do this in python?

[Bruno Desthuilliers]

H J van Rooyen wrote:
> "Bruno Desthuilliers" <bdesth.quelquechose at free.quelquepart.fr> wrote:
> 
> 
> |H J van Rooyen a écrit :
> |> Hi,
> |>
> |> I want to write a small system that is transaction based.
> |>
> |> I want to split the GUI front end data entry away from the file handling and
> |> record keeping.
> |>
> |> Now it seems almost trivially easy using the sockets module to communicate
> |> between machines on the same LAN, so that I want to do the record keeping on
> one
> |> machine.
> |>
> |> I want to keep the "server" machine as simple as possible - just doing record
> |> keeping on a stimulus response basis - I would prefer it to do one thing at a
> |> time to completion because this style of operation, though limited in
> |> performance, keeps a lot of hassles out of life - a transaction has either
> |> completed, or it has not - recovery scenarios are relatively easy...
> |
> |IOW, you want a SQL DBMS. May I recommand PostgreSQL ?
> |
> 
> Looks like the way to go - after the argy bargy here in another thread seems
> mySQL has no supporters left...

Indeed, my choices would now be SQLite for simple things and PostgreSQL
for more serious stuff...

> |> Up to this point, I don't have a problem - my toy system can create a dummy
> |> transaction, and I can echo it from the "server" machine, with more than one
> |> "user" machine running - so I think it is feasible to have several tens of
> "data
> |> entry terminal" systems running, served by one not very strong machine.
> |>
> |> Now what I would really like to do is to differentiate between the 'User"
> |> machines, so that some can do a full range of transactions, and others a
> limited
> |> range.
> |
> |Any decent SQL DBMS is able to handle this. It's kind of builtin...
> 
> Yes - if you do the whole job on the server -

> the architecture I have mind is
> more like a banking terminal scenario - please see my reply to Simon

(...)
Done. And I still think that a CherryPy/PostgreSQL based solution is the
way to go.

> |
> |> And I would like to make this flexible, so that it becomes easy to introduce
> new
> |> transactions, without having to run around updating the code in all the user
> |> machines, with the concomitant version number hassles.
> |
> |Then you want a web front end.
> 
> This seems to me to assume that the server does all the work

Not necessarily. Of course most computations are done on the server, but
what you describe here really feels like AJAX IMHO. Have a look at some
Turbogears AJAX addons like Catwalk and ModelDesigner...

> |
> |> And I would like to do the whole thing in python
> |
> |You'll at least need bits of SQL (but SQLAlchemy may hide away most of
> |it) and HTML (but there are some python packages that knows how to build
> |HTML from declarative Python code).
> |
> 
> that is good news - which packages?

http://divmod.org/trac/wiki/DivmodNevow
http://divmod.org/trac/wiki/DivmodNevow/Athena
http://starship.python.net/crew/friedrich/HTMLgen/html/main.html
http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/366000
http://dustman.net/andy/python/HyperText/
http://pyhtmloo.sourceforge.net/



> |> - so my question is this - is
> |> it possible to do the equivalent of dynamic linking? - i.e. if I keep a list
> of
> |> what a user is allowed to do
> |
> |In SQL : GRANT/REVOKE
> 
> again - centric thinking - I really would like to change the bits on the client,
> as I explained to Simon
> 
> |
> |> - can I somehow send him just the bits he needs to
> |> do the job, without having to change the static code on his machine?
> |
> |HTTP/HTML.
> |
> 
> everybody says this

Well, there must be a reason...

> - I am being dragged, kicking and screaming...
> 
> |> - it seems
> |> to me that the eval() thingy could possibly do this for me,
> |
> |Err... I thought you wanted a reasonnably secure system, but I may have
> |misunderstood.
> |
> 
> this is the guts of what I want - if eval is NFG then how do I implement such a
> kind of "dynamic linking" of modules on the client?

You may want to look at stuff like Pyro (Python remote objects).

> |> by sending it data
> |> that makes it do import statements followed by calls to whatever... - will
> this
> |> work, or is there a better way?
> |>
> |> Or has all this been done already?
> |
> |Yes, it's called a web frontend for a SQL DBMS. There's no shortage of
> |Python frameworks to do this kind of things.
> |
> 
> I kind of wanted to avoid the web based stuff - the application data is so small
> and trivial, in a sense.

So why even bother writing your own transaction manager, dynamic client
and protocol when the whole thing already exists - PostgreSQL,
Javascript-enabled browser and HTTP... FWIW, deploying a CherryPy
application is really trivial. I have not tested Divmod/nevow yet, but I
think you should have a look there too.


> |> - and no I don't want a web server
> |
> |If you don't want Apache, there are Python-based application servers.
> |CherryPy comes to mind.
> |
> |> and php
> |
> |Why PHP ?
> |
> 
> seems popular

Yes, but why PHP ? Python is quite good for web apps.

> |> and browsers and Java
> |
> |Why Java ?
> |
> 
> it addresses what I want - to dynamically and securely download bits of code and
> execute them on the remote machine...

If you really want security, you have to keep the critical parts on the
server.

> |> and html or xml... - I want to write something that works
> |> simply and reliably
> |
> |We do write SQL-based web apps all day long, and I can tell you they are
> |certainly more simple and reliable than whatever eval()-based home-made
> |solution we could imagine !-)
> 
> Aah! but I would like you to stretch that imagination - to tell me how to do
> some of what Java was designed to do,

Initially, Java - it was named Oak by the time - was designed for
embedded programming. It happened to be a failure. Then it was renamed
to Java and "redesigned" (hum) for rich web client (applets). It still
failed there. It also failed for traditional cross-platform GUI
programming (too heavy and too autistic), and finally happened to make
it on the web server side, but even there it's a really heavy-weight
solution with no obvious practical advantage wrt/ more agile solutions
(PHP, Python, Ruby, Perl etc) IMHO.

> but better and easier, because this is
> python we are talking about...


indeed !-)

> I saw something in another thread here - they were talking about weave

???

> - can I
> use that if eval is nfg?

Can't tell...

> If my original post was unclear I am sorry - the point I want answered, if
> possible, is how to make the client code effectively updateable on the fly -
> because the answer to this will influence the whole design of the rest of the
> system...

This is something I have been thinking about... IMHO what you want is
not to "update client code on the fly", but to make the client mostly a
kind of interpreter for what the server sends in. That is, the client
code itself doesn't contain any application logic, it gets it from the
server and execute it. This can certainly be done with Pyro.

Now while this may be an interesting project, I'm not really sure it's
worth the effort when we already have HTTP, HTML and AJAX...

-- 
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'onurb at xiludom.gro'.split('@')])"