public override void Build() { var hasher = new ProjectionHasher(); var builder = this as ISettingsBuilder; var processorSettings = this as ISubscrptionMiddlewareSettings; Func <SubscriptionMiddleware> messageHandlerProcessorFactory = () => { var handlerFactory = new DefaultHandlerFactory(processorSettings.HandlerFactory); var clusterServiceMiddleware = new SystemMiddleware(handlerFactory); var middleware = processorSettings.HandleMiddleware(clusterServiceMiddleware); var subscriptionMiddleware = new SubscriptionMiddleware(); var clusterSettings = builder.Container.Resolve <IClusterSettings>(); string nodeId = $"{clusterSettings.CurrentNodeName}@{clusterSettings.ClusterName}"; foreach (var reg in (this as ISubscrptionMiddlewareSettings).HandlerRegistrations) { string subscriberId = reg.FullName + "." + nodeId; if (typeof(ISystemProjection).IsAssignableFrom(reg) && reg.IsClass) { subscriptionMiddleware.Subscribe(new SystemProjectionSubscriber(reg, middleware, subscriberId)); var transport = builder.Container.Resolve <ITransport>(builder.Name); var serializer = builder.Container.Resolve <ISerializer>(null); var publisher = transport.GetPublisher <ICommand>(serializer); var projManagerId = new ProjectionVersionManagerId(reg.GetContractId()); var command = new RegisterProjection(projManagerId, hasher.CalculateHash(reg).ToString()); publisher.Publish(command); } } return(subscriptionMiddleware); }; builder.Container.RegisterSingleton <SubscriptionMiddleware>(() => messageHandlerProcessorFactory(), builder.Name); }
private async Task <bool> IsVersionTrackerMissingAsync() { var versionId = new ProjectionVersionManagerId(ProjectionVersionsHandler.ContractId, context.Tenant); var result = await projectionReader.GetAsync <ProjectionVersionsHandler>(versionId).ConfigureAwait(false); return(result.HasError || result.NotFound); }
bool IsVersionTrackerMissing() { var versionId = new ProjectionVersionManagerId(ProjectionVersionsHandler.ContractId, context.Tenant); var result = projectionReader.Get <ProjectionVersionsHandler>(versionId); return(result.HasError || result.NotFound); }
private async Task <ProjectionVersion> GetLiveVersion(Type projectionType) { var projectionVersionManagerId = new ProjectionVersionManagerId(projectionType.GetContractId(), context.Tenant); ProjectionDto dto = await ExploreAsync(projectionVersionManagerId, typeof(ProjectionVersionsHandler)).ConfigureAwait(false); var state = dto?.State as ProjectionVersionsHandlerState; ProjectionVersion liveVersion = state is null ? null : state.AllVersions.GetLive(); return(liveVersion); }
IProjectionGetResult <PersistentProjectionVersionHandler> GetProjectionVersionsFromStore(string contractId) { var versionId = new ProjectionVersionManagerId(contractId); var persistentVersionType = typeof(PersistentProjectionVersionHandler); var persistentVersionContractId = persistentVersionType.GetContractId(); var persistentVersion = new ProjectionVersion(persistentVersionContractId, ProjectionStatus.Live, 1, persistentVersionType.GetProjectionHash()); ProjectionStream stream = LoadProjectionStream(persistentVersionType, persistentVersion, versionId, new NoSnapshot(versionId, contractId)); var queryResult = stream.RestoreFromHistory <PersistentProjectionVersionHandler>(); return(queryResult); }
public void Bootstrap() { foreach (var handler in handlerTypeContainer.Items) { foreach (var tenant in tenants.GetTenants()) { var id = new ProjectionVersionManagerId(handler.GetContractId(), tenant); var command = new RegisterProjection(id, hasher.CalculateHash(handler)); publisher.Publish(command); } } }
private async Task <ProjectionVersions> GetAllVersionsAsync(ProjectionVersion version) { var versionId = new ProjectionVersionManagerId(version.ProjectionName, context.Tenant); var result = await projectionReader.GetAsync <ProjectionVersionsHandler>(versionId).ConfigureAwait(false); if (result.IsSuccess) { return(result.Data.State.AllVersions); } return(new ProjectionVersions()); }
ProjectionVersions GetAllVersions(ProjectionVersion version) { var versionId = new ProjectionVersionManagerId(version.ProjectionName, context.Tenant); var result = projectionReader.Get <ProjectionVersionsHandler>(versionId); if (result.IsSuccess) { return(result.Data.State.AllVersions); } return(new ProjectionVersions()); }
public async Task <IActionResult> Meta([FromQuery] RequestModel model) { IEnumerable <Assembly> loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().Where(assembly => assembly.IsDynamic == false); Type metadata = loadedAssemblies .SelectMany(assembly => assembly.GetLoadableTypes() .Where(x => typeof(IProjection).IsAssignableFrom(x)) .Where(x => x.GetCustomAttributes(typeof(DataContractAttribute), false).Length > 0)) .Where(x => x.GetContractId() == model.ProjectionContractId) .FirstOrDefault(); if (metadata is null) { return(new BadRequestObjectResult(new ResponseResult <string>($"Projection with contract '{model.ProjectionContractId}' not found"))); } var id = new ProjectionVersionManagerId(model.ProjectionContractId, context.Tenant); ProjectionDto dto = await _projectionExplorer.ExploreAsync(id, typeof(ProjectionVersionsHandler)); var state = dto?.State as ProjectionVersionsHandlerState; var metaProjection = new ProjectionMeta() { ProjectionContractId = metadata.GetContractId(), ProjectionName = metadata.Name, IsReplayable = typeof(IAmEventSourcedProjection).IsAssignableFrom(metadata) }; if (state is null) { metaProjection.Versions.Add(new ProjectionVersionDto() { Status = ProjectionStatus.NotPresent, Hash = projectionHasher.CalculateHash(typeof(ProjectionVersionsHandler)), Revision = 0 }); } else { foreach (var ver in state.AllVersions) { metaProjection.Versions.Add(new ProjectionVersionDto() { Hash = ver.Hash, Revision = ver.Revision, Status = ver.Status }); } } return(Ok(new ResponseResult <ProjectionMeta>(metaProjection))); }
public void Bootstrap() { var systemProjection = typeof(ISystemProjection); foreach (var handler in handlerTypeContainer.Items.OrderByDescending(x => systemProjection.IsAssignableFrom(x))) { foreach (var tenant in tenants.GetTenants()) { var id = new ProjectionVersionManagerId(handler.GetContractId(), tenant); var command = new RegisterProjection(id, hasher.CalculateHash(handler)); publisher.Publish(command); } } }
public async Task <IActionResult> List() { var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().Where(assembly => assembly.IsDynamic == false); var projectionMetaData = loadedAssemblies .SelectMany(ass => ass.GetLoadableTypes() .Where(x => typeof(IProjection).IsAssignableFrom(x) && x.GetCustomAttributes(typeof(DataContractAttribute), false).Length > 0)); ProjectionListDto result = new ProjectionListDto(); foreach (var meta in projectionMetaData) { var id = new ProjectionVersionManagerId(meta.GetContractId(), context.Tenant); var dto = await _projectionExplorer.ExploreAsync(id, typeof(ProjectionVersionsHandler)); ProjectionVersionsHandlerState state = dto?.State as ProjectionVersionsHandlerState; var metaProjection = new ProjectionMeta() { ProjectionContractId = meta.GetContractId(), ProjectionName = meta.Name, IsReplayable = typeof(IAmEventSourcedProjection).IsAssignableFrom(meta) }; if (ReferenceEquals(null, state)) { metaProjection.Versions.Add(new ProjectionVersionDto() { Status = ProjectionStatus.NotPresent, Hash = projectionHasher.CalculateHash(meta), Revision = 0 }); } else { foreach (var ver in state.AllVersions) { metaProjection.Versions.Add(new ProjectionVersionDto() { Hash = ver.Hash, Revision = ver.Revision, Status = ver.Status }); } } result.Projections.Add(metaProjection); } return(new OkObjectResult(new ResponseResult <ProjectionListDto>(result))); }
ProjectionVersions GetProjectionVersions(string contractId) { ProjectionVersions versions = inMemoryVersionStore.Get(contractId); if (versions == null || versions.Count == 0) { var versionId = new ProjectionVersionManagerId(contractId); var persistentVersionType = typeof(PersistentProjectionVersionHandler); var persistentVersionContractId = persistentVersionType.GetContractId(); var persistentVersion = new ProjectionVersion(persistentVersionContractId, ProjectionStatus.Live, 1, persistentVersionType.GetProjectionHash()); ProjectionStream stream = LoadProjectionStream(typeof(PersistentProjectionVersionHandler), persistentVersion, versionId, new NoSnapshot(versionId, contractId)); var queryResult = stream.RestoreFromHistory <PersistentProjectionVersionHandler>(); if (queryResult.Success) { if (queryResult.Projection.State.Live != null) { inMemoryVersionStore.Cache(queryResult.Projection.State.Live); } if (queryResult.Projection.State.Building != null) { inMemoryVersionStore.Cache(queryResult.Projection.State.Building); } versions = inMemoryVersionStore.Get(contractId); } // inception if (versions == null || versions.Count == 0) { if (string.Equals(persistentVersionContractId, contractId, StringComparison.OrdinalIgnoreCase)) { inMemoryVersionStore.Cache(persistentVersion); versions = inMemoryVersionStore.Get(contractId); } else { var initialVersion = new ProjectionVersion(contractId, ProjectionStatus.Building, 1, contractId.GetTypeByContract().GetProjectionHash()); inMemoryVersionStore.Cache(initialVersion); versions = inMemoryVersionStore.Get(contractId); } } } return(versions ?? new ProjectionVersions()); }
ReadResult <ProjectionVersionsHandler> GetProjectionVersionsFromStore(string projectionName) { try { var persistentVersionType = typeof(ProjectionVersionsHandler); var projectionVersions_ProjectionName = persistentVersionType.GetContractId(); var versionId = new ProjectionVersionManagerId(projectionName, context.Tenant); var persistentVersion = new ProjectionVersion(projectionVersions_ProjectionName, ProjectionStatus.Live, 1, projectionHasher.CalculateHash(persistentVersionType)); ProjectionStream stream = LoadProjectionStream(persistentVersionType, persistentVersion, versionId, new NoSnapshot(versionId, projectionVersions_ProjectionName).GetMeta()); var queryResult = stream.RestoreFromHistory <ProjectionVersionsHandler>(); return(new ReadResult <ProjectionVersionsHandler>(queryResult)); } catch (Exception ex) { return(ReadResult <ProjectionVersionsHandler> .WithNotFoundHint(ex.Message)); } }
private async Task <ReadResult <ProjectionVersionsHandler> > GetProjectionVersionsFromStoreAsync(string projectionName) { try { var persistentVersionType = typeof(ProjectionVersionsHandler); var projectionVersions_ProjectionName = persistentVersionType.GetContractId(); var versionId = new ProjectionVersionManagerId(projectionName, context.Tenant); var persistentVersion = new ProjectionVersion(projectionVersions_ProjectionName, ProjectionStatus.Live, 1, projectionHasher.CalculateHash(persistentVersionType)); ProjectionStream stream = await LoadProjectionStreamAsync(persistentVersionType, persistentVersion, versionId, new NoSnapshot(versionId, projectionVersions_ProjectionName).GetMeta()).ConfigureAwait(false); var queryResult = await stream.RestoreFromHistoryAsync <ProjectionVersionsHandler>().ConfigureAwait(false); return(new ReadResult <ProjectionVersionsHandler>(queryResult)); } catch (Exception ex) { log.WarnException(ex, () => $"Failed to load projection versions. ProjectionName: {projectionName}"); return(ReadResult <ProjectionVersionsHandler> .WithError(ex.Message)); } }
public override void Build() { var hasher = new ProjectionHasher(); var builder = this as ISettingsBuilder; var processorSettings = this as ISubscrptionMiddlewareSettings; Func <SubscriptionMiddleware> messageHandlerProcessorFactory = () => { var handlerFactory = new DefaultHandlerFactory(processorSettings.HandlerFactory); // May be we want to have separate serializer + transport per type?!?!? var transport = builder.Container.Resolve <ITransport>(builder.Name); var serializer = builder.Container.Resolve <ISerializer>(null); var publisher = transport.GetPublisher <ICommand>(serializer); var projectionsMiddleware = new ProjectionsMiddleware(handlerFactory); var middleware = processorSettings.HandleMiddleware(projectionsMiddleware); var subscriptionMiddleware = new SubscriptionMiddleware(); var iProjection = typeof(IProjection); foreach (var handler in processorSettings.HandlerRegistrations) { if (iProjection.IsAssignableFrom(handler)) { subscriptionMiddleware.Subscribe(new HandlerSubscriber <IProjection, IEventHandler <IEvent> >(handler, middleware)); var projManagerId = new ProjectionVersionManagerId(handler.GetContractId()); var command = new RegisterProjection(projManagerId, hasher.CalculateHash(handler).ToString()); publisher.Publish(command); } } var indexSubscriber = builder.Container.Resolve <EventTypeIndexForProjections>(); subscriptionMiddleware.Subscribe(indexSubscriber); return(subscriptionMiddleware); }; builder.Container.RegisterSingleton <SubscriptionMiddleware>(() => messageHandlerProcessorFactory(), builder.Name); }