public async Task <IBackgroundTransfer> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var file = fileEntry as AzureStorageFileEntry;
var ret = await CreateAsync(file.Directory, file.Name, data, cancellationToken);
return(ret);
}
public Task <Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition,
CancellationToken cancellationToken)
{
var file = (CloudBlockBlob)((AzureBlobFileEntry)fileEntry).Item;
return(Task.FromResult(file.OpenRead()));
}
/// <inheritdoc />
public async Task <IBackgroundTransfer> AppendAsync(IUnixFileEntry fileEntry, long?startPosition, Stream data, CancellationToken cancellationToken)
{
var entry = (InMemoryFileEntry)fileEntry;
// Copy original data into memory stream
var temp = new MemoryStream();
temp.Write(entry.Data, 0, entry.Data.Length);
// Set new write position (if given)
if (startPosition.HasValue)
{
temp.Position = startPosition.Value;
}
// Copy given data
await data.CopyToAsync(temp, 81920, cancellationToken)
.ConfigureAwait(false);
// Update data
entry.Data = temp.ToArray();
entry.SetLastWriteTime(DateTimeOffset.Now);
return(null);
}
public async Task <Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition, CancellationToken cancellationToken)
{
var file = fileEntry as AzureStorageFileEntry;
var policy = new SharedAccessBlobPolicy
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessExpiryTime = DateTimeOffset.Now.AddHours(1),
SharedAccessStartTime = DateTimeOffset.Now.AddSeconds(-5)
};
var sas = file.CloudBlob.GetSharedAccessSignature(policy);
var url = $"{file.CloudBlob.Uri}{sas}";
using (var httpClient = new HttpClient())
{
// we use the HttpClient to download the file so that we can pass the stream directly to the client
// the blob storage library forces you to pull the whole stream down first
var ret = await httpClient.GetStreamAsync(url);
if (startPosition > 0)
{
ret.Seek(startPosition, SeekOrigin.Begin);
}
return(ret);
}
}
/// <inheritdoc/>
public Task <IBackgroundTransfer> AppendAsync(
IUnixFileEntry fileEntry,
long?startPosition,
Stream data,
CancellationToken cancellationToken)
{
throw new NotSupportedException();
}
public async Task <IBackgroundTransfer> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var file = (CloudBlockBlob)((AzureBlobFileEntry)fileEntry).Item;
file.UploadFromStream(data);
return(null);
}
/// <inheritdoc/>
public async Task <Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition, CancellationToken cancellationToken)
{
var from = startPosition != 0 ? (long?)startPosition : null;
var fileItem = ((OneDriveFileEntry)fileEntry).Item;
var response = await Service.GetDownloadResponseAsync(Drive.Id, fileItem.Id, from, cancellationToken);
return(new OneDriveDownloadStream(this, fileItem, response, startPosition, fileEntry.Size));
}
/// <inheritdoc />
public Task <IBackgroundTransfer?> AppendAsync(
IUnixFileEntry fileEntry,
long?startPosition,
Stream data,
CancellationToken cancellationToken)
{
throw new InvalidOperationException();
}
/// <inheritdoc/>
public Task <IBackgroundTransfer> AppendAsync(
IUnixFileEntry fileEntry,
long?startPosition,
Stream data,
CancellationToken cancellationToken)
{
throw new NotSupportedException("Resuming uploads is not supported for non-seekable streams.");
}
/// <inheritdoc/>
public async Task <Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition, CancellationToken cancellationToken)
{
var from = startPosition != 0 ? (long?)startPosition : null;
var fe = (GoogleDriveFileEntry)fileEntry;
var response = await Service.GetDownloadResponseAsync(fe.File, from, cancellationToken);
return(new GoogleDriveDownloadStream(response, startPosition, fe.Size));
}
/// <summary>
/// Creates a selection result for a found file.
/// </summary>
/// <param name="foundPathSegments">The found path segments.</param>
/// <param name="document">The found file.</param>
/// <returns>The created selection result.</returns>
public static PathSelectionResult Create(
Stack <IUnixDirectoryEntry> foundPathSegments,
IUnixFileEntry document)
{
return(new PathSelectionResult(
PathSelectionResultType.FoundFile,
document ?? throw new ArgumentNullException(nameof(document)),
foundPathSegments ?? throw new ArgumentNullException(nameof(foundPathSegments)),
null));
}
/// <inheritdoc />
public Task <Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition, CancellationToken cancellationToken)
{
var entry = (InMemoryFileEntry)fileEntry;
var stream = new MemoryStream(entry.Data)
{
Position = startPosition,
};
return(Task.FromResult <Stream>(stream));
}
/// <inheritdoc />
public async Task <IBackgroundTransfer> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var fileInfo = ((UnixFileEntry)fileEntry).Info;
var stream = fileInfo.Open(FileMode.Create, FileAccess.Write, FilePermissions.DEFFILEMODE);
/* Must be ConfigureAwait(true) to stay in the same synchronization context. */
await data.CopyToAsync(stream, 81920, cancellationToken)
.ConfigureAwait(true);
return(null);
}
/// <inheritdoc/>
public Task <Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition, CancellationToken cancellationToken)
{
var fileInfo = ((DotNetFileEntry)fileEntry).Info;
var input = fileInfo.OpenRead();
if (startPosition != 0)
{
input.Seek(startPosition, SeekOrigin.Begin);
}
return(Task.FromResult <Stream>(input));
}
internal PathSelectionResult(
PathSelectionResultType resultType,
[CanBeNull] IUnixFileEntry document,
[NotNull][ItemNotNull] Stack <IUnixDirectoryEntry> foundPathSegments,
[CanBeNull][ItemNotNull] IReadOnlyCollection <string> missingPathSegments)
{
ResultType = resultType;
_document = document;
_foundPathSegments = foundPathSegments;
_missingPathSegments = missingPathSegments ?? Array.Empty <string>();
}
/// <inheritdoc/>
public Task <Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition, CancellationToken cancellationToken)
{
var fileInfo = (FileInfo)((ServerManagerFileEntry)fileEntry).Info;
var input = new FileStream(fileInfo.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
if (startPosition != 0)
{
input.Seek(startPosition, SeekOrigin.Begin);
}
return(Task.FromResult <Stream>(input));
}
/// <inheritdoc/>
public async Task <IBackgroundTransfer> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var fileInfo = ((DotNetFileEntry)fileEntry).Info;
using (var output = fileInfo.OpenWrite())
{
await data.CopyToAsync(output, _streamBufferSize, cancellationToken);
output.SetLength(output.Position);
}
return(null);
}
/// <inheritdoc/>
public async Task <IBackgroundTransfer?> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var fileInfo = ((CustomFileEntry)fileEntry).FileInfo;
using (var output = fileInfo.OpenWrite())
{
await data.CopyToAsync(output, _streamBufferSize, _flushStream, cancellationToken).ConfigureAwait(false);
output.SetLength(output.Position);
}
return(null);
}
public async Task <IBackgroundTransfer> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var gcsFileEntry = (GcsFileEntry)fileEntry;
try
{
var obj = await _storageClient.UploadObjectAsync(_bucketName, gcsFileEntry.FullName, null, data,
null, cancellationToken);
}
catch { }
return(null);
}
/// <inheritdoc/>
public async Task <IBackgroundTransfer> AppendAsync(IUnixFileEntry fileEntry, long?startPosition, Stream data, CancellationToken cancellationToken)
{
var fileInfo = ((DotNetFileEntry)fileEntry).Info;
using (var output = fileInfo.OpenWrite())
{
if (startPosition == null)
{
startPosition = fileInfo.Length;
}
output.Seek(startPosition.Value, SeekOrigin.Begin);
await data.CopyToAsync(output, _streamBufferSize, cancellationToken);
}
return(null);
}
private static string BuildLine(IUnixFileSystemEntry entry, IUnixFileEntry fileEntry, string name)
{
return(string.Format(
CultureInfo.InvariantCulture,
"{0}{1}{2}{3} {4} {5} {6} {7:D13} {8:MMM dd HH:mm} {9}",
fileEntry == null ? "d" : "-",
BuildAccessMode(entry.Permissions.User),
BuildAccessMode(entry.Permissions.Group),
BuildAccessMode(entry.Permissions.Other),
entry.NumberOfLinks,
entry.Owner,
entry.Group,
fileEntry?.Size ?? 0,
entry.LastWriteTime,
name));
}
private static string BuildLine(IUnixFileSystemEntry entry, IUnixFileEntry fileEntry, string name)
{
return string.Format(
CultureInfo.InvariantCulture,
"{0}{1}{2}{3} {4} {5} {6} {7:D13} {8:MMM dd HH:mm} {9}",
fileEntry == null ? "d" : "-",
BuildAccessMode(entry.Permissions.User),
BuildAccessMode(entry.Permissions.Group),
BuildAccessMode(entry.Permissions.Other),
entry.NumberOfLinks,
entry.Owner,
entry.Group,
fileEntry?.Size ?? 0,
entry.LastWriteTime,
name);
}
/// <inheritdoc />
public async Task <IBackgroundTransfer> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var temp = new MemoryStream();
await data.CopyToAsync(temp, 81920, cancellationToken)
.ConfigureAwait(false);
var entry = (InMemoryFileEntry)fileEntry;
entry.Data = temp.ToArray();
var now = DateTimeOffset.Now;
entry.SetLastWriteTime(now);
return(null);
}
/// <inheritdoc />
public async Task <IBackgroundTransfer> AppendAsync(IUnixFileEntry fileEntry, long?startPosition, Stream data, CancellationToken cancellationToken)
{
var fileInfo = ((UnixFileEntry)fileEntry).Info;
var stream = fileInfo.Open(FileMode.Append);
if (startPosition != null)
{
stream.Seek(startPosition.Value, SeekOrigin.Begin);
}
/* Must be ConfigureAwait(true) to stay in the same synchronization context. */
await data.CopyToAsync(stream, 81920, cancellationToken)
.ConfigureAwait(true);
return(null);
}
/// <inheritdoc />
public async Task <Stream> OpenReadAsync(
IUnixFileEntry fileEntry,
long startPosition,
CancellationToken cancellationToken)
{
var stream = await _transferUtility.OpenStreamAsync(
_options.BucketName,
((S3FileSystemEntry)fileEntry).Key,
cancellationToken);
if (startPosition != 0)
{
stream.Seek(startPosition, SeekOrigin.Begin);
}
return(stream);
}
public Task <Stream> OpenReadAsync(IUnixFileEntry file, long startPos, CancellationToken token)
{
var entity = (VirtualFile)file;
var vfs = Parent.Parent.Parent;
var folder = entity.Path.Replace(entity.Name, "");
var model = vfs.GetFolder(folder, false) as VfsFolder;
var entry = model[entity.Name] as IFile;
Guid id;
string arg, relative;
DetermineArgs(vfs, model, entity, out id, out arg, out relative);
ReadFileChunk rfc = (a, b, c, d) =>
vfs.ReadFile(id, arg, relative, a, b, c, d);
var str = new VirtualStream(entry, startPos, rfc);
return(Task.FromResult <Stream>(str));
}
/// <inheritdoc/>
public async Task <IBackgroundTransfer> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var fe = (GoogleDriveFileEntry)fileEntry;
var tempData = await _requestFactory.CreateTemporaryData(data, cancellationToken);
var backgroundUploads = new BackgroundUpload(fe.FullName, fe.File, tempData, this);
await _uploadsLock.WaitAsync(cancellationToken);
try
{
_uploads.Add(backgroundUploads.File.Id, backgroundUploads);
}
finally
{
_uploadsLock.Release();
}
return(backgroundUploads);
}
/// <inheritdoc />
public async Task <IBackgroundTransfer?> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var fileInfo = ((UnixFileEntry)fileEntry).Info;
_logger?.LogTrace("Start writing to {fileName} while replacing old content", fileInfo.FullName);
using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write, FilePermissions.DEFFILEMODE))
{
/* Must be ConfigureAwait(true) to stay in the same synchronization context. */
await data.CopyToAsync(stream, 81920, _flushStream, cancellationToken)
.ConfigureAwait(true);
_logger?.LogTrace("Closing {fileName}", fileInfo.FullName);
}
_logger?.LogTrace("Closed {fileName}", fileInfo.FullName);
return(null);
}
public async Task <Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition, CancellationToken cancellationToken)
{
var gcsFileEntry = (GcsFileEntry)fileEntry;
try
{
var ms = new MemoryStream();
await _storageClient.DownloadObjectAsync(_bucketName, gcsFileEntry.FullName, ms, null, cancellationToken);
var data = ms.ToArray().Skip(Convert.ToInt32(startPosition)).ToArray();
ms = new MemoryStream(data);
return(ms);
}
catch
{
return(null);
}
}
/// <inheritdoc/>
public async Task <Stream> OpenReadAsync(
IUnixFileEntry fileEntry,
long startPosition,
CancellationToken cancellationToken)
{
var from = startPosition != 0 ? (long?)startPosition : null;
var fe = (GoogleDriveFileEntry)fileEntry;
var request = Service.Files.Get(fe.File.Id);
using (var msg = request.CreateRequest())
{
if (from != null)
{
msg.Headers.Range = new RangeHeaderValue(from, null);
}
// Add alt=media to the query parameters.
var uri = new UriBuilder(msg.RequestUri);
if (uri.Query.Length <= 1)
{
uri.Query = "alt=media";
}
else
{
// Remove the leading '?'. UriBuilder.Query doesn't round-trip.
uri.Query = uri.Query.Substring(1) + "&alt=media";
}
msg.RequestUri = uri.Uri;
var response = await request.Service.HttpClient.SendAsync(
msg,
HttpCompletionOption.ResponseHeadersRead,
cancellationToken)
.ConfigureAwait(false);
response.EnsureSuccessStatusCode();
var responseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(new GoogleDriveDownloadStream(response, responseStream, startPosition, fe.Size));
}
}
private static string BuildLine(IUnixFileSystemEntry entry, IUnixFileEntry fileEntry, string name)
{
var lastWriteDate = entry.LastWriteTime ?? new DateTimeOffset(new DateTime(1970, 01, 01));
var format = lastWriteDate.Year == DateTimeOffset.UtcNow.Year
? "{0}{1}{2}{3} {4} {5} {6} {7} {8:MMM dd HH:mm} {9}"
: "{0}{1}{2}{3} {4} {5} {6} {7} {8:MMM dd yyyy} {9}";
return(string.Format(
CultureInfo.InvariantCulture,
format,
fileEntry == null ? "d" : "-",
BuildAccessMode(entry.Permissions.User),
BuildAccessMode(entry.Permissions.Group),
BuildAccessMode(entry.Permissions.Other),
entry.NumberOfLinks,
entry.Owner,
entry.Group,
fileEntry?.Size ?? 0,
lastWriteDate,
name));
}
/// <inheritdoc/>
public async Task<IBackgroundTransfer> AppendAsync(IUnixFileEntry fileEntry, long? startPosition, Stream data, CancellationToken cancellationToken)
{
var fileInfo = ((DotNetFileEntry)fileEntry).Info;
using (var output = fileInfo.OpenWrite())
{
if (startPosition == null)
startPosition = fileInfo.Length;
output.Seek(startPosition.Value, SeekOrigin.Begin);
await data.CopyToAsync(output, _streamBufferSize, cancellationToken);
}
return null;
}
/// <inheritdoc/>
public async Task<IBackgroundTransfer> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var fileInfo = ((DotNetFileEntry)fileEntry).Info;
using (var output = fileInfo.OpenWrite())
{
await data.CopyToAsync(output, _streamBufferSize, cancellationToken);
output.SetLength(output.Position);
}
return null;
}
/// <inheritdoc/>
public async Task<Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition, CancellationToken cancellationToken)
{
var from = startPosition != 0 ? (long?)startPosition : null;
var fe = (GoogleDriveFileEntry)fileEntry;
var response = await Service.GetDownloadResponseAsync(fe.File, from, cancellationToken);
return new GoogleDriveDownloadStream(response, startPosition, fe.Size);
}
/// <inheritdoc/>
public async Task<IBackgroundTransfer> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var fe = (GoogleDriveFileEntry)fileEntry;
var tempData = await _requestFactory.CreateTemporaryData(data, cancellationToken);
var backgroundUploads = new BackgroundUpload(fe.FullName, fe.File, tempData, this);
await _uploadsLock.WaitAsync(cancellationToken);
try
{
_uploads.Add(backgroundUploads.File.Id, backgroundUploads);
}
finally
{
_uploadsLock.Release();
}
return backgroundUploads;
}
/// <inheritdoc/>
public Task<IBackgroundTransfer> AppendAsync(IUnixFileEntry fileEntry, long? startPosition, Stream data, CancellationToken cancellationToken)
{
throw new NotSupportedException();
}
/// <inheritdoc/>
public Task<Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition, CancellationToken cancellationToken)
{
throw new NotSupportedException();
}
/// <inheritdoc/>
public async Task<Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition, CancellationToken cancellationToken)
{
var from = startPosition != 0 ? (long?)startPosition : null;
var fileItem = ((OneDriveFileEntry)fileEntry).Item;
var response = await Service.GetDownloadResponseAsync(Drive.Id, fileItem.Id, from, cancellationToken);
return new OneDriveDownloadStream(this, fileItem, response, startPosition, fileEntry.Size);
}
/// <inheritdoc/>
public Task<IBackgroundTransfer> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
throw new NotSupportedException();
}
/// <inheritdoc/>
public async Task<IBackgroundTransfer> ReplaceAsync(IUnixFileEntry fileEntry, Stream data, CancellationToken cancellationToken)
{
var fileItem = ((OneDriveFileEntry)fileEntry).Item;
var parentId = fileItem.ParentReference.Id;
var fileName = fileItem.Name;
var tempData = await _supportFactory.CreateTemporaryData(data, cancellationToken);
var targetId = GetFileId(parentId, fileName);
var backgroundUploads = new BackgroundUpload(targetId, parentId, fileName, tempData, this);
await _uploadsLock.WaitAsync(cancellationToken);
try
{
var fileId = GetFileId(parentId, fileName);
_uploads.Add(fileId, backgroundUploads);
}
finally
{
_uploadsLock.Release();
}
return backgroundUploads;
}
/// <inheritdoc/>
public Task<Stream> OpenReadAsync(IUnixFileEntry fileEntry, long startPosition, CancellationToken cancellationToken)
{
var fileInfo = ((DotNetFileEntry)fileEntry).Info;
var input = fileInfo.OpenRead();
if (startPosition != 0)
input.Seek(startPosition, SeekOrigin.Begin);
return Task.FromResult<Stream>(input);
}
