public override object Handle(FileDeleteArguments arguments)
{
Guard.NotNull(arguments, nameof(arguments));
var resolver = new FileResolver(Root);
FileResolveResult resolveResult = resolver.TryResolveFile(arguments.Path);
if (resolveResult.ExistingFileOrNull != null)
{
DeleteFile(resolveResult.ExistingFileOrNull, resolveResult.ContainingDirectory, arguments);
}
return(Missing.Value);
}
public override bool Handle(EntryExistsArguments arguments)
{
Guard.NotNull(arguments, nameof(arguments));
if (arguments.Path == null)
{
return(false);
}
var resolver = new FileResolver(Container);
FileResolveResult resolveResult = resolver.TryResolveFile(arguments.Path);
return(resolveResult.ExistingFileOrNull != null);
}
public override IFileStream Handle(FileOpenArguments arguments)
{
Guard.NotNull(arguments, nameof(arguments));
FileAccess fileAccess = DetectFileAccess(arguments);
AssertValidCombinationOfModeWithAccess(arguments.Mode, fileAccess);
var resolver = new FileResolver(Root);
FileResolveResult resolveResult = resolver.TryResolveFile(arguments.Path);
return(resolveResult.ExistingFileOrNull != null
? HandleExistingFile(resolveResult.ExistingFileOrNull, fileAccess, arguments)
: HandleNewFile(resolveResult.FileName, resolveResult.ContainingDirectory, fileAccess, arguments));
}
private FileEntry PrepareDestinationFile([NotNull] FileResolveResult destinationResolveResult,
[NotNull] FileEntry sourceFile, [NotNull] FileCopyArguments arguments)
{
DateTime utcNow = Container.SystemClock.UtcNow();
FileEntry destinationFile;
bool isNewlyCreated;
if (destinationResolveResult.ExistingFileOrNull != null)
{
destinationFile = destinationResolveResult.ExistingFileOrNull;
isNewlyCreated = false;
AssertCanOverwriteFile(arguments.Overwrite, arguments.DestinationPath);
AssertIsNotHiddenOrReadOnly(destinationFile, arguments.DestinationPath);
AssertIsNotExternallyEncrypted(destinationFile, arguments.DestinationPath, arguments.IsCopyAfterMoveFailed);
AssertSufficientDiskSpace(sourceFile.Size - destinationFile.Size,
destinationResolveResult.ContainingDirectory.Root);
AddChangeForExistingDestinationFile(destinationFile);
}
else
{
AssertSufficientDiskSpace(sourceFile.Size, destinationResolveResult.ContainingDirectory.Root);
destinationFile = destinationResolveResult.ContainingDirectory.CreateFile(destinationResolveResult.FileName);
destinationFile.CreationTimeUtc = utcNow;
isNewlyCreated = true;
}
using (IFileStream createStream = destinationFile.Open(FileMode.Truncate, FileAccess.Write, arguments.DestinationPath,
isNewlyCreated, false, false))
{
createStream.SetLength(sourceFile.Size);
}
destinationFile.SetAttributes(sourceFile.Attributes);
destinationFile.LastAccessTimeUtc = utcNow;
destinationFile.LastWriteTimeUtc = utcNow;
return(destinationFile);
}
public override IFileStream Handle(FileCreateArguments arguments)
{
Guard.NotNull(arguments, nameof(arguments));
AssertValidCreationOptions(arguments);
var resolver = new FileResolver(Root);
FileResolveResult resolveResult = resolver.TryResolveFile(arguments.Path);
AssertIsNotHiddenOrReadOnly(resolveResult.ExistingFileOrNull, arguments.Path);
FileEntry file = resolveResult.ExistingFileOrNull ??
resolveResult.ContainingDirectory.CreateFile(resolveResult.FileName);
if ((arguments.Options & FileOptions.DeleteOnClose) != 0)
{
file.EnableDeleteOnClose();
}
return(file.Open(FileMode.Create, FileAccess.ReadWrite, arguments.Path));
}
public override FileCopyResult Handle(FileCopyArguments arguments)
{
Guard.NotNull(arguments, nameof(arguments));
pendingContentChanges.Clear();
pendingContentChanges.Add(FileAccessKinds.Write);
FileEntry sourceFile = ResolveSourceFile(arguments.SourcePath, arguments.IsCopyAfterMoveFailed);
FileResolveResult destinationResolveResult = ResolveDestinationFile(arguments);
DateTime? existingDestinationLastWriteTimeUtc = destinationResolveResult.ExistingFileOrNull?.LastWriteTimeUtc;
FileEntry destinationFile = PrepareDestinationFile(destinationResolveResult, sourceFile, arguments);
foreach (FileAccessKinds change in pendingContentChanges)
{
Container.ChangeTracker.NotifyContentsAccessed(destinationFile.PathFormatter, change);
}
IFileStream sourceStream = null;
IFileStream destinationStream = null;
try
{
sourceStream = sourceFile.Open(FileMode.Open, FileAccess.ReadWrite, arguments.SourcePath, false, false, false);
destinationStream = destinationFile.Open(FileMode.Open, FileAccess.Write, arguments.DestinationPath, false, false,
false);
return(new FileCopyResult(sourceFile, sourceStream.AsStream(), destinationFile, destinationStream.AsStream(),
existingDestinationLastWriteTimeUtc));
}
catch (Exception)
{
destinationStream?.Dispose();
sourceStream?.Dispose();
throw;
}
}
private FileEntry ResolveDestinationFile([NotNull] AbsolutePath destinationPath, bool overwrite,
[NotNull] FileEntry sourceFile)
{
var destinationResolver = new FileResolver(Root)
{
ErrorFileFoundAsDirectory = ErrorFactory.System.TargetIsNotFile
};
FileResolveResult resolveResult = destinationResolver.TryResolveFile(destinationPath);
DateTime utcNow = Root.SystemClock.UtcNow();
FileEntry destinationFile;
if (resolveResult.ExistingFileOrNull != null)
{
AssertCanOverwriteFile(overwrite, destinationPath);
AssertIsNotHiddenOrReadOnly(resolveResult.ExistingFileOrNull, destinationPath);
destinationFile = resolveResult.ContainingDirectory.Files[resolveResult.FileName];
}
else
{
destinationFile = resolveResult.ContainingDirectory.CreateFile(resolveResult.FileName);
destinationFile.CreationTimeUtc = utcNow;
}
using (IFileStream createStream = destinationFile.Open(FileMode.Truncate, FileAccess.Write, destinationPath))
{
createStream.SetLength(sourceFile.Size);
}
destinationFile.Attributes = sourceFile.Attributes;
destinationFile.LastAccessTimeUtc = utcNow;
destinationFile.LastWriteTimeUtc = sourceFile.LastWriteTimeUtc;
return(destinationFile);
}
