/// <summary>
/// Moves a file or folder placeholder in user file system.
/// </summary>
/// <param name="userFileSystemNewPath">New path in user file system.</param>
/// <remarks>
/// This method failes if the file or folder in user file system is modified (not in sync with the remote storage)
/// or if the target file exists.
/// </remarks>
public async Task MoveToAsync(string userFileSystemNewPath)
{
// Cloud Filter API does not provide a function to move a placeholder file only if it is not modified.
// The file may be modified between InSync call, Move() call and SetInSync() in this method.
try
{
// Because of the on-demand population the file or folder placeholder may not exist in the user file system.
if (FsPath.Exists(userFileSystemPath))
{
bool inSync = PlaceholderItem.GetItem(userFileSystemPath).GetInSync();
if (inSync)
{
string eTag = await ETag.GetETagAsync(userFileSystemPath);
ETag.DeleteETag(userFileSystemPath);
try
{
Directory.Move(userFileSystemPath, userFileSystemNewPath);
}
catch
{
await ETag.SetETagAsync(userFileSystemPath, eTag);
throw;
}
await ETag.SetETagAsync(userFileSystemNewPath, eTag);
// The file is marked as not in sync after move/rename. Marking it as in-sync.
PlaceholderItem placeholderItem = PlaceholderItem.GetItem(userFileSystemNewPath);
placeholderItem.SetInSync(true);
placeholderItem.SetOriginalPath(userFileSystemNewPath);
await new UserFileSystemRawItem(userFileSystemNewPath).ClearStateAsync();
}
if (!inSync)
{
throw new ConflictException(Modified.Client, "The item is not in-sync with the cloud.");
}
}
}
catch (Exception ex)
{
string path = FsPath.Exists(userFileSystemNewPath) ? userFileSystemNewPath : userFileSystemPath;
await new UserFileSystemRawItem(userFileSystemPath).SetDownloadErrorStateAsync(ex);
// Rethrow the exception preserving stack trace of the original exception.
System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(ex).Throw();
}
}
//$>
//$<PlaceholderItem.SetItemInfo
/// <summary>
/// Updates information about the file or folder placeholder in the user file system.
/// This method automatically hydrates and dehydrate files.
/// </summary>
/// <remarks>This method failes if the file or folder in user file system is modified (not in-sync with the remote storage).</remarks>
/// <param name="itemInfo">New file or folder info.</param>
/// <returns>True if the file was updated. False - otherwise.</returns>
public async Task <bool> UpdateAsync(FileSystemItemBasicInfo itemInfo)
{
try
{
// Because of the on-demand population the file or folder placeholder may not exist in the user file system.
if (FsPath.Exists(userFileSystemPath))
{
PlaceholderItem placeholderItem = PlaceholderItem.GetItem(userFileSystemPath);
// To be able to update the item we need to remove the read-only attribute.
if ((FsPath.GetFileSystemItem(userFileSystemPath).Attributes | System.IO.FileAttributes.ReadOnly) != 0)
{
FsPath.GetFileSystemItem(userFileSystemPath).Attributes &= ~System.IO.FileAttributes.ReadOnly;
}
// Dehydrate/hydrate the file, update file size, custom data, creation date, modification date, attributes.
placeholderItem.SetItemInfo(itemInfo);
// Set ETag.
await ETag.SetETagAsync(userFileSystemPath, itemInfo.ETag);
// Clear icon.
//await ClearStateAsync();
// Set the "locked by another user" icon and all custom columns data.
await SetLockedByAnotherUserAsync(itemInfo.LockedByAnotherUser);
await SetCustomColumnsDataAsync(itemInfo.CustomProperties);
return(true);
}
}
catch (Exception ex)
{
await SetDownloadErrorStateAsync(ex);
// Rethrow the exception preserving stack trace of the original exception.
System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(ex).Throw();
}
return(false);
}
//$<PlaceholderFolder.CreatePlaceholders
/// <summary>
/// Creates a new file or folder placeholder in user file system.
/// </summary>
/// <param name="userFileSystemParentPath">User file system folder path in which the new item will be created.</param>
/// <param name="newItemsInfo">Array of new files and folders.</param>
/// <returns>Number of items created.</returns>
public static async Task <uint> CreateAsync(string userFileSystemParentPath, FileSystemItemBasicInfo[] newItemsInfo)
{
try
{
// Because of the on-demand population the file or folder placeholder may not exist in the user file system.
// Here we also check that the folder content was loaded into user file system (the folder is not offline).
if (Directory.Exists(userFileSystemParentPath) &&
!new DirectoryInfo(userFileSystemParentPath).Attributes.HasFlag(System.IO.FileAttributes.Offline))
{
// Create placeholders.
uint created = new PlaceholderFolder(userFileSystemParentPath).CreatePlaceholders(newItemsInfo);
// Create ETags.
foreach (FileSystemItemBasicInfo child in newItemsInfo)
{
string userFileSystemItemPath = Path.Combine(userFileSystemParentPath, child.Name);
await ETag.SetETagAsync(userFileSystemItemPath, child.ETag);
// Set the "locked by another user" icon and all custom columns data.
await new UserFileSystemRawItem(userFileSystemItemPath).SetLockedByAnotherUserAsync(child.LockedByAnotherUser);
await new UserFileSystemRawItem(userFileSystemItemPath).SetCustomColumnsDataAsync(child.CustomProperties);
}
return(created);
}
}
catch (ExistsException ex)
{
// "Cannot create a file when that file already exists."
//await new UserFileSystemItem(userFileSystemParentPath).ShowDownloadErrorAsync(ex);
// Rethrow the exception preserving stack trace of the original exception.
System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(ex).Throw();
}
return(0);
}
internal async Task MoveToAsync(string userFileSystemNewPath, IConfirmationResultContext resultContext = null)
{
string userFileSystemOldPath = userFileSystemPath;
try
{
bool? inSync = null;
bool updateTargetOnSuccess = false;
string eTag = null;
try
{
if (!FsPath.IsRecycleBin(userFileSystemNewPath) && // When a file is deleted, it is moved to a Recycle Bin.
!FsPath.AvoidSync(userFileSystemOldPath) && !FsPath.AvoidSync(userFileSystemNewPath))
{
logger.LogMessage("Moving item in remote storage", userFileSystemOldPath, userFileSystemNewPath);
// Read In-Sync state before move and set after move
if (FsPath.Exists(userFileSystemOldPath))
{
inSync = PlaceholderItem.GetItem(userFileSystemOldPath).GetInSync();
}
eTag = await ETag.GetETagAsync(userFileSystemOldPath);
ETag.DeleteETag(userFileSystemOldPath);
IUserFileSystemItem userFileSystemItemOld = await virtualDrive.GetItemAsync <IUserFileSystemItem>(userFileSystemOldPath);
await userFileSystemItemOld.MoveToAsync(userFileSystemNewPath);
updateTargetOnSuccess = true;
logger.LogMessage("Moved succesefully in remote storage", userFileSystemOldPath, userFileSystemNewPath);
}
}
finally
{
if (resultContext != null)
{
resultContext.ReturnConfirmationResult();
}
// This check is just to avoid extra error in the log.
if (FsPath.Exists(userFileSystemNewPath))
{
// Open file to preven reads and changes between GetFileDataSizeInfo() call and SetInSync() call.
using (WindowsFileSystemItem userFileSystemWinItem = WindowsFileSystemItem.OpenReadAttributes(userFileSystemNewPath, FileMode.Open, FileShare.None))
{
if ((eTag != null) && PlaceholderItem.IsPlaceholder(userFileSystemNewPath))
{
await ETag.SetETagAsync(userFileSystemNewPath, eTag);
}
// If a file with content is deleted it is moved to a recycle bin and converted
// to a regular file, so placeholder features are not available on it, checking if a file is a placeholder.
if (updateTargetOnSuccess && PlaceholderItem.IsPlaceholder(userFileSystemNewPath))
{
PlaceholderItem placeholderNew = PlaceholderItem.GetItem(userFileSystemNewPath);
// Update OriginalPath, so the item does not appear as moved.
placeholderNew.SetOriginalPath(userFileSystemNewPath);
if (inSync != null)
{
placeholderNew.SetInSync(inSync.Value);
}
else if ((placeholderNew is PlaceholderFile) && ((PlaceholderFile)placeholderNew).GetFileDataSizeInfo().ModifiedDataSize == 0)
{
placeholderNew.SetInSync(true);
}
await new UserFileSystemRawItem(userFileSystemNewPath).ClearStateAsync();
}
}
}
}
}
catch (Exception ex)
{
string userFileSystemPath = FsPath.Exists(userFileSystemNewPath) ? userFileSystemNewPath : userFileSystemOldPath;
await new UserFileSystemRawItem(userFileSystemPath).SetUploadErrorStateAsync(ex);
// Rethrow the exception preserving stack trace of the original exception.
System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(ex).Throw();
}
}
/// <summary>
/// Creates or updates the item in the remote storage.
/// </summary>
/// <param name="mode">
/// Indicates if the file should created or updated.
/// Supported modes are <see cref="FileMode.CreateNew"/> and <see cref="FileMode.Open"/>
/// </param>
/// <param name="lockInfo">Information about the lock. Pass null if the item is not locked.</param>
private async Task CreateOrUpdateAsync(FileMode mode, ServerLockInfo lockInfo = null)
{
if ((mode != FileMode.CreateNew) && (mode != FileMode.Open))
{
throw new ArgumentOutOfRangeException("mode", $"Must be {FileMode.CreateNew} or {FileMode.Open}");
}
FileSystemInfo userFileSystemItem = FsPath.GetFileSystemItem(userFileSystemPath);
using (WindowsFileSystemItem userFileSystemWinItem = WindowsFileSystemItem.OpenReadAttributes(userFileSystemPath, FileMode.Open, FileShare.Read))
//await using (FileStream userFileSystemStream = userFileSystemFile.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
{
// Create the new file/folder in the remote storage only if the file/folder in the user file system was not moved.
// If the file is moved in user file system, move must first be syched to remote storage.
if ((mode == FileMode.CreateNew) && PlaceholderItem.GetItem(userFileSystemPath).IsMoved())
{
string originalPath = PlaceholderItem.GetItem(userFileSystemPath).GetOriginalPath();
throw new ConflictException(Modified.Client, $"The item was moved. Original path: {originalPath}");
}
// Ensures LastWriteTimeUtc is in sync with file content after Open() was called.
userFileSystemItem.Refresh();
IFileSystemItemBasicInfo info = GetBasicInfo(userFileSystemItem);
// Update remote storage file.
FileStream userFileSystemStream = null;
try
{
string eTag = null;
if (FsPath.IsFile(userFileSystemPath))
{
// File is marked as not in-sync when updated OR moved.
// Opening a file for reading triggers hydration, make sure to open only if content is modified.
if (PlaceholderFile.GetFileDataSizeInfo(userFileSystemWinItem.SafeHandle).ModifiedDataSize > 0)
{
//userFileSystemStream = new FileStream(userFileSystemWinItem.SafeHandle, FileAccess.Read);
userFileSystemStream = ((FileInfo)userFileSystemItem).Open(FileMode.Open, FileAccess.Read, FileShare.Read);
}
if (mode == FileMode.CreateNew)
{
string userFileSystemParentPath = Path.GetDirectoryName(userFileSystemPath);
IUserFolder userFolder = await virtualDrive.GetItemAsync <IUserFolder>(userFileSystemParentPath);
eTag = await userFolder.CreateFileAsync((IFileBasicInfo)info, userFileSystemStream);
}
else
{
IUserFile userFile = await virtualDrive.GetItemAsync <IUserFile>(userFileSystemPath);
eTag = await userFile.UpdateAsync((IFileBasicInfo)info, userFileSystemStream, lockInfo);
}
}
else
{
if (mode == FileMode.CreateNew)
{
string userFileSystemParentPath = Path.GetDirectoryName(userFileSystemPath);
IUserFolder userFolder = await virtualDrive.GetItemAsync <IUserFolder>(userFileSystemParentPath);
eTag = await userFolder.CreateFolderAsync((IFolderBasicInfo)info);
}
else
{
IUserFolder userFolder = await virtualDrive.GetItemAsync <IUserFolder>(userFileSystemPath);
eTag = await userFolder.UpdateAsync((IFolderBasicInfo)info, lockInfo);
}
}
await ETag.SetETagAsync(userFileSystemPath, eTag);
if (mode == FileMode.CreateNew)
{
PlaceholderItem.GetItem(userFileSystemPath).SetOriginalPath(userFileSystemPath);
}
}
finally
{
if (userFileSystemStream != null)
{
userFileSystemStream.Close();
}
}
PlaceholderItem.SetInSync(userFileSystemWinItem.SafeHandle, true);
}
}