public BerkeleyBackingStoreEnvironment(
string databaseDirectory,
DatabaseEnvironmentConfig databaseEnvironmentConfig,
ValueDatabaseConfig valueDatabaseConfig,
ReverseIndexDatabaseConfig reverseIndexDatabaseConfig,
ObjectIndexDatabaseConfig objectIndexDatabaseConfig,
BooleanIndexDatabaseConfig booleanIndexDatabaseConfig,
CharIndexDatabaseConfig charIndexDatabaseConfig,
DateTimeIndexDatabaseConfig dateTimeIndexDatabaseConfig,
DoubleIndexDatabaseConfig doubleIndexDatabaseConfig,
FloatIndexDatabaseConfig floatIndexDatabaseConfig,
GuidIndexDatabaseConfig guidIndexDatabaseConfig,
IntIndexDatabaseConfig intIndexDatabaseConfig,
LongIndexDatabaseConfig longIndexDatabaseConfig,
ShortIndexDatabaseConfig shortIndexDatabaseConfig,
StringIndexDatabaseConfig stringIndexDatabaseConfig,
TypeIndexDatabaseConfig typeIndexDatabaseConfig,
UIntIndexDatabaseConfig uIntIndexDatabaseConfig,
ULongIndexDatabaseConfig uLongIndexDatabaseConfig,
UShortIndexDatabaseConfig uShortIndexDatabaseConfig)
{
DatabaseDirectory = databaseDirectory;
DatabaseEnvironmentConfig = databaseEnvironmentConfig;
ValueDatabaseConfig = valueDatabaseConfig;
ReverseIndexDatabaseConfig = reverseIndexDatabaseConfig;
IndexDatabaseConfigForTypes = new Dictionary<Type, IndexDatabaseConfig>
{
{typeof(object), objectIndexDatabaseConfig},
{typeof(bool), booleanIndexDatabaseConfig},
{typeof(char), charIndexDatabaseConfig},
{typeof(DateTime), dateTimeIndexDatabaseConfig},
{typeof(double), doubleIndexDatabaseConfig},
{typeof(float), floatIndexDatabaseConfig},
{typeof(Guid), guidIndexDatabaseConfig},
{typeof(int), intIndexDatabaseConfig},
{typeof(long), longIndexDatabaseConfig},
{typeof(short), shortIndexDatabaseConfig},
{typeof(string), stringIndexDatabaseConfig},
{typeof(Type), typeIndexDatabaseConfig},
{typeof(uint), uIntIndexDatabaseConfig},
{typeof(ulong), uLongIndexDatabaseConfig},
{typeof(ushort), uShortIndexDatabaseConfig},
};
openEnvironment();
}
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.LogExternalFileContent = false;
cfg.LogSystemCfg.MaxFileSize = 1048576;
cfg.LogSystemCfg.NoBuffer = false;
cfg.LogSystemCfg.NoSync = true;
cfg.LogSystemCfg.RegionSize = 204800;
cfg.LogSystemCfg.ZeroOnCreate = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(testHome, cfg);
LogStats stats = env.LoggingSystemStats();
env.Msgfile = testHome + "/" + testName + ".log";
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.AreEqual(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 static void Confirm(XmlElement xmlElement,
DatabaseEnvironmentConfig envConfig, bool compulsory)
{
Configuration.ConfirmBool(xmlElement, "AutoCommit",
envConfig.AutoCommit, compulsory);
Configuration.ConfirmBool(xmlElement, "CDB_ALLDB",
envConfig.CDB_ALLDB, compulsory);
Configuration.ConfirmBool(xmlElement, "Create",
envConfig.Create, compulsory);
Configuration.ConfirmStringList(xmlElement, "DataDirs",
envConfig.DataDirs, compulsory);
Configuration.ConfirmString(xmlElement, "ErrorPrefix",
envConfig.ErrorPrefix, compulsory);
Configuration.ConfirmBool(xmlElement, "ForceFlush",
envConfig.ForceFlush, compulsory);
Configuration.ConfirmBool(xmlElement, "FreeThreaded",
envConfig.FreeThreaded, compulsory);
Configuration.ConfirmBool(xmlElement, "InitRegions",
envConfig.InitRegions, compulsory);
Configuration.ConfirmString(xmlElement,
"IntermediateDirMode",
envConfig.IntermediateDirMode, compulsory);
Configuration.ConfirmBool(xmlElement, "Lockdown",
envConfig.Lockdown, compulsory);
Configuration.ConfirmUint(xmlElement, "LockTimeout",
envConfig.LockTimeout, compulsory);
Configuration.ConfirmUint(xmlElement, "MaxTransactions",
envConfig.MaxTransactions, compulsory);
Configuration.ConfirmBool(xmlElement, "NoBuffer",
envConfig.NoBuffer, compulsory);
Configuration.ConfirmBool(xmlElement, "NoLocking",
envConfig.NoLocking, compulsory);
Configuration.ConfirmBool(xmlElement, "NoMMap",
envConfig.NoMMap, compulsory);
Configuration.ConfirmBool(xmlElement, "NoLocking",
envConfig.NoLocking, compulsory);
Configuration.ConfirmBool(xmlElement, "NoPanic",
envConfig.NoPanic, compulsory);
Configuration.ConfirmBool(xmlElement, "Overwrite",
envConfig.Overwrite, compulsory);
Configuration.ConfirmBool(xmlElement, "Private",
envConfig.Private, compulsory);
Configuration.ConfirmBool(xmlElement, "Register",
envConfig.Register, compulsory);
Configuration.ConfirmBool(xmlElement, "RunFatalRecovery",
envConfig.RunFatalRecovery, compulsory);
Configuration.ConfirmBool(xmlElement, "RunRecovery",
envConfig.RunRecovery, compulsory);
Configuration.ConfirmBool(xmlElement, "SystemMemory",
envConfig.SystemMemory, compulsory);
Configuration.ConfirmString(xmlElement, "TempDir",
envConfig.TempDir, compulsory);
Configuration.ConfirmBool(xmlElement, "TimeNotGranted",
envConfig.TimeNotGranted, compulsory);
Configuration.ConfirmBool(xmlElement, "TxnNoSync",
envConfig.TxnNoSync, compulsory);
Configuration.ConfirmBool(xmlElement, "TxnNoWait",
envConfig.TxnNoWait, compulsory);
Configuration.ConfirmBool(xmlElement, "TxnSnapshot",
envConfig.TxnSnapshot, compulsory);
Configuration.ConfirmDateTime(xmlElement, "TxnTimestamp",
envConfig.TxnTimestamp, compulsory);
Configuration.ConfirmBool(xmlElement, "TxnWriteNoSync",
envConfig.TxnWriteNoSync, compulsory);
Configuration.ConfirmBool(xmlElement, "UseCDB",
envConfig.UseCDB, compulsory);
Configuration.ConfirmBool(xmlElement, "UseLocking",
envConfig.UseLocking, compulsory);
Configuration.ConfirmBool(xmlElement, "UseLogging",
envConfig.UseLogging, compulsory);
Configuration.ConfirmBool(xmlElement, "UseMPool",
envConfig.UseMPool, compulsory);
Configuration.ConfirmBool(xmlElement, "UseMVCC",
envConfig.UseMVCC, compulsory);
Configuration.ConfirmBool(xmlElement, "UseReplication",
envConfig.UseReplication, compulsory);
Configuration.ConfirmBool(xmlElement, "UseTxns",
envConfig.UseTxns, compulsory);
envConfig.Verbosity = new VerboseMessages();
Configuration.ConfirmVerboseMessages(xmlElement,
"Verbosity", envConfig.Verbosity, compulsory);
Configuration.ConfirmBool(xmlElement, "YieldCPU",
envConfig.YieldCPU, compulsory);
}
public void TestLogStatPrint()
{
testName = "TestLogStatPrint";
SetUpTest(true);
string[] messageInfo = new string[]
{
"Log magic number",
"Log version number",
"Log record cache size",
"Log file mode",
"Current log file size",
"Initial fileid allocation",
"Current fileids in use",
"Maximum fileids used",
"Records entered into the log",
"Log bytes written",
"Log bytes written since last checkpoint",
"Total log file I/O writes",
"Total log file I/O writes due to overflow",
"Total log file flushes",
"Total log file I/O reads",
"Current log file number",
"Current log file offset",
"On-disk log file number",
"On-disk log file offset",
"Maximum commits in a log flush",
"Minimum commits in a log flush",
"Region size",
"The number of region locks that required waiting (0%)"
};
string logDir = "./";
Directory.CreateDirectory(testHome + "/" + logDir);
// Configure and open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.LogSystemCfg = new LogConfig();
envConfig.LogSystemCfg.AutoRemove = false;
envConfig.LogSystemCfg.BufferSize = 10240;
envConfig.LogSystemCfg.Dir = logDir;
envConfig.LogSystemCfg.FileMode = 755;
envConfig.LogSystemCfg.ForceSync = true;
envConfig.LogSystemCfg.InMemory = false;
envConfig.LogSystemCfg.LogExternalFileContent = false;
envConfig.LogSystemCfg.MaxFileSize = 1048576;
envConfig.LogSystemCfg.NoBuffer = false;
envConfig.LogSystemCfg.NoSync = true;
envConfig.LogSystemCfg.RegionSize = 204800;
envConfig.LogSystemCfg.ZeroOnCreate = true;
DatabaseEnvironment env =
DatabaseEnvironment.Open(testHome, envConfig);
// Confirm message file does not exist.
string messageFile = testHome + "/" + "msgfile";
Assert.AreEqual(false, File.Exists(messageFile));
// Call set_msgfile() of env.
env.Msgfile = messageFile;
// Print env statistic to message file.
env.PrintLoggingSystemStats();
// Confirm message file exists now.
Assert.AreEqual(true, File.Exists(messageFile));
env.Msgfile = "";
int counter = 0;
string line;
line = null;
// Read the message file line by line.
System.IO.StreamReader file = new System.IO.StreamReader(@"" + messageFile);
while ((line = file.ReadLine()) != null)
{
string[] tempStr = line.Split('\t');
// Confirm the content of the message file.
Assert.AreEqual(tempStr[1], messageInfo[counter]);
counter++;
}
Assert.AreNotEqual(counter, 0);
file.Close();
env.Close();
}
public void TestPrepare()
{
testName = "TestPrepare";
testHome = testFixtureHome + "/" + testName;
DatabaseEnvironment env;
byte[] gid;
Configuration.ClearDir(testHome);
/*
* Open an environment and begin a transaction
* called "transaction". Within the transacion, open a
* database, write a record and close it. Then prepare
* the transaction and panic the environment.
*/
PanicPreparedTxn(testHome, testName, out env, out gid);
/*
* Recover the environment. Log and db files are not
* destoyed so run normal recovery. Recovery should
* use DB_CREATE and DB_INIT_TXN flags when
* opening the environment.
*/
DatabaseEnvironmentConfig envConfig
= new DatabaseEnvironmentConfig();
envConfig.RunRecovery = true;
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
env = DatabaseEnvironment.Open(testHome, envConfig);
// Reopen the database.
BTreeDatabase db;
OpenBtreeDBInEnv(testName + ".db", env, out db,
false, null);
/*
* Confirm that record("key", "data") exists in the
* database.
*/
DatabaseEntry key, data;
key = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("key"));
data = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("data"));
try
{
db.GetBoth(key, data);
}
catch (DatabaseException)
{
throw new TestException();
}
finally
{
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();
}
/*
* Test the external file database with or without environment.
* 1. Config and open the environment;
* 2. Verify the environment external file configs;
* 3. Config and open the database;
* 4. Verify the database external file configs;
* 5. Insert and verify some external file data by database methods;
* 6. Verify the stats;
* 7. Close all handles.
* If "blobdbt" is true, set the data DatabaseEntry.ExternalFile as
* true, otherwise make the data DatabaseEntry reach the external file
* threshold in size.
*/
void TestBlobHeapDatabase(uint env_threshold, string env_blobdir,
uint db_threshold, string db_blobdir, bool blobdbt)
{
if (env_threshold == 0 && db_threshold == 0)
{
return;
}
string heapDBName =
testHome + "/" + testName + ".db";
Configuration.ClearDir(testHome);
HeapDatabaseConfig cfg = new HeapDatabaseConfig();
cfg.Creation = CreatePolicy.ALWAYS;
string blrootdir = "__db_bl";
// Open the environment and verify the external file configs.
if (env_threshold > 0)
{
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.AutoCommit = true;
envConfig.Create = true;
envConfig.UseMPool = true;
envConfig.UseLogging = true;
envConfig.UseTxns = true;
envConfig.UseLocking = true;
envConfig.ExternalFileThreshold = env_threshold;
if (env_blobdir != null)
{
envConfig.ExternalFileDir = env_blobdir;
blrootdir = env_blobdir;
}
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
if (env_blobdir == null)
{
Assert.IsNull(env.ExternalFileDir);
}
else
{
Assert.AreEqual(0,
env.ExternalFileDir.CompareTo(env_blobdir));
}
Assert.AreEqual(env_threshold, env.ExternalFileThreshold);
cfg.Env = env;
heapDBName = testName + ".db";
}
// Open the database and verify the external file configs.
if (db_threshold > 0)
{
cfg.ExternalFileThreshold = db_threshold;
}
if (db_blobdir != null)
{
cfg.ExternalFileDir = db_blobdir;
/*
* The external file directory setting in the database
* is effective only when it is opened without
* an environment.
*/
if (cfg.Env == null)
{
blrootdir = db_blobdir;
}
}
HeapDatabase db = HeapDatabase.Open(heapDBName, cfg);
Assert.AreEqual(
db_threshold > 0 ? db_threshold : env_threshold,
db.ExternalFileThreshold);
if (db_blobdir == null && cfg.Env == null)
{
Assert.IsNull(db.ExternalFileDir);
}
else
{
Assert.AreEqual(0, db.ExternalFileDir.CompareTo(blrootdir));
}
// Insert and verify some external file data by database
// methods.
string[] records = { "a", "b", "c", "d", "e", "f", "g", "h",
"i", "j", "k", "l", "m", "n", "o", "p","q","r", "s",
"t", "u", "v", "w", "x", "y", "z" };
DatabaseEntry kdbt = new DatabaseEntry();
DatabaseEntry ddbt = new DatabaseEntry();
byte[] ddata;
string str;
KeyValuePair <DatabaseEntry, DatabaseEntry> pair;
ddbt.ExternalFile = blobdbt;
Assert.AreEqual(blobdbt, ddbt.ExternalFile);
for (int i = 0; i < records.Length; i++)
{
str = records[i];
if (!blobdbt)
{
for (int j = 0; j < db_threshold; j++)
{
str = str + records[i];
}
}
ddata = Encoding.ASCII.GetBytes(str);
ddbt.Data = ddata;
kdbt = new DatabaseEntry((db.Append(ddbt)).toArray());
try
{
pair = db.Get(kdbt);
}
catch (DatabaseException)
{
db.Close();
if (cfg.Env != null)
{
cfg.Env.Close();
}
throw new TestException();
}
Assert.AreEqual(ddata, pair.Value.Data);
}
/*
* Verify the external file files are created in the expected
* location.
* This part of test is disabled since BTreeDatabase.BlobSubDir
* is not exposed to users.
*/
//if (cfg.Env != null)
// blrootdir = testHome + "/" + blrootdir;
//string blobdir = blrootdir + "/" + db.BlobSubDir;
//Assert.AreEqual(records.Length,
// Directory.GetFiles(blobdir, "__db.bl*").Length);
//Assert.AreEqual(1,
// Directory.GetFiles(blobdir, "__db_blob_meta.db").Length);
// Verify the stats.
HeapStats st = db.Stats();
Assert.AreEqual(records.Length, st.nExternalFiles);
// Close all handles.
db.Close();
if (cfg.Env != null)
{
cfg.Env.Close();
}
/*
* Remove the default external file directory
* when it is not under the test home.
*/
if (db_blobdir == null && cfg.Env == null)
{
Directory.Delete("__db_bl", true);
}
}
/* 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 UnstableMaster()
{
string home = testHome + "/UnstableMaster";
Configuration.ClearDir(home);
// Open environment with replication configuration.
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 = 200;
cfg.RepSystemCfg.ElectionRetry = 10;
cfg.RepSystemCfg.RepMgrAckPolicy = AckPolicy.ALL;
cfg.EventNotify = new EventNotifyDelegate(stuffHappened);
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, cfg);
env.DeadlockResolution = DeadlockPolicy.DEFAULT;
try {
// Start as master site.
env.RepMgrStartMaster(3);
Console.WriteLine(
"Master: Create a new repmgr group");
// Client1 could start now.
client1StartSignal.Set();
// Wait for initialization of all clients.
if (!masterLeaveSignal.WaitOne(50000))
{
throw new TestException();
}
// Check remote sites are valid.
foreach (RepMgrSite site in
env.RepMgrRemoteSites)
{
Assert.AreEqual("127.0.0.1",
site.Address.Host);
Assert.IsTrue(ports.Contains(
site.Address.Port));
}
// Close the current master.
Console.WriteLine("Master: Unexpected leave.");
env.LogFlush();
} catch (Exception e) {
Console.WriteLine(e.Message);
} finally {
env.Close();
/*
* Clean up electionDone and startUpDone to
* check election for new master and start-up
* done on clients.
*/
electionDone = false;
startUpDone = 0;
/*
* Need to set signals for three times, each
* site would wait for one.
*/
for (int i = 0; i < 3; i++)
{
clientsElectionSignal.Set();
}
}
}
public void TestRepMgrSite()
{
testName = "TestRepMgrSite";
SetUpTest(true);
string masterHome = testHome + "\\Master";
Configuration.ClearDir(masterHome);
string clientHome = testHome + "\\Client";
Configuration.ClearDir(clientHome);
ports.Clear();
AvailablePorts portGen = new AvailablePorts();
uint mPort = portGen.Current;
portGen.MoveNext();
uint cPort = portGen.Current;
// Open environment with replication configuration.
DatabaseEnvironmentConfig cfg =
new DatabaseEnvironmentConfig();
cfg.Create = true;
cfg.RunRecovery = true;
cfg.UseLocking = true;
cfg.UseLogging = true;
cfg.UseMPool = true;
cfg.UseReplication = true;
cfg.FreeThreaded = true;
cfg.UseTxns = true;
cfg.EventNotify = new EventNotifyDelegate(stuffHappened);
cfg.RepSystemCfg = new ReplicationConfig();
cfg.RepSystemCfg.RepmgrSitesConfig.Add(new DbSiteConfig());
cfg.RepSystemCfg.RepmgrSitesConfig[0].Host = "127.0.0.1";
cfg.RepSystemCfg.RepmgrSitesConfig[0].Port = mPort;
cfg.RepSystemCfg.RepmgrSitesConfig[0].LocalSite = true;
cfg.RepSystemCfg.RepmgrSitesConfig[0].GroupCreator = true;
cfg.RepSystemCfg.Priority = 100;
DatabaseEnvironment mEnv = DatabaseEnvironment.Open(
masterHome, cfg);
mEnv.DeadlockResolution = DeadlockPolicy.DEFAULT;
mEnv.RepMgrStartMaster(2);
cfg.RepSystemCfg.RepmgrSitesConfig[0].Port = cPort;
cfg.RepSystemCfg.RepmgrSitesConfig[0].GroupCreator = false;
cfg.RepSystemCfg.Priority = 10;
cfg.RepSystemCfg.RepmgrSitesConfig.Add(new DbSiteConfig());
cfg.RepSystemCfg.RepmgrSitesConfig[1].Host = "127.0.0.1";
cfg.RepSystemCfg.RepmgrSitesConfig[1].Port = mPort;
cfg.RepSystemCfg.RepmgrSitesConfig[1].Helper = true;
DatabaseEnvironment cEnv = DatabaseEnvironment.Open(
clientHome, cfg);
cEnv.RepMgrStartClient(2, false);
/* Wait for client to start up */
int i = 0;
while (!cEnv.ReplicationSystemStats().ClientStartupComplete)
{
if (i < 20)
{
Thread.Sleep(1000);
i++;
}
else
{
throw new TestException();
}
}
/*
* Verify the client info could be observed by master's
* remote site.
*/
Assert.AreEqual(1, mEnv.RepMgrRemoteSites.Length);
RepMgrSite rsite = mEnv.RepMgrRemoteSites[0];
Assert.AreEqual("127.0.0.1", rsite.Address.Host);
Assert.AreEqual(cPort, rsite.Address.Port);
Assert.AreEqual(true, rsite.isConnected);
Assert.AreEqual(false, rsite.isPeer);
DbSite site = mEnv.RepMgrSite("127.0.0.1", mPort);
Assert.AreEqual("127.0.0.1", site.Address.Host);
Assert.AreEqual(mPort, site.Address.Port);
Assert.LessOrEqual(0, site.EId);
Assert.AreEqual(true, site.GroupCreator);
Assert.AreEqual(true, site.LocalSite);
Assert.AreEqual(false, site.Helper);
Assert.AreEqual(false, site.Legacy);
Assert.AreEqual(false, site.Peer);
site.Close();
site = mEnv.RepMgrSite("127.0.0.1", cPort);
Assert.AreEqual("127.0.0.1", site.Address.Host);
Assert.AreEqual(cPort, site.Address.Port);
Assert.AreEqual(rsite.EId, site.EId);
Assert.AreEqual(false, site.GroupCreator);
Assert.AreEqual(false, site.LocalSite);
Assert.AreEqual(false, site.Helper);
Assert.AreEqual(false, site.Legacy);
Assert.AreEqual(false, site.Peer);
site.Remove();
cEnv.Close();
mEnv.Close();
/*
* Update the repmgr site, and verify it is updated in
* unmanaged memory.
*/
rsite.Address = new ReplicationHostAddress(
"192.168.1.1", 1000);
rsite.EId = 1024;
rsite.isConnected = false;
rsite.isPeer = true;
Assert.AreEqual("192.168.1.1", rsite.Address.Host);
Assert.AreEqual(1000, rsite.Address.Port);
Assert.AreEqual(1024, rsite.EId);
Assert.AreEqual(false, rsite.isConnected);
Assert.AreEqual(true, rsite.isPeer);
}
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 TestLockStatPrint()
{
testName = "TestLockStatPrint";
SetUpTest(true);
string[] messageInfo = new string[]
{
"Last allocated locker ID",
"Current maximum unused locker ID",
"Number of lock modes",
"Initial number of locks allocated",
"Initial number of lockers allocated",
"Initial number of lock objects allocated",
"Maximum number of locks possible",
"Maximum number of lockers possible",
"Maximum number of lock objects possible",
"Current number of locks allocated",
"Current number of lockers allocated",
"Current number of lock objects allocated",
"Number of lock object partitions",
"Size of object hash table",
"Number of current locks",
"Maximum number of locks at any one time",
"Maximum number of locks in any one bucket",
"Maximum number of locks stolen by for an empty partition",
"Maximum number of locks stolen for any one partition",
"Number of current lockers",
"Maximum number of lockers at any one time",
"Number of hits in the thread locker cache",
"Total number of lockers reused",
"Number of current lock objects",
"Maximum number of lock objects at any one time",
"Maximum number of lock objects in any one bucket",
"Maximum number of objects stolen by for an empty partition",
"Maximum number of objects stolen for any one partition",
"Total number of locks requested",
"Total number of locks released",
"Total number of locks upgraded",
"Total number of locks downgraded",
"Lock requests not available due to conflicts, for which we waited",
"Lock requests not available due to conflicts, for which we did not wait",
"Number of deadlocks",
"Lock timeout value",
"Number of locks that have timed out",
"Transaction timeout value",
"Number of transactions that have timed out",
"Region size",
"The number of partition locks that required waiting (0%)",
"The maximum number of times any partition lock was waited for (0%)",
"The number of object queue operations that required waiting (0%)",
"The number of locker allocations that required waiting (0%)",
"The number of region locks that required waiting (0%)",
"Maximum hash bucket length"
};
// 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 an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.LockSystemCfg = lkConfig;
envConfig.LockTimeout = 1000;
envConfig.NoLocking = false;
envConfig.UseLocking = true;
DatabaseEnvironment env =
DatabaseEnvironment.Open(testHome, envConfig);
// Confirm message file does not exist.
string messageFile = testHome + "/" + "msgfile";
Assert.AreEqual(false, File.Exists(messageFile));
// Call set_msgfile() of env.
env.Msgfile = messageFile;
// Print env statistic to message file.
env.PrintLockingSystemStats();
// Confirm message file exists now.
Assert.AreEqual(true, File.Exists(messageFile));
env.Msgfile = "";
int counter = 0;
string line;
line = null;
// Read the message file line by line.
System.IO.StreamReader file = new System.IO.StreamReader(@"" + messageFile);
while ((line = file.ReadLine()) != null)
{
string[] tempStr = line.Split('\t');
// Confirm the content of the message file.
Assert.AreEqual(tempStr[1], messageInfo[counter]);
counter++;
}
Assert.AreNotEqual(counter, 0);
file.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();
}
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 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();
}
}
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.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;
Thread thread1 = new Thread(new ThreadStart(Write));
Thread thread2 = new Thread(new ThreadStart(Read));
thread1.Start();
Thread.Sleep(10);
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 StableClient(string home, int clientIdx,
uint localPort, uint priority,
uint helperPort, uint peerPort,
EventWaitHandle notifyHandle)
{
int timeout = 0;
Configuration.ClearDir(home);
Console.WriteLine(
"Client{0}: Join the replication", clientIdx);
DatabaseEnvironmentConfig cfg =
new DatabaseEnvironmentConfig();
cfg.Create = true;
cfg.FreeThreaded = true;
cfg.MPoolSystemCfg = new MPoolConfig();
cfg.MPoolSystemCfg.CacheSize =
new CacheInfo(0, 20485760, 1);
cfg.RunRecovery = true;
cfg.TxnNoSync = true;
cfg.UseLocking = true;
cfg.UseMPool = true;
cfg.UseTxns = true;
cfg.UseReplication = true;
cfg.UseLogging = 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 = localPort;
cfg.RepSystemCfg.RepmgrSitesConfig[0].LocalSite = true;
cfg.RepSystemCfg.Priority = priority;
cfg.RepSystemCfg.RepmgrSitesConfig.Add(
new DbSiteConfig());
cfg.RepSystemCfg.RepmgrSitesConfig[1].Host = "127.0.0.1";
cfg.RepSystemCfg.RepmgrSitesConfig[1].Port = helperPort;
cfg.RepSystemCfg.RepmgrSitesConfig[1].Helper = true;
cfg.RepSystemCfg.ElectionRetry = 100;
cfg.RepSystemCfg.RepMgrAckPolicy = AckPolicy.NONE;
cfg.EventNotify = new EventNotifyDelegate(stuffHappened);
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, cfg);
env.DeadlockResolution = DeadlockPolicy.DEFAULT;
try {
// Start the client.
Assert.AreEqual(clientIdx - 1, startUpDone);
env.RepMgrStartClient(3, false);
while (startUpDone < clientIdx)
{
if (timeout > 10)
{
throw new TestException();
}
timeout++;
Thread.Sleep(1000);
}
ReplicationStats repStats =
env.ReplicationSystemStats();
Assert.LessOrEqual(0, repStats.Elections);
Assert.LessOrEqual(0,
repStats.ElectionTiebreaker);
Assert.LessOrEqual(0, repStats.ElectionTimeSec +
repStats.ElectionTimeUSec);
Assert.LessOrEqual(0, repStats.MasterChanges);
Assert.LessOrEqual(0, repStats.NewSiteMessages);
Assert.LessOrEqual(0,
repStats.ReceivedLogRecords);
Assert.LessOrEqual(0, repStats.ReceivedMessages);
Assert.LessOrEqual(0, repStats.ReceivedPages);
Assert.GreaterOrEqual(clientIdx + 1,
repStats.RegisteredSitesNeeded);
Assert.LessOrEqual(0, repStats.Sites);
// Notify the next event.
notifyHandle.Set();
// Wait for master's leave.
if (!clientsElectionSignal.WaitOne(50000))
{
throw new TestException();
}
timeout = 0;
while (!electionDone)
{
if (timeout > 10)
{
throw new TestException();
}
timeout++;
Thread.Sleep(1000);
}
env.LogFlush();
timeout = 0;
// Start up done event happens on client.
while (startUpDone < 2)
{
if (timeout > 10)
{
throw new TestException();
}
timeout++;
Thread.Sleep(1000);
}
Thread.Sleep((int)priority * 100);
} catch (Exception e) {
Console.WriteLine(e.Message);
} finally {
env.Close();
Console.WriteLine(
"Client{0}: Leaving the replication",
clientIdx);
}
}
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);
}
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.RepMgrLocalSite =
new ReplicationHostAddress("127.0.0.1", ports[0]);
cfg.RepSystemCfg.Priority = 100;
cfg.RepSystemCfg.NSites = 2;
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);
// Start a master site with replication manager.
env.RepMgrStartMaster(3);
// Open a btree database and write some data.
BTreeDatabaseConfig dbConfig =
new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.AutoCommit = true;
dbConfig.Env = env;
dbConfig.PageSize = 512;
BTreeDatabase db = BTreeDatabase.Open(dbName,
dbConfig);
for (int i = 0; i < 5; i++)
{
db.Put(new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(BitConverter.GetBytes(i)));
}
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.
for (int i = 10; i < 15; i++)
{
db.Put(new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(BitConverter.GetBytes(i)));
}
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.LessOrEqual(0, repMgrStats.DroppedConnections);
Assert.LessOrEqual(0, repMgrStats.DroppedMessages);
Assert.LessOrEqual(0, repMgrStats.FailedConnections);
Assert.LessOrEqual(0, repMgrStats.FailedMessages);
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 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 Client()
{
string home = testHome + "/Client";
Configuration.ClearDir(home);
clientStartSignal.WaitOne();
Console.WriteLine("Client: Join the replication");
// Open a environment.
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.LockTimeout = 50000;
cfg.RepSystemCfg = new ReplicationConfig();
cfg.RepSystemCfg.RepMgrLocalSite =
new ReplicationHostAddress("127.0.0.1", ports[1]);
cfg.RepSystemCfg.Priority = 10;
cfg.RepSystemCfg.AddRemoteSite(
new ReplicationHostAddress("127.0.0.1", ports[0]), false);
cfg.RepSystemCfg.NSites = 2;
cfg.EventNotify = new EventNotifyDelegate(stuffHappened);
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, cfg);
// Start a client site with replication manager.
env.RepMgrStartClient(3, false);
// Leave enough time to sync.
Thread.Sleep(20000);
// Open database.
BTreeDatabaseConfig dbConfig =
new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.NEVER;
dbConfig.AutoCommit = true;
dbConfig.Env = env;
dbConfig.PageSize = 512;
BTreeDatabase db = BTreeDatabase.Open("rep.db",
dbConfig);
// Write data into database.
Console.WriteLine("Client: Start reading data #1.");
for (int i = 0; i < 5; i++)
{
db.GetBoth(new DatabaseEntry(
BitConverter.GetBytes(i)), new DatabaseEntry(
BitConverter.GetBytes(i)));
}
// Leave sometime for client to read new data from master.
Thread.Sleep(20000);
/*
* Read the data. All data exists in master site should
* appear in the client site.
*/
Console.WriteLine("Client: Start reading data #2.");
for (int i = 10; i < 15; i++)
{
db.GetBoth(new DatabaseEntry(
BitConverter.GetBytes(i)), new DatabaseEntry(
BitConverter.GetBytes(i)));
}
// Get the latest replication subsystem statistics.
ReplicationStats repStats = env.ReplicationSystemStats();
Assert.IsTrue(repStats.ClientStartupComplete);
Assert.AreEqual(1, repStats.DuplicateLogRecords);
Assert.LessOrEqual(0, repStats.EnvID);
Assert.LessOrEqual(0, repStats.NextPage);
Assert.LessOrEqual(0, repStats.ReceivedPages);
Assert.AreEqual(1, repStats.Status);
// Close all.
db.Close(false);
env.LogFlush();
env.Close();
Console.WriteLine(
"Client: All data is read. Leaving the replication");
// The master is closed after client's close.
masterCloseSignal.Set();
}
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 TestRepMgrSite()
{
testName = "TestRepMgrSite";
SetUpTest(true);
string masterHome = testHome + "\\Master";
Configuration.ClearDir(masterHome);
string clientHome = testHome + "\\Client";
Configuration.ClearDir(clientHome);
ports.Clear();
AvailablePorts portGen = new AvailablePorts();
uint mPort = portGen.Current;
portGen.MoveNext();
uint cPort = portGen.Current;
// Open environment with replication configuration.
DatabaseEnvironmentConfig cfg =
new DatabaseEnvironmentConfig();
cfg.Create = true;
cfg.RunRecovery = true;
cfg.UseLocking = true;
cfg.UseLogging = true;
cfg.UseMPool = true;
cfg.UseReplication = true;
cfg.FreeThreaded = true;
cfg.UseTxns = true;
cfg.EventNotify = new EventNotifyDelegate(stuffHappened);
cfg.RepSystemCfg = new ReplicationConfig();
cfg.RepSystemCfg.RepMgrLocalSite =
new ReplicationHostAddress("127.0.0.1", mPort);
cfg.RepSystemCfg.Priority = 100;
cfg.RepSystemCfg.NSites = 2;
DatabaseEnvironment mEnv = DatabaseEnvironment.Open(
masterHome, cfg);
mEnv.DeadlockResolution = DeadlockPolicy.DEFAULT;
mEnv.RepMgrStartMaster(2);
cfg.RepSystemCfg.RepMgrLocalSite =
new ReplicationHostAddress("127.0.0.1", cPort);
cfg.RepSystemCfg.Priority = 10;
cfg.RepSystemCfg.AddRemoteSite(
new ReplicationHostAddress("127.0.0.1", mPort),
false);
DatabaseEnvironment cEnv = DatabaseEnvironment.Open(
clientHome, cfg);
cEnv.RepMgrStartClient(2, false);
/*
* Verify the client info could be achived by master's
* remote site.
*/
Assert.AreEqual(1, mEnv.RepMgrRemoteSites.Length);
RepMgrSite site = mEnv.RepMgrRemoteSites[0];
Assert.AreEqual("127.0.0.1", site.Address.Host);
Assert.AreEqual(cPort, site.Address.Port);
Assert.AreEqual(0, site.EId);
Assert.AreEqual(true, site.isConnected);
Assert.AreEqual(false, site.isPeer);
cEnv.Close();
mEnv.Close();
/*
* Update the repmgr site, and verify it is updated in
* unmanged memory.
*/
site.Address = new ReplicationHostAddress(
"192.168.1.1", 1000);
site.EId = 1024;
site.isConnected = false;
site.isPeer = true;
Assert.AreEqual("192.168.1.1", site.Address.Host);
Assert.AreEqual(1000, site.Address.Port);
Assert.AreEqual(1024, site.EId);
Assert.AreEqual(false, site.isConnected);
Assert.AreEqual(true, site.isPeer);
}
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 void UnstableMaster()
{
string home = testHome + "/UnstableMaster";
Configuration.ClearDir(home);
// Open environment with replication configuration.
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.RepMgrLocalSite =
new ReplicationHostAddress("127.0.0.1", ports[0]);
cfg.RepSystemCfg.Priority = 200;
cfg.RepSystemCfg.NSites = 4;
cfg.RepSystemCfg.ElectionRetry = 10;
cfg.RepSystemCfg.RepMgrAckPolicy = AckPolicy.ALL;
cfg.EventNotify = new EventNotifyDelegate(stuffHappened);
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, cfg);
env.DeadlockResolution = DeadlockPolicy.DEFAULT;
// Start as master site.
env.RepMgrStartMaster(3);
Console.WriteLine("Master: Finish initialization");
// Notify clients to join.
client1StartSignal.Set();
client2StartSignal.Set();
client3StartSignal.Set();
// Wait for initialization of all clients.
client1ReadySignal.WaitOne();
client2ReadySignal.WaitOne();
client3ReadySignal.WaitOne();
ports.Add(ports[1]);
ports.Add(ports[2]);
ports.Add(ports[3]);
foreach (RepMgrSite site in env.RepMgrRemoteSites)
{
Assert.AreEqual("127.0.0.1", site.Address.Host);
Assert.IsTrue(ports.Contains(site.Address.Port));
Assert.Greater(4, site.EId);
Assert.IsTrue(site.isConnected);
Assert.IsFalse(site.isPeer);
}
// After all of them are ready, close the current master.
Console.WriteLine("Master: Unexpected leave.");
env.LogFlush();
env.Close();
masterLeaveSignal.Set();
}
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.NoSync = true;
cfg.LogSystemCfg.ZeroOnCreate = true;
cfg.LogSystemCfg.InMemory = true;
cfg.LogSystemCfg.LogExternalFileContent = 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 StableClient1()
{
string home = testHome + "/StableClient1";
Configuration.ClearDir(home);
// Get notification from master and start the #1 client.
client1StartSignal.WaitOne();
Console.WriteLine("Client1: Join the replication");
// Open the environment.
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.LockTimeout = 50000;
cfg.RepSystemCfg = new ReplicationConfig();
cfg.RepSystemCfg.RepMgrLocalSite =
new ReplicationHostAddress("127.0.0.1", ports[1]);
cfg.RepSystemCfg.Priority = 10;
cfg.RepSystemCfg.AddRemoteSite(
new ReplicationHostAddress("127.0.0.1", ports[0]), false);
cfg.RepSystemCfg.AddRemoteSite(
new ReplicationHostAddress("127.0.0.1", ports[3]), true);
cfg.RepSystemCfg.NSites = 4;
cfg.RepSystemCfg.ElectionRetry = 10;
cfg.RepSystemCfg.RepMgrAckPolicy = AckPolicy.NONE;
cfg.EventNotify = new EventNotifyDelegate(stuffHappened);
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, cfg);
env.DeadlockResolution = DeadlockPolicy.DEFAULT;
// Start the client who won't raise any election.
env.RepMgrStartClient(3, false);
// Leave enough time to sync.
Thread.Sleep(20000);
// The current client site is fully initialized.
client1ReadySignal.Set();
foreach (RepMgrSite site in env.RepMgrRemoteSites)
{
if (site.Address.Port == ports[3])
{
Assert.IsTrue(site.isPeer);
}
else
{
Assert.IsFalse(site.isPeer);
}
}
// Wait for master's leave signal.
masterLeaveSignal.WaitOne();
/*
* Set the master's leave signal so that other clients
* could be informed.
*/
masterLeaveSignal.Set();
// Leave sometime for client to hold election.
Thread.Sleep(10000);
env.LogFlush();
env.Close();
Console.WriteLine("Client1: Leaving the replication");
}
public void OpenSecHashDBWithinTxn(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 hash database.
Transaction openDBTxn = env.BeginTransaction();
HashDatabaseConfig dbConfig =
new HashDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
HashDatabase db = HashDatabase.Open(
dbFileName, dbConfig, openDBTxn);
openDBTxn.Commit();
// Open a secondary hash database.
Transaction openSecTxn = env.BeginTransaction();
SecondaryHashDatabaseConfig secDBConfig =
new SecondaryHashDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
SecondaryHashDatabaseConfigTest.Config(xmlElem,
ref secDBConfig, false);
secDBConfig.HashFunction = null;
secDBConfig.Env = env;
SecondaryHashDatabase secDB;
if (ifDbName == false)
{
secDB = SecondaryHashDatabase.Open(
dbSecFileName, secDBConfig, openSecTxn);
}
else
{
secDB = SecondaryHashDatabase.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 = SecondaryHashDatabase.Open(
dbSecFileName, secConfig, secTxn);
}
else
{
secExDB = SecondaryHashDatabase.Open(
dbSecFileName, "secondary", secConfig,
secTxn);
}
secExDB.Close();
secTxn.Commit();
db.Close();
env.Close();
}
public void StableClient2()
{
string home = testHome + "/StableClient2";
Configuration.ClearDir(home);
client2StartSignal.WaitOne();
Console.WriteLine("Client2: Join the replication");
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.LockTimeout = 50000;
cfg.RepSystemCfg = new ReplicationConfig();
cfg.RepSystemCfg.RepMgrLocalSite =
new ReplicationHostAddress("127.0.0.1", ports[2]);
cfg.RepSystemCfg.Priority = 20;
cfg.RepSystemCfg.AddRemoteSite(
new ReplicationHostAddress("127.0.0.1", ports[0]), false);
cfg.RepSystemCfg.AddRemoteSite(
new ReplicationHostAddress("127.0.0.1", ports[1]), true);
cfg.RepSystemCfg.NSites = 4;
cfg.RepSystemCfg.ElectionRetry = 10;
cfg.RepSystemCfg.RepMgrAckPolicy =
AckPolicy.ONE_PEER;
cfg.EventNotify = new EventNotifyDelegate(stuffHappened);
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, cfg);
env.DeadlockResolution = DeadlockPolicy.DEFAULT;
// Start the client who will raise election if no master.
env.RepMgrStartClient(3, true);
// Leave enough time to sync.
Thread.Sleep(20000);
// The current client site is fully initialized.
client2ReadySignal.Set();
// Wait for master's leave signal.
masterLeaveSignal.WaitOne();
/*
* Set the master's leave signal so that other clients
* could be informed.
*/
masterLeaveSignal.Set();
// Leave sometime for client to hold election.
Thread.Sleep(5000);
env.LogFlush();
env.Close();
Console.WriteLine("Client2: Leaving the replication");
}
public void StableClient3()
{
string home = testHome + "/StableClient3";
Configuration.ClearDir(home);
client3StartSignal.WaitOne();
Console.WriteLine("Client3: Join the replication");
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.LockTimeout = 50000;
cfg.RepSystemCfg = new ReplicationConfig();
cfg.RepSystemCfg.RepMgrLocalSite =
new ReplicationHostAddress("127.0.0.1", ports[3]);
cfg.RepSystemCfg.Priority = 80;
cfg.RepSystemCfg.AddRemoteSite(
new ReplicationHostAddress("127.0.0.1", ports[0]), false);
cfg.RepSystemCfg.AddRemoteSite(
new ReplicationHostAddress("127.0.0.1", ports[2]), true);
cfg.RepSystemCfg.NSites = 4;
cfg.EventNotify = new EventNotifyDelegate(stuffHappened);
cfg.RepSystemCfg.ElectionRetry = 10;
cfg.RepSystemCfg.RepMgrAckPolicy = AckPolicy.QUORUM;
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, cfg);
env.DeadlockResolution = DeadlockPolicy.DEFAULT;
env.RepMgrStartClient(3, false);
// Leave enough time to sync with master.
Thread.Sleep(20000);
// The current client site is fully initialized.
client3ReadySignal.Set();
// Wait for master's leave signal.
masterLeaveSignal.WaitOne();
/*
* Set the master's leave signal so that other clients
* could be informed.
*/
masterLeaveSignal.Set();
/*
* Master will leave the replication after all clients'
* initialization. Leave sometime for master to leave
* and for clients elect.
*/
Thread.Sleep(5000);
ReplicationStats repStats = env.ReplicationSystemStats();
Assert.LessOrEqual(0, repStats.Elections);
Assert.LessOrEqual(0, repStats.ElectionTiebreaker);
Assert.LessOrEqual(0,
repStats.ElectionTimeSec + repStats.ElectionTimeUSec);
Assert.LessOrEqual(0, repStats.MasterChanges);
Assert.LessOrEqual(0, repStats.NewSiteMessages);
Assert.LessOrEqual(0, repStats.ReceivedLogRecords);
Assert.LessOrEqual(0, repStats.ReceivedMessages);
Assert.LessOrEqual(0, repStats.ReceivedPages);
Assert.GreaterOrEqual(4, repStats.RegisteredSitesNeeded);
Assert.LessOrEqual(0, repStats.Sites);
/*
* Client 3 will be the new master. The Elected master should wait
* until all other clients leave.
*/
Thread.Sleep(10000);
env.LogFlush();
env.Close();
Console.WriteLine("Client3: Leaving the replication");
}
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();
}
