public void ConnectTest()
{
Sequoiadb sdb2 = new Sequoiadb(config.conf.Coord.Address);
System.Console.WriteLine(config.conf.Coord.Address.ToString());
// check whether it is in the cluster environment or not
if (!Constants.isClusterEnv(sdb))
{
System.Console.WriteLine("ConnectWithAuth is for cluster environment only.");
return;
}
sdb.CreateUser("testusr", "testpwd");
sdb2.Connect("testusr", "testpwd");
Assert.IsNotNull(sdb.Connection);
sdb2.RemoveUser("testusr", "testpwd");
sdb2.Disconnect();
Assert.IsNull(sdb2.Connection);
try
{
sdb2.Connect("testusr", "testpwd");
}
catch (BaseException e)
{
Assert.IsTrue(e.ErrorType == "SDB_AUTH_AUTHORITY_FORBIDDEN");
}
}
public static void SequoiadbInitialize(TestContext testContext)
{
if ( config == null )
config = new Config();
sdb = new Sequoiadb(config.conf.Coord.Address);
sdb.Connect(config.conf.UserName, config.conf.Password);
}
public void MyTestInitialize()
{
sdb = new Sequoiadb(config.conf.Coord.Address);
sdb.Connect(config.conf.UserName, config.conf.Password);
if (sdb.IsCollectionSpaceExist(csName))
sdb.DropCollectionSpace(csName);
cs = sdb.CreateCollectionSpace(csName);
coll = cs.CreateCollection(cName);
}
public void MyTestInitialize()
{
// check whether it is in the cluster environment or not
if (!Constants.isClusterEnv(sdb))
{
Console.WriteLine("removeRG is for cluster environment only.");
return;
}
// argument
groupName = config.conf.Groups[0].GroupName;
hostName = config.conf.Groups[0].Nodes[0].HostName;
port = config.conf.Groups[0].Nodes[0].Port;
dbpath = config.conf.Groups[0].Nodes[0].DBPath;
// drop the exist group
group = sdb.GetReplicaGroup(groupName);
if (group != null)
{
// drop all the cs in current group, and then remove this group
int nodeNum = group.GetNodeNum(SDBConst.NodeStatus.SDB_NODE_ALL);
if (nodeNum > 0)
{
var nd = group.GetMaster();
Sequoiadb db = new Sequoiadb(nd.HostName, nd.Port);
Assert.IsTrue(nd.Start());
db.Connect(config.conf.UserName, config.conf.Password);
DBCursor cursor = db.ListCollectionSpaces();
while (cursor.Next() != null)
{
BsonDocument obj = cursor.Current();
string temp = null;
if (obj.Contains("Name"))
temp = obj["Name"].AsString;
sdb.DropCollectionSpace(temp);
}
db.Disconnect();
}
try
{
sdb.RemoveReplicaGroup(group.GroupName);
}
catch (BaseException e)
{
string errInfo = e.Message;
Console.WriteLine("Error code is: " + errInfo);
}
}
// create a new group
group = sdb.CreateReplicaGroup(groupName);
Assert.IsTrue(groupName.Equals(group.GroupName));
// create a node
Dictionary<string, string> map = new Dictionary<string, string>();
map.Add("diaglevel", config.conf.Groups[0].Nodes[0].DiagLevel);
node = group.CreateNode(hostName, port, dbpath, map);
Assert.IsNotNull(node);
group.Start();
}
// connect to a given database
public static void Connect(Sequoiadb sdb)
{
try
{
// connect to database
sdb.Connect();
}
catch (Exception e)
{
Console.WriteLine("Failed to connect to database at {0}:{1}", sdb.ServerAddr.Host, sdb.ServerAddr.Port);
Console.WriteLine(e.Message);
Environment.Exit(0);
}
}
public void MyTestInitialize()
{
try
{
sdb = new Sequoiadb(config.conf.Coord.Address);
sdb.Connect(config.conf.UserName, config.conf.Password);
if (sdb.IsCollectionSpaceExist(csName))
sdb.DropCollectionSpace(csName);
cs = sdb.CreateCollectionSpace(csName);
cl = cs.CreateCollection(cName);
}
catch (BaseException e)
{
Console.WriteLine("Failed to Initialize in DBLobTest, ErrorType = {0}", e.ErrorType);
Environment.Exit(0);
}
}
public void CollectionTest()
{
string csName = "testCS1";
string clName = "testCL1";
CollectionSpace cs = null;
Sequoiadb sdb = new Sequoiadb(config.conf.Coord.Address);
sdb.Connect(config.conf.UserName, config.conf.Password);
if(sdb.IsCollectionSpaceExist(csName))
cs = sdb.GetCollecitonSpace(csName);
else
cs = sdb.CreateCollectionSpace(csName);
if (!cs.IsCollectionExist(clName))
cs.CreateCollection(clName);
cs.DropCollection(clName);
Assert.IsFalse(cs.IsCollectionExist(clName));
sdb.DropCollectionSpace(csName);
sdb.Disconnect();
}
public void setSessionAttr_Arguments_Test()
{
// begin a new session
Sequoiadb sdb2 = new Sequoiadb(config.conf.Coord.Address);
sdb2.Connect(config.conf.UserName, config.conf.Password);
Assert.IsNotNull(sdb2.Connection);
// TODO:
BsonDocument conf = null;
string[] str = { "M", "m", "S", "s", "A", "a" };
int[] nodeNumber = { 1, 2, 3, 4, 5, 6, 7 };
Random rnd = new Random();
int r = rnd.Next(2);
int n = -1;
if (r == 0)
{
n = rnd.Next(6);
conf = new BsonDocument("PreferedInstance", str[n]);
}
else
{
n = rnd.Next(7);
conf = new BsonDocument("PreferedInstance", nodeNumber[n]);
}
try
{
sdb2.SetSessionAttr(conf);
}
catch (BaseException e)
{
Console.WriteLine(e.ErrorType);
Assert.Fail();
}
}
public void setSessionAttrTest()
{
// create another node
string host = "192.168.20.42";
int port = 55555;
string dataPath = "/opt/sequoiadb/database/data/55555";
string groupName = "group1";
ReplicaGroup rg = null;
try
{
// get the exist group
rg = sdb.GetReplicaGroup(groupName);
// remove the node we going to use
var node = rg.GetNode(host, port);
if (node != null)
{
rg.RemoveNode(host, port, new BsonDocument());
}
// create node
Dictionary<string, string> opt = new Dictionary<string, string>();
rg.CreateNode(host, port, dataPath, opt);
rg.Start();
// insert some records first
int num = 10;
List<BsonDocument> insertor = new List<BsonDocument>();
for (int i = 0; i < num; i++)
{
BsonDocument obj = new BsonDocument();
obj.Add("id", i);
insertor.Add(obj);
}
coll.BulkInsert(insertor, 0);
// begin a new session
Sequoiadb sdb2 = new Sequoiadb(config.conf.Coord.Address);
sdb2.Connect(config.conf.UserName, config.conf.Password);
Assert.IsNotNull(sdb2.Connection);
// TODO:
BsonDocument conf = new BsonDocument("PreferedInstance", "m");
sdb2.SetSessionAttr(conf);
// check
// record the slave note "TotalDataRead" before query
var sddb = new Sequoiadb(host, port);
sddb.Connect(config.conf.UserName, config.conf.Password);
DBCursor cur1 = sddb.GetSnapshot(6, null, null, null);
BsonDocument status1 = cur1.Next();
long count1 = status1.GetValue("TotalDataRead").AsInt64;
// query
DBCursor cursor = coll.Query(null, null, null, null, 0, -1);
BsonDocument o = new BsonDocument();
long count = 0;
while ((o = cursor.Next()) != null)
count++;
// record the slave note "TotalRead" after query
DBCursor cur2 = sddb.GetSnapshot(6, null, null, null);
BsonDocument status2 = cur2.Next();
long count2 = status2.GetValue("TotalDataRead").AsInt64;
//Assert.IsTrue(num == count2 - count1);
long temp = count2 - count1;
Console.WriteLine("count2 is " + count2 + ", count1 is " + count1);
DBCursor cur3 = sddb.GetSnapshot(6, null, null, null);
BsonDocument status3 = cur3.Next();
long count3 = status3.GetValue("TotalRead").AsInt64;
}
finally
{
// remove the newly build node
var node = rg.GetNode(host, port);
if (node != null)
{
rg.RemoveNode(host, port, new BsonDocument());
}
}
}
public void CheckDisableCacheLogic()
{
// test1: test default value
bool boolValue = false;
long longValue = 300 * 1000;
ClientOptions opt = new ClientOptions();
opt.CacheInterval = longValue;
opt.EnableCache = boolValue;
Sequoiadb db = new Sequoiadb(config.conf.Coord.Address);
db.Connect(config.conf.UserName, config.conf.Password);
Sequoiadb.InitClient(opt);
// check
Type t = db.GetType();
BindingFlags flag = BindingFlags.NonPublic | BindingFlags.Instance;
FieldInfo f_nameCache = t.GetField("nameCache", flag);
Dictionary <String, DateTime> dic = f_nameCache.GetValue(db) as Dictionary <String, DateTime>;
Assert.AreEqual(0, dic.Count);
// create cs
CollectionSpace[] csObjArr = new CollectionSpace[3];
for (int i = 0; i < csArr.Length; i++)
{
try
{
db.DropCollectionSpace(csArr[i]);
}
catch (BaseException e)
{
}
}
for (int i = 0; i < csArr.Length; i++)
{
csObjArr[i] = db.CreateCollectionSpace(csArr[i]);
}
// test1: 检测db对象中cs的缓存情况
Console.Out.WriteLine("point 1: after creating cs, nameCache.Count is: " + dic.Count);
Assert.AreEqual(0, dic.Count);
// drop one cs
db.DropCollectionSpace(csArr[0]);
// test2: 删除一个cs之后，检测db对象中cs的缓存情况
Assert.AreEqual(0, dic.Count);
// create the drop cs
csObjArr[0] = db.CreateCollectionSpace(csArr[0]);
Assert.AreEqual(0, dic.Count);
// create cl
BsonDocument conf = new BsonDocument();
conf.Add("ReplSize", 0);
for (int i = 0; i < clArr1.Length; i++)
{
//Console.Out.WriteLine("csObjArr[0] is: " + csObjArr[0].getName() + ", clArr1[x] is: " + clArr1[i]);
csObjArr[0].CreateCollection(clArr1[i], conf);
}
// test3: 检测db对象中cs,cl的缓存情况
Assert.AreEqual(0, dic.Count);
// drop one cl
csObjArr[0].DropCollection(clArr1[0]);
// test4: 检测删除cl之后，cs,cl的缓存情况
Assert.AreEqual(0, dic.Count);
// drop one cs
db.DropCollectionSpace(csArr[0]);
// test5: 检测删除cs之后，cs,cl的缓存情况
Assert.AreEqual(0, dic.Count);
db.Disconnect();
}
public void CheckInvalidSituaction()
{
bool boolValue = true;
long longValue = 300 * 1000;
ClientOptions opt = new ClientOptions();
opt.CacheInterval = longValue;
opt.EnableCache = boolValue;
Sequoiadb db = new Sequoiadb(config.conf.Coord.Address);
db.Connect(config.conf.UserName, config.conf.Password);
Sequoiadb.InitClient(opt);
// check
Type t = db.GetType();
BindingFlags flag = BindingFlags.NonPublic | BindingFlags.Instance;
FieldInfo f_nameCache = t.GetField("nameCache", flag);
Dictionary <String, DateTime> dic = f_nameCache.GetValue(db) as Dictionary <String, DateTime>;
Assert.AreEqual(0, dic.Count);
String csName = "foo_csharp.";
String clName = "bar_csharp.";
try {
db.DropCollectionSpace(csName);
} catch (BaseException e) {
}
try {
db.CreateCollectionSpace(csName);
Assert.Fail();
} catch (BaseException e) {
csName = "foo_csharp";
}
try {
db.DropCollectionSpace(csName);
} catch (BaseException e) {
}
// check
Assert.AreEqual(0, dic.Count);
CollectionSpace cs = db.CreateCollectionSpace(csName);
// check
Assert.AreEqual(1, dic.Count);
Assert.IsTrue(dic.ContainsKey(csName));
try {
cs.CreateCollection(clName);
Assert.Fail();
} catch (BaseException e) {
clName = "bar_csharp";
}
// check
Assert.AreEqual(1, dic.Count);
Assert.IsTrue(dic.ContainsKey(csName));
cs.CreateCollection(clName);
// check
Assert.AreEqual(2, dic.Count);
Assert.IsTrue(dic.ContainsKey(csName + "." + clName));
Assert.IsTrue(dic.ContainsKey(csName));
db.DropCollectionSpace(csName);
// check
Assert.AreEqual(0, dic.Count);
db.Disconnect();
}
public void CreateReplicaCataSetTest()
{
try
{
System.Console.WriteLine(config.conf.Groups[2].Nodes[0].HostName.ToString());
System.Console.WriteLine(config.conf.Groups[2].Nodes[0].Port.ToString());
System.Console.WriteLine(config.conf.Groups[2].Nodes[0].DBPath.ToString());
string str1 = config.conf.Groups[2].Nodes[0].HostName.ToString();
string str2 = config.conf.Groups[2].Nodes[0].Port.ToString();
string str3 = config.conf.Groups[2].Nodes[0].DBPath.ToString();
sdb.CreateReplicaCataGroup(config.conf.Groups[2].Nodes[0].HostName,
config.conf.Groups[2].Nodes[0].Port,
config.conf.Groups[2].Nodes[0].DBPath,
null);
}
catch (BaseException)
{
}
Sequoiadb sdb2 = new Sequoiadb(config.conf.Groups[2].Nodes[0].HostName,
config.conf.Groups[2].Nodes[0].Port);
sdb2.Connect();
Assert.IsNotNull(sdb2.Connection);
sdb2.Disconnect();
}
public void GetListTest()
{
BsonDocument dummy = new BsonDocument();
BsonDocument bson = null;
DBCursor cursor = null;
// list cs
cursor = sdb.GetList(SDBConst.SDB_LIST_COLLECTIONSPACES, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
// list cl
cursor = sdb.GetList(SDBConst.SDB_LIST_COLLECTIONS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
BsonDocument obj = new BsonDocument("test", "test");
coll.Insert(obj);
// list groups
// check whether it is in the cluster environment or not
if (Constants.isClusterEnv(sdb))
{
cursor = sdb.GetList(SDBConst.SDB_LIST_GROUPS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
}
// list task
cursor = sdb.GetList(SDBConst.SDB_LIST_TASKS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
// list domains
if (Constants.isClusterEnv(sdb))
{
string dmName = "testListDomain";
Domain dm = sdb.CreateDomain(dmName, null);
cursor = null;
cursor = sdb.ListDomains(null, null, null, null);
Assert.IsNotNull(cursor);
Assert.IsNotNull(cursor.Next());
sdb.DropDomain(dmName);
}
// list stored procedure
cursor = sdb.GetList(SDBConst.SDB_LIST_STOREPROCEDURES, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
// list all the contexts
if (Constants.isClusterEnv(sdb))
{
sdb.Disconnect();
sdb = new Sequoiadb(config.conf.Data.Address);
sdb.Connect(config.conf.UserName, config.conf.Password);
}
cursor = sdb.GetList(SDBConst.SDB_LIST_CONTEXTS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
// list current context
cursor = sdb.GetList(SDBConst.SDB_LIST_CONTEXTS_CURRENT, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
// list all the sessions
cursor = sdb.GetList(SDBConst.SDB_LIST_SESSIONS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
// list current session
cursor = sdb.GetList(SDBConst.SDB_LIST_SESSIONS_CURRENT, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
// list storge units
cursor = sdb.GetList(SDBConst.SDB_LIST_STORAGEUNITS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
}
public void GetSnapshotTest()
{
Sequoiadb sdb2 = new Sequoiadb(config.conf.Coord.Address);
sdb2.Connect();
BsonDocument dummy = new BsonDocument();
DBCursor cursor = sdb2.GetSnapshot(SDBConst.SDB_SNAP_CONTEXTS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
BsonDocument bson = cursor.Next();
Assert.IsNotNull(bson);
cursor = sdb2.GetSnapshot(SDBConst.SDB_SNAP_CONTEXTS_CURRENT, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
cursor = sdb2.GetSnapshot(SDBConst.SDB_SNAP_SESSIONS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
cursor = sdb2.GetSnapshot(SDBConst.SDB_SNAP_SESSIONS_CURRENT, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
cursor = sdb2.GetSnapshot(SDBConst.SDB_SNAP_COLLECTIONS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
cursor = sdb2.GetSnapshot(SDBConst.SDB_SNAP_COLLECTIONSPACES, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
cursor = sdb2.GetSnapshot(SDBConst.SDB_SNAP_DATABASE, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
cursor = sdb2.GetSnapshot(SDBConst.SDB_SNAP_SYSTEM, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
if (Constants.isClusterEnv(sdb))
{
cursor = sdb.GetSnapshot(SDBConst.SDB_SNAP_CATALOG, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
BsonDocument obj = cursor.Next();
Assert.IsNotNull(obj);
}
sdb2.Disconnect();
}
public void IsClosedTest()
{
//bool result = false;
Sequoiadb sdb2 = new Sequoiadb(config.conf.Coord.Address);
System.Console.WriteLine(config.conf.Coord.Address.ToString());
sdb2.Connect("", "");
Assert.IsNotNull(sdb2.Connection);
// TODO:
//result = sdb2.IsClosed();
Assert.IsFalse(false);
// check
sdb2.Disconnect();
//result = sdb2.IsClosed();
Assert.IsTrue(true);
}
public void Connect_With_Serval_Arg_Test()
{
List<string> list = new List<string>();
list.Add("192.168.20.35:12340");
list.Add("192.168.20.36:12340");
list.Add("123:123");
list.Add("");
list.Add("192.168.20.40");
list.Add("192.168.30.161:11810");
list.Add("localhost:50000");
list.Add("192.168.20.42:11810");
list.Add("192.168.20.165:11810");
list.Add("localhost:12340");
list.Add("192.168.20.40:12340");
ConfigOptions options = new ConfigOptions();
options.MaxAutoConnectRetryTime = 0;
options.ConnectTimeout = 100;
// connect
Sequoiadb sdb1 = new Sequoiadb(list);
sdb1.Connect("", "", options);
// set option and change the connect
options.ConnectTimeout = 2000;
sdb1.ChangeConnectionOptions(options);
// check
DBCursor cursor = sdb1.GetList(4, null, null, null);
Assert.IsTrue(cursor != null);
sdb1.Disconnect();
}
public static void SequoiadbInitialize(TestContext testContext)
{
if (config == null)
{
config = new Config();
}
sdb = new Sequoiadb(config.conf.Coord.Address);
sdb.Connect(config.conf.UserName, config.conf.Password);
// check whether it is in the cluster environment or not
if (!Constants.isClusterEnv(sdb))
{
return;
}
// argument
groupName = config.conf.Groups[3].GroupName;
hostName = config.conf.Groups[3].Nodes[0].HostName;
port = config.conf.Groups[3].Nodes[0].Port;
dbpath = config.conf.Groups[3].Nodes[0].DBPath;
// drop the exist group
group = sdb.GetReplicaGroup(groupName);
if (group != null)
{
// drop all the cs in current group, and then remove this group
int nodeNum = group.GetNodeNum(SDBConst.NodeStatus.SDB_NODE_ALL);
if (nodeNum > 0)
{
SequoiaDB.Node nd = group.GetMaster();
Sequoiadb db = new Sequoiadb(nd.HostName, nd.Port);
Assert.IsTrue(nd.Start());
db.Connect(config.conf.UserName, config.conf.Password);
DBCursor cursor = db.ListCollectionSpaces();
while (cursor.Next() != null)
{
BsonDocument obj = cursor.Current();
string temp = null;
if (obj.Contains("Name"))
{
temp = obj["Name"].AsString;
}
sdb.DropCollectionSpace(temp);
}
db.Disconnect();
}
try
{
sdb.RemoveReplicaGroup(group.GroupName);
}
catch (BaseException e)
{
string errInfo = e.Message;
Console.WriteLine("Error code is: " + errInfo);
}
}
// create a new group
group = sdb.CreateReplicaGroup(groupName);
Assert.IsTrue(groupName.Equals(group.GroupName));
create_rg_flag = true;
// create a node
BsonDocument options = new BsonDocument();
options.Add("logfilenum", 1);
node = group.CreateNode(hostName, port, dbpath, options);
Assert.IsNotNull(node);
node.Start();
create_node_flag = true;
}
public void setSessionAttrTest()
{
// create another node
string host = "192.168.20.42";
int port = 55555;
string dataPath = "/opt/sequoiadb/database/data/55555";
string groupName = "group1";
ReplicaGroup rg = null;
try
{
// get the exist group
rg = sdb.GetReplicaGroup(groupName);
// remove the node we going to use
SequoiaDB.Node node = rg.GetNode(host, port);
if (node != null)
{
rg.RemoveNode(host, port, new BsonDocument());
}
// create node
Dictionary <string, string> opt = new Dictionary <string, string>();
rg.CreateNode(host, port, dataPath, opt);
rg.Start();
// insert some records first
int num = 10;
List <BsonDocument> insertor = new List <BsonDocument>();
for (int i = 0; i < num; i++)
{
BsonDocument obj = new BsonDocument();
obj.Add("id", i);
insertor.Add(obj);
}
coll.BulkInsert(insertor, 0);
// begin a new session
Sequoiadb sdb2 = new Sequoiadb(config.conf.Coord.Address);
sdb2.Connect(config.conf.UserName, config.conf.Password);
Assert.IsNotNull(sdb2.Connection);
// TODO:
BsonDocument conf = new BsonDocument("PreferedInstance", "m");
sdb2.SetSessionAttr(conf);
// check
// record the slave note "TotalDataRead" before query
Sequoiadb sddb = new Sequoiadb(host, port);
sddb.Connect(config.conf.UserName, config.conf.Password);
DBCursor cur1 = sddb.GetSnapshot(6, null, null, null);
BsonDocument status1 = cur1.Next();
long count1 = status1.GetValue("TotalDataRead").AsInt64;
// query
DBCursor cursor = coll.Query(null, null, null, null, 0, -1);
BsonDocument o = new BsonDocument();
long count = 0;
while ((o = cursor.Next()) != null)
{
count++;
}
// record the slave note "TotalRead" after query
DBCursor cur2 = sddb.GetSnapshot(6, null, null, null);
BsonDocument status2 = cur2.Next();
long count2 = status2.GetValue("TotalDataRead").AsInt64;
//Assert.IsTrue(num == count2 - count1);
long temp = count2 - count1;
Console.WriteLine("count2 is " + count2 + ", count1 is " + count1);
DBCursor cur3 = sddb.GetSnapshot(6, null, null, null);
BsonDocument status3 = cur3.Next();
long count3 = status3.GetValue("TotalRead").AsInt64;
}
finally
{
// remove the newly build node
SequoiaDB.Node node = rg.GetNode(host, port);
if (node != null)
{
rg.RemoveNode(host, port, new BsonDocument());
}
}
}
public void GetListTest()
{
BsonDocument dummy = new BsonDocument();
BsonDocument bson = null;
DBCursor cursor = null;
// list cs
cursor = sdb.GetList(SDBConst.SDB_LIST_COLLECTIONSPACES, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
// list cl
cursor = sdb.GetList(SDBConst.SDB_LIST_COLLECTIONS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
BsonDocument obj = new BsonDocument("test", "test");
coll.Insert(obj);
// list groups
// check whether it is in the cluster environment or not
if (Constants.isClusterEnv(sdb))
{
cursor = sdb.GetList(SDBConst.SDB_LIST_GROUPS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
}
// list task
cursor = sdb.GetList(SDBConst.SDB_LIST_TASKS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
// list domains
if (Constants.isClusterEnv(sdb))
{
string dmName = "testListDomain";
Domain dm = sdb.CreateDomain(dmName, null);
cursor = null;
cursor = sdb.ListDomains(null, null, null, null);
Assert.IsNotNull(cursor);
Assert.IsNotNull(cursor.Next());
sdb.DropDomain(dmName);
}
// list stored procedure
cursor = sdb.GetList(SDBConst.SDB_LIST_STOREPROCEDURES, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
// list all the contexts
if (Constants.isClusterEnv(sdb))
{
sdb.Disconnect();
sdb = new Sequoiadb(config.conf.Data.Address);
sdb.Connect(config.conf.UserName, config.conf.Password);
}
cursor = sdb.GetList(SDBConst.SDB_LIST_CONTEXTS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
// list current context
cursor = sdb.GetList(SDBConst.SDB_LIST_CONTEXTS_CURRENT, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
// list all the sessions
cursor = sdb.GetList(SDBConst.SDB_LIST_SESSIONS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
// list current session
cursor = sdb.GetList(SDBConst.SDB_LIST_SESSIONS_CURRENT, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
// list storge units
cursor = sdb.GetList(SDBConst.SDB_LIST_STORAGEUNITS, dummy, dummy, dummy);
Assert.IsNotNull(cursor);
bson = cursor.Next();
Assert.IsNotNull(bson);
}
public void IsValidTest()
{
bool result = false;
Sequoiadb sdb2 = new Sequoiadb(config.conf.Coord.Address);
System.Console.WriteLine(config.conf.Coord.Address.ToString());
sdb2.Connect("", "");
Assert.IsNotNull(sdb2.Connection);
// check before disconnect
result = sdb2.IsValid();
Assert.IsTrue(result);
// check after disconnect
sdb2.Disconnect();
result = sdb2.IsValid();
Assert.IsFalse(result);
/*
// check after shutdown database manually
sdb2 = new SequoiaClient(config.conf.Coord.Address);
sdb2.Connect("", "");
result = true;
result = sdb2.IsValid();
Assert.IsFalse(result);
*/
}
public void MyTestCleanup()
{
// check whether it is in the cluster environment or not
if (!Constants.isClusterEnv(sdb))
{
Console.WriteLine("removeRG is for cluster environment only.");
return;
}
group = sdb.GetReplicaGroup(groupName);
if (group != null)
{
// drop all the cs in current group, and then remove this group
int nodeNum = group.GetNodeNum(SDBConst.NodeStatus.SDB_NODE_ALL);
if (nodeNum > 0)
{
var nd = group.GetMaster();
var db = new Sequoiadb(nd.HostName, nd.Port);
Assert.IsTrue(nd.Start());
db.Connect(config.conf.UserName, config.conf.Password);
DBCursor cursor = db.ListCollectionSpaces();
while (cursor.Next() != null)
{
BsonDocument obj = cursor.Current();
string temp = null;
if (obj.Contains("Name"))
temp = obj["Name"].AsString;
sdb.DropCollectionSpace(temp);
}
db.Disconnect();
}
Assert.IsTrue(group.Stop());
// remove group
try
{
sdb.RemoveReplicaGroup(group.GroupName);
}
catch (BaseException e)
{
string errInfo = e.Message;
Console.WriteLine("Error code is: " + errInfo);
}
}
sdb.Disconnect();
}