public static IAccessMode GetEffectivePermissions(
[NotNull] this IUnixDirectoryEntry entry,
[NotNull] IFtpUser ftpUser)
{
var canRead = false;
var canWrite = false;
var canExecute = false;
void UpdatePermissions(
IAccessMode toApply)
{
canRead |= toApply.Read;
canWrite |= toApply.Write;
canExecute |= toApply.Execute;
}
if (entry.Owner == ftpUser.Name)
{
UpdatePermissions(entry.Permissions.User);
}
if (ftpUser.IsInGroup(entry.Group))
{
UpdatePermissions(entry.Permissions.Group);
}
UpdatePermissions(entry.Permissions.Other);
return(new GenericAccessMode(canRead, canWrite, canExecute));
}
public async Task <IReadOnlyList <IUnixFileSystemEntry> > GetEntriesAsync(IUnixDirectoryEntry directoryEntry, CancellationToken cancellationToken)
{
var ret = new List <IUnixFileSystemEntry>();
//handle container listing
if (directoryEntry.IsRoot == true)
{
var containers = _blobClient.ListContainersSegmentedAsync(null).Result;
ret.AddRange(containers.Results.Select(c => new AzureStorageDirectoryEntry(c)));
}
//handle a url inside a container
else
{
var split = directoryEntry.Name.Split('/').Where(s => string.IsNullOrEmpty(s) == false).ToArray();
if (split != null && split.Length > 0)
{
var container = _blobClient.GetContainerReference(split.FirstOrDefault());
var subdir = split.Length > 1 ? string.Join("/", split.Skip(1).Take(split.Length - 1)) : "";
var directoryReference = container.GetDirectoryReference(subdir);
//get blobs in dir
var blobs = await directoryReference.ListBlobsSegmentedAsync(false, BlobListingDetails.Copy, 10000, null, null, null);
ret.AddRange(blobs.Results.Where(b => b.GetType() == typeof(CloudBlobDirectory)).Select(b => new AzureStorageDirectoryEntry(b as CloudBlobDirectory)));
ret.AddRange(blobs.Results.Where(b => b.GetType() != typeof(CloudBlobDirectory)).Select(b => new AzureStorageFileEntry(b as CloudBlockBlob)));
}
}
return(ret);
}
public PermissionsFact(IFtpUser user, IUnixDirectoryEntry?dir, IUnixDirectoryEntry entry)
{
var values = new StringBuilder();
var entryPerm = entry.Permissions.GetAccessModeFor(entry, user);
if (entryPerm.Write)
{
values.Append('c');
values.Append('m');
values.Append('p');
}
if (dir != null)
{
var dirPerm = dir.Permissions.GetAccessModeFor(dir, user);
if (dirPerm.Write && entryPerm.Write)
{
if (!entry.IsRoot && entry.IsDeletable)
{
values.Append('d');
}
values.Append('f');
}
}
if (entryPerm.Read)
{
values.Append('e');
values.Append('l');
}
Value = values.ToString();
}
/// <inheritdoc />
public Task <IUnixFileSystemEntry> MoveAsync(
IUnixDirectoryEntry parent,
IUnixFileSystemEntry source,
IUnixDirectoryEntry target,
string fileName,
CancellationToken cancellationToken)
{
var parentEntry = (InMemoryDirectoryEntry)parent;
var sourceEntry = (InMemoryFileSystemEntry)source;
var targetEntry = (InMemoryDirectoryEntry)target;
targetEntry.Children.Add(fileName, source);
if (!parentEntry.Children.Remove(source.Name))
{
targetEntry.Children.Remove(fileName);
throw new FileUnavailableException($"The source file {source.Name} couldn't be found in directory {parentEntry.Name}");
}
var now = DateTimeOffset.Now;
parentEntry.SetLastWriteTime(now);
targetEntry.SetLastWriteTime(now);
sourceEntry.Parent = targetEntry;
return(Task.FromResult(source));
}
public async Task <IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
{
// just file first
if (((AzureBlobFileSystemEntry)source).IsFolder)
{
throw new NotImplementedException();
}
var file = (CloudBlockBlob)((AzureBlobFileEntry)source).Item;
var dir = (CloudBlobDirectory)((AzureBlobDirectoryEntry)target).Item;
var blockblob = dir.GetBlockBlobReference(fileName);
await blockblob.StartCopyAsync(file);
while (blockblob.CopyState.Status == CopyStatus.Pending)
{
await Task.Delay(100);
}
if (blockblob.CopyState.Status != CopyStatus.Success)
{
throw new ApplicationException("Move failed: " + blockblob.CopyState.Status);
}
await file.DeleteAsync();
return(new AzureBlobFileEntry(this, blockblob, blockblob.Properties.Length));
}
public UnixDirectoryEntry(
[NotNull] UnixDirectoryInfo info,
[NotNull] IFtpUser user,
[CanBeNull] UnixUserInfo userInfo,
IUnixDirectoryEntry parent = null)
: base(info)
{
IsRoot = parent == null;
Info = info;
if (parent == null)
{
// Root user
IsDeletable = false;
}
else if (info.Parent == info)
{
// File system root
IsDeletable = false;
}
else if (userInfo != null && (userInfo.UserId == 0 || userInfo.GroupId == 0))
{
IsDeletable = true;
}
else
{
IsDeletable = parent.GetEffectivePermissions(user).Write;
}
}
private async Task <FtpResponse> ExecuteSendAsync(
TcpClient responseSocket,
Stack <IUnixDirectoryEntry> path,
IUnixDirectoryEntry dirEntry,
CancellationToken cancellationToken)
{
var encoding = Data.NlstEncoding ?? Connection.Encoding;
using (var stream = await Connection.CreateEncryptedStream(responseSocket.GetStream()).ConfigureAwait(false))
{
using (var writer = new StreamWriter(stream, encoding, 4096, true)
{
NewLine = "\r\n",
})
{
var entries = await Data.FileSystem.GetEntriesAsync(dirEntry, cancellationToken).ConfigureAwait(false);
var enumerator = new DirectoryListingEnumerator(entries, Data.FileSystem, path, true);
var formatter = new FactsListFormatter(Data.User, enumerator, Data.ActiveMlstFacts, false);
while (enumerator.MoveNext())
{
var name = enumerator.Name;
var entry = enumerator.Entry;
var line = formatter.Format(entry, name);
Connection.Log?.LogDebug(line);
await writer.WriteLineAsync(line).ConfigureAwait(false);
}
await writer.FlushAsync().ConfigureAwait(false);
}
await stream.FlushAsync(cancellationToken).ConfigureAwait(false);
}
// Use 250 when the connection stays open.
return(new FtpResponse(226, "Closing data connection."));
}
/// <inheritdoc/>
public Task <IUnixDirectoryEntry> CreateDirectoryAsync(IUnixDirectoryEntry targetDirectory, string directoryName, CancellationToken cancellationToken)
{
var targetEntry = (CustomDirectoryEntry)targetDirectory;
var newDirInfo = targetEntry.DirectoryInfo.CreateSubdirectory(directoryName);
return(Task.FromResult <IUnixDirectoryEntry>(new CustomDirectoryEntry(newDirInfo, false, SupportsNonEmptyDirectoryDelete)));
}
/// <inheritdoc/>
public Task <IUnixDirectoryEntry> CreateDirectoryAsync(IUnixDirectoryEntry targetDirectory, string directoryName, CancellationToken cancellationToken)
{
var targetEntry = (DotNetDirectoryEntry)targetDirectory;
var newDirInfo = targetEntry.Info.CreateSubdirectory(directoryName);
return(Task.FromResult <IUnixDirectoryEntry>(new DotNetDirectoryEntry(this, newDirInfo, false)));
}
/// <inheritdoc />
public async Task <IBackgroundTransfer> CreateAsync(
IUnixDirectoryEntry targetDirectory,
string fileName,
Stream data,
CancellationToken cancellationToken)
{
var temp = new MemoryStream();
await data.CopyToAsync(temp, 81920, cancellationToken)
.ConfigureAwait(false);
var targetEntry = (InMemoryDirectoryEntry)targetDirectory;
var entry = new InMemoryFileEntry(targetEntry, fileName, temp.ToArray());
targetEntry.Children.Add(fileName, entry);
var now = DateTimeOffset.Now;
targetEntry.SetLastWriteTime(now);
entry
.SetLastWriteTime(now)
.SetCreateTime(now);
return(null);
}
public async Task <IReadOnlyList <IUnixFileSystemEntry> > GetEntriesAsync(IUnixDirectoryEntry directoryEntry, CancellationToken cancellationToken)
{
var dir = (CloudBlobDirectory)((AzureBlobDirectoryEntry)directoryEntry).Item;
var result = new List <IUnixFileSystemEntry>();
foreach (IListBlobItem item in dir.ListBlobs())
{
if (item.GetType() == typeof(CloudBlockBlob))
{
CloudBlockBlob blob = (CloudBlockBlob)item;
// hide the directory holder file from the client
if (blob.Name.Replace(blob.Parent.Prefix, "") == DirectoryHolderFileName)
{
continue;
}
result.Add(new AzureBlobFileEntry(this, blob, blob.Properties.Length));
}
else if (item.GetType() == typeof(CloudBlobDirectory))
{
CloudBlobDirectory directory = (CloudBlobDirectory)item;
result.Add(new AzureBlobDirectoryEntry(this, directory, false));
}
}
return(result);
}
public async Task <IUnixFileSystemEntry> GetEntryByNameAsync(IUnixDirectoryEntry directoryEntry, string name, CancellationToken cancellationToken)
{
var dir = (CloudBlobDirectory)((AzureBlobDirectoryEntry)directoryEntry).Item;
foreach (IListBlobItem item in dir.ListBlobs())
{
if (item.GetType() == typeof(CloudBlockBlob))
{
CloudBlockBlob blob = (CloudBlockBlob)item;
var abf = new AzureBlobFileEntry(this, blob, blob.Properties.Length);
if (abf.Name == name)
{
return((IUnixFileSystemEntry)abf);
}
}
else if (item.GetType() == typeof(CloudBlobDirectory))
{
CloudBlobDirectory directory = (CloudBlobDirectory)item;
var abd = new AzureBlobDirectoryEntry(this, directory, false);
if (abd.Name == name)
{
return((IUnixFileSystemEntry)abd);
}
}
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnixFileSystem"/> class.
/// </summary>
/// <param name="root">The root directory.</param>
/// <param name="user">The current user.</param>
/// <param name="userInfo">The user information.</param>
public UnixFileSystem(
IUnixDirectoryEntry root,
ClaimsPrincipal user,
UnixUserInfo?userInfo)
: this(root, user, userInfo, false)
{
}
public async Task <IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
{
var targetDirEntry = (GcsDirectoryEntry)target;
var targetName = string.Join("/", new string[] { targetDirEntry.FullName.Trim('/'), fileName }).Trim('/');
if (source is GcsFileEntry sourceFileEntry)
{
var sourceDirEntry = (GcsDirectoryEntry)parent;
var sourceName = string.Join("/", new string[] { sourceDirEntry.FullName.Trim('/'), sourceFileEntry.Name }).Trim('/');
try
{
var newObj = await _storageClient.CopyObjectAsync(_bucketName, sourceName,
_bucketName, targetName,
null, cancellationToken);
if (newObj != null)
{
await _storageClient.DeleteObjectAsync(_bucketName, sourceName, null, cancellationToken);
}
}
catch { }
}
else
{
throw new NotSupportedException();
}
return(new GcsDirectoryEntry(this)
{
Name = targetName
});
}
/// <inheritdoc />
public Task <IUnixFileSystemEntry> MoveAsync(
IUnixDirectoryEntry parent,
IUnixFileSystemEntry source,
IUnixDirectoryEntry target,
string fileName,
CancellationToken cancellationToken)
{
var parentEntry = (InMemoryDirectoryEntry)parent;
var sourceEntry = (InMemoryFileSystemEntry)source;
var targetEntry = (InMemoryDirectoryEntry)target;
targetEntry.Children.Add(fileName, source);
if (!parentEntry.Children.Remove(source.Name))
{
targetEntry.Children.Remove(fileName);
return(Task.FromResult <IUnixFileSystemEntry>(null));
}
var now = DateTimeOffset.Now;
parentEntry.SetLastWriteTime(now);
targetEntry.SetLastWriteTime(now);
sourceEntry.Parent = targetEntry;
return(Task.FromResult(source));
}
/// <inheritdoc/>
public async Task <IUnixFileSystemEntry> MoveAsync(
IUnixDirectoryEntry parent,
IUnixFileSystemEntry source,
IUnixDirectoryEntry target,
string fileName,
CancellationToken cancellationToken)
{
var parentEntry = (GoogleDriveDirectoryEntry)parent;
var targetEntry = (GoogleDriveDirectoryEntry)target;
var targetName = FileSystemExtensions.CombinePath(targetEntry.FullName, fileName);
if (source is GoogleDriveFileEntry sourceFileEntry)
{
var newFile = await MoveItem(
parentEntry.File.Id,
targetEntry.File.Id,
sourceFileEntry.File.Id,
fileName,
cancellationToken);
return(new GoogleDriveFileEntry(this, newFile, targetName));
}
else
{
var sourceDirEntry = (GoogleDriveDirectoryEntry)source;
var newDir = await MoveItem(
parentEntry.File.Id,
targetEntry.File.Id,
sourceDirEntry.File.Id,
fileName,
cancellationToken);
return(new GoogleDriveDirectoryEntry(this, newDir, targetName));
}
}
/// <inheritdoc />
public async Task <IUnixFileSystemEntry?> GetEntryByNameAsync(
IUnixDirectoryEntry directoryEntry,
string name,
CancellationToken cancellationToken)
{
var key = S3Path.Combine(((S3DirectoryEntry)directoryEntry).Key, name);
var entry = await GetObjectAsync(key, cancellationToken);
if (entry != null)
{
return(entry);
}
// not a file search for directory
key += '/';
var objects = await ListObjectsAsync(key, true, cancellationToken);
if (objects.Count > 0)
{
return(new S3DirectoryEntry(key));
}
return(null);
}
/// <inheritdoc/>
public async Task <IUnixDirectoryEntry> CreateDirectoryAsync(IUnixDirectoryEntry targetDirectory, string directoryName, CancellationToken cancellationToken)
{
var dirEntry = (GoogleDriveDirectoryEntry)targetDirectory;
var newDir = await Service.CreateDirectoryAsync(dirEntry.File, directoryName, cancellationToken);
return(new GoogleDriveDirectoryEntry(this, newDir, FileSystemExtensions.CombinePath(dirEntry.FullName, newDir.Title)));
}
/// <inheritdoc/>
public async Task <IUnixDirectoryEntry> CreateDirectoryAsync(
IUnixDirectoryEntry targetDirectory,
string directoryName,
CancellationToken cancellationToken)
{
var dirEntry = (GoogleDriveDirectoryEntry)targetDirectory;
var body = new File
{
Name = directoryName,
Parents = new List <string>()
{
dirEntry.File.Id,
},
}.AsDirectory();
var request = Service.Files.Create(body);
request.Fields = FileExtensions.DefaultFileFields;
var newDir = await request.ExecuteAsync(cancellationToken);
return(new GoogleDriveDirectoryEntry(
this,
newDir,
FileSystemExtensions.CombinePath(dirEntry.FullName, newDir.Name)));
}
/// <inheritdoc/>
public async Task <IUnixDirectoryEntry> CreateDirectoryAsync(IUnixDirectoryEntry targetDirectory, string directoryName, CancellationToken cancellationToken)
{
var targetFolderItem = ((OneDriveDirectoryEntry)targetDirectory).Item;
var folderItem = await Service.CreateFolderAsync(Drive.Id, targetFolderItem.Id, directoryName, cancellationToken);
return(new OneDriveDirectoryEntry(this, folderItem, false));
}
/// <inheritdoc/>
public async Task <IReadOnlyList <IUnixFileSystemEntry> > GetEntriesAsync(IUnixDirectoryEntry directoryEntry, CancellationToken cancellationToken)
{
var item = ((OneDriveDirectoryEntry)directoryEntry).Item;
var children = await Service.GetItemChildrenAsync(Drive.Id, item.Id, cancellationToken);
return(await ConvertToUnixFileSystemEntries(item.Id, children, cancellationToken));
}
/// <inheritdoc/>
public async Task <IUnixFileSystemEntry> GetEntryByNameAsync(IUnixDirectoryEntry directoryEntry, string name, CancellationToken cancellationToken)
{
var item = ((OneDriveDirectoryEntry)directoryEntry).Item;
var childId = GetFileId(item.Id, name);
var child = await _cache.TryGet(childId, () => Service.GetChildItemAsync(Drive.Id, item.Id, name, cancellationToken), _defaultCacheTimeSpan);
if (child == null)
{
await _uploadsLock.WaitAsync(cancellationToken);
try
{
var result = _uploads.Values
.Where(x => x.ParentId == item.Id)
.Select(x => new OneDriveFileEntry(this, x.Item, x.FileSize))
.FirstOrDefault();
return(result);
}
finally
{
_uploadsLock.Release();
}
}
return(await ConvertToUnixFileSystemEntry(child, cancellationToken));
}
public PermissionsFact(IFtpUser user, IUnixFileSystem fileSystem, IUnixDirectoryEntry dir, IUnixFileEntry entry)
{
var values = new StringBuilder();
var entryPerm = entry.Permissions.GetAccessModeFor(entry, user);
var dirPerm = dir.Permissions.GetAccessModeFor(dir, user);
if (dirPerm.Write)
{
values.Append('c');
if (entryPerm.Write)
{
if (fileSystem.SupportsAppend)
{
values.Append('a');
}
values.Append('d');
values.Append('f');
}
}
if (entryPerm.Read)
{
values.Append('r');
}
if (entryPerm.Write)
{
values.Append('w');
}
Value = values.ToString();
}
/// <inheritdoc />
public Task <IReadOnlyList <IUnixFileSystemEntry> > GetEntriesAsync(IUnixDirectoryEntry directoryEntry, CancellationToken cancellationToken)
{
var dirEntry = (UnixDirectoryEntry)directoryEntry;
var dirInfo = dirEntry.Info;
var entries = dirInfo.GetFileSystemEntries().Select(x => CreateEntry(dirEntry, x)).ToList();
return(Task.FromResult <IReadOnlyList <IUnixFileSystemEntry> >(entries));
}
/// <summary>
/// Initializes a new instance of the <see cref="UnixFileSystem"/> class.
/// </summary>
/// <param name="root">The root directory.</param>
/// <param name="user">The current user.</param>
/// <param name="userInfo">The user information.</param>
/// <param name="flushStream">Flush the stream after every write operation.</param>
public UnixFileSystem(
IUnixDirectoryEntry root,
ClaimsPrincipal user,
UnixUserInfo?userInfo,
bool flushStream)
: this(root, user, userInfo, flushStream, null)
{
}
/// <inheritdoc/>
public async Task<IUnixFileSystemEntry> GetEntryByNameAsync(IUnixDirectoryEntry directoryEntry, string name, CancellationToken cancellationToken)
{
var dirEntry = (GoogleDriveDirectoryEntry)directoryEntry;
var entries = await ConvertEntries(
dirEntry,
() => Service.FindChildByNameAsync(dirEntry.File, name, cancellationToken),
cancellationToken);
return entries.FirstOrDefault();
}
public UnixFileSystem(
IUnixDirectoryEntry root,
IFtpUser user,
UnixUserInfo?userInfo)
{
_user = user.CreateClaimsPrincipal();
_userInfo = userInfo;
Root = root;
}
/// <summary>
/// Initializes a new instance of the <see cref="UnixFileSystem"/> class.
/// </summary>
/// <param name="root">The root directory.</param>
/// <param name="user">The current user.</param>
/// <param name="userInfo">The user information.</param>
public UnixFileSystem(
[NotNull] IUnixDirectoryEntry root,
[NotNull] IFtpUser user,
[CanBeNull] UnixUserInfo userInfo)
{
_user = user;
_userInfo = userInfo;
Root = root;
}
public Task <IUnixFileSystemEntry> GetEntryByNameAsync(IUnixDirectoryEntry dir, string name, CancellationToken token)
{
var folder = (VirtualDirectory)dir;
var vfs = Parent.Parent.Parent;
var model = vfs.GetFolder(folder.Path, false);
var entry = model[name];
return(Task.FromResult(entry.ToEntry(this, folder)));
}
public async Task <IBackgroundTransfer> CreateAsync(IUnixDirectoryEntry targetDirectory, string fileName, Stream data, CancellationToken cancellationToken)
{
var dir = (CloudBlobDirectory)((AzureBlobDirectoryEntry)targetDirectory).Item;
var blockblob = dir.GetBlockBlobReference(fileName);
blockblob.UploadFromStream(data);
return(null);
}
/// <inheritdoc/>
public async Task<IReadOnlyList<IUnixFileSystemEntry>> GetEntriesAsync(IUnixDirectoryEntry directoryEntry, CancellationToken cancellationToken)
{
var dirEntry = (GoogleDriveDirectoryEntry)directoryEntry;
var entries = await ConvertEntries(
dirEntry,
() => Service.GetChildrenAsync(dirEntry.File, cancellationToken),
cancellationToken);
return entries;
}
/// <inheritdoc />
public Task <IReadOnlyList <IUnixFileSystemEntry> > GetEntriesAsync(
IUnixDirectoryEntry directoryEntry,
CancellationToken cancellationToken)
{
var entry = (InMemoryDirectoryEntry)directoryEntry;
var children = entry.Children.Values.ToList();
return(Task.FromResult <IReadOnlyList <IUnixFileSystemEntry> >(children));
}
/// <inheritdoc/>
public IEnumerable<string> GetPrefix(IUnixDirectoryEntry directoryEntry)
{
var result = new List<string>
{
".",
};
if (!string.IsNullOrEmpty(directoryEntry.Name))
result.Add("..");
return result;
}
/// <inheritdoc/>
public IEnumerable<string> GetPrefix(IUnixDirectoryEntry directoryEntry)
{
var result = new List<string>
{
BuildLine(directoryEntry, null, "."),
};
if (!string.IsNullOrEmpty(directoryEntry.Name))
{
result.Add(BuildLine(directoryEntry, null, ".."));
}
return result;
}
/// <inheritdoc/>
public Task<IUnixFileSystemEntry> GetEntryByNameAsync(IUnixDirectoryEntry directoryEntry, string name, CancellationToken cancellationToken)
{
var searchDirInfo = ((DotNetDirectoryEntry)directoryEntry).Info;
var fullPath = Path.Combine(searchDirInfo.FullName, name);
IUnixFileSystemEntry result;
if (File.Exists(fullPath))
result = new DotNetFileEntry(this, new FileInfo(fullPath));
else if (Directory.Exists(fullPath))
result = new DotNetDirectoryEntry(this, new DirectoryInfo(fullPath), false);
else
result = null;
return Task.FromResult(result);
}
/// <inheritdoc/>
public IEnumerable<string> GetPrefix(IUnixDirectoryEntry directoryEntry)
{
var isRoot = directoryEntry.IsRoot;
var parentDir = _pathEntries.Skip(1).FirstOrDefault() ?? (isRoot ? null : _fileSystem.Root);
var isParentRoot = parentDir?.IsRoot ?? true;
var grandParentDir = _pathEntries.Skip(2).FirstOrDefault() ?? (isParentRoot ? null : _fileSystem.Root);
var result = new List<string>()
{
BuildLine(BuildFacts(parentDir, directoryEntry, new CurrentDirectoryFact()), "."),
};
if (!isRoot)
{
result.Add(BuildLine(BuildFacts(grandParentDir, parentDir, new ParentDirectoryFact()), ".."));
}
return result;
}
/// <inheritdoc/>
public Task<IReadOnlyList<IUnixFileSystemEntry>> GetEntriesAsync(IUnixDirectoryEntry directoryEntry, CancellationToken cancellationToken)
{
var result = new List<IUnixFileSystemEntry>();
var searchDirInfo = ((DotNetDirectoryEntry)directoryEntry).Info;
foreach (var info in searchDirInfo.EnumerateFileSystemInfos())
{
var dirInfo = info as DirectoryInfo;
if (dirInfo != null)
{
result.Add(new DotNetDirectoryEntry(this, dirInfo, false));
}
else
{
var fileInfo = info as FileInfo;
if (fileInfo != null)
{
result.Add(new DotNetFileEntry(this, fileInfo));
}
}
}
return Task.FromResult<IReadOnlyList<IUnixFileSystemEntry>>(result);
}
/// <inheritdoc/>
public Task<IUnixDirectoryEntry> CreateDirectoryAsync(IUnixDirectoryEntry targetDirectory, string directoryName, CancellationToken cancellationToken)
{
var targetEntry = (DotNetDirectoryEntry)targetDirectory;
var newDirInfo = targetEntry.Info.CreateSubdirectory(directoryName);
return Task.FromResult<IUnixDirectoryEntry>(new DotNetDirectoryEntry(this, newDirInfo, false));
}
/// <inheritdoc/>
public async Task<IBackgroundTransfer> CreateAsync(IUnixDirectoryEntry targetDirectory, string fileName, Stream data, CancellationToken cancellationToken)
{
var targetEntry = (DotNetDirectoryEntry)targetDirectory;
var fileInfo = new FileInfo(Path.Combine(targetEntry.Info.FullName, fileName));
using (var output = fileInfo.Create())
{
await data.CopyToAsync(output, _streamBufferSize, cancellationToken);
}
return null;
}
/// <inheritdoc/>
public async Task<IUnixFileSystemEntry> GetEntryByNameAsync(IUnixDirectoryEntry directoryEntry, string name, CancellationToken cancellationToken)
{
var item = ((OneDriveDirectoryEntry)directoryEntry).Item;
var childId = GetFileId(item.Id, name);
var child = await _cache.TryGet(childId, () => Service.GetChildItemAsync(Drive.Id, item.Id, name, cancellationToken), _defaultCacheTimeSpan);
if (child == null)
{
await _uploadsLock.WaitAsync(cancellationToken);
try
{
var result = _uploads.Values
.Where(x => x.ParentId == item.Id)
.Select(x => new OneDriveFileEntry(this, x.Item, x.FileSize))
.FirstOrDefault();
return result;
}
finally
{
_uploadsLock.Release();
}
}
return await ConvertToUnixFileSystemEntry(child, cancellationToken);
}
/// <inheritdoc/>
public async Task<IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
{
var sourceItem = ((OneDriveFileSystemEntry)source).Item;
var sourceId = sourceItem.Id;
var newParentItem = ((OneDriveDirectoryEntry)target).Item;
var newParentRef = new ItemReference()
{
Id = newParentItem.Id,
};
_cache.Remove(GetFileId(sourceItem));
var newItem = await Service.MoveAsync(Drive.Id, sourceId, fileName, newParentRef, cancellationToken);
_cache.Set(GetFileId(newItem), newItem, _defaultCacheTimeSpan);
return await ConvertToUnixFileSystemEntry(newItem, cancellationToken);
}
/// <inheritdoc/>
public async Task<IUnixDirectoryEntry> CreateDirectoryAsync(IUnixDirectoryEntry targetDirectory, string directoryName, CancellationToken cancellationToken)
{
var targetFolderItem = ((OneDriveDirectoryEntry)targetDirectory).Item;
var folderItem = await Service.CreateFolderAsync(Drive.Id, targetFolderItem.Id, directoryName, cancellationToken);
return new OneDriveDirectoryEntry(this, folderItem, false);
}
/// <inheritdoc/>
public async Task<IReadOnlyList<IUnixFileSystemEntry>> GetEntriesAsync(IUnixDirectoryEntry directoryEntry, CancellationToken cancellationToken)
{
var item = ((OneDriveDirectoryEntry)directoryEntry).Item;
var children = await Service.GetItemChildrenAsync(Drive.Id, item.Id, cancellationToken);
return await ConvertToUnixFileSystemEntries(item.Id, children, cancellationToken);
}
/// <inheritdoc/>
public Task<IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
{
throw new NotSupportedException();
}
/// <inheritdoc/>
public async Task<IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
{
var parentEntry = (GoogleDriveDirectoryEntry)parent;
var targetEntry = (GoogleDriveDirectoryEntry)target;
var targetName = FileSystemExtensions.CombinePath(targetEntry.FullName, fileName);
var sourceFileEntry = source as GoogleDriveFileEntry;
if (sourceFileEntry != null)
{
var newFile = await Service.MoveAsync(sourceFileEntry.File, parentEntry.File.Id, targetEntry.File, fileName, cancellationToken);
return new GoogleDriveFileEntry(this, newFile, targetName);
}
var sourceDirEntry = (GoogleDriveDirectoryEntry)source;
var newDir = await Service.MoveAsync(sourceDirEntry.File, parentEntry.File.Id, targetEntry.File, fileName, cancellationToken);
return new GoogleDriveDirectoryEntry(this, newDir, targetName);
}
/// <inheritdoc/>
public Task<IUnixDirectoryEntry> CreateDirectoryAsync(IUnixDirectoryEntry targetDirectory, string directoryName, CancellationToken cancellationToken)
{
throw new NotSupportedException();
}
/// <inheritdoc/>
public Task<IReadOnlyList<IUnixFileSystemEntry>> GetEntriesAsync(IUnixDirectoryEntry directoryEntry, CancellationToken cancellationToken)
{
return Task.FromResult<IReadOnlyList<IUnixFileSystemEntry>>(new List<IUnixFileSystemEntry>());
}
/// <inheritdoc/>
public Task<IUnixFileSystemEntry> GetEntryByNameAsync(IUnixDirectoryEntry directoryEntry, string name, CancellationToken cancellationToken)
{
return Task.FromResult<IUnixFileSystemEntry>(null);
}
/// <inheritdoc/>
public Task<IBackgroundTransfer> CreateAsync(IUnixDirectoryEntry targetDirectory, string fileName, Stream data, CancellationToken cancellationToken)
{
throw new NotSupportedException();
}
/// <inheritdoc/>
public IEnumerable<string> GetSuffix(IUnixDirectoryEntry directoryEntry)
{
return new string[0];
}
/// <inheritdoc/>
public async Task<IUnixDirectoryEntry> CreateDirectoryAsync(IUnixDirectoryEntry targetDirectory, string directoryName, CancellationToken cancellationToken)
{
var dirEntry = (GoogleDriveDirectoryEntry)targetDirectory;
var newDir = await Service.CreateDirectoryAsync(dirEntry.File, directoryName, cancellationToken);
return new GoogleDriveDirectoryEntry(this, newDir, FileSystemExtensions.CombinePath(dirEntry.FullName, newDir.Title));
}
/// <inheritdoc/>
public async Task<IBackgroundTransfer> CreateAsync(IUnixDirectoryEntry targetDirectory, string fileName, Stream data, CancellationToken cancellationToken)
{
var targetFolderItem = ((OneDriveDirectoryEntry)targetDirectory).Item;
var tempData = await _supportFactory.CreateTemporaryData(data, cancellationToken);
var targetId = GetFileId(targetFolderItem.Id, fileName);
var backgroundUploads = new BackgroundUpload(targetId, targetFolderItem.Id, fileName, tempData, this);
await _uploadsLock.WaitAsync(cancellationToken);
try
{
var fileId = GetFileId(targetFolderItem.Id, fileName);
_uploads.Add(fileId, backgroundUploads);
}
finally
{
_uploadsLock.Release();
}
return backgroundUploads;
}
/// <inheritdoc/>
public Task<IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
{
var targetEntry = (DotNetDirectoryEntry)target;
var targetName = Path.Combine(targetEntry.Info.FullName, fileName);
var sourceFileEntry = source as DotNetFileEntry;
if (sourceFileEntry != null)
{
sourceFileEntry.Info.MoveTo(targetName);
return Task.FromResult<IUnixFileSystemEntry>(new DotNetFileEntry(this, new FileInfo(targetName)));
}
var sourceDirEntry = (DotNetDirectoryEntry)source;
sourceDirEntry.Info.MoveTo(targetName);
return Task.FromResult<IUnixFileSystemEntry>(new DotNetDirectoryEntry(this, new DirectoryInfo(targetName), false));
}
/// <inheritdoc/>
public async Task<IBackgroundTransfer> CreateAsync(IUnixDirectoryEntry targetDirectory, string fileName, Stream data, CancellationToken cancellationToken)
{
var targetEntry = (GoogleDriveDirectoryEntry)targetDirectory;
var newFileEntry = await Service.CreateItemAsync(targetEntry.File, fileName, cancellationToken);
var tempData = await _requestFactory.CreateTemporaryData(data, cancellationToken);
var fullPath = FileSystemExtensions.CombinePath(targetEntry.FullName, fileName);
var backgroundUploads = new BackgroundUpload(fullPath, newFileEntry, tempData, this);
await _uploadsLock.WaitAsync(cancellationToken);
try
{
_uploads.Add(backgroundUploads.File.Id, backgroundUploads);
}
finally
{
_uploadsLock.Release();
}
return backgroundUploads;
}
