/// <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);
}
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());
}
public static void SafeFileReplace(string currentFilePath, string newFilePath, string backupFilePath, string traceType)
{
if (FabricFile.Exists(backupFilePath))
{
FabricFile.Delete(backupFilePath);
}
if (FabricFile.Exists(backupFilePath))
{
TestableAssertHelper.FailInvalidData(traceType, "CheckpointFileHelper.SafeFileReplace", "!FabricFile.Exists(backupFilePath) : {0}", backupFilePath);
}
// Previous replace could have failed in the middle before the next metadata table file got renamed to current.
if (!FabricFile.Exists(currentFilePath))
{
FabricFile.Move(newFilePath, currentFilePath);
}
else
{
FabricFile.Replace(newFilePath, currentFilePath, backupFilePath, ignoreMetadataErrors: false);
}
if (FabricFile.Exists(backupFilePath))
{
FabricFile.Delete(backupFilePath);
}
if (FabricFile.Exists(backupFilePath))
{
TestableAssertHelper.FailInvalidData(traceType, "CheckpointFileHelper.SafeFileReplace", "!FabricFile.Exists(backupFilePath) : {0}", backupFilePath);
}
}
/// <summary>
/// Open an existing <see cref="RecoveryPointMetadataFile"/> from the given file path.
/// </summary>
/// <param name="recoveryPointMetadataFilePath">Path of the recovery point meta data file.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>The read <see cref="RecoveryPointMetadataFile"/>.</returns>
public static async Task <RecoveryPointMetadataFile> OpenAsync(
string recoveryPointMetadataFilePath,
CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(recoveryPointMetadataFilePath))
{
throw new ArgumentException(
string.Format(CultureInfo.CurrentCulture,
SR.Error_NullArgument_Formatted,
"recoveryPointMetadataFilePath"));
}
if (!FabricFile.Exists(recoveryPointMetadataFilePath))
{
throw new ArgumentException(
string.Format(
CultureInfo.CurrentCulture,
SR.Error_FilePath_Null,
recoveryPointMetadataFilePath),
"recoveryPointMetadataFilePath");
}
// Open the file with asynchronous flag and 4096 cache size (C# default).
using (var filestream = FabricFile.Open(
recoveryPointMetadataFilePath,
FileMode.Open,
FileAccess.Read,
FileShare.Read,
4096,
FileOptions.Asynchronous))
{
return(await OpenAsync(filestream, recoveryPointMetadataFilePath, cancellationToken));
}
}
private Task DeleteLogFileAsync(string fileName)
{
var path = FileLogicalLog.GetFullPathToLog(this.LogFileDirectoryPath, fileName);
if (FabricFile.Exists(path))
{
try
{
FabricFile.Delete(path);
}
catch (Exception ex)
{
// TODO: Exception/HRESULT work needs to be finished: catch (FabricElementNotFoundException)
FabricEvents.Events.LogManagerExceptionInfo(
this.Tracer.Type,
"DeleteLogFileAsync: Delete logical log: " + fileName,
ex.GetType().ToString(),
ex.Message,
ex.HResult,
ex.StackTrace);
}
}
return(Task.FromResult(0));
}
protected override async Task <ILogicalLog> CreateLogFileAsync(
bool createNew,
CancellationToken cancellationToken)
{
var fullLogfileName = FileLogicalLog.GetFullPathToLog(
this.LogFileDirectoryPath,
this.CurrentLogFileAlias);
if (!FabricFile.Exists(fullLogfileName))
{
// If the current log does not exist, try to use the backup file.
var backupfullLogfileName = FileLogicalLog.GetFullPathToLog(
this.LogFileDirectoryPath,
this.CurrentLogFileAlias + BackupSuffix);
if (FabricFile.Exists(backupfullLogfileName))
{
// if the backup file exists, rename it to the current log file name.
FabricFile.Move(backupfullLogfileName, fullLogfileName);
}
}
return(await FileLogicalLog.CreateFileLogicalLog(
fullLogfileName,
this.logWriteFaultInjectionParameters).ConfigureAwait(false));
}
private static T ReadXml <T>(string fileName, XmlReader reader)
{
try
{
var serializer = new XmlSerializer(typeof(T));
T obj = (T)serializer.Deserialize(reader);
return(obj);
}
catch (InvalidOperationException xmlParseException)
{
if (FabricFile.Exists(fileName))
{
ImageBuilder.TraceSource.WriteError(
TraceType,
"Invalid XML Content. File Size: {0}",
FabricFile.GetSize(fileName));
}
else
{
ImageBuilder.TraceSource.WriteError(
TraceType,
"File '{0}' does not exist.",
fileName);
}
TraceAndThrowValidationErrorWithFileName(
xmlParseException,
TraceType,
fileName,
StringResources.ImageBuilderError_ErrorParsingXmlFile,
fileName);
}
return(default(T));
}
/// <summary>
/// Opens a <see cref="ValueCheckpointFile"/> from the given file.
/// The file stream will be disposed when the checkpoint file is disposed.
/// </summary>
/// <param name="filename">The file to open that contains an existing checkpoint file.</param>
/// <param name="traceType">Tracing information.</param>
public static async Task <ValueCheckpointFile> OpenAsync(string filename, string traceType)
{
FabricEvents.Events.ValueCheckpointFileAsyncOpen(traceType, DiskConstants.state_opening, filename);
Diagnostics.Assert(FabricFile.Exists(filename), traceType, "File name {0} does not exist", filename);
ValueCheckpointFile checkpointFile = null;
try
{
checkpointFile = new ValueCheckpointFile(filename);
await checkpointFile.ReadMetadataAsync().ConfigureAwait(false);
}
catch (Exception)
{
// Ensure the checkpoint file get disposed quickly if we get an exception.
if (checkpointFile != null)
{
checkpointFile.Dispose();
}
throw;
}
FabricEvents.Events.ValueCheckpointFileAsyncOpen(traceType, DiskConstants.state_complete, filename);
return(checkpointFile);
}
bool CheckIfBackupExists(string fileOrFolderPath)
{
if (fileOrFolderPath.EndsWith(ZipFileExtension) || fileOrFolderPath.EndsWith(RecoveryPointMetadataFileExtension))
{
return(FabricFile.Exists(fileOrFolderPath));
}
return(FabricDirectory.Exists(fileOrFolderPath));
}
public static T ReadXml <T>(string fileName, XmlReaderSettings validatingXmlReaderSettings)
{
#if !DotNetCoreClr
// Ensure the XmlResolve is set to null
validatingXmlReaderSettings.XmlResolver = null;
#endif
using (var stream = FabricFile.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var xmlReader = XmlReader.Create(stream, validatingXmlReaderSettings))
{
T v = ReadXml <T>(fileName, xmlReader);
#if DotNetCoreClr
try
{
var applicationManifestType = v as IXmlValidator;
if (applicationManifestType != null)
{
applicationManifestType.Validate();
}
}
catch (InvalidOperationException xmlParseException)
{
if (FabricFile.Exists(fileName))
{
ImageBuilder.TraceSource.WriteError(
TraceType,
"Invalid XML Content. File Size: {0}",
FabricFile.GetSize(fileName));
}
else
{
ImageBuilder.TraceSource.WriteError(
TraceType,
"File '{0}' does not exist.",
fileName);
}
TraceAndThrowValidationErrorWithFileName(
xmlParseException,
TraceType,
fileName,
StringResources.ImageBuilderError_ErrorParsingXmlFile,
fileName);
}
catch (XmlException xmlException)
{
TraceAndThrowValidationErrorWithFileName(
xmlException,
TraceType,
fileName,
StringResources.ImageBuilderError_ErrorParsingXmlFile,
fileName);
}
#endif
return(v);
}
}
private static async Task <ConditionalValue <CheckpointManager <T> > > TryReadCheckpointFile(
string directory,
string fileName,
IStateSerializer <T> valueSerializer,
string traceType)
{
var filePath = Path.Combine(directory, fileName);
if (!FabricFile.Exists(filePath))
{
return(new ConditionalValue <CheckpointManager <T> >(false, default(CheckpointManager <T>)));
}
using (var stream = FabricFile.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan))
{
var intSegment = new ArraySegment <byte>(new byte[sizeof(int)]);
var versionRead = await SerializationHelper.ReadIntAsync(intSegment, stream).ConfigureAwait(false);
if (versionRead != FileVersion)
{
throw new InvalidDataException(string.Format("versionRead '{0}' != FileVersion '{1}'", versionRead, FileVersion));
}
var nameLength = await SerializationHelper.ReadIntAsync(intSegment, stream).ConfigureAwait(false);
if (nameLength < 0)
{
throw new InvalidDataException(string.Format("nameLength '{0}' < 0", nameLength));
}
if (nameLength == 0)
{
return(new ConditionalValue <CheckpointManager <T> >(true, new CheckpointManager <T>(null, directory, fileName, valueSerializer, traceType)));
}
var nameSegment = new ArraySegment <byte>(new byte[nameLength]);
await SerializationHelper.ReadBytesAsync(nameSegment, nameLength, stream).ConfigureAwait(false);
string name;
using (var reader = new InMemoryBinaryReader(new MemoryStream(nameSegment.Array)))
{
name = reader.ReadString();
}
var path = Path.Combine(directory, name);
if (!FabricFile.Exists(path))
{
throw new InvalidDataException(string.Format("Current checkpoint file does not exist: {0}", path));
}
return(new ConditionalValue <CheckpointManager <T> >(
true,
new CheckpointManager <T>(new Checkpoint <T>(directory, name, valueSerializer, traceType), directory, fileName, valueSerializer, traceType)));
}
}
public void UploadContent(string tag, string sourceSoftLink, IImageStoreProgressHandler handler, TimeSpan timeout, CopyFlag copyFlag, bool acquireSourceReaderLock)
{
TimeoutHelper helper = timeout == TimeSpan.MaxValue ? null : new TimeoutHelper(timeout);
sourceSoftLink = this.GetLocalPath(sourceSoftLink);
if ((!FabricFile.Exists(sourceSoftLink)) &&
(!FabricDirectory.Exists(sourceSoftLink)))
{
throw new IOException(
string.Format(
CultureInfo.CurrentCulture,
StringResources.ImageStoreError_DoesNotExistError,
sourceSoftLink));
}
try
{
using (XStoreFileOperations xstoreFileOperation =
new XStoreFileOperations(new XStoreParameters(this.providerParams.ConnectionString, this.providerParams.SecondaryConnectionString, this.providerParams.ContainerName)))
{
tag = XStoreCommon.FormatXStoreUri(tag);
if (copyFlag == CopyFlag.AtomicCopy)
{
this.DeleteContent(tag, helper == null ? timeout : helper.GetRemainingTime());
}
if (FabricFile.Exists(sourceSoftLink))
{
// This is a file copy
xstoreFileOperation.CopyFile(
sourceSoftLink,
tag,
XStoreFileOperationType.CopyFromSMBToXStore,
helper);
}
else
{
// this is a folder copy
xstoreFileOperation.CopyFolder(
sourceSoftLink,
tag,
XStoreFileOperationType.CopyFromSMBToXStore,
copyFlag,
null,
null,
helper);
}
}
}
catch (Exception ex)
{
this.HandleException(ex);
throw;
}
}
public bool FileExists(string filePath)
{
if (isArchive)
{
return(ImageBuilderUtility.IsInArchive(this.DirectoryOrArchivePath, filePath));
}
else
{
return(FabricFile.Exists(Path.Combine(this.DirectoryOrArchivePath, filePath)));
}
}
public void Copy(string targetDirectory, bool overwrite)
{
var targetPath = Path.Combine(targetDirectory, this.FileName);
if (!FabricFile.Exists(this.FilePath))
{
throw new InvalidOperationException(string.Format("Checkpoint file not found at path {0}", this.FilePath));
}
FabricFile.Copy(this.FilePath, targetPath, overwrite);
}
public bool HasEtlFileBeenFullyProcessed(string etlFileName)
{
var etlFileFullPath = Path.Combine(
this.traceDirectory,
etlFileName);
var markerFileFullPath = Path.Combine(
this.markerFileDirectory,
etlFileName);
return((false == FabricFile.Exists(etlFileFullPath)) || FabricFile.Exists(markerFileFullPath));
}
public static void DeleteTempLocation(string location)
{
if (!string.IsNullOrEmpty(location) && FabricDirectory.Exists(location))
{
FabricDirectory.Delete(location, recursive: true, deleteReadOnlyFiles: true);
}
else if (!string.IsNullOrEmpty(location) && FabricFile.Exists(location))
{
FabricFile.Delete(location, deleteReadonly: true);
}
}
/// <summary>
/// Moves the temporary checkpoint file to the checkpoint file.
/// </summary>
/// <returns>Asynchronous operation the represents the file replace.</returns>
/// <remarks>
/// Code depends on only being called in cases where next (tmp) checkpoint exists.
/// </remarks>
public static async Task SafeFileReplaceAsync(
string checkpointFileName,
string temporaryCheckpointFileName,
string backupCheckpointFileName,
string traceType)
{
if (string.IsNullOrEmpty(checkpointFileName))
{
throw new ArgumentException("Checkpoint file name is null or empty.", "checkpointFileName");
}
if (string.IsNullOrEmpty(temporaryCheckpointFileName))
{
throw new ArgumentException("Temporary file name is null or empty.", "temporaryCheckpointFileName");
}
if (string.IsNullOrEmpty(backupCheckpointFileName))
{
throw new ArgumentException("Backup file name is null or empty.", "backupCheckpointFileName");
}
// Delete previous backup, if it exists.
if (FabricFile.Exists(backupCheckpointFileName))
{
FabricFile.Delete(backupCheckpointFileName);
}
// Previous replace could have failed in the middle before the next checkpoint file got renamed to current.
if (!FabricFile.Exists(checkpointFileName))
{
// Validate the next file is complete (this will throw InvalidDataException if it's not valid).
var nextCheckpointFile = await OpenAsync(temporaryCheckpointFileName, traceType, CancellationToken.None).ConfigureAwait(false);
// Next checkpoint file is valid. Move it to be current.
// MCoskun: Note that FabricFile.Move is MOVEFILE_WRITE_THROUGH by default.
// Note using this flag can cause undetected dataloss.
FabricFile.Move(temporaryCheckpointFileName, checkpointFileName);
}
else
{
// Current exists, so we must have gotten here only after writing a valid next checkpoint file.
// MCoskun: Note that FabricFile.Move is MOVEFILE_WRITE_THROUGH by default.
// NTFS guarantees that this operation will not be lost as long as MOVEFILE_WRITE_THROUGH is on.
// If NTFS metadata log's tail is not flushed yet, it will be flushed before this operation is logged with FUA.
// Note that ReplaceFile is not guaranteed to be persisted even after it returns.
// #9291020: Using ReplaceFile here instead of MoveFile with MOVEFILE_WRITE_THROUGH can cause data-loss
FabricFile.Move(checkpointFileName, backupCheckpointFileName);
FabricFile.Move(temporaryCheckpointFileName, checkpointFileName);
// Delete the backup file.
FabricFile.Delete(backupCheckpointFileName);
}
}
private static ulong GetNewContainerInstanceIdAtomic(
ContainerDescription containerDesc)
{
#if DotNetCoreClrLinux
// There is a file called containerid in
// /log/application/partitionid/servicepackageactivationid/codepackagename/
// This file contains the number corresponding to the latest folder for logs
// /mnt/log/application/partitionid/servicepackageactivationid/codepackagename/number/application.log
//
// For the first instance of thecontainer, create a new file and start at 0,
// For every container afterwards, check the file exists, read from the file
// and add 1 to the value in the file in order to get the new current instance id
// and save the value to the file.
var applicationNamePart = containerDesc.ApplicationName;
var applicationNameExtraPart = string.Format("{0}/", RootNamingUriString);
if (applicationNamePart.StartsWith(applicationNameExtraPart))
{
applicationNamePart = applicationNamePart.Substring(applicationNameExtraPart.Length);
}
applicationNamePart = applicationNamePart.Replace('/', '_');
var digestedApplicationName = applicationNamePart + DigestedApplicationNameDockerSuffix;
var logRoots = "/mnt/logs";
var logPath = Path.Combine(logRoots, digestedApplicationName, containerDesc.PartitionId, containerDesc.ServicePackageActivationId, containerDesc.CodePackageName);
if (!FabricDirectory.Exists(logPath))
{
FabricDirectory.CreateDirectory(logPath);
}
ulong containerId = 0;
var containerInstanceIdFilePath = Path.Combine(logPath, CodePackageInstanceIdFileName);
if (!FabricFile.Exists(containerInstanceIdFilePath))
{
using (var containerIdFile = FabricFile.Create(containerInstanceIdFilePath))
{
containerId = 0;
}
}
else
{
containerId = ReadContainerIdFromFile(containerInstanceIdFilePath) + 1;
}
WriteContainerIdToFile(containerInstanceIdFilePath, containerId);
return(containerId);
#else
return(0);
#endif
}
/// <summary>
/// Get the image store content information including all files and subfolders
/// </summary>
/// <param name="storeSource">The relative path to file or folder from image store root</param>
/// <param name="isRecursive">flag list subhierarchy</param>
/// <param name="timeout">The timeout for performing the listing operation</param>
/// <returns>ImageStoreContent object including files and subfolders</returns>
public ImageStoreContent ListContentWithDetails(string storeSource, bool isRecursive, TimeSpan timeout)
{
ImageStoreContent content = null;
try
{
string smbTag = this.ConvertTagToSMBPath(storeSource);
if (!FabricDirectory.Exists(smbTag))
{
if (FabricFile.Exists(smbTag))
{
var fullSourcePath = FabricPath.GetFullPath(storeSource);
content = new ImageStoreContent()
{
Files = new List <ImageStoreFile>()
{
this.ConvertToImageStoreFile(fullSourcePath, storeSource)
}
};
}
else
{
TraceSource.WriteWarning(
TraceType,
"Directory/File {0} doesn't exist",
smbTag);
}
}
else
{
content = isRecursive
? new ImageStoreContent()
{
Files = this.GetAllFiles(smbTag, storeSource).ToList()
}
: this.GetFilesAndSubFolders(smbTag, storeSource, timeout);
}
}
catch (IOException exception)
{
if (exception.GetType() == typeof(IOException))
{
throw new FabricImageStoreException(string.Format(CultureInfo.CurrentCulture, StringResources.Error_ImageStoreIOException, exception));
}
else
{
throw;
}
}
return(content);
}
public static string EnsureHashFile(string resourcePath, string hashFilePath, bool imageStoreServiceEnabled)
{
if (!FabricFile.Exists(hashFilePath))
{
string checksum = ChecksumUtility.ComputeHash(resourcePath, imageStoreServiceEnabled);
ImageBuilderUtility.WriteStringToFile(hashFilePath, checksum);
return(checksum);
}
else
{
return(ImageBuilderUtility.ReadStringFromFile(hashFilePath));
}
}
private bool TryUpdateLocalMap(int retryCount, string localMapDestinationDir, string localMapDestination, DateTime sourceLastWriteTime)
{
// Record the source file's last write time based on the snapshot
// we took before copying the source file. We know that we copied
// over a version that it at least as new as the timestamp in the
// snapshot.
// Figure out in which directory in the local map we will
// record information about this file. Create that directory
// if it doesn't exist.
if ((false == string.IsNullOrEmpty(localMapDestinationDir)) &&
(false == FabricDirectory.Exists(localMapDestinationDir)))
{
try
{
Utility.PerformIOWithRetries(
() => { FabricDirectory.CreateDirectory(localMapDestinationDir); },
retryCount);
}
catch (Exception e)
{
this.TraceSource.WriteExceptionAsError(
this.LogSourceId,
e,
"Failed to create directory {0} in the local map of uploaded files.",
localMapDestinationDir);
return(false);
}
}
// If the file doesn't exist in the local map, create it.
if (false == FabricFile.Exists(localMapDestination))
{
if (!this.TryCreateLocalMapFile(retryCount, localMapDestination, sourceLastWriteTime))
{
return(false);
}
}
else
{
// File already exists in the local map. Set the last
// write time for the file in the local map to the last
// write time from the source file snapshot
// It's a Best Effort operation.
this.TryUpdateLastWriteTime(localMapDestination, sourceLastWriteTime);
}
return(true);
}
/// <summary>
/// Compare two files and return true if they are different.
/// </summary>
/// <param name="firstFilename">The name of the first file to compare.</param>
/// <param name="secondFilename">The name of the second file to compare.</param>
/// <returns>True if the files are different, false otherwise </returns>
public bool AreFilesDifferent(string firstFilename, string secondFilename)
{
this.ThrowIfDisposed();
if (this.copyFlag == CopyFlag.AtomicCopy || this.copyFlag == CopyFlag.AtomicCopySkipIfExists)
{
return(true);
}
else
{
return(FabricFile.Exists(firstFilename) != FabricFile.Exists(secondFilename) ||
FabricFile.GetSize(firstFilename) != FabricFile.GetSize(secondFilename) ||
FabricFile.GetLastWriteTime(firstFilename) != FabricFile.GetLastWriteTime(firstFilename));
}
}
internal static void CreateHardLinkOrCopyFile(string sourceFileName, string destinationFileName)
{
if (!FabricFile.Exists(sourceFileName))
{
return;
}
// Since the source file won't be changed, we can simply create a hardlink
if (!FabricFile.CreateHardLink(destinationFileName, sourceFileName))
{
// Hardlink can fail, e.g. if the destination is on another drive or the drive isn't NTFS.
// Fallback to a full file copy.
FabricFile.Copy(sourceFileName, destinationFileName, overwrite: true);
}
}
private static void GenerateChecksumFile(
string fileOrDirectoryPath,
BuildLayoutSpecification layoutSpecification,
bool isImageStoreServiceEnabled)
{
var checksumFileName = layoutSpecification.GetChecksumFile(fileOrDirectoryPath);
if (FabricFile.Exists(checksumFileName))
{
FabricFile.Delete(checksumFileName);
}
var checksumValue = ChecksumUtility.ComputeHash(fileOrDirectoryPath, isImageStoreServiceEnabled);
WriteStringToFile(checksumFileName, checksumValue);
}
public static bool TryDeleteCopyFile(string directory, string traceType)
{
var filePath = GetCopyFilePath(directory);
if (!FabricFile.Exists(filePath))
{
return(false);
}
FabricFile.Delete(filePath);
if (FabricFile.Exists(filePath))
{
TestableAssertHelper.FailInvalidData(traceType, "CheckpointFileHelper.TryDeleteCopyFile", "!FabricFile.Exists(filePath). filePath: {0}", filePath);
}
return(true);
}
/// <summary>
/// Try to delete the file.
/// </summary>
/// <param name="filePath">The complete path of the file to be deleted.</param>
private static void TryDeleteFile(string filePath)
{
try
{
if (FabricFile.Exists(filePath))
{
FabricFile.Delete(filePath, deleteReadonly: true);
}
}
catch (Exception e)
{
if (!ExceptionHandler.IsIOException(e))
{
throw;
}
}
}
public void Copy(string targetDirectory, bool overwrite)
{
var sourcePath = Path.Combine(this.directory, this.FileName);
var targetPath = Path.Combine(targetDirectory, this.FileName);
if (!FabricFile.Exists(sourcePath))
{
throw new ArgumentException(string.Format("Checkpoint Manager file not found in directory {0}", this.directory), "this.directory");
}
if (this.CurrentCheckpoint != null)
{
this.CurrentCheckpoint.Copy(targetDirectory, overwrite);
}
FabricFile.Copy(sourcePath, targetPath, overwrite);
}
internal bool OkToDeleteFile(FolderTrimmer.FolderDeletionInfo folderInfo, string fileName)
{
string relativePath = (string)folderInfo.Context;
string pathOnLocalNode;
if (string.IsNullOrEmpty(relativePath))
{
pathOnLocalNode = Path.Combine(this.sourceFolder, fileName);
}
else
{
pathOnLocalNode = Path.Combine(
this.sourceFolder,
relativePath,
fileName);
}
return(false == FabricFile.Exists(pathOnLocalNode));
}
public void OpenLastEndTimeFile()
{
// Check if file exists as an optimization before trying to open.
if (this.Mode == FileMode.Open && !FabricFile.Exists(this.FileName))
{
return;
}
try
{
this.Fs = FabricFile.Open(this.FileName, this.Mode, this.Access);
#if !DotNetCoreClrLinux
Helpers.SetIoPriorityHint(this.Fs.SafeFileHandle, Kernel32Types.PRIORITY_HINT.IoPriorityHintVeryLow);
#endif
}
catch (FileNotFoundException)
{
// File was not found. This is not an error.
}
}
private static void DeleteTargetInformationFile(string targetInformationFile)
{
if (FabricFile.Exists(targetInformationFile))
{
try
{
DeployerTrace.WriteInfo("Attempting to delete TargetInformationFile.");
FabricFile.Delete(targetInformationFile, true);
}
catch (Exception ex)
{
DeployerTrace.WriteError("Failed to delete: {0}. Exception: {1}.", targetInformationFile, ex);
throw;
}
}
else
{
DeployerTrace.WriteWarning("TargetInformationFile does not exist.");
}
}
