private static void Connect(SshServer server, string client)
{
try {
using (Stream clientStream = server.Connect(client, 8000))
{
/* Simple HTTP request. Remove this and put your own
* operations here. */
Console.WriteLine("Connected");
string message = "GET / HTTP/1.1\r\n" +
"User - Agent: Server\r\n" +
"Host: 169.254.73.20:8000\r\n\r\n";
byte[] sendBuffer = Encoding.UTF8.GetBytes(message);
clientStream.Write(sendBuffer, 0, sendBuffer.Length);
byte[] headerBuffer = new byte[400];
clientStream.Read(headerBuffer, 0, 300);
Console.WriteLine(Encoding.UTF8.GetString(headerBuffer));
byte[] bodyBuffer = new byte[100];
clientStream.Read(bodyBuffer, 0, 100);
Console.WriteLine(Encoding.UTF8.GetString(bodyBuffer));
GetConnectedClients(server);
}
} catch (SshClientNotFoundException ex) {
Console.WriteLine("Error the client was not found in the list of connected clients.");
}
}
static void Main()
{
var server = new SshServer(new IPEndPoint(IPAddress.Any, 8888));
var authenticationMethods = new List <FxSsh.AuthenticationMethod>();
server.SetClientKeyRepository(new ClientKeyRepository());
authenticationMethods.Add(AuthenticationMethod.PublicKey);
// server.AuthenticationMethods = authenticationMethods;
// Called when a client has connected to the server.
server.ConnectionAccepted += ServerConnectionAccepted;
server.Start();
while (true)
{
var input = Console.ReadLine().Split(" ");
var command = input[0];
switch (command)
{
case "Connect":
if (input.Length < 2)
{
return;
}
Connect(server, input[1]);
break;
case "GetConnectedClients":
GetConnectedClients(server);
break;
default:
break;
}
}
}
public async Task <IActionResult> CreateSshServer(string apiKey, string email)
{
if (!HasAccess(apiKey))
{
return(BadRequest("No AuthKey set or wrong auth key!"));
}
var model = new SshServer
{
Name = "Please Change",
SshUsername = "******",
SshPassword = "******"
};
var user = await _userService.GetUserByEmail(email);
if (user != null)
{
model.LiteDbUserId = user.Id.ToString();
model.Owner = user;
if (!await _userManager.IsInRoleAsync(user, "OnPremise"))
{
await _userManager.AddToRoleAsync(user, "OnPremise");
}
}
var sshServer = await _sshServerSerivce.Insert(model);
if (user == null)
{
await _reservedServersService.Add(new ReservedServer()
{
Email = email, SshServerId = sshServer
});
}
return(Ok(sshServer));
}
public async Task <bool> Update(SshServer sshServer, bool validate = true)
{
SshServer old = null;
if (string.IsNullOrEmpty(sshServer.SshPassphrase) || string.IsNullOrEmpty(sshServer.SshPassword))
{
old = await FindOne(sshServer.Id);
if (old != null)
{
if (string.IsNullOrEmpty(sshServer.SshPassphrase))
{
sshServer.SshPassphrase = old.SshPassphrase;
}
if (string.IsNullOrEmpty(sshServer.SshPassword))
{
sshServer.SshPassword = old.SshPassword;
}
}
}
if (validate)
{
ValidateSshServer(sshServer);
}
return(await _liteDb.LiteDatabaseAsync.GetCollection <SshServer>("SshServer")
.UpdateAsync(sshServer));
}
private static void ValidateSshServer(SshServer server)
{
if (server.SshPort <= 0)
{
throw new ValidateException("SshPort", "You need a SSH port!");
}
if (string.IsNullOrEmpty(server.SshUsername))
{
throw new ValidateException("SshUsername", "You need a username!");
}
if (string.IsNullOrEmpty(server.SshPassword) && (server.SshKeyFileName == null || !server.SshKeyFileName.Any()))
{
throw new ValidateException("SshPassword", "You need at least a password or a key file!");
}
if (server.SshUsername == "root")
{
throw new ValidateException("SshUsername", "Dont use root here!");
}
try
{
RconStatic.AuthenticateOnTheSshServer(server);
}
catch (CommandException e)
{
throw new ValidateException("Id", e.Message);
}
}
public static void StartSshServer()
{
if (!UserConfiguration.Current.EnableSsh || _server != null)
{
return;
}
_server = new SshServer(new StartingInfo(IPAddress.IPv6Any, UserConfiguration.Current.SshPort));
_server.ConnectionAccepted += (s, e) => new GitSshService(e);
_server.ExceptionRasied += (s, e) =>
{
if (!(e is SshConnectionException))
{
XTrace.Log.Error(e.ToString());
}
};
foreach (var key in UserConfiguration.Current.HostKeys)
{
_server.AddHostKey(key.KeyType, key.KeyXml);
}
for (var i = 1; i <= 10; i++)
{
try
{
_server.Start();
XTrace.WriteLine("SSH server started.");
break;
}
catch (Exception ex)
{
XTrace.WriteLine("Attempt to start SSH server failed in {0} times. {1}", i, ex);
Task.Delay(1000).Wait();
}
}
}
public static PavlovServer[] PavlovServers(SshServer sshServer, PavlovServerService pavlovServerService)
{
pavlovServerService.Upsert(PavlovServer(sshServer), false);
var pavlovServers = pavlovServerService.FindAll().GetAwaiter().GetResult();
return(pavlovServers);
}
public async Task <int> Insert(SshServer sshServer, bool validate = true)
{
if (validate)
{
ValidateSshServer(sshServer);
}
return(await _liteDb.LiteDatabaseAsync.GetCollection <SshServer>("SshServer")
.InsertAsync(sshServer));
}
public void Start()
{
this.server = new SshServer();
// ServiceRegistered Events When Add Any
this.server.AddHostKey("ssh-rsa", "<RSAKeyValue><Modulus>xXKzcIH/rzcfv2D7VcvLdxR5S5iw2TTsP65Aa82S4+9ZIqLPTNtuzr76Mz6Cx0yDOhawHlIujtalqaaQzaUvkudCtMcVMnj37OcCYz7XDAYejalCxf/vtJo7U4mnYdCM+nAOQKNIDKLGbLtGuEAGwdi560DOJY2plhnBf1oOI+k=</Modulus><Exponent>AQAB</Exponent><P>37kMr9YiU4cSqHqTJSjBJ/szG2O4n5xSIlPy4MZ4aAN5NALHxfsN0dq1y8NL6GTLMI5qoykvp4Bjrm2ZgU1cDQ==</P><Q>4e84rF+UsFBfQEKJc2pbACWWJjttNW0hccdQZzA3IUxRmd/Z4yEMr1L70TP0XV7dw1RDs1JyU7xnXBIbGy5ETQ==</Q><DP>vP0TbI6VnL3j0xMIrkFJOj8Ho0GQOrTQ5VLJP3wpRqR4hKk8nVBBEl+RZznpK73Jr5D/ICmwqezZSAYpwILbGQ==</DP><DQ>bHdzZtWwRYEgaXJIGL+7lnN1BT/MazTMNJpykEeGgBbqqgvcx/zq4RTezg26SEUuBANlSSbQukCeAoayurbYlQ==</DQ><InverseQ>Irq9vR7CXIVR+r09caYIxIY8BOig+HShN1bXvATERJcjTW2jUgJrUttDGNEx70/hBd7m1NWCZz5YO3RH9Bdf5w==</InverseQ><D>AqxsufxFcW9TDCAmQK4mwVdsoQjRp2jfcULmkM8fl9u40dtxTr6Csv5dz7qfKLWxHTGlDUDabCK2t/DCcZZoA3rsqwLADe4ZerDdg6xiq4MBzNprM8Y0IfNESEdFB9T0T73ONQCsMalUzEvUknC4Ed4Fya34LUHntgQtEhXpDJE=</D></RSAKeyValue>");
this.server.AddHostKey("ssh-dss", "<DSAKeyValue><P>1fge/S/6Y42F73v/RhtkZQUEgNktLUzjf4zcJPse2JfXGqtg3lMaEiEDbb/2Nm4Q/M7iksZxlIxge0BkP1ul69+Tovl+Gg+hI+OPGaKlD/1dnX4D4i1FiOpnjtyoCTeZysJ5X8nO1lSInDRnRv46gHk4cHSFVKILKY7CVo1sf0s=</P><Q>tb2irBOnujteP+kf5HmH0yXepE8=</Q><G>HJfQK2Sdd5vN47HWVdmRRYhwAhiVoP98l7FZ3FzVxZvE/CurAL2xVrDi9modbLg0UA1JHeOi6h9FTI9ijepnqRscBKFlyIny0wh15sc8EMcZzG/vJVH2M48ps1knt793sxEwjU/SPYxE7UEX5HGa/KyLuP6Ev/0z4WOOIJ62B5w=</G><Y>ebWWjjGiFpfKfaXlrY3SiMorrkvge/UEeHd5E27RS4B/BBlm9OhdNBFq3zzILAa3X8KvDOGlVZgTYqDchp3/SK/Y8HsbqNyTyqDMNvcnHILDqSrWmGMQEA/0kGiPn0nwEcA87F1osCro7Y70SuLNwUOl3xh+gQKdi5V6WU75gaw=</Y><Seed>w0QY1PFWINvz3x2OZlVF6Vi5cCw=</Seed><PgenCounter>UQ==</PgenCounter><X>SFKXJnLYP8UM5tlOCpVQ0S2yE78=</X></DSAKeyValue>");
this.server.ConnectionAccepted += server_ConnectionAccepted;
this.server.Start();
}
public async Task <IActionResult> EditServer(SshServer server, bool remove = false)
{
if (!await CheckIfUserHasrights(server.Id))
{
return(Forbid());
}
ViewBag.Remove = remove;
server.HostingAvailable = ApiWithKeyController.ApiKeySet(_configuration);
server.LiteDbUsers = (await _userservice.FindAll()).ToList();
return(View("Server", server));
}
static void Main(string[] args)
{
var server = new SshServer();
server.AddHostKey("ssh-rsa", "BwIAAACkAABSU0EyAAQAAAEAAQADKjiW5UyIad8ITutLjcdtejF4wPA1dk1JFHesDMEhU9pGUUs+HPTmSn67ar3UvVj/1t/+YK01FzMtgq4GHKzQHHl2+N+onWK4qbIAMgC6vIcs8u3d38f3NFUfX+lMnngeyxzbYITtDeVVXcLnFd7NgaOcouQyGzYrHBPbyEivswsnqcnF4JpUTln29E1mqt0a49GL8kZtDfNrdRSt/opeexhCuzSjLPuwzTPc6fKgMc6q4MBDBk53vrFY2LtGALrpg3tuydh3RbMLcrVyTNT+7st37goubQ2xWGgkLvo+TZqu3yutxr1oLSaPMSmf9bTACMi5QDicB3CaWNe9eU73MzhXaFLpNpBpLfIuhUaZ3COlMazs7H9LCJMXEL95V6ydnATf7tyO0O+jQp7hgYJdRLR3kNAKT0HU8enE9ZbQEXG88hSCbpf1PvFUytb1QBcotDy6bQ6vTtEAZV+XwnUGwFRexERWuu9XD6eVkYjA4Y3PGtSXbsvhwgH0mTlBOuH4soy8MV4dxGkxM8fIMM0NISTYrPvCeyozSq+NDkekXztFau7zdVEYmhCqIjeMNmRGuiEo8ppJYj4CvR1hc8xScUIw7N4OnLISeAdptm97ADxZqWWFZHno7j7rbNsq5ysdx08OtplghFPx4vNHlS09LwdStumtUel5oIEVMYv+yWBYSPPZBcVY5YFyZFJzd0AOkVtUbEbLuzRs5AtKZG01Ip/8+pZQvJvdbBMLT1BUvHTrccuRbY03SHIaUM3cTUc=");
server.AddHostKey("ssh-dss", "BwIAAAAiAABEU1MyAAQAAG+6KQWB+crih2Ivb6CZsMe/7NHLimiTl0ap97KyBoBOs1amqXB8IRwI2h9A10R/v0BHmdyjwe0c0lPsegqDuBUfD2VmsDgrZ/i78t7EJ6Sb6m2lVQfTT0w7FYgVk3J1Deygh7UcbIbDoQ+refeRNM7CjSKtdR+/zIwO3Qub2qH+p6iol2iAlh0LP+cw+XlH0LW5YKPqOXOLgMIiO+48HZjvV67pn5LDubxru3ZQLvjOcDY0pqi5g7AJ3wkLq5dezzDOOun72E42uUHTXOzo+Ct6OZXFP53ZzOfjNw0SiL66353c9igBiRMTGn2gZ+au0jMeIaSsQNjQmWD+Lnri39n0gSCXurDaPkec+uaufGSG9tWgGnBdJhUDqwab8P/Ipvo5lS5p6PlzAQAAACqx1Nid0Ea0YAuYPhg+YolsJ/ce");
server.ConnectionAccepted += server_ConnectionAccepted;
server.Start();
Task.Delay(-1).Wait();
}
public static void StopSshServer()
{
if (_server == null)
{
return;
}
_server.Stop();
_server = null;
XTrace.WriteLine("SSH server stoped.");
}
public static void StopSshServer()
{
if (_server == null)
{
return;
}
_server.Stop();
_server = null;
Logger.Info("SSH server stoped.");
}
private static void GetConnectedClients(SshServer server)
{
var clients = server.GetConnectedClients();
foreach (var c in clients)
{
Console.WriteLine(c.Name);
var connections = c.Connections;
foreach (var connection in connections)
{
Console.WriteLine("---> " + connection.WhenConnected);
}
}
}
private static PavlovServer PavlovServer(SshServer sshServer)
{
return(new()
{
Name = "test",
TelnetPort = 9100,
DeletAfter = 7,
TelnetPassword = "******",
ServerPort = 9101,
ServerFolderPath = "/home/steam/pavlovserver",
ServerSystemdServiceName = "pavlovserver",
ServerType = ServerType.Community,
ServerServiceState = ServerServiceState.inactive,
SshServer = sshServer
});
}
public async Task <IActionResult> EditServer(int?serverId)
{
if (serverId != null && !await CheckIfUserHasrights((int)serverId))
{
return(Forbid());
}
var server = new SshServer();
if (serverId != null && serverId != 0)
{
server = await _service.FindOne((int)serverId);
}
if (server.Id == 0)
{
if (!HttpContext.User.IsInRole("Admin"))
{
return(Forbid());
}
}
ViewBag.Remove = false;
server.HostingAvailable = ApiWithKeyController.ApiKeySet(_configuration);
server.LiteDbUsers = (await _userservice.FindAll()).ToList();
return(View("Server", server));
}
public async Task <IActionResult> SaveServer(SshServer server)
{
if (!await CheckIfUserHasrights(server.Id))
{
return(Forbid());
}
var newServer = false;
if (!ModelState.IsValid)
{
return(View("Server", server));
}
server.LiteDbUsers = (await _userservice.FindAll()).ToList();
if (server.SshKeyFileNameForm != null)
{
await using var ms = new MemoryStream();
await server.SshKeyFileNameForm.CopyToAsync(ms);
var fileBytes = ms.ToArray();
server.SshKeyFileName = fileBytes;
// act on the Base64 data
}
if (server.SshKeyFileNameRootForHostingForm != null)
{
await using var ms = new MemoryStream();
await server.SshKeyFileNameRootForHostingForm.CopyToAsync(ms);
var fileBytes = ms.ToArray();
server.SshKeyFileNameRootForHosting = fileBytes;
// act on the Base64 data
}
server.Owner = (await _userservice.FindAll())
.FirstOrDefault(x => x.Id == new ObjectId(server.LiteDbUserId));
try
{
if (server.Id == 0)
{
newServer = true;
server.Id = await _service.Insert(server);
}
else
{
if (server.SshKeyFileName == null)
{
var old = await _service.FindOne(server.Id);
if (old.SshKeyFileName != null)
{
server.SshKeyFileName = old.SshKeyFileName;
}
}
await _service.Update(server);
}
}
catch (ValidateException e)
{
if (e.FieldName == "" && e.Message.ToLower().Contains("telnet"))
{
ModelState.AddModelError("Password", e.Message);
}
else if (e.FieldName == "" && e.Message.ToLower().Contains("ssh"))
{
ModelState.AddModelError("SshPassword", e.Message);
}
else if (e.FieldName == "")
{
ModelState.AddModelError("Id", e.Message);
}
else
{
ModelState.AddModelError(e.FieldName, e.Message);
}
}
if (ModelState.ErrorCount > 0)
{
if (newServer)
{
return(await EditServer(server));
}
return(await EditServer(server));
}
if (newServer)
{
return(await Index());
}
return(await Index());
}
/// <summary>
///
/// </summary>
/// <param name="server"></param>
/// <param name="reservedFor"></param>
/// <exception cref="CommandExceptionCreateServerDuplicate"></exception>
public async Task CreatePavlovServer(PavlovServerViewModel server, string reservedFor = "")
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Start creting server", LogEventLevel.Verbose,
_notifyService);
//Check stuff
var exist = RconStatic.DoesPathExist(server, server.ServerFolderPath, _notifyService);
if (exist)
{
throw new CommandExceptionCreateServerDuplicate("ServerFolderPath already exist!");
}
exist = RconStatic.DoesPathExist(server,
"/etc/systemd/system/" + server.ServerSystemdServiceName + ".service", _notifyService);
if (exist)
{
throw new CommandExceptionCreateServerDuplicate("Systemd Service already exist!");
}
var portsUsed = (await FindAll()).Where(x => x.SshServer.Id == server.SshServer.Id)
.FirstOrDefault(x => x.ServerPort == server.ServerPort || x.TelnetPort == server.TelnetPort);
if (portsUsed != null)
{
if (portsUsed.ServerPort == server.ServerPort)
{
throw new CommandExceptionCreateServerDuplicate("The server port is already used!");
}
if (portsUsed.TelnetPort == server.TelnetPort)
{
throw new CommandExceptionCreateServerDuplicate("The telnet port is already used!");
}
}
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Start Install pavlovserver", LogEventLevel.Verbose,
_notifyService);
DataBaseLogger.LogToDatabaseAndResultPlusNotify(
"Username used befor changed to root: " + server.SshServer.SshUsername, LogEventLevel.Verbose,
_notifyService);
await RconStatic.UpdateInstallPavlovServer(server, this);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Start Install pavlovserver service",
LogEventLevel.Verbose, _notifyService);
var oldSSHcrid = new SshServer
{
SshPassphrase = server.SshServer.SshPassphrase,
SshUsername = server.SshServer.SshUsername,
SshPassword = server.SshServer.SshPassword,
SshKeyFileName = server.SshServer.SshKeyFileName
};
server.SshServer.SshPassphrase = server.SshPassphraseRoot;
server.SshServer.SshUsername = server.SshUsernameRoot;
server.SshServer.SshPassword = server.SshPasswordRoot;
server.SshServer.SshKeyFileName = server.SshKeyFileNameRoot;
server.SshServer.NotRootSshUsername = oldSSHcrid.SshUsername;
try
{
await RconStatic.InstallPavlovServerService(server, _notifyService);
}
catch (CommandException e)
{
//If crash inside here the user login is still root. If the root login is bad this will fail to remove the server afterwards
OverwrideTheNormalSSHLoginData(server, oldSSHcrid);
DataBaseLogger.LogToDatabaseAndResultPlusNotify(
"Could not install service while creating the pavlov server -> " + e.Message, LogEventLevel.Verbose, _notifyService);
throw;
}
OverwrideTheNormalSSHLoginData(server, oldSSHcrid);
DataBaseLogger.LogToDatabaseAndResultPlusNotify(
"Username used after override old infos: " + server.SshServer.SshUsername, LogEventLevel.Verbose,
_notifyService);
//start server and stop server to get Saved folder etc.
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Start after install", LogEventLevel.Verbose,
_notifyService);
await RconStatic.SystemDStart(server, this);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("stop after install", LogEventLevel.Verbose,
_notifyService);
await RconStatic.SystemDStop(server, this);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Try to save game ini", LogEventLevel.Verbose,
_notifyService);
var pavlovServerGameIni = new PavlovServerGameIni();
DataBaseLogger.LogToDatabaseAndResultPlusNotify("created Ini", LogEventLevel.Verbose, _notifyService);
var selectedMaps = await _serverSelectedMapService.FindAllFrom(server);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("found maps", LogEventLevel.Verbose, _notifyService);
pavlovServerGameIni.ServerName = server.Name;
pavlovServerGameIni.SaveToFile(server, selectedMaps, _notifyService);
//also create rcon settings
DataBaseLogger.LogToDatabaseAndResultPlusNotify("write rcon file", LogEventLevel.Verbose,
_notifyService);
var lines = new List <string>
{
"Password="******"Port=" + server.TelnetPort
};
RconStatic.WriteFile(server.SshServer, server.ServerFolderPath + FilePaths.RconSettings,
lines.ToArray(), _notifyService);
}
public async Task RemovePavlovServerFromDisk(
PavlovServerViewModel server, bool ignoreMostExceptions)
{
//Todo AuthError??
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Start remove server!", LogEventLevel.Verbose,
_notifyService);
string result = "";
//start server and stop server to get Saved folder etc.
if (ignoreMostExceptions)
{
try
{
await RconStatic.SystemDStop(server, _pavlovServerService);
}
catch (CommandException)
{
//ignore
}
}
else
{
await RconStatic.SystemDStop(server, _pavlovServerService);
}
if (ignoreMostExceptions)
{
try
{
await RconStatic.RemovePath(server, server.ServerFolderPath, _pavlovServerService);
}
catch (CommandException)
{
//ignore
}
}
else
{
await RconStatic.RemovePath(server, server.ServerFolderPath, _pavlovServerService);
}
server.SshServer = await FindOne(server.sshServerId);
if (server.SshServer == null)
{
throw new CommandException("Could not get the sshServer!");
}
var oldSSHcrid = new SshServer
{
SshPassphrase = server.SshServer.SshPassphrase,
SshUsername = server.SshServer.SshUsername,
SshPassword = server.SshServer.SshPassword,
SshKeyFileName = server.SshServer.SshKeyFileName
};
server.SshServer.SshPassphrase = server.SshPassphraseRoot;
server.SshServer.SshUsername = server.SshUsernameRoot;
server.SshServer.SshPassword = server.SshPasswordRoot;
if (server.SshKeyFileNameForm != null)
{
await using var ms = new MemoryStream();
await server.SshKeyFileNameForm.CopyToAsync(ms);
var fileBytes = ms.ToArray();
server.SshKeyFileNameRoot = fileBytes;
// act on the Base64 data
}
server.SshServer.SshKeyFileName = server.SshKeyFileNameRoot;
server.SshServer.NotRootSshUsername = oldSSHcrid.SshUsername;
if (ignoreMostExceptions)
{
try
{
await RconStatic.RemovePath(server,
"/etc/systemd/system/" + server.ServerSystemdServiceName + ".service", _pavlovServerService);
}
catch (CommandException)
{
//ignore
}
}
else
{
await RconStatic.RemovePath(server,
"/etc/systemd/system/" + server.ServerSystemdServiceName + ".service", _pavlovServerService);
}
//Remove the server from the sudoers file
var sudoersPathParent = "/etc/sudoers.d";
var sudoersPath = sudoersPathParent + "/pavlovRconWebserverManagement";
var removed = true;
if (ignoreMostExceptions)
{
try
{
removed = RconStatic.RemoveServerLineToSudoersFile(server, _notifyService, sudoersPath, _pavlovServerService);
}
catch (CommandException)
{
//ignore
}
}
else
{
removed = RconStatic.RemoveServerLineToSudoersFile(server, _notifyService, sudoersPath, _pavlovServerService);
}
if (removed)
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify("server line removed from sudoers file!",
LogEventLevel.Verbose, _notifyService);
}
else
{
//means that the lines still is in the file!!!
var error =
"Could not remove the server line from sudoers file!";
DataBaseLogger.LogToDatabaseAndResultPlusNotify(error, LogEventLevel.Fatal, _notifyService);
if (!ignoreMostExceptions)
{
throw new CommandException(error);
}
}
//Handle the presets an newer systemd
if (ignoreMostExceptions)
{
try
{
RconStatic.AddLineToNewerSystemDsIfNeeded(server, _notifyService, true);
}
catch (CommandException)
{
//ignore
}
}
else
{
RconStatic.AddLineToNewerSystemDsIfNeeded(server, _notifyService, true);
}
DataBaseLogger.LogToDatabaseAndResultPlusNotify(result, LogEventLevel.Verbose, _notifyService);
}
private PavlovServerViewModel OverwrideTheNormalSSHLoginData(PavlovServerViewModel server, SshServer oldSSHcrid)
{
server.SshServer.SshPassphrase = oldSSHcrid.SshPassphrase;
server.SshServer.SshUsername = oldSSHcrid.SshUsername;
server.SshServer.SshPassword = oldSSHcrid.SshPassword;
server.SshServer.SshKeyFileName = oldSSHcrid.SshKeyFileName;
return(server);
}
