public IEnumerable <BlobDirectory> GetSubdirectories(bool flat) { if (!_blobsInitialized) { InitializeBlobs(); } var dirsPaths = new List <string>(); BlobCollection.Instance.GetStartingWith(Path + "/", flat) .Where(b => b.Exists()) .Select(b => AzurePathHelper.GetBlobDirectory(b.Path)) .Union(BlobDirectoryCollection.Instance.GetStartingWith(Path + "/", flat).Where(d => d.Exists()).Select(d => d.Path)) .Distinct() .ToList() .ForEach(b => dirsPaths.AddRange(DirectoryHelper.PathToParent(b, Path))); dirsPaths = dirsPaths.Distinct().ToList(); if (flat) { dirsPaths = dirsPaths.Where(d => AzurePathHelper.GetBlobDirectory(d) == Path).ToList(); } return(dirsPaths.Select(p => BlobDirectoryCollection.Instance.GetOrCreate(p))); }
private byte[] TryGetFromFileSystemCache(string path, DateTime remoteLastModified) { byte[] data = null; var fileLastModified = DateTime.MinValue; var tempFilePath = AzurePathHelper.GetTempBlobPath(path); if (System.IO.File.Exists(tempFilePath)) { fileLastModified = System.IO.File.GetLastWriteTimeUtc(tempFilePath); using (var stream = new System.IO.FileStream(tempFilePath, System.IO.FileMode.Open)) { data = new byte[stream.Length]; stream.Read(data, 0, data.Length); } } // no data in cache or outdated if (data == null || fileLastModified < remoteLastModified) { if (data != null) { Discard(path); } return(null); } return(data); }
public override void Move(string sourceDirName, string destDirName) { var sourceDirPath = AzurePathHelper.GetBlobPath(sourceDirName); var destDirPath = AzurePathHelper.GetBlobPath(destDirName); // if web farms are enabled, reinitialize source and destination folder to see if another web farm server has already moved the files if (SynchronizationHelper.Synchronizing()) { BlobDirectoryCollection.Instance.GetOrCreate(sourceDirPath).Reinitialize(); BlobDirectoryCollection.Instance.GetOrCreate(destDirPath).Reinitialize(); } var sourceDirBlobs = Get(sourceDirName).GetBlobs(false); foreach (var blob in sourceDirBlobs) { blob.Move(destDirPath + "/" + blob.Path.Substring(sourceDirPath.Length + 1)); } // we have to do this on file system too because of Dirs :( if (System.IO.Directory.Exists(sourceDirName)) { System.IO.Directory.Move(sourceDirName, destDirName); } }
private void End_Execute(object sender, EventArgs e) { // remove azure temp folder var tempFolder = AzurePathHelper.GetTempBlobPath(string.Empty); if (!string.IsNullOrEmpty(tempFolder) && System.IO.Directory.Exists(tempFolder)) { System.IO.Directory.Delete(tempFolder, true); } }
public void SetExists(bool exists) { lock (_lock) { _exists = exists; _lastRefresh = DateTime.UtcNow; if (_exists.Value) { BlobDirectoryCollection.Instance.GetOrCreate(AzurePathHelper.GetBlobDirectory(Path)).SetExists(); } } }
private void AddToFileSystem(string path, byte[] data, DateTime created) { var tempFilePath = AzurePathHelper.GetTempBlobPath(path); System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(tempFilePath)); using (var stream = new System.IO.FileStream(tempFilePath, System.IO.FileMode.Create)) { stream.Write(data, 0, data.Length); } // make sure the last write time matches cloud timestamp System.IO.File.SetLastWriteTimeUtc(tempFilePath, created); }
public void ResetExistsForParents() { var blobDirectory = AzurePathHelper.GetBlobDirectory(Path); if (blobDirectory != string.Empty) { if (_exists.HasValue && _exists.Value) { BlobDirectoryCollection.Instance.GetOrCreate(blobDirectory).SetExists(); } else { BlobDirectoryCollection.Instance.GetOrCreate(blobDirectory).ResetExists(); } } }
public void Discard(string path) { switch (_cacheType) { case BlobCacheType.Memory: CacheHelper.TouchKey(BlobCacheHelper.GetCacheDependency(path)); break; case BlobCacheType.FileSystem: var tempFilePath = AzurePathHelper.GetTempBlobPath(path); if (System.IO.File.Exists(tempFilePath)) { System.IO.File.Delete(tempFilePath); } break; } }
public void Delete() { if (Exists()) { lock (_lock) { if (!SynchronizationHelper.Synchronizing() || _cloudBlobService.Exists(Path)) { _cloudBlobService.Delete(Path); } SetExists(false); _blobCacheService.Discard(Path); BlobDirectoryCollection.Instance.GetOrCreate(AzurePathHelper.GetBlobDirectory(Path)).ResetExists(); } } }
private bool ExistsInternal() { if (_exists == null) { // if parent directory has been initialized, this blob can not exist var parentDirPath = AzurePathHelper.GetBlobDirectory(Path); if (BlobDirectoryCollection.Instance.GetOrCreate(parentDirPath).BlobsInitialized) { SetExists(false); } else { SetExists(_cloudBlobService.Exists(Path)); } } return(_exists.Value); }
public void DoesNotFailForInvalidDateFormat() { var appPath = AzurePathHelper.CurrentDirectory; var file = new FileInfo(appPath + "\\FileInfoTests\\DoesNotFailForInvalidDateFormat\\test.txt"); using (var writer = file.CreateText()) { writer.Write("This is test"); } file = new FileInfo(appPath + "\\FileInfoTests\\DoesNotFailForInvalidDateFormat\\test.txt"); Assert.LessOrEqual(file.CreationTime, DateTime.UtcNow); BlobCollection.Instance.GetOrCreate(AzurePathHelper.GetBlobPath(appPath + "\\FileInfoTests\\DoesNotFailForInvalidDateFormat\\test.txt")) .SetMetadataAttributeAndSave(BlobMetadataEnum.DateCreated, "invalid date"); Assert.AreEqual(file.CreationTime, DateTime.MinValue); }
protected void InitializeBlobsInternal(bool forceRefresh = false) { if (!forceRefresh) { TryInitializeFromParent(); } if (!forceRefresh && BlobsInitialized) { _exists = BlobCollection.Instance.GetStartingWith(Path + "/", false).Any(b => b.Exists()); return; } // at this point we need to get data from remote var blobs = _cloudDirectoryService.GetBlobs(Path); if (LoggingHelper.LogsEnabled) { LoggingHelper.Log($"Blobs for path {Path}", $"{string.Join(",", blobs.Select(b => b.Path))}"); } BlobCollection.Instance.AddRangeDistinct(blobs); _blobsInitialized = true; _exists = blobs.Any(); // update directories in collection var subDirectoriesPaths = new List <string>(); blobs .Select(b => AzurePathHelper.GetBlobDirectory(b.Path)) .Distinct() .Where(d => d != Path) .ToList() .ForEach(p => subDirectoriesPaths.AddRange(DirectoryHelper.PathToParent(p, Path))); var subDirectories = subDirectoriesPaths .Distinct() .Select(d => new BlobDirectory().InitializeWithFlag(d)) .ToList(); BlobDirectoryCollection.Instance.AddRangeDistinct(subDirectories); }
public string Execute(TaskInfo task) { if (_blobCacheService.CacheType != BlobCacheType.FileSystem) { return("Caching of Azure data is disabled or is set to memory. No need to run this task."); } var blobCacheService = Service <IBlobCacheService> .Entry(); var minutes = AccountInfo.Instance.BlobCacheMinutes; var dateThreshold = DateTime.UtcNow.AddMinutes(-minutes); var blobsToDelete = BlobCollection.Instance.GetOutdatedBlobPaths(dateThreshold); var blobsDeleted = 0; var directoriesUninitialized = 0; foreach (var path in blobsToDelete) { // remove the blob blobCacheService.Discard(path); blobsDeleted++; } // clear empty folders in file system if (blobsDeleted > 0) { var folders = System.IO.Directory.GetDirectories(AzurePathHelper.GetTempBlobPath(string.Empty), "*", System.IO.SearchOption.AllDirectories).OrderByDescending(p => p.Length); foreach (var subFolder in folders) { if (System.IO.Directory.Exists(subFolder) && !System.IO.Directory.GetFiles(subFolder).Any() && !System.IO.Directory.EnumerateDirectories(subFolder).Any()) { System.IO.Directory.Delete(subFolder, false); } } } return("OK, discarded metadata of " + blobsDeleted + " blobs, " + directoriesUninitialized + " dirs"); }
public void DoesNotGetsBlobCaseInvariantIfAlreadyExistsInBlob() { var temp = AzurePathHelper.ForceLowercase; AzurePathHelper.ForceLowercase = false; var appPath = AzurePathHelper.CurrentDirectory; var file = new FileInfo(appPath + "\\GetsBlobCaseInvariantIfAlreadyExistsInBlob\\First.txt"); using (var writer = file.CreateText()) { writer.Write("This is test"); } BlobCollection.Instance.GetOrCreate(AzurePathHelper.GetBlobPath(appPath + "\\GetsBlobCaseInvariantIfAlreadyExistsInBlob\\First.txt")).Uninitialize(); AzurePathHelper.ForceLowercase = true; Assert.IsFalse(new FileInfo(appPath + "\\getsblobcaseinvariantifalreadyexistsinblob\\first.txt").Exists); AzurePathHelper.ForceLowercase = temp; }
public void GetsBlobCaseInvariant() { var temp = AzurePathHelper.ForceLowercase; AzurePathHelper.ForceLowercase = true; var appPath = AzurePathHelper.CurrentDirectory; var file = new FileInfo(appPath + "\\GetsBlobCaseInvariant\\First.txt"); using (var writer = file.CreateText()) { writer.Write("This is test"); } // to make sure we will get hit in BLOB storage BlobCollection.Instance.GetOrCreate(AzurePathHelper.GetBlobPath(appPath + "\\GetsBlobCaseInvariant\\First.txt")).Uninitialize(); Assert.IsTrue(new FileInfo(appPath + "\\geTSblobcaseiNVARiant\\first.txt").Exists); AzurePathHelper.ForceLowercase = temp; }
public void RemovesCachedFile() { _blobCacheService.SetCacheType(BlobCacheType.FileSystem); using (var ms = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes("string"))) { Get("RemovesCachedFile.txt").Upload(ms); } var cachePath = AzurePathHelper.GetTempBlobPath(Get("RemovesCachedFile.txt").Path); // cache was created in file system Assert.IsTrue(System.IO.File.Exists(cachePath)); Get("RemovesCachedFile.txt").Delete(); // cache was removed Assert.IsFalse(System.IO.File.Exists(cachePath)); Assert.AreEqual(3, _cloudBlobService.History.Count); }
public override string[] GetDirectories(string path, string searchPattern, SearchOption searchOption) { // weird fallback from original implementation that checks whether file exists on file system // should be absolutely removed!!! var fileSystemSubDirectories = System.IO.Directory.Exists(path) ? System.IO.Directory.GetDirectories(path, searchPattern, searchOption == SearchOption.AllDirectories ? System.IO.SearchOption.AllDirectories : System.IO.SearchOption.TopDirectoryOnly) : new string[0]; if (AzurePathHelper.ForceLowercase) { fileSystemSubDirectories = fileSystemSubDirectories.Select(s => s.ToLowerInvariant()).ToArray(); } // end of weird fallback! // var condition = new Func <string, bool>(p => true); if (!string.IsNullOrEmpty(searchPattern) || searchPattern == "*") { var regex = RegexHelper.GetRegex(searchPattern.Replace("*", ".*"), true); condition = new Func <string, bool>(p => regex.IsMatch(Path.GetFileName(p))); } var flat = searchOption == SearchOption.TopDirectoryOnly; var cloudSubDirectories = Get(path).GetSubdirectories(flat) .Where(d => d.Exists()) .Select(d => AzurePathHelper.GetFileSystemPath(d.Path)) .Where(condition) .ToArray(); if (LoggingHelper.LogsEnabled) { LoggingHelper.Log($"GetDirectories {path}", $"Base path: {path}, cloud directories: {string.Join(",", cloudSubDirectories)}, file system directories: {string.Join(",", fileSystemSubDirectories)}"); } var listOfAll = new List <string>(fileSystemSubDirectories); listOfAll.AddRange(cloudSubDirectories); return(listOfAll.Distinct().ToArray()); }
public void InitializesBlobAsLowercase() { var temp = AzurePathHelper.ForceLowercase; AzurePathHelper.ForceLowercase = false; var appPath = AzurePathHelper.CurrentDirectory; var file = new FileInfo(appPath + "\\initializesblobaslowercase\\TEST.txt"); using (var writer = file.CreateText()) { writer.Write("This is test"); } BlobCollection.Instance.GetOrCreate(AzurePathHelper.GetBlobPath(appPath + "\\initializesblobaslowercase\\TEST.txt")).Uninitialize(); AzurePathHelper.ForceLowercase = true; var files = BlobDirectoryCollection.Instance.GetOrCreate(AzurePathHelper.GetBlobPath(appPath + "\\initializesblobaslowercase")).GetBlobs(false); Assert.AreEqual(1, files.Count()); Assert.AreEqual("test.txt", System.IO.Path.GetFileName(files.Single().Path)); AzurePathHelper.ForceLowercase = temp; }
public string[] GetFiles(string path, string searchPattern, SearchOption searchOption) { var condition = new Func <string, bool>(p => true); if (!string.IsNullOrEmpty(searchPattern)) { var regex = RegexHelper.GetRegex(searchPattern.Replace("*", ".*"), true); condition = new Func <string, bool>(p => regex.IsMatch(Path.GetFileName(p))); } var flat = searchOption == SearchOption.TopDirectoryOnly; var files = Get(path).GetBlobs(flat) .Select(d => AzurePathHelper.GetFileSystemPath(d.Path)) .Where(condition) .ToArray(); if (LoggingHelper.LogsEnabled) { LoggingHelper.Log($"GetFiles {path}", $"Base path: {path}, condition: {condition}, files: {string.Join(",", files)}"); } return(files); }
public void GetParentFromPathEnsuresForwardSlashes() { Assert.AreEqual("dir22/dir23", AzurePathHelper.GetBlobDirectory("dir22/dir23/test.txt")); }
public void GetsParentFromPath() { Assert.AreEqual("dir21", AzurePathHelper.GetBlobDirectory("dir21/test.txt")); Assert.AreEqual(string.Empty, AzurePathHelper.GetBlobDirectory("test.txt")); }
public void GetsDirectoryForBlob() { Assert.AreEqual("dir10", AzurePathHelper.GetBlobDirectory("dir10/file.txt")); Assert.AreEqual("dir10/dir11", AzurePathHelper.GetBlobDirectory("dir10/dir11/file.txt")); }
public void TranslatesPathsToBlob() { var path = AzurePathHelper.CurrentDirectory + "\\test.txt"; Assert.AreEqual("test.txt", AzurePathHelper.GetBlobPath(path)); }
/// <summary> /// Copies an existing file to a new file. Overwriting a file of the same name is allowed. /// </summary> /// <param name="sourceFileName">Path to source file.</param> /// <param name="destFileName">Path to destination file.</param> /// <param name="overwrite">If destination file should be overwritten.</param> public override void Copy(string sourceFileName, string destFileName, bool overwrite) { Get(sourceFileName).Copy(AzurePathHelper.GetBlobPath(destFileName), overwrite); }
/// <summary> /// Moves a specified file to a new location, providing the option to specify a new file name. /// </summary> /// <param name="sourceFileName">Source file name.</param> /// <param name="destFileName">Destination file name.</param> public override void Move(string sourceFileName, string destFileName) { Get(sourceFileName).Move(AzurePathHelper.GetBlobPath(destFileName)); }
public string GetUrl() { return(BlobContainerCollection.Instance.GetOrCreate(AccountInfo.Instance.RootContainer).IsPublic() ? GetAttribute(a => a.AbsoluteUri) : AzurePathHelper.GetDownloadUri(Path)); }
protected override void ProcessRequestInternal(HttpContextBase context) { var hash = QueryHelper.GetString("hash", string.Empty); var path = QueryHelper.GetString("path", string.Empty); // Validate hash var settings = new HashSettings { Redirect = false }; if (!ValidationHelper.ValidateHash("?path=" + URLHelper.EscapeSpecialCharacters(path), hash, settings)) { RequestHelper.Respond403(); } if (path.StartsWithCSafe("~")) { path = context.Server.MapPath(path); } var blobPath = AzurePathHelper.GetBlobPath(path); var blob = BlobCollection.Instance.GetOrCreate(blobPath); if (!blob.Exists()) { RequestHelper.Respond404(); } CookieHelper.ClearResponseCookies(); Response.Clear(); SetRevalidation(); var eTag = blob.GetAttribute(a => a.Etag); var lastModified = ValidationHelper.GetDateTime(blob.GetAttribute(a => a.LastModified), DateTimeHelper.ZERO_TIME); SetResponseContentType(path); // Client caching - only on the live site if (AllowCache && AllowClientCache && ETagsMatch(eTag, lastModified)) { // Set the file time stamps to allow client caching SetTimeStamps(lastModified); RespondNotModified(eTag); return; } SetDisposition(Path.GetFileName(path), Path.GetExtension(path)); // Setup Etag property ETag = eTag; if (AllowCache) { // Set the file time stamps to allow client caching SetTimeStamps(lastModified); Response.Cache.SetETag(eTag); } else { SetCacheability(); } WriteFile(path, CacheHelper.CacheImageAllowed(CurrentSiteName, Convert.ToInt32(blob.GetAttribute(a => a.Length)))); CompleteRequest(); }
private Blob Get(string path) { return(BlobCollection.Instance.GetOrCreate(AzurePathHelper.GetBlobPath(path))); }
public bool IsCached(string path) { var tempFilePath = AzurePathHelper.GetTempBlobPath(path); return(System.IO.File.Exists(tempFilePath)); }