public void SetDeviceConnectionDetails(string deviceName, Core.Entities.DeviceConnectionStatus status)
{
var device = dbContext.Clients.SingleOrDefault(c => c.ClientName == deviceName);
var existDeviceRequest = dbContext.DeviceRequests.Any(r => r.ClientId == device.Id);
if (!existDeviceRequest)
{
var newConnection = new ClientConnection()
{
Client = device,
Status = (short)status.State,
ConnectionTimestamp = DateTime.UtcNow,
SshIp = status.SshHost,
SshPort = status.SshPort,
SshUser = status.SshUser,
SshForwarding = status.SshForwarding
};
dbContext.ClientConnections.Add(newConnection);
}
var deviceConnection = dbContext.ClientConnections.SingleOrDefault(c => c.ClientId == device.Id);
if (deviceConnection != null)
{
deviceConnection.Status = (short)status.State;
deviceConnection.ConnectionTimestamp = DateTime.UtcNow;
deviceConnection.SshIp = status.SshHost;
deviceConnection.SshPort = status.SshPort;
deviceConnection.SshUser = status.SshUser;
deviceConnection.SshForwarding = status.SshForwarding;
}
dbContext.SaveChanges();
}
private Core.Entities.DeviceConnectionStatus GenerateSshConnectionDetails()
{
// Inserting device connection details
Core.Entities.DeviceConnectionStatus deviceConnectionDetails = new Core.Entities.DeviceConnectionStatus();
deviceConnectionDetails.SshHost = settings.SshHost;
deviceConnectionDetails.SshUser = settings.SshUser;
deviceConnectionDetails.SshPort = settings.SshPort;
deviceConnectionDetails.State = EnumClientConnectionState.Ready;
using (sshondemandContext dbContext = new sshondemandContext())
{
List <int> usedPorts = clientConnections.GetForwardingPorts();
for (int i = settings.SshFirstPort; i < settings.SshFirstPort + 1000; i++)
{
if (!usedPorts.Contains(i))
{
deviceConnectionDetails.SshForwarding = i;
break;
}
}
return(deviceConnectionDetails);
}
}
public IActionResult DeveloperCheckDeviceConnection([FromBody] DeveloperCheckDeviceConnectionArgs args)
{
string developerIdentity = (string)HttpContext.Items["ClientName"];
Console.WriteLine("Developer identity is: " + developerIdentity);
// Check developer device connection authorization
bool isDeveloperAuthorized =
developerAuthorizationsRepository.IsDeveloperConnectionToDeviceAuthorized(developerIdentity, args.DeviceName);
if (isDeveloperAuthorized)
{
// Checking device connection status
var deviceConnection = this.clientConnectionsRepository.CheckDeviceConnection(args.DeviceName);
Core.Entities.DeviceConnectionStatus currentDeviceConnectionStatus = ClientConnectionMapper.Mapper.Map <Core.Entities.DeviceConnectionStatus>(deviceConnection);
if (currentDeviceConnectionStatus.State == EnumClientConnectionState.Ready || currentDeviceConnectionStatus.State == EnumClientConnectionState.Connected)
{
this.ssh.SaveClientKeys(currentDeviceConnectionStatus.SshForwarding, "developer_" + developerIdentity, args.DeveloperSshPublicKey);
}
return(Ok(currentDeviceConnectionStatus));
}
else if (!isDeveloperAuthorized)
{
return(StatusCode(403, "Develeper is not authorized to connect to this device"));
}
else
{
return(StatusCode((int)HttpStatusCode.InternalServerError, "Database error"));
}
}
public ClientConnection CheckDeviceConnection(string deviceName)
{
Core.Entities.DeviceConnectionStatus status = new Core.Entities.DeviceConnectionStatus();
status.State = EnumClientConnectionState.Disconnected;
var connectionStatus = dbContext.ClientConnections.Where(c => c.Client.ClientName == deviceName).SingleOrDefault();
return(connectionStatus);
}
public IActionResult DeviceCheckRemoteConnectionRequest([FromBody] string devicePublicKey)
{
#warning to move in infrastructure module
string deviceIdentity = (string)HttpContext.Items["ClientName"];
Console.WriteLine("Device identity is: " + deviceIdentity);
var deviceConnectionRequest = clientConnections.GetByClientName(deviceIdentity);
bool isDeviceConnectionRequested = deviceConnectionRequest != null;
if (isDeviceConnectionRequested)
{
// Verifica dello stato della connessione, se è già attiva non devo fare nulla
var deviceConnection = this.clientConnections.CheckDeviceConnection(deviceIdentity);
Core.Entities.DeviceConnectionStatus connectionStatus = ClientConnectionMapper.Mapper.Map <Core.Entities.DeviceConnectionStatus>(deviceConnection);
// Altrimenti devo fare in modo che venga attivata la nuova connessione
if (connectionStatus.State != EnumClientConnectionState.Connected)
{
this.ssh.SaveClientKeys(connectionStatus.SshForwarding, "device_" + deviceIdentity, devicePublicKey);
// Generating Ssh connection details
Core.Entities.DeviceConnectionStatus connectionDetails = GenerateSshConnectionDetails();
// Inserting connection details to database
this.clientConnections.SetDeviceConnectionDetails(deviceIdentity, connectionDetails);
return(Ok(connectionDetails));
}
// in questo caso torna connected (quello che ha detto il db)
return(Ok(connectionStatus));
}
else if (!isDeviceConnectionRequested)
{
DeviceConnectionStatus connectionStatus = new DeviceConnectionStatus()
{
State = EnumClientConnectionState.NotRequest
};
return(Ok(connectionStatus));
}
else
{
return(StatusCode((int)HttpStatusCode.InternalServerError, "Database error"));
}
}
