public void GetCursorWithExplicitTxn(string home,
string dbFile, bool ifConfig)
{
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, envConfig);
Transaction openTxn = env.BeginTransaction();
RecnoDatabaseConfig dbConfig =
new RecnoDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
RecnoDatabase db = RecnoDatabase.Open(dbFile,
dbConfig, openTxn);
openTxn.Commit();
Transaction cursorTxn = env.BeginTransaction();
RecnoCursor cursor;
if (ifConfig == false)
{
cursor = db.Cursor(cursorTxn);
}
else
{
cursor = db.Cursor(new CursorConfig(), cursorTxn);
}
cursor.Close();
cursorTxn.Commit();
db.Close();
env.Close();
}
public void ReadTxn()
{
// Get a new transaction for reading the db.
TransactionConfig txnConfig =
new TransactionConfig();
txnConfig.Snapshot = true;
readTxn = paramEnv.BeginTransaction(
txnConfig);
// Get a new cursor for putting record into db.
CursorConfig cursorConfig = new CursorConfig();
cursorConfig.WriteCursor = false;
BTreeCursor cursor = paramDB.Cursor(
cursorConfig, readTxn);
// Continually reading record from db.
try
{
Assert.IsTrue(cursor.MoveFirst());
int i = 0;
do
{
Assert.AreEqual(
BitConverter.ToInt32(
cursor.Current.Key.Data, 0),
BitConverter.ToInt32(
cursor.Current.Value.Data, 0));
} while (i <= 1000 && cursor.MoveNext());
}
catch (DeadlockException)
{
}
finally
{
cursor.Close();
}
}
public void TestEmptyException()
{
testName = "TestEmptyException";
SetUpTest(true);
DatabaseEnvironment master = SetUpEnv(testHome + "/master", 100, 8000, true);
Transaction txn = master.BeginTransaction();
txn.Commit();
byte[] token = txn.CommitToken;
Assert.AreEqual(TransactionAppliedStatus.EMPTY_TRANSACTION,
master.IsTransactionApplied(token, 1000));
master.Close();
}
public void OpenNewSequenceInEnv(string home, string dbname,
out DatabaseEnvironment env, out BTreeDatabase db,
out Sequence seq)
{
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
envConfig.UseLogging = true;
env = DatabaseEnvironment.Open(home, envConfig);
Transaction openTxn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig =
new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
db = BTreeDatabase.Open(dbname + ".db", dbConfig,
openTxn);
openTxn.Commit();
Transaction seqTxn = env.BeginTransaction();
SequenceConfig seqConfig = new SequenceConfig();
seqConfig.BackingDatabase = db;
seqConfig.Creation = CreatePolicy.ALWAYS;
seqConfig.Decrement = false;
seqConfig.FreeThreaded = true;
seqConfig.Increment = true;
seqConfig.InitialValue = 0;
seqConfig.key = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("key"));
seqConfig.SetRange(Int64.MinValue, Int64.MaxValue);
seqConfig.Wrap = true;
seq = new Sequence(seqConfig);
seqTxn.Commit();
}
public void TestTruncateUnusedPagesInTxn()
{
testName = "TestTruncateUnusedPagesInTxn";
testHome = testFixtureHome + "/" + testName;
Configuration.ClearDir(testHome);
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseLogging = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
Transaction openTxn = env.BeginTransaction();
RecnoDatabaseConfig dbConfig =
new RecnoDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
dbConfig.PageSize = 512;
RecnoDatabase db = RecnoDatabase.Open(
testName + ".db", dbConfig, openTxn);
openTxn.Commit();
Transaction modifyTxn = env.BeginTransaction();
ModifyRecordsInDB(db, modifyTxn);
Assert.Less(0, db.TruncateUnusedPages(modifyTxn));
modifyTxn.Commit();
db.Close();
env.Close();
}
public void TestNestedTXN()
{
testName = "TestNestedTXN";
SetUpTest(true);
DatabaseEntry key, data;
DatabaseEnvironment master = SetUpEnv(testHome + "/master", 100, 8000, true);
BTreeDatabase db = Open(master, true);
TransactionConfig txnconfig = new TransactionConfig();
Transaction txn = master.BeginTransaction();
Transaction txn1 = master.BeginTransaction(txnconfig, txn);
key = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("Key"));
data = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("Data"));
db.Put(key, data, txn1);
txn1.Commit();
txn.Commit();
byte[] token;
Assert.Throws <ArgumentException>(delegate { token = txn1.CommitToken; });
master.Close();
}
public void TestAppendWithTxn()
{
testName = "TestAppendWithTxn";
SetUpTest(true);
string heapDBFileName = testHome + "/" + testName + ".db";
string heapDBName =
Path.GetFileNameWithoutExtension(heapDBFileName);
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
Transaction txn = env.BeginTransaction();
HeapDatabaseConfig heapConfig = new HeapDatabaseConfig();
heapConfig.Creation = CreatePolicy.ALWAYS;
heapConfig.Env = env;
/* If environmnet home is set, the file name in
* Open() is the relative path.
*/
HeapDatabase heapDB = HeapDatabase.Open(
heapDBName, heapConfig, txn);
DatabaseEntry data;
int i = 1000;
try {
while (i > 0)
{
data = new DatabaseEntry(
BitConverter.GetBytes(i));
heapDB.Append(data, txn);
i--;
}
txn.Commit();
} catch {
txn.Abort();
} finally {
heapDB.Close();
env.Close();
}
}
public void TestPutNoDuplicateWithTxn()
{
testName = "TestPutNoDuplicateWithTxn";
testHome = testFixtureHome + "/" + testName;
Configuration.ClearDir(testHome);
// Open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseLogging = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
// Open a hash database within a transaction.
Transaction txn = env.BeginTransaction();
HashDatabaseConfig dbConfig = new HashDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Duplicates = DuplicatesPolicy.SORTED;
dbConfig.Env = env;
HashDatabase db = HashDatabase.Open(testName + ".db", dbConfig, txn);
DatabaseEntry dbt = new DatabaseEntry(BitConverter.GetBytes((int)100));
db.PutNoDuplicate(dbt, dbt, txn);
try
{
db.PutNoDuplicate(dbt, dbt, txn);
}
catch (KeyExistException)
{
throw new ExpectedTestException();
}
finally
{
// Close all.
db.Close();
txn.Commit();
env.Close();
}
}
public void GenerateDeadlock()
{
Transaction txn = testLockStatsEnv.BeginTransaction();
try
{
testLockStatsDb.Put(
new DatabaseEntry(BitConverter.GetBytes(100)),
new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes(
Configuration.RandomString(200))), txn);
DeadlockDidPut = 1;
testLockStatsDb.Get(new DatabaseEntry(
BitConverter.GetBytes(10)), txn);
}
catch (DeadlockException) { }
// Abort unconditionally - we don't care about the transaction
txn.Abort();
}
public static void GetCursorInBtreeDBInTDS(
string home, string name,
CursorConfig cursorConfig,
out DatabaseEnvironment env, out BTreeDatabase db,
out BTreeCursor cursor, out Transaction txn)
{
string dbFileName = name + ".db";
Configuration.ClearDir(home);
// Open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
envConfig.NoMMap = false;
envConfig.UseLocking = true;
env = DatabaseEnvironment.Open(home, envConfig);
// Begin a transaction.
txn = env.BeginTransaction();
/*
* Open an btree database. The underlying database
* should be opened with ReadUncommitted if the
* cursor's isolation degree will be set to be 1.
*/
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
if (cursorConfig.IsolationDegree == Isolation.DEGREE_ONE)
{
dbConfig.ReadUncommitted = true;
}
db = BTreeDatabase.Open(dbFileName, dbConfig, txn);
// Get a cursor in the transaction.
cursor = db.Cursor(cursorConfig, txn);
}
public void TestInvalidToken()
{
DatabaseEntry key, data;
DatabaseEnvironment master = SetUpEnv("./master", 100, 8000, true);
BTreeDatabase db = Open(master, true);
Transaction txn = master.BeginTransaction();
key = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("Key"));
data = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("Data"));
db.Put(key, data, txn);
txn.Commit();
byte[] token = txn.CommitToken;
token[19] += 123;
Assert.Throws <DatabaseException>(delegate { master.IsTransactionApplied(token, 1000); });
db.Close();
master.Close();
}
public static void SetUpEnvWithTxnAndLocking(string envHome,
out DatabaseEnvironment env, out Transaction txn,
uint maxLock, uint maxLocker, uint maxObject, uint partition)
{
// Configure env and locking subsystem.
LockingConfig lkConfig = new LockingConfig();
/*
* If the maximum number of locks/lockers/objects
* is given, then the LockingConfig is set. Unless,
* it is not set to any value.
*/
if (maxLock != 0)
{
lkConfig.MaxLocks = maxLock;
}
if (maxLocker != 0)
{
lkConfig.MaxLockers = maxLocker;
}
if (maxObject != 0)
{
lkConfig.MaxObjects = maxObject;
}
if (partition != 0)
{
lkConfig.Partitions = partition;
}
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
envConfig.LockSystemCfg = lkConfig;
envConfig.UseLocking = true;
envConfig.NoLocking = false;
env = DatabaseEnvironment.Open(envHome, envConfig);
txn = env.BeginTransaction();
}
public void PutRecordWithTxn(out DatabaseEnvironment env,
string home, string dbName, out Transaction txn)
{
BTreeDatabase db;
// Open a new environment and begin a transaction.
SetUpTransactionalEnv(home, out env);
TransactionConfig txnConfig = new TransactionConfig();
txnConfig.Name = "Transaction";
txn = env.BeginTransaction(txnConfig);
Assert.AreEqual("Transaction", txn.Name);
// Open a new database within the transaction.
OpenBtreeDBInEnv(dbName + ".db", env, out db, true, txn);
// Write to the database within the transaction.
WriteOneIntoBtreeDBWithTxn(db, txn);
// Close the database.
db.Close();
}
private void GetMultipleDB(string home, string dbFileName,
BTreeDatabaseConfig dbConfig, out DatabaseEnvironment env,
out Transaction txn, out BTreeDatabase db,
out BTreeCursor cursor)
{
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseLocking = true;
envConfig.UseLogging = true;
envConfig.UseMPool = true;
env = DatabaseEnvironment.Open(home, envConfig);
txn = env.BeginTransaction();
if (dbConfig == null)
{
dbConfig = new BTreeDatabaseConfig();
}
dbConfig.Env = env;
GetMultipleDB(dbFileName, dbConfig, txn, out db,
out cursor);
}
public void TestLockStats()
{
testName = "TestLockStats";
SetUpTest(true);
// Configure locking subsystem.
LockingConfig lkConfig = new LockingConfig();
lkConfig.MaxLockers = 60;
lkConfig.MaxLocks = 50;
lkConfig.MaxObjects = 70;
lkConfig.Partitions = 20;
lkConfig.DeadlockResolution = DeadlockPolicy.DEFAULT;
// Configure and open environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.FreeThreaded = true;
envConfig.LockSystemCfg = lkConfig;
envConfig.LockTimeout = 1000;
envConfig.MPoolSystemCfg = new MPoolConfig();
envConfig.MPoolSystemCfg.CacheSize = new CacheInfo(0, 104800, 1);
envConfig.NoLocking = false;
envConfig.TxnTimeout = 2000;
envConfig.UseLocking = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
DatabaseEnvironment env =
DatabaseEnvironment.Open(testHome, envConfig);
// Get and confirm locking subsystem statistics.
LockStats stats = env.LockingSystemStats();
env.PrintLockingSystemStats(true, true);
Assert.AreEqual(0, stats.LastAllocatedLockerID);
Assert.AreEqual(0, stats.LockConflictsNoWait);
Assert.AreEqual(0, stats.LockConflictsWait);
Assert.AreEqual(0, stats.LockDeadlocks);
Assert.AreEqual(0, stats.LockDowngrades);
Assert.AreEqual(0, stats.LockerNoWait);
Assert.AreEqual(0, stats.Lockers);
Assert.AreEqual(0, stats.LockerWait);
Assert.AreEqual(9, stats.LockModes);
Assert.AreEqual(0, stats.LockPuts);
Assert.AreEqual(0, stats.LockRequests);
Assert.AreEqual(0, stats.Locks);
Assert.AreEqual(0, stats.LockSteals);
Assert.AreEqual(1000, stats.LockTimeoutLength);
Assert.AreEqual(0, stats.LockTimeouts);
Assert.AreEqual(0, stats.LockUpgrades);
Assert.AreEqual(0, stats.MaxBucketLength);
Assert.AreEqual(0, stats.MaxLockers);
Assert.AreEqual(60, stats.MaxLockersInTable);
Assert.AreEqual(0, stats.MaxLocks);
Assert.AreEqual(0, stats.MaxLocksInBucket);
Assert.AreEqual(50, stats.MaxLocksInTable);
Assert.AreEqual(0, stats.MaxLockSteals);
Assert.AreEqual(0, stats.MaxObjects);
Assert.AreEqual(0, stats.MaxObjectsInBucket);
Assert.AreEqual(70, stats.MaxObjectsInTable);
Assert.AreEqual(0, stats.MaxObjectSteals);
Assert.AreEqual(0, stats.MaxPartitionLockNoWait);
Assert.AreEqual(0, stats.MaxPartitionLockWait);
Assert.AreNotEqual(0, stats.MaxUnusedID);
Assert.AreEqual(20, stats.nPartitions);
Assert.AreEqual(0, stats.ObjectNoWait);
Assert.AreEqual(0, stats.Objects);
Assert.AreEqual(0, stats.ObjectSteals);
Assert.AreEqual(0, stats.ObjectWait);
Assert.LessOrEqual(0, stats.PartitionLockNoWait);
Assert.AreEqual(0, stats.PartitionLockWait);
Assert.Less(0, stats.RegionNoWait);
Assert.AreNotEqual(0, stats.RegionSize);
Assert.AreEqual(0, stats.RegionWait);
Assert.AreEqual(2000, stats.TxnTimeoutLength);
Assert.AreEqual(0, stats.TxnTimeouts);
env.PrintLockingSystemStats();
Transaction txn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
dbConfig.FreeThreaded = true;
BTreeDatabase db = BTreeDatabase.Open(
testName + ".db", dbConfig, txn);
txn.Commit();
testLockStatsEnv = env;
testLockStatsDb = db;
Thread thread1 = new Thread(new ThreadStart(Read));
Thread thread2 = new Thread(new ThreadStart(Write));
thread1.Start();
Thread.Sleep(1000);
thread2.Start();
thread1.Join();
thread2.Join();
env.PrintLockingSystemStats();
stats = env.LockingSystemStats();
Assert.Less(0, stats.LastAllocatedLockerID);
Assert.Less(0, stats.LockConflictsNoWait);
Assert.LessOrEqual(0, stats.LockConflictsWait);
Assert.LessOrEqual(0, stats.LockDeadlocks);
Assert.Less(0, stats.LockDowngrades);
Assert.LessOrEqual(0, stats.LockerNoWait);
Assert.Less(0, stats.Lockers);
Assert.LessOrEqual(0, stats.LockerWait);
Assert.Less(0, stats.LockPuts);
Assert.Less(0, stats.LockRequests);
Assert.Less(0, stats.Locks);
Assert.LessOrEqual(0, stats.LockSteals);
Assert.LessOrEqual(0, stats.LockTimeouts);
Assert.LessOrEqual(0, stats.LockUpgrades);
Assert.Less(0, stats.MaxBucketLength);
Assert.Less(0, stats.MaxLockers);
Assert.Less(0, stats.MaxLocks);
Assert.Less(0, stats.MaxLocksInBucket);
Assert.LessOrEqual(0, stats.MaxLockSteals);
Assert.Less(0, stats.MaxObjects);
Assert.Less(0, stats.MaxObjectsInBucket);
Assert.LessOrEqual(0, stats.MaxObjectSteals);
Assert.LessOrEqual(0, stats.MaxPartitionLockNoWait);
Assert.LessOrEqual(0, stats.MaxPartitionLockWait);
Assert.Less(0, stats.MaxUnusedID);
Assert.Less(0, stats.ObjectNoWait);
Assert.Less(0, stats.Objects);
Assert.LessOrEqual(0, stats.ObjectSteals);
Assert.LessOrEqual(0, stats.ObjectWait);
Assert.Less(0, stats.PartitionLockNoWait);
Assert.LessOrEqual(0, stats.PartitionLockWait);
Assert.Less(0, stats.RegionNoWait);
Assert.LessOrEqual(0, stats.RegionWait);
Assert.Less(0, stats.TxnTimeouts);
db.Close();
env.Close();
}
public void TestCommitSuccess()
{
testName = "TestCommitSuccess";
SetUpTest(true);
string[] keys = { "key 1", "key 2", "key 3", "key 4",
"key 5", "key 6", "key 7", "key 8","key 9", "key 10" };
DatabaseEnvironment master = SetUpEnv(testHome + "/master", 100, masterPort, true);
DatabaseEnvironment client = SetUpEnv(testHome + "/client", 0, clientPort, false);
master.RepMgrStartMaster(2);
Thread.Sleep(2000);
client.RepMgrStartClient(2);
BTreeDatabase db1 = Open(master, true);
BTreeDatabase db2 = null;
for (; ;)
{
if (db2 == null)
{
try {
db2 = Open(client, false);
break;
} catch (DatabaseException) {
if (db2 != null)
{
db2.Close(true);
db2 = null;
}
System.Threading.Thread.Sleep(1000);
continue;
}
}
}
try {
for (int i = 0; i < 3; i++)
{
Transaction txn = master.BeginTransaction();
// Get the key.
DatabaseEntry key, data;
key = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes(keys[i]));
data = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes(keys[i]));
db1.Put(key, data, txn);
txn.Commit();
byte[] token = txn.CommitToken;
Assert.AreEqual(master.IsTransactionApplied(token, 5000), TransactionAppliedStatus.APPLIED);
Assert.AreEqual(client.IsTransactionApplied(token, 200000), TransactionAppliedStatus.APPLIED);
}
}
finally {
db1.Close();
db2.Close();
master.Close();
client.Close();
}
}
public void OpenSecDBWithinTxn(string home,
string dbFileName, string dbSecFileName, bool ifDbName)
{
// Open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
envConfig.UseLogging = true;
envConfig.UseLocking = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, envConfig);
// Open a primary btree database.
Transaction openDBTxn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig =
new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
BTreeDatabase db = BTreeDatabase.Open(
dbFileName, dbConfig, openDBTxn);
// Open a secondary btree database.
SecondaryBTreeDatabaseConfig secDBConfig =
new SecondaryBTreeDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secDBConfig.Env = env;
secDBConfig.Creation = CreatePolicy.IF_NEEDED;
SecondaryBTreeDatabase secDB;
if (ifDbName == false)
{
secDB = SecondaryBTreeDatabase.Open(
dbSecFileName, secDBConfig, openDBTxn);
}
else
{
secDB = SecondaryBTreeDatabase.Open(
dbSecFileName, "secondary", secDBConfig,
openDBTxn);
}
openDBTxn.Commit();
secDB.Close();
// Open the existing secondary database.
Transaction secTxn = env.BeginTransaction();
SecondaryDatabaseConfig secConfig =
new SecondaryDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secConfig.Env = env;
SecondaryDatabase secExDB;
if (ifDbName == false)
{
secExDB = SecondaryBTreeDatabase.Open(
dbSecFileName, secConfig, secTxn);
}
else
{
secExDB = SecondaryBTreeDatabase.Open(
dbSecFileName, "secondary", secConfig,
secTxn);
}
secExDB.Close();
secTxn.Commit();
db.Close();
env.Close();
}
public void Master()
{
string home = testHome + "/Master";
string dbName = "rep.db";
Configuration.ClearDir(home);
/*
* Configure and open environment with replication
* application.
*/
DatabaseEnvironmentConfig cfg =
new DatabaseEnvironmentConfig();
cfg.UseReplication = true;
cfg.MPoolSystemCfg = new MPoolConfig();
cfg.MPoolSystemCfg.CacheSize =
new CacheInfo(0, 20485760, 1);
cfg.UseLocking = true;
cfg.UseTxns = true;
cfg.UseMPool = true;
cfg.Create = true;
cfg.UseLogging = true;
cfg.RunRecovery = true;
cfg.TxnNoSync = true;
cfg.FreeThreaded = true;
cfg.RepSystemCfg = new ReplicationConfig();
cfg.RepSystemCfg.RepmgrSitesConfig.Add(new DbSiteConfig());
cfg.RepSystemCfg.RepmgrSitesConfig[0].Host = "127.0.0.1";
cfg.RepSystemCfg.RepmgrSitesConfig[0].Port = ports[0];
cfg.RepSystemCfg.RepmgrSitesConfig[0].LocalSite = true;
cfg.RepSystemCfg.Priority = 100;
cfg.RepSystemCfg.BulkTransfer = true;
cfg.RepSystemCfg.AckTimeout = 2000;
cfg.RepSystemCfg.BulkTransfer = true;
cfg.RepSystemCfg.CheckpointDelay = 1500;
cfg.RepSystemCfg.Clockskew(102, 100);
cfg.RepSystemCfg.ConnectionRetry = 10;
cfg.RepSystemCfg.DelayClientSync = false;
cfg.RepSystemCfg.ElectionRetry = 5;
cfg.RepSystemCfg.ElectionTimeout = 3000;
cfg.RepSystemCfg.FullElectionTimeout = 5000;
cfg.RepSystemCfg.HeartbeatMonitor = 100;
cfg.RepSystemCfg.HeartbeatSend = 10;
cfg.RepSystemCfg.LeaseTimeout = 1300;
cfg.RepSystemCfg.AutoInit = true;
cfg.RepSystemCfg.NoBlocking = false;
cfg.RepSystemCfg.RepMgrAckPolicy =
AckPolicy.ALL_PEERS;
cfg.RepSystemCfg.RetransmissionRequest(10, 100);
cfg.RepSystemCfg.Strict2Site = true;
cfg.RepSystemCfg.UseMasterLeases = false;
cfg.EventNotify = new EventNotifyDelegate(stuffHappened);
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, cfg);
// Get initial replication stats.
ReplicationStats repStats = env.ReplicationSystemStats();
env.PrintReplicationSystemStats();
Assert.AreEqual(100, repStats.EnvPriority);
Assert.AreEqual(1,
repStats.CurrentElectionGenerationNumber);
Assert.AreEqual(0, repStats.CurrentGenerationNumber);
Assert.AreEqual(0, repStats.AppliedTransactions);
Assert.AreEqual(0, repStats.ElectionDataGeneration);
// Start a master site with replication manager.
env.RepMgrStartMaster(3);
// Open a btree database and write some data.
Transaction txn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig =
new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
dbConfig.PageSize = 512;
BTreeDatabase db = BTreeDatabase.Open(dbName,
dbConfig, txn);
txn.Commit();
txn = env.BeginTransaction();
for (int i = 0; i < 5; i++)
{
db.Put(new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(BitConverter.GetBytes(i)), txn);
}
txn.Commit();
Console.WriteLine(
"Master: Finished initialization and data#1.");
// Client site could enter now.
clientStartSignal.Set();
Console.WriteLine(
"Master: Wait for Client to join and get #1.");
Console.WriteLine("...");
// Put some new data into master site.
txn = env.BeginTransaction();
for (int i = 10; i < 15; i++)
{
db.Put(new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(BitConverter.GetBytes(i)),
txn);
}
txn.Commit();
Console.WriteLine(
"Master: Write something new, data #2.");
Console.WriteLine("Master: Wait for client to read #2...");
// Get the stats.
repStats = env.ReplicationSystemStats(true);
env.PrintReplicationSystemStats();
Assert.LessOrEqual(0, repStats.AppliedTransactions);
Assert.LessOrEqual(0, repStats.AwaitedLSN.LogFileNumber);
Assert.LessOrEqual(0, repStats.AwaitedLSN.Offset);
Assert.LessOrEqual(0, repStats.AwaitedPage);
Assert.LessOrEqual(0, repStats.BadGenerationMessages);
Assert.LessOrEqual(0, repStats.BulkBufferFills);
Assert.LessOrEqual(0, repStats.BulkBufferOverflows);
Assert.LessOrEqual(0, repStats.BulkBufferTransfers);
Assert.LessOrEqual(0, repStats.BulkRecordsStored);
Assert.LessOrEqual(0, repStats.ClientServiceRequests);
Assert.LessOrEqual(0, repStats.ClientServiceRequestsMissing);
Assert.IsInstanceOf(typeof(bool), repStats.ClientStartupComplete);
Assert.AreEqual(2, repStats.CurrentElectionGenerationNumber);
Assert.AreEqual(1, repStats.CurrentGenerationNumber);
Assert.LessOrEqual(0, repStats.CurrentQueuedLogRecords);
Assert.LessOrEqual(0, repStats.CurrentWinner);
Assert.LessOrEqual(0, repStats.CurrentWinnerMaxLSN.LogFileNumber);
Assert.LessOrEqual(0, repStats.CurrentWinnerMaxLSN.Offset);
Assert.LessOrEqual(0, repStats.DuplicateLogRecords);
Assert.LessOrEqual(0, repStats.DuplicatePages);
Assert.LessOrEqual(0, repStats.DupMasters);
Assert.LessOrEqual(0, repStats.ElectionGenerationNumber);
Assert.LessOrEqual(0, repStats.ElectionPriority);
Assert.LessOrEqual(0, repStats.Elections);
Assert.LessOrEqual(0, repStats.ElectionStatus);
Assert.LessOrEqual(0, repStats.ElectionsWon);
Assert.LessOrEqual(0, repStats.ElectionTiebreaker);
Assert.LessOrEqual(0, repStats.ElectionTimeSec);
Assert.LessOrEqual(0, repStats.ElectionTimeUSec);
Assert.AreEqual(repStats.EnvID, repStats.MasterEnvID);
Assert.LessOrEqual(0, repStats.EnvPriority);
Assert.LessOrEqual(0, repStats.FailedMessageSends);
Assert.LessOrEqual(0, repStats.ForcedRerequests);
Assert.LessOrEqual(0, repStats.IgnoredMessages);
Assert.LessOrEqual(0, repStats.MasterChanges);
Assert.LessOrEqual(0, repStats.MasterEnvID);
Assert.LessOrEqual(0, repStats.MaxLeaseSec);
Assert.LessOrEqual(0, repStats.MaxLeaseUSec);
Assert.LessOrEqual(0, repStats.MaxPermanentLSN.Offset);
Assert.LessOrEqual(0, repStats.MaxQueuedLogRecords);
Assert.LessOrEqual(0, repStats.MessagesSent);
Assert.LessOrEqual(0, repStats.MissedLogRecords);
Assert.LessOrEqual(0, repStats.MissedPages);
Assert.LessOrEqual(0, repStats.NewSiteMessages);
Assert.LessOrEqual(repStats.MaxPermanentLSN.LogFileNumber,
repStats.NextLSN.LogFileNumber);
if (repStats.MaxPermanentLSN.LogFileNumber ==
repStats.NextLSN.LogFileNumber)
{
Assert.Less(repStats.MaxPermanentLSN.Offset,
repStats.NextLSN.Offset);
}
Assert.LessOrEqual(0, repStats.NextPage);
Assert.LessOrEqual(0, repStats.Outdated);
Assert.LessOrEqual(0, repStats.QueuedLogRecords);
Assert.LessOrEqual(0, repStats.ReceivedLogRecords);
Assert.LessOrEqual(0, repStats.ReceivedMessages);
Assert.LessOrEqual(0, repStats.ReceivedPages);
Assert.LessOrEqual(0, repStats.RegisteredSites);
Assert.LessOrEqual(0, repStats.RegisteredSitesNeeded);
Assert.LessOrEqual(0, repStats.Sites);
Assert.LessOrEqual(0, repStats.StartSyncMessagesDelayed);
Assert.AreEqual(2, repStats.Status);
Assert.LessOrEqual(0, repStats.Throttled);
Assert.LessOrEqual(0, repStats.Votes);
// Get replication manager statistics.
RepMgrStats repMgrStats = env.RepMgrSystemStats(true);
Assert.AreEqual(0, repMgrStats.AutoTakeovers);
Assert.LessOrEqual(0, repMgrStats.DroppedConnections);
Assert.LessOrEqual(0, repMgrStats.DroppedMessages);
Assert.LessOrEqual(0, repMgrStats.ElectionThreads);
Assert.LessOrEqual(0, repMgrStats.FailedConnections);
Assert.LessOrEqual(0, repMgrStats.FailedMessages);
Assert.Less(0, repMgrStats.MaxElectionThreads);
Assert.LessOrEqual(0, repMgrStats.QueuedMessages);
// Print them out.
env.PrintRepMgrSystemStats();
// Wait until client has finished reading.
masterCloseSignal.WaitOne();
Console.WriteLine("Master: Leave as well.");
// Close all.
db.Close(false);
env.LogFlush();
env.Close();
}
public void TestLockStats()
{
testName = "TestLockStats";
SetUpTest(true);
// Configure locking subsystem.
LockingConfig lkConfig = new LockingConfig();
lkConfig.MaxLockers = 60;
lkConfig.MaxLocks = 50;
lkConfig.MaxObjects = 70;
lkConfig.Partitions = 20;
lkConfig.DeadlockResolution = DeadlockPolicy.DEFAULT;
// Configure and open environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.FreeThreaded = true;
envConfig.LockSystemCfg = lkConfig;
envConfig.LockTimeout = 1000;
envConfig.MPoolSystemCfg = new MPoolConfig();
envConfig.MPoolSystemCfg.CacheSize = new CacheInfo(0, 104800, 1);
envConfig.NoLocking = false;
envConfig.TxnTimeout = 2000;
envConfig.UseLocking = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
DatabaseEnvironment env =
DatabaseEnvironment.Open(testHome, envConfig);
// Get and confirm locking subsystem statistics.
LockStats stats = env.LockingSystemStats();
env.Msgfile = testHome + "/" + testName + ".log";
env.PrintLockingSystemStats(true, true);
Assert.AreEqual(0, stats.AllocatedLockers);
Assert.AreNotEqual(0, stats.AllocatedLocks);
Assert.AreNotEqual(0, stats.AllocatedObjects);
Assert.AreEqual(0, stats.InitLockers);
Assert.AreNotEqual(0, stats.InitLocks);
Assert.AreNotEqual(0, stats.InitObjects);
Assert.AreEqual(0, stats.LastAllocatedLockerID);
Assert.AreEqual(0, stats.LockConflictsNoWait);
Assert.AreEqual(0, stats.LockConflictsWait);
Assert.AreEqual(0, stats.LockDeadlocks);
Assert.AreEqual(0, stats.LockDowngrades);
Assert.AreEqual(0, stats.LockerNoWait);
Assert.AreEqual(0, stats.Lockers);
Assert.AreEqual(0, stats.LockerWait);
Assert.AreEqual(9, stats.LockModes);
Assert.AreEqual(0, stats.LockPuts);
Assert.AreEqual(0, stats.LockRequests);
Assert.AreEqual(0, stats.Locks);
Assert.AreEqual(0, stats.LockSteals);
Assert.AreEqual(1000, stats.LockTimeoutLength);
Assert.AreEqual(0, stats.LockTimeouts);
Assert.AreEqual(0, stats.LockUpgrades);
Assert.AreEqual(0, stats.MaxBucketLength);
Assert.AreEqual(0, stats.MaxLockers);
Assert.AreEqual(60, stats.MaxLockersInTable);
Assert.AreEqual(0, stats.MaxLocks);
Assert.AreEqual(0, stats.MaxLocksInBucket);
Assert.AreEqual(50, stats.MaxLocksInTable);
Assert.AreEqual(0, stats.MaxLockSteals);
Assert.AreEqual(0, stats.MaxObjects);
Assert.AreEqual(0, stats.MaxObjectsInBucket);
Assert.AreEqual(70, stats.MaxObjectsInTable);
Assert.AreEqual(0, stats.MaxObjectSteals);
Assert.AreEqual(0, stats.MaxPartitionLockNoWait);
Assert.AreEqual(0, stats.MaxPartitionLockWait);
Assert.AreNotEqual(0, stats.MaxUnusedID);
Assert.AreEqual(20, stats.nPartitions);
Assert.AreEqual(0, stats.ObjectNoWait);
Assert.AreEqual(0, stats.Objects);
Assert.AreEqual(0, stats.ObjectSteals);
Assert.AreEqual(0, stats.ObjectWait);
Assert.LessOrEqual(0, stats.PartitionLockNoWait);
Assert.AreEqual(0, stats.PartitionLockWait);
Assert.Less(0, stats.RegionNoWait);
Assert.AreNotEqual(0, stats.RegionSize);
Assert.AreEqual(0, stats.RegionWait);
Assert.AreNotEqual(0, stats.TableSize);
Assert.AreEqual(2000, stats.TxnTimeoutLength);
Assert.AreEqual(0, stats.TxnTimeouts);
env.PrintLockingSystemStats();
Transaction txn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
dbConfig.FreeThreaded = true;
BTreeDatabase db = BTreeDatabase.Open(
testName + ".db", dbConfig, txn);
txn.Commit();
testLockStatsEnv = env;
testLockStatsDb = db;
// Use some locks, to ensure the stats work when populated.
txn = testLockStatsEnv.BeginTransaction();
for (int i = 0; i < 500; i++)
{
testLockStatsDb.Put(
new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes(
Configuration.RandomString(i))), txn);
testLockStatsDb.Sync();
}
txn.Commit();
env.PrintLockingSystemStats();
stats = env.LockingSystemStats();
Assert.Less(0, stats.LastAllocatedLockerID);
Assert.Less(0, stats.LockDowngrades);
Assert.LessOrEqual(0, stats.LockerNoWait);
Assert.Less(0, stats.Lockers);
Assert.LessOrEqual(0, stats.LockerWait);
Assert.Less(0, stats.LockPuts);
Assert.Less(0, stats.LockRequests);
Assert.Less(0, stats.Locks);
Assert.LessOrEqual(0, stats.LockSteals);
Assert.LessOrEqual(0, stats.LockTimeouts);
Assert.LessOrEqual(0, stats.LockUpgrades);
Assert.Less(0, stats.MaxBucketLength);
Assert.Less(0, stats.MaxLockers);
Assert.Less(0, stats.MaxLocks);
Assert.Less(0, stats.MaxLocksInBucket);
Assert.LessOrEqual(0, stats.MaxLockSteals);
Assert.Less(0, stats.MaxObjects);
Assert.Less(0, stats.MaxObjectsInBucket);
Assert.LessOrEqual(0, stats.MaxObjectSteals);
Assert.LessOrEqual(0, stats.MaxPartitionLockNoWait);
Assert.LessOrEqual(0, stats.MaxPartitionLockWait);
Assert.Less(0, stats.MaxUnusedID);
Assert.LessOrEqual(0, stats.ObjectNoWait);
Assert.Less(0, stats.Objects);
Assert.LessOrEqual(0, stats.ObjectSteals);
Assert.LessOrEqual(0, stats.ObjectWait);
Assert.Less(0, stats.PartitionLockNoWait);
Assert.LessOrEqual(0, stats.PartitionLockWait);
Assert.Less(0, stats.RegionNoWait);
Assert.LessOrEqual(0, stats.RegionWait);
Assert.LessOrEqual(0, stats.TxnTimeouts);
// Force a deadlock to ensure the stats work.
txn = testLockStatsEnv.BeginTransaction();
testLockStatsDb.Put(new DatabaseEntry(BitConverter.GetBytes(10)),
new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes(
Configuration.RandomString(200))), txn);
Thread thread1 = new Thread(GenerateDeadlock);
thread1.Start();
while (DeadlockDidPut == 0)
{
Thread.Sleep(10);
}
try
{
testLockStatsDb.Get(new DatabaseEntry(
BitConverter.GetBytes(100)), txn);
}
catch (DeadlockException) { }
// Abort unconditionally - we don't care about the transaction
txn.Abort();
thread1.Join();
stats = env.LockingSystemStats();
Assert.Less(0, stats.LockConflictsNoWait);
Assert.LessOrEqual(0, stats.LockConflictsWait);
db.Close();
env.Close();
}
public void TestFullLogBufferException()
{
testName = "TestFullLogBufferException";
SetUpTest(true);
// Open an environment and configured log subsystem.
DatabaseEnvironmentConfig cfg =
new DatabaseEnvironmentConfig();
cfg.Create = true;
cfg.TxnNoSync = true;
cfg.UseTxns = true;
cfg.UseLocking = true;
cfg.UseMPool = true;
cfg.UseLogging = true;
cfg.LogSystemCfg = new LogConfig();
cfg.LogSystemCfg.AutoRemove = false;
cfg.LogSystemCfg.BufferSize = 409600;
cfg.LogSystemCfg.MaxFileSize = 10480;
cfg.LogSystemCfg.NoBuffer = false;
cfg.LogSystemCfg.ZeroOnCreate = true;
cfg.LogSystemCfg.InMemory = true;
cfg.LogSystemCfg.LogBlobContent = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(testHome, cfg);
BTreeDatabase db;
try
{
Transaction openTxn = env.BeginTransaction();
try
{
BTreeDatabaseConfig dbConfig =
new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
db = BTreeDatabase.Open(testName + ".db", dbConfig, openTxn);
openTxn.Commit();
}
catch (DatabaseException e)
{
openTxn.Abort();
throw e;
}
Transaction writeTxn = env.BeginTransaction();
try
{
/*
* Writing 10 large records into in-memory logging
* database should throw FullLogBufferException since
* the amount of put data is larger than buffer size.
*/
byte[] byteArr = new byte[204800];
for (int i = 0; i < 10; i++)
{
db.Put(new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(byteArr), writeTxn);
}
writeTxn.Commit();
}
catch (Exception e)
{
writeTxn.Abort();
throw e;
}
finally
{
db.Close(true);
}
}
catch (FullLogBufferException e)
{
Assert.AreEqual(ErrorCodes.DB_LOG_BUFFER_FULL, e.ErrorCode);
throw new ExpectedTestException();
}
finally
{
env.Close();
}
}
public void TestLoggingSystemStats()
{
testName = "TestLoggingSystemStats";
SetUpTest(true);
string logDir = "./";
Directory.CreateDirectory(testHome + "/" + logDir);
DatabaseEnvironmentConfig cfg =
new DatabaseEnvironmentConfig();
cfg.Create = true;
cfg.UseTxns = true;
cfg.AutoCommit = true;
cfg.UseLocking = true;
cfg.UseMPool = true;
cfg.UseLogging = true;
cfg.MPoolSystemCfg = new MPoolConfig();
cfg.MPoolSystemCfg.CacheSize = new CacheInfo(0, 1048576, 1);
cfg.LogSystemCfg = new LogConfig();
cfg.LogSystemCfg.AutoRemove = false;
cfg.LogSystemCfg.BufferSize = 10240;
cfg.LogSystemCfg.Dir = logDir;
cfg.LogSystemCfg.FileMode = 755;
cfg.LogSystemCfg.ForceSync = true;
cfg.LogSystemCfg.InMemory = false;
cfg.LogSystemCfg.LogBlobContent = false;
cfg.LogSystemCfg.MaxFileSize = 1048576;
cfg.LogSystemCfg.NoBuffer = false;
cfg.LogSystemCfg.RegionSize = 204800;
cfg.LogSystemCfg.ZeroOnCreate = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(testHome, cfg);
LogStats stats = env.LoggingSystemStats();
env.PrintLoggingSystemStats();
Assert.AreEqual(10240, stats.BufferSize);
Assert.AreEqual(1, stats.CurrentFile);
Assert.AreNotEqual(0, stats.CurrentOffset);
Assert.AreEqual(0, stats.FileId);
Assert.AreEqual(1048576, stats.FileSize);
Assert.AreEqual(0, stats.InitFileId);
Assert.AreNotEqual(0, stats.MagicNumber);
Assert.AreEqual(0, stats.MaxFileId);
Assert.AreNotEqual(0, stats.PermissionsMode);
Assert.AreEqual(1, stats.Records);
Assert.AreNotEqual(0, stats.RegionLockNoWait);
Assert.LessOrEqual(204800, stats.RegionSize);
Assert.AreNotEqual(0, stats.Version);
Transaction openTxn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
BTreeDatabase db = BTreeDatabase.Open(testName + ".db", dbConfig, openTxn);
openTxn.Commit();
Transaction writeTxn = env.BeginTransaction();
byte[] byteArr = new byte[1024];
for (int i = 0; i < 1000; i++)
{
db.Put(new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(byteArr), writeTxn);
}
writeTxn.Commit();
stats = env.LoggingSystemStats();
Assert.AreNotEqual(0, stats.Bytes);
Assert.AreNotEqual(0, stats.BytesSinceCheckpoint);
Assert.AreNotEqual(0, stats.DiskFileNumber);
Assert.AreNotEqual(0, stats.DiskOffset);
Assert.AreNotEqual(0, stats.MaxCommitsPerFlush);
Assert.AreNotEqual(0, stats.MBytes);
Assert.AreNotEqual(0, stats.MBytesSinceCheckpoint);
Assert.AreNotEqual(0, stats.MinCommitsPerFlush);
Assert.AreNotEqual(0, stats.OverflowWrites);
Assert.AreNotEqual(0, stats.Syncs);
Assert.AreNotEqual(0, stats.Writes);
Assert.AreEqual(0, stats.Reads);
Assert.AreEqual(0, stats.RegionLockWait);
stats = env.LoggingSystemStats(true);
stats = env.LoggingSystemStats();
Assert.AreEqual(0, stats.Bytes);
Assert.AreEqual(0, stats.BytesSinceCheckpoint);
Assert.AreEqual(0, stats.MaxCommitsPerFlush);
Assert.AreEqual(0, stats.MBytes);
Assert.AreEqual(0, stats.MBytesSinceCheckpoint);
Assert.AreEqual(0, stats.MinCommitsPerFlush);
Assert.AreEqual(0, stats.OverflowWrites);
Assert.AreEqual(0, stats.Syncs);
Assert.AreEqual(0, stats.Writes);
Assert.AreEqual(0, stats.Reads);
env.PrintLoggingSystemStats(true, true);
db.Close();
env.Close();
}
public void TestConsumeWithTxn()
{
testName = "TestConsumeWithTxn";
testHome = testFixtureHome + "/" + testName;
string queueDBFileName = testHome + "/" + testName + ".db";
string queueDBName = Path.GetFileName(queueDBFileName);
Configuration.ClearDir(testHome);
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
Transaction txn = env.BeginTransaction();
QueueDatabaseConfig queueConfig =
new QueueDatabaseConfig();
queueConfig.Creation = CreatePolicy.ALWAYS;
queueConfig.Env = env;
queueConfig.Length = 1000;
QueueDatabase queueDB = QueueDatabase.Open(
queueDBName, queueConfig, txn);
int i = 1;
DatabaseEntry data;
DatabaseEntry getData = new DatabaseEntry();
while (i <= 10)
{
data = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes(i.ToString()));
queueDB.Append(data, txn);
if (i == 5)
{
getData = data;
}
i++;
}
KeyValuePair <uint, DatabaseEntry> pair = queueDB.Consume(false, txn);
queueDB.Close();
txn.Commit();
env.Close();
Database db = Database.Open(queueDBFileName,
new QueueDatabaseConfig());
try
{
DatabaseEntry key =
new DatabaseEntry(BitConverter.GetBytes(pair.Key));
db.Get(key);
}
catch (NotFoundException)
{
throw new ExpectedTestException();
}
finally
{
db.Close();
}
}
private void WriteData()
{
/*
* Write a series of records to the database using transaction
* protection. Deadlock handling is demonstrated here.
*/
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
Random generator = new Random();
Transaction txn = null;
string[] keys = { "key 1", "key 2", "key 3", "key 4",
"key 5", "key 6", "key 7", "key 8","key 9", "key 10" };
// Perform 20 transactions.
int iters = 0;
int retry_count = 0;
int maxRetry = 20;
while (iters < 50)
{
try {
// Get a transaction.
txn = env.BeginTransaction();
// Write 10 records to the db for each transaction.
for (int j = 0; j < 10; j++)
{
// Get the key.
DatabaseEntry key;
key = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes(keys[j]));
// Get the data.
PayloadData pd = new PayloadData(
iters + j,
Thread.CurrentThread.Name,
generator.NextDouble());
formatter.Serialize(ms, pd);
Byte[] bytes = ms.GetBuffer();
DatabaseEntry data = new DatabaseEntry(bytes);
// Put key/data pair within the transaction.
db.Put(key, data, txn);
}
// Commit the transaction.
Console.WriteLine("{0} committing txn: {1}",
Thread.CurrentThread.Name, iters);
int recCount = CountRecords(inMem ? txn : null);
Console.WriteLine("{0} found {1} records in the database.",
Thread.CurrentThread.Name, recCount);
try {
txn.Commit();
txn = null;
} catch (DatabaseException e) {
Console.WriteLine(
"Error on txn commit: " +
e.ToString());
}
iters++;
retry_count = 0;
} catch (DeadlockException) {
Console.WriteLine(
"##### {0} deadlocked.", Thread.CurrentThread.Name);
// Retry if necessary.
if (retry_count < maxRetry)
{
Console.WriteLine("{0} retrying.",
Thread.CurrentThread.Name);
retry_count++;
}
else
{
Console.WriteLine("{0} out of retries. Giving up.",
Thread.CurrentThread.Name);
iters++;
retry_count = 0;
}
} catch (DatabaseException e) {
// Abort and don't retry.
iters++;
retry_count = 0;
Console.WriteLine(Thread.CurrentThread.Name +
" : caught exception: " + e.ToString());
Console.WriteLine(Thread.CurrentThread.Name +
" : errno: " + e.ErrorCode);
Console.WriteLine(e.StackTrace);
} finally {
if (txn != null)
{
try {
txn.Abort();
} catch (DatabaseException e) {
Console.WriteLine("Error aborting transaction: " +
e.ToString());
Console.WriteLine(e.StackTrace);
}
}
}
}
}
/* Initialize environment and database (s) */
public void InitDbs()
{
/* Open transactional environment */
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseMPool = true;
envConfig.UseLocking = true;
envConfig.UseLogging = true;
envConfig.UseTxns = true;
envConfig.LockSystemCfg = new LockingConfig();
envConfig.LockSystemCfg.MaxLocks =
(this.dups == 0) ?
(uint)this.num :
(uint)(this.num * this.dups);
envConfig.LockSystemCfg.MaxObjects =
envConfig.LockSystemCfg.MaxLocks;
if (this.cachesize != 0)
{
envConfig.MPoolSystemCfg = new MPoolConfig();
envConfig.MPoolSystemCfg.CacheSize =
new CacheInfo(0, this.cachesize, 1);
}
try {
env = DatabaseEnvironment.Open(home, envConfig);
} catch (Exception e) {
Console.WriteLine(e.StackTrace);
System.Environment.Exit(1);
}
Transaction txn = env.BeginTransaction();
try {
/* Open primary db in transaction */
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Env = env;
dbConfig.Creation = CreatePolicy.IF_NEEDED;
if (this.pagesize != 0)
{
dbConfig.PageSize = this.pagesize;
}
if (this.dups != 0)
{
dbConfig.Duplicates = DuplicatesPolicy.UNSORTED;
}
pdb = BTreeDatabase.Open(dbFileName, pDbName, dbConfig, txn);
/* Open secondary db in transaction */
if (this.secondary)
{
SecondaryBTreeDatabaseConfig sdbConfig =
new SecondaryBTreeDatabaseConfig(
pdb, new SecondaryKeyGenDelegate(SecondaryKeyGen));
sdbConfig.Creation = CreatePolicy.IF_NEEDED;
if (this.pagesize != 0)
{
sdbConfig.PageSize = this.pagesize;
}
sdbConfig.Duplicates = DuplicatesPolicy.SORTED;
sdbConfig.Env = env;
sdb = SecondaryBTreeDatabase.Open(
dbFileName, sDbName, sdbConfig, txn);
}
txn.Commit();
} catch (DatabaseException e1) {
txn.Abort();
throw e1;
} catch (FileNotFoundException e2) {
txn.Abort();
throw e2;
}
}
public void OpenSecQueueDBWithinTxn(string className,
string funName, string home, string dbFileName,
string dbSecFileName)
{
XmlElement xmlElem = Configuration.TestSetUp(
className, funName);
// Open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
envConfig.UseLogging = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, envConfig);
// Open a primary queue database.
Transaction openDBTxn = env.BeginTransaction();
QueueDatabaseConfig dbConfig =
new QueueDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
QueueDatabase db = QueueDatabase.Open(
dbFileName, dbConfig, openDBTxn);
openDBTxn.Commit();
// Open a secondary queue database.
Transaction openSecTxn = env.BeginTransaction();
SecondaryQueueDatabaseConfig secDBConfig =
new SecondaryQueueDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
SecondaryQueueDatabaseConfigTest.Config(xmlElem,
ref secDBConfig, true);
secDBConfig.Env = env;
SecondaryQueueDatabase secDB;
secDB = SecondaryQueueDatabase.Open(
dbSecFileName, secDBConfig, openSecTxn);
openSecTxn.Commit();
// Confirm its flags configured in secDBConfig.
Confirm(xmlElem, secDB, true);
secDB.Close();
// Open the existing secondary database.
Transaction secTxn = env.BeginTransaction();
SecondaryDatabaseConfig secConfig =
new SecondaryDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secConfig.Env = env;
SecondaryDatabase secExDB;
secExDB = SecondaryQueueDatabase.Open(
dbSecFileName, secConfig, secTxn);
secExDB.Close();
secTxn.Commit();
db.Close();
env.Close();
}
public void TestKeyEmptyException()
{
testName = "TestKeyEmptyException";
testHome = testFixtureHome + "/" + testName;
Configuration.ClearDir(testHome);
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseLocking = true;
envConfig.UseLogging = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
QueueDatabase db;
try
{
Transaction openTxn = env.BeginTransaction();
try
{
QueueDatabaseConfig queueConfig =
new QueueDatabaseConfig();
queueConfig.Creation = CreatePolicy.IF_NEEDED;
queueConfig.Length = 10;
queueConfig.Env = env;
db = QueueDatabase.Open(testName + ".db",
queueConfig, openTxn);
openTxn.Commit();
}
catch (DatabaseException e)
{
openTxn.Abort();
throw e;
}
Transaction cursorTxn = env.BeginTransaction();
Cursor cursor;
try
{
/*
* Put a record into queue database with
* cursor and abort the operation.
*/
cursor = db.Cursor(cursorTxn);
KeyValuePair <DatabaseEntry, DatabaseEntry> pair;
pair = new KeyValuePair <DatabaseEntry, DatabaseEntry>(
new DatabaseEntry(BitConverter.GetBytes((int)10)),
new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("data")));
cursor.Add(pair);
cursor.Close();
cursorTxn.Abort();
}
catch (DatabaseException e)
{
cursorTxn.Abort();
db.Close();
throw e;
}
Transaction delTxn = env.BeginTransaction();
try
{
/*
* The put operation is aborted in the queue
* database so querying if the record still exists
* throws KeyEmptyException.
*/
db.Exists(new DatabaseEntry(
BitConverter.GetBytes((int)10)), delTxn);
delTxn.Commit();
}
catch (DatabaseException e)
{
delTxn.Abort();
throw e;
}
finally
{
db.Close();
}
}
catch (KeyEmptyException)
{
throw new ExpectedTestException();
}
finally
{
env.Close();
}
}
public void TestExists()
{
testName = "TestExists";
SetUpTest(true);
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseLocking = true;
envConfig.UseLogging = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
HeapDatabase db;
try {
Transaction openTxn = env.BeginTransaction();
try {
HeapDatabaseConfig heapConfig =
new HeapDatabaseConfig();
heapConfig.Creation = CreatePolicy.IF_NEEDED;
heapConfig.Env = env;
db = HeapDatabase.Open(testName + ".db",
heapConfig, openTxn);
openTxn.Commit();
} catch (DatabaseException e) {
openTxn.Abort();
throw e;
}
Transaction cursorTxn = env.BeginTransaction();
Cursor cursor;
HeapRecordId rid;
try {
/*
* Put a record into heap database with
* cursor and abort the operation.
*/
rid = db.Append(new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("foo")), cursorTxn);
cursor = db.Cursor(cursorTxn);
KeyValuePair <DatabaseEntry, DatabaseEntry> pair;
pair = new KeyValuePair <DatabaseEntry, DatabaseEntry>(
new DatabaseEntry(rid.toArray()),
new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("bar")));
cursor.Add(pair);
cursor.Close();
Assert.IsTrue(db.Exists(
new DatabaseEntry(rid.toArray()), cursorTxn));
cursorTxn.Abort();
} catch (DatabaseException e) {
cursorTxn.Abort();
db.Close();
throw e;
}
Transaction delTxn = env.BeginTransaction();
try {
/*
* The put operation is aborted in the heap
* database so querying if the record still exists
* throws KeyEmptyException.
*/
Assert.IsFalse(db.Exists(
new DatabaseEntry(rid.toArray()), delTxn));
delTxn.Commit();
} catch (DatabaseException e) {
delTxn.Abort();
throw e;
} finally {
db.Close();
}
} finally {
env.Close();
}
}
public void MoveWithRMW(string home, string name)
{
paramEnv = null;
paramDB = null;
// Open the environment.
DatabaseEnvironmentConfig envCfg =
new DatabaseEnvironmentConfig();
envCfg.Create = true;
envCfg.FreeThreaded = true;
envCfg.UseLocking = true;
envCfg.UseLogging = true;
envCfg.UseMPool = true;
envCfg.UseTxns = true;
paramEnv = DatabaseEnvironment.Open(home, envCfg);
// Open database in transaction.
Transaction openTxn = paramEnv.BeginTransaction();
BTreeDatabaseConfig cfg = new BTreeDatabaseConfig();
cfg.Creation = CreatePolicy.ALWAYS;
cfg.Env = paramEnv;
cfg.FreeThreaded = true;
cfg.PageSize = 4096;
// Use record number.
cfg.UseRecordNumbers = true;
paramDB = BTreeDatabase.Open(name + ".db", cfg, openTxn);
openTxn.Commit();
/*
* Put 10 different, 2 duplicate and another different
* records into database.
*/
Transaction txn = paramEnv.BeginTransaction();
for (int i = 0; i < 13; i++)
{
DatabaseEntry key, data;
if (i == 10 || i == 11)
{
key = new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("key"));
data = new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("data"));
}
else
{
key = new DatabaseEntry(BitConverter.GetBytes(i));
data = new DatabaseEntry(BitConverter.GetBytes(i));
}
paramDB.Put(key, data, txn);
}
txn.Commit();
// Get a event wait handle.
signal = new EventWaitHandle(false,
EventResetMode.ManualReset);
/*
* Start RdMfWt() in two threads. RdMfWt() reads
* and writes data into database.
*/
Thread t1 = new Thread(new ThreadStart(RdMfWt));
Thread t2 = new Thread(new ThreadStart(RdMfWt));
t1.Start();
t2.Start();
// Give both threads time to read before signalling them to write.
Thread.Sleep(1000);
// Invoke the write operation in both threads.
signal.Set();
// Return the number of deadlocks.
while (t1.IsAlive || t2.IsAlive)
{
/*
* Give both threads time to write before
* counting the number of deadlocks.
*/
Thread.Sleep(1000);
uint deadlocks = paramEnv.DetectDeadlocks(DeadlockPolicy.DEFAULT);
// Confirm that there won't be any deadlock.
Assert.AreEqual(0, deadlocks);
}
t1.Join();
t2.Join();
paramDB.Close();
paramEnv.Close();
}
public void StatsInTxn(string home, string name, bool ifIsolation)
{
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
EnvConfigCase1(envConfig);
DatabaseEnvironment env = DatabaseEnvironment.Open(home, envConfig);
Transaction openTxn = env.BeginTransaction();
HashDatabaseConfig dbConfig = new HashDatabaseConfig();
ConfigCase1(dbConfig);
dbConfig.Env = env;
HashDatabase db = HashDatabase.Open(name + ".db", dbConfig, openTxn);
openTxn.Commit();
Transaction statsTxn = env.BeginTransaction();
HashStats stats;
HashStats fastStats;
if (ifIsolation == false)
{
stats = db.Stats(statsTxn);
fastStats = db.Stats(statsTxn);
}
else
{
stats = db.Stats(statsTxn, Isolation.DEGREE_ONE);
fastStats = db.Stats(statsTxn, Isolation.DEGREE_ONE);
}
ConfirmStatsPart1Case1(stats);
// Put 100 records into the database.
PutRecordCase1(db, statsTxn);
if (ifIsolation == false)
{
stats = db.Stats(statsTxn);
}
else
{
stats = db.Stats(statsTxn, Isolation.DEGREE_TWO);
}
ConfirmStatsPart2Case1(stats);
// Delete some data to get some free pages.
byte[] bigArray = new byte[262144];
db.Delete(new DatabaseEntry(bigArray), statsTxn);
if (ifIsolation == false)
{
stats = db.Stats(statsTxn);
}
else
{
stats = db.Stats(statsTxn, Isolation.DEGREE_THREE);
}
ConfirmStatsPart3Case1(stats);
statsTxn.Commit();
db.Close();
env.Close();
}
public void StatsInTxn(string home, string name, bool ifIsolation)
{
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
EnvConfigCase1(envConfig);
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, envConfig);
Transaction openTxn = env.BeginTransaction();
RecnoDatabaseConfig dbConfig =
new RecnoDatabaseConfig();
ConfigCase1(dbConfig);
dbConfig.Env = env;
RecnoDatabase db = RecnoDatabase.Open(name + ".db",
dbConfig, openTxn);
openTxn.Commit();
Transaction statsTxn = env.BeginTransaction();
RecnoStats stats;
RecnoStats fastStats;
if (ifIsolation == false)
{
stats = db.Stats(statsTxn);
fastStats = db.FastStats(statsTxn);
}
else
{
stats = db.Stats(statsTxn, Isolation.DEGREE_ONE);
fastStats = db.FastStats(statsTxn,
Isolation.DEGREE_ONE);
}
ConfirmStatsPart1Case1(stats);
// Put 1000 records into the database.
PutRecordCase1(db, statsTxn);
if (ifIsolation == false)
{
stats = db.Stats(statsTxn);
fastStats = db.FastStats(statsTxn);
}
else
{
stats = db.Stats(statsTxn, Isolation.DEGREE_TWO);
fastStats = db.FastStats(statsTxn,
Isolation.DEGREE_TWO);
}
ConfirmStatsPart2Case1(stats);
// Delete 500 records.
for (int i = 250; i <= 750; i++)
{
db.Delete(new DatabaseEntry(BitConverter.GetBytes(i)),
statsTxn);
}
if (ifIsolation == false)
{
stats = db.Stats(statsTxn);
fastStats = db.FastStats(statsTxn);
}
else
{
stats = db.Stats(statsTxn, Isolation.DEGREE_THREE);
fastStats = db.FastStats(statsTxn,
Isolation.DEGREE_THREE);
}
ConfirmStatsPart3Case1(stats);
statsTxn.Commit();
db.Close();
env.Close();
}