public RestoreContext(Guid appId, IUserMapping userMapping, IBackupReader reader)
: base(appId, userMapping)
{
Guard.NotNull(reader);
Reader = reader;
}
public static async Task CheckCompatibilityAsync(this IBackupReader reader)
{
var current = await reader.ReadVersionAsync();
if (!Expected.Equals(current))
{
throw new BackupRestoreException("Backup file is not compatible with this version.");
}
}
public RestoreContext(DomainId appId, IUserMapping userMapping, IBackupReader reader, DomainId previousAppId)
: base(appId, userMapping)
{
Guard.NotNull(reader);
Reader = reader;
PreviousAppId = previousAppId;
}
private async Task ReadEventsAsync(IBackupReader reader, IEnumerable <IBackupHandler> handlers)
{
await reader.ReadEventsAsync(streamNameResolver, eventDataFormatter, async storedEvent =>
{
await HandleEventAsync(reader, handlers, storedEvent.Stream, storedEvent.Event);
});
Log($"Reading {reader.ReadEvents} events and {reader.ReadAttachments} attachments completed.", true);
}
private Task ReadAssetAsync(Guid assetId, long fileVersion, IBackupReader reader)
{
assetIds.Add(assetId);
return(reader.ReadBlobAsync(GetName(reader.OldGuid(assetId), fileVersion), stream =>
{
return assetFileStore.UploadAsync(assetId, fileVersion, stream);
}));
}
private static async Task <FileVersion> ReadVersionAsync(this IBackupReader reader)
{
try
{
return(await reader.ReadJsonAsync <FileVersion>(VersionFile));
}
catch
{
return(None);
}
}
private static async Task <Urls?> ReadUrlsAsync(IBackupReader reader)
{
try
{
return(await reader.ReadJsonAsync <Urls>(UrlsFile));
}
catch
{
return(null);
}
}
private static async Task <Urls?> ReadUrlsAsync(IBackupReader reader,
CancellationToken ct)
{
try
{
return(await reader.ReadJsonAsync <Urls>(UrlsFile, ct));
}
catch
{
return(null);
}
}
private async Task ReadAssetAsync(Guid appId, IBackupReader reader)
{
await reader.ReadBlobAsync(AvatarFile, async stream =>
{
try
{
await appImageStore.UploadAsync(appId, stream);
}
catch (AssetAlreadyExistsException)
{
}
});
}
private async Task CreateContextAsync(IBackupReader reader)
{
var userMapping = new UserMapping(CurrentJob.Actor);
using (Profiler.Trace("CreateUsers"))
{
Log("Creating Users");
await userMapping.RestoreAsync(reader, userResolver);
Log("Created Users");
}
restoreContext = new RestoreContext(CurrentJob.AppId.Id, userMapping, reader);
}
private static async Task <Guid> ReadGuidAsync(IBackupReader reader, string file)
{
var read = Guid.Empty;
await using (var stream = await reader.OpenBlobAsync(file))
{
var buffer = new byte[16];
_ = await stream.ReadAsync(buffer);
read = new Guid(buffer);
}
return(read);
}
private static async Task <Guid> ReadGuidAsync(IBackupReader reader, string file)
{
var read = Guid.Empty;
await reader.ReadBlobAsync(file, async stream =>
{
var buffer = new byte[16];
await stream.ReadAsync(buffer);
read = new Guid(buffer);
});
return(read);
}
private async Task HandleEventAsync(IBackupReader reader, IEnumerable <IBackupHandler> handlers, string stream, Envelope <IEvent> @event)
{
if (@event.Payload is AppCreated appCreated)
{
if (!string.IsNullOrWhiteSpace(CurrentJob.NewAppName))
{
appCreated.Name = CurrentJob.NewAppName;
CurrentJob.AppId = NamedId.Of(appCreated.AppId.Id, CurrentJob.NewAppName);
}
else
{
CurrentJob.AppId = appCreated.AppId;
}
await CreateContextAsync(reader);
}
if (@event.Payload is SquidexEvent squidexEvent && squidexEvent.Actor != null)
{
if (restoreContext.UserMapping.TryMap(squidexEvent.Actor, out var newUser))
{
squidexEvent.Actor = newUser;
}
}
if (@event.Payload is AppEvent appEvent)
{
appEvent.AppId = CurrentJob.AppId;
}
foreach (var handler in handlers)
{
if (!await handler.RestoreEventAsync(@event, restoreContext))
{
return;
}
}
var eventData = eventDataFormatter.ToEventData(@event, @event.Headers.CommitId());
var eventCommit = new List <EventData> {
eventData
};
await eventStore.AppendAsync(Guid.NewGuid(), stream, eventCommit);
Log($"Read {reader.ReadEvents} events and {reader.ReadAttachments} attachments.", true);
}
private async Task ReadAssetAsync(DomainId appId, IBackupReader reader,
CancellationToken ct)
{
try
{
await using (var stream = await reader.OpenBlobAsync(AvatarFile, ct))
{
await appImageStore.UploadAsync(appId, stream, ct);
}
}
catch (AssetAlreadyExistsException)
{
}
catch (FileNotFoundException)
{
}
}
public async Task RestoreAsync(IBackupReader reader, IUserResolver userResolver)
{
Guard.NotNull(reader, nameof(reader));
Guard.NotNull(userResolver, nameof(userResolver));
var json = await reader.ReadJsonAsync <Dictionary <string, string> >(UsersFile);
foreach (var(userId, email) in json)
{
var(user, _) = await userResolver.CreateUserIfNotExistsAsync(email, false);
if (user != null)
{
userMap[userId] = RefToken.User(user.Id);
}
}
}
public async Task RestoreAsync(IBackupReader reader, IUserResolver userResolver)
{
Guard.NotNull(reader);
Guard.NotNull(userResolver);
var json = await reader.ReadJsonAttachmentAsync <Dictionary <string, string> >(UsersFile);
foreach (var(userId, email) in json)
{
var user = await userResolver.FindByIdOrEmailAsync(email);
if (user == null && await userResolver.CreateUserIfNotExistsAsync(email, false))
{
user = await userResolver.FindByIdOrEmailAsync(email);
}
if (user != null)
{
userMap[userId] = new RefToken(RefTokenType.Subject, user.Id);
}
}
}
private async Task ReadAssetAsync(DomainId appId, DomainId assetId, long fileVersion, IBackupReader reader)
{
try
{
await reader.ReadBlobAsync(GetName(assetId, fileVersion), stream =>
{
return(assetFileStore.UploadAsync(appId, assetId, fileVersion, stream));
});
}
catch (FileNotFoundException)
{
return;
}
}
private Task ReadAssetAsync(DomainId appId, DomainId assetId, long fileVersion, IBackupReader reader)
{
return(reader.ReadBlobAsync(GetName(assetId, fileVersion), stream =>
{
return assetFileStore.UploadAsync(appId, assetId, fileVersion, stream);
}));
}
private static Task <Guid> ReadJsonGuidAsync(IBackupReader reader, string file)
{
return(reader.ReadJsonAsync <Guid>(file));
}
private async Task HandleEventAsync(IBackupReader reader, IEnumerable <IBackupHandler> handlers, string stream, Envelope <IEvent> @event)
{
if (@event.Payload is AppCreated appCreated)
{
var previousAppId = appCreated.AppId.Id;
if (!string.IsNullOrWhiteSpace(CurrentJob.NewAppName))
{
appCreated.Name = CurrentJob.NewAppName;
CurrentJob.AppId = NamedId.Of(DomainId.NewGuid(), CurrentJob.NewAppName);
}
else
{
CurrentJob.AppId = NamedId.Of(DomainId.NewGuid(), appCreated.Name);
}
await CreateContextAsync(reader, previousAppId);
}
stream = stream.Replace(
restoreContext.PreviousAppId.ToString(),
restoreContext.AppId.ToString());
if (@event.Payload is SquidexEvent squidexEvent && squidexEvent.Actor != null)
{
if (restoreContext.UserMapping.TryMap(squidexEvent.Actor, out var newUser))
{
squidexEvent.Actor = newUser;
}
}
if (@event.Payload is AppEvent appEvent)
{
appEvent.AppId = CurrentJob.AppId;
}
if (@event.Headers.TryGet(CommonHeaders.AggregateId, out var aggregateId) && aggregateId is JsonString s)
{
var id = s.Value.Replace(
restoreContext.PreviousAppId.ToString(),
restoreContext.AppId.ToString());
var domainId = DomainId.Create(id);
@event.SetAggregateId(domainId);
}
foreach (var handler in handlers)
{
if (!await handler.RestoreEventAsync(@event, restoreContext))
{
return;
}
}
var eventData = eventDataFormatter.ToEventData(@event, @event.Headers.CommitId());
var eventCommit = new List <EventData>
{
eventData
};
await eventStore.AppendAsync(Guid.NewGuid(), stream, eventCommit);
Log($"Read {reader.ReadEvents} events and {reader.ReadAttachments} attachments.", true);
}
