/// <exclude />
public object Deserialize(string serializedObject)
{
Dictionary <string, string> dic = StringConversionServices.ParseKeyValueCollection(serializedObject);
string zipFilename = StringConversionServices.DeserializeValueString(dic["ZipFileName"]);
string packageInstallDirectory = StringConversionServices.DeserializeValueString(dic["PackageInstallDirectory"]);
bool hasBeenValidated = StringConversionServices.DeserializeValueBool(dic["HasBeenValidated"]);
string originalPackageInstallDirectory = null;
string serializedValue;
if (dic.TryGetValue("OriginalPackageInstallDirectory", out serializedValue))
{
originalPackageInstallDirectory = StringConversionServices.DeserializeValueString(serializedValue);
}
if (C1File.Exists(zipFilename))
{
XElement installContent;
XmlHelper.LoadInstallXml(zipFilename, out installContent);
PackageInformation packageInformation;
PackageManager.ValidatePackageInformation(installContent, out packageInformation);
string packageZipFilename = Path.Combine(packageInstallDirectory, Path.GetFileName(zipFilename));
C1File.Copy(zipFilename, packageZipFilename, true);
var packageInstaller = new PackageInstaller(new PackageInstallerUninstallerFactory(), packageZipFilename, packageInstallDirectory, TempDirectoryFacade.CreateTempDirectory(), packageInformation);
var packageManagerInstallProcess = new PackageManagerInstallProcess(
packageInstaller,
packageInformation.SystemLockingType,
zipFilename,
packageInstallDirectory,
packageInformation.Name,
packageInformation.Version,
packageInformation.Id,
originalPackageInstallDirectory);
if (hasBeenValidated)
{
packageManagerInstallProcess.Validate();
}
return(packageManagerInstallProcess);
}
return(new PackageManagerInstallProcess(new List <PackageFragmentValidationResult>(), null));;
}
/// <exclude />
public static PackageManagerUninstallProcess Uninstall(Guid id)
{
try
{
string absolutePath = Path.Combine(PathUtil.Resolve(GlobalSettingsFacade.PackageDirectory), id.ToString());
InstalledPackageInformation installedPackageInformation =
(from package in GetInstalledPackages()
where package.Id == id
select package).SingleOrDefault();
if (installedPackageInformation == null)
{
return(new PackageManagerUninstallProcess(new List <PackageFragmentValidationResult> {
new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingPackageDirectory"), absolutePath))
}));
}
Log.LogVerbose("PackageManager", "Uninstalling package: {0}, Id = {1}", installedPackageInformation.Name, installedPackageInformation.Id);
if (installedPackageInformation.CanBeUninstalled == false)
{
return(new PackageManagerUninstallProcess(new List <PackageFragmentValidationResult> {
new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, GetText("PackageManager.Uninstallable"))
}));
}
string zipFilePath = Path.Combine(absolutePath, PackageSystemSettings.ZipFilename);
if (C1File.Exists(zipFilePath) == false)
{
return(new PackageManagerUninstallProcess(new List <PackageFragmentValidationResult> {
new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingZipFile"), zipFilePath))
}));
}
string uninstallFilePath = Path.Combine(absolutePath, PackageSystemSettings.UninstallFilename);
if (C1File.Exists(uninstallFilePath) == false)
{
return(new PackageManagerUninstallProcess(new List <PackageFragmentValidationResult> {
new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingUninstallFile"), uninstallFilePath))
}));
}
PackageInformation packageInformation = new PackageInformation
{
Id = installedPackageInformation.Id,
Name = installedPackageInformation.Name,
GroupName = installedPackageInformation.GroupName,
Author = installedPackageInformation.Author,
Website = installedPackageInformation.Website,
Description = installedPackageInformation.Description,
Version = installedPackageInformation.Version,
CanBeUninstalled = installedPackageInformation.CanBeUninstalled,
SystemLockingType = installedPackageInformation.SystemLockingType,
FlushOnCompletion = installedPackageInformation.FlushOnCompletion,
ReloadConsoleOnCompletion = installedPackageInformation.ReloadConsoleOnCompletion,
};
PackageUninstaller packageUninstaller = new PackageUninstaller(zipFilePath, uninstallFilePath, absolutePath, TempDirectoryFacade.CreateTempDirectory(), installedPackageInformation.FlushOnCompletion, installedPackageInformation.ReloadConsoleOnCompletion, true, packageInformation);
PackageManagerUninstallProcess packageManagerUninstallProcess = new PackageManagerUninstallProcess(packageUninstaller, absolutePath, installedPackageInformation.SystemLockingType);
return(packageManagerUninstallProcess);
}
catch (Exception ex)
{
return(new PackageManagerUninstallProcess(new List <PackageFragmentValidationResult> {
new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, ex)
}));
}
}
private PackageFragmentValidationResult DoInstall()
{
using (var transactionScope = TransactionsFacade.Create(true, TimeSpan.FromMinutes(30.0)))
{
string uninstallFilename = Path.Combine(this.PackageInstallDirectory,
PackageSystemSettings.UninstallFilename);
Exception installException = null;
XElement uninstallElements =
new XElement(XmlUtils.GetXName(PackageSystemSettings.XmlNamespace,
PackageSystemSettings.PackageFragmentUninstallersElementName));
try
{
foreach (var kvp in _packageFramentInstallers)
{
List <XElement> uninstallInformation = kvp.Key.Install().ToList();
if (this.CanBeUninstalled)
{
XElement uninstallElement =
new XElement(XmlUtils.GetXName(PackageSystemSettings.XmlNamespace,
PackageSystemSettings.
PackageFragmentUninstallersAddElementName));
uninstallElement.Add(new XAttribute(PackageSystemSettings.UninstallerTypeAttributeName,
TypeManager.SerializeType(kvp.Value)));
uninstallElement.Add(uninstallInformation);
uninstallElements.Add(uninstallElement);
}
}
}
catch (Exception ex)
{
installException = ex;
LoggingService.LogError("Package installation failed", ex);
}
finally
{
if (this.CanBeUninstalled)
{
XDocument doc =
new XDocument(
new XElement(
XmlUtils.GetXName(PackageSystemSettings.XmlNamespace,
PackageSystemSettings.PackageInstallerElementName),
uninstallElements));
doc.SaveToFile(uninstallFilename);
}
}
if (installException != null)
{
if (this.CanBeUninstalled)
{
IPackageUninstaller packageUninstaller =
this.PackageInstallerUninstallerFactory.CreateUninstaller(
this.ZipFilename, uninstallFilename,
this.PackageInstallDirectory,
TempDirectoryFacade.
CreateTempDirectory(),
this.FlushOnCompletion,
this.ReloadConsoleOnCompletion,
false,
this.PackageInformation);
List <PackageFragmentValidationResult> validationResult = null;
try
{
validationResult = packageUninstaller.Validate().ToList();
}
catch (Exception ex)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, ex));
}
if (validationResult.Count == 0)
{
try
{
packageUninstaller.Uninstall(SystemLockingType.None);
}
catch (Exception ex)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, ex));
}
}
else
{
LoggingService.LogError(LogTitle, "Failed to perform installation rollback.");
foreach (var valResult in validationResult)
{
if (valResult.Exception != null)
{
LoggingService.LogError(LogTitle, new InvalidOperationException(valResult.Message ?? string.Empty, valResult.Exception));
}
else
{
LoggingService.LogWarning(LogTitle, valResult.Message);
}
}
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal,
"Could not perform installation rollback. The details are in the log.")
{
InnerResult = validationResult
});
}
}
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal,
installException));
}
transactionScope.Complete();
}
return(null);
}
/// <exclude />
public static PackageManagerInstallProcess Install(Stream zipFileStream, bool isLocalInstall, string packageServerAddress)
{
if (!isLocalInstall && string.IsNullOrEmpty(packageServerAddress))
{
throw new ArgumentException("Non local install needs a packageServerAddress");
}
string zipFilename = null;
try
{
PackageFragmentValidationResult packageFragmentValidationResult = SaveZipFile(zipFileStream, out zipFilename);
if (packageFragmentValidationResult != null)
{
return(new PackageManagerInstallProcess(new List <PackageFragmentValidationResult> {
packageFragmentValidationResult
}, null));
}
XElement installContent;
packageFragmentValidationResult = XmlHelper.LoadInstallXml(zipFilename, out installContent);
if (packageFragmentValidationResult != null)
{
return(new PackageManagerInstallProcess(new List <PackageFragmentValidationResult> {
packageFragmentValidationResult
}, zipFilename));
}
PackageInformation packageInformation;
packageFragmentValidationResult = ValidatePackageInformation(installContent, out packageInformation);
if (packageFragmentValidationResult != null)
{
return(new PackageManagerInstallProcess(new List <PackageFragmentValidationResult> {
packageFragmentValidationResult
}, zipFilename));
}
if (RuntimeInformation.ProductVersion < packageInformation.MinCompositeVersionSupported ||
RuntimeInformation.ProductVersion > packageInformation.MaxCompositeVersionSupported)
{
return(new PackageManagerInstallProcess(new List <PackageFragmentValidationResult>
{
new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal,
Texts.PackageManager_CompositeVersionMisMatch(
RuntimeInformation.ProductVersion,
packageInformation.MinCompositeVersionSupported,
packageInformation.MaxCompositeVersionSupported))
}, zipFilename));
}
bool updatingInstalledPackage = false;
if (IsInstalled(packageInformation.Id))
{
string currentVersionString = GetCurrentVersion(packageInformation.Id);
Version currentVersion = new Version(currentVersionString);
Version newVersion = new Version(packageInformation.Version);
if (newVersion <= currentVersion)
{
string validationError = newVersion == currentVersion
? Texts.PackageManager_PackageAlreadyInstalled
: Texts.PackageManager_NewerVersionInstalled;
return(new PackageManagerInstallProcess(
new List <PackageFragmentValidationResult>
{
new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, validationError)
}, zipFilename));
}
updatingInstalledPackage = true;
}
string originalInstallDirectory = null;
string packageInstallDirectory = CreatePackageDirectoryName(packageInformation);
if (updatingInstalledPackage)
{
originalInstallDirectory = packageInstallDirectory;
packageInstallDirectory += "-" + packageInformation.Version;
}
C1Directory.CreateDirectory(packageInstallDirectory);
string packageZipFilename = Path.Combine(packageInstallDirectory, Path.GetFileName(zipFilename));
C1File.Copy(zipFilename, packageZipFilename, true);
string username = "******";
if (UserValidationFacade.IsLoggedIn())
{
username = UserValidationFacade.GetUsername();
}
var doc = new XDocument();
XElement packageInfoElement = new XElement(XmlUtils.GetXName(PackageSystemSettings.XmlNamespace, PackageSystemSettings.PackageInfoElementName));
doc.Add(packageInfoElement);
packageInfoElement.Add(
new XAttribute(PackageSystemSettings.PackageInfo_NameAttributeName, packageInformation.Name),
new XAttribute(PackageSystemSettings.PackageInfo_GroupNameAttributeName, packageInformation.GroupName),
new XAttribute(PackageSystemSettings.PackageInfo_VersionAttributeName, packageInformation.Version),
new XAttribute(PackageSystemSettings.PackageInfo_AuthorAttributeName, packageInformation.Author),
new XAttribute(PackageSystemSettings.PackageInfo_WebsiteAttributeName, packageInformation.Website),
new XAttribute(PackageSystemSettings.PackageInfo_DescriptionAttributeName, packageInformation.Description),
new XAttribute(PackageSystemSettings.PackageInfo_InstallDateAttributeName, DateTime.Now),
new XAttribute(PackageSystemSettings.PackageInfo_InstalledByAttributeName, username),
new XAttribute(PackageSystemSettings.PackageInfo_IsLocalInstalledAttributeName, isLocalInstall),
new XAttribute(PackageSystemSettings.PackageInfo_CanBeUninstalledAttributeName, packageInformation.CanBeUninstalled),
new XAttribute(PackageSystemSettings.PackageInfo_FlushOnCompletionAttributeName, packageInformation.FlushOnCompletion),
new XAttribute(PackageSystemSettings.PackageInfo_ReloadConsoleOnCompletionAttributeName, packageInformation.ReloadConsoleOnCompletion),
new XAttribute(PackageSystemSettings.PackageInfo_SystemLockingAttributeName, packageInformation.SystemLockingType.Serialize()));
if (!string.IsNullOrEmpty(packageServerAddress))
{
packageInfoElement.Add(new XAttribute(PackageSystemSettings.PackageInfo_PackageServerAddressAttributeName, packageServerAddress));
}
string infoFilename = Path.Combine(packageInstallDirectory, PackageSystemSettings.PackageInformationFilename);
doc.SaveToFile(infoFilename);
var packageInstaller = new PackageInstaller(new PackageInstallerUninstallerFactory(), packageZipFilename, packageInstallDirectory, TempDirectoryFacade.CreateTempDirectory(), packageInformation);
return(new PackageManagerInstallProcess(
packageInstaller,
packageInformation.SystemLockingType,
zipFilename,
packageInstallDirectory,
packageInformation.Name,
packageInformation.Version,
packageInformation.Id,
originalInstallDirectory));
}
catch (Exception ex)
{
return(new PackageManagerInstallProcess(new List <PackageFragmentValidationResult>
{
new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, ex)
}, zipFilename));
}
}