internal static IEnumerable <AlternateStreamInformation> GetAlternateStreamInformation(string path)
{
List <AlternateStreamInformation> streams = new List <AlternateStreamInformation>();
path = Paths.AddExtendedPrefix(path);
using (var fileHandle = FileManagement.CreateFile(
path,
// To look at metadata we don't need read or write access
0,
FileShare.ReadWrite,
FileMode.Open,
FileManagement.AllFileAttributeFlags.FILE_FLAG_BACKUP_SEMANTICS))
{
using (BackupReader reader = new BackupReader(fileHandle))
{
StreamInfo?info;
while ((info = reader.GetNextInfo()).HasValue)
{
if (info.Value.Type == BackupStreamType.BACKUP_ALTERNATE_DATA)
{
streams.Add(new AlternateStreamInformation {
Name = info.Value.Name, Size = info.Value.Size
});
}
}
}
}
return(streams);
}
public override async Task RestoreAsync(Guid appId, BackupReader reader)
{
await RestoreTagsAsync(appId, reader);
await RebuildManyAsync(assetIds, RebuildAsync <AssetState, AssetGrain>);
await RebuildManyAsync(assetFolderIds, RebuildAsync <AssetFolderState, AssetFolderGrain>);
}
public void Restore(string filePath)
{
var repo = new DisconnectedRepository();
var reader = new BackupReader();
var ipDetails = reader.ParseIpDetails(filePath);
var files = reader.ParseLogFiles(filePath);
var lines = reader.ParseLogLines(filePath);
repo.ClearTables();
foreach (var detail in ipDetails)
{
repo.AddNewIpDetail(detail);
}
foreach (var file in files)
{
repo.AddNewLogFile(file);
}
foreach (var line in lines)
{
repo.AddNewLogLine(line);
}
}
public void ReadFile()
{
var filePath = @"GameMaster5.xml";
var reader = new BackupReader();
GameData gameData = reader.Read(filePath);
Assert.NotNull(gameData);
}
public override async Task CompleteRestoreAsync(Guid appId, BackupReader reader)
{
await appsByNameIndex.AddAppAsync(appId, appName);
foreach (var user in contributors)
{
await grainFactory.GetGrain <IAppsByUserIndex>(user).AddAppAsync(appId);
}
}
public override Task RestoreEventAsync(Envelope <IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
{
switch (@event.Payload)
{
case ContentCreated contentCreated:
contentIds.Add(contentCreated.ContentId);
break;
}
return(TaskHelper.Done);
}
public override async Task CompleteRestoreAsync(Guid appId, BackupReader reader)
{
await RebuildAsync <AppState, AppGrain>(appId, (e, s) => s.Apply(e));
await appsByNameIndex.AddAppAsync(appId, appName);
foreach (var user in activeUsers)
{
await grainFactory.GetGrain <IAppsByUserIndex>(user).AddAppAsync(appId);
}
}
public override Task RestoreEventAsync(Envelope <IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
{
switch (@event.Payload)
{
case SchemaCreated schemaCreated:
schemaIds.Add(schemaCreated.SchemaId);
schemasByName[schemaCreated.SchemaId.Name] = schemaCreated.SchemaId.Id;
break;
}
return(TaskHelper.Done);
}
public override Task RestoreEventAsync(Envelope <IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
{
switch (@event.Payload)
{
case AssetCreated assetCreated:
return(ReadAssetAsync(assetCreated.AssetId, assetCreated.FileVersion, reader));
case AssetUpdated assetUpdated:
return(ReadAssetAsync(assetUpdated.AssetId, assetUpdated.FileVersion, reader));
}
return(TaskHelper.Done);
}
private async Task ResolveUsersAsync(BackupReader reader)
{
await ReadUsersAsync(reader);
foreach (var kvp in usersWithEmail)
{
var user = await userResolver.FindByIdOrEmailAsync(kvp.Value);
if (user != null)
{
userMapping[kvp.Key] = new RefToken(RefTokenType.Subject, user.Id);
}
}
}
public override Task RestoreEventAsync(Envelope <IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
{
switch (@event.Payload)
{
case RuleCreated ruleCreated:
ruleIds.Add(ruleCreated.RuleId);
break;
case RuleDeleted ruleDeleted:
ruleIds.Remove(ruleDeleted.RuleId);
break;
}
return(TaskHelper.Done);
}
private Task ReadAssetAsync(Guid assetId, long fileVersion, BackupReader reader)
{
assetIds.Add(assetId);
return(reader.ReadBlobAsync(GetName(reader.OldGuid(assetId), fileVersion), async stream =>
{
try
{
await assetStore.UploadAsync(assetId.ToString(), fileVersion, null, stream);
}
catch (AssetAlreadyExistsException)
{
return;
}
}));
}
public void RestoreDetails(string filePath)
{
var repo = new DisconnectedRepository();
var reader = new BackupReader();
var ipDetails = reader.ParseIpDetails(filePath);
repo.ClearDetailTable();
foreach (var detail in ipDetails)
{
repo.AddNewIpDetail(detail);
}
}
private async Task ReadSettingsAsync(BackupReader reader, Guid appId)
{
var json = await reader.ReadJsonAttachmentAsync <JsonObject>(SettingsFile);
await appUISettings.SetAsync(appId, null, json);
}
public override async Task <bool> RestoreEventAsync(Envelope <IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
{
switch (@event.Payload)
{
case AssetFolderCreated assetFolderCreated:
assetFolderIds.Add(assetFolderCreated.AssetFolderId);
break;
case AssetCreated assetCreated:
await ReadAssetAsync(assetCreated.AssetId, assetCreated.FileVersion, reader);
break;
case AssetUpdated assetUpdated:
await ReadAssetAsync(assetUpdated.AssetId, assetUpdated.FileVersion, reader);
break;
}
return(true);
}
public async override Task RestoreAsync(Guid appId, BackupReader reader)
{
await RebuildManyAsync(ruleIds, id => RebuildAsync <RuleState, RuleGrain>(id, (e, s) => s.Apply(e)));
await grainFactory.GetGrain <IRulesByAppIndex>(appId).RebuildAsync(ruleIds);
}
public override Task RestoreAsync(Guid appId, BackupReader reader)
{
return(RebuildManyAsync(contentIds, id => RebuildAsync <ContentState, ContentGrain>(id, (e, s) => s.Apply(e))));
}
public override Task RestoreAsync(Guid appId, BackupReader reader)
{
return(indexForRules.RebuildAsync(appId, ruleIds));
}
public override async Task RestoreAsync(Guid appId, BackupReader reader)
{
await RestoreTagsAsync(appId, reader);
await RebuildManyAsync(assetIds, id => RebuildAsync <AssetState, AssetGrain>(id, (e, s) => s.Apply(e)));
}
private async Task ReadSettingsAsync(BackupReader reader, Guid appId)
{
var json = await reader.ReadJsonAttachmentAsync <JsonObject>(SettingsFile);
await grainFactory.GetGrain <IAppUISettingsGrain>(appId).SetAsync(json);
}
private async Task ReadUsersAsync(BackupReader reader)
{
var json = await reader.ReadJsonAttachmentAsync <Dictionary <string, string> >(UsersFile);
usersWithEmail = json;
}
public override Task RestoreAsync(Guid appId, BackupReader reader)
{
var contentIds = contentIdsBySchemaId.Values.SelectMany(x => x);
return(RebuildManyAsync(contentIds, id => RebuildAsync <ContentState, ContentGrain>(id, (e, s) => s.Apply(e))));
}
public override Task RestoreAsync(Guid appId, BackupReader reader)
{
return(ReadSettingsAsync(reader, appId));
}
public override async Task RestoreAsync(Guid appId, BackupReader reader)
{
await grainFactory.GetGrain <ISchemasByAppIndex>(appId).RebuildAsync(schemasByName);
}
public override Task <bool> RestoreEventAsync(Envelope <IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
{
switch (@event.Payload)
{
case SchemaCreated schemaCreated:
schemasByName[schemaCreated.SchemaId.Name] = schemaCreated.SchemaId.Id;
break;
case SchemaDeleted schemaDeleted:
schemasByName.Remove(schemaDeleted.SchemaId.Name);
break;
}
return(TaskHelper.True);
}
public override Task RestoreAsync(Guid appId, BackupReader reader)
{
return(indexSchemas.RebuildAsync(appId, schemasByName));
}
public override async Task CompleteRestoreAsync(Guid appId, BackupReader reader)
{
await appsIndex.AddAsync(appReservation);
await appsIndex.RebuildByContributorsAsync(appId, contributors);
}
private async Task RestoreTagsAsync(Guid appId, BackupReader reader)
{
var tags = await reader.ReadJsonAttachmentAsync(TagsFile);
await tagService.RebuildTagsAsync(appId, TagGroups.Assets, tags.ToObject <TagSet>());
}
public override async Task <bool> RestoreEventAsync(Envelope <IEvent> @event, Guid appId, BackupReader reader, RefToken actor)
{
switch (@event.Payload)
{
case AppCreated appCreated:
{
appName = appCreated.Name;
await ResolveUsersAsync(reader);
await ReserveAppAsync(appId);
break;
}
case AppContributorAssigned contributorAssigned:
{
if (!userMapping.TryGetValue(contributorAssigned.ContributorId, out var user) || user.Equals(actor))
{
return(false);
}
contributorAssigned.ContributorId = user.Identifier;
contributors.Add(contributorAssigned.ContributorId);
break;
}
case AppContributorRemoved contributorRemoved:
{
if (!userMapping.TryGetValue(contributorRemoved.ContributorId, out var user) || user.Equals(actor))
{
return(false);
}
contributorRemoved.ContributorId = user.Identifier;
contributors.Remove(contributorRemoved.ContributorId);
break;
}
}
if (@event.Payload is SquidexEvent squidexEvent)
{
squidexEvent.Actor = MapUser(squidexEvent.Actor.Identifier, actor);
}
return(true);
}
public async override Task RestoreAsync(Guid appId, BackupReader reader)
{
await RebuildManyAsync(schemaIds.Select(x => x.Id), id => RebuildAsync <SchemaState, SchemaGrain>(id, (e, s) => s.Apply(e, fieldRegistry)));
await grainFactory.GetGrain <ISchemasByAppIndex>(appId).RebuildAsync(schemasByName);
}
internal static IEnumerable<AlternateStreamInformation> GetAlternateStreamInformation(string path)
{
List<AlternateStreamInformation> streams = new List<AlternateStreamInformation>();
path = Paths.AddExtendedPrefix(path);
using (var fileHandle = FileManagement.CreateFile(
path,
// To look at metadata we don't need read or write access
0,
FileShare.ReadWrite,
FileMode.Open,
FileManagement.AllFileAttributeFlags.FILE_FLAG_BACKUP_SEMANTICS))
{
using (BackupReader reader = new BackupReader(fileHandle))
{
StreamInfo? info;
while ((info = reader.GetNextInfo()).HasValue)
{
if (info.Value.Type == BackupStreamType.BACKUP_ALTERNATE_DATA)
{
streams.Add(new AlternateStreamInformation { Name = info.Value.Name, Size = info.Value.Size });
}
}
}
}
return streams;
}
