private void InitializeFile(ConfigurationPart part, IDictionary <string, string> query, string key)
{
FilePart filePart;
int id;
var file = query[key] ?? "0";
if (int.TryParse(file, out id))
{
if (id > 0)
{
filePart = _fileService.Get(id) ?? CreateOutputFile(part);
}
else
{
filePart = CreateOutputFile(part);
}
}
else
{
if (file.IndexOfAny(Path.GetInvalidPathChars()) == -1 && _appDataFolder.FileExists(file))
{
filePart = _fileService.Create(file);
}
else
{
Logger.Error("File '{0}' passed into process is invalid!", file);
return;
}
}
query[key] = filePart.FullPath;
}
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 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 void Monitor(Action <IVolatileToken> monitor)
{
if (!_appDataFolder.FileExists(fileName))
{
TouchFile();
}
monitor(_appDataFolder.WhenPathChanges(fileName));
}
/// <summary>
/// 监控动作。
/// </summary>
/// <param name="monitor">监控动作。</param>
public void Monitor(Action <IVolatileToken> monitor)
{
if (!_appDataFolder.FileExists(FileName))
{
TouchFile();
}
Logger.Debug("监控虚拟路径 \"{0}\"", FileName);
monitor(_appDataFolder.WhenPathChanges(FileName));
}
public void Monitor(Action <IVolatileToken> monitor)
{
if (!_appDataFolder.FileExists(fileName))
{
TouchFile();
}
Logger.Debug("Monitoring virtual path \"{0}\"", fileName);
monitor(_appDataFolder.WhenPathChanges(fileName));
}
public void Remove(string key)
{
var hash = GetCacheItemFileHash(key);
lock (String.Intern(hash)) {
Retry(() => {
var filename = _appDataFolder.Combine(_metadata, hash);
if (_appDataFolder.FileExists(filename))
{
_appDataFolder.DeleteFile(filename);
}
});
Retry(() => {
var filename = _appDataFolder.Combine(_content, hash);
if (_appDataFolder.FileExists(filename))
{
_appDataFolder.DeleteFile(filename);
}
});
}
}
private ConfigurationCache ReadConfiguration(string hash)
{
if (!_hostEnvironment.IsFullTrust)
{
return(null);
}
var pathName = GetPathName(_shellSettings.Name);
if (!_appDataFolder.FileExists(pathName))
{
return(null);
}
try
{
var formatter = new BinaryFormatter();
using (var stream = _appDataFolder.OpenFile(pathName))
{
// if the stream is empty, stop here
if (stream.Length == 0)
{
return(null);
}
var oldHash = (string)formatter.Deserialize(stream);
if (hash != oldHash)
{
Logger.Information("The cached NHibernate configuration is out of date. A new one will be re-generated.");
return(null);
}
var oldConfig = (Configuration)formatter.Deserialize(stream);
return(new ConfigurationCache
{
Hash = oldHash,
Configuration = oldConfig
});
}
}
catch (Exception e)
{
for (var scan = e; scan != null; scan = scan.InnerException)
{
Logger.Warning("Error reading the cached NHibernate configuration: {0}", scan.Message);
}
Logger.Information("A new one will be re-generated.");
return(null);
}
}
/// <summary>
/// Creates an empty cache file if it doesn't exist already
/// </summary>
private void VerifyCacheFile()
{
if (!_appDataFolder.FileExists(DescriptorCacheFileName))
{
var writer = new StringWriter();
using (var xmlWriter = XmlWriter.Create(writer)) {
xmlWriter.WriteStartDocument();
xmlWriter.WriteStartElement("Tenants");
xmlWriter.WriteEndElement();
xmlWriter.WriteEndDocument();
}
_appDataFolder.CreateFile(DescriptorCacheFileName, writer.ToString());
}
}
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);
}
/// <summary>
/// Creates an empty cache file if it doesn't exist already
/// </summary>
private void VerifyCacheFile()
{
if (!_appDataFolder.FileExists(DescriptorCacheFileName))
{
using (var writer = new StringWriter())
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
using (var xmlWriter = XmlWriter.Create(writer, settings))
{
xmlWriter.WriteStartDocument();
xmlWriter.WriteStartElement("Tenants");
xmlWriter.WriteEndElement();
xmlWriter.WriteEndDocument();
}
_appDataFolder.CreateFile(DescriptorCacheFileName, writer.ToString());
}
}
}
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)
});
}
}
public async Task <String> GetDataAsync(string blockName)
{
IAppDataFolder folder = _dataFolderFactory();
string file = $@"DebugDistributedStore/{blockName}.txt";
if (folder.FileExists(file))
{
string text = File.ReadAllText(file);
return(await Task.FromResult(text));
}
else
{
using (var stream = File.Create(file))
{
using (var streamWriter = new StreamWriter(stream))
{
streamWriter.Write(this.FirstCreationData);
}
}
return(await Task.FromResult(this.FirstCreationData));
}
}
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 bool AssemblyExists(string moduleName)
{
var path = PrecompiledAssemblyPath(moduleName);
return(_appDataFolder.FileExists(path));
}
/// <summary>
/// 程序集是否存在。
/// </summary>
/// <param name="descriptor">程序集描述符。</param>
/// <returns>true为存在，false为不存在。</returns>
public bool AssemblyExists(AssemblyDescriptor descriptor)
{
var path = PrecompiledAssemblyPath(descriptor);
return(_appDataFolder.FileExists(path));
}
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));
}
}
public void FileExistsReturnsFalseForNonExistingFile()
{
Assert.Equal(_appDataFolder.FileExists("notexisting"), false);
}
public void FileExistsReturnsFalseForNonExistingFile()
{
Assert.That(_appDataFolder.FileExists("notexisting"), Is.False);
}
