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; }