public ShellDescriptor Fetch(string name)
{
if (Disabled)
{
return(null);
}
lock (_synLock)
{
VerifyCacheFile();
var text = _appDataFolder.ReadFile(DescriptorCacheFileName);
var xmlDocument = new XmlDocument();
xmlDocument.LoadXml(text);
XmlNode rootNode = xmlDocument.DocumentElement;
if (rootNode != null)
{
foreach (XmlNode tenantNode in rootNode.ChildNodes)
{
if (String.Equals(tenantNode.Name, name, StringComparison.OrdinalIgnoreCase))
{
return(GetShellDecriptorForCacheText(tenantNode.InnerText));
}
}
}
return(null);
}
}
public void Release()
{
_rwLock.EnterWriteLock();
try
{
if (_released || !_appDataFolder.FileExists(_path))
{
// nothing to do, might happen if re-granted, and already released
return;
}
_released = true;
// check it has not been granted in the meantime
var current = _appDataFolder.ReadFile(_path);
if (current == _content)
{
_appDataFolder.DeleteFile(_path);
}
}
finally
{
_rwLock.ExitWriteLock();
}
}
public String GetInstanceId()
{
if (_instanceId.IsNullOrEmpty())
{
lock (this)
{
if (_instanceId.IsNullOrEmpty())
{
IAppDataFolder folder = _serviceProvider.GetRequiredService <IAppDataFolder>();
string id = ToolHelper.NewShortId();
string fileName = $"{_appName}.instance";
if (!folder.FileExists(fileName))
{
folder.CreateFile(fileName, id);
}
else
{
id = folder.ReadFile(fileName);
}
_instanceId = id;
}
}
}
return(_instanceId);
}
public RecipeStep Dequeue(string executionId)
{
if (!_appDataFolder.DirectoryExists(Path.Combine(_recipeQueueFolder, executionId)))
{
return(null);
}
RecipeStep recipeStep = null;
int stepIndex = GetFirstStepIndex(executionId);
if (stepIndex >= 0)
{
var stepPath = Path.Combine(_recipeQueueFolder, executionId + Path.DirectorySeparatorChar + stepIndex);
// string to xelement
var stepElement = XElement.Parse(_appDataFolder.ReadFile(stepPath));
var stepName = stepElement.Element("Name").Value;
recipeStep = new RecipeStep {
Name = stepName,
Step = stepElement.Element(stepName)
};
_appDataFolder.DeleteFile(stepPath);
}
if (stepIndex < 0)
{
_appDataFolder.DeleteFile(Path.Combine(_recipeQueueFolder, executionId));
}
return(recipeStep);
}
public IEnumerable <Report> Fetch()
{
lock ( _synLock ) {
if (!_appDataFolder.FileExists(_reportsFileName))
{
yield break;
}
var text = _appDataFolder.ReadFile(_reportsFileName);
var xmlDocument = XDocument.Parse(text);
var rootNode = xmlDocument.Root;
if (rootNode == null)
{
yield break;
}
foreach (var reportNode in rootNode.Elements())
{
var reader = new StringReader(reportNode.Value);
using (var xmlReader = XmlReader.Create(reader)) {
yield return((Report)_dataContractSerializer.ReadObject(xmlReader, true));
}
}
}
}
public RecipeStep Dequeue(string executionId)
{
Logger.Information("Dequeuing recipe steps.");
if (!_appDataFolder.DirectoryExists(Path.Combine(_recipeQueueFolder, executionId)))
{
return(null);
}
RecipeStep recipeStep = null;
int stepIndex = GetFirstStepIndex(executionId);
if (stepIndex >= 0)
{
var stepPath = Path.Combine(_recipeQueueFolder, executionId + Path.DirectorySeparatorChar + stepIndex);
// string to xelement
var stepElement = XElement.Parse(_appDataFolder.ReadFile(stepPath));
var stepName = stepElement.Element("Name").Value;
var stepId = stepElement.Attr("Id");
var recipeName = stepElement.Attr("RecipeName");
Logger.Information("Dequeuing recipe step '{0}'.", stepName);
recipeStep = new RecipeStep(id: stepId, recipeName: recipeName, name: stepName, step: stepElement.Element(stepName));
_appDataFolder.DeleteFile(stepPath);
}
if (stepIndex < 0)
{
_appDataFolder.DeleteFile(Path.Combine(_recipeQueueFolder, executionId));
}
return(recipeStep);
}
private IEnumerable <ShellSettings> LoadSettingsInternal()
{
var filePaths = _appDataFolder
.ListDirectories("Sites")
.SelectMany(path => _appDataFolder.ListFiles(path))
.Where(path => String.Equals(Path.GetFileName(path), SettingsFileName, StringComparison.OrdinalIgnoreCase));
foreach (var filePath in filePaths)
{
yield return(ShellSettingsSerializer.ParseSettings(_appDataFolder.ReadFile(filePath)));
}
}
/// <summary>
/// Loads the settings file or create a new default one if it doesn't exist
/// </summary>
public IndexSettings LoadSettings(string indexName)
{
var indexSettings = new IndexSettings();
var settingsFilename = GetSettingsFileName(indexName);
if (_appDataFolder.FileExists(settingsFilename))
{
var content = _appDataFolder.ReadFile(settingsFilename);
indexSettings = IndexSettings.Parse(content);
}
return(indexSettings);
}
public void FilesCanBeReadBack()
{
_appDataFolder.CreateFile("alpha\\gamma\\foo\\bar.txt", @"
this is
a
test");
var text = _appDataFolder.ReadFile("alpha\\gamma\\foo\\bar.txt");
Assert.That(text, Is.EqualTo(@"
this is
a
test"));
}
private bool IsLockedImpl(string path)
{
if (_appDataFolder.FileExists(path))
{
var content = _appDataFolder.ReadFile(path);
DateTime creationUtc;
if (DateTime.TryParse(content, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out creationUtc))
{
// if expired the file is not removed
// it should be automatically as there is a finalizer in LockFile
// or the next taker can do it, unless it also fails, again
return(creationUtc.ToUniversalTime().Add(Expiration) > _clock.UtcNow);
}
}
return(false);
}
private bool IsLockedImpl(string path)
{
if (appDataFolder.FileExists(path))
{
var content = appDataFolder.ReadFile(path);
DateTime creationUtc;
if (DateTime.TryParse(content, out creationUtc))
{
// if expired the file is not removed
// it should be automatically as there is a finalizer in LockFile
// or the next taker can do it, unless it also fails, again
return(creationUtc.Add(Expiration) > clock.UtcNow);
}
}
return(false);
}
public IEnumerable <ReportEntry> Read()
{
if (!_appDataFolder.FileExists(_warmupReportPath))
{
yield break;
}
var warmupReportContent = _appDataFolder.ReadFile(_warmupReportPath);
var doc = XDocument.Parse(warmupReportContent);
foreach (var entryNode in doc.Root.Descendants("ReportEntry"))
{
yield return(new ReportEntry {
CreatedUtc = XmlConvert.ToDateTime(entryNode.Attribute("CreatedUtc").Value, XmlDateTimeSerializationMode.Utc),
Filename = entryNode.Attribute("Filename").Value,
RelativeUrl = entryNode.Attribute("RelativeUrl").Value,
StatusCode = Int32.Parse(entryNode.Attribute("StatusCode").Value)
});
}
}
private string ReadFileSetting()
{
var content = "";
_encryptionKeys = new Dictionary <string, string>();
if (!_appDataFolder.FileExists(_filePath))
{
var key = "";
content = "TheDefaultChannel" + ":" + key + Environment.NewLine;
_encryptionKeys.Add("TheDefaultChannel", key);
_appDataFolder.CreateFile(_filePath, content);
}
else
{
var filecontent = _appDataFolder.ReadFile(_filePath);
var lines = filecontent.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
foreach (string line in lines)
{
var keyval = line.Split(':');
if (keyval.Length > 1)
{
if (!string.IsNullOrEmpty(line.Substring(keyval[0].Length + 1).Trim()))
{
_encryptionKeys.Add(keyval[0], line.Substring(keyval[0].Length + 1).Trim());
}
else
{
_encryptionKeys.Add(keyval[0], "");
}
}
}
content = filecontent;
}
_lastWriteTimedUtc = _appDataFolder.GetFileLastWriteTimeUtc(_filePath);
return(content);
}
public void ShouldDownloadConfiguredUrls()
{
_settings.Urls = @" /
/About";
_webDownloader
.Setup(w => w.Download("http://orchardproject.net/"))
.Returns(new DownloadResult {
Content = "Foo", StatusCode = HttpStatusCode.OK
});
_webDownloader
.Setup(w => w.Download("http://orchardproject.net/About"))
.Returns(new DownloadResult {
Content = "Bar", StatusCode = HttpStatusCode.OK
});
_warmupUpdater.Generate();
var files = _appDataFolder.ListFiles(WarmupFolder).ToList();
Assert.That(files, Has.Some.Matches <string>(x => x == _appDataFolder.Combine(WarmupFolder, WarmupUtility.EncodeUrl("http://orchardproject.net"))));
Assert.That(files, Has.Some.Matches <string>(x => x == _appDataFolder.Combine(WarmupFolder, WarmupUtility.EncodeUrl("http://orchardproject.net/About"))));
files = _appDataFolder.ListFiles(TenantFolder).ToList();
Assert.That(files, Has.Some.Matches <string>(x => x == _appDataFolder.Combine(TenantFolder, "warmup.txt")));
Assert.That(files, Has.Some.Matches <string>(x => x == _appDataFolder.Combine(TenantFolder, "warmup.xml")));
var homepageContent = _appDataFolder.ReadFile(_appDataFolder.Combine(WarmupFolder, WarmupUtility.EncodeUrl("http://orchardproject.net")));
var aboutcontent = _appDataFolder.ReadFile(_appDataFolder.Combine(WarmupFolder, WarmupUtility.EncodeUrl("http://orchardproject.net/About")));
Assert.That(homepageContent, Is.EqualTo("Foo"));
Assert.That(aboutcontent, Is.EqualTo("Bar"));
}
public void EnsureGenerate()
{
var baseUrl = _orchardServices.WorkContext.CurrentSite.BaseUrl;
var part = _orchardServices.WorkContext.CurrentSite.As <WarmupSettingsPart>();
// do nothing while the base url setting is not defined
if (String.IsNullOrWhiteSpace(baseUrl))
{
return;
}
// prevent multiple appdomains from rebuilding the static page concurrently (e.g., command line)
ILockFile lockFile = null;
if (!_lockFileManager.TryAcquireLock(_lockFilename, ref lockFile))
{
return;
}
using (lockFile) {
// check if we need to regenerate the pages by reading the last time it has been done
// 1- if the warmup file doesn't exists, generate the pages
// 2- otherwise, if the scheduled generation option is on, check if the delay is over
if (_appDataFolder.FileExists(_warmupPath))
{
try {
var warmupContent = _appDataFolder.ReadFile(_warmupPath);
var expired = XmlConvert.ToDateTimeOffset(warmupContent).AddMinutes(part.Delay);
if (expired > _clock.UtcNow)
{
return;
}
}
catch {
// invalid file, delete continue processing
_appDataFolder.DeleteFile(_warmupPath);
}
}
// delete peviously generated pages, by reading the Warmup Report file
try {
var encodedPrefix = WarmupUtility.EncodeUrl("http://www.");
foreach (var reportEntry in _reportManager.Read())
{
try {
// use FileName as the SiteBaseUrl could have changed in the meantime
var path = _appDataFolder.Combine(BaseFolder, reportEntry.Filename);
_appDataFolder.DeleteFile(path);
// delete the www-less version too if it's available
if (reportEntry.Filename.StartsWith(encodedPrefix, StringComparison.OrdinalIgnoreCase))
{
var filename = WarmupUtility.EncodeUrl("http://") + reportEntry.Filename.Substring(encodedPrefix.Length);
path = _appDataFolder.Combine(BaseFolder, filename);
_appDataFolder.DeleteFile(path);
}
}
catch (Exception e) {
Logger.Error(e, "Could not delete specific warmup file: ", reportEntry.Filename);
}
}
}
catch (Exception e) {
Logger.Error(e, "Could not read warmup report file");
}
var reportEntries = new List <ReportEntry>();
if (!String.IsNullOrEmpty(part.Urls))
{
// loop over every relative url to generate the contents
using (var urlReader = new StringReader(part.Urls)) {
string relativeUrl;
while (null != (relativeUrl = urlReader.ReadLine()))
{
if (String.IsNullOrWhiteSpace(relativeUrl))
{
continue;
}
string url = null;
relativeUrl = relativeUrl.Trim();
try {
url = VirtualPathUtility.RemoveTrailingSlash(baseUrl) + relativeUrl;
var filename = WarmupUtility.EncodeUrl(url.TrimEnd('/'));
var path = _appDataFolder.Combine(BaseFolder, filename);
var download = _webDownloader.Download(url);
if (download != null)
{
if (download.StatusCode == HttpStatusCode.OK)
{
// success
_appDataFolder.CreateFile(path, download.Content);
reportEntries.Add(new ReportEntry {
RelativeUrl = relativeUrl,
Filename = filename,
StatusCode = (int)download.StatusCode,
CreatedUtc = _clock.UtcNow
});
// if the base url contains http://www, then also render the www-less one);
if (url.StartsWith("http://www.", StringComparison.OrdinalIgnoreCase))
{
url = "http://" + url.Substring("http://www.".Length);
filename = WarmupUtility.EncodeUrl(url.TrimEnd('/'));
path = _appDataFolder.Combine(BaseFolder, filename);
_appDataFolder.CreateFile(path, download.Content);
}
}
else
{
reportEntries.Add(new ReportEntry {
RelativeUrl = relativeUrl,
Filename = filename,
StatusCode = (int)download.StatusCode,
CreatedUtc = _clock.UtcNow
});
}
}
else
{
// download failed
reportEntries.Add(new ReportEntry {
RelativeUrl = relativeUrl,
Filename = filename,
StatusCode = 0,
CreatedUtc = _clock.UtcNow
});
}
}
catch (Exception e) {
Logger.Error(e, "Could not extract warmup page content for: ", url);
}
}
}
}
_reportManager.Create(reportEntries);
// finally write the time the generation has been executed
_appDataFolder.CreateFile(_warmupPath, XmlConvert.ToString(_clock.UtcNow, XmlDateTimeSerializationMode.Utc));
}
}
