public static void Initialize(IEventRegistry eventRegistry, IEventBus eventBus, AnalyticsOperationRequestRepository OperationRequestRepository, AnalyticsRegistry analyticsRegistry)//, IServiceProvider services) { _eventRegistry = eventRegistry; _eventBus = eventBus; _OperationRequestRepository = OperationRequestRepository; _analyticsRegistry = analyticsRegistry; }
private void FlushOnQueryStarted(IInternalObjectContainer container) { IEventRegistry registry = EventRegistryFactory.ForObjectContainer(container); registry.QueryStarted += new System.EventHandler <Db4objects.Db4o.Events.QueryEventArgs> (new _IEventListener4_46(this).OnEvent); }
public RedisTests() { string endpoint = Environment.GetEnvironmentVariable("REDIS_ENDPOINT") ?? "localhost:6379"; string password = Environment.GetEnvironmentVariable("REDIS_PASSWORD"); var configuration = new ConfigurationOptions { Ssl = true, AbortOnConnectFail = false, Password = password }; configuration.EndPoints.Add(endpoint); var redisEventRegistry = new RedisEventRegistry( ConnectionMultiplexer.Connect(configuration), new JsonPayloadSerializer()); _sender = redisEventRegistry; _registry = redisEventRegistry; }
public void Apply(IInternalObjectContainer container) { IEventRegistry registry = EventRegistryFactory.ForObjectContainer(container); registry.Creating += new CancellableObjectEventHandler(registry_Creating); registry.Updating += new CancellableObjectEventHandler(registry_Updating); }
public ReleaseOrderBlock(IPersistEntityPipeline persistEntityPipeline, IEventRegistry eventRegistry, IRemoveListEntitiesPipeline removeListEntitiesPipeline) : base(null) { this.persistEntityPipeline = persistEntityPipeline; this.eventRegistry = eventRegistry; this.removeListEntitiesPipeline = removeListEntitiesPipeline; }
private static void CommitEvents() { CleanUp(); StoreJoe(); using (IObjectContainer container = OpenEmbedded()) { // #example: Commit-info IEventRegistry events = EventRegistryFactory.ForObjectContainer(container); events.Committed += delegate(object sender, CommitEventArgs args) { foreach (LazyObjectReference reference in args.Added) { Console.WriteLine("Added " + reference.GetObject()); } foreach (LazyObjectReference reference in args.Updated) { Console.WriteLine("Updated " + reference.GetObject()); } foreach (FrozenObjectInfo reference in args.Deleted) { //the deleted info might doesn't contain the object anymore and //return the null. Console.WriteLine("Deleted " + reference.GetObject()); } }; // #end example RunOperations(container); } CleanUp(); }
public static void AssertDeltaPath(IEventRegistry blob, int[] path) { EventSourceRoot root = AssertGenerated(blob); AssertPath(root.Events[0], path); blob.ClearEvents(); }
public static void Main(string[] args) { using (IObjectContainer container = Db4oEmbedded.OpenFile("database.db4")) { // #example: Register validation for the create and update event IEventRegistry events = EventRegistryFactory.ForObjectContainer(container); events.Creating += ValidateObject; events.Updating += ValidateObject; // #end example // #example: Storing a valid pilot var pilot = new Pilot { Name = "Joe" }; container.Store(pilot); // #end example // #example: Storing a invalid pilot throws exception var otherPilot = new Pilot { Name = "" }; try { container.Store(otherPilot); } catch (EventException e) { ValidationException cause = (ValidationException)e.InnerException; Console.WriteLine(cause.ValidationResult.ErrorMessage); } // #end example } }
private static void RegisterAFewEvents(IEventRegistry events, string containerName) { events.Activating += delegate { Console.Out.WriteLine("Activating on {0}", containerName); }; events.Activated += delegate { Console.Out.WriteLine("Activated on {0}", containerName); }; events.Creating += delegate { Console.Out.WriteLine("Creating on {0}", containerName); }; events.Created += delegate { Console.Out.WriteLine("Created on {0}", containerName); }; events.Updating += delegate { Console.Out.WriteLine("Updating on {0}", containerName); }; events.Updated += delegate { Console.Out.WriteLine("Updated on {0}", containerName); }; events.QueryStarted += delegate { Console.Out.WriteLine("QueryStarted on {0}", containerName); }; events.QueryFinished += delegate { Console.Out.WriteLine("QueryFinished on {0}", containerName); }; events.Committing += delegate { Console.Out.WriteLine("Committing on {0}", containerName); }; events.Committed += delegate { Console.Out.WriteLine("Committing on {0}", containerName); }; // #example: register for a event events.Committing += HandleCommitting; // #end example }
private void RegisterEventHandlers() { IObjectContainer deletionEventSource = Db(); if (Fixture() is IDb4oClientServerFixture) { IDb4oClientServerFixture clientServerFixture = (IDb4oClientServerFixture)Fixture( ); deletionEventSource = clientServerFixture.Server().Ext().ObjectContainer(); } IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(Db()); IEventRegistry deletionEventRegistry = EventRegistryFactory.ForObjectContainer(deletionEventSource ); // No dedicated IncrementListener class due to sharpen event semantics deletionEventRegistry.Deleted += new System.EventHandler <Db4objects.Db4o.Events.ObjectInfoEventArgs> (new _IEventListener4_91(this).OnEvent); eventRegistry.Activated += new System.EventHandler <Db4objects.Db4o.Events.ObjectInfoEventArgs> (new _IEventListener4_96(this).OnEvent); eventRegistry.Committed += new System.EventHandler <Db4objects.Db4o.Events.CommitEventArgs> (new _IEventListener4_101(this).OnEvent); eventRegistry.Created += new System.EventHandler <Db4objects.Db4o.Events.ObjectInfoEventArgs> (new _IEventListener4_106(this).OnEvent); eventRegistry.Updated += new System.EventHandler <Db4objects.Db4o.Events.ObjectInfoEventArgs> (new _IEventListener4_111(this).OnEvent); }
public static EventSourceRoot AssertGenerated(IEventRegistry blob) { EventSourceRoot root = blob.PeekEvents(); Assert.Single(root.Events); return(root); }
public RemoteEventController(IEventRegistry eventRegistry, ServerStateService serverStateService, EventProviderService providerService) { _eventRegistry = eventRegistry; _serverStateService = serverStateService; _providerService = providerService; TranslateGuidToName(); }
/// <exception cref="System.Exception"></exception> public virtual void TestCommittedCallbacks() { Lock4 lockObject = new Lock4(); BooleanByRef ownEvent = new BooleanByRef(false); BooleanByRef gotEvent = new BooleanByRef(false); BooleanByRef shallListen = new BooleanByRef(false); OwnCommittedCallbacksFixture.IContainerFactory factory = ((OwnCommittedCallbacksFixture.IContainerFactory )Factory.Value); OwnCommittedCallbacksFixture.CommitAction action = ((OwnCommittedCallbacksFixture.CommitAction )Action.Value); factory.Open(); IObjectContainer clientA = factory.OpenClient(); IObjectContainer clientB = factory.OpenClient(); IEventRegistry registry = EventRegistryFactory.ForObjectContainer(clientA); registry.Committed += new System.EventHandler <Db4objects.Db4o.Events.CommitEventArgs> (new _IEventListener4_153(shallListen, gotEvent, ownEvent, lockObject).OnEvent); shallListen.value = true; action.CommitItem(new OwnCommitCallbackFlaggedNetworkingTestSuite.Item(42), clientA , clientB); lockObject.Run(new _IClosure4_172(lockObject)); shallListen.value = false; clientB.Close(); clientA.Close(); factory.Close(); Assert.IsTrue(gotEvent.value); Assert.AreEqual(action.SelectsFirstClient(), ownEvent.value); }
private void RegisterPushedUpdates(IExtObjectContainer client) { IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(client); eventRegistry.Committed += new System.EventHandler <Db4objects.Db4o.Events.CommitEventArgs> (new _IEventListener4_120(this, client).OnEvent); }
public void Apply(IInternalObjectContainer container) { #if NET_3_5 My <LinqQueryMonitor> .Instance.Initialize(); #endif IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(container); PerformanceCounter unoptimizedNativeQueriesPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.UnoptimizedNativeQueriesPerSec, false); PerformanceCounter nativeQueriesPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.NativeQueriesPerSec, false); container.GetNativeQueryHandler().QueryExecution += delegate(object sender, QueryExecutionEventArgs args) { if (args.ExecutionKind == QueryExecutionKind.Unoptimized) { unoptimizedNativeQueriesPerSec.Increment(); } nativeQueriesPerSec.Increment(); }; eventRegistry.Closing += delegate { nativeQueriesPerSec.RemoveInstance(); nativeQueriesPerSec.Dispose(); unoptimizedNativeQueriesPerSec.Dispose(); #if NET_3_5 container.WithEnvironment(delegate { My <LinqQueryMonitor> .Instance.Dispose(); }); #endif }; }
public void Apply(IInternalObjectContainer container) { PerformanceCounter queriesPerSec = null; PerformanceCounter classIndexScansPerSec = null; container.WithEnvironment(delegate { queriesPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.QueriesPerSec, false); classIndexScansPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ClassIndexScansPerSec, false); }); IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(container); eventRegistry.QueryFinished += delegate { queriesPerSec.Increment(); }; container.Configure().Diagnostic().AddListener(new DiagnosticListener(classIndexScansPerSec)); eventRegistry.Closing += delegate { queriesPerSec.RemoveInstance(); classIndexScansPerSec.RemoveInstance(); queriesPerSec.Dispose(); classIndexScansPerSec.Dispose(); }; }
public RemoteContentIndexRepository(IContentIndexRepository contentIndexRepository, IEventRegistry eventService , IIndexRecoveryService indexRecoveryService) { _contentIndexRepository = contentIndexRepository; _eventService = eventService; _indexRecoveryService = indexRecoveryService; }
public Payment(Account source, Account destination, Money money, IEventRegistry eventRegistry, PaymentId paymentId) { _source = source; _destination = destination; _money = money; _eventRegistry = eventRegistry; _paymentId = paymentId; }
public ClientSlotCacheImpl(ClientObjectContainer clientObjectContainer) { IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(clientObjectContainer ); eventRegistry.Activated += new System.EventHandler <Db4objects.Db4o.Events.ObjectInfoEventArgs> (new _IEventListener4_29(this).OnEvent); }
private static void RegisterForEventsOnTheServer() { // #example: register for events on the server IObjectServer server = Db4oClientServer.OpenServer(DatabaseFileName, PortNumber); IEventRegistry eventsOnServer = EventRegistryFactory.ForObjectContainer(server.Ext().ObjectContainer()); // #end example }
private void AssertEventThrows(string eventName, ICodeBlock codeBlock, IProcedure4 listenerSetter) { IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(Db()); listenerSetter.Apply(eventRegistry); Assert.Expect(typeof(EventException), typeof(NotImplementedException), codeBlock, eventName); }
public RedisTests(RedisResource redisResource) { var redisEventRegistry = new RedisEventRegistry( redisResource.GetConnection(), new JsonPayloadSerializer()); _sender = redisEventRegistry; _registry = redisEventRegistry; }
/// <exception cref="System.Exception"></exception> protected override void Db4oSetupAfterStore() { IEventRegistry events = EventRegistry(); events.QueryStarted += new System.EventHandler <Db4objects.Db4o.Events.QueryEventArgs> (new _IEventListener4_23(this).OnEvent); events.QueryFinished += new System.EventHandler <Db4objects.Db4o.Events.QueryEventArgs> (new _IEventListener4_29(this).OnEvent); }
public static void Open() { Db4oFactory.Configure().Queries().EvaluationMode(QueryEvaluationMode.Snapshot); _Current = Db4oFactory.OpenFile("yapFile.yap"); IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(_Current); eventRegistry.Creating += eventRegistry_Validate; eventRegistry.Updating += eventRegistry_Validate; eventRegistry.Committing += eventRegistry_Committing; _Validators = new Dictionary <Type, ObjectValidator>(); }
public EventRegistryTests() { events = new List <IEvent>(); var mock = new Mock <IEventRegistry>(); mock.Setup(x => x.Register(It.IsAny <IEvent>())) .Callback <IEvent>(e => events.Add(e)); registry = mock.Object; }
public virtual void TestClassRegistrationEvents() { ClassRegistrationEventsTestCase.EventFlag eventFlag = new ClassRegistrationEventsTestCase.EventFlag (); IEventRegistry registry = EventRegistryFactory.ForObjectContainer(Db()); registry.ClassRegistered += new System.EventHandler <Db4objects.Db4o.Events.ClassEventArgs> (new _IEventListener4_23(eventFlag).OnEvent); Store(new ClassRegistrationEventsTestCase.Data()); Assert.IsTrue(eventFlag.eventOccurred); }
public void Apply(IInternalObjectContainer container) { PerformanceCounter storedObjectsPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsStoredPerSec, false); PerformanceCounter activatedObjectsPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsActivatedPerSec, false); PerformanceCounter deactivatedObjectsPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsDeactivatedPerSec, false); IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(container); EventHandler <ObjectInfoEventArgs> eventHandler = delegate { storedObjectsPerSec.Increment(); }; eventRegistry.Created += eventHandler; eventRegistry.Updated += eventHandler; eventRegistry.Activated += delegate { activatedObjectsPerSec.Increment(); }; eventRegistry.Deactivated += delegate { deactivatedObjectsPerSec.Increment(); }; eventRegistry.Closing += delegate { storedObjectsPerSec.Dispose(); activatedObjectsPerSec.Dispose(); deactivatedObjectsPerSec.Dispose(); storedObjectsPerSec.RemoveInstance(); }; if (container.IsClient) { return; } PerformanceCounter deletedObjectsPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsDeletedPerSec, false); eventRegistry.Deleted += delegate { deletedObjectsPerSec.Increment(); }; eventRegistry.Closing += delegate { deletedObjectsPerSec.Dispose(); }; }
public static void Register <TEvent>(this IEventRegistry <TEvent> registry, IEventSource source, params object[] args) where TEvent : class, IEvent { if (source == null) { throw new ArgumentNullException(nameof(source)); } var @event = (TEvent)CreateEvent(typeof(TEvent), source, args); registry.Register(@event); }
private static void ReferentialIntegrity() { using (IObjectContainer container = Db4oEmbedded.OpenFile(DatabaseFile)) { // #example: Register handler IEventRegistry events = EventRegistryFactory.ForObjectContainer(container); events.Deleting += ReferentialIntegrityCheck; // #end example Pilot pilot = container.Query <Pilot>()[0]; container.Delete(pilot); } }
public virtual void TestTransactionInEventArgs() { IEventRegistry factory = EventRegistryFactory.ForObjectContainer(Db()); BooleanByRef called = new BooleanByRef(); ObjectByRef foundTrans = new ObjectByRef(); factory.Creating += new System.EventHandler <Db4objects.Db4o.Events.CancellableObjectEventArgs> (new _IEventListener4_20(called, foundTrans).OnEvent); Db().Store(new EventArgsTransactionTestCase.Item()); Db().Commit(); Assert.IsTrue(called.value); Assert.AreSame(Trans(), foundTrans.value); }
/// <summary> /// Creates a new instance of Incremental Publish Handler /// </summary> public IncrementalPublishHandler(IRequiredPublishFieldsResolver requiredPublishFieldsResolver, IPublisherOperationService publisherOpsService, IDataStoreFactory dataStoreFactory, IRepositoryFactory<IMediaRepository> mediaRepositoryFactory, IRepositoryFactory<IItemIndexRepository> targetIndexRepositoryFactory, IRepositoryFactory<IItemRepository> itemRepositoryFactory, IRepositoryFactory<IItemRelationshipRepository> itemRelationshipRepoFactory, IRepositoryFactory<IItemNodeRepository> itemNodeRepositoryFactory, IRepositoryFactory<ITemplateGraphRepository> templateGraphRepositoryFactory, IRepositoryFactory<IIndexableItemRepository> indexablePublishTargetRepositoryFactory, IRepositoryFactory<IWorkflowStateRepository> workflowRepositoryFactory, IRepositoryFactory<ITestableContentRepository> testableContentRepositoryFactory, IRepositoryFactory<IManifestRepository> manifestRepositoryFactory, IRepositoryFactory<IPublishExclusionsRepository> publishExclusionsRepositoryFactory, IPromotionCoordinator promoterCoordinator, IEventRegistry eventRegistry, ILoggerFactory loggerFactory, IApplicationLifetime applicationLifetime, PublishJobHandlerOptions options = null) : base(requiredPublishFieldsResolver, publisherOpsService, dataStoreFactory, mediaRepositoryFactory, targetIndexRepositoryFactory, itemRepositoryFactory, itemRelationshipRepoFactory, itemNodeRepositoryFactory, templateGraphRepositoryFactory, indexablePublishTargetRepositoryFactory, workflowRepositoryFactory, testableContentRepositoryFactory, manifestRepositoryFactory, publishExclusionsRepositoryFactory, promoterCoordinator, eventRegistry, loggerFactory, applicationLifetime, options ?? new PublishJobHandlerOptions()) { }
public TreePublishHandler(IRequiredPublishFieldsResolver requiredPublishFieldsResolver, IPublisherOperationService publisherOpsService, IDataStoreFactory dataStoreFactory, IRepositoryFactory<IMediaRepository> mediaRepositoryFactory, IRepositoryFactory<IItemIndexRepository> targetIndexRepositoryFactory, IRepositoryFactory<IItemRepository> itemRepositoryFactory, IRepositoryFactory<IItemRelationshipRepository> itemRelationshipRepoFactory, IRepositoryFactory<IItemNodeRepository> itemNodeRepositoryFactory, IRepositoryFactory<ITemplateGraphRepository> templateGraphRepositoryFactory, IRepositoryFactory<IIndexableItemRepository> indexablePublishTargetRepositoryFactory, IRepositoryFactory<IWorkflowStateRepository> workflowRepositoryFactory, IRepositoryFactory<ITestableContentRepository> testableContentRepositoryFactory, IRepositoryFactory<IManifestRepository> manifestRepositoryFactory, IRepositoryFactory<IPublishExclusionsRepository> publishExclusionsRepositoryFactory, IPromotionCoordinator promoterCoordinator, IEventRegistry eventRegistry, ILoggerFactory loggerFactory, IApplicationLifetime applicationLifetime, IConfiguration config) : this(requiredPublishFieldsResolver, publisherOpsService, dataStoreFactory, mediaRepositoryFactory, targetIndexRepositoryFactory, itemRepositoryFactory, itemRelationshipRepoFactory, itemNodeRepositoryFactory, templateGraphRepositoryFactory, indexablePublishTargetRepositoryFactory, workflowRepositoryFactory, testableContentRepositoryFactory, manifestRepositoryFactory, publishExclusionsRepositoryFactory, promoterCoordinator, eventRegistry, loggerFactory, applicationLifetime, SitecoreConfigurationExtensions.As<PublishJobHandlerOptions>(config)) { }
/// <summary> /// Initializes the default event registry for this context. /// </summary> private void InitEventRegistry() { if (ContainsLocalObject(EventRegistryObjectName)) { object candidateRegistry = GetObject(EventRegistryObjectName); if (candidateRegistry is IEventRegistry) { _eventRegistry = (IEventRegistry)candidateRegistry; #region Instrumentation log.Debug(StringUtils.Surround( "Using IEventRegistry [", EventRegistry, "]")); #endregion } else { _eventRegistry = new EventRegistry(); #region Instrumentation if (log.IsWarnEnabled) { log.Warn(string.Format( "Found object in context named '{0}' : this name " + "is typically reserved for IEventRegistry objects. " + "Falling back to default '{1}'.", EventRegistryObjectName, EventRegistry)); } #endregion } } else { _eventRegistry = new EventRegistry(); #region Instrumentation if (log.IsDebugEnabled) { log.Debug(string.Format( "No IEventRegistry found with name '{0}' : using default '{1}'.", EventRegistryObjectName, EventRegistry)); } #endregion } ICollection interestedParties = GetObjectsOfType(typeof(IEventRegistryAware), true, false).Values; foreach (IEventRegistryAware party in interestedParties) { party.EventRegistry = EventRegistry; } EventRegistry.PublishEvents(this); }