/// <exclude />
public static void ApplicationStartInitialize(bool displayDebugInfo = false)
{
ThreadDataManager.InitializeThroughHttpContext();
if (displayDebugInfo)
{
Log.LogVerbose("Global.asax", "--- Web Application Start, {0} Id = {1} ---", DateTime.Now.ToLongTimeString(), AppDomain.CurrentDomain.Id);
}
PerformanceCounterFacade.SystemStartupIncrement();
using (GlobalInitializerFacade.GetPreInitHandlersScope())
{
ApplicationStartupFacade.FireConfigureServices(ServiceLocator.ServiceCollection);
ServiceLocator.BuildServiceProvider();
ServiceLocator.CreateRequestServicesScope(HttpContext.Current);
ApplicationStartupFacade.FireBeforeSystemInitialize(ServiceLocator.ServiceProvider);
}
TempDirectoryFacade.OnApplicationStart();
HostnameBindingsFacade.Initialize();
ApplicationStartupFacade.FireSystemInitialized(ServiceLocator.ServiceProvider);
ThreadDataManager.FinalizeThroughHttpContext();
}
/// <exclude />
public static void Application_End(object sender, EventArgs e)
{
if (RuntimeInformation.IsDebugBuild)
{
Log.LogInformation(_verboseLogEntryTitle, "AppDomain {0} ended at {1} in process {2}", AppDomain.CurrentDomain.Id, DateTime.Now.ToString("HH:mm:ss:ff"), Process.GetCurrentProcess().Id);
}
if (!SystemSetupFacade.IsSystemFirstTimeInitialized)
{
return;
}
using (ThreadDataManager.Initialize())
{
try
{
CodeGenerationManager.ValidateCompositeGenerate(_startTime);
CodeGenerationManager.GenerateCompositeGeneratedAssembly();
}
catch (Exception ex)
{
Log.LogCritical("Global.asax", "Error updating Composite.Generated.dll");
Log.LogCritical("Global.asax", ex);
}
try
{
GlobalEventSystemFacade.PrepareForShutDown();
if (RuntimeInformation.IsDebugBuild)
{
LogShutDownReason();
}
GlobalEventSystemFacade.ShutDownTheSystem();
TempDirectoryFacade.OnApplicationEnd();
}
catch (Exception ex)
{
Log.LogCritical("Global.asax", ex);
throw;
}
Log.LogVerbose("Global.asax", string.Format("--- Web Application End, {0} Id = {1}---",
DateTime.Now.ToLongTimeString(),
AppDomain.CurrentDomain.Id));
}
}
/// <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));;
}
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);
}
/*
* Moth knows about the ugly parameters, please refactor!
* We should probably supply XSLT params by webcontrol markup...
*/
public static MemoryStream Transform(MemoryStream buffer, String mode, String browser, String platform)
{
var readerSettings = new XmlReaderSettings();
readerSettings.XmlResolver = null;
readerSettings.DtdProcessing = DtdProcessing.Parse;
readerSettings.CheckCharacters = false;
List <string> xsltFilePaths = GetTransformationsInPriority().ToList();
if (xsltFilePaths.Count == 0)
{
return(buffer);
}
// Detection doctype
buffer.Seek(0, SeekOrigin.Begin);
var line = new C1StreamReader(buffer).ReadLine();
var doctype = line.Contains("<!DOCTYPE");
buffer.Seek(0, SeekOrigin.Begin);
MemoryStream outputStream = null;
int xsltCount = xsltFilePaths.Count;
for (int i = 0; i < xsltCount; i++)
{
string xsltFilePath = xsltFilePaths[i];
bool isFirst = (i == 0);
MemoryStream inputStream = isFirst ? buffer : outputStream;
inputStream.Position = 0;
outputStream = new MemoryStream();
/*
* Hardcoding a parameter for masterfilter.xsl
* TODO: parametersetup in webcontrol markup!
*/
var transformer = GetCachedTransformation(xsltFilePath);
var argList = new XsltArgumentList();
if (!string.IsNullOrEmpty(mode))
{
argList.AddParam("mode", "", mode);
}
if (!string.IsNullOrEmpty(browser))
{
argList.AddParam("browser", "", browser);
}
if (!string.IsNullOrEmpty(platform))
{
argList.AddParam("platform", "", platform);
}
argList.AddParam("version", "", RuntimeInformation.ProductVersion.ToString());
argList.AddParam("doctype", "", doctype.ToString());
argList.AddParam("appVirtualPath", "", GetAppRootPath());
var reader = XmlReader.Create(inputStream, readerSettings);
var writer = XmlWriter.Create(outputStream, transformer.OutputSettings);
try
{
transformer.Transform(reader, argList, writer);
}
catch (XmlException xmlException)
{
string tempFilePath = TempDirectoryFacade.GetTempFileName(".xml");
inputStream.Position = 0;
string markup = new C1StreamReader(inputStream).ReadToEnd();
C1File.WriteAllText(tempFilePath, markup);
throw new InvalidOperationException(
"Incorrect xml markup, source saved in '{0}'".FormatWith(tempFilePath),
xmlException);
}
}
Verify.That(outputStream != null, "NullRef");
return(outputStream);
}
/// <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)
}));
}
}
/// <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));
}
}
