public async Task QueueEvent_DeQueue()
{
// Arrange
var compassEvent = new CompassEvent
{
EventName = "test"
};
var queuedEvents = new QueuedEvents()
{
Events = new List <CompassEvent>()
{
compassEvent
}
};
A.CallTo(() => _dataStore.GetQueuedEventsAsync())
.Returns(Task.FromResult(queuedEvents));
// Act
await _sut.DeQueueEventAsync(compassEvent);
// Assert
A.CallTo(() => _dataStore.UpsertAsync(queuedEvents))
.MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => _dataStore.UpsertAsync(A <QueuedEvents> .That.Matches(arg => !arg.Events.Contains(compassEvent))))
.MustHaveHappened(Repeated.Exactly.Once);
}
public async Task DeQueueEventAsync(CompassEvent compassEvent)
{
var queuedEvents = await _dataStore.GetQueuedEventsAsync();
queuedEvents.Events.Remove(compassEvent);
await _dataStore.UpsertAsync(queuedEvents);
}
private async Task SendEvent(ServiceSubscription serviceSubscription, CompassEvent compassEvent)
{
await _sendToEndpointService.SendToEndpointAsync(new List <ServiceSubscription> {
serviceSubscription
},
compassEvent);
await _queueEventService.DeQueueEventAsync(compassEvent);
}
public async Task <CompassResult> RouteRequest(CompassEvent compassEvent)
{
await _validateApplicationTokenService.ValidateApplicationTokenAsync(compassEvent.ApplicationToken);
var subscriptions =
await _getServiceSubscriptionsForEventService.GetServiceSubscriptionsAsync(compassEvent);
_kafkaProducerService.Produce(compassEvent);
return(await SendToSubscriptionsAsync(compassEvent, subscriptions));
}
public async Task QueueEventAsync(CompassEvent compassEvent)
{
compassEvent.Identifier = Guid.NewGuid();
compassEvent.DateCreated = DateTime.Now;
var queuedEvents = await GetQueuedEventsAsync();
queuedEvents.Events.Add(compassEvent);
await _dataStore.UpsertAsync(queuedEvents);
}
public async Task <CompassResult> SendRequestAsync(CompassEvent compassEvent)
{
// if no compass url is set, then we bail
if (_options.CompassUri == null)
{
throw new NoCompassEndpointSetException(compassEvent.EventName);
}
// build the request and send
return(await CompassRestClient.SendRequestAsync <CompassResult>(_options.CompassUri, compassEvent));
}
public void Produce(CompassEvent compassEvent)
{
try
{
_producer.ProduceAsync(_compassEnvironment.GetKafkaTopic(), null, JsonConvert.SerializeObject(compassEvent));
_producer.Flush(_compassEnvironment.GetKafkaProducerTimeout());
}
catch (Exception e)
{
// TODO: Log
Console.WriteLine(e);
}
}
public Policy GetPolicy(CompassEvent compassEvent)
{
var fallback = Policy
.Handle <NoValidSubscriptionsException>()
.FallbackAsync(
(context, cancellationToken) => _queueEventService.QueueEventAsync(compassEvent),
(exception, context) => throw exception
);
var retry = Policy
.Handle <NoValidSubscriptionsException>()
.WaitAndRetryAsync(GetTimeSpans());
return(Policy
.WrapAsync(fallback, retry));
}
public async Task RouteRequest_ValidateAppToken()
{
// Arrange
var appToken = Guid.NewGuid();
var compassEvent = new CompassEvent() { EventName = "test", ApplicationToken = appToken };
var subscriptions = new List<ServiceSubscription>
{
new ServiceSubscription()
};
A.CallTo(() => _getServiceSubscriptionsForEventService.GetServiceSubscriptionsAsync(compassEvent))
.Returns(subscriptions);
// Act
await _sut.RouteRequest(compassEvent);
// Assert
A.CallTo(() => _validateApplicationTokenService.ValidateApplicationTokenAsync(appToken))
.MustHaveHappened(Repeated.Exactly.Once);
}
private async Task <CompassResult> SendToSubscriptionsAsync(CompassEvent compassEvent, IReadOnlyCollection <ServiceSubscription> subscriptions)
{
var registeredApplicationTask =
_dataStore.GetByDocumentsIdAsync <RegisteredApplication>(
subscriptions.Select(subscription => subscription.ApplicationToken.ToString()));
var sendToEndpointTask = _sendToEndpointService.SendToEndpointAsync(subscriptions, compassEvent);
await Task.WhenAll(registeredApplicationTask, sendToEndpointTask);
var registeredApplications = await registeredApplicationTask;
var responses = await sendToEndpointTask;
var compassResult = new CompassResult {
Status = CompassResponseStatus.Success
};
if (responses != null)
{
compassResult.Status = GetCompassResponseStatus(responses);
compassResult.Payload = BuildResponse(registeredApplications, responses);
}
return(compassResult);
}
private async Task <object> SendAsync(Uri endpoint, CompassEvent compassEvent)
{
const string header = "application/json";
var client = GetHttpClient(header);
var queryContent =
new StringContent(
JsonConvert.SerializeObject(new
{
ApplicationToken = compassEvent.ApplicationToken,
ApplicationName = compassEvent.ApplicationName,
EventName = compassEvent.EventName,
Payload = compassEvent.Payload
}), Encoding.UTF8, header);
var response = await _sendToEndpointPolicy.GetPolicy()
.ExecuteAsync <HttpResponseMessage>(() => client.PostAsync(endpoint, queryContent));
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadAsStringAsync();
return(result == null ? null : JsonConvert.DeserializeObject <object>(result));
}
public async Task RouteRequest_SendToAllSubscriptions()
{
// Arrange
var subscriptions = new List<ServiceSubscription>
{
new ServiceSubscription()
{
ApplicationToken = Guid.NewGuid(),
ApplicationUri = new Uri("http://www.example.com/"),
SubscribedEvents = new List<string>() { "test"}
},
new ServiceSubscription()
{
ApplicationToken = Guid.NewGuid(),
ApplicationUri = new Uri("http://www.example2.com/"),
SubscribedEvents = new List<string>() { "test"}
}
};
var payload = new {test = "test"};
var compassEvent = new CompassEvent
{
EventName = "test",
ApplicationToken = Guid.NewGuid(),
Payload = payload
};
A.CallTo(() => _getServiceSubscriptionsForEventService.GetServiceSubscriptionsAsync(compassEvent))
.Returns(subscriptions);
// Act
await _sut.RouteRequest(compassEvent);
// Assert
A.CallTo(() => _sendToEndpointService.SendToEndpointAsync(subscriptions, compassEvent))
.MustHaveHappened(Repeated.Exactly.Once);
}
public async Task <IReadOnlyCollection <SendToEndpointResult> > SendToEndpointAsync(IReadOnlyCollection <ServiceSubscription> subscriptions, CompassEvent compassEvent)
{
var tasks = subscriptions.Select(async subscription =>
{
var sendToEndpointResult =
new SendToEndpointResult {
ApplicationToken = subscription.ApplicationToken.ToString()
};
try
{
sendToEndpointResult.Result = await SendAsync(subscription.ApplicationUri, compassEvent);
sendToEndpointResult.Success = true;
}
catch (Exception)
{
sendToEndpointResult.Success = false;
}
return(sendToEndpointResult);
}).ToList();
return(await Task.WhenAll(tasks));
}
// send standard event through compass
public async Task <CompassResult> SendRequestAsync(CompassEvent compassEvent)
{
return(await _compassRequest.SendRequestAsync(compassEvent));
}
public NoValidSubscriptionsException(CompassEvent compassEvent)
: base($"There were no valid services subscribed to this event: {compassEvent.EventName}.")
{
CompassEvent = compassEvent;
}
public async Task <CompassResult> RouteRequest([FromBody] CompassEvent compassEvent)
{
return(await _routeRequestService.RouteRequest(compassEvent));
}
private async Task <IReadOnlyCollection <ServiceSubscription> > GetSubscriptionsAsync(CompassEvent compassEvent)
{
var subscriptions = await _dataStore.GetServiceSubscribedToEventAsync(compassEvent.EventName);
// TODO: Determine how to handle one service going down,
// but another still alive
if (subscriptions == null || subscriptions.Count == 0)
{
throw new NoValidSubscriptionsException(compassEvent);
}
return(subscriptions.ToList());
}
private void Initialize()
{
_compassTimerCount = 0;
_accelTimerCount = 0;
_carCrashTimerCount = 0;
SessionStatus = SessionStatus.Stopped;
if (CurrentDriver == null)
{
CurrentDriver = new Driver {
Image = "/Assets/user_unknow.png"
};
}
CompassEvent = new CompassEvent
{
HeadingDegrees = 0
};
AccelerometerEvent = new AccelerometerEvent
{
X = 0000.00,
Z = 0000.00,
Y = 0000.00,
};
AvailableDrivers = new ObservableCollection <Driver>
{
new Driver {
Id = 1, LicensePlate = "FGH-9876", Image = "/Assets/Drivers/1.jpg"
},
new Driver {
Id = 2, LicensePlate = "SLV-4335", Image = "/Assets/Drivers/2.jpg"
},
new Driver {
Id = 3, LicensePlate = "MAX-9876", Image = "/Assets/Drivers/3.jpg"
},
new Driver {
Id = 4, LicensePlate = "CCC-1432", Image = "/Assets/Drivers/4.jpg"
},
new Driver {
Id = 5, LicensePlate = "JNV-9876", Image = "/Assets/Drivers/5.jpg"
},
new Driver {
Id = 6, LicensePlate = "CUA-1456", Image = "/Assets/Drivers/6.jpg"
},
new Driver {
Id = 7, LicensePlate = "JOP-9876", Image = "/Assets/Drivers/7.jpg"
},
new Driver {
Id = 8, LicensePlate = "HTY-1243", Image = "/Assets/Drivers/8.jpg"
},
new Driver {
Id = 9, LicensePlate = "VVV-4444", Image = "/Assets/Drivers/9.jpg"
},
new Driver {
Id = 10, LicensePlate = "ERT-1256", Image = "/Assets/Drivers/10.jpg"
}
};
}
public async Task <IReadOnlyCollection <ServiceSubscription> > GetServiceSubscriptionsAsync(CompassEvent compassEvent)
{
return(await _getServiceSubscriptionsForEventPolicy.GetPolicy(compassEvent)
.ExecuteAsync(() => GetSubscriptionsAsync(compassEvent)));
}