async Task <bool> RejectIfInvalidDefinition(
EmbeddingDefinition definition,
IReverseCallDispatcher <EmbeddingClientToRuntimeMessage, EmbeddingRuntimeToClientMessage, EmbeddingRegistrationRequest, EmbeddingRegistrationResponse, EmbeddingRequest, EmbeddingResponse> dispatcher,
CancellationToken cancellationToken)
{
_logger.ComparingEmbeddingDefinition(definition);
var tenantsAndComparisonResult = await _embeddingDefinitionComparer.DiffersFromPersisted(
new EmbeddingDefinition(
definition.Embedding,
definition.Events,
definition.InititalState),
cancellationToken).ConfigureAwait(false);
if (tenantsAndComparisonResult.Values.All(_ => _.Succeeded))
{
return(false);
}
var unsuccessfulComparisons = tenantsAndComparisonResult
.Where(_ => !_.Value.Succeeded)
.Select(_ => (_.Key, _.Value));
_logger.InvalidEmbeddingDefinition(definition, unsuccessfulComparisons);
await dispatcher.Reject(CreateInvalidValidationResponse(
unsuccessfulComparisons,
definition.Embedding),
cancellationToken).ConfigureAwait(false);
return(true);
}
static bool InitialStatesAreEqual(EmbeddingDefinition newDefinition, EmbeddingDefinition oldDefinition, out EmbeddingDefinitionComparisonResult failedComparison)
{
failedComparison = null;
if (newDefinition.InititalState == oldDefinition.InititalState)
{
return(true);
}
failedComparison = EmbeddingDefinitionComparisonResult.Unequal("The initial Embedding state is not the same as the persisted definition");
return(false);
}
static EmbeddingDefinitionComparisonResult DefinitionsAreEqual(
EmbeddingDefinition newDefinition,
EmbeddingDefinition oldDefinition)
{
if (newDefinition.Embedding != oldDefinition.Embedding)
{
return(EmbeddingDefinitionComparisonResult.Unequal($"The new Embedding identifier {newDefinition.Embedding.Value} is not the same as the persisted embedding identifier {oldDefinition.Embedding.Value}"));
}
if (!InitialStatesAreEqual(newDefinition, oldDefinition, out var failedComparison))
{
return(failedComparison);
}
return(!EventsAreEqual(newDefinition, oldDefinition, out failedComparison)
? failedComparison
: EmbeddingDefinitionComparisonResult.Equal);
}
/// <inheritdoc/>
public async Task <IDictionary <TenantId, EmbeddingDefinitionComparisonResult> > DiffersFromPersisted(
EmbeddingDefinition definition,
CancellationToken token)
{
var results = new Dictionary <TenantId, EmbeddingDefinitionComparisonResult>();
await _forAllTenants.PerformAsync(async (tenant, _) =>
{
var definitions = _getDefinitionsFor(tenant);
var tryGetDefinition = await definitions.TryGet(definition.Embedding, token).ConfigureAwait(false);
var comparisonResult = tryGetDefinition.Success switch
{
true => DefinitionsAreEqual(definition, tryGetDefinition),
false => EmbeddingDefinitionComparisonResult.Equal
};
results.Add(tenant, comparisonResult);
}).ConfigureAwait(false);
return(results);
}
/// <inheritdoc/>
public async Task <Try> TryPersist(EmbeddingDefinition definition, CancellationToken token)
{
_logger.PersistingDefinition(definition.Embedding);
var results = new Dictionary <TenantId, Try <bool> >();
await _forAllTenants.PerformAsync(async (tenant, _) =>
{
var result = await _getDefinitionsFor(tenant).TryPersist(definition, token).ConfigureAwait(false);
results.Add(tenant, result);
}).ConfigureAwait(false);
if (results.Any(_ => !_.Value.Success))
{
return(results.First(_ => !_.Value.Success).Value.Exception);
}
if (results.Any(_ => !_.Value.Result))
{
return(new FailedPersistingEmbeddingDefinition(definition.Embedding));
}
return(Try.Succeeded());
}
static bool EventsAreEqual(EmbeddingDefinition newDefinition, EmbeddingDefinition oldDefinition, out EmbeddingDefinitionComparisonResult failedComparison)
{
failedComparison = null;
if (newDefinition.Events.Count() != oldDefinition.Events.Count())
{
failedComparison = EmbeddingDefinitionComparisonResult.Unequal("The definitions does not have the same number of events");
return(false);
}
foreach (var newEvent in newDefinition.Events)
{
var oldEvent = oldDefinition.Events.FirstOrDefault(oldEvent => oldEvent.Id == newEvent.Id);
if (oldEvent != default)
{
continue;
}
failedComparison = EmbeddingDefinitionComparisonResult.Unequal($"Event {newEvent.Id.Value} was not in previous Embedding definition");
return(false);
}
return(true);
}
/// <inheritdoc/> public Store.Definition.EmbeddingDefinition ToRuntime(EmbeddingDefinition definition) => new(
internal static void InvalidEmbeddingDefinition(this ILogger logger, EmbeddingDefinition defintion, IEnumerable <(TenantId, EmbeddingDefinitionComparisonResult)> failedComparisons)
internal static void ComparingEmbeddingDefinition(this ILogger logger, EmbeddingDefinition arguments) => _comparingEmbeddingDefinition(logger, arguments.Embedding, null);
