public void Should_download_with_id_and_version()
{
sut.DownloadAsync(id, 1, string.Empty, stream);
A.CallTo(() => sut.DownloadAsync($"{id}_1", stream, default))
.MustHaveHappened();
}
public IActionResult GetImage(string app)
{
if (App.Image == null)
{
return(NotFound());
}
var etag = App.Image.Etag;
Response.Headers[HeaderNames.ETag] = etag;
var handler = new Func <Stream, Task>(async bodyStream =>
{
var assetId = App.Id.ToString();
var assetResizedId = $"{assetId}_{etag}_Resized";
try
{
await assetStore.DownloadAsync(assetResizedId, bodyStream);
}
catch (AssetNotFoundException)
{
using (Profiler.Trace("Resize"))
{
using (var sourceStream = GetTempStream())
{
using (var destinationStream = GetTempStream())
{
using (Profiler.Trace("ResizeDownload"))
{
await assetStore.DownloadAsync(assetId, sourceStream);
sourceStream.Position = 0;
}
using (Profiler.Trace("ResizeImage"))
{
await assetThumbnailGenerator.CreateThumbnailAsync(sourceStream, destinationStream, 150, 150, "Crop");
destinationStream.Position = 0;
}
using (Profiler.Trace("ResizeUpload"))
{
await assetStore.UploadAsync(assetResizedId, destinationStream);
destinationStream.Position = 0;
}
await destinationStream.CopyToAsync(bodyStream);
}
}
}
}
});
return(new FileCallbackResult(App.Image.MimeType, null, true, handler));
}
public async Task <IActionResult> GetAssetContent(Guid id, [FromQuery] long version = EtagVersion.Any, [FromQuery] int?width = null, [FromQuery] int?height = null, [FromQuery] string mode = null)
{
var entity = await assetRepository.FindAssetAsync(id);
if (entity == null || entity.FileVersion < version || width == 0 || height == 0)
{
return(NotFound());
}
Response.Headers["ETag"] = entity.FileVersion.ToString();
return(new FileCallbackResult(entity.MimeType, entity.FileName, async bodyStream =>
{
var assetId = entity.Id.ToString();
if (entity.IsImage && (width.HasValue || height.HasValue))
{
var assetSuffix = $"{width}_{height}_{mode}";
try
{
await assetStore.DownloadAsync(assetId, entity.FileVersion, assetSuffix, bodyStream);
}
catch (AssetNotFoundException)
{
using (var sourceStream = GetTempStream())
{
using (var destinationStream = GetTempStream())
{
await assetStore.DownloadAsync(assetId, entity.FileVersion, null, sourceStream);
sourceStream.Position = 0;
await assetThumbnailGenerator.CreateThumbnailAsync(sourceStream, destinationStream, width, height, mode);
destinationStream.Position = 0;
await assetStore.UploadAsync(assetId, entity.FileVersion, assetSuffix, destinationStream);
destinationStream.Position = 0;
await destinationStream.CopyToAsync(bodyStream);
}
}
}
}
else
{
await assetStore.DownloadAsync(assetId, entity.FileVersion, null, bodyStream);
}
}));
}
public async Task DownloadAsync(DomainId appId, DomainId id, long fileVersion, Stream stream, BytesRange range = default, CancellationToken ct = default)
{
try
{
var fileNameNew = GetFileName(appId, id, fileVersion);
await assetStore.DownloadAsync(fileNameNew, stream, range, ct);
}
catch (AssetNotFoundException)
{
var fileNameOld = GetFileName(id, fileVersion);
await assetStore.DownloadAsync(fileNameOld, stream, range, ct);
}
}
public async Task Should_invoke_asset_store_to_download_picture()
{
A.CallTo(() => assetStore.DownloadAsync(userId, 0, "picture", A <Stream> .Ignored))
.Invokes(async(string id, long version, string suffix, Stream stream) =>
{
await stream.WriteAsync(new byte[] { 1, 2, 3, 4 }, 0, 4);
});
var result = await sut.DownloadAsync(userId);
Assert.Equal(0, result.Position);
Assert.Equal(4, result.Length);
A.CallTo(() => assetStore.DownloadAsync(userId, 0, "picture", A <Stream> .Ignored)).MustHaveHappened();
}
public async Task Should_invoke_asset_store_to_download_archive()
{
var stream = new MemoryStream();
await sut.DownloadAsync(appId, stream);
A.CallTo(() => assetStore.DownloadAsync(fileName, stream, default, CancellationToken.None))
public async Task <LuceneDirectory> CreateDirectoryAsync(Guid schemaId)
{
var directoryInfo = new DirectoryInfo(Path.Combine(Path.GetTempPath(), "LocalIndices", schemaId.ToString()));
if (directoryInfo.Exists)
{
directoryInfo.Delete(true);
}
directoryInfo.Create();
using (var fileStream = GetArchiveStream(directoryInfo))
{
try
{
await assetStore.DownloadAsync(directoryInfo.Name, fileStream);
fileStream.Position = 0;
using (var zipArchive = new ZipArchive(fileStream, ZipArchiveMode.Read, true))
{
zipArchive.ExtractToDirectory(directoryInfo.FullName);
}
}
catch (AssetNotFoundException)
{
}
}
var directory = FSDirectory.Open(directoryInfo);
return(directory);
}
public async Task Should_invoke_asset_store_to_download_archive_using_suffix_for_compatibility()
{
var stream = new MemoryStream();
await sut.DownloadAsync(backupId, stream, ct);
A.CallTo(() => assetStore.DownloadAsync(fileName, stream, default, ct))
public async Task Should_invoke_asset_store_to_download_picture_using_suffix_for_compatibility()
{
var stream = new MemoryStream();
await sut.DownloadAsync(userId, stream);
A.CallTo(() => assetStore.DownloadAsync(file, stream, default, CancellationToken.None))
private Task WriteAssetAsync(Guid assetId, long fileVersion, BackupWriter writer)
{
return(writer.WriteBlobAsync(GetName(assetId, fileVersion), stream =>
{
return assetStore.DownloadAsync(assetId.ToString(), fileVersion, null, stream);
}));
}
public IActionResult GetBackupContent(string app, Guid id)
{
return(new FileCallbackResult("application/zip", "Backup.zip", bodyStream =>
{
return assetStore.DownloadAsync(id.ToString(), 0, null, bodyStream);
}));
}
public Task DownloadAsync(string appId, Media media, Stream stream, BytesRange range,
CancellationToken ct = default)
{
var fileName = CreateFileName(appId, media);
return(assetStore.DownloadAsync(fileName, stream, range, ct));
}
public async Task Should_download_file_from_store()
{
var stream = new MemoryStream();
await sut.DownloadAsync(appId, assetId, assetFileVersion, stream);
A.CallTo(() => assetStore.DownloadAsync(fileNameNew, stream, default, CancellationToken.None))
public IActionResult GetImage(string app)
{
if (App.Image == null)
{
return(NotFound());
}
var etag = App.Image.Etag;
Response.Headers[HeaderNames.ETag] = etag;
var callback = new FileCallback(async(body, range, ct) =>
{
var resizedAsset = $"{App.Id}_{etag}_Resized";
try
{
await assetStore.DownloadAsync(resizedAsset, body, ct: ct);
}
catch (AssetNotFoundException)
{
await ResizeAsync(resizedAsset, App.Image.MimeType, body, ct);
}
});
return(new FileCallbackResult(App.Image.MimeType, callback)
{
ErrorAs404 = true
});
}
public static async Task DownloadAsync(this IAssetStore assetStore, DirectoryInfo directory)
{
if (directory.Exists)
{
directory.Delete(true);
}
directory.Create();
using (var fileStream = new FileStream(
Path.Combine(directory.FullName, ArchiveFile),
FileMode.Create,
FileAccess.ReadWrite,
FileShare.None,
4096,
FileOptions.DeleteOnClose))
{
try
{
await assetStore.DownloadAsync(directory.Name, 0, string.Empty, fileStream);
fileStream.Position = 0;
using (var zipArchive = new ZipArchive(fileStream, ZipArchiveMode.Read, true))
{
zipArchive.ExtractToDirectory(directory.FullName);
}
}
catch (AssetNotFoundException)
{
return;
}
}
}
public async Task Should_invoke_asset_store_to_download_picture()
{
A.CallTo(() => assetStore.DownloadAsync(userId, 0, "picture", A <Stream> .Ignored, CancellationToken.None))
.Invokes(async(IFakeObjectCall call) =>
{
var stream = call.GetArgument <Stream>(3);
await stream.WriteAsync(new byte[] { 1, 2, 3, 4 }, 0, 4);
});
var result = await sut.DownloadAsync(userId);
Assert.Equal(0, result.Position);
Assert.Equal(4, result.Length);
A.CallTo(() => assetStore.DownloadAsync(userId, 0, "picture", A <Stream> .Ignored, CancellationToken.None)).MustHaveHappened();
}
public async Task Should_invoke_asset_store_to_download_archive_using_suffix_for_compatibility()
{
var stream = new MemoryStream();
await sut.DownloadAsync(backupId, stream);
A.CallTo(() => assetStore.DownloadAsync(fileName, stream, CancellationToken.None))
.MustHaveHappened();
}
public async Task Should_invoke_asset_store_to_download_file()
{
var stream = new MemoryStream();
await sut.DownloadAsync(assetId, assetFileVersion, stream);
A.CallTo(() => assetStore.DownloadAsync(fileName, stream, CancellationToken.None))
.MustHaveHappened();
}
public IActionResult GetImage(string app)
{
if (App.Image == null)
{
return(NotFound());
}
var etag = App.Image.Etag;
Response.Headers[HeaderNames.ETag] = etag;
var callback = new FileCallback(async(body, range, ct) =>
{
var resizedAsset = $"{App.Id}_{etag}_Resized";
try
{
await assetStore.DownloadAsync(resizedAsset, body, ct: ct);
}
catch (AssetNotFoundException)
{
using (Profiler.Trace("Resize"))
{
using (var sourceStream = GetTempStream())
{
using (var destinationStream = GetTempStream())
{
using (Profiler.Trace("ResizeDownload"))
{
await appImageStore.DownloadAsync(App.Id, sourceStream);
sourceStream.Position = 0;
}
using (Profiler.Trace("ResizeImage"))
{
await assetThumbnailGenerator.CreateThumbnailAsync(sourceStream, destinationStream, ResizeOptions);
destinationStream.Position = 0;
}
using (Profiler.Trace("ResizeUpload"))
{
await assetStore.UploadAsync(resizedAsset, destinationStream);
destinationStream.Position = 0;
}
await destinationStream.CopyToAsync(body, ct);
}
}
}
}
});
return(new FileCallbackResult(App.Image.MimeType, callback)
{
ErrorAs404 = true
});
}
public async Task <Stream> DownloadAsync(string userId)
{
var memoryStream = new MemoryStream();
await assetStore.DownloadAsync(userId, 0, "picture", memoryStream);
memoryStream.Position = 0;
return(memoryStream);
}
public async Task <IActionResult> GetAssetContent(string app, Guid id, [FromQuery] int version = -1, [FromQuery] int?width = null, [FromQuery] int?height = null, [FromQuery] string mode = null)
{
var asset = await assetRepository.FindAssetAsync(id);
if (asset == null || asset.FileVersion < version || width == 0 || height == 0)
{
return(NotFound());
}
return(new FileCallbackResult(asset.MimeType, asset.FileName, async bodyStream =>
{
if (asset.IsImage && (width.HasValue || height.HasValue))
{
var suffix = $"{width}_{height}_{mode}";
try
{
await assetStorage.DownloadAsync(asset.Id, asset.FileVersion, suffix, bodyStream);
}
catch (AssetNotFoundException)
{
using (var sourceStream = GetTempStream())
{
using (var destinationStream = GetTempStream())
{
await assetStorage.DownloadAsync(asset.Id, asset.FileVersion, null, sourceStream);
sourceStream.Position = 0;
await assetThumbnailGenerator.CreateThumbnailAsync(sourceStream, destinationStream, width, height, mode);
destinationStream.Position = 0;
await assetStorage.UploadAsync(asset.Id, asset.FileVersion, suffix, destinationStream);
destinationStream.Position = 0;
await destinationStream.CopyToAsync(bodyStream);
}
}
}
}
await assetStorage.DownloadAsync(asset.Id, asset.FileVersion, null, bodyStream);
}));
}
public async Task Should_download_file_from_store(bool folderPerApp, string?suffix, string fileName)
{
var fullName = GetFullName(fileName);
options.FolderPerApp = folderPerApp;
var stream = new MemoryStream();
await sut.DownloadAsync(appId, assetId, assetFileVersion, suffix, stream);
A.CallTo(() => assetStore.DownloadAsync(fullName, stream, default, CancellationToken.None))
public async Task Should_invoke_asset_store_to_download_archive(bool folderPerApp)
{
var stream = new MemoryStream();
options.FolderPerApp = folderPerApp;
var fileName = GetFileName(folderPerApp);
await sut.DownloadAsync(appId, stream);
A.CallTo(() => assetStore.DownloadAsync(fileName, stream, default, CancellationToken.None))
public async Task <IActionResult> GetBackupContent(string app, Guid id)
{
var backupGrain = grainFactory.GetGrain <IBackupGrain>(AppId);
var backups = await backupGrain.GetStateAsync();
var backup = backups.Value.Find(x => x.Id == id);
if (backup == null || backup.Status != JobStatus.Completed)
{
return(NotFound());
}
var fileName = $"backup-{app}-{backup.Started:yyyy-MM-dd_HH-mm-ss}.zip";
return(new FileCallbackResult("application/zip", fileName, false, bodyStream =>
{
return assetStore.DownloadAsync(id.ToString(), 0, null, bodyStream);
}));
}
protected override async Task OnActivateAsync(Guid key)
{
directory = new DirectoryInfo(Path.Combine(Path.GetTempPath(), $"Index_{key}"));
await assetStore.DownloadAsync(directory);
var config = new IndexWriterConfig(Version, Analyzer)
{
IndexDeletionPolicy = snapshotter
};
indexWriter = new IndexWriter(FSDirectory.Open(directory), config);
if (indexWriter.NumDocs > 0)
{
OpenReader();
}
else
{
indexState = new IndexState(indexReader, indexWriter);
}
}
public Task DownloadAsync(Guid id, long fileVersion, Stream stream, BytesRange range = default, CancellationToken ct = default)
{
var fileName = GetFileName(id, fileVersion);
return(assetStore.DownloadAsync(fileName, stream, range, ct));
}
public Task DownloadAsync(Guid backupId, Stream stream, CancellationToken ct = default)
{
var fileName = GetFileName(backupId);
return(assetStore.DownloadAsync(fileName, stream, default, ct));
private IActionResult DeliverAsset(string appId, MediaItem?media, MediaFileQueryDto?query)
{
query ??= new MediaFileQueryDto();
if (media == null)
{
return(NotFound());
}
var resizeOptions = query.ToResizeOptions();
FileCallback callback;
if (query.CacheDuration > 0)
{
Response.Headers[HeaderNames.CacheControl] = $"public,max-age={query.CacheDuration}";
}
var contentLength = (long?)null;
if (media.Type == MediaType.Image && resizeOptions.IsValid)
{
callback = async(bodyStream, range, ct) =>
{
var resizedAsset = $"{appId}_{media.FileName}_{resizeOptions}";
if (query.ForceResize)
{
await ResizeAsync(appId, media, bodyStream, resizedAsset, resizeOptions, true, ct);
}
else
{
try
{
await assetStore.DownloadAsync(resizedAsset, bodyStream, ct : ct);
}
catch (AssetNotFoundException)
{
await ResizeAsync(appId, media, bodyStream, resizedAsset, resizeOptions, false, ct);
}
}
};
}
else
{
contentLength = media.FileSize;
callback = async(bodyStream, range, ct) =>
{
await mediaFileStore.DownloadAsync(appId, media, bodyStream, range, ct);
};
}
return(new FileCallbackResult(media.MimeType, callback)
{
EnableRangeProcessing = contentLength > 0,
ErrorAs404 = true,
FileDownloadName = media.FileName,
FileSize = contentLength,
SendInline = query.Download != 1
});
}
private IActionResult DeliverAsset(IAssetEntity?asset, AssetQuery query)
{
query ??= new AssetQuery();
if (asset == null || asset.FileVersion < query.Version)
{
return(NotFound());
}
if (asset.IsProtected && !this.HasPermission(Permissions.AppAssetsRead))
{
return(StatusCode(403));
}
var fileVersion = query.Version;
if (fileVersion <= EtagVersion.Any)
{
fileVersion = asset.FileVersion;
}
Response.Headers[HeaderNames.ETag] = fileVersion.ToString();
if (query.CacheDuration > 0)
{
Response.Headers[HeaderNames.CacheControl] = $"public,max-age={query.CacheDuration}";
}
var handler = new Func <Stream, Task>(async bodyStream =>
{
if (asset.Type == AssetType.Image && query.ShouldResize())
{
var resizedAsset = $"{asset.Id}_{asset.FileVersion}_{query.Width}_{query.Height}_{query.Mode}";
if (query.Quality.HasValue)
{
resizedAsset += $"_{query.Quality}";
}
try
{
await assetStore.DownloadAsync(resizedAsset, bodyStream);
}
catch (AssetNotFoundException)
{
using (Profiler.Trace("Resize"))
{
using (var sourceStream = GetTempStream())
{
using (var destinationStream = GetTempStream())
{
using (Profiler.Trace("ResizeDownload"))
{
await assetFileStore.DownloadAsync(asset.Id, fileVersion, sourceStream);
sourceStream.Position = 0;
}
using (Profiler.Trace("ResizeImage"))
{
await assetThumbnailGenerator.CreateThumbnailAsync(sourceStream, destinationStream, query.Width, query.Height, query.Mode, query.Quality);
destinationStream.Position = 0;
}
using (Profiler.Trace("ResizeUpload"))
{
await assetStore.UploadAsync(resizedAsset, destinationStream);
destinationStream.Position = 0;
}
await destinationStream.CopyToAsync(bodyStream);
}
}
}
}
}
else
{
await assetFileStore.DownloadAsync(asset.Id, fileVersion, bodyStream);
}
});
if (query.Download == 1)
{
return(new FileCallbackResult(asset.MimeType, asset.FileName, true, handler));
}
else
{
return(new FileCallbackResult(asset.MimeType, null, true, handler));
}
}
public async Task RunAsync()
{
if (currentTask != null)
{
throw new DomainException("Another backup process is already running.");
}
if (state.Jobs.Count >= MaxBackups)
{
throw new DomainException($"You cannot have more than {MaxBackups} backups.");
}
var job = new BackupStateJob {
Id = Guid.NewGuid(), Started = clock.GetCurrentInstant()
};
currentTask = new CancellationTokenSource();
currentJob = job;
var lastTimestamp = job.Started;
state.Jobs.Insert(0, job);
await WriteAsync();
try
{
using (var stream = await backupArchiveLocation.OpenStreamAsync(job.Id))
{
using (var writer = new EventStreamWriter(stream))
{
await eventStore.QueryAsync(async @event =>
{
var eventData = @event.Data;
if (eventData.Type == "AssetCreatedEvent" ||
eventData.Type == "AssetUpdatedEvent")
{
var parsedEvent = eventDataFormatter.Parse(eventData);
var assetVersion = 0L;
var assetId = Guid.Empty;
if (parsedEvent.Payload is AssetCreated assetCreated)
{
assetId = assetCreated.AssetId;
assetVersion = assetCreated.FileVersion;
}
if (parsedEvent.Payload is AssetUpdated asetUpdated)
{
assetId = asetUpdated.AssetId;
assetVersion = asetUpdated.FileVersion;
}
await writer.WriteEventAsync(eventData, async attachmentStream =>
{
await assetStore.DownloadAsync(assetId.ToString(), assetVersion, null, attachmentStream);
});
job.HandledAssets++;
}
else
{
await writer.WriteEventAsync(eventData);
}
job.HandledEvents++;
var now = clock.GetCurrentInstant();
if ((now - lastTimestamp) >= UpdateDuration)
{
lastTimestamp = now;
await WriteAsync();
}
}, SquidexHeaders.AppId, appId.ToString(), null, currentTask.Token);
}
stream.Position = 0;
currentTask.Token.ThrowIfCancellationRequested();
await assetStore.UploadAsync(job.Id.ToString(), 0, null, stream, currentTask.Token);
}
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "makeBackup")
.WriteProperty("status", "failed")
.WriteProperty("backupId", job.Id.ToString()));
job.IsFailed = true;
}
finally
{
await CleanupArchiveAsync(job);
job.Stopped = clock.GetCurrentInstant();
await WriteAsync();
currentTask = null;
currentJob = null;
}
}