public AgentDescriptor RegisterOrUpdate(AgentDescriptor descriptor)
{
Verify(descriptor);
var desc = dbSetDescriptors.FirstOrDefault(d => d.Id == descriptor.Id);
if (desc == null || desc.ExpirationDate < DateTime.UtcNow)
{
if (desc != null)
{
//Expired
dbSetDescriptors.Remove(desc);
}
desc = descriptor;
if (string.IsNullOrEmpty(desc.Id))
{
desc.Id = GetDescriptorId();
}
desc.DateCreated = DateTime.UtcNow;
desc.ExpirationDate = descriptor.DateCreated.Value.AddDays(tunnelsConfig.ExpirationDays);
dbSetDescriptors.Add(desc);
}
else
{
dbContext.Entry(desc).CurrentValues.SetValues(descriptor);
}
dbContext.SaveChanges();
return(desc);
}
private void CheckPortAvailable(AgentDescriptor descriptor)
{
var port = descriptor.RemotePort;
if (port == 0)
{
port = tunnelsConfig.PortFrom;
}
var attempts = 0;
var maxAttempts = (tunnelsConfig.PortTo - tunnelsConfig.PortFrom);
while (attempts < maxAttempts)
{
var exists = dbSetDescriptors.Count(d => d.Id != descriptor.Id && d.RemotePort == port) > 0;
logger.LogInformation(exists ? "Remote port {0} exists" : "Remote port {0} doesn't exist", descriptor.RemotePort);
attempts++;
if (exists)
{
port++;
if (port >= tunnelsConfig.PortTo)
{
port = tunnelsConfig.PortFrom;
}
}
else
{
break;
}
}
if (attempts > maxAttempts)
{
throw new ArgumentException("No more free remote ports");
}
descriptor.RemotePort = port;
}
public AgentDescriptor RegisterOrUpdate(AgentDescriptor descriptor)
{
if (!descriptors.ContainsKey(descriptor.SshServer) || descriptors[descriptor.SshServer] == null)
{
descriptors[descriptor.SshServer] = new List <AgentDescriptor>();
}
Verify(descriptor);
var desc = descriptors[descriptor.SshServer].FirstOrDefault(d => d.Id == descriptor.Id);
if (desc == null || desc.ExpirationDate < DateTime.UtcNow)
{
if (desc != null)
{
//Expired
descriptors[descriptor.SshServer].Remove(desc);
}
desc = descriptor;
desc.Id = GetDescriptorId(GetAllDescriptors());
desc.DateCreated = DateTime.UtcNow;
desc.ExpirationDate = descriptor.DateCreated.Value.AddDays(tunnelsConfig.ExpirationDays);
descriptors[descriptor.SshServer].Add(descriptor);
}
else
{
desc.MachineName = descriptor.MachineName;
desc.ClientName = descriptor.ClientName;
desc.ExpirationDate = descriptor.ExpirationDate;
desc.LocalPort = descriptor.LocalPort;
desc.RemotePort = descriptor.RemotePort;
}
SaveDescriptors();
return(desc);
}
private AgentDescriptor RegisterOrUpdate(AgentDescriptor descriptor)
{
if (string.IsNullOrEmpty(descriptor.SshServer))
{
throw new ArgumentException("SSH server name must be supplied");
}
_logger.LogInformation("Registering descriptor {d}", JsonConvert.SerializeObject(descriptor));
return(descriptorsService.RegisterOrUpdate(descriptor));
}
public void UpdateDescriptor(AgentDescriptor descriptor)
{
var desc = dbSetDescriptors.FirstOrDefault(d => d.Id == descriptor.Id);
if (desc != null)
{
dbContext.Entry(desc).CurrentValues.SetValues(descriptor);
dbContext.SaveChanges();
}
}
public void Verify(AgentDescriptor descriptor)
{
//check server
if (string.IsNullOrEmpty(descriptor.SshServer))
{
descriptor.SshServer = GetAvailableServer(descriptor);
}
var port = CheckPortAvailable(descriptor);
}
public void UpdateLastActive(AgentDescriptor descriptor)
{
lock (lockObj)
{
var desc = dbSetDescriptors.FirstOrDefault(d => d.Id == descriptor.Id);
if (desc != null)
{
desc.LastActive = descriptor.LastActive;
dbContext.SaveChanges();
}
}
}
/// <summary>
/// Returns sshserver and first available port
/// </summary>
/// <param name="descriptor"></param>
/// <returns></returns>
public void Verify(AgentDescriptor descriptor)
{
//check server
GetAvailableServer(descriptor);
CheckPortAvailable(descriptor);
if (string.IsNullOrEmpty(descriptor.Id))
{
descriptor.Id = GetDescriptorId();
}
}
public AgentDescriptor RegisterAgent([FromBody] AgentDescriptor descriptor)
{
try
{
return(RegisterOrUpdate(descriptor));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
throw;
}
}
public static AgentDescriptorData fromComponent(AgentDescriptor descriptor)
{
if (descriptor == null) {
return null;
}
AgentDescriptorData descriptorData = new AgentDescriptorData();
descriptorData.id = descriptor.id;
descriptorData.agentName = descriptor.agentName;
descriptorData.portraitId = descriptor.portraitId;
return descriptorData;
}
public static Agent GetAgent(AgentDescriptor agentDescriptor)
{
if (!agentDescriptor.isValid()) {
return null;
}
if (!AGENTS.ContainsKey(agentDescriptor.agentName)) {
GameLogger.printRed(string.Format("DynamicObjectRegistry:: agent {0} not found", agentDescriptor.agentName));
return null;
}
return AGENTS[agentDescriptor.agentName];
}
public static void AddAgent(AgentDescriptor agentDescriptor, Agent agent)
{
if (!agentDescriptor.isValid()) {
GameLogger.printRed(string.Format("DynamicObjectRegistry:: Cannot add invalid {0} agent descriptor!", agentDescriptor.agentName));
return;
}
if (AGENTS.ContainsKey(agentDescriptor.agentName)) {
GameLogger.printRed(string.Format("DynamicObjectRegistry:: Agent {0} already present!", agentDescriptor.agentName));
return;
}
AGENTS.Add(agentDescriptor.agentName, agent);
}
public async Task <IActionResult> UpdateLastActive(AgentDescriptor descriptor)
{
//Call registrationwebapi and get all agent descriptors
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("X-Api-Key", appSettings.AgentDescriptorsApiKey);
var response = await client.PutAsync($"{appSettings.AgentDescriptorsApiUrl}/updateLastActive",
new StringContent(JsonConvert.SerializeObject(descriptor), Encoding.UTF8, "application/json"));
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return(Ok(JsonConvert.DeserializeObject <AgentDescriptor>(response.Content.ReadAsStringAsync().Result)));
}
return(BadRequest(response.Content.ReadAsStringAsync().Result));
}
}
public IActionResult UpdateDescriptor([FromBody] AgentDescriptor descriptor)
{
if (string.IsNullOrEmpty(descriptor.SshServer))
{
throw new ArgumentException("SSH server must be specified");
}
try
{
descriptorsService.UpdateDescriptor(descriptor);
}
catch (DuplicateRemotePortException)
{
return(BadRequest($"Remote port {descriptor.RemotePort} already in use"));
}
return(Ok(descriptor));
}
public void UpdateDescriptor(AgentDescriptor descriptor)
{
if (descriptors.ContainsKey(descriptor.SshServer))
{
var found = descriptors[descriptor.SshServer].FirstOrDefault(d => d.Id == descriptor.Id);
if (found != null)
{
//Check duplicate port
if (descriptors[descriptor.SshServer].Count(d => d.RemotePort == descriptor.RemotePort && d.Id != descriptor.Id) > 0)
{
throw new DuplicateRemotePortException();
}
CopyDescriptor(found, descriptor);
SaveDescriptors();
}
}
}
private void GetAvailableServer(AgentDescriptor descriptor)
{
if (string.IsNullOrEmpty(descriptor.SshServer) || descriptor.IdSSHServer <= 0)
{
//Find first pingable server with free ports
var servers = dbSetServers.ToList();
foreach (var server in servers)
{
if (dbSetDescriptors.Count(d => d.SshServer == server.Url || d.IdSSHServer == server.Id) < (tunnelsConfig.PortTo - tunnelsConfig.PortFrom))
{
//there are free ports
if (IsServerLive(server))
{
descriptor.SshServer = server.Url;
descriptor.IdSSHServer = server.Id;
return;
}
}
}
throw new ArgumentException("No available SSH servers.");
}
}
public async Task <bool> CheckTunnelAlive([FromBody] AgentDescriptor descriptor)
{
try
{
using (var client = new HttpClient())
{
var url = $"http://{descriptor.SshServer}:{descriptor.RemotePort}/?cmd=status&detaillevel=ping";
var response = await client.GetAsync(url);
var result = JsonConvert.DeserializeObject(response.Content.ReadAsStringAsync().Result);
if (result != null)
{
descriptor.LastActive = DateTime.Now;
descriptorsService.UpdateLastActive(descriptor);
}
return(result != null);
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(false);
}
}
public IActionResult UpdateLastActive([FromBody] AgentDescriptor descriptor)
{
descriptorsService.UpdateLastActive(descriptor);
return(Ok(descriptor));
}
public AgentDescriptor VerifyDescriptor([FromBody] AgentDescriptor descriptor)
{
descriptorsService.Verify(descriptor);
return(descriptor);
}
private string GetAvailableServer(AgentDescriptor descriptor)
{
//TODO
return(string.Empty);
}
public void UpdateLastActive(AgentDescriptor descriptor)
{
throw new NotImplementedException();
}
public static void toComponent(AgentDescriptorData descriptorData, AgentDescriptor descriptor)
{
descriptor.id = descriptorData.id;
descriptor.agentName = descriptorData.agentName;
descriptor.portraitId = descriptorData.portraitId;
}
