- Does converting an application to run within XA change any of
the already existing C/C++ API calls it does?
When converting an application to run under XA, the application's Berkeley DB
calls are unchanged, with two exceptions:
- The application must specify the DB_XA_CREATE flag to
the db_create interface.
- The application should never explicitly call txn_commit,
txn_abort or txn_begin, as those calls are replaced by
calls into the Tuxedo transaction manager. For the same reason, the
application will always specify a transaction argument of NULL to the
Berkeley DB functions that take transaction arguments (for example,
DB->put or DB->cursor).
Otherwise, your application should be unchanged.
- Is it possible to mix XA and non-XA transactions?
Yes. It is also possible for XA and non-XA transactions to coexist in
the same Berkeley DB environment. To do this, specify the same environment
to the non-XA DB_ENV->open calls as was specified in the Tuxedo
configuration file.
- How does Berkeley DB recovery interact with recovery by the Tuxedo
transaction manager?
Recovery is completed in two steps. First, each resource manager should
recover its environment(s). This can be done via a program that calls
DB_ENV->open or by calling the db_recover utility. If
using the db_recover utility, then the -e option
should be specified so that the regions that are recovered persist after
the utility exits. Any transactions that were prepared, but neither
completed nor aborted, are restored to their prepared state so that they
may be aborted or committed via the Tuxedo recovery mechanisms. After
each resource manager has recovered, then Tuxedo recovery may begin.
Tuxedo will interact with each resource manager via the __db_xa_recover
function which returns the list of prepared, but not yet completed
transactions. It should issue a commit or abort for each one, and only
after having completed each transaction will normal processing resume.
Finally, standard log file archival and catastrophic recovery procedures
should occur independently of XA operation.
The application should never explicitly call DB_TXN->commit,
DB_TXN->abort or DB_ENV->txn_begin, as those calls are replaced by
@
1.1.1.3
log
@Import: RPM 4.0.5
@
text
@d1 2
a2 2
a3 1
d14 1
a14 1
  
d19 16
a40 18
Does converting an application to run within XA change any of
the already existing C/C++ API calls it does?
When converting an application to run under XA, the application's Berkeley DB
calls are unchanged, with three exceptions:
- The application must specify the DB_XA_CREATE flag to
the db_create interface.
- Unless the application is performing an operation for a non-XA
transaction, the application should never explicitly call
DB_TXN->commit, DB_TXN->abort or DB_ENV->txn_begin, and those
calls should be replaced by calls into the Tuxedo transaction manager.
- Unless the application is performing an operation for a non-XA
transaction, the application should specify a transaction argument of NULL
to Berkeley DB methods taking transaction arguments (for example, DB->put
or DB->cursor).
Otherwise, the application should be unchanged.
d59 1
a59 1
|
@
1.1.1.4
log
@Import: RPM 4.1
@
text
@d1 2
a2 2
d4 1
d15 1
a15 1
|
a19 16
Does converting an application to run within XA change any of
the already existing C/C++ API calls it does?
When converting an application to run under XA, the application's Berkeley DB
calls are unchanged, with two exceptions:
- The application must specify the DB_XA_CREATE flag to
the db_create interface.
- The application should never explicitly call DB_TXN->commit,
DB_TXN->abort or DB_ENV->txn_begin, as those calls are replaced by
calls into the Tuxedo transaction manager. For the same reason, the
application will always specify a transaction argument of NULL to the
Berkeley DB functions that take transaction arguments (for example,
DB->put or DB->cursor).
Otherwise, your application should be unchanged.
d26 18
d62 1
a62 1
|
@
1.1.1.5
log
@Import: RPM 4.1.1
@
text
@d1 2
a2 2
a3 1
d14 1
a14 1
|
d19 16
a40 18
Does converting an application to run within XA change any of
the already existing C/C++ API calls it does?
When converting an application to run under XA, the application's Berkeley DB
calls are unchanged, with three exceptions:
- The application must specify the DB_XA_CREATE flag to
the db_create interface.
- Unless the application is performing an operation for a non-XA
transaction, the application should never explicitly call
DB_TXN->commit, DB_TXN->abort or DB_ENV->txn_begin, and those
calls should be replaced by calls into the Tuxedo transaction manager.
- Unless the application is performing an operation for a non-XA
transaction, the application should specify a transaction argument of NULL
to Berkeley DB methods taking transaction arguments (for example, DB->put
or DB->cursor).
Otherwise, the application should be unchanged.
d59 1
a59 1
|
|
|