|Version 6 (modified by 7 years ago) ( diff ),|
Trac maintains coherency upon data changes by using various
I...Listener extension points.
While this works in many cases, this approach is somewhat flawed or insufficient in situations where there are multiple server processes. And this is quite a common scenario, with the widespread use of the Apache/prefork web front-end.
Reacting on Wiki content change
Several Wiki pages are used to facilitate interactive configuration by the users. This is the case of the InterMapTxt, for maintaining the list of InterWiki prefixes, the BadContent page for maintaining a list of regexps used to filter out SPAM, and probably more in the future. See my original explanation about what's going on with updating InterMapTxt.
Reacting on Wiki page creation/deletion
In order to not have to check in the DB for the existence of a Wiki page every time a WikiPageNames is seen in wiki text, we maintain a cache of the existing wiki pages. This list could be easily maintained using the change listener, but this would not work if a creation and deletion would be done by another process. A workaround for this is currently implemented: every once in a while, the cache is cleared and updated (see from source:trunk/trac/wiki/api.py@3362#L114). This is a very ad-hoc solution. It should be possible to do this better and in a more generic way.
See TracDev/JournalingProposal for a more concise solution.
Now, what is described below is still useful for what has been discussed in #1890 (improved recording of ticket changes) and will eventually be consolidated with TracDev/Proposals/DataModel#ResourceChangeHistory one day.
For example, all the ticket changes are journaled, in the
CREATE TABLE ticket_change ( ticket integer, time integer, author text, field text, oldvalue text, newvalue text, UNIQUE (ticket,time,field) );
There's currently some discussion about adding to the above
authenticated columns, to better track
who did what (see #1890 for details).
But adding those to the above table would lead to even more duplication of data than what we currently have. Currently this duplication (of the ticket/time/author values) is even used to group together related changes!
Step in the Right Direction
A cleaner approach, for #1890, would be:
CREATE TABLE ticket_change ( tid integer, field text, oldvalue text, newvalue text, ); CREATE TABLE ticket_transaction ( tid integer PRIMARY KEY, ticket integer, time integer, author text, ipnr text, authenticated boolean );
Now, with this proposal, this could be extended to:
CREATE TABLE ticket_history ( tid integer, id int, field text, value text ); CREATE TABLE ticket_journal ( tid integer PRIMARY KEY, id int, change text, time integer, author text, ipnr text, authenticated boolean );
ticket_history could eventually be spread in multiple, type-specialized tables (
change column in
<resource>_journal could contain some keyword about
the nature of the change:
Each process would write into the
<resource>_journal table during the same
transaction that modifies the object model tables themselves.
This could be something along the lines of the following API:
class WikiModule(): def _do_create(self, pagename): ... # Getting a new transaction for creating a Wiki page tnx = ModelTransaction(self.env.get_db_cnx()) tnx.prepare(req.authname, 'CREATE') tnx.save('wiki', id=pagename, readonly=readonly, content=content) tnx.commit() # flush all changes to disk self.notify(tnx) # dispatch change information to listeners class TicketModule(): def _do_save(self, ticket): tnx = ModelTransaction(self.env.get_db_cnx()) tnx.prepare(req, 'MODIFY') tnx.save('ticket', ticket) tnx.commit() # flush all changes to disk self.notify(tnx) # dispatch change information to listeners
ModelTransaction object would know how to modify the underlying (generic) data model, hence the "Model" in the name.