/// <summary>
/// Creates a new Heartbeat entity for the specified Agent id
/// </summary>
/// <param name="request"></param>
/// <param name="agentId"></param>
/// <returns>Newly created Heartbeat</returns>
public AgentHeartbeat PerformAgentHeartbeat(HeartbeatViewModel request, string agentId)
{
Agent agent = _agentRepo.GetOne(new Guid(agentId));
if (agent == null)
{
throw new EntityDoesNotExistException("The Agent ID provided does not match any existing Agents");
}
if (agent.IsConnected == false)
{
throw new EntityOperationException("Agent is not connected. Please connect the agent and try again");
}
if (request.IsHealthy == false)
{
_webhookPublisher.PublishAsync("Agents.UnhealthyReported", agent.Id.ToString(), agent.Name).ConfigureAwait(false);
}
AgentHeartbeat agentHeartbeat = request.Map(request);
//Add HeartBeat Values
agentHeartbeat.AgentId = new Guid(agentId);
agentHeartbeat.CreatedBy = _caller?.Identity.Name;
agentHeartbeat.CreatedOn = DateTime.UtcNow;
agentHeartbeat.LastReportedOn = request.LastReportedOn ?? DateTime.UtcNow;
_agentHeartbeatRepo.Add(agentHeartbeat);
return(agentHeartbeat);
}
public async Task HeartbeatAsync(AgentHeartbeat heartbeat)
{
await using var conn = new MySqlConnection(_options.ConnectionString);
await conn.ExecuteAsync(
$"INSERT IGNORE INTO {_options.Database}.agent_heartbeat (agent_id, agent_name, available_memory, cpu_load, creation_time) VALUES (@AgentId, @AgentName, @FreeMemory, @CpuLoad, CURRENT_TIMESTAMP);",
new { heartbeat.AgentId, heartbeat.AgentName, heartbeat.AvailableMemory, heartbeat.CpuLoad });
await conn.ExecuteAsync(
$"UPDATE {_options.Database}.agent SET last_modification_time = CURRENT_TIMESTAMP WHERE id = @AgentId",
new { heartbeat.AgentId, });
}
public async Task <IActionResult> AddHeartbeat([FromBody] AgentHeartbeat request, string agentId)
{
try
{
if (request == null)
{
ModelState.AddModelError("Save", "No data passed");
return(BadRequest(ModelState));
}
Guid entityId = Guid.NewGuid();
if (request.Id == null || !request.Id.HasValue || request.Id.Equals(Guid.Empty))
{
request.Id = entityId;
}
Agent agent = agentRepo.GetOne(new Guid(agentId));
if (agent == null)
{
return(NotFound("The Agent ID provided does not match any existing Agents"));
}
if (agent.IsConnected == false)
{
ModelState.AddModelError("HeartBeat", "Agent is not connected");
return(BadRequest(ModelState));
}
if (request.IsHealthy == false)
{
await webhookPublisher.PublishAsync("Agents.UnhealthyReported", agent.Id.ToString(), agent.Name).ConfigureAwait(false);
}
//Add HeartBeat Values
request.AgentId = new Guid(agentId);
request.CreatedBy = applicationUser?.UserName;
request.CreatedOn = DateTime.UtcNow;
request.LastReportedOn = request.LastReportedOn ?? DateTime.UtcNow;
agentHeartbeatRepo.Add(request);
var resultRoute = "GetAgentHeartbeat";
return(CreatedAtRoute(resultRoute, new { id = request.Id.Value.ToString("b") }, request));
}
catch (Exception ex)
{
ModelState.AddModelError("Heartbeat", ex.Message);
return(ex.GetActionResult());
}
}
public AgentViewModel GetAgentDetails(AgentViewModel agentView)
{
agentView.UserName = usersRepo.Find(null, u => u.Name == agentView.Name).Items?.FirstOrDefault()?.UserName;
agentView.CredentialName = credentialRepo.GetOne(agentView.CredentialId ?? Guid.Empty)?.Name;
AgentHeartbeat agentHeartBeat = agentHeartbeatRepo.Find(0, 1).Items?.Where(a => a.AgentId == agentView.Id).OrderByDescending(a => a.CreatedOn).FirstOrDefault();
if (agentHeartBeat != null)
{
agentView.LastReportedOn = agentHeartBeat.LastReportedOn;
agentView.LastReportedStatus = agentHeartBeat.LastReportedStatus;
agentView.LastReportedWork = agentHeartBeat.LastReportedWork;
agentView.LastReportedMessage = agentHeartBeat.LastReportedMessage;
agentView.IsHealthy = agentHeartBeat.IsHealthy;
}
return(agentView);
}
public async Task TestAgentManager()
{
//arrange
var options = new DbContextOptionsBuilder <StorageContext>()
.UseInMemoryDatabase(databaseName: "AgentManager")
.Options;
Guid credentialId = Guid.NewGuid();
Guid agentId = Guid.NewGuid();
var context = new StorageContext(options);
var dummyAgent = new Agent
{
Id = agentId,
Name = "TesterAgent",
MachineName = "TestingMachine",
MacAddresses = "00:00:00:a1:2b:cc",
IPAddresses = "192.165.1.91",
CredentialId = credentialId
};
var dummyAgentHeartbeat = new AgentHeartbeat
{
Id = Guid.NewGuid(),
AgentId = agentId
};
var dummyCredential = new Credential
{
Id = credentialId,
Name = "TesterCredential"
};
var dummyUserAgent = new AspNetUsers
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Name = "TesterAgent"
};
var dummyJob = new Job
{
Id = Guid.NewGuid(),
AgentId = agentId,
JobStatus = JobStatusType.New
};
Seed(context, dummyAgent, dummyCredential, dummyUserAgent, dummyJob, dummyAgentHeartbeat);
var agentLogger = Mock.Of <ILogger <Agent> >();
var usersLogger = Mock.Of <ILogger <AspNetUsers> >();
var scheduleLogger = Mock.Of <ILogger <Schedule> >();
var jobLogger = Mock.Of <ILogger <Job> >();
var credentialLogger = Mock.Of <ILogger <Credential> >();
var agentHeartbeatLogger = Mock.Of <ILogger <AgentHeartbeat> >();
var httpContextAccessor = new Mock <IHttpContextAccessor>();
httpContextAccessor.Setup(req => req.HttpContext.User.Identity.Name).Returns(It.IsAny <string>());
var userRepo = new AspNetUsersRepository(context, usersLogger, httpContextAccessor.Object);
var agentRepo = new AgentRepository(context, agentLogger, httpContextAccessor.Object);
var scheduleRepo = new ScheduleRepository(context, scheduleLogger, httpContextAccessor.Object);
var jobRepo = new JobRepository(context, jobLogger, httpContextAccessor.Object);
var credentialRepo = new CredentialRepository(context, credentialLogger, httpContextAccessor.Object);
var agentHeartbeatRepo = new AgentHeartbeatRepository(context, agentHeartbeatLogger, httpContextAccessor.Object);
/*var manager = new AgentManager(agentRepo, scheduleRepo, jobRepo,userRepo, credentialRepo, agentHeartbeatRepo);*/
//act
AgentViewModel view = new AgentViewModel();
Agent agentModel = agentRepo.GetOne(agentId);
view = view.Map(agentModel);
/*var validAgentView = manager.GetAgentDetails(view);//Fetches agent details
* bool agentWithDependant = manager.CheckReferentialIntegrity(agentId.ToString());
*
* dummyJob.JobStatus = JobStatusType.Completed;//Removes referential integrity violation
* bool agentWithoutDependant = manager.CheckReferentialIntegrity(agentId.ToString());*/
//assert
/*Assert.Equal(dummyCredential.Name, validAgentView.CredentialName);
* Assert.Equal(dummyUserAgent.UserName, validAgentView.UserName);
* Assert.True(agentWithDependant);
* Assert.False(agentWithoutDependant);*/
}
private void Seed(StorageContext context, Agent agent, Credential credential, AspNetUsers aspNetUser, Job job, AgentHeartbeat agentHeartbeat)
{
context.Agents.AddRange(agent);
context.AgentHeartbeats.AddRange(agentHeartbeat);
context.Credentials.AddRange(credential);
context.AspNetUsers.AddRange(aspNetUser);
context.Jobs.Add(job);
context.SaveChanges();
}
public AgentHeartBeatManager()
{
Heartbeat = new AgentHeartbeat();
}
public static int SendAgentHeartBeat(AuthAPIManager apiManager, string agentId, AgentHeartbeat body)
{
AgentsApi agentsApi = new AgentsApi(apiManager.Configuration);
try
{
return(agentsApi.ApiV1AgentsAgentIdAddHeartbeatPostWithHttpInfo(agentId, body).StatusCode);
}
catch (Exception ex)
{
// In case of Unauthorized request
if (ex.GetType().GetProperty("ErrorCode").GetValue(ex, null).ToString() == "401")
{
// Refresh Token and Call API
agentsApi.Configuration.AccessToken = apiManager.GetToken();
return(agentsApi.ApiV1AgentsAgentIdAddHeartbeatPostWithHttpInfo(agentId, body).StatusCode);
}
throw ex;
}
}
