public EndpointRegistryTests()
{
_monitorRegistry = new Mock <IHealthMonitorRegistry>();
_configurationStore = new Mock <IEndpointConfigurationStore>();
_statsRepository = new Mock <IEndpointStatsRepository>();
_registry = new EndpointRegistry(_monitorRegistry.Object, _configurationStore.Object, _statsRepository.Object);
}
public void RegisterEndpoint(IRabbitListenerEndpoint endpoint, IRabbitListenerContainerFactory factory)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (string.IsNullOrEmpty(endpoint.Id))
{
throw new InvalidOperationException("Endpoint id must be set");
}
if (StartImmediately && EndpointRegistry == null)
{
throw new InvalidOperationException("No registry available");
}
// Factory may be null, we defer the resolution right before actually creating the container
var descriptor = new AmqpListenerEndpointDescriptor(endpoint, factory);
lock (_endpointDescriptors)
{
if (StartImmediately)
{ // Register and start immediately
EndpointRegistry.RegisterListenerContainer(descriptor.Endpoint, ResolveContainerFactory(descriptor), true);
}
else
{
_endpointDescriptors.Add(descriptor);
}
}
}
public EndpointRegistryTests()
{
_monitorRegistry = new Mock<IHealthMonitorRegistry>();
_configurationStore = new Mock<IEndpointConfigurationStore>();
_statsRepository=new Mock<IEndpointStatsRepository>();
_registry = new EndpointRegistry(_monitorRegistry.Object, _configurationStore.Object,_statsRepository.Object);
}
public void EndpointRegistry_should_keep_refuseUid_after_register_new_Endpoint()
{
var reg = new EndpointRegistry();
var deadline = Deadline.Now + TimeSpan.FromMinutes(30);
reg.RegisterWritableEndpoint(address1, actorA, null);
reg.MarkAsQuarantined(address1, 42, deadline);
reg.RefuseUid(address1).Should().Be(42);
reg.IsQuarantined(address1, 42).Should().BeTrue();
reg.UnregisterEndpoint(actorA);
// Quarantined marker is kept so far
var policy = reg.WritableEndpointWithPolicyFor(address1);
policy.Should().BeOfType <EndpointManager.Quarantined>();
policy.AsInstanceOf <EndpointManager.Quarantined>().Uid.Should().Be(42);
policy.AsInstanceOf <EndpointManager.Quarantined>().Deadline.Should().Be(deadline);
reg.RefuseUid(address1).Should().Be(42);
reg.IsQuarantined(address1, 42).Should().BeTrue();
reg.RegisterWritableEndpoint(address1, actorB, null);
// Quarantined marker is gone
var policy2 = reg.WritableEndpointWithPolicyFor(address1);
policy2.Should().BeOfType <EndpointManager.Pass>();
policy2.AsInstanceOf <EndpointManager.Pass>().Endpoint.Should().Be(actorB);
// but we still have the refuseUid
reg.RefuseUid(address1).Should().Be(42);
reg.IsQuarantined(address1, 42).Should().BeTrue();
}
public DiagramApiController(IProvideBreakdown[] breakdownProviders, EndpointRegistry endpointRegistry, EndpointInstanceActivityTracker activityTracker, MessageTypeRegistry messageTypeRegistry)
{
this.breakdownProviders = breakdownProviders;
this.endpointRegistry = endpointRegistry;
this.activityTracker = activityTracker;
this.messageTypeRegistry = messageTypeRegistry;
}
public void MetricAggregationByInstanceIsScopedToLogicalEndpoint()
{
var processingTimeStore = new ProcessingTimeStore();
var endpointRegistry = new EndpointRegistry();
var apiController = CreateConroller(processingTimeStore, endpointRegistry);
var instanceAId = new EndpointInstanceId("EndpointA", "instance");
var instanceBId = new EndpointInstanceId("EndpointB", "instance");
endpointRegistry.Record(instanceAId);
endpointRegistry.Record(instanceBId);
var period = HistoryPeriod.FromMinutes(DiagramApiController.DefaultHistory);
var now = DateTime.UtcNow.Subtract(new TimeSpan(period.IntervalSize.Ticks * period.DelayedIntervals));
var dataA = new RawMessage.Entry {
DateTicks = now.Ticks, Value = 5
};
var dataB = new RawMessage.Entry {
DateTicks = now.Ticks, Value = 10
};
processingTimeStore.Store(new[] { dataA }, instanceAId, EndpointMessageType.Unknown(instanceAId.EndpointName));
processingTimeStore.Store(new[] { dataB }, instanceBId, EndpointMessageType.Unknown(instanceBId.EndpointName));
var result = apiController.GetSingleEndpointMetrics(instanceAId.EndpointName);
var contentResult = result as OkNegotiatedContentResult <MonitoredEndpointDetails>;
var model = contentResult.Content;
Assert.AreEqual(5, model.Instances[0].Metrics["ProcessingTime"].Average);
}
public new void Setup()
{
endpointRegistry = new EndpointRegistry();
criticalTimeStore = new CriticalTimeStore();
processingTimeStore = new ProcessingTimeStore();
retriesStore = new RetriesStore();
queueLengthProvider = new FakeQueueLengthProvider();
queueLengthStore = new QueueLengthStore();
queueLengthProvider.Initialize(string.Empty, (entryDtos, dto) => queueLengthStore.Store(entryDtos.Select(e => ToEntry(e)).ToArray(), ToEndpointInputQueue(dto)));
var settings = new Settings {
EndpointUptimeGracePeriod = TimeSpan.FromMinutes(5)
};
activityTracker = new EndpointInstanceActivityTracker(settings);
messageTypeRegistry = new MessageTypeRegistry();
var breakdownProviders = new IProvideBreakdown[]
{
criticalTimeStore,
processingTimeStore,
retriesStore,
queueLengthStore
};
var controller = new DiagramApiController(breakdownProviders, endpointRegistry, activityTracker, messageTypeRegistry)
{
Request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/monitored-endpoint")
};
GetMonitoredEndpoints = () => controller.GetAllEndpointsMetrics();
GetMonitoredSingleEndpoint = endpointName => controller.GetSingleEndpointMetrics(endpointName);
}
public EndpointRegistryTests()
{
_healthMonitorTypeRegistry = new Mock <IHealthMonitorTypeRegistry>();
_configurationStore = new Mock <IEndpointConfigurationRepository>();
_statsRepository = new Mock <IEndpointStatsRepository>();
_registry = new EndpointRegistry(_healthMonitorTypeRegistry.Object, _configurationStore.Object, _statsRepository.Object, _statsManager.Object, _timeCoordinator.Object);
}
public void EndpointRegistry_must_remove_readonly_endpoints_if_marked_as_failed()
{
var reg = new EndpointRegistry();
reg.RegisterReadOnlyEndpoint(address1, actorA);
reg.MarkAsFailed(actorA, Deadline.Now);
Assert.Null(reg.ReadOnlyEndpointFor(address1));
}
public void EndpointRegistry_should_load_endpoints_from_store()
{
var endpoint = new Endpoint(Guid.NewGuid(), MonitorMock.Mock("monitor"), "address", "name", "group");
_configurationStore.Setup(s => s.LoadEndpoints(_monitorRegistry.Object)).Returns(new[] { endpoint });
var registry = new EndpointRegistry(_monitorRegistry.Object, _configurationStore.Object,_statsRepository.Object);
Assert.Same(endpoint, registry.GetById(endpoint.Id));
}
public void EndpointRegistry_should_load_endpoints_from_repository()
{
var endpoint = new Endpoint(_timeCoordinator.Object, new EndpointIdentity(Guid.NewGuid(), "monitor", "address"), new EndpointMetadata("name", "group", new[] { "t1", "t2" }, EndpointMetadata.DefaultMonitorTag, DateTime.UtcNow, DateTime.UtcNow));
_configurationStore.Setup(s => s.LoadEndpoints()).Returns(new[] { endpoint });
var registry = new EndpointRegistry(_healthMonitorTypeRegistry.Object, _configurationStore.Object, _statsManager.Object, _timeCoordinator.Object);
Assert.Same(endpoint, registry.GetById(endpoint.Identity.Id));
}
public void EndpointRegistry_should_load_endpoints_from_repository()
{
var endpoint = new Endpoint(_timeCoordinator.Object, new EndpointIdentity(Guid.NewGuid(), "monitor", "address"), new EndpointMetadata("name", "group", new[] { "t1", "t2" }, EndpointMetadata.DefaultMonitorTag, DateTime.UtcNow, DateTime.UtcNow));
_configurationStore.Setup(s => s.LoadEndpoints()).Returns(new[] { endpoint });
var registry = new EndpointRegistry(_healthMonitorTypeRegistry.Object, _configurationStore.Object, _statsManager.Object, _timeCoordinator.Object);
Assert.Same(endpoint, registry.GetById(endpoint.Identity.Id));
}
public void EndpointRegistry_should_load_endpoints_from_store()
{
var endpoint = new Endpoint(Guid.NewGuid(), MonitorMock.Mock("monitor"), "address", "name", "group");
_configurationStore.Setup(s => s.LoadEndpoints(_monitorRegistry.Object)).Returns(new[] { endpoint });
var registry = new EndpointRegistry(_monitorRegistry.Object, _configurationStore.Object, _statsRepository.Object);
Assert.Same(endpoint, registry.GetById(endpoint.Id));
}
static MonitoredEndpointInstance[] GetMonitoredEndpointInstances(EndpointRegistry endpointRegistry, string endpointName, EndpointInstanceActivityTracker activityTracker)
{
return(endpointRegistry.GetForEndpointName(endpointName)
.Select(endpointInstance => new MonitoredEndpointInstance
{
Id = endpointInstance.InstanceId,
Name = endpointInstance.InstanceName,
IsStale = activityTracker.IsStale(endpointInstance)
}).ToArray());
}
public void EndpointRegistry_must_be_able_to_register_Gated_policy_for_an_address()
{
var reg = new EndpointRegistry();
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
reg.RegisterWritableEndpoint(address1, actorA);
var deadline = Deadline.Now;
reg.MarkAsFailed(actorA, deadline);
Assert.Equal(deadline, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf<EndpointManager.Gated>().TimeOfRelease);
Assert.False(reg.IsReadOnly(actorA));
Assert.False(reg.IsWritable(actorA));
}
static MonitoredEndpoint[] GetMonitoredEndpoints(EndpointRegistry endpointRegistry, EndpointInstanceActivityTracker activityTracker)
{
return(endpointRegistry.GetGroupedByEndpointName()
.Select(endpoint => new MonitoredEndpoint
{
Name = endpoint.Key,
EndpointInstanceIds = endpoint.Value.Select(i => i.InstanceId).ToArray(),
IsStale = endpoint.Value.Any(activityTracker.IsStale)
})
.ToArray());
}
public void EndpointRegistry_must_be_able_to_register_a_readonly_endpoint()
{
var reg = new EndpointRegistry();
Assert.Null(reg.ReadOnlyEndpointFor(address1));
Assert.Equal(actorA, reg.RegisterReadOnlyEndpoint(address1, actorA));
Assert.Equal(actorA, reg.ReadOnlyEndpointFor(address1));
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
Assert.False(reg.IsWritable(actorA));
Assert.True(reg.IsReadOnly(actorA));
Assert.False(reg.IsQuarantined(address1, 42));
}
public void EndpointRegistry_should_be_able_to_register_Quarantined_policy_for_an_address()
{
var reg = new EndpointRegistry();
var deadline = Deadline.Now + TimeSpan.FromMinutes(30);
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
reg.MarkAsQuarantined(address1, 42, deadline);
Assert.True(reg.IsQuarantined(address1, 42));
Assert.False(reg.IsQuarantined(address1, 33));
Assert.Equal(42, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf <EndpointManager.Quarantined>().Uid);
Assert.Equal(deadline, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf <EndpointManager.Quarantined>().Deadline);
}
public void Fix_1845_EndpointRegistry_should_override_ReadOnly_endpoint()
{
var reg = new EndpointRegistry();
var endpoint = TestActor;
reg.RegisterReadOnlyEndpoint(address1, endpoint, 1);
reg.RegisterReadOnlyEndpoint(address1, endpoint, 2);
var ep = reg.ReadOnlyEndpointFor(address1);
ep.Item1.ShouldBe(endpoint);
ep.Item2.ShouldBe(2);
}
public void EndpointRegistry_must_be_able_to_register_Gated_policy_for_an_address()
{
var reg = new EndpointRegistry();
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
reg.RegisterWritableEndpoint(address1, actorA);
var deadline = Deadline.Now;
reg.MarkAsFailed(actorA, deadline);
Assert.Equal(deadline, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf <EndpointManager.Gated>().TimeOfRelease);
Assert.False(reg.IsReadOnly(actorA));
Assert.False(reg.IsWritable(actorA));
}
public void EndpointRegistry_must_be_able_to_register_a_readonly_endpoint()
{
var reg = new EndpointRegistry();
Assert.Null(reg.ReadOnlyEndpointFor(address1));
Assert.Equal(actorA, reg.RegisterReadOnlyEndpoint(address1, actorA));
Assert.Equal(actorA, reg.ReadOnlyEndpointFor(address1));
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
Assert.False(reg.IsWritable(actorA));
Assert.True(reg.IsReadOnly(actorA));
Assert.False(reg.IsQuarantined(address1, 42));
}
public void EndpointRegistry_should_prune_outdated_Gated_directives_properly()
{
var reg = new EndpointRegistry();
reg.RegisterWritableEndpoint(address1, actorA, null);
reg.RegisterWritableEndpoint(address2, actorB, null);
reg.MarkAsFailed(actorA, Deadline.Now);
var farIntheFuture = Deadline.Now + TimeSpan.FromSeconds(60);
reg.MarkAsFailed(actorB, farIntheFuture);
reg.Prune();
Assert.Equal(farIntheFuture, reg.WritableEndpointWithPolicyFor(address2).AsInstanceOf <EndpointManager.Gated>().TimeOfRelease);
}
public void When_known_endpoint_instance_changes_name_existing_entry_is_used_and_udpated()
{
var registry = new EndpointRegistry();
var originalId = new EndpointInstanceId("LogicalName", "instance-id", "original-name");
var renamedId = new EndpointInstanceId(originalId.EndpointName, originalId.InstanceId, "renamed-name");
registry.Record(originalId);
registry.Record(renamedId);
var records = registry.GetForEndpointName(originalId.EndpointName).ToArray();
Assert.AreEqual(1, records.Length, "Existing entry should be reused");
Assert.AreEqual("renamed-name", records[0].InstanceName);
}
public void EndpointRegistry_should_overwrite_Quarantine_policy_with_Pass_on_RegisterWritableEndpoint()
{
var reg = new EndpointRegistry();
var deadline = Deadline.Now + TimeSpan.FromMinutes(30);
var quarantinedUid = 42;
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
reg.MarkAsQuarantined(address1, quarantinedUid, deadline);
Assert.True(reg.IsQuarantined(address1, quarantinedUid));
var writableUid = 43;
reg.RegisterWritableEndpoint(address1, TestActor, writableUid);
Assert.True(reg.IsWritable(TestActor));
}
public void EndpointRegistry_should_not_report_endpoint_as_writable_if_no_Pass_policy()
{
var reg = new EndpointRegistry();
var deadline = Deadline.Now + TimeSpan.FromMinutes(30);
Assert.False(reg.IsWritable(TestActor)); // no policy
reg.RegisterWritableEndpoint(address1, TestActor, 42);
Assert.True(reg.IsWritable(TestActor)); // pass
reg.MarkAsFailed(TestActor, deadline);
Assert.False(reg.IsWritable(TestActor)); // Gated
reg.RegisterWritableEndpoint(address1, TestActor, 43); // restarted
Assert.True(reg.IsWritable(TestActor)); // pass
reg.MarkAsQuarantined(address1, 43, deadline);
Assert.False(reg.HasWritableEndpointFor(address1)); // Quarantined
}
public void EndpointRegistry_must_be_able_to_register_a_writeable_endpoint_and_policy()
{
var reg = new EndpointRegistry();
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
Assert.Equal(actorA, reg.RegisterWritableEndpoint(address1, actorA));
Assert.IsType<EndpointManager.Pass>(reg.WritableEndpointWithPolicyFor(address1));
Assert.Equal(actorA, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf<EndpointManager.Pass>().Endpoint);
Assert.Null(reg.ReadOnlyEndpointFor(address1));
Assert.True(reg.IsWritable(actorA));
Assert.False(reg.IsReadOnly(actorA));
Assert.False(reg.IsQuarantined(address1, 42));
}
public void EndpointRegistry_must_be_able_to_register_a_writeable_endpoint_and_policy()
{
var reg = new EndpointRegistry();
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
Assert.Equal(actorA, reg.RegisterWritableEndpoint(address1, actorA));
Assert.IsType <EndpointManager.Pass>(reg.WritableEndpointWithPolicyFor(address1));
Assert.Equal(actorA, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf <EndpointManager.Pass>().Endpoint);
Assert.Null(reg.ReadOnlyEndpointFor(address1));
Assert.True(reg.IsWritable(actorA));
Assert.False(reg.IsReadOnly(actorA));
Assert.False(reg.IsQuarantined(address1, 42));
}
protected void RegisterAllEndpoints()
{
if (EndpointRegistry == null)
{
throw new InvalidOperationException("No registry available");
}
lock (_endpointDescriptors)
{
foreach (var descriptor in _endpointDescriptors)
{
EndpointRegistry.RegisterListenerContainer(descriptor.Endpoint, ResolveContainerFactory(descriptor));
}
StartImmediately = true; // trigger immediate startup
}
}
public void EndpointRegistry_should_overwrite_Gated_policy_with_Pass_on_RegisterWritableEndpoint()
{
var reg = new EndpointRegistry();
var deadline = Deadline.Now + TimeSpan.FromMinutes(30);
var willBeGated = 42;
reg.RegisterWritableEndpoint(address1, TestActor, willBeGated);
Assert.NotNull(reg.WritableEndpointWithPolicyFor(address1));
Assert.True(reg.IsWritable(TestActor));
reg.MarkAsFailed(TestActor, deadline);
Assert.False(reg.IsWritable(TestActor));
var writableUid = 43;
reg.RegisterWritableEndpoint(address1, TestActor, writableUid);
Assert.True(reg.IsWritable(TestActor));
}
public void EndpointRegistry_must_be_able_to_register_writable_and_readonly_endpoint_correctly()
{
var reg = new EndpointRegistry();
Assert.Null(reg.ReadOnlyEndpointFor(address1));
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
Assert.Equal(actorA, reg.RegisterReadOnlyEndpoint(address1, actorA));
Assert.Equal(actorB, reg.RegisterWritableEndpoint(address1, actorB));
Assert.Equal(actorA, reg.ReadOnlyEndpointFor(address1));
Assert.Equal(actorB, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf<EndpointManager.Pass>().Endpoint);
Assert.False(reg.IsWritable(actorA));
Assert.True(reg.IsWritable(actorB));
Assert.True(reg.IsReadOnly(actorA));
Assert.False(reg.IsReadOnly(actorB));
}
public void EndpointRegistry_must_keep_tombstones_when_removing_an_endpoint()
{
var reg = new EndpointRegistry();
reg.RegisterWritableEndpoint(address1, actorA);
reg.RegisterWritableEndpoint(address2, actorB);
var deadline = Deadline.Now;
reg.MarkAsFailed(actorA, deadline);
reg.MarkAsQuarantined(address2, 42, deadline);
reg.UnregisterEndpoint(actorA);
reg.UnregisterEndpoint(actorB);
Assert.Equal(deadline, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf <EndpointManager.Gated>().TimeOfRelease);
Assert.Equal(deadline, reg.WritableEndpointWithPolicyFor(address2).AsInstanceOf <EndpointManager.Quarantined>().Deadline);
Assert.Equal(42, reg.WritableEndpointWithPolicyFor(address2).AsInstanceOf <EndpointManager.Quarantined>().Uid);
}
public void EndpointRegistry_must_be_able_to_register_writable_and_readonly_endpoint_correctly()
{
var reg = new EndpointRegistry();
Assert.Null(reg.ReadOnlyEndpointFor(address1));
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
Assert.Equal(actorA, reg.RegisterReadOnlyEndpoint(address1, actorA));
Assert.Equal(actorB, reg.RegisterWritableEndpoint(address1, actorB));
Assert.Equal(actorA, reg.ReadOnlyEndpointFor(address1));
Assert.Equal(actorB, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf <EndpointManager.Pass>().Endpoint);
Assert.False(reg.IsWritable(actorA));
Assert.True(reg.IsWritable(actorB));
Assert.True(reg.IsReadOnly(actorA));
Assert.False(reg.IsReadOnly(actorB));
}
public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
{
IPrincipal principal = null;
GenericIdentity identity;
var credentials = context.ParseAuthorizationHeader();
var adminCred = CredentialsProvider.GetAdminCredentials();
var pullCred = CredentialsProvider.GetMonitorCredentials();
if (credentials == null)
{
return(Task.FromResult(0));
}
if (credentials.Equals(adminCred))
{
identity = new GenericIdentity(credentials.Id.ToString());
principal = new GenericPrincipal(identity, new[] { SecurityRole.Admin.ToString() });
}
else if (credentials.Equals(pullCred))
{
identity = new GenericIdentity(pullCred.Id.ToString());
principal = new GenericPrincipal(identity, new[] { SecurityRole.Monitor.ToString() });
}
else
{
string encryptedPassword = credentials.Password.ToSha256Hash();
var endpoint = EndpointRegistry.GetById(credentials.Id);
if (endpoint?.Password == encryptedPassword)
{
context.Request.Properties[_passwordKey] = encryptedPassword;
identity = new GenericIdentity(credentials.Id.ToString());
principal = new GenericPrincipal(identity, null);
}
}
context.Principal = principal;
return(Task.FromResult(0));
}
public void Setup()
{
endpointRegistry = new EndpointRegistry();
criticalTimeStore = new CriticalTimeStore();
processingTimeStore = new ProcessingTimeStore();
retriesStore = new RetriesStore();
queueLengthProvider = new DefaultQueueLengthProvider();
queueLengthStore = new QueueLengthStore();
queueLengthProvider.Initialize(string.Empty, queueLengthStore);
var settings = new Settings {
EndpointUptimeGracePeriod = TimeSpan.FromMinutes(5)
};
activityTracker = new EndpointInstanceActivityTracker(settings);
messageTypeRegistry = new MessageTypeRegistry();
var breakdownProviders = new IProvideBreakdown[]
{
criticalTimeStore,
processingTimeStore,
retriesStore,
queueLengthStore
};
var monitoredEndpointsModule = new MonitoredEndpointsModule(breakdownProviders, endpointRegistry, activityTracker, messageTypeRegistry)
{
Context = new NancyContext()
{
Request = new Request("Get", "/monitored-endpoints", "HTTP")
}
};
var dictionary = monitoredEndpointsModule.Routes.ToDictionary(r => r.Description.Path, r => r.Action);
GetMonitoredEndpoints = () => dictionary["/monitored-endpoints"](new object(), new CancellationToken(false));
GetMonitoredSingleEndpoint = endpointName => dictionary["/monitored-endpoints/{endpointName}"](new { EndpointName = endpointName }.ToDynamic(), new CancellationToken());
}
public void Setup()
{
settings = new Settings {
EndpointUptimeGracePeriod = TimeSpan.FromMinutes(5)
};
activityTracker = new EndpointInstanceActivityTracker(settings);
processingTimeStore = new ProcessingTimeStore();
endpointRegistry = new EndpointRegistry();
var messageTypeRegistry = new MessageTypeRegistry();
var breakdownProviders = new IProvideBreakdown[]
{
processingTimeStore,
new CriticalTimeStore(),
new RetriesStore(),
new QueueLengthStore()
};
apiController = new DiagramApiController(breakdownProviders, endpointRegistry, activityTracker, messageTypeRegistry)
{
Request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/monitored-endpoint")
};
}
public async Task MetricAggregationByInstanceIsScopedToLogicalEndpoint()
{
var processingTimeStore = new ProcessingTimeStore();
var endpointRegistry = new EndpointRegistry();
var queryAction = CreateQuery(processingTimeStore, endpointRegistry);
var instanceAId = new EndpointInstanceId("EndpointA", "instance");
var instanceBId = new EndpointInstanceId("EndpointB", "instance");
endpointRegistry.Record(instanceAId);
endpointRegistry.Record(instanceBId);
var period = HistoryPeriod.FromMinutes(MonitoredEndpointsModule.DefaultHistory);
var now = DateTime.UtcNow.Subtract(new TimeSpan(period.IntervalSize.Ticks * period.DelayedIntervals));
var dataA = new RawMessage.Entry {
DateTicks = now.Ticks, Value = 5
};
var dataB = new RawMessage.Entry {
DateTicks = now.Ticks, Value = 10
};
processingTimeStore.Store(new[] { dataA }, instanceAId, EndpointMessageType.Unknown(instanceAId.EndpointName));
processingTimeStore.Store(new[] { dataB }, instanceBId, EndpointMessageType.Unknown(instanceBId.EndpointName));
var result = await queryAction(new
{
instanceAId.EndpointName
}.ToDynamic(), new CancellationToken());
var model = (MonitoredEndpointDetails)result.NegotiationContext.DefaultModel;
Assert.AreEqual(5, model.Instances[0].Metrics["ProcessingTime"].Average);
}
public void EndpointRegistry_should_overwrite_Gated_policy_with_Pass_on_RegisterWritableEndpoint()
{
var reg = new EndpointRegistry();
var deadline = Deadline.Now + TimeSpan.FromMinutes(30);
var willBeGated = 42;
reg.RegisterWritableEndpoint(address1, TestActor, willBeGated, null);
Assert.NotNull(reg.WritableEndpointWithPolicyFor(address1));
Assert.True(reg.IsWritable(TestActor));
reg.MarkAsFailed(TestActor, deadline);
Assert.False(reg.IsWritable(TestActor));
var writableUid = 43;
reg.RegisterWritableEndpoint(address1, TestActor, writableUid, willBeGated);
Assert.True(reg.IsWritable(TestActor));
}
public void EndpointRegistry_should_overwrite_Quarantine_policy_with_Pass_on_RegisterWritableEndpoint()
{
var reg = new EndpointRegistry();
var deadline = Deadline.Now + TimeSpan.FromMinutes(30);
var quarantinedUid = 42;
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
reg.MarkAsQuarantined(address1, quarantinedUid, deadline);
Assert.True(reg.IsQuarantined(address1, quarantinedUid));
var writableUid = 43;
reg.RegisterWritableEndpoint(address1, TestActor, writableUid, quarantinedUid);
Assert.True(reg.IsWritable(TestActor));
}
public void Fix_1845_EndpointRegistry_should_override_ReadOnly_endpoint()
{
var reg = new EndpointRegistry();
var endpoint = TestActor;
reg.RegisterReadOnlyEndpoint(address1, endpoint, 1);
reg.RegisterReadOnlyEndpoint(address1, endpoint, 2);
var ep = reg.ReadOnlyEndpointFor(address1);
ep.Item1.ShouldBe(endpoint);
ep.Item2.ShouldBe(2);
}
public EndpointRegistryTests()
{
_healthMonitorTypeRegistry = new Mock<IHealthMonitorTypeRegistry>();
_configurationStore = new Mock<IEndpointConfigurationRepository>();
_registry = new EndpointRegistry(_healthMonitorTypeRegistry.Object, _configurationStore.Object, _statsManager.Object, _timeCoordinator.Object);
}
void Initialize()
{
var endpointRegistry = new EndpointRegistry();
var handlerRegistry = new HandlerRegistry();
var messageTrees = CreateMessageTrees(messages).ToArray();
var messagesInOrder = messageTrees.SelectMany(x => x.Walk()).ToArray();
// NOTE: All sending endpoints are created first to ensure version info is retained
foreach (var message in messagesInOrder)
{
endpointRegistry.Register(CreateSendingEndpoint(message));
}
foreach (var message in messagesInOrder)
{
endpointRegistry.Register(CreateProcessingEndpoint(message));
}
foreach (var message in messagesInOrder)
{
var sendingEndpoint = endpointRegistry.Get(CreateSendingEndpoint(message));
if (!endpoints.Contains(sendingEndpoint))
{
endpoints.Add(sendingEndpoint);
}
var processingEndpoint = endpointRegistry.Get(CreateProcessingEndpoint(message));
if (!endpoints.Contains(processingEndpoint))
{
endpoints.Add(processingEndpoint);
}
Handler sendingHandler;
Handler processingHandler;
if (handlerRegistry.TryRegisterHandler(CreateSendingHandler(message, sendingEndpoint), out sendingHandler))
{
handlers.Add(sendingHandler);
sendingEndpoint.Handlers.Add(sendingHandler);
}
sendingHandler.UpdateProcessedAtGuess(message.TimeSent);
if (handlerRegistry.TryRegisterHandler(CreateProcessingHandler(message, processingEndpoint), out processingHandler))
{
handlers.Add(processingHandler);
processingEndpoint.Handlers.Add(processingHandler);
}
else
{
UpdateProcessingHandler(processingHandler, message, processingEndpoint);
}
var arrow = CreateArrow(message);
arrow.ToHandler = processingHandler;
arrow.FromHandler = sendingHandler;
var messageProcessingRoute = CreateRoute(arrow, processingHandler);
arrow.MessageProcessingRoute = messageProcessingRoute;
processingRoutes.Add(messageProcessingRoute);
processingHandler.In = arrow;
sendingHandler.Out = sendingHandler.Out.Concat(new[] { arrow }).OrderBy(a => a).ToList();
}
}
public HealthMonitorTests()
{
_testableHealthMonitor = new TestableHealthMonitor();
_endpointRegistry = new EndpointRegistry(new HealthMonitorRegistry(new[] { _testableHealthMonitor }), new Mock<IEndpointConfigurationStore>().Object);
}
static DiagramApiController CreateConroller(ProcessingTimeStore processingTimeStore, EndpointRegistry endpointRegistry)
{
var criticalTimeStore = new CriticalTimeStore();
var retriesStore = new RetriesStore();
var queueLengthStore = new QueueLengthStore();
var settings = new Settings
{
EndpointUptimeGracePeriod = TimeSpan.FromMinutes(5)
};
var activityTracker = new EndpointInstanceActivityTracker(settings);
var messageTypeRegistry = new MessageTypeRegistry();
var breakdownProviders = new IProvideBreakdown[]
{
processingTimeStore,
criticalTimeStore,
retriesStore,
queueLengthStore
};
var controller = new DiagramApiController(breakdownProviders, endpointRegistry, activityTracker, messageTypeRegistry)
{
Request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/monitored-endpoint")
};
return(controller);
}
public void EndpointRegistry_must_keep_tombstones_when_removing_an_endpoint()
{
var reg = new EndpointRegistry();
reg.RegisterWritableEndpoint(address1, actorA);
reg.RegisterWritableEndpoint(address2, actorB);
var deadline = Deadline.Now;
reg.MarkAsFailed(actorA, deadline);
reg.MarkAsQuarantined(address2, 42, deadline);
reg.UnregisterEndpoint(actorA);
reg.UnregisterEndpoint(actorB);
Assert.Equal(deadline, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf<EndpointManager.Gated>().TimeOfRelease);
Assert.Equal(deadline, reg.WritableEndpointWithPolicyFor(address2).AsInstanceOf<EndpointManager.Quarantined>().Deadline);
Assert.Equal(42, reg.WritableEndpointWithPolicyFor(address2).AsInstanceOf<EndpointManager.Quarantined>().Uid);
}
public void EndpointRegistry_must_remove_readonly_endpoints_if_marked_as_failed()
{
var reg = new EndpointRegistry();
reg.RegisterReadOnlyEndpoint(address1, actorA);
reg.MarkAsFailed(actorA, Deadline.Now);
Assert.Null(reg.ReadOnlyEndpointFor(address1));
}
public void EndpointRegister_should_not_report_endpoint_as_writeable_if_no_Pass_policy()
{
var reg = new EndpointRegistry();
var deadline = Deadline.Now + TimeSpan.FromMinutes(30);
Assert.False(reg.IsWritable(TestActor)); // no policy
reg.RegisterWritableEndpoint(address1, TestActor, 42, null);
Assert.True(reg.IsWritable(TestActor)); // pass
reg.MarkAsFailed(TestActor, deadline);
Assert.False(reg.IsWritable(TestActor)); // Gated
reg.RegisterWritableEndpoint(address1, TestActor, 43, 42); // restarted
Assert.True(reg.IsWritable(TestActor)); // pass
reg.MarkAsQuarantined(address1, 43, deadline);
Assert.False(reg.HasWriteableEndpointFor(address1)); // Quarantined
}
public void EndpointRegistry_should_prune_outdated_Gated_directives_properly()
{
var reg = new EndpointRegistry();
reg.RegisterWritableEndpoint(address1, actorA);
reg.RegisterWritableEndpoint(address2, actorB);
reg.MarkAsFailed(actorA, Deadline.Now);
var farIntheFuture = Deadline.Now + TimeSpan.FromSeconds(60);
reg.MarkAsFailed(actorB, farIntheFuture);
reg.Prune();
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
Assert.Equal(farIntheFuture, reg.WritableEndpointWithPolicyFor(address2).AsInstanceOf<EndpointManager.Gated>().TimeOfRelease);
}
public void EndpointRegistry_should_be_able_to_register_Quarantined_policy_for_an_address()
{
var reg = new EndpointRegistry();
var deadline = Deadline.Now + TimeSpan.FromMinutes(30);
Assert.Null(reg.WritableEndpointWithPolicyFor(address1));
reg.MarkAsQuarantined(address1, 42, deadline);
Assert.True(reg.IsQuarantined(address1, 42));
Assert.False(reg.IsQuarantined(address1, 33));
Assert.Equal(42, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf<EndpointManager.Quarantined>().Uid);
Assert.Equal(deadline, reg.WritableEndpointWithPolicyFor(address1).AsInstanceOf<EndpointManager.Quarantined>().Deadline);
}