private async Task DeleteItem(string filePath, FSItem item)
{
try
{
if (item.ParentIds.Count == 1)
{
if (item.IsUploading)
{
UploadService.CancelUpload(item.Id);
}
else
{
await cloud.Nodes.Trash(item.Id);
}
}
else
{
var dir = Path.GetDirectoryName(filePath);
var dirItem = await FetchNode(dir);
await cloud.Nodes.Remove(dirItem.Id, item.Id);
}
}
catch (AggregateException ex)
{
throw ex.Flatten();
}
catch (CloudException ex) when(ex.Error == HttpStatusCode.NotFound || ex.Error == HttpStatusCode.Conflict)
{
Log.Warn(ex.Error.ToString());
}
}
private async Task MakeUploads(FSItem dest, List <string> files)
{
var currentfiles = new Queue <UploadTaskItem>(files.Select(f => new UploadTaskItem {
Parent = dest, File = f
}));
while (currentfiles.Count > 0)
{
var item = currentfiles.Dequeue();
if (Directory.Exists(item.File))
{
var created = await CheckCreateFolder(item.Parent, Path.GetFileName(item.File));
if (created != null)
{
foreach (var file in Directory.EnumerateFileSystemEntries(item.File))
{
currentfiles.Enqueue(new UploadTaskItem {
Parent = created, File = file
});
}
}
}
else
{
await UploadService.AddUpload(item.Parent, item.File);
}
}
}
private bool disposedValue; // To detect redundant calls
public FSProvider(IHttpCloud cloud, StatisticUpdateDelegate statisticUpdate)
{
onStatisticsUpdated = statisticUpdate;
this.cloud = cloud;
SmallFilesCache = new SmallFilesCache(cloud)
{
OnDownloadStarted =
info =>
{
onStatisticsUpdated(cloud, StatisticUpdateReason.DownloadAdded, new DownloadStatisticInfo(info));
},
OnDownloaded =
info =>
{
onStatisticsUpdated(
cloud,
StatisticUpdateReason.DownloadFinished,
new DownloadStatisticInfo(info));
},
OnDownloadFailed =
info =>
{
onStatisticsUpdated(cloud, StatisticUpdateReason.DownloadFailed, new DownloadStatisticInfo(info));
}
};
uploadService = new UploadService(2, cloud)
{
OnUploadFailed = UploadFailed,
OnUploadFinished = UploadFinished,
OnUploadProgress =
async(item, done) =>
{
await onStatisticsUpdated(
cloud,
StatisticUpdateReason.Progress,
new UploadStatisticInfo(item) { Done = done });
},
OnUploadAdded = async item =>
{
itemsTreeCache.Add(item.ToFSItem());
await onStatisticsUpdated(cloud, StatisticUpdateReason.UploadAdded, new UploadStatisticInfo(item));
},
OnUploadState = async(item, state) =>
{
await onStatisticsUpdated(
cloud,
StatisticUpdateReason.UploadState,
new UploadStatisticInfo(item) { State = state });
}
};
uploadService.Start();
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
itemsTreeCache.Dispose();
UploadService.Dispose();
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
disposedValue = true;
}
}
public void Stop()
{
UploadService.Stop();
}
#pragma warning disable RECS0154 // Parameter is never used
public async Task <IBlockStream> OpenFile(string filePath, FileMode mode, FileAccess fileAccess, FileShare share, FileOptions options)
#pragma warning restore RECS0154 // Parameter is never used
{
var item = await FetchNode(filePath);
if (fileAccess == FileAccess.Read)
{
if (item == null)
{
return(null);
}
Log.Trace($"Opening {filePath} for Read");
if (!item.IsUploading && item.Length < SmallFileSizeLimit)
{
return(SmallFilesCache.OpenReadWithDownload(item));
}
var result = SmallFilesCache.OpenReadCachedOnly(item);
if (result != null)
{
return(result);
}
await WaitForReal(item, 25000);
await onStatisticsUpdated(cloud, StatisticUpdateReason.DownloadAdded, new DownloadStatisticInfo(item));
var buffered = new BufferedHttpCloudBlockReader(item, cloud);
buffered.OnClose = async() =>
{
await onStatisticsUpdated(cloud, StatisticUpdateReason.DownloadFinished, new DownloadStatisticInfo(item));
};
return(buffered);
}
if (item == null || item.Length == 0)
{
Log.Trace($"Creating {filePath} as New because mode:{mode} and {((item == null) ? "item is null" : "length is 0")}");
var dir = Path.GetDirectoryName(filePath);
var name = Path.GetFileName(filePath);
var dirItem = await FetchNode(dir);
item = FSItem.MakeUploading(filePath, Guid.NewGuid().ToString(), dirItem.Id, 0);
var file = UploadService.OpenNew(item);
SmallFilesCache.AddAsLink(item, file.UploadCachePath);
itemsTreeCache.Add(item);
return(file);
}
if (item == null)
{
return(null);
}
await WaitForReal(item, 25000);
if ((mode == FileMode.Create || mode == FileMode.Truncate) && item.Length > 0)
{
Log.Trace($"Opening {filePath} as Truncate because mode:{mode} and length {item.Length}");
item.Length = 0;
SmallFilesCache.Delete(item);
item.MakeUploading();
var file = UploadService.OpenTruncate(item);
return(file);
}
if (mode == FileMode.Open || mode == FileMode.Append || mode == FileMode.OpenOrCreate)
{
Log.Trace($"Opening {filePath} as ReadWrite because mode:{mode} and length {item.Length}");
if (item.Length < SmallFileSizeLimit)
{
var file = SmallFilesCache.OpenReadWrite(item);
file.OnChangedAndClosed = async(it, path) =>
{
it.LastWriteTime = DateTime.UtcNow;
if (!it.IsUploading)
{
it.MakeUploading();
var olditemPath = Path.Combine(SmallFilesCache.CachePath, item.Id);
var newitemPath = Path.Combine(UploadService.CachePath, item.Id);
if (File.Exists(newitemPath))
{
File.Delete(newitemPath);
}
HardLink.Create(olditemPath, newitemPath);
SmallFilesCache.AddExisting(it);
}
await UploadService.AddOverwrite(it);
};
return(file);
}
Log.Warn("File is too big for ReadWrite: " + filePath);
}
return(null);
}
public void CancelUpload(string id)
{
UploadService.CancelUpload(id);
}