/// <exclude /> public static XslCompiledTransform GetCompiledXsltTransform(string stylesheetPath) { lock (_lock) { DateTime lastXsltFileWrite = C1File.GetLastWriteTime(stylesheetPath); bool compiledVersionExists = _xsltLookup.ContainsKey(stylesheetPath); bool reloadFresh = (DateTime.Now - lastXsltFileWrite).Minutes < 30; if (compiledVersionExists == false || lastXsltFileWrite > _xsltFileTimestamps[stylesheetPath] || reloadFresh) { XslCompiledTransform xslt = new XslCompiledTransform(); using (XmlReader reader = XmlReaderUtils.Create(stylesheetPath)) { xslt.Load(reader); } if (compiledVersionExists) { _xsltLookup.Remove(stylesheetPath); _xsltFileTimestamps.Remove(stylesheetPath); } _xsltLookup.Add(stylesheetPath, xslt); _xsltFileTimestamps.Add(stylesheetPath, lastXsltFileWrite); } } return(_xsltLookup[stylesheetPath]); }
protected void Page_Load(object sender, EventArgs e) { var xsdFiles = C1Directory.GetFiles(this.MapPath(""), "*.xsd"); XElement xsdFilesTable = new XElement("table", new XElement("tr", new XElement("td", "Namespace"), new XElement("td", "Last generated"))); foreach (string xsdFile in xsdFiles) { DateTime lastWrite = C1File.GetLastWriteTime(xsdFile); XDocument schemaDocument = XDocumentUtils.Load(xsdFile); string targetNamespace = schemaDocument.Root.Attribute("targetNamespace").Value; xsdFilesTable.Add( new XElement("tr", new XElement("td", new XElement("a", new XAttribute("href", Path.GetFileName(xsdFile)), targetNamespace)), new XElement("td", lastWrite))); } XsdTable.Controls.Add(new LiteralControl(xsdFilesTable.ToString())); GenerateButton.Click += new EventHandler(GenerateButton_Click); }
private void DeleteOldWorkflows() { using (GlobalInitializerFacade.CoreIsInitializedScope) { foreach (string filename in C1Directory.GetFiles(SerializedWorkflowsDirectory)) { DateTime creationTime = C1File.GetLastWriteTime(filename); if (DateTime.Now.Subtract(creationTime) > OldFileExistenceTimeout) { Guid instanceId = new Guid(Path.GetFileNameWithoutExtension(filename)); if (Path.GetExtension(filename) == "bin") { try { WorkflowRuntime.GetWorkflow(instanceId); AbortWorkflow(instanceId); } catch (Exception) { } } C1File.Delete(filename); Log.LogVerbose(LogTitle, $"Old workflow instance file deleted {filename}"); } } } }
/// <summary> /// Returns strings for the specified culture or null if no strings exists. /// </summary> private Dictionary <string, string> GetStringsForCulture(CultureInfo cultureInfo) { Dictionary <string, string> stringDictionary; using (_resourceLocker.Locker) { if (_resourceLocker.Resources.CultureFileLastUpdated.ContainsKey(cultureInfo)) { string unresolvedFileName = _resourceLocker.Resources.CultureToFileLookup[cultureInfo]; string resolvedFileName = PathUtil.Resolve(unresolvedFileName); DateTime lastWrite = C1File.GetLastWriteTime(resolvedFileName); double secondsSinceLastWrite = (DateTime.Now - lastWrite).TotalSeconds; if (secondsSinceLastWrite < 300 || lastWrite > _resourceLocker.Resources.CultureFileLastUpdated[cultureInfo]) { _resourceLocker.Resources.CultureToTranslation.Remove(cultureInfo); _resourceLocker.Resources.CultureFileLastUpdated[cultureInfo] = lastWrite; } } if (_resourceLocker.Resources.CultureToTranslation.TryGetValue(cultureInfo, out stringDictionary) == false) { string unresolvedFileName; if (_resourceLocker.Resources.CultureToFileLookup.TryGetValue(cultureInfo, out unresolvedFileName) == false) { return(null); } string resolvedFileName = PathUtil.Resolve(unresolvedFileName); XElement strings = XElementUtils.Load(resolvedFileName); stringDictionary = new Dictionary <string, string>(); foreach (XElement stringElement in strings.Elements()) { XAttribute keyAttribute = stringElement.Attribute("key"); XAttribute valueAttribute = stringElement.Attribute("value"); if (keyAttribute != null && valueAttribute != null) { if (stringDictionary.ContainsKey(keyAttribute.Value)) { throw new InvalidOperationException(string.Format("Duplicate string resource key '{0}' in XML file '{1}'", keyAttribute.Value, unresolvedFileName)); } stringDictionary.Add(keyAttribute.Value, valueAttribute.Value); } else { LoggingService.LogError("XmlStringResourceProvider", string.Format("Invalid entry '{0}' in file '{1}'", stringElement.ToString(SaveOptions.DisableFormatting), unresolvedFileName)); } } _resourceLocker.Resources.CultureToTranslation.Add(cultureInfo, stringDictionary); } } return(stringDictionary); }
private static void OnFileExternallyChanged(string filePath, FileChangeType changeType) { filePath = filePath.ToLowerInvariant(); var fileRecord = _cache[filePath]; if (fileRecord == null || fileRecord.FileModificationDate == DateTime.MinValue || C1File.GetLastWriteTime(filePath) == fileRecord.FileModificationDate) { // Ignoring this notification since it's very very probably caused by XmlDataProvider itself return; } lock (_documentEditingSyncRoot) { lock (_cacheSyncRoot) { fileRecord = _cache[filePath]; if (fileRecord == null || fileRecord.FileModificationDate == DateTime.MinValue || C1File.GetLastWriteTime(filePath) == fileRecord.FileModificationDate) { // Ignoring this notification since it's very very probably caused by XmlDataProvider itself return; } _cache.Remove(filePath); Log.LogVerbose(LogTitle, "File '{0}' changed by another process. Flushing cache.", filePath); if (_externalFileChangeActions.Any(f => f.Key == filePath)) { var actions = _externalFileChangeActions.Where(f => f.Key == filePath).Select(f => f.Value).ToList(); foreach (var action in actions) { action.Invoke(); } } else { Log.LogWarning(LogTitle, "File '{0}' has not been related to a scope - unable to raise store change event", filePath); } } } }
/// <exclude /> public static void OnApplicationEnd() { // Deleting everything that is older than 24 hours string tempDirectoryName = TempDirectoryPath; if (!C1Directory.Exists(tempDirectoryName)) { return; } foreach (string filename in C1Directory.GetFiles(tempDirectoryName)) { try { if (DateTime.Now > C1File.GetLastWriteTime(filename) + TemporaryFileExpirationTimeSpan) { C1File.Delete(filename); } } catch { } } foreach (string directoryPath in C1Directory.GetDirectories(tempDirectoryName)) { try { if (DateTime.Now > C1Directory.GetCreationTime(directoryPath) + TemporaryFileExpirationTimeSpan) { C1Directory.Delete(directoryPath, true); } } catch { } } }
public XmlStringResourceProvider(string defaultCultureName, Dictionary <CultureInfo, string> cultureToFileLookup, Dictionary <CultureInfo, bool> watchForFileChanges, string providerName) { using (_resourceLocker.Locker) { _providerName = providerName; _resourceLocker.Resources.DefaultCulture = new CultureInfo(defaultCultureName); _resourceLocker.Resources.CultureToFileLookup = cultureToFileLookup; foreach (CultureInfo watchedCulture in watchForFileChanges.Where(f => f.Value).Select(f => f.Key)) { string unresolvedFileName; if (_resourceLocker.Resources.CultureToFileLookup.TryGetValue(watchedCulture, out unresolvedFileName)) { string resolvedFileName = PathUtil.Resolve(unresolvedFileName); DateTime lastWrite = C1File.GetLastWriteTime(resolvedFileName); _resourceLocker.Resources.CultureFileLastUpdated.Add(watchedCulture, lastWrite); } } } }
/// <summary> /// Add assemblies that are loaded in the app domain. /// </summary> /// <param name="compilerParameters">The compiler parameters.</param> /// <param name="includeAppCode">if set to <c>true</c> reference to App_Code will be included to results.</param> public static void AddLoadedAssemblies(this CompilerParameters compilerParameters, bool includeAppCode) { Dictionary <string, string> foundAssemblyLocations = new Dictionary <string, string>(); IEnumerable <Assembly> assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(AssemblyHasLocation); if (!includeAppCode) { assemblies = assemblies.Where(asm => !asm.GetName().Name.StartsWith("App_Code")); } IEnumerable <string> locations = assemblies.Select(a => a.Location); foreach (string location in locations) { string locationKey = Path.GetFileName(location).ToLowerInvariant(); if (foundAssemblyLocations.ContainsKey(locationKey) == false) { foundAssemblyLocations.Add(locationKey, location); } else { string currentUsedLocation = foundAssemblyLocations[locationKey]; DateTime currentlyUsedLastWrite = C1File.GetLastWriteTime(currentUsedLocation); DateTime locationCandidateLastWrite = C1File.GetLastWriteTime(location); if (locationCandidateLastWrite > currentlyUsedLastWrite) { foundAssemblyLocations.Remove(locationKey); foundAssemblyLocations.Add(locationKey, location); } } } compilerParameters.ReferencedAssemblies.AddRangeIfNotContained(foundAssemblyLocations.Values); }
void OnFileWatcherEvent(object sender, FileSystemEventArgs e) { FileSystemEventHandler hander = FileChangedEvent; if (hander != null) { lock (_fileUpdateLock) { bool fileExists = true; if (fileExists) { // Supress multiple events fireing by observing last write time DateTime writeTime = C1File.GetLastWriteTime(e.FullPath); if (_lastWriteHandleTime < writeTime) { _lastWriteHandleTime = writeTime; try { using (ThreadDataManager.EnsureInitialize()) { hander(sender, e); } } catch (ThreadAbortException) { } catch (Exception ex) { Log.LogWarning(LogTitle, "Failed to reload functions on file watcher event"); Log.LogError(LogTitle, ex); } } } } } }
/// <summary> /// Validates that the current Composite.Generated.dll is not compiled after the given /// time. If it is compiled after the given time. Any attempts to recompile Composite.Generated.dll /// will be ignored. This is used to stop app domains from shutting each other down by recompiles. /// </summary> /// <param name="time"></param> internal static void ValidateCompositeGenerate(DateTime time) { if (SuppressGeneration) { return; } string filePath = Path.Combine(PathUtil.BaseDirectory, "Bin", "Composite.Generated.dll"); if (!C1File.Exists(filePath)) { return; } DateTime lastWrite = C1File.GetLastWriteTime(filePath); if (lastWrite <= time) { return; } _compositeGeneratedCompiled = true; Log.LogVerbose(LogTitle, $"Assembly in this application domain is newer than this application domain ({AppDomain.CurrentDomain.Id})"); }
private static StartupHandlerInfo[] GetSubscribedTypes( string filePath, List <AssemblyInfo> cachedTypesInfo, ref bool cacheHasBeenUpdated) { string assemblyName = Path.GetFileNameWithoutExtension(filePath); foreach (string assemblyToIgnore in AssembliesToIgnore) { if (assemblyName == assemblyToIgnore || assemblyName.StartsWith(assemblyToIgnore + ",") || (assemblyToIgnore.EndsWith(".") && assemblyName.StartsWith(assemblyToIgnore))) { return(null); } } DateTime modificationDate = C1File.GetLastWriteTime(filePath); var cachedInfo = cachedTypesInfo.FirstOrDefault(asm => asm.AssemblyName == assemblyName); if (cachedInfo != null) { if (cachedInfo.LastModified == modificationDate) { string[] subscribedTypesNames = cachedInfo.SubscribedTypes; if (subscribedTypesNames.Length == 0) { return(new StartupHandlerInfo[0]); } var asm = Assembly.LoadFrom(filePath); return((from typeName in subscribedTypesNames let type = asm.GetType(typeName) where type != null let attribute = type.GetCustomAttributes(false) .OfType <ApplicationStartupAttribute>() .FirstOrDefault() where attribute != null select new StartupHandlerInfo(type, attribute)).ToArray()); } // Removing cache entry if it is obsolete cachedTypesInfo.Remove(cachedInfo); } Assembly assembly; try { assembly = Assembly.LoadFrom(filePath); } catch (ReflectionTypeLoadException ex) { Log.LogWarning(LogTitle, "Failed to load assembly '{0}'".FormatWith(filePath)); if (ex.LoaderExceptions != null && ex.LoaderExceptions.Length > 0) { Log.LogError(LogTitle, ex.LoaderExceptions[0]); } return(null); } if (!AssemblyFacade.AssemblyPotentiallyUsesType(assembly, typeof(ApplicationStartupAttribute))) { return(null); } Type[] types; if (!TryGetTypes(assembly, out types)) { return(new StartupHandlerInfo[0]); } var result = GetSubscribedTypes(types); var newCacheEntry = new AssemblyInfo { AssemblyName = assembly.GetName().Name, LastModified = modificationDate, SubscribedTypes = result.Select(sh => sh.Type.FullName).ToArray() }; cachedTypesInfo.Add(newCacheEntry); cacheHasBeenUpdated = true; return(result); }
private static void DoSave(FileRecord fileRecord) { var root = new XElement(GetRootElementName(fileRecord.ElementName)); var xDocument = new XDocument(root); var recordSet = fileRecord.RecordSet; var elements = new List <XElement>(recordSet.Index.GetValues()); Func <IEnumerable <XElement>, IOrderedEnumerable <XElement> > orderer; if (TryGetFileOrderer(out orderer, fileRecord.FilePath)) { var orderedElements = orderer(elements); orderedElements.ForEach(root.Add); } else { elements.ForEach(root.Add); } Exception thrownException = null; // Writing the file in the "catch" block in order to prevent chance of corrupting the file by experiencing ThreadAbortException. try { } finally { try { // Saving to temp file and file move to prevent broken saves var xmlWriterSettings = new XmlWriterSettings { CheckCharacters = false, Indent = true }; using (XmlWriter xmlWriter = XmlWriter.Create(fileRecord.TempFilePath, xmlWriterSettings)) { xDocument.Save(xmlWriter); } Thread.Sleep(_fileIoDelay); bool failed = true; Exception lastException = null; for (int i = 0; i < NumberOfRetries; i++) { DateTime lastSuccessfulFileChange = fileRecord.FileModificationDate; try { fileRecord.FileModificationDate = DateTime.MinValue; File.Copy(fileRecord.TempFilePath, fileRecord.FilePath, true); failed = false; break; } catch (Exception ex) { fileRecord.FileModificationDate = lastSuccessfulFileChange; lastException = ex; Thread.Sleep(10 * (i + 1)); } } if (!failed) { Thread.Sleep(_fileIoDelay); File.Delete(fileRecord.TempFilePath); } else { Log.LogCritical(LogTitle, "Failed deleting the file: " + fileRecord.FilePath); if (lastException != null) { throw lastException; } throw new InvalidOperationException("Failed to delete a file, this code shouldn't be reachable"); } fileRecord.FileModificationDate = C1File.GetLastWriteTime(fileRecord.FilePath); } catch (Exception exception) { thrownException = exception; } } // ThreadAbortException should have a higher priority, and therefore we're doing rethrow in a separate block if (thrownException != null) { throw thrownException; } }
private static Type[] GetSubscribedTypes(string filePath, List <AssemblyInfo> cachedTypesInfo, ref bool cacheHasBeenUpdated) { string assemblyName = Path.GetFileNameWithoutExtension(filePath); foreach (string assemblyToIgnore in AssembliesToIgnore) { if (assemblyName == assemblyToIgnore || assemblyName.StartsWith(assemblyToIgnore + ",") || (assemblyToIgnore.EndsWith(".") && assemblyName.StartsWith(assemblyToIgnore))) { return(null); } } DateTime modificationDate = C1File.GetLastWriteTime(filePath); var cachedInfo = cachedTypesInfo.FirstOrDefault(asm => asm.AssemblyName == assemblyName); if (cachedInfo != null) { if (cachedInfo.LastModified == modificationDate) { string[] subscribedTypesNames = cachedInfo.SubscribedTypes; if (subscribedTypesNames.Length == 0) { return(new Type[0]); } Assembly asm = Assembly.LoadFrom(filePath); return(subscribedTypesNames.Select(asm.GetType).ToArray()); } // Removing cache entry if it is obsolete cachedTypesInfo.Remove(cachedInfo); } Assembly assembly; try { assembly = Assembly.LoadFrom(filePath); } catch (ReflectionTypeLoadException ex) { Log.LogWarning(LogTitle, "Failed to load assembly '{0}'".FormatWith(filePath)); if (ex.LoaderExceptions != null && ex.LoaderExceptions.Length > 0) { Log.LogError(LogTitle, ex.LoaderExceptions[0]); } return(null); } Type[] types; if (!TryGetTypes(assembly, out types)) { return(new Type[0]); } Type[] result = GetSubscribedTypes(types); var newCacheEntry = new AssemblyInfo { AssemblyName = assembly.GetName().Name, LastModified = modificationDate, SubscribedTypes = result.Select(type => type.FullName).ToArray() }; cachedTypesInfo.Add(newCacheEntry); cacheHasBeenUpdated = true; return(result); }
/// <summary> /// Gets the resized image. /// </summary> /// <param name="httpServerUtility">An instance of <see cref="System.Web.HttpServerUtility" />.</param> /// <param name="file">The media file.</param> /// <param name="resizingOptions">The resizing options.</param> /// <param name="targetImageFormat">The target image format.</param> /// <returns>A full file path to a resized image; null if there's no need to resize the image</returns> public static string GetResizedImage(HttpServerUtility httpServerUtility, IMediaFile file, ResizingOptions resizingOptions, ImageFormat targetImageFormat) { Verify.ArgumentNotNull(file, "file"); Verify.That(ImageFormatIsSupported(targetImageFormat), "Unsupported image format '{0}'", targetImageFormat); if (_resizedImagesDirectoryPath == null) { _resizedImagesDirectoryPath = httpServerUtility.MapPath(ResizedImagesCacheDirectory); if (!C1Directory.Exists(_resizedImagesDirectoryPath)) { C1Directory.CreateDirectory(_resizedImagesDirectoryPath); } } string imageKey = file.CompositePath; bool isNativeProvider = file is FileSystemFileBase; string imageSizeCacheKey = "ShowMedia.ashx image size " + imageKey; Size? imageSize = HttpRuntime.Cache.Get(imageSizeCacheKey) as Size?; Bitmap bitmap = null; Stream fileStream = null; try { if (imageSize == null) { fileStream = file.GetReadStream(); Size calculatedSize; if (!ImageSizeReader.TryGetSize(fileStream, out calculatedSize)) { fileStream.Dispose(); fileStream = file.GetReadStream(); bitmap = new Bitmap(fileStream); calculatedSize = new Size { Width = bitmap.Width, Height = bitmap.Height }; } imageSize = calculatedSize; // We can provider cache dependency only for the native media provider var cacheDependency = isNativeProvider ? new CacheDependency((file as FileSystemFileBase).SystemPath) : null; HttpRuntime.Cache.Add(imageSizeCacheKey, imageSize, cacheDependency, DateTime.MaxValue, CacheExpirationTimeSpan, CacheItemPriority.Normal, null); } int newWidth, newHeight; bool centerCrop; bool needToResize = CalculateSize(imageSize.Value.Width, imageSize.Value.Height, resizingOptions, out newWidth, out newHeight, out centerCrop); needToResize = needToResize || resizingOptions.CustomQuality; if (!needToResize) { return(null); } int filePathHash = imageKey.GetHashCode(); string centerCroppedString = centerCrop ? "c" : string.Empty; string fileExtension = _ImageFormat2Extension[targetImageFormat]; string resizedImageFileName = string.Format("{0}x{1}_{2}{3}_{4}.{5}", newWidth, newHeight, filePathHash, centerCroppedString, resizingOptions.Quality, fileExtension); string imageFullPath = Path.Combine(_resizedImagesDirectoryPath, resizedImageFileName); if (!C1File.Exists(imageFullPath) || C1File.GetLastWriteTime(imageFullPath) != file.LastWriteTime) { if (bitmap == null) { fileStream = file.GetReadStream(); bitmap = new Bitmap(fileStream); } ResizeImage(bitmap, imageFullPath, newWidth, newHeight, centerCrop, targetImageFormat, resizingOptions.Quality); if (file.LastWriteTime.HasValue) { C1File.SetLastWriteTime(imageFullPath, file.LastWriteTime.Value); } } return(imageFullPath); } finally { if (bitmap != null) { bitmap.Dispose(); } if (fileStream != null) { fileStream.Dispose(); } } }