/// <summary>
/// Called when a file or folder is created in the user file system.
/// </summary>
/// <remarks>
/// This method is also called when a file is being moved in user file system, after the IFileSystem.MoveToAsync() call.
/// </remarks>
private async void CreatedAsync(object sender, FileSystemEventArgs e)
{
LogMessage($"{e.ChangeType}", e.FullPath);
string userFileSystemPath = e.FullPath;
try
{
// When a file/folder is moved this method is also called. The file/folder move is already processed in IFileSystem.MoveToAsync().
if (FsPath.Exists(userFileSystemPath) && !PlaceholderItem.IsPlaceholder(userFileSystemPath))
{
// When a new file or folder is created under sync root it is
// created as a regular file or folder. Converting to placeholder.
PlaceholderItem.ConvertToPlaceholder(userFileSystemPath, false);
LogMessage("Converted to placeholder", userFileSystemPath);
// Do not create temp MS Office, temp and hidden files in remote storage.
if (!FsPath.AvoidSync(userFileSystemPath))
{
// Create the file/folder in the remote storage.
try
{
await RemoteStorageRawItem.CreateAsync(userFileSystemPath, this);
}
catch (IOException ex)
{
LogError("Creation in remote storage failed. Possibly in use by an application", userFileSystemPath, null, ex);
}
}
}
}
catch (Exception ex)
{
LogError($"{e.ChangeType} failed", userFileSystemPath, null, ex);
}
}
///<inheritdoc>
public async Task MoveToAsync(string userFileSystemNewPath, IOperationContext operationContext, IConfirmationResultContext resultContext)
{
// Here we will simply move the file in remote storage and confirm the operation.
// In your implementation you may implement a more complex scenario with offline operations support.
LogMessage("IFileSystemItem.MoveToAsync()", this.FullPath, userFileSystemNewPath);
string userFileSystemOldPath = this.FullPath;
try
{
bool?inSync = null;
try
{
Program.RemoteStorageMonitorInstance.Enabled = false; // Disable RemoteStorageMonitor to avoid circular calls.
// When a file is deleted, it is moved to a Recycle Bin, that is why we check for recycle bin here.
if (FsPath.Exists(userFileSystemOldPath) && !FsPath.IsRecycleBin(userFileSystemNewPath) &&
!FsPath.AvoidSync(userFileSystemOldPath) && !FsPath.AvoidSync(userFileSystemNewPath))
{
inSync = PlaceholderItem.GetItem(userFileSystemOldPath).GetInSync();
string remoteStorageOldPath = Mapping.MapPath(userFileSystemOldPath);
string remoteStorageNewPath = Mapping.MapPath(userFileSystemNewPath);
FileSystemInfo remoteStorageOldItem = FsPath.GetFileSystemItem(remoteStorageOldPath);
if (remoteStorageOldItem is FileInfo)
{
(remoteStorageOldItem as FileInfo).MoveTo(remoteStorageNewPath);
}
else
{
(remoteStorageOldItem as DirectoryInfo).MoveTo(remoteStorageNewPath);
}
LogMessage("Moved succesefully:", remoteStorageOldPath, remoteStorageNewPath);
}
}
finally
{
resultContext.ReturnConfirmationResult();
// 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.
if ((inSync != null) && PlaceholderItem.IsPlaceholder(userFileSystemNewPath))
{
PlaceholderItem.GetItem(userFileSystemNewPath).SetInSync(inSync.Value);
}
}
}
catch (Exception ex)
{
// remove try-catch when error processing inside CloudProvider is fixed.
LogError("Move failed:", $"From: {this.FullPath} to:{userFileSystemNewPath}", ex);
}
finally
{
Program.RemoteStorageMonitorInstance.Enabled = true;
}
}
/// <summary>
/// Recursively restores OriginalPath and the 'locked' icon.
/// </summary>
/// <param name="userFileSystemNewPath">Path in the user file system to start recursive processing.</param>
private async Task MoveToCompletionRecursiveAsync(string userFileSystemNewPath)
{
if (FsPath.IsFolder(userFileSystemNewPath))
{
if (!new DirectoryInfo(userFileSystemNewPath).Attributes.HasFlag(System.IO.FileAttributes.Offline))
{
//LogMessage("Folder offline, skipping:", userFileSystemFolderPath);
IEnumerable <string> userFileSystemChildren = Directory.EnumerateFileSystemEntries(userFileSystemNewPath, "*");
foreach (string userFileSystemChildPath in userFileSystemChildren)
{
try
{
await MoveToCompletionRecursiveAsync(userFileSystemChildPath);
}
catch (Exception ex)
{
logger.LogError("Failed to complete move", userFileSystemChildPath, null, ex);
}
}
}
}
if (FsPath.Exists(userFileSystemNewPath) && // This check is just to avoid extra error in the log.
!FsPath.IsRecycleBin(userFileSystemNewPath) && // When a file with content is deleted, it is moved to a Recycle Bin.
!FsPath.AvoidAutoLock(userFileSystemNewPath)) // No need to update temp MS Office docs.
{
// Open file to prevent reads and changes between GetFileDataSizeInfo() call and SetInSync() call.
using (WindowsFileSystemItem userFileSystemWinItem = WindowsFileSystemItem.OpenReadAttributes(userFileSystemNewPath, FileMode.Open, FileShare.None))
{
// 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);
await virtualDrive.GetUserFileSystemRawItem(userFileSystemNewPath, logger).ClearStateAsync();
// Update OriginalPath if the item is not new.
// Required for pptx and xlsx files Save As operation.
if (!placeholderNew.IsNew(virtualDrive))
{
// Update OriginalPath, so the item does not appear as moved.
logger.LogMessage("Setting Original Path", userFileSystemNewPath);
placeholderNew.SetOriginalPath(userFileSystemNewPath);
}
// Restore the 'locked' icon.
ServerLockInfo existingLock = await virtualDrive.LockManager(userFileSystemNewPath, logger).GetLockInfoAsync();
await virtualDrive.GetUserFileSystemRawItem(userFileSystemNewPath, logger).SetLockInfoAsync(existingLock);
}
}
}
}
/// <inheritdoc/>
public async Task CloseAsync(IOperationContext operationContext, IResultContext context)
{
// Here, if the file in the user file system is modified (not in-sync), you will send the file content,
// creation time, modification time and attributes to the remote storage.
// We also send ETag, to make sure the changes on the server, if any, are not overwritten.
Logger.LogMessage("IFile.CloseAsync()", UserFileSystemPath);
string userFileSystemFilePath = UserFileSystemPath;
// In case the file is moved it does not exist in user file system when CloseAsync() is called.
if (Engine.ChangesProcessingEnabled &&
FsPath.Exists(userFileSystemFilePath) &&
!FsPath.AvoidSync(userFileSystemFilePath))
{
// In case the file is overwritten it is converted to a regular file prior to CloseAsync().
// we need to convert it back into file/folder placeholder.
if (!PlaceholderItem.IsPlaceholder(userFileSystemFilePath))
{
PlaceholderItem.ConvertToPlaceholder(userFileSystemFilePath, false);
Logger.LogMessage("Converted to placeholder", userFileSystemFilePath);
}
try
{
if (PlaceholderItem.GetItem(userFileSystemFilePath).IsNew(VirtualDrive))
{
// Create new file in the remote storage.
await new RemoteStorageRawItem <IVirtualFile>(userFileSystemFilePath, VirtualDrive, Logger).CreateAsync();
}
else if (!PlaceholderItem.GetItem(userFileSystemFilePath).IsMoved())
{
// Send content to remote storage. Unlock if auto-locked.
await new RemoteStorageRawItem <IVirtualFile>(userFileSystemFilePath, VirtualDrive, Logger).UpdateAsync();
}
}
catch (IOException ex)
{
// Either the file is already being synced in another thread or client or server file is blocked by concurrent process.
// This is a normal behaviour.
// The file must be synched by your synchronyzation service at a later time, when the file becomes available.
Logger.LogMessage("Failed to upload file. Possibly in use by an application or blocked for synchronization in another thread:", ex.Message);
}
}
}
/// <inheritdoc/>
public async Task CloseAsync(IOperationContext operationContext, IResultContext context)
{
// Here, if the file in user file system is modified (not in-sync), we send file content,
// creation time, modification time and attributes to remote storage.
// We also create new ETag, associate it with a file in user file system and send it to the server.
LogMessage("IFile.CloseAsync()", this.FullPath);
string userFileSystemFilePath = this.FullPath;
// In case the file is moved it does not exist in user file system when Close() is called.
if (!FsPath.Exists(userFileSystemFilePath) || FsPath.AvoidSync(userFileSystemFilePath))
{
return;
}
// In case the file is overwritten it is converted to a regular file prior to Close().
// we need to convert it back into file/folder placeholder.
if (!PlaceholderItem.IsPlaceholder(userFileSystemFilePath))
{
PlaceholderItem.ConvertToPlaceholder(userFileSystemFilePath, false);
LogMessage("Converted to placeholder:", userFileSystemFilePath);
}
if (!PlaceholderItem.GetItem(userFileSystemFilePath).GetInSync())
{
LogMessage("Changed:", userFileSystemFilePath);
string remoteStorageFilePath = Mapping.MapPath(userFileSystemFilePath);
try
{
await new RemoteStorageItem(remoteStorageFilePath).UpdateAsync(userFileSystemFilePath);
LogMessage("Updated succesefully:", remoteStorageFilePath);
}
catch (IOException ex)
{
// Either the file is already being synced in another thread or client or server file is blocked by concurrent process.
// This is a normal behaviour.
// The file must be synched by your synchronyzation service at a later time, when the file becomes available.
LogMessage("Failed to upload file. Possibly in use by an application or blocked for synchronization in another thread:", ex.Message);
}
}
}
/// <summary>
/// Called when a file or folder is renamed in the user file system.
/// </summary>
private async void RenamedAsync(object sender, RenamedEventArgs e)
{
// If the item and was previusly filtered by EngineWindows.FilterAsync(),
// for example temp MS Office file was renamed SGE4274H->file.xlsx,
// we need to convert the file to a pleaceholder and upload it to the remote storage.
// We must also
LogMessage("Renamed", e.OldFullPath, e.FullPath);
string userFileSystemOldPath = e.OldFullPath;
string userFileSystemNewPath = e.FullPath;
try
{
if (System.IO.File.Exists(userFileSystemNewPath) &&
!MsOfficeHelper.AvoidMsOfficeSync(userFileSystemNewPath))
{
if (!PlaceholderItem.IsPlaceholder(userFileSystemNewPath))
{
if (engine.CustomDataManager(userFileSystemNewPath).IsNew)
{
await engine.ClientNotifications(userFileSystemNewPath, this).CreateAsync();
}
else
{
LogMessage("Converting to placeholder", userFileSystemNewPath);
PlaceholderItem.ConvertToPlaceholder(userFileSystemNewPath, null, null, false);
await engine.ClientNotifications(userFileSystemNewPath, this).UpdateAsync();
await engine.CustomDataManager(userFileSystemNewPath).RefreshCustomColumnsAsync();
}
}
}
}
catch (Exception ex)
{
LogError($"{e.ChangeType} failed", userFileSystemOldPath, userFileSystemNewPath, ex);
}
}
/// <summary>
/// Completes move. This method is called by the platform.
/// To move item manually use the <see cref="MoveToAsync(string)"/> method instead.
/// Sets In-Sync state based on file content changes,
/// Updates OriginalPath so the file does not appear as moved.
/// </summary>
/// <returns></returns>
internal async Task MoveToCompletionAsync()
{
string userFileSystemNewPath = userFileSystemPath;
if (FsPath.Exists(userFileSystemNewPath) && // This check is just to avoid extra error in the log.
!FsPath.IsRecycleBin(userFileSystemNewPath) && // When a file with content is deleted, it is moved to a Recycle Bin.
!FsPath.AvoidAutoLock(userFileSystemNewPath)) // No need to update temp MS Office docs.
{
// Open file to prevent reads and changes between GetFileDataSizeInfo() call and SetInSync() call.
//using (WindowsFileSystemItem userFileSystemWinItem = WindowsFileSystemItem.OpenReadAttributes(userFileSystemNewPath, FileMode.Open, FileShare.None))
{
// 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);
// Restore In-sync state.
/*
* if (inSync != null)
* {
* placeholderNew.SetInSync(inSync.Value);
* }
* else
*/
if (((placeholderNew is PlaceholderFile) && ((PlaceholderFile)placeholderNew).GetFileDataSizeInfo().ModifiedDataSize == 0) ||
(placeholderNew is PlaceholderFolder))
{
logger.LogMessage("Setting In-Sync state", userFileSystemNewPath);
placeholderNew.SetInSync(true);
}
}
}
// Recursively restore OriginalPath and the 'locked' icon.
await MoveToCompletionRecursiveAsync(userFileSystemNewPath);
}
}
//$<IFileSystemItem.MoveToAsync
///<inheritdoc>
public async Task MoveToAsync(string userFileSystemNewPath, IOperationContext operationContext, IConfirmationResultContext resultContext)
{
string userFileSystemOldPath = this.UserFileSystemPath;
Logger.LogMessage("IFileSystemItem.MoveToAsync()", userFileSystemOldPath, userFileSystemNewPath);
// Process move.
if (Engine.ChangesProcessingEnabled)
{
if (FsPath.Exists(userFileSystemOldPath))
{
await new RemoteStorageRawItem(userFileSystemOldPath, VirtualDrive, Logger).MoveToAsync(userFileSystemNewPath, resultContext);
}
}
else
{
resultContext.ReturnConfirmationResult();
}
// Restore Original Path and locked icon, lost during MS Office transactional save.
if (FsPath.Exists(userFileSystemNewPath) && PlaceholderItem.IsPlaceholder(userFileSystemNewPath))
{
PlaceholderItem userFileSystemNewItem = PlaceholderItem.GetItem(userFileSystemNewPath);
if (!userFileSystemNewItem.IsNew() && string.IsNullOrEmpty(userFileSystemNewItem.GetOriginalPath()))
{
// Restore Original Path.
Logger.LogMessage("Saving Original Path", userFileSystemNewPath);
userFileSystemNewItem.SetOriginalPath(userFileSystemNewPath);
// Restore the 'locked' icon.
bool isLocked = await Lock.IsLockedAsync(userFileSystemNewPath);
ServerLockInfo existingLock = isLocked ? await(await Lock.LockAsync(userFileSystemNewPath, FileMode.Open, LockMode.None, Logger)).GetLockInfoAsync() : null;
await new UserFileSystemRawItem(userFileSystemNewPath).SetLockInfoAsync(existingLock);
}
}
}
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>
/// Recursively synchronizes all files and folders moved in user file system with the remote storage.
/// Synchronizes only folders already loaded into the user file system.
/// </summary>
/// <param name="userFileSystemFolderPath">Folder path in user file system.</param>
internal async Task SyncronizeMovedAsync(string userFileSystemFolderPath)
{
// In case of on-demand loading the user file system contains only a subset of the server files and folders.
// Here we sync folder only if its content already loaded into user file system (folder is not offline).
// The folder content is loaded inside IFolder.GetChildrenAsync() method.
if (new DirectoryInfo(userFileSystemFolderPath).Attributes.HasFlag(System.IO.FileAttributes.Offline))
{
//LogMessage("Folder offline, skipping:", userFileSystemFolderPath);
return;
}
IEnumerable <string> userFileSystemChildren = Directory.EnumerateFileSystemEntries(userFileSystemFolderPath, "*");
//LogMessage("Synchronizing:", userFileSystemFolderPath);
foreach (string userFileSystemPath in userFileSystemChildren)
{
string userFileSystemOldPath = null;
try
{
//$<PlaceholderItem.IsPlaceholder
if (!PlaceholderItem.IsPlaceholder(userFileSystemPath))
{
// Convert regular file/folder to placeholder.
// The file/folder was created or overwritten.
PlaceholderItem.ConvertToPlaceholder(userFileSystemPath, false);
LogMessage("Converted to placeholder", userFileSystemPath);
}
//$>
if (!FsPath.AvoidSync(userFileSystemPath))
{
PlaceholderItem userFileSystemItem = PlaceholderItem.GetItem(userFileSystemPath);
if (userFileSystemItem.IsMoved())
{
// Process items moved in user file system.
userFileSystemOldPath = userFileSystemItem.GetOriginalPath();
await new RemoteStorageRawItem(userFileSystemOldPath, this).MoveToAsync(userFileSystemPath);
}
else
{
// Restore Original Path and 'locked' icon that are lost during MS Office transactional save.
// We keep Original Path to process moved files when app was not running.
userFileSystemOldPath = userFileSystemItem.GetOriginalPath();
if (!userFileSystemItem.IsNew() && string.IsNullOrEmpty(userFileSystemOldPath))
{
// Restore Original Path.
LogMessage("Saving Original Path", userFileSystemItem.Path);
userFileSystemItem.SetOriginalPath(userFileSystemItem.Path);
// Restore the 'locked' icon.
bool isLocked = await Lock.IsLockedAsync(userFileSystemPath);
await new UserFileSystemRawItem(userFileSystemPath).SetLockIconAsync(isLocked);
}
}
}
}
catch (Exception ex)
{
LogError("Move in remote storage failed", userFileSystemOldPath, userFileSystemPath, ex);
}
// Synchronize subfolders.
try
{
if (FsPath.IsFolder(userFileSystemPath))
{
await SyncronizeMovedAsync(userFileSystemPath);
}
}
catch (Exception ex)
{
LogError("Folder move sync failed", userFileSystemPath, null, ex);
}
}
}