home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_292 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  5.4 KB  |  157 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import unittest
  6. from test_all import db, test_support, get_new_environment_path, get_new_database_path
  7.  
  8. try:
  9.     a = set()
  10. except:
  11.     from sets import Set as set
  12.  
  13. del a
  14. from test_all import verbose
  15.  
  16. class DBTxn_distributed(unittest.TestCase):
  17.     num_txns = 1234
  18.     nosync = True
  19.     must_open_db = False
  20.     
  21.     def _create_env(self, must_open_db):
  22.         self.dbenv = db.DBEnv()
  23.         self.dbenv.set_tx_max(self.num_txns)
  24.         self.dbenv.set_lk_max_lockers(self.num_txns * 2)
  25.         self.dbenv.set_lk_max_locks(self.num_txns * 2)
  26.         self.dbenv.set_lk_max_objects(self.num_txns * 2)
  27.         if self.nosync:
  28.             self.dbenv.set_flags(db.DB_TXN_NOSYNC, True)
  29.         
  30.         self.dbenv.open(self.homeDir, db.DB_CREATE | db.DB_THREAD | db.DB_RECOVER | db.DB_INIT_TXN | db.DB_INIT_LOG | db.DB_INIT_MPOOL | db.DB_INIT_LOCK, 438)
  31.         self.db = db.DB(self.dbenv)
  32.         self.db.set_re_len(db.DB_XIDDATASIZE)
  33.         if must_open_db:
  34.             if db.version() > (4, 1):
  35.                 txn = self.dbenv.txn_begin()
  36.                 self.db.open(self.filename, db.DB_QUEUE, db.DB_CREATE | db.DB_THREAD, 438, txn = txn)
  37.                 txn.commit()
  38.             else:
  39.                 self.db.open(self.filename, db.DB_QUEUE, db.DB_CREATE | db.DB_THREAD, 438)
  40.         
  41.  
  42.     
  43.     def setUp(self):
  44.         self.homeDir = get_new_environment_path()
  45.         self.filename = 'test'
  46.         return self._create_env(must_open_db = True)
  47.  
  48.     
  49.     def _destroy_env(self):
  50.         if self.nosync or db.version()[:2] == (4, 6):
  51.             self.dbenv.log_flush()
  52.         
  53.         self.db.close()
  54.         self.dbenv.close()
  55.  
  56.     
  57.     def tearDown(self):
  58.         self._destroy_env()
  59.         test_support.rmtree(self.homeDir)
  60.  
  61.     
  62.     def _recreate_env(self, must_open_db):
  63.         self._destroy_env()
  64.         self._create_env(must_open_db)
  65.  
  66.     
  67.     def test01_distributed_transactions(self):
  68.         txns = set()
  69.         
  70.         adapt = lambda x: x
  71.         import sys
  72.         if sys.version_info[0] >= 3:
  73.             
  74.             adapt = lambda x: bytes(x, 'ascii')
  75.         
  76.         for i in xrange(self.num_txns):
  77.             txn = self.dbenv.txn_begin()
  78.             gid = '%%%dd' % db.DB_XIDDATASIZE
  79.             gid = adapt(gid % i)
  80.             self.db.put(i, gid, txn = txn, flags = db.DB_APPEND)
  81.             txns.add(gid)
  82.             txn.prepare(gid)
  83.         
  84.         del txn
  85.         self._recreate_env(self.must_open_db)
  86.         recovered_txns = self.dbenv.txn_recover()
  87.         self.assertEquals(self.num_txns, len(recovered_txns))
  88.         for gid, txn in recovered_txns:
  89.             self.assert_(gid in txns)
  90.         
  91.         del txn
  92.         del recovered_txns
  93.         self._recreate_env(self.must_open_db)
  94.         recovered_txns = self.dbenv.txn_recover()
  95.         self.assertEquals(self.num_txns, len(recovered_txns))
  96.         discard_txns = set()
  97.         committed_txns = set()
  98.         state = 0
  99.         for gid, txn in recovered_txns:
  100.             if state == 0 or state == 1:
  101.                 committed_txns.add(gid)
  102.                 txn.commit()
  103.             elif state == 2:
  104.                 txn.abort()
  105.             elif state == 3:
  106.                 txn.discard()
  107.                 discard_txns.add(gid)
  108.                 state = -1
  109.             
  110.             state += 1
  111.         
  112.         del txn
  113.         del recovered_txns
  114.         self._recreate_env(self.must_open_db)
  115.         recovered_txns = self.dbenv.txn_recover()
  116.         self.assertEquals(len(discard_txns), len(recovered_txns))
  117.         for gid, txn in recovered_txns:
  118.             txn.abort()
  119.         
  120.         del txn
  121.         del recovered_txns
  122.         self._recreate_env(must_open_db = True)
  123.         recovered_txns = self.dbenv.txn_recover()
  124.         self.assert_(len(recovered_txns) == 0)
  125.         self.assertEquals(len(committed_txns), self.db.stat()['nkeys'])
  126.  
  127.  
  128.  
  129. class DBTxn_distributedSYNC(DBTxn_distributed):
  130.     nosync = False
  131.  
  132.  
  133. class DBTxn_distributed_must_open_db(DBTxn_distributed):
  134.     must_open_db = True
  135.  
  136.  
  137. class DBTxn_distributedSYNC_must_open_db(DBTxn_distributed):
  138.     nosync = False
  139.     must_open_db = True
  140.  
  141.  
  142. def test_suite():
  143.     suite = unittest.TestSuite()
  144.     if db.version() >= (4, 5):
  145.         suite.addTest(unittest.makeSuite(DBTxn_distributed))
  146.         suite.addTest(unittest.makeSuite(DBTxn_distributedSYNC))
  147.     
  148.     if db.version() >= (4, 6):
  149.         suite.addTest(unittest.makeSuite(DBTxn_distributed_must_open_db))
  150.         suite.addTest(unittest.makeSuite(DBTxn_distributedSYNC_must_open_db))
  151.     
  152.     return suite
  153.  
  154. if __name__ == '__main__':
  155.     unittest.main(defaultTest = 'test_suite')
  156.  
  157.