public Tree LoadTreeFromDom(string treeId, XDocument document)
{
string xslFilename = Path.Combine(TreeDefinitionsFolder, XslFilename);
var fileInfo = new C1FileInfo(xslFilename);
// The default xslt transformation does no changes and it's xsl file has size of 358 bytes, skipping this file saves up to 0.5 second on site startup
if (fileInfo.Exists && fileInfo.Length != 358)
{
try
{
var newDocument = new XDocument();
using (XmlWriter xmlWriter = newDocument.CreateWriter())
{
var xslTransform = new XslCompiledTransform();
xslTransform.LoadFromPath(xslFilename);
xslTransform.Transform(document.CreateReader(), xmlWriter);
}
document = newDocument;
}
catch (Exception ex)
{
Log.LogCritical("TreeFacade", "Failed to apply xslt on the tree {0} with the following exception", treeId);
Log.LogCritical("TreeFacade", ex);
}
}
return(Load(treeId, document));
}
private static XDocument TryLoad(C1FileInfo candidateFile)
{
XDocument dataDocument = null;
try
{
XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();
xmlReaderSettings.CheckCharacters = false;
using (XmlReader xmlReader = XmlReaderUtils.Create(candidateFile.FullName, xmlReaderSettings))
{
dataDocument = XDocument.Load(xmlReader);
}
}
catch (Exception)
{
// broken file - should not stop us...
}
return(dataDocument);
}
public IEnumerable <SiteUpdateInformation> GetUpdateSummaries(Guid installationId)
{
var basePath = PathUtil.Resolve(_location);
var folder = Path.Combine(basePath, installationId.ToString());
var list = new List <SiteUpdateInformation>();
if (!Directory.Exists(folder))
{
return(list);
}
var files = C1Directory.GetFiles(folder, "*.zip");
foreach (var f in files)
{
try
{
var fi = new C1FileInfo(f);
var packageInformation = PackageSystemServices.GetPackageInformationFromZipfile(f);
var changelog = ZipFileHelper.GetContentFromFile(f, "changelog.txt");
list.Add(new SiteUpdateInformation
{
Id = packageInformation.Id,
InstallationId = installationId,
FileName = fi.Name,
Name = packageInformation.Name,
Version = packageInformation.Version,
ReleasedDate = fi.CreationTime,
ChangeLog = changelog
});
}
catch { }
}
return(list);
}
private static XDocument TryLoad(C1FileInfo candidateFile, ref string errorCause)
{
XDocument dataDocument = null;
try
{
var xmlReaderSettings = new XmlReaderSettings {
CheckCharacters = false
};
using (XmlReader xmlReader = XmlReaderUtils.Create(candidateFile.FullName, xmlReaderSettings))
{
dataDocument = XDocument.Load(xmlReader);
}
}
catch (Exception ex)
{
errorCause = ex.Message;
// broken file - should not stop us...
}
return(dataDocument);
}
/// <summary>
/// Will pull up most recent from disk - if no good file is found an empty store will be constructed anyway
/// </summary>
/// <param name="filePath"></param>
/// <param name="elementName"></param>
/// <param name="keyGetter"></param>
/// <returns></returns>
private static FileRecord LoadFileRecordFromDisk(string filePath, string elementName, Func <XElement, IDataId> keyGetter)
{
XDocument dataDocument = null;
C1FileInfo usedFile = null;
IList <C1FileInfo> candidateFiles = GetCandidateFiles(filePath);
foreach (C1FileInfo candidateFile in candidateFiles)
{
bool tryLoad = true;
while (tryLoad && dataDocument == null)
{
dataDocument = TryLoad(candidateFile);
if (dataDocument == null)
{
if ((DateTime.Now - candidateFile.LastWriteTime).TotalSeconds > 30)
{
tryLoad = false;
}
else
{
Thread.Sleep(250); // other processes/servers may be writing to this file at the moment. Patience young padawan!
}
}
}
if (dataDocument != null)
{
usedFile = candidateFile;
break;
}
}
if (dataDocument == null)
{
dataDocument = new XDocument(new XElement("fallback"));
Log.LogWarning(LogTitle, "Did not find a healthy XML document for '{0}' - creating an empty store.", filePath);
}
List <XElement> elements = ExtractElements(dataDocument);
var index = new Hashtable <IDataId, XElement>(elements.Count);
foreach (var element in elements)
{
IDataId id = keyGetter(element);
if (!index.ContainsKey(id))
{
index.Add(id, element);
}
else
{
Log.LogWarning(LogTitle, "Found multiple elements in '{0}' sharing same key - duplicates ignored.", filePath);
}
}
if (usedFile != null)
{
// clean up old and unused files
foreach (C1FileInfo file in candidateFiles.Where(f => f.LastWriteTime < usedFile.LastWriteTime))
{
try
{
C1File.Move(file.FullName, file.FullName + ".ghost");
}
catch (Exception)
{
Log.LogWarning(LogTitle, "Failed to clean up ghost file '{0}'.", filePath);
}
}
}
DateTime lastModifiedFileDate = usedFile != null ? usedFile.LastWriteTime : DateTime.Now;
return(new FileRecord
{
FilePath = filePath,
ElementName = elementName,
RecordSet = new RecordSet {
Index = index
},
ReadOnlyElementsList = new List <XElement>(elements),
LastModified = DateTime.Now,
FileModificationDate = lastModifiedFileDate
});
}
protected string CreateBackup()
{
var Url = Request.Url;
string zipFilename = Url.Scheme + "_" + Url.Host + (Url.IsDefaultPort ? "" : (" " + Url.Port)) + "_" +
DateTime.Now.ToString("yyyy_MM.dd_HHmm") + ".zip";
string zipFilePath = PathCombine(BackupDirectory, zipFilename);
string backupDirectory = Path.GetDirectoryName(zipFilePath);
if (!C1Directory.Exists(backupDirectory))
{
C1Directory.CreateDirectory(backupDirectory);
}
var filenames = GetFilesRecursive(BaseDirectory);
var directories = GetDirectoriesRecursive(BaseDirectory);
lock (_lock)
{
using (var archiveFileStream = FileCreate(zipFilePath))
using (var archive = new ZipArchive(archiveFileStream, ZipArchiveMode.Create))
{
int oldScriptTimeOut = Server.ScriptTimeout;
Server.ScriptTimeout = ScriptTimeoutInSeconds;
foreach (string directory in directories)
{
if (directory.Contains(BackupDirectoryRelativePath))
{
continue;
}
string directoryEntryName = directory.Replace(BaseDirectory, "").Replace("\\", "/") + "/";
var dirEntry = archive.CreateEntry(directoryEntryName);
dirEntry.LastWriteTime = Directory.GetLastWriteTime(directory);
}
foreach (string file in filenames)
{
if (file.Contains(BackupDirectoryRelativePath) || IsTemporaryDirectory(file))
{
continue;
}
string fileEntryName = file.Replace(BaseDirectory, "").Replace("\\", "/");
var entry = archive.CreateEntry(fileEntryName, BackupCompressionLevel);
try
{
var fi = new C1FileInfo(file);
entry.LastWriteTime = fi.LastWriteTime;
using (var fileStream = C1File.OpenRead(file))
using (var entryStream = entry.Open())
{
fileStream.CopyTo(entryStream);
}
}
catch (Exception e)
{
if (!file.Contains("App_Data\\Composite\\LogFiles"))
{
this.Validators.Add(new ErrorSummary(e.Message));
}
}
}
Server.ScriptTimeout = oldScriptTimeOut;
}
}
return(zipFilename);
}