public static LockFileTargetLibrary CreateLockFileTargetLibrary(LockFileProjectLibrary library,
Runtime.Project projectInfo,
RestoreContext context)
{
var lockFileLib = new LockFileTargetLibrary
{
Name = library.Name,
Version = library.Version,
Type = "project"
};
var targetFrameworkInfo = projectInfo.GetTargetFramework(context.FrameworkName);
var dependencies = projectInfo.Dependencies.Concat(targetFrameworkInfo.Dependencies);
foreach (var dependency in dependencies)
{
if (dependency.LibraryRange.IsGacOrFrameworkReference)
{
lockFileLib.FrameworkAssemblies.Add(
LibraryRange.GetAssemblyName(dependency.LibraryRange.Name));
}
else
{
lockFileLib.Dependencies.Add(new PackageDependency(
dependency.LibraryRange.Name,
dependency.LibraryRange.VersionRange));
}
}
return(lockFileLib);
}
// OnDataLossAsync is the restore part of the process. This is NOT an arbitrary name, it is an override of the
// method on StatefulServiceBase.
// The method below looks in the backupFolder directory (where the backup files were
// stored in BackupCallbackAsync above), searches for the folder of backup files that have the newest ListWriteTime, then restores them.
// Once the RestoreDescription object is told where to find your data, RestoreAsync is called
// to restore that data to the reliable objects
// Each partition will have OnDataLossAsync called on it
protected override async Task <bool> OnDataLossAsync(RestoreContext restoreCtx,
CancellationToken cancellationToken)
{
string backupFolder;
ServiceEventSource.Current.ServiceMessage(this, "OnDataLoss Invoked!");
this.SetupBackupManager();
try
{
if (this.backupStorageType == BackupManagerType.None)
{
//since we have no backup configured, we return false to indicate
//that state has not changed. This replica will become the basis
//for future replica builds
return(false);
}
else
{
backupFolder =
await this.backupManager.RestoreLatestBackupToTempLocation(cancellationToken);
}
ServiceEventSource.Current.ServiceMessage(this, "Restoration Folder Path " + backupFolder);
RestoreDescription restoreDescription =
new RestoreDescription(backupFolder, RestorePolicy.Force);
// Restore the backup copy
await restoreCtx.RestoreAsync(restoreDescription, cancellationToken);
ServiceEventSource.Current.ServiceMessage(this, "Restore completed");
// Clean up the local temporary directory (the root directory where all backups were unzipped in to)
try
{
DirectoryInfo tempRestoreDirectory = new DirectoryInfo(backupFolder);
tempRestoreDirectory.Delete(true);
}
catch (System.Exception ddel)
{
ServiceEventSource.Current.ServiceMessage(this, "OnDataLossAsync: Delete of backup folder failed with {0}", ddel.Message);
}
// now that a restore has been performed, reset the full backup flag and incremental
// counter so you start fresh again
// You will need to change this type of logic for your own scenario
takeFullBackup = true;
incrementalCount = 0;
return(true);
}
catch (Exception e)
{
ServiceEventSource.Current.ServiceMessage(this, "Restoration failed: " + "{0} {1}" + e.GetType() + e.Message);
throw;
}
}
public async Task RestoreAsync(RestoreContext context,
CancellationToken ct)
{
var json = await context.Reader.ReadJsonAsync <JsonObject>(SettingsFile, ct);
await appUISettings.SetAsync(context.AppId, null, json);
}
public IDisposable MakeCurrent(EglSurface surface)
{
Monitor.Enter(_lock);
var success = false;
try
{
var old = new RestoreContext(_egl, _disp.Handle, _lock);
var surf = surface ?? OffscreenSurface;
_egl.MakeCurrent(_disp.Handle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
if (!_egl.MakeCurrent(_disp.Handle, surf?.DangerousGetHandle() ?? IntPtr.Zero,
surf?.DangerousGetHandle() ?? IntPtr.Zero, Context))
{
throw OpenGlException.GetFormattedException("eglMakeCurrent", _egl);
}
success = true;
return(old);
}
finally
{
if (!success)
{
Monitor.Enter(_lock);
}
}
}
private async Task RestoreTagsAsync(RestoreContext context,
CancellationToken ct)
{
var tags = (Dictionary <string, Tag>?)null;
if (await context.Reader.HasFileAsync(TagsFile, ct))
{
tags = await context.Reader.ReadJsonAsync <Dictionary <string, Tag> >(TagsFile, ct);
}
var alias = (Dictionary <string, string>?)null;
if (await context.Reader.HasFileAsync(TagsAliasFile, ct))
{
alias = await context.Reader.ReadJsonAsync <Dictionary <string, string> >(TagsAliasFile, ct);
}
if (alias == null && tags == null)
{
return;
}
var export = new TagsExport {
Tags = tags, Alias = alias
};
await tagService.RebuildTagsAsync(context.AppId, TagGroups.Assets, export);
}
protected override async Task <bool> OnDataLossAsync(RestoreContext restoreCtx, CancellationToken cancellationToken)
{
ServiceEventSource.Current.ServiceMessage(this.Context, "OnDataLoss Invoked!");
this.SetupBackupManager();
try
{
string backupFolder;
backupFolder = await this.backupManager.RestoreLatestBackupToTempLocation(cancellationToken);
ServiceEventSource.Current.ServiceMessage(this.Context, "Restoration Folder Path " + backupFolder);
RestoreDescription restoreRescription = new RestoreDescription(backupFolder, RestorePolicy.Force);
await restoreCtx.RestoreAsync(restoreRescription, cancellationToken);
ServiceEventSource.Current.ServiceMessage(this.Context, "Restore completed");
DirectoryInfo tempRestoreDirectory = new DirectoryInfo(backupFolder);
tempRestoreDirectory.Delete(true);
return(true);
}
catch (Exception e)
{
ServiceEventSource.Current.ServiceMessage(this.Context, "Restoration failed: " + "{0} {1}" + e.GetType() + e.Message);
throw;
}
}
public async Task <bool> RestoreEventAsync(Envelope <IEvent> @event, RestoreContext context)
{
switch (@event.Payload)
{
case AssetFolderCreated _:
assetFolderIds.Add(@event.Headers.AggregateId());
break;
case AssetCreated assetCreated:
assetIds.Add(@event.Headers.AggregateId());
await ReadAssetAsync(
assetCreated.AppId.Id,
assetCreated.AssetId,
assetCreated.FileVersion,
context.Reader);
break;
case AssetUpdated assetUpdated:
await ReadAssetAsync(
assetUpdated.AppId.Id,
assetUpdated.AssetId,
assetUpdated.FileVersion,
context.Reader);
break;
}
return(true);
}
public static LockFileTargetLibrary CreateLockFileTargetLibrary(Runtime.Project projectDependency,
RestoreContext context)
{
var targetFrameworkInfo = projectDependency.GetCompatibleTargetFramework(context.FrameworkName);
var lockFileLib = new LockFileTargetLibrary
{
Name = projectDependency.Name,
Version = projectDependency.Version,
TargetFramework = targetFrameworkInfo.FrameworkName, // null TFM means it's incompatible
Type = "project"
};
var dependencies = projectDependency.Dependencies.Concat(targetFrameworkInfo.Dependencies);
foreach (var dependency in dependencies)
{
if (dependency.LibraryRange.IsGacOrFrameworkReference)
{
lockFileLib.FrameworkAssemblies.Add(
LibraryRange.GetAssemblyName(dependency.LibraryRange.Name));
}
else
{
lockFileLib.Dependencies.Add(new PackageDependency(
dependency.LibraryRange.Name,
dependency.LibraryRange.VersionRange));
}
}
return lockFileLib;
}
public async Task RestoreAsync(RestoreContext context)
{
await RestoreTagsAsync(context);
if (assetIds.Count > 0)
{
await rebuilder.InsertManyAsync <AssetDomainObject, AssetState>(async target =>
{
foreach (var id in assetIds)
{
await target(id);
}
});
}
if (assetFolderIds.Count > 0)
{
await rebuilder.InsertManyAsync <AssetFolderDomainObject, AssetFolderState>(async target =>
{
foreach (var id in assetFolderIds)
{
await target(id);
}
});
}
}
public async Task CompleteRestoreAsync(RestoreContext context, string appName)
{
await rebuilder.InsertManyAsync <AppDomainObject, AppDomainObject.State>(Enumerable.Repeat(context.AppId, 1), 1, default);
await appsIndex.RegisterAsync(context.AppId, appName);
await appsIndex.RemoveReservationAsync(appReservation);
}
public async Task RestoreAsync(RestoreContext context,
CancellationToken ct)
{
if (ruleIds.Count > 0)
{
await rebuilder.InsertManyAsync <RuleDomainObject, RuleDomainObject.State>(ruleIds, BatchSize, ct);
}
}
protected override async Task <bool> OnDataLossAsync(RestoreContext restoreContext, CancellationToken cancellationToken)
{
await DatalossHelper.UpdateHeathStateAsync(isHealthy : false).ConfigureAwait(false);
UpgradeOrchestrationTrace.TraceSource.WriteWarning(TraceType, "Data loss happens. Manual cluster config upgrade is required to fix.");
return(false);
}
public async Task RestoreAsync(RestoreContext context)
{
var ids = contentIdsBySchemaId.Values.SelectMany(x => x);
if (ids.Any())
{
await rebuilder.InsertManyAsync <ContentDomainObject, ContentDomainObject.State>(ids, BatchSize);
}
}
protected override async Task <bool> OnDataLossAsync(RestoreContext restoreCtx, CancellationToken cancellationToken)
{
Log.WriteLine("{0}", $"Partition {GraphEngineStatefulServiceRuntime.Instance.PartitionId} received OnDataLossAsync. Triggering data restore.");
RestoreEventArgs rstArgs = new RestoreEventArgs(restoreCtx, cancellationToken);
RequestRestore(this, rstArgs);
await rstArgs.Wait();
return(true);
}
/// <summary>
/// Creates a new StatefulService.
/// </summary>
/// <param name="serviceContext">
/// A <see cref="StatefulServiceContext"/> that describes the service context.
/// </param>
/// <param name="stateProviderReplica">
/// A <see cref="IStateProviderReplica"/> that represents a reliable state provider replica.
/// </param>
protected StatefulServiceBase(
StatefulServiceContext serviceContext,
IStateProviderReplica stateProviderReplica)
{
this.stateProviderReplica = stateProviderReplica;
this.stateProviderReplica.OnDataLossAsync = this.OnDataLossAsync;
this.restoreContext = new RestoreContext(this.stateProviderReplica);
this.serviceContext = serviceContext;
this.addresses = new ReadOnlyDictionary <string, string>(new Dictionary <string, string>());
}
protected override async Task <bool> OnDataLossAsync(RestoreContext restoreCtx, CancellationToken cancellationToken)
{
var backupsourcedir = this._fileStore.GetRestoreDirectory();
this._serviceEventSource.Message($"BackupRestoreStatefulService: Restoring backup of partition { Context.PartitionId} of service {Context.ServiceName.AbsoluteUri} from {backupsourcedir}");
await restoreCtx.RestoreAsync(new RestoreDescription(backupsourcedir, RestorePolicy.Force), cancellationToken);
this._serviceEventSource.Message($"BackupRestoreStatefulService: Backup of partition { Context.PartitionId} of service {Context.ServiceName.AbsoluteUri} from {backupsourcedir} has been restored!");
return(true);
}
public IDisposable MakeCurrent(IntPtr xid)
{
var old = new RestoreContext(Glx, _x11.Display);
if (!Glx.MakeContextCurrent(_x11.Display, xid, xid, Handle))
{
throw new OpenGlException("glXMakeContextCurrent failed ");
}
return(old);
}
public async Task Should_restore_states_for_all_contents()
{
var me = new RefToken(RefTokenType.Subject, "123");
var schemaId1 = NamedId.Of(DomainId.NewGuid(), "my-schema1");
var schemaId2 = NamedId.Of(DomainId.NewGuid(), "my-schema2");
var contentId1 = DomainId.NewGuid();
var contentId2 = DomainId.NewGuid();
var contentId3 = DomainId.NewGuid();
var context = new RestoreContext(appId.Id, new UserMapping(me), A.Fake <IBackupReader>(), DomainId.NewGuid());
await sut.RestoreEventAsync(ContentEvent(new ContentCreated
{
ContentId = contentId1,
SchemaId = schemaId1
}), context);
await sut.RestoreEventAsync(ContentEvent(new ContentCreated
{
ContentId = contentId2,
SchemaId = schemaId1
}), context);
await sut.RestoreEventAsync(ContentEvent(new ContentCreated
{
ContentId = contentId3,
SchemaId = schemaId2
}), context);
await sut.RestoreEventAsync(ContentEvent(new ContentDeleted
{
ContentId = contentId2,
SchemaId = schemaId1
}), context);
await sut.RestoreEventAsync(Envelope.Create(new SchemaDeleted
{
SchemaId = schemaId2
}), context);
var rebuildContents = new HashSet <DomainId>();
A.CallTo(() => rebuilder.InsertManyAsync <ContentDomainObject, ContentState>(A <IEnumerable <DomainId> > ._, A <CancellationToken> ._))
.Invokes((IEnumerable <DomainId> source, CancellationToken _) => rebuildContents.AddRange(source));
await sut.RestoreAsync(context);
Assert.Equal(new HashSet <DomainId>
{
DomainId.Combine(appId.Id, contentId1),
DomainId.Combine(appId.Id, contentId2)
}, rebuildContents);
}
public IDisposable MakeCurrent()
{
var old = new RestoreContext(_egl, _disp.Handle);
_egl.MakeCurrent(_disp.Handle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
if (!_egl.MakeCurrent(_disp.Handle, IntPtr.Zero, IntPtr.Zero, Context))
{
throw OpenGlException.GetFormattedException("eglMakeCurrent", _egl);
}
return(old);
}
protected override async Task <bool> OnDataLossAsync(
RestoreContext restoreCtx,
CancellationToken cancellationToken)
{
var ctx = new StatefulServiceRestoreContext(restoreCtx);
var payload = new StatefulServiceEventPayloadOnDataLoss(ctx);
await this.serviceEvents.NotifyDataLossAsync(payload, cancellationToken);
return(ctx.IsRestored);
}
public IDisposable MakeCurrent(EglSurface surface)
{
var old = new RestoreContext(_egl, _disp.Handle);
var surf = surface ?? OffscreenSurface;
_egl.MakeCurrent(_disp.Handle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
if (!_egl.MakeCurrent(_disp.Handle, surf.DangerousGetHandle(), surf.DangerousGetHandle(), Context))
{
throw OpenGlException.GetFormattedException("eglMakeCurrent", _egl);
}
return(old);
}
public async Task RestoreAsync(RestoreContext context)
{
if (contentIdsBySchemaId.Count > 0)
{
await rebuilder.InsertManyAsync <ContentDomainObject, ContentState>(async target =>
{
foreach (var contentId in contentIdsBySchemaId.Values.SelectMany(x => x))
{
await target(contentId);
}
});
}
}
public async Task RestoreAsync(RestoreContext context)
{
await RestoreTagsAsync(context);
if (assetIds.Count > 0)
{
await rebuilder.InsertManyAsync <AssetDomainObject, AssetState>(assetIds);
}
if (assetFolderIds.Count > 0)
{
await rebuilder.InsertManyAsync <AssetFolderDomainObject, AssetFolderState>(assetFolderIds);
}
}
public async Task RestoreAsync(RestoreContext context,
CancellationToken ct)
{
await RestoreTagsAsync(context, ct);
if (assetIds.Count > 0)
{
await rebuilder.InsertManyAsync <AssetDomainObject, AssetDomainObject.State>(assetIds, BatchSize, ct);
}
if (assetFolderIds.Count > 0)
{
await rebuilder.InsertManyAsync <AssetFolderDomainObject, AssetFolderDomainObject.State>(assetFolderIds, BatchSize, ct);
}
}
public Task <bool> RestoreEventAsync(Envelope <IEvent> @event, RestoreContext context)
{
switch (@event.Payload)
{
case ContentCreated contentCreated:
contentIdsBySchemaId.GetOrAddNew(contentCreated.SchemaId.Id).Add(contentCreated.ContentId);
break;
case SchemaDeleted schemaDeleted:
contentIdsBySchemaId.Remove(schemaDeleted.SchemaId.Id);
break;
}
return(TaskHelper.True);
}
public Task <bool> RestoreEventAsync(Envelope <IEvent> @event, RestoreContext context)
{
switch (@event.Payload)
{
case ContentCreated contentCreated:
contentIdsBySchemaId.GetOrAddNew(contentCreated.SchemaId.Id).Add(@event.Headers.AggregateId());
break;
case SchemaDeleted schemaDeleted:
contentIdsBySchemaId.Remove(schemaDeleted.SchemaId.Id);
break;
}
return(Task.FromResult(true));
}
public Task <bool> RestoreEventAsync(Envelope <IEvent> @event, RestoreContext context)
{
switch (@event.Payload)
{
case RuleCreated ruleCreated:
ruleIds.Add(ruleCreated.RuleId);
break;
case RuleDeleted ruleDeleted:
ruleIds.Remove(ruleDeleted.RuleId);
break;
}
return(Task.FromResult(true));
}
public Task <bool> RestoreEventAsync(Envelope <IEvent> @event, RestoreContext context)
{
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 Task <bool> RestoreEventAsync(Envelope <IEvent> @event, RestoreContext context,
CancellationToken ct)
{
switch (@event.Payload)
{
case RuleCreated:
ruleIds.Add(@event.Headers.AggregateId());
break;
case RuleDeleted:
ruleIds.Remove(@event.Headers.AggregateId());
break;
}
return(Task.FromResult(true));
}
public async Task <bool> RestoreEventAsync(Envelope <IEvent> @event, RestoreContext context,
CancellationToken ct)
{
switch (@event.Payload)
{
case AppCreated appCreated:
{
await ReserveAppAsync(context.AppId, appCreated.Name, ct);
break;
}
case AppImageUploaded:
{
await ReadAssetAsync(context.AppId, context.Reader, ct);
break;
}
case AppContributorAssigned contributorAssigned:
{
if (!context.UserMapping.TryMap(contributorAssigned.ContributorId, out var user) || user.Equals(context.Initiator))
{
return(false);
}
contributorAssigned.ContributorId = user.Identifier;
contributors.Add(contributorAssigned.ContributorId);
break;
}
case AppContributorRemoved contributorRemoved:
{
if (!context.UserMapping.TryMap(contributorRemoved.ContributorId, out var user) || user.Equals(context.Initiator))
{
return(false);
}
contributorRemoved.ContributorId = user.Identifier;
contributors.Remove(contributorRemoved.ContributorId);
break;
}
}
return(true);
}
public async Task Should_restore_indices_for_all_non_deleted_rules()
{
var appId = Guid.NewGuid();
var ruleId1 = Guid.NewGuid();
var ruleId2 = Guid.NewGuid();
var ruleId3 = Guid.NewGuid();
var context = new RestoreContext(appId, new UserMapping(new RefToken(RefTokenType.Subject, "123")), A.Fake <IBackupReader>());
await sut.RestoreEventAsync(Envelope.Create(new RuleCreated
{
RuleId = ruleId1
}), context);
await sut.RestoreEventAsync(Envelope.Create(new RuleCreated
{
RuleId = ruleId2
}), context);
await sut.RestoreEventAsync(Envelope.Create(new RuleCreated
{
RuleId = ruleId3
}), context);
await sut.RestoreEventAsync(Envelope.Create(new RuleDeleted
{
RuleId = ruleId3
}), context);
HashSet <Guid>?newIndex = null;
A.CallTo(() => index.RebuildAsync(appId, A <HashSet <Guid> > ._))
.Invokes(new Action <Guid, HashSet <Guid> >((_, i) => newIndex = i));
await sut.RestoreAsync(context);
Assert.Equal(new HashSet <Guid>
{
ruleId1,
ruleId2
}, newIndex);
}
public static LockFileTargetLibrary CreateLockFileTargetLibrary(LockFileLibrary library, IPackage package, RestoreContext context, string correctedPackageName)
{
var lockFileLib = new LockFileTargetLibrary();
var framework = context.FrameworkName;
var runtimeIdentifier = context.RuntimeName;
// package.Id is read from nuspec and it might be in wrong casing.
// correctedPackageName should be the package name used by dependency graph and
// it has the correct casing that runtime needs during dependency resolution.
lockFileLib.Name = correctedPackageName ?? package.Id;
lockFileLib.Version = package.Version;
var files = library.Files.Select(p => p.Replace(Path.DirectorySeparatorChar, '/'));
var contentItems = new ContentItemCollection();
contentItems.Load(files);
IEnumerable<PackageDependencySet> dependencySet;
if (VersionUtility.GetNearest(framework, package.DependencySets, out dependencySet))
{
var set = dependencySet.FirstOrDefault()?.Dependencies?.ToList();
if (set != null)
{
lockFileLib.Dependencies = set;
}
}
// TODO: Remove this when we do #596
// ASP.NET Core and .NET Core 5.0 don't have framework reference assemblies
if (!VersionUtility.IsPackageBased(framework))
{
IEnumerable<FrameworkAssemblyReference> frameworkAssemblies;
if (VersionUtility.GetNearest(framework, package.FrameworkAssemblies, out frameworkAssemblies))
{
AddFrameworkReferences(lockFileLib, framework, frameworkAssemblies);
}
// Add framework assemblies with empty supported frameworks
AddFrameworkReferences(lockFileLib, framework, package.FrameworkAssemblies.Where(f => !f.SupportedFrameworks.Any()));
}
var patterns = PatternDefinitions.DotNetPatterns;
var criteriaBuilderWithTfm = new SelectionCriteriaBuilder(patterns.Properties.Definitions);
var criteriaBuilderWithoutTfm = new SelectionCriteriaBuilder(patterns.Properties.Definitions);
if (context.RuntimeSpecs != null)
{
foreach (var runtimeSpec in context.RuntimeSpecs)
{
criteriaBuilderWithTfm = criteriaBuilderWithTfm
.Add["tfm", framework]["rid", runtimeSpec.Name];
criteriaBuilderWithoutTfm = criteriaBuilderWithoutTfm
.Add["rid", runtimeSpec.Name];
}
}
criteriaBuilderWithTfm = criteriaBuilderWithTfm
.Add["tfm", framework];
var criteria = criteriaBuilderWithTfm.Criteria;
var compileGroup = contentItems.FindBestItemGroup(criteria, patterns.CompileTimeAssemblies, patterns.ManagedAssemblies);
if (compileGroup != null)
{
lockFileLib.CompileTimeAssemblies = compileGroup.Items.Select(t => (LockFileItem)t.Path).ToList();
}
var runtimeGroup = contentItems.FindBestItemGroup(criteria, patterns.ManagedAssemblies);
if (runtimeGroup != null)
{
lockFileLib.RuntimeAssemblies = runtimeGroup.Items.Select(p => (LockFileItem)p.Path).ToList();
}
var resourceGroup = contentItems.FindBestItemGroup(criteria, patterns.ResourceAssemblies);
if (resourceGroup != null)
{
lockFileLib.ResourceAssemblies = resourceGroup.Items.Select(ToResourceLockFileItem).ToList();
}
var nativeGroup = contentItems.FindBestItemGroup(criteriaBuilderWithoutTfm.Criteria, patterns.NativeLibraries);
if (nativeGroup != null)
{
lockFileLib.NativeLibraries = nativeGroup.Items.Select(p => (LockFileItem)p.Path).ToList();
}
// COMPAT: Support lib/contract so older packages can be consumed
string contractPath = "lib/contract/" + package.Id + ".dll";
var hasContract = files.Any(path => path == contractPath);
var hasLib = lockFileLib.RuntimeAssemblies.Any();
if (hasContract && hasLib && !VersionUtility.IsDesktop(framework))
{
lockFileLib.CompileTimeAssemblies.Clear();
lockFileLib.CompileTimeAssemblies.Add(contractPath);
}
// See if there's a list of specific references defined for this target framework
IEnumerable<PackageReferenceSet> referenceSets;
if (VersionUtility.GetNearest(framework, package.PackageAssemblyReferences, out referenceSets))
{
// Get the first compatible reference set
var referenceSet = referenceSets.FirstOrDefault();
if (referenceSet != null)
{
// Remove all assemblies of which names do not appear in the References list
lockFileLib.RuntimeAssemblies.RemoveAll(path => path.Path.StartsWith("lib/") && !referenceSet.References.Contains(Path.GetFileName(path), StringComparer.OrdinalIgnoreCase));
lockFileLib.CompileTimeAssemblies.RemoveAll(path => path.Path.StartsWith("lib/") && !referenceSet.References.Contains(Path.GetFileName(path), StringComparer.OrdinalIgnoreCase));
}
}
return lockFileLib;
}
//Dataloss testing can be triggered via powershell. To do so, run the following commands as a script
//Connect-ServiceFabricCluster
//$s = "fabric:/WebReferenceApplication/InventoryService"
//$p = Get-ServiceFabricApplication | Get-ServiceFabricService -ServiceName $s | Get-ServiceFabricPartition | Select -First 1
//$p | Invoke-ServiceFabricPartitionDataLoss -DataLossMode FullDataLoss -ServiceName $s
protected override async Task<bool> OnDataLossAsync(RestoreContext restoreCtx, CancellationToken cancellationToken)
{
ServiceEventSource.Current.ServiceMessage(this, "OnDataLoss Invoked!");
this.SetupBackupManager();
try
{
string backupFolder;
if (this.backupStorageType == BackupManagerType.None)
{
//since we have no backup configured, we return false to indicate
//that state has not changed. This replica will become the basis
//for future replica builds
return false;
}
else
{
backupFolder = await this.backupManager.RestoreLatestBackupToTempLocation(cancellationToken);
}
ServiceEventSource.Current.ServiceMessage(this, "Restoration Folder Path " + backupFolder);
RestoreDescription restoreRescription = new RestoreDescription(backupFolder, RestorePolicy.Force);
await restoreCtx.RestoreAsync(restoreRescription, cancellationToken);
ServiceEventSource.Current.ServiceMessage(this, "Restore completed");
DirectoryInfo tempRestoreDirectory = new DirectoryInfo(backupFolder);
tempRestoreDirectory.Delete(true);
return true;
}
catch (Exception e)
{
ServiceEventSource.Current.ServiceMessage(this, "Restoration failed: " + "{0} {1}" + e.GetType() + e.Message);
throw;
}
}
