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 RemoteEventController(IEventRegistry eventRegistry, ServerStateService serverStateService, EventProviderService providerService)
{
_eventRegistry = eventRegistry;
_serverStateService = serverStateService;
_providerService = providerService;
TranslateGuidToName();
}
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);
}
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
}
