public async Task <PalaceServer.Models.AvailablePackage> GetAvailablePackage(Models.MicroServiceSettings microServiceSettings)
{
var httpClient = HttpClientFactory.CreateClient("PalaceServer");
var url = $"{PalaceSettings.UpdateServerUrl}/api/microservices/info/{microServiceSettings.PackageFileName}";
HttpResponseMessage response = null;
try
{
response = await httpClient.GetAsync(url);
}
catch (Exception ex)
{
ex.Data.Add("url", url);
Logger.LogError(ex, ex.Message);
}
if (response == null ||
response.StatusCode != System.Net.HttpStatusCode.OK)
{
return(null);
}
var remoteServiceInfo = await response.Content.ReadFromJsonAsync <PalaceServer.Models.AvailablePackage>();
return(remoteServiceInfo);
}
public async Task <PalaceServer.Models.NextActionResult> GetNextAction(Models.MicroServiceSettings microServiceSettings)
{
var httpClient = HttpClientFactory.CreateClient("PalaceServer");
httpClient.BaseAddress = new Uri(PalaceSettings.UpdateServerUrl);
HttpResponseMessage response = null;
try
{
var url = $"/api/microservices/getnextaction/{microServiceSettings.ServiceName}";
response = await httpClient.GetAsync(url);
}
catch (Exception ex)
{
Logger.LogError(ex, ex.Message);
return(null);
}
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
Logger.LogWarning($"get nextaction for {microServiceSettings.ServiceName} return bad status code {response.StatusCode}");
return(null);
}
var result = await response.Content.ReadFromJsonAsync <PalaceServer.Models.NextActionResult>();
Logger.LogDebug($"Next action for {microServiceSettings.ServiceName} : {result.Action}");
return(result);
}
public async Task <PalaceClient.StopResult> StopRunningMicroService(Models.MicroServiceSettings microServiceSettings)
{
HttpResponseMessage response = null;
try
{
Logger.LogInformation("Try to stop service {0}", microServiceSettings.ServiceName);
var httpClient = CreateHttpClient(microServiceSettings);
var url = $"{microServiceSettings.AdminServiceUrl}/api/palace/stop";
response = await httpClient.GetAsync(url);
}
catch (Exception ex)
{
ex.Data.Add("url", microServiceSettings.AdminServiceUrl);
ex.Data.Add("certificate", microServiceSettings.SSLCertificate);
Logger.LogError(ex, ex.Message);
return(null);
}
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
Logger.LogWarning("Stop service {0} failed", microServiceSettings.ServiceName);
return(null);
}
var result = await response.Content.ReadFromJsonAsync <PalaceClient.StopResult>();
return(result);
}
public Models.MicroServiceInfo GetLocallyInstalledMicroServiceInfo(Models.MicroServiceSettings microServiceSettings)
{
Models.MicroServiceInfo result = null;
var directoryName = System.IO.Path.Combine(PalaceSettings.InstallationDirectory, microServiceSettings.ServiceName);
var mainAssemblyFileName = System.IO.Path.Combine(directoryName, microServiceSettings.MainAssembly.Replace(@".\", ""));
var fileInfo = new System.IO.FileInfo(mainAssemblyFileName);
if (!fileInfo.Exists)
{
return(null);
}
result = new Models.MicroServiceInfo
{
InstallationFolder = directoryName,
MainFileName = microServiceSettings.MainAssembly,
Arguments = microServiceSettings.Arguments,
Name = microServiceSettings.ServiceName,
LocalInstallationExists = true,
LastWriteTime = fileInfo.LastWriteTime
};
return(result);
}
public async Task AddOrUpdateService(Models.MicroServiceSettings serviceSettings)
{
var httpClient = HttpClientFactory.CreateClient("PalaceServer");
var response = await httpClient.PostAsJsonAsync("/api/microservices/addorupdateservicesettings", serviceSettings);
response.EnsureSuccessStatusCode();
}
public Task <bool> UninstallMicroService(Models.MicroServiceSettings microServiceSettings)
{
bool uninstallSuccess = true;
var directory = System.IO.Path.Combine(PalaceSettings.InstallationDirectory, microServiceSettings.ServiceName);
var fileList = System.IO.Directory.GetFiles(directory, "*.*", System.IO.SearchOption.AllDirectories);
var directoryList = System.IO.Directory.GetDirectories(directory, "*.*", SearchOption.AllDirectories);
Logger.LogInformation($"try to remove {fileList.Count()} files from {microServiceSettings.InstallationFolder}");
foreach (var removeFile in fileList)
{
try
{
System.IO.File.Delete(removeFile);
}
catch (Exception ex)
{
Logger.LogError(ex, ex.Message);
uninstallSuccess = false;
}
}
foreach (var removeDirectory in directoryList)
{
try
{
System.IO.Directory.Delete(removeDirectory);
}
catch (Exception ex)
{
Logger.LogError(ex, ex.Message);
uninstallSuccess = false;
}
}
try
{
System.IO.Directory.Delete(directory, true);
}
catch (Exception ex)
{
ex.Data.Add("Directory", directory);
Logger.LogError(ex, ex.Message);
uninstallSuccess = false;
}
return(Task.FromResult(uninstallSuccess));
}
public IActionResult AddService([FromHeader] string authorization, Models.MicroServiceSettings serviceSettings)
{
EnsureGoodAuthorization(authorization);
var palaceInfo = PalaceInfoManager.GetOrCreatePalaceInfo(HttpContext.GetUserAgent(), HttpContext.GetUserHostAddress());
if (palaceInfo == null)
{
return(NoContent());
}
var result = PalaceInfoManager.SaveMicroServiceSettings(palaceInfo, serviceSettings);
if (result.Count > 0)
{
BadRequest(result);
}
return(Ok());
}
public bool KillProcess(Models.MicroServiceSettings settings)
{
return(true);
var processList = Process.GetProcesses();
if (!processList.Any())
{
Logger.LogWarning("Could not find any dotnet.exe process in this machine");
return(false);
}
try
{
foreach (var p in processList)
{
if (p.ProcessName.IndexOf("dotnet") != -1)
{
string arguments = null;
try
{
arguments = p.StartInfo.Arguments;
}
catch
{
}
Logger.LogWarning("Try to kill process {0}", p.Id);
}
Logger.LogDebug(p.ProcessName);
}
var process = processList.FirstOrDefault(p => p.StartInfo.Arguments.Contains(settings.MainAssembly));
process.Kill(true);
Logger.LogWarning("Try to kill service {0} on processId {1}", settings.ServiceName, process.Id);
process.Kill(true);
return(true);
}
catch (Exception ex)
{
Logger.LogError(ex, ex.Message);
}
return(false);
}
public HttpClient CreateHttpClient(Models.MicroServiceSettings microServiceSettings)
{
var handler = new HttpClientHandler();
Version httpVersion = null;
if (microServiceSettings.AdminServiceUrl.StartsWith("https") &&
!string.IsNullOrWhiteSpace(microServiceSettings.SSLCertificate))
{
if (System.IO.File.Exists(microServiceSettings.SSLCertificate))
{
var certificate = new X509Certificate2(microServiceSettings.SSLCertificate);
handler.ClientCertificates.Add(certificate);
handler.ServerCertificateCustomValidationCallback = (sender, certificate, chain, errors) =>
{
if (errors == System.Net.Security.SslPolicyErrors.RemoteCertificateNotAvailable)
{
return(false);
}
return(true);
};
}
else
{
Logger.LogWarning("SSLCertifiate filename does not exists {0}", microServiceSettings.SSLCertificate);
}
httpVersion = new Version(2, 0);
}
var httpClient = new HttpClient(handler);
if (httpVersion != null)
{
httpClient.DefaultRequestVersion = httpVersion;
}
httpClient.DefaultRequestHeaders.Add("Authorization", $"Basic {microServiceSettings.PalaceApiKey}");
return(httpClient);
}
private Dictionary <string, List <string> > UpdateMicroServiceSettings(Models.PalaceInfo palaceInfo, Models.MicroServiceSettings settings)
{
var existing = palaceInfo.MicroServiceSettingsList.FirstOrDefault(i => i.ServiceName == settings.ServiceName);
bool isDirty = false;
if (existing.AdminServiceUrl != settings.AdminServiceUrl)
{
isDirty = true;
}
existing.AdminServiceUrl = settings.AdminServiceUrl;
if (existing.AlwaysStarted != settings.AlwaysStarted)
{
isDirty = true;
}
existing.AlwaysStarted = settings.AlwaysStarted;
if (existing.Arguments != settings.Arguments)
{
isDirty = true;
}
existing.Arguments = settings.Arguments;
if (existing.InstallationFolder != settings.InstallationFolder)
{
isDirty = true;
}
existing.InstallationFolder = settings.InstallationFolder;
if (existing.MainAssembly != settings.MainAssembly)
{
isDirty = true;
}
existing.MainAssembly = settings.MainAssembly;
if (existing.PackageFileName != settings.PackageFileName)
{
isDirty = true;
}
existing.PackageFileName = settings.PackageFileName;
if (existing.PalaceApiKey != settings.PalaceApiKey)
{
isDirty = true;
}
existing.PalaceApiKey = settings.PalaceApiKey;
if (existing.ServiceName != settings.ServiceName)
{
isDirty = true;
}
existing.ServiceName = settings.ServiceName;
if (existing.SSLCertificate != settings.SSLCertificate)
{
isDirty = true;
}
existing.SSLCertificate = settings.SSLCertificate;
if (existing.InstanceCount != settings.InstanceCount)
{
isDirty = true;
}
existing.InstanceCount = settings.InstanceCount;
if (existing.MaxWorkingSetLimitBeforeAlert != settings.MaxWorkingSetLimitBeforeAlert)
{
isDirty = true;
}
existing.MaxWorkingSetLimitBeforeAlert = settings.MaxWorkingSetLimitBeforeAlert;
if (existing.MaxWorkingSetLimitBeforeRestart != settings.MaxWorkingSetLimitBeforeRestart)
{
isDirty = true;
}
existing.MaxWorkingSetLimitBeforeRestart = settings.MaxWorkingSetLimitBeforeRestart;
if (existing.ThreadLimitBeforeAlert != settings.ThreadLimitBeforeAlert)
{
isDirty = true;
}
existing.ThreadLimitBeforeAlert = settings.ThreadLimitBeforeAlert;
if (existing.ThreadLimitBeforeRestart != settings.ThreadLimitBeforeRestart)
{
isDirty = true;
}
existing.ThreadLimitBeforeRestart = settings.ThreadLimitBeforeRestart;
if (existing.NotRespondingCountBeforeAlert != settings.NotRespondingCountBeforeAlert)
{
isDirty = true;
}
existing.NotRespondingCountBeforeAlert = settings.NotRespondingCountBeforeAlert;
if (existing.NotRespondingCountBeforeRestart != settings.NotRespondingCountBeforeRestart)
{
isDirty = true;
}
existing.NotRespondingCountBeforeRestart = settings.NotRespondingCountBeforeRestart;
if (isDirty)
{
palaceInfo.LastConfigurationUpdate = DateTime.Now;
SaveConfiguration(palaceInfo);
}
return(new Dictionary <string, List <string> >());
}
private Dictionary <string, List <string> > AddMicroServiceSettings(Models.PalaceInfo palaceInfo, Models.MicroServiceSettings settings)
{
((List <Models.MicroServiceSettings>)palaceInfo.MicroServiceSettingsList).Add(settings);
palaceInfo.LastConfigurationUpdate = DateTime.Now;
SaveConfiguration(palaceInfo);
return(new Dictionary <string, List <string> >());
}
internal Dictionary <string, List <string> > SaveMicroServiceSettings(Models.PalaceInfo palaceInfo, Models.MicroServiceSettings settings)
{
var validation = Validate(settings);
if (!validation.IsValid)
{
return(validation.BrokenRules);
}
Dictionary <string, List <string> > result = null;
var existing = palaceInfo.MicroServiceSettingsList.FirstOrDefault(i => i.ServiceName == settings.ServiceName);
if (existing == null)
{
result = AddMicroServiceSettings(palaceInfo, settings);
}
else
{
result = UpdateMicroServiceSettings(palaceInfo, settings);
}
return(result);
}
internal (bool IsValid, Dictionary <string, List <string> > BrokenRules) Validate(Models.MicroServiceSettings mss)
{
var result = true;
var brokenRules = new Dictionary <string, List <string> >();
if (string.IsNullOrWhiteSpace(mss.ServiceName))
{
brokenRules.Add("ServiceName", new List <string>
{
{ "Service name is null or empty" }
});
result = false;
}
if (string.IsNullOrWhiteSpace(mss.MainAssembly))
{
brokenRules.Add(nameof(mss.MainAssembly), new List <string>
{
{ "MainAssembly is null or empty" }
});
result = false;
}
if (string.IsNullOrWhiteSpace(mss.PackageFileName))
{
brokenRules.Add(nameof(mss.PackageFileName), new List <string>
{
{ "PackageFileName is null or empty" }
});
result = false;
}
else if (!mss.PackageFileName.EndsWith(".zip", StringComparison.InvariantCultureIgnoreCase))
{
brokenRules.Add(nameof(mss.PackageFileName), new List <string>
{
{ "PackageFileName is not zip file" }
});
result = false;
}
if (string.IsNullOrWhiteSpace(mss.AdminServiceUrl))
{
brokenRules.Add(nameof(mss.AdminServiceUrl), new List <string>
{
{ "AdminServiceUrl is null or empty" }
});
result = false;
}
else
{
try
{
new Uri(mss.AdminServiceUrl);
}
catch
{
brokenRules.Add(nameof(mss.AdminServiceUrl), new List <string>
{
{ "AdminServiceUrl is not valid uri" }
});
result = false;
}
}
return(result, brokenRules);
}
public void Remove(Models.MicroServiceSettings item)
{
_list.TryRemove(item.ServiceName, out var removed);
}
public async Task <bool> InstallMicroService(Models.MicroServiceInfo microServiceInfo, Models.MicroServiceSettings serviceSettings)
{
microServiceInfo.InstallationFolder = System.IO.Path.Combine(PalaceSettings.InstallationDirectory, serviceSettings.ServiceName);
microServiceInfo.MainFileName = serviceSettings.MainAssembly;
microServiceInfo.Arguments = serviceSettings.Arguments;
Logger.LogInformation("Try to install MicroService{0} in {1}", microServiceInfo.MainFileName, microServiceInfo.InstallationFolder);
// On recupere le zip sur le serveur
var zipFileInfo = await DownloadPackage(serviceSettings.PackageFileName);
if (zipFileInfo == null)
{
Logger.LogWarning("Download zipfile for service {0} failed", microServiceInfo.Name);
return(false);
}
var version = 1;
string extractDirectory = null;
while (true)
{
// Dezip dans son répertoire avec la bonne version
extractDirectory = System.IO.Path.Combine(PalaceSettings.DownloadDirectory, microServiceInfo.Name, $"v{version}");
if (Directory.Exists(extractDirectory))
{
version++;
continue;
}
break;
}
Logger.LogWarning("Extact zipfile {0} for service {1} in directory {2}", zipFileInfo.ZipFileName, microServiceInfo.Name, extractDirectory);
if (!System.IO.Directory.Exists(extractDirectory))
{
System.IO.Directory.CreateDirectory(extractDirectory);
}
System.IO.Compression.ZipFile.ExtractToDirectory(zipFileInfo.ZipFileName, extractDirectory, true);
// Deploy dans son repertoire d'installation
var deploySuccess = await DeployMicroService(microServiceInfo, extractDirectory);
return(deploySuccess);
}
