public async Task Test_Use_Simple_Layer() { using (var db = MemoryDatabase.CreateNew("FOO")) { var location = db.GlobalSpace; var map = new FdbMap <int, string>("Foos", db.GlobalSpace.Partition.ByKey("Foos"), KeyValueEncoders.Values.StringEncoder); var index = new FdbIndex <int, string>("Foos.ByColor", db.GlobalSpace.Partition.ByKey("Foos", "Color")); using (var tr = db.BeginTransaction(this.Cancellation)) { map.Set(tr, 3, @"{ ""name"": ""Juliet"", ""color"": ""red"" }"); map.Set(tr, 2, @"{ ""name"": ""Joey"", ""color"": ""blue"" }"); map.Set(tr, 1, @"{ ""name"": ""Bob"", ""color"": ""red"" }"); index.Add(tr, 3, "red"); index.Add(tr, 2, "blue"); index.Add(tr, 1, "red"); await tr.CommitAsync(); } db.Debug_Dump(true); //// Collect memory //Trace.WriteLine("### GARBAGE COLLECT! ###"); //db.Collect(); //db.Debug_Dump(); } }
public async Task Test_FdbMap_List() { using (var db = await OpenTestPartitionAsync()) { var location = await GetCleanDirectory(db, "Collections", "Maps"); var map = new FdbMap <string, string>("Foos", location.Partition("Foos"), KeyValueEncoders.Values.StringEncoder); // write a bunch of keys await db.WriteAsync((tr) => { map.Set(tr, "foo", "foo_value"); map.Set(tr, "bar", "bar_value"); }, this.Cancellation); #if DEBUG await DumpSubspace(db, location); #endif // read them back using (var tr = db.BeginTransaction(this.Cancellation)) { var value = await map.GetAsync(tr, "foo"); Assert.That(value, Is.EqualTo("foo_value")); value = await map.GetAsync(tr, "bar"); Assert.That(value, Is.EqualTo("bar_value")); Assert.That(async() => await map.GetAsync(tr, "baz"), Throws.InstanceOf <KeyNotFoundException>()); var opt = await map.TryGetAsync(tr, "baz"); Assert.That(opt.HasValue, Is.False); } } }
public async Task Test_FdbMap_List() { using (var db = await OpenTestPartitionAsync()) { var location = db.Root["Collections"]["Maps"]; await CleanLocation(db, location); var mapFoos = new FdbMap <string, string>(location.ByKey("Foos"), BinaryEncoding.StringEncoder); // write a bunch of keys await mapFoos.WriteAsync(db, (tr, foos) => { foos.Set(tr, "foo", "foo_value"); foos.Set(tr, "bar", "bar_value"); }, this.Cancellation); #if FULL_DEBUG await DumpSubspace(db, location); #endif // read them back await mapFoos.ReadAsync(db, async (tr, foos) => { var value = await foos.GetAsync(tr, "foo"); Assert.That(value, Is.EqualTo("foo_value")); value = await foos.GetAsync(tr, "bar"); Assert.That(value, Is.EqualTo("bar_value")); Assert.That(async() => await foos.GetAsync(tr, "baz"), Throws.InstanceOf <KeyNotFoundException>()); var opt = await foos.TryGetAsync(tr, "baz"); Assert.That(opt.HasValue, Is.False); }, this.Cancellation); } }
public async Task Test_FdbMap_Read_Write_Delete() { using (var db = await OpenTestPartitionAsync()) { var location = db.Root["Collections"]["Maps"]; await CleanLocation(db, location); var mapFoos = new FdbMap <string, string>(location.ByKey("Foos"), BinaryEncoding.StringEncoder); string secret = "world:" + Guid.NewGuid().ToString(); // read non existing value await mapFoos.WriteAsync(db, async (tr, foos) => { Assert.That(async() => await foos.GetAsync(tr, "hello"), Throws.InstanceOf <KeyNotFoundException>()); var value = await foos.TryGetAsync(tr, "hello"); Assert.That(value.HasValue, Is.False); Assert.That(value.Value, Is.Null); }, this.Cancellation); // write value await mapFoos.WriteAsync(db, (tr, foos) => foos.Set(tr, "hello", secret), this.Cancellation); #if FULL_DEBUG await DumpSubspace(db, location); #endif // read value back await mapFoos.ReadAsync(db, async (tr, foos) => { var value = await foos.GetAsync(tr, "hello"); Assert.That(value, Is.EqualTo(secret)); var opt = await foos.TryGetAsync(tr, "hello"); Assert.That(opt.HasValue, Is.True); Assert.That(opt.Value, Is.EqualTo(secret)); }, this.Cancellation); // directly read the value, behind the table's back await mapFoos.ReadAsync(db, async (tr, foos) => { var value = await tr.GetAsync(foos.Subspace.AsDynamic().Encode("Foos", "hello")); Assert.That(value, Is.Not.EqualTo(Slice.Nil)); Assert.That(value.ToString(), Is.EqualTo(secret)); }, this.Cancellation); // delete the value await mapFoos.WriteAsync(db, (tr, foos) => foos.Remove(tr, "hello"), this.Cancellation); #if FULL_DEBUG await DumpSubspace(db, location); #endif // verifiy that it is gone await mapFoos.ReadAsync(db, async (tr, foos) => { Assert.That(async() => await foos.GetAsync(tr, "hello"), Throws.InstanceOf <KeyNotFoundException>()); var value = await foos.TryGetAsync(tr, "hello"); Assert.That(value.HasValue, Is.False); // also check directly var folder = await location.Resolve(tr); var data = await tr.GetAsync(folder.Encode("Foos", "hello")); Assert.That(data, Is.EqualTo(Slice.Nil)); }, this.Cancellation); } }
public async Task Test_FdbMap_With_Custom_Key_Encoder() { // Use a table as a backing store for the rules of a Poor Man's firewall, where each keys are the IPEndPoint (tcp only!), and the values are "pass" or "block" // Encode IPEndPoint as the (IP, Port,) encoded with the Tuple codec // note: there is a much simpler way or creating composite keys, this is just a quick and dirty test! var keyEncoder = new KeyEncoder <IPEndPoint>( (ipe) => ipe == null ? Slice.Empty : TuPack.EncodeKey(ipe.Address, ipe.Port), (packed) => { if (packed.IsNullOrEmpty) { return(default(IPEndPoint)); } var t = TuPack.Unpack(packed); return(new IPEndPoint(t.Get <IPAddress>(0), t.Get <int>(1))); } ); var rules = new Dictionary <IPEndPoint, string>() { { new IPEndPoint(IPAddress.Parse("172.16.12.34"), 6667), "block" }, { new IPEndPoint(IPAddress.Parse("192.168.34.56"), 80), "pass" }, { new IPEndPoint(IPAddress.Parse("192.168.34.56"), 443), "pass" } }; using (var db = await OpenTestPartitionAsync()) { var location = db.Root["Collections"]["Maps"]; await CleanLocation(db, location); var mapHosts = new FdbMap <IPEndPoint, string>(location.ByKey("Hosts").AsTyped <IPEndPoint>(keyEncoder), BinaryEncoding.StringEncoder); // import all the rules await mapHosts.WriteAsync(db, (tr, hosts) => { foreach (var rule in rules) { hosts.Set(tr, rule.Key, rule.Value); } }, this.Cancellation); #if FULL_DEBUG await DumpSubspace(db, location); #endif // test the rules await mapHosts.ReadAsync(db, async (tr, hosts) => { var value = await hosts.GetAsync(tr, new IPEndPoint(IPAddress.Parse("172.16.12.34"), 6667)); Assert.That(value, Is.EqualTo("block")); value = await hosts.GetAsync(tr, new IPEndPoint(IPAddress.Parse("192.168.34.56"), 443)); Assert.That(value, Is.EqualTo("pass")); var baz = new IPEndPoint(IPAddress.Parse("172.16.12.34"), 80); Assert.That(async() => await hosts.GetAsync(tr, baz), Throws.InstanceOf <KeyNotFoundException>()); var opt = await hosts.TryGetAsync(tr, baz); Assert.That(opt.HasValue, Is.False); }, this.Cancellation); } }
public async Task Test_FdbMap_Read_Write_Delete() { using (var db = await OpenTestPartitionAsync()) { var location = await GetCleanDirectory(db, "Collections", "Maps"); var map = new FdbMap <string, string>("Foos", location.Partition("Foos"), KeyValueEncoders.Values.StringEncoder); string secret = "world:" + Guid.NewGuid().ToString(); // read non existing value using (var tr = db.BeginTransaction(this.Cancellation)) { Assert.That(async() => await map.GetAsync(tr, "hello"), Throws.InstanceOf <KeyNotFoundException>()); var value = await map.TryGetAsync(tr, "hello"); Assert.That(value.HasValue, Is.False); Assert.That(value.GetValueOrDefault(), Is.Null); } // write value using (var tr = db.BeginTransaction(this.Cancellation)) { map.Set(tr, "hello", secret); await tr.CommitAsync(); } #if DEBUG await DumpSubspace(db, location); #endif // read value back using (var tr = db.BeginTransaction(this.Cancellation)) { var value = await map.GetAsync(tr, "hello"); Assert.That(value, Is.EqualTo(secret)); var opt = await map.TryGetAsync(tr, "hello"); Assert.That(opt.HasValue, Is.True); Assert.That(opt.Value, Is.EqualTo(secret)); } // directly read the value, behind the table's back using (var tr = db.BeginTransaction(this.Cancellation)) { var value = await tr.GetAsync(location.Pack("Foos", "hello")); Assert.That(value, Is.Not.EqualTo(Slice.Nil)); Assert.That(value.ToString(), Is.EqualTo(secret)); } // delete the value using (var tr = db.BeginTransaction(this.Cancellation)) { map.Remove(tr, "hello"); await tr.CommitAsync(); } #if DEBUG await DumpSubspace(db, location); #endif // verifiy that it is gone using (var tr = db.BeginTransaction(this.Cancellation)) { Assert.That(async() => await map.GetAsync(tr, "hello"), Throws.InstanceOf <KeyNotFoundException>()); var value = await map.TryGetAsync(tr, "hello"); Assert.That(value.HasValue, Is.False); // also check directly var data = await tr.GetAsync(location.Pack("Foos", "hello")); Assert.That(data, Is.EqualTo(Slice.Nil)); } } }
public async Task Test_Use_Simple_Layer() { using (var db = MemoryDatabase.CreateNew("FOO")) { var location = db.GlobalSpace; var map = new FdbMap<int, string>("Foos", db.GlobalSpace.Partition.ByKey("Foos"), KeyValueEncoders.Values.StringEncoder); var index = new FdbIndex<int, string>("Foos.ByColor", db.GlobalSpace.Partition.ByKey("Foos", "Color")); using (var tr = db.BeginTransaction(this.Cancellation)) { map.Set(tr, 3, @"{ ""name"": ""Juliet"", ""color"": ""red"" }"); map.Set(tr, 2, @"{ ""name"": ""Joey"", ""color"": ""blue"" }"); map.Set(tr, 1, @"{ ""name"": ""Bob"", ""color"": ""red"" }"); index.Add(tr, 3, "red"); index.Add(tr, 2, "blue"); index.Add(tr, 1, "red"); await tr.CommitAsync(); } db.Debug_Dump(true); //// Collect memory //Trace.WriteLine("### GARBAGE COLLECT! ###"); //db.Collect(); //db.Debug_Dump(); } }
public async Task Test_FdbMap_Read_Write_Delete() { using (var db = await OpenTestPartitionAsync()) { var location = await GetCleanDirectory(db, "Collections", "Maps"); var map = new FdbMap<string, string>("Foos", location.Partition("Foos"), KeyValueEncoders.Values.StringEncoder); string secret = "world:" + Guid.NewGuid().ToString(); // read non existing value using (var tr = db.BeginTransaction(this.Cancellation)) { Assert.That(async () => await map.GetAsync(tr, "hello"), Throws.InstanceOf<KeyNotFoundException>()); var value = await map.TryGetAsync(tr, "hello"); Assert.That(value.HasValue, Is.False); Assert.That(value.GetValueOrDefault(), Is.Null); } // write value using (var tr = db.BeginTransaction(this.Cancellation)) { map.Set(tr, "hello", secret); await tr.CommitAsync(); } #if DEBUG await DumpSubspace(db, location); #endif // read value back using (var tr = db.BeginTransaction(this.Cancellation)) { var value = await map.GetAsync(tr, "hello"); Assert.That(value, Is.EqualTo(secret)); var opt = await map.TryGetAsync(tr, "hello"); Assert.That(opt.HasValue, Is.True); Assert.That(opt.Value, Is.EqualTo(secret)); } // directly read the value, behind the table's back using (var tr = db.BeginTransaction(this.Cancellation)) { var value = await tr.GetAsync(location.Pack("Foos", "hello")); Assert.That(value, Is.Not.EqualTo(Slice.Nil)); Assert.That(value.ToString(), Is.EqualTo(secret)); } // delete the value using (var tr = db.BeginTransaction(this.Cancellation)) { map.Remove(tr, "hello"); await tr.CommitAsync(); } #if DEBUG await DumpSubspace(db, location); #endif // verifiy that it is gone using (var tr = db.BeginTransaction(this.Cancellation)) { Assert.That(async () => await map.GetAsync(tr, "hello"), Throws.InstanceOf<KeyNotFoundException>()); var value = await map.TryGetAsync(tr, "hello"); Assert.That(value.HasValue, Is.False); // also check directly var data = await tr.GetAsync(location.Pack("Foos", "hello")); Assert.That(data, Is.EqualTo(Slice.Nil)); } } }
public async Task Test_FdbMap_With_Custom_Key_Encoder() { // Use a table as a backing store for the rules of a Poor Man's firewall, where each keys are the IPEndPoint (tcp only!), and the values are "pass" or "block" // Encode IPEndPoint as the (IP, Port,) encoded with the Tuple codec // note: there is a much simpler way or creating composite keys, this is just a quick and dirty test! var keyEncoder = KeyValueEncoders.Bind<IPEndPoint>( (ipe) => ipe == null ? Slice.Empty : FdbTuple.Pack(ipe.Address, ipe.Port), (packed) => { if (packed.IsNullOrEmpty) return default(IPEndPoint); var t = FdbTuple.Unpack(packed); return new IPEndPoint(t.Get<IPAddress>(0), t.Get<int>(1)); } ); var rules = new Dictionary<IPEndPoint, string>() { { new IPEndPoint(IPAddress.Parse("172.16.12.34"), 6667), "block" }, { new IPEndPoint(IPAddress.Parse("192.168.34.56"), 80), "pass" }, { new IPEndPoint(IPAddress.Parse("192.168.34.56"), 443), "pass" } }; using (var db = await OpenTestPartitionAsync()) { var location = await GetCleanDirectory(db, "Collections", "Maps"); var map = new FdbMap<IPEndPoint, string>("Firewall", location.Partition("Hosts"), keyEncoder, KeyValueEncoders.Values.StringEncoder); // import all the rules await db.WriteAsync((tr) => { foreach(var rule in rules) { map.Set(tr, rule.Key, rule.Value); } }, this.Cancellation); #if DEBUG await DumpSubspace(db, location); #endif // test the rules using (var tr = db.BeginTransaction(this.Cancellation)) { var value = await map.GetAsync(tr, new IPEndPoint(IPAddress.Parse("172.16.12.34"), 6667)); Assert.That(value, Is.EqualTo("block")); value = await map.GetAsync(tr, new IPEndPoint(IPAddress.Parse("192.168.34.56"), 443)); Assert.That(value, Is.EqualTo("pass")); var baz = new IPEndPoint(IPAddress.Parse("172.16.12.34"), 80); Assert.That(async () => await map.GetAsync(tr, baz), Throws.InstanceOf<KeyNotFoundException>()); var opt = await map.TryGetAsync(tr, baz); Assert.That(opt.HasValue, Is.False); } } }
public async Task Test_FdbMap_List() { using (var db = await OpenTestPartitionAsync()) { var location = await GetCleanDirectory(db, "Collections", "Maps"); var map = new FdbMap<string, string>("Foos", location.Partition("Foos"), KeyValueEncoders.Values.StringEncoder); // write a bunch of keys await db.WriteAsync((tr) => { map.Set(tr, "foo", "foo_value"); map.Set(tr, "bar", "bar_value"); }, this.Cancellation); #if DEBUG await DumpSubspace(db, location); #endif // read them back using (var tr = db.BeginTransaction(this.Cancellation)) { var value = await map.GetAsync(tr, "foo"); Assert.That(value, Is.EqualTo("foo_value")); value = await map.GetAsync(tr, "bar"); Assert.That(value, Is.EqualTo("bar_value")); Assert.That(async () => await map.GetAsync(tr, "baz"), Throws.InstanceOf<KeyNotFoundException>()); var opt = await map.TryGetAsync(tr, "baz"); Assert.That(opt.HasValue, Is.False); } } }