any suitable tests produced an ugly traceback. Instead the
testrunner now prints a warning to stderr.

Added an argument to pass error_log_url into raise_standardErrorMessage since logging is now done above it.

After further investigation I found that my change to SimpleItem to sniff the response._error_format was unnecessary (although harmless) since Zope/__init__.py already does this. This check has been removed.

And since error logging was being done in SimpleItem, my previous change prevented xml-rpc exceptions from being logged.

The logging code has now been moved into the Zope/__init__ top-level exception handler to correct this problem. This also seems generally more correct since we no longer rely on SimpleItem to do-the-right-thing.

Refactored error message handling so that SimpleItem's raise_standardErrorMessage sniffs the response to see if it wants an html encoded error message or not.

If so, then standard_error_message is rendered as usual as the error value. Otherwise the error value text is passed through unchanged.

XML-RPC responses now request text/plain error format so that standard_error_message is not envoked to render the fault string. Because of this, the previous formatting code could be removed, although html tags are still stripped because error values themselves sometimes contain tags 8^/

 - Value is stripped of HTML tags and minimally formatted

 - In debug mode, a full traceback is included in the fault string

occurs.  First, inherit from BerkeleyTestBase which has proper setUp
and tearDown methods, and second, wrap the .abort() and ._close() call
in tearDown() in a try/finally so we're guaranteed that the base
class's tearDown gets run.

likely to actually remove the test-db directory every time.

for 'index_html' default views. This breaks things like Cookie Crumbler. And
yes, when you use a JavaScript XML-RPC library, the browser could include an
authentication cookie for CookieCrumbler.

Instead, do not clear REQUEST_METHOD but check for a xmlrpc.Response object
when initiating the variable that will cause 'index_html' views to be used.

This fixes Zope Collector issue #528.

patch from Brad Clements (fixes Zope Collector issue #525).

specific addition of marshalling None to <boolean>0</boolean>.

Benefits gained:

  - Uses Expat when available (like in Zope), which makes unmarshalling
    (receiving XML-RPC calls) much,much faster.

  - New library imports other python modules lazily, which helps speed up
    Zope startup time.

  - Faster escape method for outgoing calls.

  - Fixes for doubles and larger integers.

  - Allow XML-RPC calls without an empty <params /> (fixes Zope Collector
    #465)

Additional fix:

  - Fix SlowParser to handle CDATA sections as well. With the ExpatParser
    this is less of a problem (fixes Zope Collector #547). Also see Python
    SF issue #601534.

missing when locking objects)

response.

opcode.

(finally) been defined: the serial number of objects in the
non-version after an abortVersion should be the last serial number of
the object before it was modified in the version.

This actually breaks the symmetry between serial numbers and
transaction ids, so it must be handled specially.

Specific changes include:

_setupDBs(): Updated documentation.

_finish(): Recognize the 'a' opcode, which is subtly different than
the 'o' opcode.  When the 'a' opcode is seen, we'll store both the
"live revision id" and the current transaction id in the _serials
table.  The former id is the serial number of the last change to the
non-version data.  If we're seeing the 'o' or 'x' opcodes, we'll save
None as the serial number, which tells the loop at the end of the
function that the object serial number and the transaction id are the
same (overwhelmingly, the most common case).

When serial# <> tid, we'll concatenate the two values together into
serial+tid as the value of the _serials's oid key.  So the value can
now be an 8-byte string (the common case), or a 16-byte string when
serial# <> tid.

_getSerialAndTid(): A new function which returns a 2-tuple of the
oid's current serial number and the tid of the last transaction that
modified the object.  Usually these are the same, but in the face of
abortVersion, they're not.

_getSerialAndTidMissingOk(): Like _getSerialAndTid() but if the oid
isn't in the _serials table, return (None, None) instead of raising a
KeyError.  Sometimes we need different table access semantics.

abortVersion(), commitVersion(), modifiedInVersion(), load(),
getSerial(), transactionalUndo(), history(), _dopack(): Use the new
_getSerialAndTid() access method to get the serial# and tid for the
last object modification, instead of accessing the _serials table
directly.

store(), _rootreachable(): Use _getSerialAndTidMissingOk()

and it is subtly different than the `o' opcode.  The serial number of
objects in the non-version after an abortVersion should be the last
serial number of the object before it was modified in the version.

This actually breaks the symmetry between serial numbers and
transaction ids, so it must be handled specially.

element if there isn't a prefix in the attribute name.

Fixes http://mail.zope.org/pipermail/zpt/2002-August/003697.html

The picklelog branch attempts to improve performance and reduce the
possibility of lock file exhaustion by optimistically writing pickle
and metadata tables at the store() call instead of during the
_finish() call.  store() will be bounded in the number of objects it
touches, but _finish() is unbounded, so we try to reduce the number of
database pages the latter might actually touch.

Other performance improvements are implemented based on hotshot
profiling.  The use of an extension module for Python 2.2 also speeds
up a critical loop.

This also implements the periodic checkpointing to improve recovery
times when the database is not cleanly shutdown.

doing a critical operation in C.  When fiddling the reference counting
we often need to

    1. unpack a 64bit string into a long
    2. add a delta value to the long
    3. pack the long into a 64bit string

_helper.incr() does these three steps in C.

This extension only works for Python 2.2, but Full.py has a Python
replacement for use with Python 2.1.

write_object(): uses the `x' opcode, which is very similar to `o'
except that the metadata is written optimistically during store() so
it shouldn't be written during _finish().

- Added BerkeleyConfig class for easier configuration of checkpointing
  policy and lock sizing.

- Added _lockstats() and _docheckpoint() helpermethods.