public DialogTaskManager(string blobKeyPrefix, IBotData botData,
IStackStoreFactory <DialogTask> stackStoreFactory,
Func <IDialogStack, CancellationToken, IDialogContext> contextFactory,
IEventProducer <IActivity> queue)
{
SetField.NotNull(out this.blobKeyPrefix, nameof(blobKeyPrefix), blobKeyPrefix);
SetField.NotNull(out this.botData, nameof(botData), botData);
SetField.NotNull(out this.contextFactory, nameof(contextFactory), contextFactory);
SetField.NotNull(out this.stackStoreFactory, nameof(stackStoreFactory), stackStoreFactory);
SetField.NotNull(out this.queue, nameof(queue), queue);
}
public void HireEmployee_providesData_expectsNewEmployee()
{
ILogger <EmployeeControl> logger = Mock.Of <ILogger <EmployeeControl> >();
INameService nameService = new NameService();
IEventProducer eventProducer = Mock.Of <IEventProducer>();
EmployeeControl employeeControl = new EmployeeControl(nameService, logger, eventProducer);
Employee employee = employeeControl.HireEmployee("First", "Last", WorkplaceSkill.Control);
Assert.NotNull(employee);
Assert.Equal(employeeControl.FindEmployeeByName("First", "Last"), employee);
}
/// <summary>
/// Constructor of sensor service.
/// </summary>
/// <param name="sensorContext">Sensor context.</param>
/// <param name="mapper">Automapper.</param>
public SensorService(ISensorContext sensorContext,
IMapper mapper,
IEventProducer <ISensorDeleted, int> sensorDeletedEventProducer,
IRecordService recordService,
ILogger <SensorService> logger)
{
_sensorContext = sensorContext ?? throw new ArgumentNullException(nameof(sensorContext));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_sensorDeletedEventProducer = sensorDeletedEventProducer ?? throw new ArgumentNullException(nameof(sensorDeletedEventProducer));
_recordService = recordService ?? throw new ArgumentNullException(nameof(recordService));
}
/// <summary>
/// Constructor of record service.
/// </summary>
/// <param name="sensorContext">Sensor context.</param>
/// <param name="mapper">Automapper.</param>
public RecordService(ISensorContext sensorContext,
IMapper mapper,
ICommandProducer <IProcessData, IRecordDTO> processDataCommandProducer,
IEventProducer <IRecordDeleted, int> recordDeletedEventProducer,
ILogger <RecordService> logger)
{
_sensorContext = sensorContext ?? throw new ArgumentNullException(nameof(sensorContext));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_processDataCommandProducer = processDataCommandProducer ?? throw new ArgumentNullException(nameof(processDataCommandProducer));
_recordDeletedEventProducer = recordDeletedEventProducer ?? throw new ArgumentNullException(nameof(recordDeletedEventProducer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env,
IEventConsumer eventConsumer, IVisitorControl visitorControl, ILocationTypeStrategy locationTypeStrategy,
IEventProducer producer, IFairyTaleClient fairyTaleClient, IRideClient rideClient, IStandClient standClient)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
locationTypeStrategy.Register(LocationType.FAIRYTALE,
new VisitorFairyTaleStrategy(producer, fairyTaleClient));
locationTypeStrategy.Register(LocationType.RIDE,
new VisitorRideStrategy(producer, rideClient));
locationTypeStrategy.Register(LocationType.STAND,
new VisitorStandStrategy(producer, standClient));
app.UseRouting();
app.UseCors(DefaultCorsPolicy);
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
_ = Task.Run(() => eventConsumer.Listen());
_ = Task.Run(() =>
{
while (true)
{
visitorControl.HandleIdleVisitors();
Task.Delay(300).Wait();
}
});
_ = Task.Run(() =>
{
Random random = new Random();
int maxVisitors = 2000;
int currentVisitors = 0;
while (currentVisitors <= maxVisitors)
{
int newVisitors = random.Next(5, 15);
visitorControl.AddVisitors(newVisitors);
currentVisitors += newVisitors;
Task.Delay(2000).Wait();
}
});
}
public void RegisterProducer(IEventProducer eventProducer)
{
// add it
Producers.Add(eventProducer);
// and register this as the context with the producer
eventProducer.Init(this);
Log(LogType.ProducerRegistered, source: eventProducer);
AssertProducerIsReady(eventProducer);
// after registered, go ahead and start the producer.
eventProducer.Start();
}
public void GetEmployee_givenRide_ExpectEmployee()
{
ILogger <EmployeeControl> logger = Mock.Of <ILogger <EmployeeControl> >();
INameService nameService = new NameService();
IEventProducer eventProducer = Mock.Of <IEventProducer>();
EmployeeControl employeeControl = new EmployeeControl(nameService, logger, eventProducer);
Employee employee = employeeControl.HireEmployee("First", "Last", WorkplaceSkill.Control);
WorkplaceDto ride = new WorkplaceDto(Guid.NewGuid(), LocationType.RIDE);
employee.GoToWork(ride, WorkplaceSkill.Engineer);
List <Employee> result = employeeControl.GetEmployees(ride);
Assert.Contains(employee, result);
}
/// <summary>
/// Produce a message of type <see cref="TMessage"/>. The type is used to look up the type name
/// in the <seealso cref="TypeMap"/>.
/// </summary>
/// <param name="producer"></param>
/// <param name="stream">Stream name where the message should be produced</param>
/// <param name="message">Message to produce</param>
/// <param name="metadata"></param>
/// <param name="onAck">Function to confirm that the message was produced</param>
/// <param name="cancellationToken"></param>
/// <typeparam name="TMessage">Message typ</typeparam>
/// <returns></returns>
public static Task Produce <TMessage>(
this IEventProducer producer,
StreamName stream,
TMessage message,
Metadata?metadata,
AcknowledgeProduce?onAck = null,
CancellationToken cancellationToken = default
) where TMessage : class
{
var producedMessages =
message is IEnumerable <object> collection
? ConvertMany(collection, metadata, onAck)
: ConvertOne(message, metadata, onAck);
return(producer.Produce(stream, producedMessages, cancellationToken));
}
protected async Task <CommandResult> CommitAndPublishDefaultAsync(IEventProducer eventsToPublish = null)
{
bool success = await CommitAsync();
if (success)
{
if (eventsToPublish != null)
{
await PublishEntityEventsAsync(eventsToPublish);
}
return(CommandResult.Ok());
}
return(FailureDueToPersistenceError());
}
public void AssignEmployee_givenRideAndSkill_ExpectEmployeeAssigned()
{
ILogger <EmployeeControl> logger = Mock.Of <ILogger <EmployeeControl> >();
INameService nameService = new NameService();
IEventProducer eventProducer = Mock.Of <IEventProducer>();
EmployeeControl employeeControl = new EmployeeControl(nameService, logger, eventProducer);
WorkplaceDto ride = new WorkplaceDto(Guid.NewGuid(), LocationType.RIDE);
employeeControl.AssignEmployee(ride, WorkplaceSkill.Control);
List <Employee> result = employeeControl.GetEmployees(ride);
Assert.NotEmpty(result);
Assert.Equal(ride, result[0].ActiveWorkplace);
Assert.Equal(WorkplaceSkill.Control, result[0].ActiveSkill);
}
/// <summary>
/// Activates this instance.
/// </summary>
/// <returns>A <see cref="Task"/> representing the work performed.</returns>
public override async Task OnActivateAsync()
{
this.IsBeingReplayed = false;
this.evaluatingEvent = false;
this.resetting = false;
this.Logger = this.GetLogger(string.Format("{0}/{1}", this.GetKind(), this.GetPrimaryKey().ToString("N")));
await base.OnActivateAsync();
// Create the journal.
this.journal = await JournalProvider.Create(this);
// Read & apply all unapplied events.
await this.ReplayUnappliedEvents();
// Create the event producer with the journal.
this.eventProducer = EventProducerGenerator.Create <TActorInterface>(this.journal, this.State.LastAppliedEventId + 1);
}
public void Activate(IEventProducer eventProducer)
{
this.PublishStateChange(eventProducer, "Activating");
try
{
if (this.WorkerDomain == null)
{
var adSetup = new AppDomainSetup();
adSetup.ApplicationName = this.ServiceComponentData.FriendlyName;
this.WorkerDomain = AppDomain.CreateDomain(this.ServiceComponentData.FriendlyName, null, adSetup);
}
this.PublishStateChange(eventProducer, "Activated");
}
catch (Exception ex)
{
this.PublishStateChangeFailed(eventProducer, "ActivationFailed", ex);
throw;
}
}
public void sellTickets_differentTicketTypes_expectsTickets()
{
IEventProducer eventProducer = Mock.Of <IEventProducer>();
EntranceControl entranceControl = new EntranceControl(logger, eventProducer);
List <TicketType> ticketTypes = new List <TicketType>();
ticketTypes.Add(TicketType.Adult);
ticketTypes.Add(TicketType.Adult);
ticketTypes.Add(TicketType.Seniors);
ticketTypes.Add(TicketType.Child);
ticketTypes.Add(TicketType.Child);
ticketTypes.Add(TicketType.Child);
List <Ticket> tickets = entranceControl.SellTickets(ticketTypes);
Assert.NotNull(tickets);
Assert.Equal(6, tickets.Count);
Assert.Equal(2, tickets.FindAll(ticket => ticket.Type == TicketType.Adult).Count);
Assert.Single(tickets.FindAll(ticket => ticket.Type == TicketType.Seniors));
Assert.Equal(3, tickets.FindAll(ticket => ticket.Type == TicketType.Child).Count);
}
public static async Task DialogTask_Frame_Scoring_Allows_Value(double score)
{
var state = new object();
var item = new Activity();
var token = new CancellationTokenSource().Token;
var scorable = MockScorable(item, state, score, token);
var innerLoop = new Mock <IEventLoop>();
var innerProducer = new Mock <IEventProducer <IActivity> >();
var queue = new EventQueue <IActivity>();
IEventLoop loop = new ScoringEventLoop <double>(innerLoop.Object, innerProducer.Object, queue, new TraitsScorable <IActivity, double>(NormalizedTraits.Instance, Comparer <double> .Default, new[] { scorable.Object }));
scorable
.Setup(s => s.PostAsync(item, state, token))
.Returns(Task.FromResult(0));
IEventProducer <IActivity> producer = queue;
producer.Post(item);
await loop.PollAsync(token);
scorable.Verify();
}
public AriClient(IActionConsumer actionConsumer, IEventProducer eventProducer, string application)
{
_actionConsumer = actionConsumer;
_eventProducer = eventProducer;
EventDispatchingStrategy = DefaultEventDispatchingStrategy;
// Setup Action Properties
Asterisk = new AsteriskActions(_actionConsumer);
Applications = new ApplicationsActions(_actionConsumer);
Bridges = new BridgesActions(_actionConsumer);
Channels = new ChannelsActions(_actionConsumer);
DeviceStates = new DeviceStatesActions(_actionConsumer);
Endpoints = new EndpointsActions(_actionConsumer);
Events = new EventsActions(_actionConsumer);
Mailboxes = new MailboxesActions(_actionConsumer);
Playbacks = new PlaybacksActions(_actionConsumer);
Recordings = new RecordingsActions(_actionConsumer);
Sounds = new SoundsActions(_actionConsumer);
// Setup Event Handlers
_eventProducer.OnMessageReceived += _eventProducer_OnMessageReceived;
_eventProducer.OnConnectionStateChanged += _eventProducer_OnConnectionStateChanged;
}
public AriClient(IActionConsumer actionConsumer, IEventProducer eventProducer, string application)
{
_actionConsumer = actionConsumer;
_eventProducer = eventProducer;
EventDispatchingStrategy = DefaultEventDispatchingStrategy;
// Setup Action Properties
Asterisk = new AsteriskActions(_actionConsumer);
Applications = new ApplicationsActions(_actionConsumer);
Bridges = new BridgesActions(_actionConsumer);
Channels = new ChannelsActions(_actionConsumer);
DeviceStates = new DeviceStatesActions(_actionConsumer);
Endpoints = new EndpointsActions(_actionConsumer);
Events = new EventsActions(_actionConsumer);
Mailboxes = new MailboxesActions(_actionConsumer);
Playbacks = new PlaybacksActions(_actionConsumer);
Recordings = new RecordingsActions(_actionConsumer);
Sounds = new SoundsActions(_actionConsumer);
// Setup Event Handlers
_eventProducer.OnMessageReceived += _eventProducer_OnMessageReceived;
_eventProducer.OnConnectionStateChanged += _eventProducer_OnConnectionStateChanged;
}
public AggregateRepository(IEventStore <TA, TId> eventStore,
IEventProducer eventPublisher)
{
_eventStore = eventStore;
_eventPublisher = eventPublisher;
}
public StringReverseEventHandler(IEventProducer <string> messageHandledProducer)
{
this.messageHandledProducer = messageHandledProducer;
}
public void Stop(IEventProducer eventProducer)
{
this.PublishStateChange(eventProducer, "Stopping");
try
{
if (this.IServiceComponent != null)
this.IServiceComponent.Stop();
this.PublishStateChange(eventProducer, "Stopped");
}
catch (Exception ex)
{
this.PublishStateChangeFailed(eventProducer, "StopFailed", ex);
throw;
}
finally
{
try
{
this.IServiceComponent.Dispose();
}
catch
{ /* eating the exception */ }
this.IServiceComponent = null;
}
}
private void PublishStateChangeFailed(IEventProducer eventProducer, string environment, string state, Exception ex)
{
eventProducer.Publish(new ServiceHostStateChangeFailed() { Environment = environment, Process = this.Process, State = state, Exception = ex });
}
public DialogTask(Func <CancellationToken, IDialogContext> makeContext, IStore <IFiberLoop <DialogTask> > store, IEventProducer <IActivity> queue)
{
SetField.NotNull(out this.makeContext, nameof(makeContext), makeContext);
SetField.NotNull(out this.store, nameof(store), store);
SetField.NotNull(out this.queue, nameof(queue), queue);
this.store.TryLoad(out this.fiber);
this.frames = new Frames(this);
}
public DialogSystem(IDialogTasks tasks, IEventLoop loop, IEventProducer <IActivity> queue)
{
SetField.NotNull(out this.tasks, nameof(tasks), tasks);
SetField.NotNull(out this.loop, nameof(loop), loop);
SetField.NotNull(out this.queue, nameof(queue), queue);
}
public EventsService(IEventProducer <TType, TKey> eventProducer, IEventsRepository <TType, TKey> eventsRepository)
{
_eventProducer = eventProducer;
_eventRepository = eventsRepository;
}
public void Deactivate(IEventProducer eventProducer)
{
if (this.IServiceComponent != null)
this.Stop(eventProducer);
this.PublishStateChange(eventProducer, "Deactivating");
try
{
if (this.WorkerDomain != null)
{
AppDomain.Unload(this.WorkerDomain);
this.WorkerDomain = null;
}
this.PublishStateChange(eventProducer, "Deactivated");
}
catch (Exception ex)
{
this.PublishStateChangeFailed(eventProducer, "DeactivationFailed", ex);
throw;
}
}
public void Update(IEventProducer eventProducer, ServiceComponent serviceComponent)
{
this.Stop(eventProducer);
this.ServiceComponentData = serviceComponent;
this.Start(eventProducer);
}
public KafkaCountEventHandler(IEventProducer <int> messageHandledProducer)
{
this.messageHandledProducer = messageHandledProducer;
}
private void PublishStateChangeFailed(IEventProducer eventProducer, string state, Exception ex)
{
eventProducer.Publish(new ServiceHostComponentStateChangeFailed() { Environment = this.Environment, Process = this.Process, ServiceComponent = this.ServiceComponentData.FriendlyName, State = state, Exception = ex });
}
public ProcessOrdersService(IEventProducer producer, IEventConsumer consumer, ILogger <ProcessOrdersService> logger)
{
_logger = logger;
_producer = producer;
_consumer = consumer;
}
public void Start(IEventProducer eventProducer)
{
if (!this.ServiceComponentData.IsActive)
return;
this.Activate(eventProducer);
this.PublishStateChange(eventProducer, "Starting");
try
{
if (this.IServiceComponent == null)
this.IServiceComponent = this.WorkerDomain.CreateInstanceAndUnwrap(this.ServiceComponentData.Assembly, this.ServiceComponentData.Class) as IWindowsServiceComponent;
this.IServiceComponent.ConfigURL = this.ConfigURL;
this.IServiceComponent.Configuration = this.ServiceComponentData.Config;
this.IServiceComponent.Environment = this.EnvironmentConfig;
this.IServiceComponent.Start();
this.PublishStateChange(eventProducer, "Started");
}
catch (Exception ex)
{
this.Deactivate(eventProducer);
this.PublishStateChangeFailed(eventProducer, "StartFailed", ex);
throw;
}
}
public HomeController(IEventProducer producer)
{
_producer = producer;
}
public async Task DialogTaskManager_TwoParallelDialogTasks()
{
var dialog = new Mock <DialogTaskTests.IDialogFrames <string> >(MockBehavior.Strict);
var secondStackDialog = new Mock <DialogTaskTests.IDialogFrames <object> >(MockBehavior.Strict);
dialog
.Setup(d => d.StartAsync(It.IsAny <IDialogContext>()))
.Returns <IDialogContext>(async context => { context.Wait(dialog.Object.ItemReceived); });
dialog
.Setup(d => d.ItemReceived(It.IsAny <IDialogContext>(), It.IsAny <IAwaitable <IMessageActivity> >()))
.Returns <IDialogContext, IAwaitable <IMessageActivity> >(async(context, message) =>
{
var msg = await message;
await context.PostAsync(msg.Text);
context.Wait(dialog.Object.ItemReceived);
});
var promptMessage = "Say something!";
secondStackDialog
.Setup(d => d.StartAsync(It.IsAny <IDialogContext>()))
.Returns <IDialogContext>(
async context =>
{ context.Wait(secondStackDialog.Object.ItemReceived <IMessageActivity>); });
secondStackDialog
.Setup(d => d.ItemReceived(It.IsAny <IDialogContext>(), It.IsAny <IAwaitable <IMessageActivity> >()))
.Returns <IDialogContext, IAwaitable <IMessageActivity> >(async(context, message) =>
{
PromptDialog.Text(context, secondStackDialog.Object.ItemReceived, promptMessage);
});
secondStackDialog
.Setup(d => d.ItemReceived(It.IsAny <IDialogContext>(), It.IsAny <IAwaitable <string> >()))
.Returns <IDialogContext, IAwaitable <string> >(async(context, message) =>
{
await context.PostAsync($"from prompt {await message}");
context.Wait(secondStackDialog.Object.ItemReceived <IMessageActivity>);
});
Func <IDialog <object> > makeRoot = () => dialog.Object;
Func <IDialog <object> > secondStackMakeRoot = () => secondStackDialog.Object;
var toBot = MakeTestMessage();
using (new FiberTestBase.ResolveMoqAssembly(dialog.Object, secondStackDialog.Object))
using (var container = Build(Options.MockConnectorFactory, dialog.Object, secondStackDialog.Object))
{
string foo = "foo";
string bar = "bar";
Queue <IMessageActivity> queue;
using (var scope = DialogModule.BeginLifetimeScope(container, toBot))
{
toBot.Text = foo;
DialogModule_MakeRoot.Register(scope, makeRoot);
await scope.Resolve <IPostToBot>().PostAsync(toBot, CancellationToken.None);
var botData = scope.Resolve <IBotData>();
await botData.LoadAsync(CancellationToken.None);
var dialogTaskManager = scope.Resolve <IDialogTaskManager>();
//create second dialog task
var secondDialogTask = dialogTaskManager.CreateDialogTask();
var reactiveDialogTask = new ReactiveDialogTask(secondDialogTask, secondStackMakeRoot);
IEventLoop loop = reactiveDialogTask;
await loop.PollAsync(CancellationToken.None);
IEventProducer <IActivity> producer = reactiveDialogTask;
producer.Post(toBot);
await loop.PollAsync(CancellationToken.None);
await botData.FlushAsync(CancellationToken.None);
queue = scope.Resolve <Queue <IMessageActivity> >();
Assert.AreEqual(foo, queue.Dequeue().Text);
Assert.AreEqual(promptMessage, queue.Dequeue().Text);
}
using (var scope = DialogModule.BeginLifetimeScope(container, toBot))
{
toBot.Text = bar;
DialogModule_MakeRoot.Register(scope, makeRoot);
await scope.Resolve <IPostToBot>().PostAsync(toBot, CancellationToken.None);
var dialogTaskManager = scope.Resolve <IDialogTaskManager>();
Assert.AreEqual(2, dialogTaskManager.DialogTasks.Count);
var secondDialogTask = dialogTaskManager.DialogTasks[1];
await secondDialogTask.PollAsync(CancellationToken.None);
secondDialogTask.Post(toBot);
await secondDialogTask.PollAsync(CancellationToken.None);
queue = scope.Resolve <Queue <IMessageActivity> >();
Assert.AreEqual(bar, queue.Dequeue().Text);
Assert.AreEqual($"from prompt {bar}", queue.Dequeue().Text);
}
}
}
public VisitorRideStrategy(IEventProducer eventProducer, IRideClient rideClient)
{
this.eventProducer = eventProducer;
this.rideClient = rideClient;
}
private void PublishStateChange(IEventProducer eventProducer, string environment, string state)
{
eventProducer.Publish(new ServiceHostStateChange() { Environment = environment, Process = this.Process, State = state });
}
public StringLowerEventHandler(IEventProducer <string> messageHandledProducer)
{
this.messageHandledProducer = messageHandledProducer;
}
public EventLoopDialogTask(Func <IEventLoop> makeInner, IEventProducer <IActivity> queue, IBotData botData)
{
SetField.NotNull(out this.queue, nameof(queue), queue);
SetField.CheckNull(nameof(makeInner), makeInner);
this.inner = new Lazy <IEventLoop>(() => makeInner());
}
public EmployeeControl(INameService nameService, ILogger <EmployeeControl> logger, IEventProducer eventProducer)
{
Employees = new ConcurrentBag <Employee>();
this.nameService = nameService;
this.logger = logger;
this.eventProducer = eventProducer;
}
public EventsService(IEventsRepository <TA, TKey> eventsRepository, IEventProducer <TA, TKey> eventProducer)
{
_eventsRepository = eventsRepository ?? throw new ArgumentNullException(nameof(eventsRepository));
_eventProducer = eventProducer ?? throw new ArgumentNullException(nameof(eventProducer));
}
public void Continue(IEventProducer eventProducer)
{
this.PublishStateChange(eventProducer, "Continuing");
try
{
if (this.IServiceComponent != null)
this.IServiceComponent.Pause();
this.PublishStateChange(eventProducer, "Started");
}
catch (Exception ex)
{
this.PublishStateChangeFailed(eventProducer, "ContinueFailed", ex);
throw;
}
}
/// <summary>
/// Creates a <see cref="Event"/> instance out of <see cref="EventDocument"/> instance
/// which can then be posted into IEventProducer. You can use this method to obtain raw event
/// once in order to possibly re-try posting if post fails. The system maintains idempotency of
/// Event posts, therefore a caller may hang to returned Event instance to retry failed posting
/// </summary>
/// <param name="producer">Producer to eventually post event into</param>
/// <param name="evtDoc">EventDocument-derivative instance</param>
/// <param name="headers">Event headers or null</param>
/// <returns>
/// A tuple of (EventAttribute attr, ShardKey partition, Event evt) suitable for
/// making a call to<see cref="IEventProducer.PostAsync(Route, ShardKey, Event, DataLossMode)"/>
/// </returns>
public static (EventAttribute attr, ShardKey partition, Event evt) GetRawEventForDocument(this IEventProducer producer,
EventDocument evtDoc,
JsonDataMap headers = null)
{
var partition = evtDoc.NonNull(nameof(evtDoc)).GetEventPartition();
var eventHeaders = evtDoc.GetEventHeaders(headers);
var rawHeaders = eventHeaders != null?JsonWriter.Write(eventHeaders, JsonWritingOptions.CompactRowsAsMap) : null;
var rawJson = JsonWriter.WriteToBuffer(evtDoc, JsonWritingOptions.CompactRowsAsMap, EVENT_JSON_ENCODING);
var rawEvent = producer.NonNull(nameof(producer))
.MakeNew(CONTENT_TYPE_JSON_DOC, rawJson, rawHeaders);
var attr = EventAttribute.GetFor(evtDoc.GetType());
return(attr, partition, rawEvent);
}
public VisitorFairyTaleStrategy(IEventProducer eventProducer, IFairyTaleClient fairyTaleClient)
{
this.eventProducer = eventProducer;
this.fairyTaleClient = fairyTaleClient;
}
