public MyVector(Reconciler rec, DataKind kind, int min, int?max)
: base(rec, null)
{
_kind = kind;
_min = min;
_max = max;
}
// Contstuct a representation for a key-typed column loaded from a text file. Key values are assumed to be contiguous.
public MyKey(Reconciler rec, DataKind kind, int oridinal, ulong minKeyValue, ulong?maxKeyValue = null)
: base(rec, null)
{
_kind = kind;
_oridinal = oridinal;
_minKeyValue = minKeyValue;
_maxKeyValue = maxKeyValue;
}
public async Task GivenSequencesWithAPreviousAndTargetSequenceThenTheReconcilerIsInvokedOnceForEachAggregateAboveThePreviousAndBelowTheTargetSequenceAsync()
{
const int ExpectedInvocations = 1;
int eventsReconciling = 0;
int eventsReconciled = 0;
SequencedEvents[] sequences = new[]
{
new SequencedEvents(1, CreateEvents()),
new SequencedEvents(2, CreateEvents()),
new SequencedEvents(3, CreateEvents()),
new SequencedEvents(4, CreateEvents()),
new SequencedEvents(5, CreateEvents()),
};
ulong previous = 1;
ulong target = 4;
SequencedEvents[] expected = sequences
.Where(aggregate => aggregate.Sequence > previous && aggregate.Sequence <= target)
.ToArray();
var aggregates = expected.ToDictionary(sequence => sequence.Aggregate, sequence => 0);
_ = EventStore
.Setup(store => store.ReadAsync(
It.Is <ulong>(value => value == previous),
It.IsAny <CancellationToken?>(),
It.IsAny <ushort>()))
.ReturnsAsync(expected);
_ = EventStore
.Setup(store => store.ReadAsync(
It.Is <ulong>(value => value > previous),
It.IsAny <CancellationToken?>(),
It.IsAny <ushort>()))
.ReturnsAsync(Enumerable.Empty <SequencedEvents>());
_ = Reconciler
.Setup(reconciler => reconciler.ReconcileAsync(
It.IsAny <IEnumerable <DomainEvent> >(),
It.IsAny <CancellationToken?>()))
.Callback <IEnumerable <DomainEvent>, CancellationToken?>((value, _) => aggregates[value.First().Aggregate]++);
instance.EventsReconciling += (sender, e) => Task.FromResult(eventsReconciling++);
instance.EventsReconciled += (sender, e) => Task.FromResult(eventsReconciled++);
_ = await instance.ReconcileAsync(previous : previous, target : target);
int invocations = expected.Length;
int skips = sequences.Length - invocations;
Assert.Equal(invocations, eventsReconciling);
Assert.Equal(invocations, eventsReconciled);
Assert.All(aggregates.Values, value => Assert.Equal(ExpectedInvocations, value));
}
public async Task GivenSequencesThenTheReconcilerIsInvokedOnceForEachAggregate()
{
const int ExpectedInvocations = 1;
int eventsReconciling = 0;
int eventsReconciled = 0;
SequencedEvents[] sequences = new[]
{
new SequencedEvents(1, CreateEvents()),
new SequencedEvents(2, CreateEvents()),
new SequencedEvents(3, CreateEvents()),
};
var aggregates = sequences.ToDictionary(sequence => sequence.Aggregate, sequence => 0);
_ = EventStore
.Setup(store => store.ReadAsync(
It.Is <ulong>(value => value == ulong.MinValue),
It.IsAny <CancellationToken?>(),
It.IsAny <ushort>()))
.ReturnsAsync(sequences);
_ = EventStore
.Setup(store => store.ReadAsync(
It.Is <ulong>(value => value > ulong.MinValue),
It.IsAny <CancellationToken?>(),
It.IsAny <ushort>()))
.ReturnsAsync(Enumerable.Empty <SequencedEvents>());
_ = Reconciler
.Setup(reconciler => reconciler.ReconcileAsync(
It.IsAny <IEnumerable <DomainEvent> >(),
It.IsAny <CancellationToken?>()))
.Callback <IEnumerable <DomainEvent>, CancellationToken?>((value, _) => aggregates[value.First().Aggregate]++);
instance.EventsReconciling += (sender, e) => Task.FromResult(eventsReconciling++);
instance.EventsReconciled += (sender, e) => Task.FromResult(eventsReconciled++);
_ = await instance.ReconcileAsync();
Assert.Equal(sequences.Length, eventsReconciling);
Assert.Equal(sequences.Length, eventsReconciled);
Assert.All(aggregates.Values, value => Assert.Equal(ExpectedInvocations, value));
}
public void MultipleNestedCustomComponents_CreatesCorrectElementTree()
{
var component1 = UIComponentDefinition.Create("Test1", converter.Convert(@"
function render(props)
return (
<Button id={""level1""}>
<Button id={""level2""}>
{props.children}
</Button>
</Button>
)
end"));
this.index.Components.Add("Test1", component1);
var component2 = UIComponentDefinition.Create("Test2", converter.Convert(@"
function render(props)
return (
<Test1>
<Button>
<Text
textAnchor={""MiddleCenter""}
alignByGeometry={""false""}
text={props.test}
/>
</Button>
</Test1>
)
end"));
var rootElement = Element.Create(component2, new PropCollection(new Dictionary <string, object>()
{
{ "test", "some text" }
}));
Reconciler.CreateElementTree(rootElement);
Assert.AreEqual(1, rootElement.Children.Count);
Assert.AreEqual("Test1", rootElement.Children.First().Component.Name);
}
private sealed class AKey <T> : Key <T>, IDeps { public AKey(Reconciler rec, PipelineColumn[] dependencies) : base(rec, dependencies)
{
Deps = dependencies;
}
private sealed class AVarVector <T> : VarVector <T>, IDeps { public AVarVector(Reconciler rec, PipelineColumn[] dependencies) : base(rec, dependencies)
{
Deps = dependencies;
}
public MyScalar(Reconciler rec, DataKind kind, int ordinal)
: base(rec, null)
{
_kind = kind;
_ordinal = ordinal;
}
internal Context(Reconciler rec)
{
Contracts.AssertValue(rec);
_rec = rec;
}
private async Task ProcessJobInfoAsync(Guid activityId, IPolicyAgentDocumentForTenant doc, CancellationToken cancellationToken)
{
DateTime now = DateTime.UtcNow;
TimeSpan completedTaskAgeThreshold = this.GetCompletedTaskAgeThreshold();
// get the ones that are claimed by this service (which is the Repair Executor (RE))
var repairTasks = await repairManager
.GetRepairTaskListAsync(activityId, null, RepairTaskStateFilter.Default, this.environment.ServiceName)
.ConfigureAwait(false);
// Count completed tasks that are going to be ignored because they are too old
int oldCompletedTaskCount = repairTasks.Count(t => IsOldCompletedRepairTask(t, now, completedTaskAgeThreshold));
// Keep all of the rest (active or recent)
repairTasks = repairTasks.Where(t => !IsOldCompletedRepairTask(t, now, completedTaskAgeThreshold)).ToList();
// get all the unclaimed repair tasks too... some may not match, we'll evaluate and ignore them later
var unclaimedRepairTasks = await repairManager
.GetRepairTaskListAsync(activityId, null, RepairTaskStateFilter.Created, null)
.ConfigureAwait(false);
foreach (var unclaimedRepairTask in unclaimedRepairTasks)
{
repairTasks.Add(unclaimedRepairTask);
}
traceType.WriteInfo(
"Processing repair tasks (count: {0}; ignored completed tasks older than {1}: {2})",
repairTasks.Count,
completedTaskAgeThreshold,
oldCompletedTaskCount);
// Dump each task separately to avoid exceeding the ETW event size limit
for (int i = 0; i < repairTasks.Count; ++i)
{
traceType.WriteInfo("Repair task {0} of {1}:{2}{3}", i + 1, repairTasks.Count, Environment.NewLine, repairTasks[i].ToJson());
}
var coordinatorContext = new CoordinatorContext {
Doc = doc
};
ActionHelper.CreateMappedWorkItems(doc.Jobs, repairTasks, coordinatorContext);
var reconciler = new Reconciler(
this.environment,
this.policyAgentClient,
this.repairManager,
this.repairActionProvider);
await reconciler.ReconcileAsync(activityId, coordinatorContext).ConfigureAwait(false);
await ActionHelper.ApplyPoliciesAsync(activityId, actionPolicies, coordinatorContext).ConfigureAwait(false);
// Publish state after reconcile + policy phases have completed
coordinatorContext.MarkFinished();
coordinatorCommandProcessor.CoordinatorContext = coordinatorContext;
var blockingPolicy = await this.jobBlockingPolicyManager.GetPolicyAsync();
if (blockingPolicy == JobBlockingPolicy.BlockAllJobs)
{
traceType.WriteInfo("All actions are blocked by job blocking policy");
}
else
{
var actionsToExecute = ActionHelper.GetActions(activityId, coordinatorContext);
await ActionHelper.ExecuteActionsAsync(activityId, this.actionTraceType, actionsToExecute).ConfigureAwait(false);
// Send all job responses (if any) as a single batch response
await policyAgentClient.SendJobResponseAsync(
activityId,
doc.JobDocumentIncarnation,
reconciler.GetJobStepResponses(),
"Automated response by Service Fabric Infrastructure Service",
cancellationToken).ConfigureAwait(false);
}
}
public static Reconciler ExcludeExtensions(this Reconciler recon, params string[] extensions)
{
recon.AddFilter(new FileExtensionFilter(extensions));
return(recon);
}
