public void Should_not_update_after_dispose()
{
CreateEnvironmentNode("default");
CreateApplicationNode("default", "application", new Dictionary <string, string> {
{ "key", "value1" }
});
CreateReplicaNode(new ReplicaInfo("default", "application", "https://github.com/vostok"));
using (var storage = GetApplicationsStorage())
{
var expected = ServiceTopology.Build(new List <Uri> {
new Uri("https://github.com/vostok")
}, new Dictionary <string, string> {
{ "key", "value1" }
});
ShouldReturnImmediately(storage, "default", "application", expected);
storage.Dispose();
CreateApplicationNode("default", "application", new Dictionary <string, string> {
{ "key", "value2" }
});
storage.UpdateAll();
ShouldReturnImmediately(storage, "default", "application", expected);
}
}
public void Should_track_application_replicas()
{
CreateEnvironmentNode("default");
CreateApplicationNode("default", "application");
using (var storage = GetApplicationsStorage())
{
var expectedReplicas = new List <Uri>();
for (var times = 0; times < 10; times++)
{
CreateReplicaNode(new ReplicaInfo("default", "application", $"https://github.com/vostok/{times}"));
expectedReplicas.Add(new Uri($"https://github.com/vostok/{times}"));
var expected = ServiceTopology.Build(expectedReplicas, null);
if (times == 0)
{
ShouldReturnImmediately(storage, "default", "application", expected);
}
else
{
ShouldReturn(storage, "default", "application", expected);
}
}
}
}
public void Should_works_disconnected()
{
CreateEnvironmentNode("default");
CreateApplicationNode("default", "application");
CreateReplicaNode(new ReplicaInfo("default", "application", "https://github.com/vostok"));
using (var storage = GetApplicationsStorage())
{
var properties = new Dictionary <string, string>
{
{ "key", "value" }
};
CreateApplicationNode("default", "application", properties);
var expected = ServiceTopology.Build(new List <Uri> {
new Uri("https://github.com/vostok")
}, properties);
ShouldReturnImmediately(storage, "default", "application", expected);
Ensemble.Stop();
ShouldReturnImmediately(storage, "default", "application", expected);
Ensemble.Start();
ShouldReturnImmediately(storage, "default", "application", expected);
}
}
public void Should_track_application_properties()
{
CreateEnvironmentNode("default");
CreateApplicationNode("default", "application");
CreateReplicaNode(new ReplicaInfo("default", "application", "https://github.com/vostok"));
using (var storage = GetApplicationsStorage())
{
for (var times = 0; times < 10; times++)
{
var properties = new Dictionary <string, string>
{
{ "key", $"value_{times}" }
};
CreateApplicationNode("default", "application", properties);
var expected = ServiceTopology.Build(new List <Uri> {
new Uri("https://github.com/vostok")
}, properties);
if (times == 0)
{
ShouldReturnImmediately(storage, "default", "application", expected);
}
else
{
ShouldReturn(storage, "default", "application", expected);
}
}
}
}
public void Should_never_forget_replicas()
{
topology = ServiceTopology.Build(new[] { replica1 }, null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1 }.Cast <object>());
topology = ServiceTopology.Build(new List <Uri>(), null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1 }.Cast <object>());
topology = ServiceTopology.Build(new[] { replica2 }, null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1, replica2 }.Cast <object>());
topology = ServiceTopology.Build(new[] { replica1, replica2 }, null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1, replica2 }.Cast <object>());
topology = ServiceTopology.Build(new List <Uri>(), null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1, replica2 }.Cast <object>());
topology = ServiceTopology.Build(new[] { replica1, replica2, replica3 }, null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1, replica2, replica3 }.Cast <object>());
topology = ServiceTopology.Build(new[] { replica3 }, null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1, replica2, replica3 }.Cast <object>());
topology = ServiceTopology.Build(new List <Uri>(), null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1, replica2, replica3 }.Cast <object>());
}
private void UpdateServiceTopology()
{
lock (updateServiceTopologySync)
{
ServiceTopology = ServiceTopology.Build(replicasContainer.Value, applicationContainer.Value?.Properties);
}
}
public void UpdateAll_should_force_update()
{
CreateEnvironmentNode("default");
CreateApplicationNode("default", "application");
using (var storage = GetApplicationsStorage())
{
var expectedReplicas = new List <Uri>();
for (var times = 0; times < 10; times++)
{
var properties = new Dictionary <string, string>
{
{ "key", $"value_{times}" }
};
CreateApplicationNode("default", "application", properties);
CreateReplicaNode(new ReplicaInfo("default", "application", $"https://github.com/vostok/{times}"));
expectedReplicas.Add(new Uri($"https://github.com/vostok/{times}"));
storage.UpdateAll();
var expected = ServiceTopology.Build(expectedReplicas, properties);
ShouldReturnImmediately(storage, "default", "application", expected);
}
}
}
public void Should_return_new_replicas_from_new_topology()
{
topology = ServiceTopology.Build(new[] { replica1, replica2 }, null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1, replica2 }.Cast <object>());
topology = ServiceTopology.Build(new[] { replica2 }, null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica2 }.Cast <object>());
}
public void Build_should_not_return_null_with_replicas_without_properties()
{
var topology = ServiceTopology.Build(new List <Uri>(), new Dictionary <string, string>());
topology.Should().NotBeNull();
topology.Replicas.Should().BeEmpty();
topology.Properties.Should().BeEmpty();
}
public void Should_filter_some_replicas_when_they_has_no_tags()
{
var applicationInfo = new ApplicationInfo(environment, application, null);
topology = ServiceTopology.Build(replicas, applicationInfo.Properties.SetPersistentReplicaTags(replica1.ToString(), new TagCollection {
"tag1"
}));
filter.Filter(replicas, context).Should().BeEquivalentTo(replica1);
}
public void Should_correct_merge_fqdn_and_nofqdn_replicas_and_replace_by_the_last_one_it_saw()
{
var r1 = new Uri("http://razr02:80");
var r2 = new Uri("http://razr02.domain.whatever:80");
topology = ServiceTopology.Build(new[] { r1 }, null);
provider.GetCluster().Should().BeEquivalentTo(new[] { r1 }.Cast <object>());
topology = ServiceTopology.Build(new[] { r2 }, null);
provider.GetCluster().Should().BeEquivalentTo(new[] { r2 }.Cast <object>());
}
public void Should_return_last_seen_non_empty_replicas_set()
{
var aliveReplicas = new[] { replica1, replica2 };
topology = ServiceTopology.Build(aliveReplicas, null);
provider.GetCluster().Should().BeEquivalentTo(aliveReplicas.Cast <object>());
topology = ServiceTopology.Build(new List <Uri>(), null);
provider.GetCluster().Should().BeEquivalentTo(aliveReplicas.Cast <object>());
}
public void Should_return_last_seen_non_empty_replicas_set_and_aply_new_blacklist_that_was_added_after_moment_of_caching()
{
var aliveReplicas = new[] { replica1, replica2 };
topology = ServiceTopology.Build(aliveReplicas, null);
provider.GetCluster().Should().BeEquivalentTo(aliveReplicas.Cast <object>());
topology = ServiceTopology.Build(new List <Uri>(), CreateApplicationInfoPropertiesWithBlackList(new[] { replica1 }));
provider.GetCluster().Should().BeEquivalentTo(new[] { replica2 }.Cast <object>());
}
public void Should_filter_all_blacklisted_replicas()
{
blacklist = new[] { replica2, replica1 };
var applicationInfo = new ApplicationInfo(environment, application, null);
topology = ServiceTopology.Build(
new[] { replica1, replica2 },
applicationInfo.Properties.SetBlacklist(blacklist));
provider.GetCluster().Should().BeEmpty();
}
public void Should_return_null_without_application()
{
CreateEnvironmentNode("default");
using (var storage = GetApplicationsStorage())
{
ShouldReturnImmediately(storage, "default", "application", null);
CreateApplicationNode("default", "application");
ShouldReturn(storage, "default", "application", ServiceTopology.Build(new Uri[0], null));
}
}
public void Should_return_empty_list_without_replicas()
{
CreateEnvironmentNode("default");
CreateApplicationNode("default", "application");
using (var storage = GetApplicationsStorage())
{
ShouldReturnImmediately(storage, "default", "application", ServiceTopology.Build(new Uri[0], null));
CreateReplicaNode(new ReplicaInfo("default", "application", "https://github.com/vostok"));
var expected = ServiceTopology.Build(new[] { new Uri("https://github.com/vostok") }, null);
ShouldReturn(storage, "default", "application", expected);
}
}
public void Build_should_fill_replicas_and_properties()
{
var replicas = new List <Uri> {
new Uri("http://x.ru"), new Uri("http://y.ru")
};
var properties = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
};
var topology = ServiceTopology.Build(replicas, properties);
topology.Should().NotBeNull();
topology.Replicas.Should().BeEquivalentTo(replicas);
topology.Properties.Should().BeEquivalentTo(properties);
}
public void Should_override_replicaMatchesFunc_from_constructor_when_defined_in_request()
{
var applicationInfo = new ApplicationInfo(environment, application, null);
topology = ServiceTopology.Build(replicas, applicationInfo.Properties.SetPersistentReplicaTags(replica1.ToString(), new TagCollection {
"tag1"
}));
var filter1 = new ServiceDiscoveryReplicasFilter(serviceLocator, environment, application, log, collection => collection.ContainsKey("tag1"));
var context1 = new FakeContext(new RequestParameters());
filter1.Filter(replicas, context1).Should().BeEquivalentTo(replica1);
var context2 = new FakeContext(new RequestParameters().SetTagsFilter(collection => collection.ContainsKey("tag2")));
filter1.Filter(replicas, context2).Should().BeEmpty();
}
public void SetUp()
{
environment = "environment";
application = "application";
replicas = new List <Uri> {
replica1, replica2
};
topology = ServiceTopology.Build(replicas, null);
serviceLocator = Substitute.For <IServiceLocator>();
serviceLocator.Locate(environment, application).Returns(_ => topology);
filter = new ServiceDiscoveryReplicasFilter(serviceLocator, environment, application, log);
context = new FakeContext(new RequestParameters().SetTagsFilter(collection => collection.ContainsKey("tag1")));
}
public void Should_filter_blacklisted_replicas_with_FQDN()
{
var r1 = new Uri("http://razr01:80");
var r2 = new Uri("http://razr02:80");
var r3 = new Uri("http://razr03:80");
var r4 = new Uri("http://razr02.domain.whatever:80");
blacklist = new[] { r4 };
var applicationInfo = new ApplicationInfo(environment, application, null);
topology = ServiceTopology.Build(
new[] { r1, r2, r3, r4 },
applicationInfo.Properties.SetBlacklist(blacklist));
provider.GetCluster().Should().Equal(r1, r3);
}
public void Should_apply_bl_only_after_restoring_all_replicas()
{
topology = ServiceTopology.Build(new[] { replica1 }, CreateApplicationInfoPropertiesWithBlackList(new[] { replica1 }));
provider.GetCluster().Should().BeEmpty();
topology = ServiceTopology.Build(new List <Uri>(), null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1 }.Cast <object>());
topology = ServiceTopology.Build(new[] { replica2 }, CreateApplicationInfoPropertiesWithBlackList(new[] { replica1 }));
provider.GetCluster().Should().BeEquivalentTo(new[] { replica2 }.Cast <object>());
topology = ServiceTopology.Build(new[] { replica1, replica2 }, null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1, replica2 }.Cast <object>());
topology = ServiceTopology.Build(new List <Uri>(), CreateApplicationInfoPropertiesWithBlackList(new[] { replica1, replica2 }));
provider.GetCluster().Should().BeEmpty();
topology = ServiceTopology.Build(new List <Uri>(), null);
provider.GetCluster().Should().BeEquivalentTo(new[] { replica1, replica2 }.Cast <object>());
}
public void Should_filter_replicas_with_FQDN()
{
var replica1Fqdn = new Uri("http://replica1.domain.my:123/v1/");
var replica2Fqdn = new Uri("http://replica2.domain.my:456/v2/");
var applicationInfo = new ApplicationInfo(environment, application, null);
topology = ServiceTopology.Build(
new [] { replica1, replica2Fqdn, replica3 },
applicationInfo.Properties
.SetPersistentReplicaTags(replica1.ToString(), new TagCollection {
"tag1"
})
.SetPersistentReplicaTags(replica2Fqdn.ToString(), new TagCollection {
"tag1"
}));
filter.Filter(new List <Uri> {
replica1Fqdn, replica2, replica3
}, context).Should().BeEquivalentTo(replica1Fqdn, replica2);
}
public void Should_filter_some_replicas_when_they_has_no_tags_and_filter_was_set_in_constructor()
{
var applicationInfo = new ApplicationInfo(environment, application, null);
topology = ServiceTopology.Build(replicas, applicationInfo.Properties.SetPersistentReplicaTags(replica1.ToString(), new TagCollection {
"tag1"
}));
var filter1 = new ServiceDiscoveryReplicasFilter(serviceLocator, environment, application, log, collection => collection.ContainsKey("tag1"));
var newContext = new FakeContext(new RequestParameters());
filter1.Filter(replicas, newContext).Should().BeEquivalentTo(replica1);
var filter2 = new ServiceDiscoveryReplicasFilter(serviceLocator, environment, application, log, new ContainsTagFilter("tag1"));
filter2.Filter(replicas, newContext).Should().BeEquivalentTo(replica1);
var filter3 = new ServiceDiscoveryReplicasFilter(serviceLocator, environment, application, log, TagFilterExpressionHelpers.Parse("tag1"));
filter3.Filter(replicas, newContext).Should().BeEquivalentTo(replica1);
}
public void Should_store_multiple_environments_and_applications()
{
CreateEnvironmentNode("environment1");
CreateApplicationNode("environment1", "application1", new Dictionary <string, string> {
{ "key", "1/1" }
});
CreateEnvironmentNode("environment2");
CreateApplicationNode("environment2", "application1", new Dictionary <string, string> {
{ "key", "2/1" }
});
CreateApplicationNode("environment2", "application2", new Dictionary <string, string> {
{ "key", "2/2" }
});
using (var storage = GetApplicationsStorage())
{
ShouldReturnImmediately(
storage,
"environment1",
"application1",
ServiceTopology.Build(new Uri[0], new Dictionary <string, string> {
{ "key", "1/1" }
}));
ShouldReturnImmediately(
storage,
"environment2",
"application1",
ServiceTopology.Build(new Uri[0], new Dictionary <string, string> {
{ "key", "2/1" }
}));
ShouldReturnImmediately(
storage,
"environment2",
"application2",
ServiceTopology.Build(new Uri[0], new Dictionary <string, string> {
{ "key", "2/2" }
}));
}
}
public void Should_filter_replicas_that_does_not_exists_in_given_replicas()
{
var applicationInfo = new ApplicationInfo(environment, application, null);
topology = ServiceTopology.Build(
new [] { replica1, replica2, replica3 },
applicationInfo.Properties
.SetPersistentReplicaTags(replica1.ToString(), new TagCollection {
"tag1"
})
.SetPersistentReplicaTags(replica2.ToString(), new TagCollection {
"tag1"
})
.SetPersistentReplicaTags(replica3.ToString(), new TagCollection {
"tag1"
}));
filter.Filter(new List <Uri> {
replica1, replica2
}, context).Should().BeEquivalentTo(replica1, replica2);
}
public void Should_not_update_to_invalid_application_properties()
{
CreateEnvironmentNode("default");
CreateApplicationNode("default", "application", new Dictionary <string, string> {
{ "key", "value" }
});
CreateReplicaNode(new ReplicaInfo("default", "application", "https://github.com/vostok"));
using (var storage = GetApplicationsStorage())
{
var expected = ServiceTopology.Build(new List <Uri> {
new Uri("https://github.com/vostok")
}, new Dictionary <string, string> {
{ "key", "value" }
});
ShouldReturnImmediately(storage, "default", "application", expected);
ZooKeeperClient.SetData(PathHelper.BuildApplicationPath("default", "application"), new byte[] { 1, 2, 3 });
storage.UpdateAll();
ShouldReturnImmediately(storage, "default", "application", expected);
}
}
public void Should_ignore_duplicate_replica_name_in_service_tags()
{
var replicaNoFqdn = new Uri("http://replica1:123/v1/");
var replicaFqdn = new Uri("http://replica1.domain.my:123/v1/");
var applicationInfo = new ApplicationInfo(environment, application, null);
topology = ServiceTopology.Build(
new [] { replicaFqdn },
applicationInfo.Properties
.SetPersistentReplicaTags(replicaNoFqdn.ToString(), new TagCollection {
"tag2"
})
.SetPersistentReplicaTags(replicaFqdn.ToString(), new TagCollection {
"tag1"
}));
filter.Filter(new List <Uri> {
replicaFqdn
}, context).Should().BeEquivalentTo(replicaFqdn);
filter.Filter(new List <Uri> {
replicaNoFqdn
}, context).Should().BeEquivalentTo(replicaNoFqdn);
}
public void Should_return_empty_list_for_empty_replicas()
{
topology = ServiceTopology.Build(new List <Uri>(), null);
provider.GetCluster().Should().BeEmpty();
}
public void Build_should_return_null_without_replicas()
{
ServiceTopology.Build(null, null).Should().BeNull();
}
