public static void WaitForEventProcessorSequence(long expectedCount, IEventProcessor batchEventProcessor)
{
while (batchEventProcessor.Sequence.Value != expectedCount)
{
Thread.Sleep(1);
}
}
public bool ConnectWithLocalFirefox(Firefox.FirefoxEventProcessor evp)
{
m_Evp = evp;
// Actually, Unicode means UTF-16, whereas we need UCS-2.
// UTF-16 might insert multi-word characters, which we do not want.
// However, since .NET strings are stored as UCS-2, we won't get multi-word characters anyway.
return Connect(IPAddress.Loopback, 34971, Encoding.UTF8, new UnicodeEncoding(true, false), true);
}
public ArtificialIntelligenceJfi(IEventAgent eventAgent, string id)
: base(eventAgent, id)
{
_app = new App(new AIDto {EventAgent = eventAgent, Id = id, AI = this});
_eventProcessor = _app.Kernel.Get<IEventProcessor>();
_strategyProcessor = _app.Kernel.Get<ICHProcessor<Strategy>>();
_strategieFactory = _app.Kernel.Get<IStrategieFactory>();
_componentService = _app.Kernel.Get<ComponentService>();
}
public EventConsumer(string id, ConsumerSetting setting, string groupName, DomainEventHandledMessageSender domainEventHandledMessageSender)
{
_consumer = new Consumer(id, setting, string.IsNullOrEmpty(groupName) ? typeof(EventConsumer).Name + "Group" : groupName);
_binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
_eventTypeCodeProvider = ObjectContainer.Resolve<IEventTypeCodeProvider>();
_eventProcessor = ObjectContainer.Resolve<IEventProcessor>();
_messageContextDict = new ConcurrentDictionary<string, IMessageContext>();
_domainEventHandledMessageSender = domainEventHandledMessageSender;
}
public EventProjectionProcessor(IEventProcessor eventProcessor, IEventProjection eventProjection)
{
Guard.AgainstNull(eventProjection, "eventProjection");
Guard.AgainstNull(eventProcessor, "eventProcessor");
_eventProcessor = eventProcessor;
_eventProjection = eventProjection;
_eventProcessor = eventProcessor;
_threadActivity = new ThreadActivity(_eventProcessor.Configuration.DurationToSleepWhenIdle);
}
public ArtificialIntelligenceNhu(IEventAgent eventAgent, string id)
: base(eventAgent, id)
{
ComponentService = new ComponentService();
EventProcessor = new AiEventProcessor(ComponentService);
OrientationService = new OrientationService(new Vector2(0,0),ComponentService);
var productionManager = new ProductionManager(ComponentService, new ProductionFacilityProvider(ComponentService), OrientationService,eventAgent, id);
HeatMapService = new HeatMapService(new HeatPortionCalculationService(),new Vector2(800,800));
HeatMapService.Initialize();
InfanteryMindStateService = new InfanteryMindStateService(EventProcessor as AiEventProcessor,HeatMapService,ComponentService);
var movementService = new MovementService(ComponentService, EventAgent, OrientationService, InfanteryMindStateService,HeatMapService);
Agent = new AiAgent(ComponentService, productionManager, movementService, InfanteryMindStateService, HeatMapService);
}
public static void AttemptInitialization(this object o, IEventProcessor eventProcessor)
{
if (o == null || eventProcessor == null)
{
return;
}
var required = o as IRequireInitialization;
if (required == null)
{
return;
}
required.Initialize(eventProcessor);
}
public EventProcessorShutdownAsyncResult(EventProcessorLifecycleManager lifeCycleManager, EventHubReceiver receiver, IEventProcessor processor, PartitionContext context, CloseReason reason, Task dispatchTask, AsyncCallback callback, object state) : base(TimeSpan.MaxValue, callback, state)
{
this.lifeCycleManager = lifeCycleManager;
this.receiver = receiver;
this.processor = processor;
this.context = context;
this.reason = reason;
this.dispatchTask = dispatchTask;
base.Start();
}
/// <inheritdoc/>
public void ReportSuccessFor(IEventProcessor eventProcessor, IEvent @event, IEventEnvelope envelope)
{
WriteState(eventProcessor, envelope, EventProcessingStatus.Success);
}
public static void AddEventProcessor(EventCategory eventCategory, IEventProcessor eventProcessor)
{
EventInfo eventInfo = GetEventInfo(eventCategory);
eventInfo.EventProcessor = eventProcessor;
}
public void Add(IEventProcessor processor)
{
var eventProcessorInfo = new EventProcessorInfo <T>(processor, null, null);
_eventProcessorInfoByEventProcessor[processor] = eventProcessorInfo;
}
public FlightEventHandler(IEventProcessor eventProcessor, IConfiguration configuration, ILogger logger)
{
_eventProcessor = eventProcessor;
_configuration = configuration;
_logger = logger;
}
public override void ProcessEvent(IEventProcessor processor)
{
processor.ProcessEvent(this);
}
/// <Summary>
/// The functor of SendMovePositionMessage method.
/// </Summary>
void MovePosition(IEventProcessor eventProcessor, BaseEventData eventData)
{
eventProcessor.OnMovePosition(sendParts);
}
string GetKeyFor(IEventProcessor eventProcessor)
{
return($"{KeyPrefix}-{eventProcessor.Identifier}");
}
public UpdateItemCommandHandler(IItemRepository repository, IEventProcessor eventProcessor)
{
_repository = repository;
_eventProcessor = eventProcessor;
}
public ProcessEventQueueJob(IEventHandler eventHandler, IEventProcessor eventProcessor, ILogHandler logHandler)
: base(logHandler)
{
_eventHandler = eventHandler;
_eventProcessor = eventProcessor;
}
public Task ProcessInstanceEventsAsync(
IEnumerable <string> projectIds,
IEnumerable <string> zones,
IEnumerable <ulong> instanceIds,
DateTime startTime,
IEventProcessor processor,
CancellationToken cancellationToken)
{
this.CallCount++;
var systemEventJson = @"
{
'protoPayload': {
'@type': 'type.googleapis.com/google.cloud.audit.AuditLog',
'authenticationInfo': {
},
'serviceName': 'compute.googleapis.com',
'methodName': 'NotifyInstanceLocation',
'request': {
'@type': 'type.googleapis.com/NotifyInstanceLocation'
},
'metadata': {
'serverId': '4aaaa7b32a208e7ccb4ee62acedee725',
'timestamp': '2020-05-04T01:50:10.917Z',
'@type': 'type.googleapis.com/google.cloud.audit.GceInstanceLocationMetadata'
}
},
'insertId': '-x0boqfe25xye',
'resource': {
'type': 'gce_instance',
'labels': {
'instance_id': '7045222222254025',
'project_id': 'project-1',
'zone': 'us-central1-a'
}
},
'timestamp': '2020-05-04T01:50:16.885Z',
'severity': 'INFO',
'logName': 'projects/project-1/logs/cloudaudit.googleapis.com%2Fsystem_event',
'receiveTimestamp': '2020-05-04T01:50:17.020301892Z'
} ";
var lifecycleEventJson = @"
{
'protoPayload': {
'@type': 'type.googleapis.com/google.cloud.audit.AuditLog',
'authenticationInfo': {
},
'requestMetadata': {
'callerIp': '1.2.3.4',
'callerSuppliedUserAgent': 'Mozilla'
},
'serviceName': 'compute.googleapis.com',
'methodName': 'v1.compute.instances.reset',
'resourceName': 'projects/project-1/zones/us-central1-a/instances/instance-1',
'request': {
'@type': 'type.googleapis.com/compute.instances.reset'
}
},
'insertId': 'yz07i2c',
'resource': {
'type': 'gce_instance',
'labels': {
'instance_id': '4894051111144103',
'project_id': 'project-1',
'zone': 'us-central1-a'
}
},
'timestamp': '2020-05-11T14:41:30.863Z',
'severity': 'NOTICE',
'logName': 'projects/project-1/logs/cloudaudit.googleapis.com%2Factivity',
'operation': {
'id': 'operation-1589208088486-5a5605796a1ac-2d2b0706-bf57b173',
'producer': 'compute.googleapis.com',
'last': true
},
'receiveTimestamp': '2020-05-11T14:41:31.096086630Z'
}";
processor.Process(new NotifyInstanceLocationEvent(LogRecord.Deserialize(systemEventJson)));
processor.Process(new ResetInstanceEvent(LogRecord.Deserialize(lifecycleEventJson)));
return(Task.CompletedTask);
}
public async Task ProcessInstanceEventsAsync(
string bucket,
DateTime startTime,
DateTime endTime,
IEventProcessor processor,
CancellationToken cancellationToken)
{
Debug.Assert(startTime.Kind == DateTimeKind.Utc);
if (startTime.Date > DateTime.UtcNow.Date)
{
return;
}
using (TraceSources.IapDesktop.TraceMethod().WithParameters(bucket, startTime))
{
var severitiesWhitelist = processor.SupportedSeverities.ToHashSet();
var methodsWhitelist = processor.SupportedMethods.ToHashSet();
var objectsByDay = await FindAuditLogExportObjectsGroupedByDay(
bucket,
startTime,
DateTime.UtcNow,
cancellationToken)
.ConfigureAwait(false);
var days = (processor.ExpectedOrder == EventOrder.OldestFirst)
? DateRange.DayRange(startTime, endTime.Date, 1)
: DateRange.DayRange(endTime, startTime.Date, -1);
foreach (var day in days)
{
TraceSources.IapDesktop.TraceVerbose("Processing {0}", day);
//
// Grab the objects for this day (typically 2, one activity and one system event).
// Each object is (probably) sorted in ascending order, but we need a global,
// descending order. Therefore, download everything for that day, merge, and
// sort it before processing each event.
//
if (objectsByDay.TryGetValue(day, out IEnumerable <StorageObjectLocator> objectsForDay))
{
TraceSources.IapDesktop.TraceVerbose(
"Processing {1} export objects for {0}", day, objectsForDay.Count());
var eventsForDay = await ListInstanceEventsAsync(
objectsForDay,
cancellationToken)
.ConfigureAwait(false);
// Merge and sort events.
var eventsForDayOrdered = (processor.ExpectedOrder == EventOrder.OldestFirst)
? eventsForDay.OrderBy(e => e.Timestamp)
: eventsForDay.OrderByDescending(e => e.Timestamp);
foreach (var e in eventsForDayOrdered)
{
if (e.LogRecord?.ProtoPayload?.MethodName != null &&
methodsWhitelist.Contains(e.LogRecord.ProtoPayload.MethodName) &&
severitiesWhitelist.Contains(e.Severity))
{
processor.Process(e);
}
}
}
else
{
TraceSources.IapDesktop.TraceWarning("No export objects found for {0}", day);
}
}
}
}
public IEventProcessor CreateEventProcessor(PartitionContext context)
{
IEventProcessor eventProcessor = (IEventProcessor)(Activator.CreateInstance(typeof(TEventProcessorDefault), ConsumerConfiguration, Services, Configuration));
return(eventProcessor);
}
public EventProcessorFactory(IEventProcessor processor)
{
_processor = processor;
}
public ReleaseResourceReservationHandler(IResourcesRepository repository, IEventProcessor eventProcessor)
{
_repository = repository;
_eventProcessor = eventProcessor;
}
public static Mock <ScopedEventProcessor> a_scoped_event_processor_mock(TenantId tenant, IEventProcessor eventProcessor, ILogger logger = null)
{
var offset_repository = new Mock <IEventProcessorOffsetRepository>();
var unprocessed_event_fetcher = new Mock <IFetchUnprocessedEvents>();
IEventProcessorOffsetRepository offset_provider() => offset_repository.Object;
FactoryFor <IFetchUnprocessedEvents> unprocessed_provider = () => unprocessed_event_fetcher.Object;
return(new Mock <ScopedEventProcessor>(
tenant,
eventProcessor,
(FactoryFor <IEventProcessorOffsetRepository>)offset_provider,
unprocessed_provider,
logger ?? mocks.a_logger().Object));
}
public static IAsyncResult Begin(EventProcessorLifecycleManager lifeCycleManager, EventHubReceiver receiver, IEventProcessor processor, PartitionContext context, CloseReason reason, Task dispatchTask, AsyncCallback callback, object state)
{
return(new EventProcessorLifecycleManager.EventProcessorShutdownAsyncResult(lifeCycleManager, receiver, processor, context, reason, dispatchTask, callback, state));
}
public AddResourceHandler(IResourcesRepository repository, IEventProcessor eventProcessor)
{
_repository = repository;
_eventProcessor = eventProcessor;
}
private static IEnumerable <T> Process <T>(IEvent @event, IContext context, IEventProcessor processor, Microsoft.Extensions.Logging.ILogger log)
{
return(processor.Process <T, IEvent, IContext>(@event, context));
}
public DeleteStockItemCommandHandler(IItemRepository repository, IEventProcessor eventProcessor)
{
_repository = repository;
_eventProcessor = eventProcessor;
}
public static void RemoveEventProcessor(EventCategory eventCategory, IEventProcessor eventProcessor)
{
EventInfo eventInfo = GetEventInfo(eventCategory);
if (eventInfo.EventProcessor == eventProcessor)
{
eventInfo.EventProcessor = null;
}
}
/// <summary>
/// Parameterized Constructor.
/// </summary>
public DefaultEventBus(IEventProcessor eventProcessor)
{
this._eventProcessor = eventProcessor;
}
public static void AddEventProcessor(EventCategory eventCategory, IEventProcessor eventProcessor)
{
EventInfo eventInfo = GetEventInfo(eventCategory);
eventInfo.EventProcessor = eventProcessor;
}
/// <Summary>
/// The functor of SendExitDungeonMessage method.
/// </Summary>
void EventExit(IEventProcessor eventProcessor, BaseEventData eventData)
{
eventProcessor.OnExitDungeon();
}
public ServerManager(IEventProcessor ep, ResourceManager rm)
{
eventProcessor = ep;
resourceManager = rm;
}
public static IEventProcessorFactory AsSingletonFactory(this IEventProcessor instance) =>
new SingleEventProcessorFactory
{
Instance = instance
};
public IotHubEventProcessorFactory(IEventProcessor eventProcessor)
{
this.eventProcessor = eventProcessor;
}
private EventProcessorInfo <T> GetEventProcessorInfo(IEventProcessor barrierEventProcessor)
{
return(_eventProcessorInfoByEventProcessor[barrierEventProcessor]);
}
public TodoReadService(IBusClient busClient, IEventProcessor eventProcessor)
: base(busClient)
{
_eventProcessor = eventProcessor;
}
/// <inheritdoc/>
public void ReportFailureFor(IEventProcessor eventProcessor, IEvent @event, IEventEnvelope envelope)
{
WriteState(eventProcessor, envelope, EventProcessingStatus.Failed);
}
/*public bool ConnectWithLocalPython(Python.PythonEventProcessor evp)
{
m_Evp = evp;
return Connect(IPAddress.Loopback, 55483, Encoding.ASCII, Encoding.ASCII, false);
}*/
public bool ConnectWithLocalJava(Java.JavaEventProcessor evp)
{
m_Evp = evp;
return Connect(IPAddress.Loopback, 38056, Encoding.ASCII, Encoding.ASCII, false);
}
string GetFileNameFor(IEventProcessor eventProcessor)
{
return($"{eventProcessor.Identifier.Value.GetHashCode().ToString()}.state");
}
public EventController(IEventProcessor eventProcessor)
{
_eventProcessor = eventProcessor;
}
public LdClient(Configuration config, IEventProcessor eventProcessor)
{
Log.InfoFormat("Starting LaunchDarkly Client {0}",
ServerSideClientEnvironment.Instance.Version);
_configuration = config;
ServerDiagnosticStore diagnosticStore = null;
if (!_configuration.DiagnosticOptOut)
{
diagnosticStore = new ServerDiagnosticStore(_configuration);
}
if (eventProcessor == null)
{
IEventProcessorFactory eventProcessorFactory = _configuration.EventProcessorFactory ?? Components.DefaultEventProcessor;
if (eventProcessorFactory is IEventProcessorFactoryWithDiagnostics epfwd)
{
_eventProcessor = epfwd.CreateEventProcessor(_configuration, diagnosticStore);
}
else
{
_eventProcessor = eventProcessorFactory.CreateEventProcessor(_configuration);
}
_shouldDisposeEventProcessor = true;
}
else
{
_eventProcessor = eventProcessor;
// The following line is for backward compatibility with the obsolete mechanism by which the
// caller could pass in an IStoreEvents implementation instance that we did not create. We
// were not disposing of that instance when the client was closed, so we should continue not
// doing so until the next major version eliminates that mechanism. We will always dispose
// of instances that we created ourselves from a factory.
_shouldDisposeEventProcessor = false;
}
IFeatureStore store;
if (_configuration.FeatureStore == null)
{
store = (_configuration.FeatureStoreFactory ??
Components.InMemoryFeatureStore).CreateFeatureStore();
_shouldDisposeFeatureStore = true;
}
else
{
store = _configuration.FeatureStore;
_shouldDisposeFeatureStore = false; // see previous comment
}
_featureStore = new FeatureStoreClientWrapper(store);
IUpdateProcessorFactory updateProcessorFactory = _configuration.UpdateProcessorFactory ?? Components.DefaultUpdateProcessor;
if (updateProcessorFactory is IUpdateProcessorFactoryWithDiagnostics upfwd)
{
_updateProcessor = upfwd.CreateUpdateProcessor(_configuration, _featureStore, diagnosticStore);
}
else
{
_updateProcessor = updateProcessorFactory.CreateUpdateProcessor(_configuration, _featureStore);
}
var initTask = _updateProcessor.Start();
if (!(_updateProcessor is NullUpdateProcessor))
{
Log.InfoFormat("Waiting up to {0} milliseconds for LaunchDarkly client to start..",
_configuration.StartWaitTime.TotalMilliseconds);
}
try
{
var unused = initTask.Wait(_configuration.StartWaitTime);
}
catch (AggregateException)
{
// StreamProcessor may throw an exception if initialization fails, because we want that behavior
// in the Xamarin client. However, for backward compatibility we do not want to throw exceptions
// from the LdClient constructor in the .NET client, so we'll just swallow this.
}
}
/// <summary>Add a event processor.
/// </summary>
/// <param name="eventProcessor"></param>
/// <returns></returns>
public Configuration AddEventProcessor(IEventProcessor eventProcessor)
{
_eventProcessors.Add(eventProcessor);
return this;
}
