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();
}
// Get a cursor in CDS.
public static void GetCursorInBtreeDBInCDS(
string home, string name,
CursorConfig cursorConfig,
out DatabaseEnvironment env, out BTreeDatabase db,
out BTreeCursor cursor)
{
string dbFileName = name + ".db";
// Open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseCDB = true;
envConfig.UseMPool = true;
env = DatabaseEnvironment.Open(home, envConfig);
/*
* 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);
// Get a cursor in the transaction.
cursor = db.Cursor(cursorConfig);
}
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();
}
/*
* Open environment, database and write data into database.
* Generated log files are put under testHome.
*/
public void Logging(string home, string dbName,
out DatabaseEnvironment env, out RecnoDatabase recnoDB)
{
string dbFileName = dbName + ".db";
Configuration.ClearDir(home);
// Open environment with logging subsystem.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseLogging = true;
envConfig.LogSystemCfg = new LogConfig();
envConfig.LogSystemCfg.FileMode = 755;
envConfig.LogSystemCfg.ZeroOnCreate = true;
envConfig.UseMPool = true;
env = DatabaseEnvironment.Open(home, envConfig);
/*
* Open recno database, write 100000 records into
* the database and close it.
*/
RecnoDatabaseConfig recnoConfig =
new RecnoDatabaseConfig();
recnoConfig.Creation = CreatePolicy.IF_NEEDED;
recnoConfig.Env = env;
// The db needs mpool to open.
recnoConfig.NoMMap = false;
recnoDB = RecnoDatabase.Open(dbFileName,
recnoConfig);
for (int i = 0; i < 1000; i++)
recnoDB.Append(new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("key")));
}
public void EnvConfigCase1(DatabaseEnvironmentConfig cfg)
{
cfg.Create = true;
cfg.UseTxns = true;
cfg.UseMPool = true;
cfg.UseLogging = true;
}
public static void LockingEnvSetUp(string testHome,
string testName, out DatabaseEnvironment env,
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.LockSystemCfg = lkConfig;
envConfig.UseLocking = true;
envConfig.ErrorPrefix = testName;
env = DatabaseEnvironment.Open(testHome, envConfig);
}
/*
* Set up environment.
*/
public static int SetUpEnv(string home, string data_dir)
{
DatabaseEnvironment env;
DatabaseEnvironmentConfig envConfig;
/* Configure an environment. */
envConfig = new DatabaseEnvironmentConfig();
envConfig.MPoolSystemCfg = new MPoolConfig();
envConfig.MPoolSystemCfg.CacheSize = new CacheInfo(
0, 64 * 1024, 1);
envConfig.Create = true;
envConfig.DataDirs.Add(data_dir);
envConfig.CreationDir = data_dir;
envConfig.ErrorPrefix = progName;
envConfig.UseLogging = true;
envConfig.UseLocking = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
/* Create and open the environment. */
try {
env = DatabaseEnvironment.Open(home, envConfig);
} catch (Exception e) {
Console.WriteLine("{0}", e.Message);
return EXIT_FAILURE;
}
Console.ReadLine();
env.Close();
return EXIT_SUCCESS;
}
public void GetCursorWithImplicitTxn(string home,
string dbFile, bool ifConfig)
{
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseCDB = true;
envConfig.UseMPool = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, envConfig);
RecnoDatabaseConfig dbConfig =
new RecnoDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
RecnoDatabase db = RecnoDatabase.Open(dbFile,
dbConfig);
RecnoCursor cursor;
if (ifConfig == false)
cursor = db.Cursor();
else
cursor = db.Cursor(new CursorConfig());
cursor.Close();
db.Close();
env.Close();
}
public static RepQuoteEnvironment Open(string home, DatabaseEnvironmentConfig cfg)
{
RepQuoteEnvironment dbEnv = new RepQuoteEnvironment();
dbEnv.env = DatabaseEnvironment.Open(home, cfg);
dbEnv._appFinished = false;
dbEnv._inClientSync = false;
dbEnv._isMaster = false;
return dbEnv;
}
public DatabaseEnvironment SetUpEnv(String home, uint priority, uint port, bool isMaster)
{
try {
Configuration.ClearDir(home);
} catch (Exception e) {
Console.WriteLine(e.Message);
throw new TestException("Please clean the directory");
}
/* 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();
DbSiteConfig dbSiteConfig = new DbSiteConfig();
dbSiteConfig.Host = ip;
dbSiteConfig.Port = port;
dbSiteConfig.LocalSite = true;
cfg.RepSystemCfg.RepmgrSitesConfig.Add(dbSiteConfig);
cfg.RepSystemCfg.Priority = priority;
if (!isMaster) {
DbSiteConfig dbSiteConfig1 = new DbSiteConfig();
dbSiteConfig1.Host = ip;
dbSiteConfig1.Port = masterPort;
dbSiteConfig1.Helper = true;
cfg.RepSystemCfg.RepmgrSitesConfig.Add(dbSiteConfig1);
}
cfg.RepSystemCfg.BulkTransfer = false;
cfg.RepSystemCfg.AckTimeout = 5000;
cfg.RepSystemCfg.RepMgrAckPolicy =
AckPolicy.ALL_PEERS;
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, cfg);
return env;
}
public void GetSecondaryCursurWithTxn(string home,
string name, bool ifCfg)
{
string dbFileName = name + ".db";
SecondaryCursor cursor;
// Open env.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(home,
envConfig);
// Open primary/secondary database.
Transaction txn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
BTreeDatabase db = BTreeDatabase.Open(dbFileName,
dbConfig, txn);
SecondaryBTreeDatabaseConfig secDBConfig = new
SecondaryBTreeDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secDBConfig.Env = env;
SecondaryBTreeDatabase secDB =
SecondaryBTreeDatabase.Open(dbFileName,
secDBConfig, txn);
for (int i = 0; i < 10; i++)
db.Put(new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(BitConverter.GetBytes((int)i)), txn);
// Create secondary cursor.
if (ifCfg == false)
secDB.SecondaryCursor(txn);
else if (ifCfg == true)
{
CursorConfig cursorConfig = new CursorConfig();
cursorConfig.WriteCursor = false;
cursor = secDB.SecondaryCursor(cursorConfig, txn);
cursor.Close();
}
secDB.Close();
db.Close();
txn.Commit();
env.Close();
}
/*
* Create and open environment and database.
*/
public static int DBInit(out DatabaseEnvironment env,
string home, string progName, uint maxLock,
uint doUnLink)
{
DatabaseEnvironmentConfig envConfig;
LockingConfig lkConfig;
/* Configure locking subsystem. */
lkConfig = new LockingConfig();
lkConfig.MaxLocks = maxLock;
/* Configure environment. */
envConfig = new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.ErrorPrefix = progName;
envConfig.LockSystemCfg = lkConfig;
envConfig.UseLocking = true;
/*
* Optionally remove the environment region and
* open the environment.
*/
try {
if (doUnLink == 1)
DatabaseEnvironment.Remove(home, true);
env = DatabaseEnvironment.Open(home, envConfig);
} catch (Exception e) {
Console.WriteLine("{0}:{1}\n{2}",
e.Source, e.Message, e.StackTrace);
env = null;
return EXIT_FAILURE;
}
/*
try
{
env = DatabaseEnvironment.Open(home, envConfig);
}
catch(Exception e)
{
Console.WriteLine("{0}:{1}\n{2}",
e.Source, e.Message, e.StackTrace);
env = null;
return ExConstants.EXIT_FAILURE;
}
*/
return EXIT_SUCCESS;
}
public void TestGetAndFreeMutex()
{
testName = "TestGetAndFreeMutex";
SetUpTest(true);
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseMPool = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
BerkeleyDB.Mutex mutex = env.GetMutex(true, true);
mutex.Dispose();
env.Close();
}
public void TestGetAndFreeMutex()
{
testName = "TestGetAndFreeMutex";
testHome = testFixtureHome + "/" + testName;
Configuration.ClearDir(testHome);
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseMPool = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
BerkeleyDB.Mutex mutex = env.GetMutex(true, true);
mutex.Dispose();
env.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 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;
cfg.Duplicates = DuplicatesPolicy.UNSORTED;
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 TestSnapshotIsolation()
{
BTreeDatabaseConfig dbConfig;
DatabaseEntry key, data;
DatabaseEnvironmentConfig envConfig;
Thread readThread, updateThread;
Transaction txn;
updateTxn = null;
readTxn = null;
paramDB = null;
paramEnv = null;
testName = "TestSnapshotIsolation";
testHome = testFixtureHome + "/" + testName;
Configuration.ClearDir(testHome);
/*
* Open environment with DB_MULTIVERSION
* which is required by DB_TXN_SNAPSHOT.
*/
envConfig = new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseMVCC = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
envConfig.UseLocking = true;
envConfig.TxnTimeout = 1000;
paramEnv = DatabaseEnvironment.Open(
testHome, envConfig);
paramEnv.DetectDeadlocks(DeadlockPolicy.YOUNGEST);
/*
* Open a transactional database and put 1000 records
* into it within transaction.
*/
txn = paramEnv.BeginTransaction();
dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.UseMVCC = true;
dbConfig.Env = paramEnv;
paramDB = BTreeDatabase.Open(
testName + ".db", dbConfig, txn);
for (int i = 0; i < 256; i++)
{
key = new DatabaseEntry(
BitConverter.GetBytes(i));
data = new DatabaseEntry(
BitConverter.GetBytes(i));
paramDB.Put(key, data, txn);
}
txn.Commit();
/*
* Begin two threads, read and update thread.
* The update thread runs a update transaction
* using full read/write locking. The read thread
* set DB_TXN_SNAPSHOT on read-only cursor.
*/
readThread = new Thread(new ThreadStart(ReadTxn));
updateThread = new Thread(new ThreadStart(UpdateTxn));
updateThread.Start();
Thread.Sleep(1000);
readThread.Start();
readThread.Join();
updateThread.Join();
// Commit transacion in both two threads.
if (updateTxn != null)
updateTxn.Commit();
if (readTxn != null)
readTxn.Commit();
/*
* Confirm that the overwrite operation works.
*/
ConfirmOverwrite();
paramDB.Close();
paramEnv.Close();
}
public static void Config(XmlElement xmlElement,
ref DatabaseEnvironmentConfig envConfig, bool compulsory)
{
uint value = new uint();
DateTime time = new DateTime();
Configuration.ConfigBool(xmlElement, "AutoCommit",
ref envConfig.AutoCommit, compulsory);
Configuration.ConfigBool(xmlElement, "CDB_ALLDB",
ref envConfig.CDB_ALLDB, compulsory);
Configuration.ConfigBool(xmlElement, "Create",
ref envConfig.Create, compulsory);
Configuration.ConfigString(xmlElement, "CreationDir",
ref envConfig.CreationDir, compulsory);
Configuration.ConfigStringList(xmlElement, "DataDirs",
ref envConfig.DataDirs, compulsory);
Configuration.ConfigString(xmlElement, "ErrorPrefix",
ref envConfig.ErrorPrefix, compulsory);
Configuration.ConfigBool(xmlElement, "ForceFlush",
ref envConfig.ForceFlush, compulsory);
Configuration.ConfigBool(xmlElement, "FreeThreaded",
ref envConfig.FreeThreaded, compulsory);
Configuration.ConfigBool(xmlElement, "InitRegions",
ref envConfig.InitRegions, compulsory);
Configuration.ConfigString(xmlElement, "IntermediateDirMode",
ref envConfig.IntermediateDirMode, compulsory);
Configuration.ConfigBool(xmlElement, "Lockdown",
ref envConfig.Lockdown, compulsory);
if (Configuration.ConfigUint(xmlElement, "LockTimeout",
ref value, compulsory))
envConfig.LockTimeout = value;
if (Configuration.ConfigUint(xmlElement, "MaxTransactions",
ref value, compulsory))
envConfig.MaxTransactions = value;
Configuration.ConfigBool(xmlElement, "NoBuffer",
ref envConfig.NoBuffer, compulsory);
Configuration.ConfigBool(xmlElement, "NoLocking",
ref envConfig.NoLocking, compulsory);
Configuration.ConfigBool(xmlElement, "NoMMap",
ref envConfig.NoMMap, compulsory);
Configuration.ConfigBool(xmlElement, "NoLocking",
ref envConfig.NoLocking, compulsory);
Configuration.ConfigBool(xmlElement, "NoPanic",
ref envConfig.NoPanic, compulsory);
Configuration.ConfigBool(xmlElement, "Overwrite",
ref envConfig.Overwrite, compulsory);
Configuration.ConfigBool(xmlElement, "Private",
ref envConfig.Private, compulsory);
Configuration.ConfigBool(xmlElement, "Register",
ref envConfig.Register, compulsory);
Configuration.ConfigBool(xmlElement, "RunFatalRecovery",
ref envConfig.RunFatalRecovery, compulsory);
Configuration.ConfigBool(xmlElement, "RunRecovery",
ref envConfig.RunRecovery, compulsory);
Configuration.ConfigBool(xmlElement, "SystemMemory",
ref envConfig.SystemMemory, compulsory);
Configuration.ConfigString(xmlElement, "TempDir",
ref envConfig.TempDir, compulsory);
Configuration.ConfigBool(xmlElement, "TimeNotGranted",
ref envConfig.TimeNotGranted, compulsory);
Configuration.ConfigBool(xmlElement, "TxnNoSync",
ref envConfig.TxnNoSync, compulsory);
Configuration.ConfigBool(xmlElement, "TxnNoWait",
ref envConfig.TxnNoWait, compulsory);
Configuration.ConfigBool(xmlElement, "TxnSnapshot",
ref envConfig.TxnSnapshot, compulsory);
if (Configuration.ConfigDateTime(xmlElement, "TxnTimestamp",
ref time, compulsory))
envConfig.TxnTimestamp = time;
Configuration.ConfigBool(xmlElement, "TxnWriteNoSync",
ref envConfig.TxnWriteNoSync, compulsory);
Configuration.ConfigBool(xmlElement, "UseLocking",
ref envConfig.UseLocking, compulsory);
Configuration.ConfigBool(xmlElement, "UseLogging",
ref envConfig.UseLogging, compulsory);
Configuration.ConfigBool(xmlElement, "UseMPool",
ref envConfig.UseMPool, compulsory);
Configuration.ConfigBool(xmlElement, "UseMVCC",
ref envConfig.UseMVCC, compulsory);
Configuration.ConfigBool(xmlElement, "UseReplication",
ref envConfig.UseReplication, compulsory);
Configuration.ConfigBool(xmlElement, "UseTxns",
ref envConfig.UseTxns, compulsory);
envConfig.Verbosity = new VerboseMessages();
Configuration.ConfigVerboseMessages(xmlElement,
"Verbosity", ref envConfig.Verbosity, compulsory);
Configuration.ConfigBool(xmlElement, "YieldCPU",
ref envConfig.YieldCPU, compulsory);
}
public void TestSetEncryption()
{
testName = "TestSetEncryption";
SetUpTest(true);
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.SetEncryption("key", EncryptionAlgorithm.AES);
Assert.AreEqual("key", envConfig.EncryptionPassword);
Assert.AreEqual(EncryptionAlgorithm.AES, envConfig.EncryptAlgorithm);
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
Assert.AreEqual(EncryptionAlgorithm.AES, env.EncryptAlgorithm);
env.Close();
}
public void TestConfigReplication()
{
testName = "TestConfigReplication";
SetUpTest(false);
XmlElement xmlElem = Configuration.TestSetUp(
testFixtureName, testName);
DatabaseEnvironmentConfig cfg =
new DatabaseEnvironmentConfig();
cfg.RepSystemCfg = new ReplicationConfig();
ReplicationConfigTest.Config(xmlElem,
ref cfg.RepSystemCfg, true);
ReplicationConfigTest.Confirm(xmlElem,
cfg.RepSystemCfg, true);
}
public void OpenSecRecnoDBWithinTxn(string className,
string funName, string home, string dbFileName,
string dbSecFileName, bool ifDbName)
{
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 recno database.
Transaction openDBTxn = env.BeginTransaction();
RecnoDatabaseConfig dbConfig =
new RecnoDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
RecnoDatabase db = RecnoDatabase.Open(
dbFileName, dbConfig, openDBTxn);
openDBTxn.Commit();
// Open a secondary recno database.
Transaction openSecTxn = env.BeginTransaction();
SecondaryRecnoDatabaseConfig secDBConfig =
new SecondaryRecnoDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
SecondaryRecnoDatabaseConfigTest.Config(xmlElem,
ref secDBConfig, false);
secDBConfig.Env = env;
SecondaryRecnoDatabase secDB;
if (ifDbName == false)
secDB = SecondaryRecnoDatabase.Open(
dbSecFileName, secDBConfig, openSecTxn);
else
secDB = SecondaryRecnoDatabase.Open(
dbSecFileName, "secondary", 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;
if (ifDbName == false)
secExDB = SecondaryRecnoDatabase.Open(
dbSecFileName, secConfig, secTxn);
else
secExDB = SecondaryRecnoDatabase.Open(
dbSecFileName, "secondary", secConfig,
secTxn);
secExDB.Close();
secTxn.Commit();
db.Close();
env.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 TestConfig()
{
testName = "TestConfig";
SetUpTest(false);
XmlElement xmlElem = Configuration.TestSetUp(
testFixtureName, testName);
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
Config(xmlElem, ref envConfig, true);
Confirm(xmlElem, envConfig, true);
}
private void Open()
{
Console.WriteLine("Opening environment and database");
// Set up the environment.
DatabaseEnvironmentConfig envCfg = new DatabaseEnvironmentConfig();
envCfg.Create = true;
envCfg.UseMPool = true;
envCfg.UseLocking = true;
envCfg.UseLogging = true;
envCfg.UseTxns = true;
// Allow multiple threads visit to the environment handle.
envCfg.FreeThreaded = true;
if (inMem)
envCfg.Private = true;
else
envCfg.RunRecovery = true;
/*
* Indicate that we want db to internally perform
* deadlock detection, aborting the transaction that
* has performed the least amount of WriteData activity
* in the event of a deadlock.
*/
envCfg.LockSystemCfg = new LockingConfig();
envCfg.LockSystemCfg.DeadlockResolution =
DeadlockPolicy.MIN_WRITE;
if (inMem) {
// Specify in-memory logging.
envCfg.LogSystemCfg = new LogConfig();
envCfg.LogSystemCfg.InMemory = true;
/*
* Specify the size of the in-memory log buffer
* Must be large enough to handle the log data
* created by the largest transaction.
*/
envCfg.LogSystemCfg.BufferSize = 10 * 1024 * 1024;
/*
* Specify the size of the in-memory cache,
* large enough to avoid paging to disk.
*/
envCfg.MPoolSystemCfg = new MPoolConfig();
envCfg.MPoolSystemCfg.CacheSize =
new CacheInfo(0, 10 * 1024 * 1024, 1);
}
// Set up the database.
BTreeDatabaseConfig dbCfg = new BTreeDatabaseConfig();
dbCfg.AutoCommit = true;
dbCfg.Creation = CreatePolicy.IF_NEEDED;
dbCfg.Duplicates = DuplicatesPolicy.SORTED;
dbCfg.FreeThreaded = true;
dbCfg.ReadUncommitted = true;
/*
* Open the environment. Any errors will be caught
* by the caller.
*/
env = DatabaseEnvironment.Open(home, envCfg);
/*
* Open the database. Do not provide a txn handle. This
* Open is autocommitted because BTreeDatabaseConfig.AutoCommit
* is true.
*/
dbCfg.Env = env;
db = BTreeDatabase.Open(dbName, dbCfg);
}
public int init(RepConfig config)
{
int ret = 0;
DatabaseEnvironmentConfig envConfig = new DatabaseEnvironmentConfig();
envConfig.ErrorPrefix = RepConfig.progname;
envConfig.RepSystemCfg = new ReplicationConfig();
envConfig.RepSystemCfg.RepmgrSitesConfig.Add(config.localSite);
for (int i = 0; i < config.remoteSites.Count; i++)
envConfig.RepSystemCfg.RepmgrSitesConfig.Add(config.remoteSites[i]);
envConfig.RepSystemCfg.BulkTransfer = config.bulk;
/*
* Configure heartbeat timeouts so that repmgr monitors the
* health of the TCP connection. Master sites broadcast a heartbeat
* at the frequency specified by the DB_REP_HEARTBEAT_SEND timeout.
* Client sites wait for message activity the length of the
* DB_REP_HEARTBEAT_MONITOR timeout before concluding that the
* connection to the master is lost. The DB_REP_HEARTBEAT_MONITOR
* timeout should be longer than the DB_REP_HEARTBEAT_SEND timeout.
*/
envConfig.RepSystemCfg.HeartbeatMonitor = 10000000;
envConfig.RepSystemCfg.HeartbeatSend = 5000000;
/*
* Set replication group election priority for this environment.
* An election first selects the site with the most recent log
* records as the new master. If multiple sites have the most
* recent log records, the site with the highest priority value
* is selected as master.
*/
envConfig.RepSystemCfg.Priority = config.priority;
envConfig.MPoolSystemCfg = new MPoolConfig();
envConfig.MPoolSystemCfg.CacheSize = RepConfig.CACHESIZE;
envConfig.TxnNoSync = true;
envConfig.EventNotify = new EventNotifyDelegate(RepQuoteEventHandler);
/*
* Set the policy that determines how master and client sites
* handle acknowledgement of replication messages needed for
* permanent records. The default policy of "quorum" requires only
* a quorum of electable peers sufficient to ensure a permanent
* record remains durable if an election is held. The "all" option
* requires all clients to acknowledge a permanent replication
* message instead.
*/
envConfig.RepSystemCfg.RepMgrAckPolicy = config.ackPolicy;
/*
* Set the threshold for the minimum and maximum time the client
* waits before requesting retransmission of a missing message.
* Base these values on the performance and load characteristics
* of the master and client host platforms as well as the round
* trip message time.
*/
envConfig.RepSystemCfg.RetransmissionRequest(20000, 500000);
/*
* Configure deadlock detection to ensure that any deadlocks
* are broken by having one of the conflicting lock requests
* rejected. DB_LOCK_DEFAULT uses the lock policy specified
* at environment creation time or DB_LOCK_RANDOM if none was
* specified.
*/
envConfig.LockSystemCfg = new LockingConfig();
envConfig.LockSystemCfg.DeadlockResolution = DeadlockPolicy.DEFAULT;
envConfig.Create = true;
envConfig.RunRecovery = true;
envConfig.FreeThreaded = true;
envConfig.UseReplication = true;
envConfig.UseLocking = true;
envConfig.UseLogging = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
envConfig.Verbosity = new VerboseMessages();
envConfig.Verbosity.Replication = config.verbose;
try
{
dbenv = RepQuoteEnvironment.Open(config.home, envConfig);
} catch(DatabaseException e)
{
Console.WriteLine("Fail to open environment: " + e.Message);
return 1;
}
/* The following base replication features may also be useful to your
* application. See Berkeley DB documentation for more details.
* - Master leases: Provide stricter consistency for data reads
* on a master site.
* - Timeouts: Customize the amount of time Berkeley DB waits
* for such things as an election to be concluded or a master
* lease to be granted.
* - Delayed client synchronization: Manage the master site's
* resources by spreading out resource-intensive client
* synchronizations.
* - Blocked client operations: Return immediately with an error
* instead of waiting indefinitely if a client operation is
* blocked by an ongoing client synchronization.
*
* The following repmgr features may also be useful to your
* application. See Berkeley DB documentation for more details.
* - Two-site strict majority rule - In a two-site replication
* group, require both sites to be available to elect a new
* master.
* - Timeouts - Customize the amount of time repmgr waits
* for such things as waiting for acknowledgements or attempting
* to reconnect to other sites.
* - Site list - return a list of sites currently known to repmgr.
*/
/* Start checkpoint and log archive support threads. */
checkpointThread = new Thread(new ThreadStart(CheckPoint));
checkpointThread.Start();
logArchiveThread = new Thread(new ThreadStart(LogArchive));
logArchiveThread.Start();
/* Start replication manager. */
if (config.startPolicy == StartPolicy.CLIENT)
dbenv.env.RepMgrStartClient(3);
else if (config.startPolicy == StartPolicy.ELECTION)
dbenv.env.RepMgrStartClient(3, true);
else if (config.startPolicy == StartPolicy.MASTER)
dbenv.env.RepMgrStartMaster(3);
return ret;
}
static void Main(string[] args) {
BTreeDatabase btreeDB;
BTreeDatabaseConfig btreeDBConfig;
DatabaseEnvironment env;
DatabaseEnvironmentConfig envConfig;
Sequence seq;
SequenceConfig seqConfig;
string buff;
string dbFileName;
string home;
string progName;
/*
* excs_sequence is meant to be run from build_windows\AnyCPU, in
* either the Debug or Release directory. The required core
* libraries, however, are in either build_windows\Win32 or
* build_windows\x64, depending upon the platform. That location
* needs to be added to the PATH environment variable for the
* P/Invoke calls to work.
*/
try {
String pwd = Environment.CurrentDirectory;
pwd = Path.Combine(pwd, "..");
pwd = Path.Combine(pwd, "..");
if (IntPtr.Size == 4)
pwd = Path.Combine(pwd, "Win32");
else
pwd = Path.Combine(pwd, "x64");
#if DEBUG
pwd = Path.Combine(pwd, "Debug");
#else
pwd = Path.Combine(pwd, "Release");
#endif
pwd += ";" + Environment.GetEnvironmentVariable("PATH");
Environment.SetEnvironmentVariable("PATH", pwd);
} catch (Exception e) {
Console.WriteLine(
"Unable to set the PATH environment variable.");
Console.WriteLine(e.Message);
return;
}
progName = "excs_sequence";
try {
home = args[0];
dbFileName = args[1];
} catch {
Usage();
return;
};
/* Optiionally remove the existing database file. */
if (File.Exists(dbFileName)) {
while (true) {
Console.Write
("File already exists, delete or not (y/n)?");
buff = Console.ReadLine();
if (buff == "y" || buff == "n")
break;
}
if (buff == "y") {
File.Delete(dbFileName);
Console.WriteLine("The existing {0} is deleted",
dbFileName);
}
}
/* Configure and open environment. */
envConfig = new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseLogging = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
try {
env = DatabaseEnvironment.Open(home, envConfig);
} catch (Exception e) {
Console.WriteLine("{0}:{1}\n{2}",
e.Source, e.Message, e.StackTrace);
return;
}
/* Configure and open sequence's database. */
btreeDBConfig = new BTreeDatabaseConfig();
btreeDBConfig.AutoCommit = true;
btreeDBConfig.Creation = CreatePolicy.IF_NEEDED;
btreeDBConfig.ErrorPrefix = progName;
btreeDBConfig.Env = env;
try {
btreeDB = BTreeDatabase.Open(dbFileName,
btreeDBConfig);
} catch (Exception e) {
Console.WriteLine("{0}:{1}\n{2}",
e.Source, e.Message, e.StackTrace);
return;
}
/* Configure and initialize sequence. */
seqConfig = new SequenceConfig();
seqConfig.BackingDatabase = btreeDB;
seqConfig.Creation = CreatePolicy.IF_NEEDED;
seqConfig.Increment = true;
seqConfig.InitialValue = Int64.MaxValue;
seqConfig.key = new DatabaseEntry();
seqConfig.SetRange(Int64.MinValue, Int64.MaxValue);
seqConfig.Wrap = true;
DbtFromString(seqConfig.key, "excs_sequence");
seq = new Sequence(seqConfig);
/* Get from sequence. */
for (int i = 0; i < 10; i++) {
Console.WriteLine("{0}", seq.Get(2));
Console.ReadLine();
}
Console.WriteLine("Sequence Name: {0}",
seq.BackingDatabase.FileName);
Console.WriteLine("Sequence Key: {0}",
StrFromDBT(seq.Key));
Console.WriteLine("{0}->{1}", seq.Min, seq.Max);
Console.WriteLine(seq.Wrap ? "wrap" : "not wrap");
Console.WriteLine(seq.Increment ? "increase" :
"decrease");
/* Close sequence, database and environment. */
seq.Close();
btreeDB.Close();
env.Close();
}
public void OpenSecDBInTxn(string home, string dbFileName,
string dbSecFileName, out DatabaseEnvironment env,
out BTreeDatabase db, out SecondaryBTreeDatabase secDB)
{
// Open environment.
DatabaseEnvironmentConfig envCfg =
new DatabaseEnvironmentConfig();
envCfg.Create = true;
envCfg.UseLocking = true;
envCfg.UseLogging = true;
envCfg.UseMPool = true;
envCfg.UseTxns = true;
env = DatabaseEnvironment.Open(
home, envCfg);
// Open primary and secondary database in a transaction.
Transaction openTxn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig =
new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
dbConfig.PageSize = 4096;
dbConfig.Duplicates = DuplicatesPolicy.NONE;
dbConfig.ReadUncommitted = true;
db = BTreeDatabase.Open(dbFileName, dbConfig,
openTxn);
openTxn.Commit();
openTxn = env.BeginTransaction();
SecondaryBTreeDatabaseConfig secConfig =
new SecondaryBTreeDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secConfig.Creation = CreatePolicy.IF_NEEDED;
secConfig.Duplicates = DuplicatesPolicy.SORTED;
secConfig.Env = env;
secConfig.ReadUncommitted = true;
secDB = SecondaryBTreeDatabase.Open(dbSecFileName,
secConfig, openTxn);
openTxn.Commit();
}
public void TestConfigLock()
{
testName = "TestConfigLock";
SetUpTest(false);
XmlElement xmlElem = Configuration.TestSetUp(
testFixtureName, testName);
DatabaseEnvironmentConfig cfg =
new DatabaseEnvironmentConfig();
cfg.LockSystemCfg = new LockingConfig();
LockingConfigTest.Config(xmlElem,
ref cfg.LockSystemCfg, true);
LockingConfigTest.Confirm(xmlElem,
cfg.LockSystemCfg, true);
}
public void TestConfigMutex()
{
testName = "TestConfigMutex";
SetUpTest(false);
XmlElement xmlElem = Configuration.TestSetUp(
testFixtureName, testName);
DatabaseEnvironmentConfig cfg =
new DatabaseEnvironmentConfig();
cfg.MutexSystemCfg = new MutexConfig();
MutexConfigTest.Config(xmlElem, ref cfg.MutexSystemCfg, true);
MutexConfigTest.Confirm(xmlElem, cfg.MutexSystemCfg, true);
}
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.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();
}