public void TestCloseWithActiveListener()
{
Listen(CreateListenerConfig());
OtherDb.Close();
_listener.Port.Should().Be(0);
_listener.Urls.Should().BeEmpty();
}
public void TestMultipleListenersOnSameDatabase()
{
_listener = CreateListener();
var _listener2 = CreateNewListener();
using (var doc1 = new MutableDocument("doc1"))
using (var doc2 = new MutableDocument("doc2")) {
doc1.SetString("name", "Sam");
Db.Save(doc1);
doc2.SetString("name", "Mary");
OtherDb.Save(doc2);
}
RunReplication(
_listener.LocalEndpoint(),
ReplicatorType.PushAndPull,
false,
null,
false, //accept only self signed server cert
_listener.TlsIdentity.Certs[0],
0,
0
);
_listener.Stop();
_listener2.Stop();
OtherDb.Count.Should().Be(2);
}
public void TestMultipleReplicatorsToListener()
{
_listener = Listen(CreateListenerConfig()); // writable listener
// save a doc on listenerDB
using (var doc = new MutableDocument()) {
OtherDb.Save(doc);
}
ValidateMultipleReplicationsTo(ReplicatorType.PushAndPull);
}
private void WithActiveReplicatorAndURLEndpointListeners(bool isCloseNotDelete)
{
WaitAssert waitIdleAssert1 = new WaitAssert();
WaitAssert waitStoppedAssert1 = new WaitAssert();
_listener = CreateListener();
var _listener2 = CreateNewListener();
_listener.Config.Database.ActiveStoppables.Count.Should().Be(2);
_listener2.Config.Database.ActiveStoppables.Count.Should().Be(2);
using (var doc1 = new MutableDocument("doc1"))
using (var doc2 = new MutableDocument("doc2")) {
doc1.SetString("name", "Sam");
Db.Save(doc1);
doc2.SetString("name", "Mary");
OtherDb.Save(doc2);
}
var target = new DatabaseEndpoint(Db);
var config1 = CreateConfig(target, ReplicatorType.PushAndPull, true, sourceDb: OtherDb);
var repl1 = new Replicator(config1);
repl1.AddChangeListener((sender, args) => {
waitIdleAssert1.RunConditionalAssert(() => {
return(args.Status.Activity == ReplicatorActivityLevel.Idle);
});
waitStoppedAssert1.RunConditionalAssert(() => {
return(args.Status.Activity == ReplicatorActivityLevel.Stopped);
});
});
repl1.Start();
waitIdleAssert1.WaitForResult(TimeSpan.FromSeconds(10));
OtherDb.ActiveStoppables.Count.Should().Be(3);
if (isCloseNotDelete)
{
OtherDb.Close();
}
else
{
OtherDb.Delete();
}
OtherDb.ActiveStoppables.Count.Should().Be(0);
OtherDb.IsClosedLocked.Should().Be(true);
waitStoppedAssert1.WaitForResult(TimeSpan.FromSeconds(30));
}
//[Fact] //Mac OS 1-6-21
public void TestMultipleReplicatorsOnReadOnlyListener()
{
var config = CreateListenerConfig(readOnly: true);
_listener = Listen(config);
// save a doc on listener DB
using (var doc = new MutableDocument()) {
OtherDb.Save(doc);
}
ValidateMultipleReplicationsTo(ReplicatorType.Pull);
}
//[Fact] Looks like MSBuild doesn't understand RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ?
public void TestMultipleReplicatorsOnReadOnlyListener()
{
if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) //Mac OS 8-23-21 hang with LiteCore Commit: 5d9539fae43e9282787c2b68772bb85ecbc00b5c [5d9539f]
{
var config = CreateListenerConfig();
config.ReadOnly = true;
_listener = Listen(config);
// save a doc on listener DB
using (var doc = new MutableDocument()) {
OtherDb.Save(doc);
}
ValidateMultipleReplicationsTo(ReplicatorType.Pull);
}
}
//[Fact] uwp
public void TestContinuousP2P()
{
OtherDb.Delete();
OtherDb = OpenDB(OtherDb.Name);
Db.Delete();
ReopenDB();
RunTwoStepContinuous(ReplicatorType.Push, "p2ptest1");
OtherDb.Delete();
OtherDb = OpenDB(OtherDb.Name);
Db.Delete();
ReopenDB();
RunTwoStepContinuous(ReplicatorType.Pull, "p2ptest2");
OtherDb.Delete();
OtherDb = OpenDB(OtherDb.Name);
Db.Delete();
ReopenDB();
RunTwoStepContinuous(ReplicatorType.PushAndPull, "p2ptest3");
}
private void WithActiveReplicationsAndURLEndpointListener(bool isCloseNotDelete)
{
var waitIdleAssert1 = new ManualResetEventSlim();
var waitIdleAssert2 = new ManualResetEventSlim();
var waitStoppedAssert1 = new ManualResetEventSlim();
var waitStoppedAssert2 = new ManualResetEventSlim();
using (var doc = new MutableDocument()) {
OtherDb.Save(doc);
}
_listener = CreateListener();
_listener.Config.Database.ActiveStoppables.Count.Should().Be(1);
using (var doc1 = new MutableDocument()) {
Db.Save(doc1);
}
var target = new DatabaseEndpoint(Db);
var config1 = CreateConfig(target, ReplicatorType.PushAndPull, true, sourceDb: OtherDb);
var repl1 = new Replicator(config1);
Database.Delete("urlepTestDb", Directory);
var urlepTestDb = OpenDB("urlepTestDb");
using (var doc2 = new MutableDocument()) {
urlepTestDb.Save(doc2);
}
var config2 = CreateConfig(_listener.LocalEndpoint(), ReplicatorType.PushAndPull, true,
serverCert: _listener.TlsIdentity.Certs[0], sourceDb: urlepTestDb);
var repl2 = new Replicator(config2);
EventHandler <ReplicatorStatusChangedEventArgs> changeListener = (sender, args) =>
{
if (args.Status.Activity == ReplicatorActivityLevel.Idle && args.Status.Progress.Completed ==
args.Status.Progress.Total)
{
if (sender == repl1)
{
waitIdleAssert1.Set();
}
else
{
waitIdleAssert2.Set();
}
}
else if (args.Status.Activity == ReplicatorActivityLevel.Stopped)
{
if (sender == repl1)
{
waitStoppedAssert1.Set();
}
else
{
waitStoppedAssert2.Set();
}
}
};
repl1.AddChangeListener(changeListener);
repl2.AddChangeListener(changeListener);
repl1.Start();
repl2.Start();
WaitHandle.WaitAll(new[] { waitIdleAssert1.WaitHandle, waitIdleAssert2.WaitHandle }, _timeout)
.Should().BeTrue();
OtherDb.ActiveStoppables.Count.Should().Be(2);
urlepTestDb.ActiveStoppables.Count.Should().Be(1);
if (isCloseNotDelete)
{
urlepTestDb.Close();
OtherDb.Close();
}
else
{
urlepTestDb.Delete();
OtherDb.Delete();
}
OtherDb.ActiveStoppables.Count.Should().Be(0);
urlepTestDb.ActiveStoppables.Count.Should().Be(0);
OtherDb.IsClosedLocked.Should().Be(true);
urlepTestDb.IsClosedLocked.Should().Be(true);
WaitHandle.WaitAll(new[] { waitStoppedAssert1.WaitHandle, waitStoppedAssert2.WaitHandle }, TimeSpan.FromSeconds(20))
.Should().BeTrue();
waitIdleAssert1.Dispose();
waitIdleAssert2.Dispose();
waitStoppedAssert1.Dispose();
waitStoppedAssert2.Dispose();
Thread.Sleep(500);
}
public void TestReplicatorAndListenerOnSameDatabase()
{
using (var doc = new MutableDocument()) {
OtherDb.Save(doc);
}
CreateListener();
using (var doc1 = new MutableDocument()) {
Db.Save(doc1);
}
var target = new DatabaseEndpoint(Db);
var config1 = CreateConfig(target, ReplicatorType.PushAndPull, true, sourceDb: OtherDb);
var repl1 = new Replicator(config1);
Database.Delete("urlepTestDb", Directory);
var urlepTestDb = OpenDB("urlepTestDb");
using (var doc2 = new MutableDocument()) {
urlepTestDb.Save(doc2);
}
var config2 = CreateConfig(_listener.LocalEndpoint(), ReplicatorType.PushAndPull, true,
serverCert: _listener.TlsIdentity.Certs[0], sourceDb: urlepTestDb);
var repl2 = new Replicator(config2);
var wait1 = new ManualResetEventSlim();
var wait2 = new ManualResetEventSlim();
EventHandler <ReplicatorStatusChangedEventArgs> changeListener = (sender, args) =>
{
if (args.Status.Activity == ReplicatorActivityLevel.Idle && args.Status.Progress.Completed ==
args.Status.Progress.Total)
{
if (OtherDb.Count == 3 && Db.Count == 3 && urlepTestDb.Count == 3)
{
((Replicator)sender).Stop();
}
}
else if (args.Status.Activity == ReplicatorActivityLevel.Stopped)
{
if (sender == repl1)
{
wait1.Set();
}
else
{
wait2.Set();
}
}
};
var token1 = repl1.AddChangeListener(changeListener);
var token2 = repl2.AddChangeListener(changeListener);
repl1.Start();
repl2.Start();
WaitHandle.WaitAll(new[] { wait1.WaitHandle, wait2.WaitHandle }, TimeSpan.FromSeconds(20))
.Should().BeTrue();
repl1.RemoveChangeListener(token1);
repl2.RemoveChangeListener(token2);
Db.Count.Should().Be(3, "because otherwise not all docs were received into Db");
OtherDb.Count.Should().Be(3, "because otherwise not all docs were received into OtherDb");
urlepTestDb.Count.Should().Be(3, "because otherwise not all docs were received into urlepTestDb");
repl1.Dispose();
repl2.Dispose();
wait1.Dispose();
wait2.Dispose();
urlepTestDb.Delete();
_listener.Stop();
Thread.Sleep(500); // wait for everything to stop
}
public void TestStatus()
{
ulong maxConnectionCount = 0UL;
ulong maxActiveCount = 0UL;
//init and start a listener
_listener = CreateListener(false);
//listener is started at this point
_listener.Status.ConnectionCount.Should().Be(0, "Listener's connection count should be 0 because no client connection has been established.");
_listener.Status.ActiveConnectionCount.Should().Be(0, "Listener's active connection count should be 0 because no client connection has been established.");
using (var doc1 = new MutableDocument())
using (var doc2 = new MutableDocument()) {
doc1.SetString("name", "Sam");
Db.Save(doc1);
doc2.SetString("name", "Mary");
OtherDb.Save(doc2);
}
var targetEndpoint = _listener.LocalEndpoint();
var config = new ReplicatorConfiguration(Db, targetEndpoint);
using (var repl = new Replicator(config)) {
var waitAssert = new WaitAssert();
var token = repl.AddChangeListener((sender, args) =>
{
WriteLine($"Yeehaw {_listener.Status.ConnectionCount} / {_listener.Status.ActiveConnectionCount}");
maxConnectionCount = Math.Max(maxConnectionCount, _listener.Status.ConnectionCount);
maxActiveCount = Math.Max(maxActiveCount, _listener.Status.ActiveConnectionCount);
waitAssert.RunConditionalAssert(() =>
{
return(args.Status.Activity == ReplicatorActivityLevel.Stopped);
});
});
repl.Start();
while (repl.Status.Activity != ReplicatorActivityLevel.Busy)
{
Thread.Sleep(100);
}
// For some reason running on mac throws off the timing enough so that the active connection count
// of 1 is never seen. So record the value right after it becomes busy.
maxConnectionCount = Math.Max(maxConnectionCount, _listener.Status.ConnectionCount);
maxActiveCount = Math.Max(maxActiveCount, _listener.Status.ActiveConnectionCount);
try {
waitAssert.WaitForResult(TimeSpan.FromSeconds(100));
} finally {
repl.RemoveChangeListener(token);
}
}
maxConnectionCount.Should().Be(1);
maxActiveCount.Should().Be(1);
//stop the listener
_listener.Stop();
_listener.Status.ConnectionCount.Should().Be(0, "Listener's connection count should be 0 because the connection is stopped.");
_listener.Status.ActiveConnectionCount.Should().Be(0, "Listener's active connection count should be 0 because the connection is stopped.");
}
public void TestShortP2P()
{
//var testNo = 1;
foreach (var protocolType in new[] { ProtocolType.ByteStream, ProtocolType.MessageStream })
{
using (var mdoc = new MutableDocument("livesindb")) {
mdoc.SetString("name", "db");
Db.Save(mdoc);
}
using (var mdoc = new MutableDocument("livesinotherdb")) {
mdoc.SetString("name", "otherdb");
OtherDb.Save(mdoc);
}
var listener = new MessageEndpointListener(new MessageEndpointListenerConfiguration(OtherDb, protocolType));
var server = new MockServerConnection(listener, protocolType);
var messageendpoint = new MessageEndpoint($"p2ptest1", server, protocolType,
new MockConnectionFactory(null));
var uid = messageendpoint.Uid;
// PUSH
var config = new ReplicatorConfiguration(Db, messageendpoint)
{
ReplicatorType = ReplicatorType.Push,
Continuous = false
};
RunReplication(config, 0, 0);
OtherDb.Count.Should().Be(2UL, "because it contains the original and new");
Db.Count.Should().Be(1UL, "because there is no pull, so the first db should only have the original");
// PULL
config = new ReplicatorConfiguration(Db, messageendpoint)
{
ReplicatorType = ReplicatorType.Pull,
Continuous = false
};
RunReplication(config, 0, 0);
Db.Count.Should().Be(2UL, "because the pull should add the document from otherDB");
using (var savedDoc = Db.GetDocument("livesinotherdb"))
using (var mdoc = savedDoc.ToMutable()) {
mdoc.SetBoolean("modified", true);
Db.Save(mdoc);
}
using (var savedDoc = OtherDb.GetDocument("livesindb"))
using (var mdoc = savedDoc.ToMutable()) {
mdoc.SetBoolean("modified", true);
OtherDb.Save(mdoc);
}
// PUSH & PULL
config = new ReplicatorConfiguration(Db,
new MessageEndpoint($"p2ptest1", server, protocolType,
new MockConnectionFactory(null)))
{
Continuous = false
};
RunReplication(config, 0, 0);
Db.Count.Should().Be(2UL, "because no new documents were added");
using (var savedDoc = Db.GetDocument("livesindb")) {
savedDoc.GetBoolean("modified").Should()
.BeTrue("because the property change should have come from the other DB");
}
using (var savedDoc = OtherDb.GetDocument("livesinotherdb")) {
savedDoc.GetBoolean("modified").Should()
.BeTrue("because the property change should come from the original DB");
}
Db.Delete();
ReopenDB();
OtherDb.Delete();
OtherDb.Dispose();
OtherDb = OpenDB(OtherDb.Name);
}
}
