/// <summary>
/// All files at the given folder
/// </summary>
/// <param name="storeSource">Location (relative to root)</param>
/// <param name="timeout">List timeout</param>
/// <returns>File name of each files within the given location</returns>
public IEnumerable <string> ListContent(string storeSource, TimeSpan timeout)
{
List <string> files = new List <string>();
try
{
string smbTag = this.ConvertTagToSMBPath(storeSource);
if (!FabricDirectory.Exists(smbTag))
{
TraceSource.WriteWarning(
TraceType,
"Directory {0} doesn't exist",
smbTag);
}
else
{
this.GetAllFileFullNames(smbTag, timeout).ForEach <string>(fullName => files.Add(fullName.Substring(this.rootUri.Length + 1)));
}
}
catch (IOException exception)
{
if (exception.GetType() == typeof(IOException))
{
throw new FabricImageStoreException(StringResources.Error_ImageStoreIOException, exception);
}
else
{
throw;
}
}
return(files);
}
private Task <bool> OnFullBackupCallback(BackupInfo backupInfo, CancellationToken cancellationToken)
{
Assert.IsFalse(cancellationToken.IsCancellationRequested);
FullBackupFolderPath = Path.Combine(ClassTestPath, BackupContainerFolderName, Guid.NewGuid().ToString("N"));
FabricDirectory.Copy(backupInfo.Directory, FullBackupFolderPath, false);
return(Task.FromResult(true));
}
public static string ComputeHash(string resourcePath, bool imageStoreServiceEnabled)
{
byte[] hash = null;
if (FabricFile.Exists(resourcePath))
{
hash = ComputeHashOnFile(resourcePath);
}
else if (FabricDirectory.Exists(resourcePath))
{
hash = ComputeHashOnDirectory(resourcePath, imageStoreServiceEnabled);
}
else
{
System.Fabric.Interop.Utility.ReleaseAssert(true, "{0} is not found.");
}
StringBuilder hashStringBuilder = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
hashStringBuilder.Append(string.Format(CultureInfo.InvariantCulture, "{0:X2}", hash[i]));
}
return(hashStringBuilder.ToString());
}
private bool IsStagingFolderNeededForCopy(string sourceFolder)
{
if (FileShareAccessAccountType.None != this.accessInfo.AccountType)
{
// We are impersonating in order to copy files to destination.
// Check if we can access the source folder while impersonating.
bool sourceAccessDeniedUnderImpersonation = false;
using (WindowsIdentity identity = this.GetIdentityToImpersonate())
{
#if DotNetCoreClr
WindowsIdentity.RunImpersonated(identity.AccessToken, () =>
#else
using (WindowsImpersonationContext impersonationCtx = identity.Impersonate())
#endif
{
try
{
// Use Directory.GetFiles directly instead of using FabricDirectory.GetFiles
// because the latter fails silently and returns an empty array if access is
// denied.
FabricDirectory.GetFiles(sourceFolder);
}
catch (UnauthorizedAccessException)
{
// We are unable to access the source folder while impersonating.
// Hence we need a staging folder, which we can access while
// impersonating.
sourceAccessDeniedUnderImpersonation = true;
}
}
/// <summary>
/// Creates bookmark directory.
/// </summary>
/// <param name="sourceFolder"></param>
/// <param name="workDirectory"></param>
/// <param name="destinationKey"></param>
/// <param name="bookmarkFolder"></param>
/// <returns></returns>
private bool CreateBookmarkSubDirectory(
string sourceFolder,
string workDirectory,
string destinationKey,
out string bookmarkFolder)
{
string bookmarkParentFolder = Path.Combine(
workDirectory,
Utility.ShortWindowsFabricIdForPaths);
bool success = Utility.CreateWorkSubDirectory(
this.traceSource,
this.logSourceId,
destinationKey,
sourceFolder,
bookmarkParentFolder,
out bookmarkFolder);
if (success)
{
bookmarkFolder = Path.Combine(bookmarkFolder, BookmarkDirName);
}
FabricDirectory.CreateDirectory(bookmarkFolder);
return(success);
}
private void TestIntersectingHardLinkAndReplace(bool isLongPath, FileShare fileShare)
{
var folderPath = this.testPath;
if (true == isLongPath)
{
folderPath = this.ExtendPath(folderPath);
}
var filePath = Path.Combine(folderPath, this.testFileName);
Assert.IsTrue(!isLongPath || filePath.Length > 260, "file path must be greater than max path size.");
var hardLinkedFilePath = Path.Combine(folderPath, this.testHardLinkedFileName);
Assert.IsTrue(!isLongPath || hardLinkedFilePath.Length > 260, "hard linked file path must be greater than max path size.");
var replaceFilePath = Path.Combine(folderPath, this.testReplaceFileName);
Assert.IsTrue(!isLongPath || replaceFilePath.Length > 260, "replace file path must be greater than max path size.");
var backupFilePath = Path.Combine(folderPath, this.testBackupFileName);
Assert.IsTrue(!isLongPath || backupFilePath.Length > 260, "backup file path must be greater than max path size.");
LogHelper.Log("FabricDirectory.Create {0}", folderPath);
FabricDirectory.CreateDirectory(folderPath);
LogHelper.Log("FabricFile.Create {0}", filePath);
using (StreamWriter streamWriter = new StreamWriter(FabricFile.Create(filePath)))
{
LogHelper.Log("Write {0}", this.testString);
streamWriter.WriteLine(this.testString);
streamWriter.Flush();
}
using (StreamWriter streamWriter = new StreamWriter(FabricFile.Create(replaceFilePath)))
{
LogHelper.Log("Write {0}", this.testNewString);
streamWriter.WriteLine(this.testNewString);
streamWriter.Flush();
}
FabricFile.CreateHardLink(hardLinkedFilePath, filePath);
using (StreamReader hardLinkReader0 = new StreamReader(FabricFile.Open(hardLinkedFilePath, FileMode.Open, FileAccess.Read, fileShare)))
{
var hardLinkContent0 = hardLinkReader0.ReadLine();
Assert.AreEqual <string>(this.testString, hardLinkContent0, "after replace hard link file must have the old content.");
try
{
FabricFile.Replace(replaceFilePath, filePath, backupFilePath, false);
Assert.Fail();
}
catch (FileLoadException)
{
}
}
}
/// <summary>
/// Post-processing of copying (from XStore to SMB)
/// </summary>
/// <param name="task">The task to end.</param>
private static void EndCopyFromXStoreToSMB(XStoreFileOperationTask task)
{
if (task.IsSucceeded)
{
// Step 3, 4 and 5 for atomic copy
// 3. delete dstFolder.old
// 4. rename dstFolder -> dstFolder.old
// 5. rename dstFolder.new -> dstFolder
// get the original destination path
string newDstRootUri = task.DstUri + NewExtension;
string oldDstRootUri = task.DstUri + OldExtension;
// Step 3, 4 & 5
if (FabricDirectory.Exists(oldDstRootUri))
{
// delete dstFolder.old
FabricDirectory.Delete(oldDstRootUri, recursive: true, deleteReadOnlyFiles: true);
}
if (FabricDirectory.Exists(task.DstUri))
{
// rename dstFolder -> dstFolder.old
RenameFolder(task.DstUri, oldDstRootUri);
}
// rename dstFolder.new -> dstFolder; and clean up
RenameFolder(newDstRootUri, task.DstUri);
if (FabricDirectory.Exists(oldDstRootUri))
{
FabricDirectory.Delete(oldDstRootUri, recursive: true, deleteReadOnlyFiles: true);
}
}
}
/// <summary>
/// Check if content is present in the store.
/// </summary>
/// <param name="tag"> Location (relative to RootUri) where to check the presence of the content. </param>
/// <param name="timeout">Check existence timeout</param>
/// <returns> True if the content exists, false otherwise. </returns>
public bool DoesContentExist(string tag, TimeSpan timeout)
{
TimeoutHelper helper = timeout == TimeSpan.MaxValue ? null : new TimeoutHelper(timeout);
#if !DotNetCoreClr
using (WindowsImpersonationContext impersonationContext = this.GetImpersonationContext())
#endif
{
string smbTag = this.ConvertTagToSMBPath(tag);
if (FabricFile.Exists(smbTag))
{
return(!FileLock.DoesWriterLockExist(smbTag));
}
if (helper != null)
{
helper.ThrowIfExpired();
}
if (FabricDirectory.Exists(smbTag))
{
return(!FileLock.DoesWriterLockExist(smbTag));
}
}
return(false);
}
private bool EnumerateFiles(object context)
{
var fileEnumerateInfo = (FileEnumerateInfo)context;;
fileEnumerateInfo.Files = FabricDirectory.GetFiles(fileEnumerateInfo.DirectoryPath, fileEnumerateInfo.FileExtension, fileEnumerateInfo.SearchOptionEnum);
return(true);
}
private static void WriteStringToFile(string fileName, string value, bool writeLine = true, Encoding encoding = null)
{
var directory = FabricPath.GetDirectoryName(fileName);
if (!FabricDirectory.Exists(directory))
{
FabricDirectory.CreateDirectory(directory);
}
if (encoding == null)
{
#if DotNetCoreClrLinux
encoding = new UTF8Encoding(false);
#else
encoding = Encoding.GetEncoding(0);
#endif
}
using (StreamWriter writer = new StreamWriter(FabricFile.Open(fileName, FileMode.OpenOrCreate), encoding))
{
if (writeLine)
{
writer.WriteLine(value);
}
else
{
writer.Write(value);
}
#if DotNetCoreClrLinux
Helpers.UpdateFilePermission(fileName);
#endif
}
}
public CheckpointManager(
IEnumerable <EtlInMemoryProducerWorker.ProviderInfo> providers,
string etlPath,
string logDirectory,
string traceDirectory,
FabricEvents.ExtensionsEvents traceSource,
string logSourceId)
{
this.traceSource = traceSource;
this.logSourceId = logSourceId;
// Directory where the producer saves the file containing information
// about the point upto which we last read the ETL files
var lastEtlFileReadFilePath = InitializeLastEtlFileReadFilePath(
etlPath,
logDirectory,
traceDirectory);
// If the directory containing the last ETL read information is
// different from the log directory, then create it now.
if (false == lastEtlFileReadFilePath.Equals(
logDirectory))
{
FabricDirectory.CreateDirectory(lastEtlFileReadFilePath);
this.traceSource.WriteInfo(
this.logSourceId,
"Directory containing last ETL read info: {0}",
lastEtlFileReadFilePath);
}
this.SetProviderCheckpointFileName(providers, lastEtlFileReadFilePath);
}
public void FabricDirectory_GetFilesNegative()
{
LogHelper.Log("FabricDirectory.GetFiles {0}", BadPath);
var res = FabricDirectory.GetFiles(BadPath);
Assert.AreEqual(0, res.Length);
}
private void RenameFolder(string srcFolderName, string dstFolderName)
{
if (string.IsNullOrEmpty(srcFolderName) || !FabricDirectory.Exists(srcFolderName))
{
this.traceSource.WriteError(ClassName, "SourceFolder {0} doesn't exist", srcFolderName);
throw new ArgumentException(StringResources.ImageStoreError_InvalidSourceFolderSpecified);
}
if (string.IsNullOrEmpty(dstFolderName) || FabricDirectory.Exists(dstFolderName))
{
this.traceSource.WriteError(ClassName, "Destination folder {0} does exist", dstFolderName);
throw new ArgumentException(StringResources.ImageStoreError_InvalidDestinationFolderSpecified);
}
try
{
FabricFile.Move(srcFolderName, dstFolderName);
}
catch (Exception ex)
{
this.traceSource.WriteError(
ClassName,
"Failed to rename folder {0} to {1} with error {2}, and detail exception {3}",
srcFolderName,
dstFolderName,
ex.Message,
ex);
throw;
}
}
private void GenerateCodeDeployment()
{
if (!this.nodeSettings.DeploymentFoldersInfo.IsCodeDeploymentNeeded)
{
return;
}
foreach (string service in this.servicesToBeDeployed)
{
string destinationFolder = this.nodeSettings.DeploymentFoldersInfo.GetCodeDeploymentDirectory(service);
string sourceFolder = this.nodeSettings.DeploymentFoldersInfo.GetInstalledBinaryDirectory(service);
if (IsCodeDeploymentNeeded(service, sourceFolder, destinationFolder))
{
try
{
FabricDirectory.Copy(sourceFolder, destinationFolder, true);
}
catch (Exception e)
{
DeployerTrace.WriteError("Code deployment failed because: {0}. Source folder: {1}. destinationFolder: {2}", e, sourceFolder, destinationFolder);
throw;
}
}
}
}
public static void ClassSetup(object testContext)
{
if (FabricDirectory.Exists(DefaultWorkDirectory))
{
FabricDirectory.Delete(DefaultWorkDirectory, true);
}
}
/// <summary>
/// Copy Folder method called by the CopyItem delegate to dequeue a folder copy item
/// This method enumerates the folder enqueues all its children and dequeues the current item
/// </summary>
/// <param name="sourceDir">
/// Source folder to be copied
/// </param>
/// <param name="destinationDir">
/// Destination folder
/// </param>
private void CopyFolder(string sourceDir, string destinationDir)
{
// create the destination folder if it doesn't exist
if (!FabricDirectory.Exists(destinationDir))
{
FabricDirectory.CreateDirectory(destinationDir);
}
// Enumerate source and queue up work items for each child folder
var directoryNames = FabricDirectory.GetDirectories(
sourceDir,
"*",
false, // full path
SearchOption.TopDirectoryOnly);
var fileNames = FabricDirectory.GetFiles(
sourceDir,
"*",
false, // full path
SearchOption.TopDirectoryOnly);
foreach (var directoryName in directoryNames)
{
this.QueueCopyItem(sourceDir, destinationDir, directoryName, true);
}
foreach (var fileName in fileNames)
{
this.QueueCopyItem(sourceDir, destinationDir, fileName, false);
}
}
public void TestCleanup()
{
if (FabricDirectory.Exists(this.testPath))
{
FabricDirectory.Delete(this.testPath, true);
}
}
public CheckpointManager(
bool isReadingFromApplicationManifest,
string etlPath,
string logDirectory,
string traceDirectory,
string producerInstanceId,
FabricEvents.ExtensionsEvents traceSource,
string logSourceId)
{
this.traceSource = traceSource;
this.logSourceId = logSourceId;
// Directory where the producer saves the file containing information
// about the point upto which we last read the ETL files
this.lastEtlFileReadFileDirectoryPath = InitializeLastEtlFileReadFilePath(
isReadingFromApplicationManifest,
etlPath,
logDirectory,
traceDirectory,
producerInstanceId);
// If the directory containing the last ETL read information is
// different from the log directory, then create it now.
if (false == this.lastEtlFileReadFileDirectoryPath.Equals(
logDirectory))
{
FabricDirectory.CreateDirectory(this.lastEtlFileReadFileDirectoryPath);
this.traceSource.WriteInfo(
this.logSourceId,
"Directory containing last ETL read info: {0}",
this.lastEtlFileReadFileDirectoryPath);
}
}
private static void PopulateVolumes(
ContainerConfig containerConfig,
ContainerDescription containerDesc)
{
foreach (var volume in containerDesc.Volumes)
{
#if !DotNetCoreClrLinux
if (string.IsNullOrEmpty(volume.Driver) && !FabricDirectory.Exists(volume.Source))
{
throw new FabricException(
string.Format(
"The source location specified for container volume does not exist. Source:{0}",
volume.Source),
FabricErrorCode.DirectoryNotFound);
}
#endif
var bindFormat = volume.IsReadOnly ? "{0}:{1}:ro" : "{0}:{1}";
containerConfig.HostConfig.Binds.Add(string.Format(bindFormat, volume.Source, volume.Destination));
}
foreach (var bind in containerDesc.BindMounts)
{
containerConfig.HostConfig.Binds.Add(
string.Format("{0}:{1}:ro", bind.Value, bind.Key));
}
}
private void SetInformationTest(bool isLongPath, Kernel32Types.PRIORITY_HINT priorityHintOne, Kernel32Types.PRIORITY_HINT priorityHintTwo)
{
var folderPath = this.testPath;
if (isLongPath == true)
{
folderPath = this.ExtendPath(folderPath);
}
var filePath = Path.Combine(folderPath, this.testFileName);
Assert.IsTrue(!isLongPath || filePath.Length > 260, "file path must be greater than max path size.");
FabricDirectory.CreateDirectory(folderPath);
using (FileStream fileStream = FabricFile.Open(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read))
{
var fileHandle = fileStream.SafeFileHandle;
// Verify that the default is Normal.
this.VerifyPriorityHint(fileHandle, Kernel32Types.PRIORITY_HINT.IoPriorityHintNormal);
this.SetPriorityHint(fileHandle, priorityHintOne);
this.VerifyPriorityHint(fileHandle, priorityHintOne);
if (priorityHintTwo != Kernel32Types.PRIORITY_HINT.MaximumIoPriorityHintType)
{
this.SetPriorityHint(fileHandle, priorityHintTwo);
this.VerifyPriorityHint(fileHandle, priorityHintTwo);
}
}
}
/// <summary>
/// Initializes a new instance of the FileImageStore class.
/// </summary>
/// <param name="uri">The root URI (the root folder) of the image store.</param>
/// <param name="localRoot">The default path for the file image store root.</param>
/// <param name="accessDescription">Access rights to specific users or groups.</param>
public FileImageStore(
string uri,
string localRoot = null,
ImageStoreAccessDescription accessDescription = null)
{
if (uri == null)
{
throw new ArgumentException(StringResources.ImageStoreError_InvalidParameterSpecified, "uri");
}
this.localRoot = localRoot;
this.accessDescription = accessDescription;
this.storeParams = new FileProviderParameters(uri);
if (!this.storeParams.RootUri.StartsWith(SchemeTag, StringComparison.OrdinalIgnoreCase))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, StringResources.ImageStoreError_InvalidImageStoreUriScheme, this.storeParams.RootUri));
}
this.rootUri = this.storeParams.RootUri.TrimStart().Substring(SchemeTag.Length).Trim();
#if !DotNetCoreClr
using (WindowsImpersonationContext impersonationContext = this.GetImpersonationContext())
#endif
{
if (!FabricDirectory.Exists(this.rootUri))
{
throw new DirectoryNotFoundException(string.Format(CultureInfo.CurrentCulture, StringResources.ImageStoreError_UnaccessibleImageStore, this.rootUri));
}
}
}
private bool EnumerateFolders(object context)
{
var folderEnumerateInfo = (FolderEnumerateInfo)context;
folderEnumerateInfo.SubFolders = FabricDirectory.GetDirectories(folderEnumerateInfo.DirectoryPath, "*", folderEnumerateInfo.GetFullPath, SearchOption.TopDirectoryOnly).Where(x => x.CompareTo(folderEnumerateInfo.DirectoryPathContinuationToken) >= 0).ToList();
return(true);
}
private bool CreateLocalMapFolder()
{
bool success = false;
if (FabricDirectory.Exists(this.localMap))
{
return(true);
}
try
{
Utility.PerformIOWithRetries(
() =>
{
FabricDirectory.CreateDirectory(this.localMap);
},
AzureBlobEtwConstants.MethodExecutionInitialRetryIntervalMs,
AzureBlobEtwConstants.MethodExecutionMaxRetryCount,
AzureBlobEtwConstants.MethodExecutionMaxRetryIntervalMs);
success = true;
}
catch (Exception e)
{
this.traceSource.WriteExceptionAsError(
this.logSourceId,
e,
string.Format("Unable to create directory {0}.", this.localMap));
}
return(success);
}
/// <summary>
/// Simply reads the folder to populate the backup folder.
/// This API does not trim or validate the backup folder.
/// Note: Using List instead of SortedList to allow same keys added to the List, this is due to
/// replicate backup log record may throw transient exception, then user may re-try the
/// BackupAsync call and leads to same backups uploaded again. In this case, add to SortedList
/// will fail since same key is not allowed.
/// </summary>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>Task that represents the asynchronous work.</returns>
/// <exception cref="FabricMissingFullBackupException">A valid full backup folder to be the head of the backup chain could not be found.</exception>
/// <exception cref="ArgumentException">The relevant folder is not a valid full backup folder.</exception>
/// <exception cref="InvalidDataException">There is a corruption in the file.</exception>
internal async Task ReadAsync(CancellationToken cancellationToken)
{
string[] list = FabricDirectory.GetFiles(
this.backupFolder,
Replicator.Constants.ReplicatorBackupMetadataFileName,
SearchOption.AllDirectories);
if (list.Length != 1)
{
// Note that we are returning full backup missing if there is no full backup or if there is more than full backup.
// If this is confusing, we could change this to ArgumentException since it already is in the set of possible exceptions.
throw new FabricMissingFullBackupException(SR.Error_BackupFolderInfo_MissingFullBackup);
}
string fullBackupDirectoryName = Path.GetDirectoryName(list[0]);
await this.AddFullBackupFolderAsync(fullBackupDirectoryName, cancellationToken).ConfigureAwait(false);
string[] incrementalBackupMetadataFilePaths = FabricDirectory.GetFiles(
this.backupFolder,
Replicator.Constants.ReplicatorIncrementalBackupMetadataFileName,
SearchOption.AllDirectories);
foreach (string path in incrementalBackupMetadataFilePaths)
{
string incrementalBackupDirectory = Path.GetDirectoryName(path);
await this.AddIncrementalBackupFolderAsync(incrementalBackupDirectory, cancellationToken).ConfigureAwait(false);
}
}
public static void CreateFolderIfNotExists(string directoryPath)
{
if (!FabricDirectory.Exists(directoryPath))
{
FabricDirectory.CreateDirectory(directoryPath);
}
}
public void FabricDirectory_DeleteNonRecursiveEmptyFolder()
{
Directory.CreateDirectory(this.testPath);
LogHelper.Log("FabricDirectory.Delete {0}", this.testPath);
FabricDirectory.Delete(this.testPath, false, false);
Assert.IsFalse(FabricDirectory.Exists(this.testPath));
}
internal Task <bool> ComplexDataBackupCallbackAsync(Data.BackupInfo backupInfo, CancellationToken cancellationToken)
{
Assert.IsFalse(cancellationToken.IsCancellationRequested);
var complexDataBackupFolderPath = Path.Combine(logFolder, "BackupContainer", Guid.NewGuid().ToString("N"));
FabricDirectory.Copy(backupInfo.Directory, complexDataBackupFolderPath, false);
return(Task.FromResult(true));
}
bool CheckIfBackupExists(string fileOrFolderPath)
{
if (fileOrFolderPath.EndsWith(ZipFileExtension) || fileOrFolderPath.EndsWith(RecoveryPointMetadataFileExtension))
{
return(FabricFile.Exists(fileOrFolderPath));
}
return(FabricDirectory.Exists(fileOrFolderPath));
}
/// <summary>
/// Retrieve files and folders under the current folder from SMB
/// </summary>
/// <param name="srcPath"> The SMB path </param>
/// <param name="files">String array of file names in the folder</param>
/// <param name="folders">String array of subfolder names in the folder</param>
private static void GetFilesAndSubfoldersFromSMB(
string srcPath,
out string[] files,
out string[] folders)
{
files = FabricDirectory.GetFiles(srcPath);
folders = FabricDirectory.GetDirectories(srcPath);
}
private void CreateDirectoryPath(string path)
{
string directoryName = FabricPath.GetDirectoryName(path);
if ((directoryName != null) && (directoryName.Length > 0) && (!FabricDirectory.Exists(directoryName)))
{
FabricDirectory.CreateDirectory(directoryName);
}
}
