public void T000_RangeKey_EncodedSort()
{
RecordKey a_key = new RecordKey().appendParsedKey("AAAAAAA/ZZZZZZZZZ/s/s/s/s/s");
RecordKey b_key = new RecordKey().appendParsedKey("B/ZZ");
Assert.True(a_key.CompareTo(b_key) < 0, "a key should be less than b key");
RecordKey a_range = RangemapManager.RangeKey.newSegmentRangeKey(a_key, a_key, 0).toRecordKey();
RecordKey b_range = RangemapManager.RangeKey.newSegmentRangeKey(b_key, b_key, 0).toRecordKey();
Console.WriteLine(Lsd.ToHexString(a_range.encode()));
Console.WriteLine(Lsd.ToHexString(b_range.encode()));
Assert.True(a_range.CompareTo(b_range) < 0, "a range should also be less than b range!!");
Assert.True(b_range.CompareTo(a_range) > 0, "b range should be greater than a range!!");
}
public void T000_TestBasic_SnapshotScanAll()
{
// TODO: right now we have to make a subset stage, because otherwise
// we see the .ROOT keyspace. Perhaps we should make prefixes
// an automatic part of stage instantiation!?!?
var snap_db = new StepsStageSnapshot(
new StepsStageSubset(
new RecordKeyType_String("snapdb"),
new LayerManager(InitMode.NEW_REGION, "c:\\BENDtst\\snap")));
string[] keys = new string[] { "1/2/3", "1/3/4", "1/5/3" };
foreach (var key in keys) {
snap_db.setValue(new RecordKey().appendParsedKey(key), RecordUpdate.WithPayload("snap1 data:" + key));
}
// TODO: check the data contents also to make sure we actually saw the right rows
{
int count = 0;
foreach (var row in snap_db.scanForward(ScanRange<RecordKey>.All())) {
var match_key = new RecordKey().appendParsedKey(keys[count]);
Assert.True(match_key.CompareTo(row.Key) == 0, "scan key mismatch");
Console.WriteLine("scanned: " + row);
count++;
}
Assert.AreEqual(keys.Length, count, "incorrect number of keys in stage1 scan");
}
var snap1 = snap_db.getSnapshot();
foreach (var key in keys) {
var newkey = new RecordKey().appendParsedKey(key).appendParsedKey("snap2");
snap_db.setValue(newkey, RecordUpdate.WithPayload("snap2 data:" + key));
}
{
int count = 0;
foreach (var row in snap1.scanForward(ScanRange<RecordKey>.All())) {
var match_key = new RecordKey().appendParsedKey(keys[count]);
Assert.True(match_key.CompareTo(row.Key) == 0, "scan key mismatch");
Console.WriteLine("scanned: " + row);
count++;
}
Assert.AreEqual(keys.Length, count, "incorrect number of keys in snap scan");
}
}
public ReplHandler(IStepsSnapshotKVDB db, ServerContext ctx)
{
this.next_stage = db;
this.my_repl_interface = new MyReplConnection(this);
this.rnd = new Random();
this.pusher = new ReplPusher(this);
this.ctx = ctx;
try {
var di_rk = new RecordKey()
.appendKeyPart("_config")
.appendKeyPart("DATA-INSTANCE-ID");
var rec = db.FindNext(di_rk, true);
if (di_rk.CompareTo(rec.Key) != 0) {
throw new Exception(
String.Format("ReplHandler {0} , not able to fetch DATA-INSTANCE-ID", ctx.server_guid));
}
this.data_instance_id = rec.Value.ToString();
Console.WriteLine("ReplHandler - {0}: data_instance_id {1}",
ctx.server_guid, data_instance_id);
} catch (KeyNotFoundException) {
throw new Exception("no data instance ID, try InitResume or InitJoin");
}
// check server_guid matches?
// register ourself
ctx.connector.registerServer(ctx.server_guid, this.my_repl_interface);
// startup our background task
worker = new Thread(delegate() {
this.workerThread();
});
worker.Start();
}
public void T000_TestBasic_SubsetScanAll()
{
LayerManager db = new LayerManager(InitMode.NEW_REGION, "c:\\BENDtst\\subset");
var stage1 = new StepsStageSubset(new RecordKeyType_String("stage1"), db);
var stage2 = new StepsStageSubset(new RecordKeyType_String("stage2"), db);
string[] keys = new string[] { "1/2/3", "1/3/4", "1/5/3" };
foreach (var key in keys) {
stage1.setValue(new RecordKey().appendParsedKey(key), RecordUpdate.WithPayload("st1 data:" + key));
stage2.setValue(new RecordKey().appendParsedKey(key), RecordUpdate.WithPayload("st2 data:" + key));
}
// TODO: check the data contents also to make sure we actually saw the right rows
{
int count = 0;
foreach (var row in stage1.scanForward(ScanRange<RecordKey>.All())) {
var match_key = new RecordKey().appendParsedKey(keys[count]);
Assert.True(match_key.CompareTo(row.Key) == 0, "scan key mismatch");
Console.WriteLine("scanned: " + row);
count++;
}
Assert.AreEqual(keys.Length, count, "incorrect number of keys in stage1 scan");
}
{
int count = 0;
foreach (var row in stage2.scanForward(ScanRange<RecordKey>.All())) {
var match_key = new RecordKey().appendParsedKey(keys[count]);
Assert.True(match_key.CompareTo(row.Key) == 0, "scan key mismatch");
Console.WriteLine("scanned: " + row);
count++;
}
Assert.AreEqual(keys.Length, count, "incorrect number of keys in stage2 scan");
}
}
public void T06_RecordKeyDelimiterEscape()
{
string DELIM = new String(RecordKey.PRINTED_DELIMITER, 1);
RecordKey key1 = new RecordKey();
key1.appendKeyParts("1", "2", "3");
Assert.AreEqual(3, key1.numParts());
RecordKey dkey1 = new RecordKey(key1.encode());
Assert.AreEqual(3, dkey1.numParts(), "dkey1 delimiter decode");
RecordKey key2 = new RecordKey();
key2.appendKeyPart("1" + DELIM + "2" + DELIM + "3");
Assert.AreEqual(1, key2.numParts());
RecordKey dkey2 = new RecordKey(key2.encode());
Assert.AreEqual(1, dkey2.numParts(), "dkey2 delimiter decode");
// key2 > key1
Assert.AreEqual(1, key2.CompareTo(key1));
Assert.AreEqual(-1, key1.CompareTo(key2));
}
public void T12_RecordKey_Bug()
{
var testkey = new RecordKey().appendParsedKey(".zdata/index/fax");
var jeskekey = new RecordKey().appendParsedKey(".zdata/index/jeske");
var jeske2key = new RecordKey().appendParsedKey(".zdata/index/jeske").appendKeyPart("");
var jeske2keyAP = RecordKey.AfterPrefix(jeske2key);
Assert.True(jeskekey.CompareTo(testkey) > 0, "1");
Assert.True(jeske2key.CompareTo(testkey) > 0, "2");
Assert.True(jeske2keyAP.CompareTo(testkey) > 0, "3");
RecordKeyComparator startrk = new RecordKeyComparator()
.appendKeyPart(jeske2key);
Assert.True(startrk.CompareTo(testkey) > 0, "4");
}
public void T12_RecordKeyStringCompBugTest()
{
var key5 = new RecordKey().appendParsedKey(@".zdata/index/>you/c:\EmailTest\Data\saved_mail_2002:1407/182");
var key6 = new RecordKey().appendParsedKey(@".zdata/index/?/c:\EmailTest\Data\saved_mail_2002:908/184");
Assert.True('>'.CompareTo('?') < 0, "check char comparison");
Assert.True(String.Compare(">", "?", System.Threading.Thread.CurrentThread.CurrentCulture,
System.Globalization.CompareOptions.Ordinal) < 0, "ordinal string comparison");
int simple_comparison = ">".CompareTo("?");
Assert.AreEqual(simple_comparison,key5.CompareTo(key6), "record keys should come out the same as strings");
// NOTE: this could fail if something returns distance instead of just (-1,0,1)
}
public void T02a_RecordKeySort()
{
String[] parts1 = { "test", "test2", "blah" };
String[] parts2 = { "test", "test3", "blah" }; // > parts 1
String[] parts3 = { "test", "test2a", "blah" }; // > parts 1 (testing per-segment sorting order!)
RecordKey key1 = new RecordKey();
key1.appendKeyParts(parts1);
RecordKey key2 = new RecordKey();
key2.appendKeyParts(parts2);
RecordKey key3 = new RecordKey();
key3.appendKeyParts(parts3);
// key2 > key1
Assert.True(key2.CompareTo(key1) > 0);
Assert.True(key1.CompareTo(key2) < 0);
// key3 > key1
Assert.True(key3.CompareTo(key1) > 0);
Assert.True(key1.CompareTo(key3) < 0);
}
public void T01_RecordKey()
{
String[] parts1 = { "test", "test2", "blah" };
{
RecordKey key = new RecordKey();
key.appendKeyParts(parts1);
byte[] data = key.encode();
// decode
RecordKey key2 = new RecordKey(data);
// verify tostring matches
Assert.AreEqual(key.ToString(), key2.ToString());
// verify comparison
Assert.AreEqual(0, key.CompareTo(key2));
// verify individual parts
}
// verify hierarchial sorting
{
RecordKey key1 = new RecordKey().appendParsedKey(".ROOT/GEN/000");
RecordKey key2 = new RecordKey().appendParsedKey(".ROOT/GEN/000/</aaaa"); // ord('<') -> 60
RecordKey key3 = new RecordKey().appendParsedKey(".ROOT/GEN/000/>"); // ord('>') -> 62
RecordKey key4 = new RecordKey().appendParsedKey(".ROOT/GEN");
Assert.AreEqual(true, ">".CompareTo("<") > 0, "expect '>' > '<'");
Assert.AreEqual(true, key1.CompareTo(key2) < 0, "prefix key should be considered earlier");
Assert.AreEqual(true, key3.CompareTo(key2) > 0, "but parts are considered individually before using length ord('_') > ord('<')");
IComparable<RecordKey> prefixend = RecordKey.AfterPrefix(key1);
Assert.AreEqual(true, prefixend.CompareTo(key1) > 0, "prefix1");
Assert.AreEqual(true, prefixend.CompareTo(key2) > 0, "prefix2");
Assert.AreEqual(true, prefixend.CompareTo(key3) > 0, "prefix3");
Assert.AreEqual(true, prefixend.CompareTo(key4) > 0, "prefix4");
}
}
