/// <summary>
/// Get a deployer for the installed application.
/// </summary>
/// <param name="globalSettings">The global settings.</param>
/// <param name="installedApplicationSettings">The installed application settings.</param>
/// <param name="logger">The logger.</param>
public ApplicationDeployer(
EnvironmentSettings globalSettings,
InstalledApplication installedApplicationSettings,
ILoggerInterface logger)
{
this.GlobalSettings = globalSettings;
this.installedAppSettings = installedApplicationSettings;
this.Logger = logger;
if (this.GlobalSettings == null)
{
throw new InvalidDataException("settings argument cannot be null.");
}
if (this.installedAppSettings == null)
{
throw new Exception("installedApplicationSettings argument cannot be null.");
}
// Try to grab previous deployment...
this.activeDeploymentPathStorage = UtilsSystem.CombinePaths(globalSettings.activeDeploymentDir, "active." + this.installedAppSettings.GetId() + ".json");
if (File.Exists(this.activeDeploymentPathStorage))
{
this.DeploymentActive = Deployment.InstanceFromPath(this.activeDeploymentPathStorage, globalSettings);
}
}
/// <summary>
///
/// </summary>
/// <param name="globalSettings"></param>
/// <param name="id"></param>
/// <returns></returns>
public static Deployment GetActiveDeploymentById(EnvironmentSettings globalSettings, string id)
{
List <Deployment> result = new List <Deployment>();
DirectoryInfo dir = new DirectoryInfo(globalSettings.activeDeploymentDir);
foreach (var f in dir.EnumerateFiles("active." + id + ".json"))
{
return(Deployment.InstanceFromPath(f.FullName, globalSettings));
}
return(null);
}
/// <summary>
/// Return a list of active deployments in the system.
/// </summary>
/// <returns></returns>
public static List <Deployment> GetActiveDeployments(EnvironmentSettings globalSettings)
{
List <Deployment> result = new List <Deployment>();
DirectoryInfo dir = new DirectoryInfo(globalSettings.activeDeploymentDir);
foreach (var f in dir.EnumerateFiles("active.*.json"))
{
result.Add(Deployment.InstanceFromPath(f.FullName, globalSettings));
}
return(result);
}
/// <summary>
/// Find the matching deployer of the parent application when
/// inheritance is configured for this application.
/// </summary>
/// <typeparam name="TType"></typeparam>
/// <returns></returns>
public TType getDeployerFromParentApp <TType>()
where TType : DeployerBase
{
// We need a parent application for this to work.
if (this.ParentApp == null)
{
return(null);
}
// Try to grab parent deployment...
Deployment parentDeployment;
string activeDeploymentPathStorage = UtilsSystem.CombinePaths(this.GlobalSettings.activeDeploymentDir, "active." + this.ParentApp.GetId() + ".json");
if (File.Exists(activeDeploymentPathStorage))
{
parentDeployment = Deployment.InstanceFromPath(activeDeploymentPathStorage, this.GlobalSettings);
DeployerSettingsBase ourSettings = this.DeployerSettings.castTo <DeployerSettingsBase>();
List <IDeployerInterface> deployersAndServices = new List <IDeployerInterface>();
deployersAndServices.AddRange(parentDeployment.GrabServices(this.Logger));
deployersAndServices.AddRange(parentDeployment.GrabDeployers(this.Logger));
// Only keep those that match our type
deployersAndServices = deployersAndServices.Where(s => s.GetType() == typeof(TType)).ToList();
// Filter by ID
foreach (TType t in deployersAndServices)
{
if (t.DeployerSettings.castTo <DeployerSettingsBase>().id == ourSettings.id)
{
return(t);
}
}
return(null);
}
else
{
return(null);
}
}
/// <summary>
/// Store a serialized version of this in a path
/// </summary>
/// <param name="path"></param>
public void StoreInPath(string path)
{
var temporaryPath = path + Guid.NewGuid() + ".tmp";
var backupPath = path + Guid.NewGuid() + ".bak";
UtilsSystem.EnsureDirectoryExists(path);
var serialized = JsonConvert.SerializeObject(
this,
Formatting.Indented,
new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
});
File.WriteAllText(temporaryPath, serialized);
try
{
Deployment.InstanceFromPath(temporaryPath, this.globalSettings);
}
catch (Exception e)
{
throw new Exception("Error while storing configuration file, corrupted file path: " + temporaryPath, e);
}
// Make this more robust, to avoid corrupted active configurations, we ensure that the active
// configuration can be read before setting it as active. File.Move() is less error to corruption
// than the actual writing to disk operation
if (File.Exists(path))
{
File.Move(path, backupPath);
}
File.Move(temporaryPath, path);
File.Delete(backupPath);
}
/// <summary>
/// Get a list of all currently installed applications.
/// </summary>
/// <returns></returns>
public List <InstalledApplication> GetInstalledApps(string identifiers = null)
{
List <InstalledApplication> apps = new List <InstalledApplication>();
string activeDeploymentPathStorage = this.GlobalSettings.activeDeploymentDir;
if (!Directory.Exists(activeDeploymentPathStorage))
{
throw new Exception("Active deployment path not found: " + activeDeploymentPathStorage);
}
foreach (var f in (new DirectoryInfo(activeDeploymentPathStorage)).EnumerateFiles("active.*.json"))
{
Deployment deployment = Deployment.InstanceFromPath(f.FullName, this.GlobalSettings);
if (string.IsNullOrWhiteSpace(identifiers) ||
this.ExplodeAndCleanList(identifiers, ",").Contains(deployment.installedApplicationSettings.GetId()))
{
apps.Add(deployment.installedApplicationSettings);
}
}
return(apps);
}