/// <inheritdoc/> /// <remark> /// Returns all of the stored embedding states, even ones that have been marked as removed. /// <remark/> public async Task <Try <IEnumerable <(EmbeddingState State, ProjectionKey Key)> > > TryGetAll( EmbeddingId embedding, CancellationToken token) { try { var states = await OnEmbedding( embedding, async collection => await collection .Find(Builders <Embedding> .Filter.Empty) .Project(_ => Tuple.Create <EmbeddingState, ProjectionKey>( new EmbeddingState(_.Content, _.Version, _.IsRemoved), _.Key)) .ToListAsync(token) .ConfigureAwait(false), token).ConfigureAwait(false); var result = states.Select(_ => { return(_.Item1, _.Item2); }); return(Try <IEnumerable <(EmbeddingState State, ProjectionKey Key)> > .Succeeded(result)); } catch (Exception ex) { return(ex); } }
/// <inheritdoc/> public async Task <Try <EmbeddingCurrentState> > TryGet(EmbeddingId embedding, ProjectionKey key, CancellationToken token) { _logger.GettingOneEmbedding(embedding, key); var state = await _embeddingStates.TryGet(embedding, key, token); var result = state switch { { Success : true, Result : { IsRemoved : true } } => await TryGetInitialState(
/// <summary> /// Initializes an instance of the <see cref="ProjectManyEvents" /> class. /// </summary> /// <param name="embedding">The <see cref="EmbeddingId"/> that identifies the embedding.</param> /// <param name="projection">The <see cref="IProjection"/> that is used to update the state.</param> /// <param name="initialState">The <see cref="ProjectionState"/> that is used to initialize newly created states.</param> /// <param name="logger">The <see cref="ILogger" />.</param> public ProjectManyEvents( EmbeddingId identifier, IEmbedding embedding, ProjectionState initialState, ILogger logger) { _identifier = identifier; _embedding = embedding; _initialState = initialState; _logger = logger; }
/// <summary> /// Initializes an instance of the <see cref="Embedding" /> class. /// </summary> /// <param name="embeddingId">The identifier for this embedding.</param> /// <param name="dispatcher">The reverse call dispatcher to use to dispatch update and delete calls to the client.</param> /// <param name="requestFactory">The factory to use to create requests to the client.</param> /// <param name="logger">The logger to use for logging.</param> public Embedding( EmbeddingId embeddingId, ReverseCallDispatcherType dispatcher, IEmbeddingRequestFactory requestFactory, ILogger logger) { _embeddingId = embeddingId; _dispatcher = dispatcher; _requestFactory = requestFactory; _logger = logger; }
/// <summary> /// Initializes a new instance of the <see cref="EmbeddingStateUpdater"/> class. /// </summary> /// <param name="embedding">The <see cref="EmbeddingId"/> that identifies the embedding.</param> /// <param name="committedEvents">The <see cref="IFetchCommittedEvents"/> that is used to fetch aggregate events.</param> /// <param name="embeddingStore">The <see cref="IEmbeddingStore"/> that is used to persist the states.</param> /// <param name="logger">The <see cref="ILogger"/>.</param> public EmbeddingStateUpdater( EmbeddingId embedding, IFetchCommittedEvents committedEvents, IEmbeddingStore embeddingStore, IProjectManyEvents projectManyEvents, ILogger logger) { _embedding = embedding; _committedEvents = committedEvents; _embeddingStore = embeddingStore; _projectManyEvents = projectManyEvents; _logger = logger; }
bool TryGetRegisteredEmbeddingProcessorForTenant(TenantId tenant, EmbeddingId embedding, out IEmbeddingProcessor processor, out Failure failure) { failure = default; if (!_embeddingProcessors.TryGetEmbeddingProcessorFor(tenant, embedding, out processor)) { failure = new Dolittle.Protobuf.Contracts.Failure { Id = EmbeddingFailures.NoEmbeddingRegisteredForTenant.ToProtobuf(), Reason = $"No embedding with id {embedding.Value} registered for tenant {tenant.Value}" }; return(false); } return(true); }
/// <summary> /// Initializes an instance of the <see cref="StateTransitionEventsCalculator" /> class. /// </summary> /// <param name="identifier">The <see cref="EmbeddingId" />.</param> /// <param name="embedding">The <see cref="IEmbedding" />.</param> /// <param name="projector">The <see cref="IProjectManyEvents"/>.</param> /// <param name="stateComparer">The <see cref="ICompareStates"/>.</param> /// <param name="loopDetector">The <see cref="IDetectEmbeddingLoops"/>.</param> /// <param name="logger">The <see cref="ILogger"/>.</param> public StateTransitionEventsCalculator( EmbeddingId identifier, IEmbedding embedding, IProjectManyEvents projector, ICompareStates stateComparer, IDetectEmbeddingLoops loopDetector, ILogger logger) { _embeddingId = identifier; _embedding = embedding; _projector = projector; _stateComparer = stateComparer; _loopDetector = loopDetector; _logger = logger; }
/// <inheritdoc/> public IEmbeddingProcessor Create(EmbeddingId embeddingId, IEmbedding embedding, ProjectionState initialState, ExecutionContext executionContext) { var projectManyEvents = CreateProjectManyEvents(embeddingId, embedding, initialState); return(new EmbeddingProcessor( embeddingId, _tenant, executionContext, CreateEmbeddingStateUpdater(embeddingId, projectManyEvents), _streamEventWatcher, _eventStore, _embeddingStore, CreateStateTransitionEventsCalculator(embeddingId, embedding, projectManyEvents), _loggerFactory.CreateLogger <EmbeddingProcessor>())); }
/// <inheritdoc/> public async Task <Try <Store.Definition.EmbeddingDefinition> > TryGet(EmbeddingId embedding, CancellationToken token) { try { return(await OnDefinitions <Try <Store.Definition.EmbeddingDefinition> >( async collection => { var definition = await collection .Find(CreateIdFilter(embedding)) .SingleOrDefaultAsync(token) .ConfigureAwait(false); return definition == null ? Try <Store.Definition.EmbeddingDefinition> .Failed(new EmbeddingDefinitionDoesNotExist(embedding)) : _definitionConverter.ToRuntime(definition); }, token).ConfigureAwait(false)); } catch (Exception ex) { return(ex); } }
/// <inheritdoc/> public async Task <Try <bool> > TryReplace( EmbeddingId embedding, ProjectionKey key, EmbeddingState state, CancellationToken token) { try { return(await OnEmbedding( embedding, async collection => { var updateDefinition = Builders <Embedding> .Update .Set(_ => _.Content, state.State.Value) .Set(_ => _.Version, state.Version.Value) .Set(_ => _.IsRemoved, state.IsRemoved); var updateResult = await collection .UpdateOneAsync( CreateKeyFilter(key), updateDefinition, new UpdateOptions { IsUpsert = true }, token) .ConfigureAwait(false); return updateResult.IsAcknowledged; }, token).ConfigureAwait(false)); } catch (MongoWaitQueueFullException) { return(false); } catch (Exception ex) { return(ex); } }
/// <inheritdoc/> public async Task <Try> TryDrop(EmbeddingId embedding, CancellationToken token) { try { await OnEmbedding( embedding, async collection => { var deleteResult = await collection .DeleteManyAsync(Builders <Embedding> .Filter.Empty, token) .ConfigureAwait(false); return(deleteResult.IsAcknowledged); }, token).ConfigureAwait(false); return(Try.Succeeded()); } catch (Exception ex) { return(ex); } }
/// <inheritdoc/> public async Task <Try <bool> > TryMarkAsRemove( EmbeddingId embedding, ProjectionKey key, AggregateRootVersion version, CancellationToken token) { try { return(await OnEmbedding( embedding, async collection => { var markDefinition = Builders <Embedding> .Update .Set(_ => _.IsRemoved, true) .Set(_ => _.Version, version.Value); var markResult = await collection .UpdateOneAsync( CreateKeyFilter(key), markDefinition, new UpdateOptions { IsUpsert = true }, token) .ConfigureAwait(false); return markResult.IsAcknowledged; }, token).ConfigureAwait(false)); } catch (MongoWaitQueueFullException) { return(false); } catch (Exception ex) { return(ex); } }
/// <inheritdoc/> public async Task <Try <EmbeddingState> > TryGet( EmbeddingId embeddingId, ProjectionKey key, CancellationToken token) { try { var embedding = await OnEmbedding( embeddingId, async collection => await collection .Find(CreateKeyFilter(key)) .SingleOrDefaultAsync(token) .ConfigureAwait(false), token).ConfigureAwait(false); return(embedding == default ? Try <EmbeddingState> .Failed(new EmbeddingStateDoesNotExist(embeddingId, key)) : new EmbeddingState(embedding.Content, embedding.Version, embedding.IsRemoved)); } catch (Exception ex) { return(ex); } }
async Task <TResult> OnEmbedding <TResult>( EmbeddingId embedding, Func <IMongoCollection <Embedding>, Task <TResult> > callback, CancellationToken token) => await callback(await _embeddings.GetStates(embedding, token).ConfigureAwait(false)) .ConfigureAwait(false);
/// <summary> /// Initializes a new instance of the <see cref="FailedProjectingEvents"/> class. /// </summary> /// <param name="embedding">The <see cref="EmbeddingId"/> </param> /// <param name="inner">The inner<see cref="Exception"/> </param> public FailedProjectingEvents(EmbeddingId embedding, Exception inner) : base($"A failure occurred while projecting events for embedding {embedding.Value}", inner) { }
/// <summary> /// Initializes a new instance of the <see cref="EmbeddingRemoteDeleteCallFailed"/> class. /// </summary> /// <param name="embedding">The <see cref="EmbeddingId"/> </param> public EmbeddingRemoteDeleteCallFailed(EmbeddingId embedding, string reason) : base($"A failure occurred during the remote Delete call for embedding {embedding.Value}. {reason}") { }
/// <inheritdoc/> public Task <Try <IEnumerable <ProjectionKey> > > TryGetKeys(EmbeddingId embedding, ExecutionContext context, CancellationToken token) => _executionContextCreator .TryCreateUsing(context) .Then(_ => _getEmbeddingStoreFor(_.Tenant)) .Then(_ => _.TryGetKeys(embedding, token));
EmbeddingStateUpdater CreateEmbeddingStateUpdater(EmbeddingId embeddingId, IProjectManyEvents projectManyEvents) => new(embeddingId, _committedEventsFetcher, _embeddingStore, projectManyEvents, _loggerFactory.CreateLogger <EmbeddingStateUpdater>());
/// <summary> /// Initializes an instance of the <see cref="FailedToRemoveEmbedding" /> class. /// </summary> /// <param name="embedding">The embedding identifier.</param> /// <param name="key">The projection key</param> /// <param name="version">The aggregate root version.</param> public FailedToRemoveEmbedding(EmbeddingId embedding, ProjectionKey key, AggregateRootVersion version) : base($"Failed to remove embedding with id {embedding.Value}, key {key.Value} and aggregate root version {version.Value}") { }
/// <summary> /// Initializes an instance of the <see cref="FailedToGetEmbeddingKeys" /> class. /// </summary> /// <param name="embedding">The embedding identifier.</param> public FailedToGetEmbeddingKeys(EmbeddingId embedding) : base($"Failed to get embedding's keys, EmbeddingId: {embedding.Value}") { }
internal static void ErrorGettingEmbeddingKeys(this ILogger logger, EmbeddingId embedding, Exception exception) => _errorGettingEmbeddingKeys(logger, embedding, exception);
internal static void GettingEmbeddingKeys(this ILogger logger, EmbeddingId embedding) => _gettingEmbeddingKeys(logger, embedding, null);
/// <inheritdoc/> public Task <Try <IEnumerable <EmbeddingCurrentState> > > TryGetAll(EmbeddingId embedding, ExecutionContext context, CancellationToken token) => _executionContextCreator .TryCreateUsing(context) .Then(_ => _getEmbeddingStoreFor(_.Tenant)) .Then(_ => _.TryGetAll(embedding, token));
/// <summary> /// Initializes a new instance of the <see cref="EmbeddingProcessorNotStarted"/> class. /// </summary> /// <param name="embedding">The <see cref="EmbeddingId"/> </param> public EmbeddingProcessorNotStarted(EmbeddingId embedding) : base($"EmbeddingProcessor for embedding {embedding.Value} is not started") { }
FilterDefinition <EmbeddingDefinition> CreateIdFilter(EmbeddingId embedding) => Builders <EmbeddingDefinition> .Filter.Eq(_ => _.Embedding, embedding.Value);
internal static void RemovingEmbedding(this ILogger logger, EmbeddingId embedding, ProjectionKey key, AggregateRootVersion version) => _removingEmbedding(logger, embedding, key, version, null);
internal static void ErrorRemovingEmbedding(this ILogger logger, EmbeddingId embedding, ProjectionKey key, AggregateRootVersion version, Exception exception) => _errorRemovingEmbedding(logger, embedding, key, version, exception);
internal static void ReplacingEmbedding(this ILogger logger, EmbeddingId embedding, ProjectionKey key, AggregateRootVersion version, ProjectionState state) => _replacingEmbedding(logger, embedding, key, version, state, null);
/// <summary> /// Initializes an instance of the <see cref="EmbeddingStateDoesNotExist" /> class. /// </summary> /// <param name="embedding">The embedding id.</param> /// <param name="key">The key to the embedding.</param> public EmbeddingStateDoesNotExist(EmbeddingId embedding, ProjectionKey key) : base($"An embedding state for embedding {embedding.Value} with key {key.Value} does not exist") { }
/// <inheritdoc/> public Task <Try <EmbeddingCurrentState> > TryGetOne(EmbeddingId embedding, ProjectionKey key, ExecutionContext context, CancellationToken token) => _executionContextCreator .TryCreateUsing(context) .Then(_ => _getEmbeddingStoreFor(_.Tenant)) .Then(_ => _.TryGet(embedding, key, token));