public async Task CopyAsync(string name, string id, long version, string suffix, CancellationToken ct = default(CancellationToken)) { try { var file = GetFile(name); var toFile = GetFile(id, version, suffix); file.CopyTo(toFile.FullName); using (var readStream = await bucket.OpenDownloadStreamAsync(file.Name, cancellationToken: ct)) { using (var writeStream = await bucket.OpenUploadStreamAsync(toFile.Name, toFile.Name, cancellationToken: ct)) { var buffer = new byte[ChunkSizeBytes]; int bytesRead; while ((bytesRead = await readStream.ReadAsync(buffer, 0, buffer.Length, ct)) > 0) { await writeStream.WriteAsync(buffer, 0, bytesRead, ct); } await writeStream.CloseAsync(ct); } } } catch (FileNotFoundException ex) { throw new AssetNotFoundException($"Asset {name} not found.", ex); } catch (GridFSException ex) { throw new AssetNotFoundException($"Asset {name} not found.", ex); } }
public async Task CopyAsync(string sourceFileName, string id, long version, string suffix, CancellationToken ct = default) { try { var target = GetFileName(id, version, suffix); using (var readStream = await bucket.OpenDownloadStreamAsync(sourceFileName, cancellationToken: ct)) { await UploadFileCoreAsync(target, readStream, ct); } } catch (GridFSFileNotFoundException ex) { throw new AssetNotFoundException(sourceFileName, ex); } }
public async Task CopyAsync(string sourceFileName, string targetFileName, CancellationToken ct = default) { try { var sourceName = GetFileName(sourceFileName, nameof(sourceFileName)); using (var readStream = await bucket.OpenDownloadStreamAsync(sourceFileName, cancellationToken: ct)) { await UploadAsync(targetFileName, readStream, false, ct); } } catch (GridFSFileNotFoundException ex) { throw new AssetNotFoundException(sourceFileName, ex); } }
public async Task CopyAsync(string name, string id, long version, string suffix, CancellationToken ct = default(CancellationToken)) { try { var target = GetFileName(id, version, suffix); using (var readStream = await bucket.OpenDownloadStreamAsync(name, cancellationToken: ct)) { await bucket.UploadFromStreamAsync(target, target, readStream, cancellationToken : ct); } } catch (GridFSFileNotFoundException ex) { throw new AssetNotFoundException($"Asset {name} not found.", ex); } }
public async Task <GridFSDownloadStream <ObjectId> > downloadFileAsync(ObjectId id) { return(await bucket.OpenDownloadStreamAsync( id, new GridFSDownloadOptions() { Seekable = true })); }
private async Task <bool> CopyToImpl(Stream stream, CancellationToken cancellationToken) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } if (_stream.Position != 0) { var newStream = await _bucket.OpenDownloadStreamAsync(_stream.FileInfo.Id, null, cancellationToken); if (newStream == null) { return(false); } using (_stream) { _stream = newStream; } } const int MinBufferSize = 81920; const int MaxBufferSize = 1 << 20; var bufferSize = Math.Min(Math.Max(_stream.FileInfo.ChunkSizeBytes, MinBufferSize), MaxBufferSize); var position = stream.CanSeek ? stream.Position : 0; try { await _stream.CopyToAsync(stream, bufferSize, cancellationToken); } catch (GridFSChunkException) when(_stream.Position == 0 && position == 0) { return(false); } catch (GridFSChunkException) when(stream.CanSeek) { stream.SetLength(position); return(false); } catch when(stream.CanSeek) { stream.SetLength(position); throw; } return(true); }
/// <inheritdoc /> public async Task <Stream> ObtainFile(string id) { if (!ObjectId.TryParse(id, out var objectId)) { return(null); } try { return(await _bucket.OpenDownloadStreamAsync(objectId, new GridFSDownloadOptions { Seekable = true })); } catch (GridFSFileNotFoundException) { return(null); } }
public async Task <(Stream, StoredFileInfo)> GetAsync(string fileId, CancellationToken cancellationToken = default) { _ = fileId ?? throw new ArgumentNullException(nameof(fileId)); IGridFSBucket bucket = getBucket(_dbClient); FilterDefinition <GridFSFileInfo> filter = Builders <GridFSFileInfo> .Filter.Eq(p => p.Filename, fileId); using var cursor = await bucket.FindAsync(filter, null, cancellationToken); var file = await cursor.FirstOrDefaultAsync(cancellationToken); if (file == null) { return(null, null); } var stream = await bucket.OpenDownloadStreamAsync(file.Id, null, cancellationToken); return(stream, BsonSerializer.Deserialize <StoredFileInfo>(file.Metadata)); }
public async Task <LuceneDirectory> CreateDirectoryAsync(DomainId ownerId) { var fileId = $"index_{ownerId}"; var directoryInfo = new DirectoryInfo(Path.Combine(Path.GetTempPath(), fileId)); if (directoryInfo.Exists) { directoryInfo.Delete(true); } directoryInfo.Create(); try { using (var stream = await bucket.OpenDownloadStreamAsync(fileId)) { using (var zipArchive = new ZipArchive(stream, ZipArchiveMode.Read, true)) { foreach (var entry in zipArchive.Entries) { var file = new FileInfo(Path.Combine(directoryInfo.FullName, entry.Name)); using (var entryStream = entry.Open()) { using (var fileStream = file.OpenWrite()) { await entryStream.CopyToAsync(fileStream); } } } } } } catch (GridFSFileNotFoundException) { } var directory = FSDirectory.Open(directoryInfo); return(directory); }
private async Task <CdnDownloadResult> GetFileById(string fileId) { using (var file = await gridFsBucket.OpenDownloadStreamAsync(ObjectId.Parse(fileId))) { byte[] fileContent = new byte[(int)file.Length]; file.Read(fileContent, 0, (int)file.Length); CdnDownloadResult result = new CdnDownloadResult() { FileId = fileId, ContentType = file.FileInfo.Metadata.GetValue("contentType").AsString, FileName = file.FileInfo.Filename, FileContentBase64 = Convert.ToBase64String(fileContent) }; await file.CloseAsync(); return(result); } }
public async Task <BucketItem> GetFileBytesAsync(ObjectId fileId) { byte[] bytes; string contentType = string.Empty; using (var stream = await gridFSBucket.OpenDownloadStreamAsync(fileId)) { bytes = new byte[stream.Length]; await stream.ReadAsync(bytes); contentType = stream.FileInfo?.Metadata?.GetValue(ContentTypeName)?.AsString; await stream.CloseAsync(); } BucketItem bucketItem = new BucketItem() { Data = bytes, ContentType = contentType }; return(bucketItem); }
public async Task <GridFSDownloadStream <ObjectId> > GetAsync(string id) => await _documents.OpenDownloadStreamAsync(new ObjectId(id));
public async Task <Stream> OpenReadAsync() { return(await _bucket.OpenDownloadStreamAsync(_fileInfo.Id)); }
async Task <Stream> IMessageDataRepository.Get(Uri address, CancellationToken cancellationToken) { var id = _resolver.GetObjectId(address); return(await _bucket.OpenDownloadStreamAsync(id, null, cancellationToken).ConfigureAwait(false)); }
public async Task <Stream> Get(Uri address, CancellationToken cancellationToken = new CancellationToken()) { var id = _mongoMessageUriResolver.Resolve(address); return(await _gridFsBucket.OpenDownloadStreamAsync(id, null, cancellationToken).ConfigureAwait(false)); }