|
Pythomnic » Documentation » Architecture (cage structure)
Each cage has a very specific internal architecture, it essentially has four
parts to it:
1. Interfaces
Interfaces accept requests from the application clients. Each interface is
handling the details of the particular network protocol and converts the
incoming network request into a call to a Pythomnic application module.
The requests Pythomnic application is capable of processing can take
form of synchronous requests (web services - SOAP, XML-RPC or HTTP),
asynchronous requests, arriving as some sort of messages (JMS, POP3)
or something else entirely (ex. appearance of a file on a shared directory).
This is what you write - there are none by default, the cage you start
could be accepting requests through the interfaces you enable on it, but
their processing is up to you. These are regular Python modules residing
in the cage's subdirectories. The most significant thing Pythomnic adds
with respect to writing your own processing application modules is that
those modules are reloadable at runtime. You don't have to shut down
the cage to make an updated module in effect - you just edit it and save.
Next time the module is accessed, it gets reloaded.
Most of the code you write in your application modules is acting like
middleware - doing what it can do, delegating what it can't do to some other
system, gluing parts of the application together. Much of the actual
request processing is only initiated by your code but is actually done
by external systems of one sort or another. For example, more often
than not you will be having a database around, running on a separate
server, treated by Pythomnic as an external system. Other examples
may include LDAP server you may be using for authentication, mail
server you engage for sending e-mails and so on. All cage's accesses
to external systems are subject to uniform rules.
Since an application is split into several cages, there must be a way for
them to communicate. Cage-to-cage communications in Pythomnic
take form of either synchronous RPC calls or asynchronous messages
sent from source cage directly to the target cage in a P2P manner.
|
Features Download Documentation Tutorial |