private async Task EnsureSendHealthUpdateAsync(HealthUpdate update)
{
while (!_cancelationTokenSource.IsCancellationRequested)
{
try
{
await SendHealthUpdateAsync(update);
_retryInterval = null;
return;
}
catch (Exception e) when(!_cancelationTokenSource.IsCancellationRequested)
{
BackOffPlan backOffPlan = await _backOffStategy.GetCurrent(_retryInterval, _cancelationTokenSource.Token);
if (backOffPlan.ShouldLog)
{
_logger.Error("Unable to send health update", e);
}
_retryInterval = backOffPlan.RetryInterval;
if (_retryInterval.HasValue)
{
await SafeDelay(_retryInterval.Value);
}
}
}
}
public void ClearDelegates()
{
PlayerHealthUpdateCall = null;
EnemyHealthUpdateCall = null;
CombatEndVictoryCall = null;
CombatEndDefeatCall = null;
}
public async Task Notifier_should_send_current_health_to_the_API()
{
var endpointId = Guid.NewGuid();
var expectedHealth = new EndpointHealth(HealthStatus.Offline, new Dictionary <string, string> {
{ "key", "value" }
});
HealthUpdate lastCaptured = null;
var countdown = new AsyncCountdown("update", 5);
SetupHealthCheckInterval(TimeSpan.FromMilliseconds(1));
SetupEndpointRegistration(endpointId);
_mockClient.Setup(c => c.SendHealthUpdateAsync(endpointId, AuthenticationToken, It.IsAny <HealthUpdate>(), It.IsAny <CancellationToken>()))
.Returns((Guid id, string authToken, HealthUpdate upd, CancellationToken token) => _awaitableFactory
.Execute(() => lastCaptured = upd)
.WithCountdown(countdown)
.RunAsync());
using (CreateNotifier(token => Task.FromResult(expectedHealth)))
await countdown.WaitAsync(TestMaxTime);
Assert.NotNull(lastCaptured);
Assert.Equal(expectedHealth.Status, lastCaptured.Status);
Assert.Equal(expectedHealth.Details, lastCaptured.Details);
Assert.True(lastCaptured.CheckTimeUtc > DateTime.UtcNow.AddMinutes(-1) && lastCaptured.CheckTimeUtc < DateTime.UtcNow.AddMinutes(1));
}
private void SendUpdate()
{
/* construct the update object so send */
HealthUpdate dt = new HealthUpdate();
//get the machine name
dt.Name = Environment.MachineName;
//get the cpu info
var cpu = getCPUCounter();
if (cpu != null)
{
dt.CPU = (float)cpu;
}
//get the ram info
var ram = getAvailableRAM();
if (!float.IsNaN(ram))
{
dt.RAM = (decimal)ram;
}
//get hard disk space
DriveInfo cDrive = DriveInfo.GetDrives()[0];//1st disk only
dt.DISK = (float)cDrive.AvailableFreeSpace / 10000000000;
//now transmit it to the server
Transmit(dt);
}
private static bool AssertHealth(EndpointHealth actual, HealthUpdate expected)
{
Assert.Equal(expected.CheckTimeUtc, actual.CheckTimeUtc);
Assert.Equal(expected.ResponseTime, actual.ResponseTime);
Assert.Equal(expected.Status, actual.Status);
Assert.Equal(expected.Details, actual.Details);
return(true);
}
public void GetPendingUpdatesTest()
{
using (MemberRepository MR = new MemberRepository())
{
HealthUpdate update = MR.GetPendingUpdatesAsync(3).Result;
Assert.AreEqual(false, update.IsProfileActive);
}
}
public void GetPendingUpdatesTest()
{
MemberService MS = new MemberService();
HealthUpdate update = MS.CheckPendingUpdates("4", DateTime.Now.AddDays(-20).ToString(), DateTime.Now.Ticks.ToString()).Result;
Assert.AreEqual(false, update.IsProfileActive);
}
public IHttpActionResult Post([FromBody] HealthUpdate anUpdate)
{
anUpdate.TimeStamp = DateTime.Now;
//var db = GHModel.HealthUpdate.
_context.HealthUpdates.Add(anUpdate);
_context.SaveChanges();
return(Ok(anUpdate));
}
public static async Task <HealthUpdate> GetSystemHealthAsync()
{
HealthUpdate objHealth = null;
if (IsDataNetworkAvailable && IsRegisteredUser)
{
objHealth = await MembershipServiceWrapper.CheckPendingUpdates(CurrentProfile.ProfileId, CurrentProfile.LastSynced.HasValue?CurrentProfile.LastSynced.Value : DateTime.MinValue);
}
return(objHealth);
}
void UpdateSubscribers()
{
var message = new HealthUpdate();
_healthSagas
.Select(x => new HealthInformation(x.CorrelationId, x.ControlUri, x.DataUri, x.LastHeartbeat, x.CurrentState.Name))
.Each(x => message.Information.Add(x));
_log.Debug("Publishing HealthUpdate");
_bus.Publish(message);
}
/// <summary>
/// Take damage from opponent's weapon
/// </summary>
/// <param name="amount">damage amount</param>
public void TakeDamage(int amount)
{
if (currentHealth > 0)
{
currentHealth -= amount;
HealthUpdate?.Invoke(currentHealth);
if (currentHealth <= 0)
{
OnDie();
}
}
}
public void OnHealthUpdate(HealthUpdate package)
{
_stateHandler.EntityManager.HealthUpdate(
package.ObjectId,
package.TimeStamp,
package.HealthChange,
package.NewHealthValue,
package.EffectType,
package.EffectOrigin,
package.CauserId,
package.CausingSpellType
);
}
private async Task SendHealthUpdateAsync(HealthUpdate update)
{
var endpointId = _endpointId ?? (_endpointId = await RegisterEndpointAsync()).Value;
try
{
await _client.SendHealthUpdateAsync(endpointId, _definition.Password, update, _cancelationTokenSource.Token);
}
catch (EndpointNotFoundException)
{
_endpointId = null;
}
}
public void PostEndpointHealth_should_return_NotFound_status_for_unknown_endpoint()
{
var endpointId = Guid.NewGuid();
var update = new HealthUpdate {
CheckTimeUtc = _utcNow, Status = EndpointStatus.Offline, ResponseTime = TimeSpan.FromSeconds(5), Details = new Dictionary <string, string> {
{ "a", "b" }
}
};
_endpointRegistry.Setup(r => r.UpdateHealth(endpointId, It.IsAny <EndpointHealth>())).Returns(false);
AuthorizeWithId(endpointId);
Assert.IsType <NotFoundResult>(_controller.PostEndpointHealth(endpointId, update));
}
public void PostEndpointHealth_should_update_health()
{
var endpointId = Guid.NewGuid();
var update = new HealthUpdate {
CheckTimeUtc = _utcNow, Status = EndpointStatus.Offline, ResponseTime = TimeSpan.FromSeconds(5), Details = new Dictionary <string, string> {
{ "a", "b" }
}
};
_endpointRegistry.Setup(r => r.UpdateHealth(endpointId, It.IsAny <EndpointHealth>())).Returns(true);
AuthorizeWithId(endpointId);
Assert.IsType <OkResult>(_controller.PostEndpointHealth(endpointId, update));
_endpointRegistry.Verify(r => r.UpdateHealth(endpointId, It.Is <EndpointHealth>(h => AssertHealth(h, update))), Times.Once);
}
/// <summary>Transmit the HealthUpdate to the central server</summary>
/// <param name="hu">The HealthUpdate to send.</param>
private void Transmit(HealthUpdate hu)
{
var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
httpWebRequest.ContentType = "text/json";
httpWebRequest.Method = "POST";
var json = new JavaScriptSerializer().Serialize(hu);
using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
streamWriter.Write(json);
streamWriter.Flush();
}
var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
}
public IHttpActionResult PostEndpointHealth(Guid id, [FromBody] HealthUpdate health, DateTimeOffset?clientCurrentTime = null)
{
if (_endpointRegistry.GetById(id) != null)
{
RequestContext.Authorize(id);
}
health.ValidateModel();
var clockDifference = GetServerToClientTimeDifference(clientCurrentTime);
if (!_endpointRegistry.UpdateHealth(id, health.ToEndpointHealth(clockDifference)))
{
return(NotFound());
}
return(Ok());
}
private void RefreshHealth(HealthUpdate ignored)
{
heartbeatList.Items.Clear();
foreach (HealthInformation information in ignored.Information)
{
var items = new[]
{
information.Uri.ToString(),
information.State
//information.FirstDetectedAt.Value.ToString("hh:mm:ss"),
//information.LastDetectedAt.Value.ToString("hh:mm:ss")
};
var lvi = new ListViewItem(items);
heartbeatList.Items.Add(lvi);
}
}
public async Task <HealthUpdate> GetPendingUpdatesAsync(long ProfileID)
{
return(await _sqlAzureExecutionStrategy.ExecuteAsync <HealthUpdate>(async() =>
{
HealthUpdate pendingUpdate = new HealthUpdate();
pendingUpdate.IsGroupModified = false;
pendingUpdate.IsProfileActive = false;
Profile updatedProfile = null;
GroupMembership updatedGroup = null;
List <Task> tasks = new List <Task>();
Task <Profile> profileTask = _guardianContext.Profiles
.Where(w => w.ProfileID == ProfileID)
.AsNoTracking().FirstOrDefaultAsync();
Task <GroupMembership> groupTask = _guardianContext.GroupMemberships
.Where(w => w.ProfileID == ProfileID)
.AsNoTracking().FirstOrDefaultAsync();
tasks.Add(profileTask);
tasks.Add(groupTask);
Task.WaitAll(tasks.ToArray());
updatedProfile = profileTask.Result;
updatedGroup = groupTask.Result;
if (updatedProfile != null)
{
pendingUpdate.IsProfileActive = updatedProfile.IsValid;
}
if (updatedGroup != null)
{
pendingUpdate.IsGroupModified = true;
}
return pendingUpdate;
}, CancellationToken.None));
}
private async Task EnsureSendHealthUpdateAsync(HealthUpdate update)
{
int repeats = 1;
while (!_cancelationTokenSource.IsCancellationRequested)
{
try
{
await SendHealthUpdateAsync(update);
return;
}
catch (Exception e) when(!_cancelationTokenSource.IsCancellationRequested)
{
_logger.Error("Unable to send health update", e);
await SafeDelay(TimeSpan.FromSeconds(Math.Min(MaxRepeatDelayInSecs, repeats)));
repeats *= 2;
}
}
}
public void PostEndpointHealth_should_update_health_and_adjust_check_time_with_clientServer_time_difference()
{
var endpointId = Guid.NewGuid();
var update = new HealthUpdate {
CheckTimeUtc = _utcNow, Status = EndpointStatus.Offline, ResponseTime = TimeSpan.FromSeconds(5), Details = new Dictionary <string, string> {
{ "a", "b" }
}
};
var timeDifference = TimeSpan.FromMinutes(5);
var expected = new HealthUpdate
{
CheckTimeUtc = update.CheckTimeUtc - timeDifference,
Details = update.Details,
ResponseTime = update.ResponseTime,
Status = update.Status
};
_endpointRegistry.Setup(r => r.UpdateHealth(endpointId, It.IsAny <EndpointHealth>())).Returns(true);
AuthorizeWithId(endpointId);
Assert.IsType <OkResult>(_controller.PostEndpointHealth(endpointId, update, _utcNow + timeDifference));
_endpointRegistry.Verify(r => r.UpdateHealth(endpointId, It.Is <EndpointHealth>(h => AssertHealth(h, expected))), Times.Once);
}
public async Task Notifier_should_send_faulty_health_to_the_API_if_provided_health_method_throws()
{
var endpointId = Guid.NewGuid();
HealthUpdate lastCaptured = null;
var countdown = new AsyncCountdown("update", 5);
SetupHealthCheckInterval(TimeSpan.FromMilliseconds(1));
SetupEndpointRegistration(endpointId);
_mockClient.Setup(c => c.SendHealthUpdateAsync(endpointId, AuthenticationToken, It.IsAny <HealthUpdate>(), It.IsAny <CancellationToken>()))
.Returns((Guid id, string authToken, HealthUpdate upd, CancellationToken token) => _awaitableFactory
.Execute(() => lastCaptured = upd)
.WithCountdown(countdown)
.RunAsync());
using (CreateNotifier(async token => { await Task.Delay(50, token); throw new InvalidOperationException("some reason"); }))
await countdown.WaitAsync(TestMaxTime);
Assert.NotNull(lastCaptured);
Assert.Equal(HealthStatus.Faulty, lastCaptured.Status);
Assert.Equal("Unable to collect health information", lastCaptured.Details["reason"]);
Assert.True(lastCaptured.Details["exception"].StartsWith("System.InvalidOperationException: some reason"));
Assert.True(lastCaptured.CheckTimeUtc > DateTime.UtcNow.AddMinutes(-1) && lastCaptured.CheckTimeUtc < DateTime.UtcNow.AddMinutes(1));
}
public void updateHealth(HealthUpdate u)
{
playerHPText.text = u.Health.ToString();
}
public async Task SendHealthUpdateAsync(Guid endpointId, string authenticationToken, HealthUpdate update, CancellationToken cancellationToken)
{
_logger.Info($"Sending health update: {update.Status}");
using (var client = new HttpClient())
{
Authorize(client, endpointId, authenticationToken);
var result = await PostAsync(client, $"/api/endpoints/{endpointId}/health?clientCurrentTime={DateTimeOffset.UtcNow.ToString("u", CultureInfo.InvariantCulture)}", update, cancellationToken);
if (result.StatusCode == HttpStatusCode.NotFound)
throw new EndpointNotFoundException();
result.EnsureSuccessStatusCode();
}
}
public void Consume(HealthUpdate message)
{
Action <IEnumerable <HealthInformation> > method = RefreshHealthView;
BeginInvoke(method, new object[] { message.Information });
}
private void HeartBeatRefreshNeeded(HealthUpdate message)
{
ThreadSafeUpdate2 tsu = RefreshHealth;
BeginInvoke(tsu, new object[] { message });
}
public void Consume(HealthUpdate message)
{
HeartBeatRefreshNeeded(message);
}
