public async Task <IActionResult> SendMessage() { var greetingAsync = new GreetingAsyncEvent("Hello from the web"); var greeting = new GreetingEvent("Hello from the web"); _context.Greetings.Add(greeting); _context.GreetingsAsync.Add(greetingAsync); await _context.SaveChangesAsync(); _commandProcessor.Post(greeting); await _commandProcessor.PostAsync(greetingAsync); return(View("Index")); }
public async Task StartAsync(CancellationToken cancellationToken) { long loop = 0; while (true) { try { if (cancellationToken.IsCancellationRequested) { break; } loop++; Console.WriteLine($"Sending message #{loop}"); _commandProcessor.Post(new GreetingEvent($"Ian #{loop}")); if (loop % 100 != 0) { continue; } Console.WriteLine("Pausing for breath..."); await Task.Delay(4000, cancellationToken); } catch (BrokenCircuitException) { Console.WriteLine("Can't send to producer, pausing...will retry in 5 seconds"); Task.Delay(TimeSpan.FromSeconds(5)).Wait(); } } }
public async Task StartAsync(CancellationToken cancellationToken) { long loop = 0; while (true) { if (cancellationToken.IsCancellationRequested) { break; } loop++; Console.WriteLine($"Sending message #{loop}"); _commandProcessor.Post(new GreetingEvent($"Ian #{loop}")); if (loop % 100 != 0) { continue; } Console.WriteLine("Pausing for breath..."); await Task.Delay(4000, cancellationToken); } }
public override HelloWorldCommand Handle(HelloWorldCommand command) { _logger.Information($"Handling HelloWorldCommand {command.Id}"); _logger.Information(command.Message); _commandProcessor.Post(new ProcessMessageCommand(command.Message)); return(base.Handle(command)); }
public void ProcessRecord(StreamRecord streamRecord) { IRecordTranslator <StreamRecord, AccountEvent> translator = _translatorRegistry.Get <StreamRecord, AccountEvent>(); var accountEvent = translator.TranslateFromRecord(streamRecord); _commandProcessor.Post(accountEvent); _logger.LogDebug($"Process Record {streamRecord.SequenceNumber}"); }
public void When_completing_a_missing_task() { _exception = Catch.Exception(() => _handler.Handle(_cmd)); //_should_fail Assert.IsInstanceOf <ArgumentOutOfRangeException>(_exception); //_should_not_post_event A.CallTo(() => _commandProcessor.Post(A <TaskCompletedEvent> ._)).MustNotHaveHappened(); }
public IActionResult Post([FromBody] BulkAddToDoRequest request) { var bulkAddCommand = new BulkAddToDoCommand(request.ItemsToAdd); _commandProcessor.Post(bulkAddCommand); //TODO: Should have a monitoring endpoint, and share a job table location for tracking progress return(Accepted()); }
public void When_completing_an_existing_task() { _handler.Handle(_cmd); _taskToBeCompleted = _tasksDAO.FindById(_cmd.TaskId); //_should_update_the_tasks_completed_date Assert.AreEqual(s_COMPLETION_DATE.Date, _taskToBeCompleted.CompletionDate.Value.Date); //_should_post_event A.CallTo(() => s_commandProcessor.Post(A <TaskCompletedEvent> ._)).MustHaveHappened(Repeated.Exactly.Once); }
/// <summary> /// We want to send a heartbeat back to the caller. The heartbeat consists of the set of channels we own /// and their current status. /// </summary> /// <param name="command">The command.</param> /// <returns>TRequest.</returns> public override HeartbeatRequest Handle(HeartbeatRequest command) { var heartbeat = new HeartbeatReply(_dispatcher.HostName, new ReplyAddress(command.ReplyAddress.Topic, command.ReplyAddress.CorrelationId)); _dispatcher.Consumers.Each((consumer) => heartbeat.Consumers.Add(new RunningConsumer(consumer.Name, consumer.State))); _commandProcessor.Post(heartbeat); return(base.Handle(command)); }
public override GreetingEvent Handle(GreetingEvent @event) { Console.WriteLine("Received Greeting. Message Follows"); Console.WriteLine("----------------------------------"); Console.WriteLine(@event.Greeting); Console.WriteLine("----------------------------------"); Console.WriteLine("Message Ends"); _commandProcessor.Post(new GreetingAsyncEvent("Greetings from Non Async")); return(base.Handle(@event)); }
private void DoWork(object state) { _iteration++; var greetingEvent = new GreetingEvent { Id = Guid.NewGuid(), Greeting = $"Hello # {_iteration}" }; _processor.Post(greetingEvent); _logger.LogInformation($"Sending message with id {greetingEvent.Id} and greeting {greetingEvent.Greeting}"); }
public void Establish() { _tasksDAO = new Tasks.Adapters.DataAccess.TasksDAO(); _tasksDAO.Clear(); _cmd = new CompleteTaskCommand(TASK_ID, _COMPLETION_DATE); _commandProcessor = A.Fake <IAmACommandProcessor>(); A.CallTo(() => _commandProcessor.Post(A <TaskCompletedEvent> ._)); _handler = new CompleteTaskCommandHandler(_tasksDAO, _commandProcessor); }
public override TaskReminderCommand Handle(TaskReminderCommand taskReminderCommand) { //_mailGateway.Send(new TaskReminder( // taskName: new TaskName(taskReminderCommand.TaskName), // dueDate: taskReminderCommand.DueDate, // reminderTo: new EmailAddress(taskReminderCommand.Recipient), // copyReminderTo: new EmailAddress(taskReminderCommand.CopyTo) // )); _commandProcessor.Post(new TaskReminderSentEvent(taskReminderCommand.Id, taskReminderCommand.TaskId, taskReminderCommand.TaskName, taskReminderCommand.DueDate, taskReminderCommand.Recipient, taskReminderCommand.CopyTo)); return(base.Handle(taskReminderCommand)); }
public IActionResult Post([FromBody] TaskReminderModel reminder) { var reminderCommand = new TaskReminderCommand( taskId: reminder.TaskId, taskName: reminder.TaskName, dueDate: DateTime.Parse(reminder.DueDate), recipient: reminder.Recipient, copyTo: reminder.CopyTo ); _commandProcessor.Post(reminderCommand); return(new StatusCodeResult(202)); }
public override EditTaskCommand Handle(EditTaskCommand editTaskCommand) { var task = _tasksDAO.FindById(editTaskCommand.TaskId); task.TaskName = editTaskCommand.TaskName; task.TaskDescription = editTaskCommand.TaskDescription; task.DueDate = editTaskCommand.TaskDueDate; _tasksDAO.Update(task); _commandProcessor.Post(new TaskEditedEvent(editTaskCommand.Id, editTaskCommand.TaskId, editTaskCommand.TaskName, editTaskCommand.TaskDescription, editTaskCommand.TaskDueDate)); return(base.Handle(editTaskCommand)); }
public void When_editing_an_existing_task() { _handler.Handle(_cmd); _taskToBeEdited = _tasksDAO.FindById(_cmd.TaskId); //_should_update_the_task_with_the_new_task_name Assert.AreEqual(NEW_TASK_NAME, _taskToBeEdited.TaskName); //_should_update_the_task_with_the_new_task_description Assert.AreEqual(NEW_TASK_DESCRIPTION, _taskToBeEdited.TaskDescription); //_should_update_the_task_with_the_new_task_time Assert.AreEqual(_NEW_TIME.Date, _taskToBeEdited.DueDate.Value.Date); //_should_post_event A.CallTo(() => s_commandProcessor.Post(A <TaskEditedEvent> ._)).MustHaveHappened(Repeated.Exactly.Once); }
public OperationResult Post(TaskReminderModel reminder) { var reminderCommand = new TaskReminderCommand( taskName: reminder.TaskName, dueDate: DateTime.Parse(reminder.DueDate), recipient: reminder.Recipient, copyTo: reminder.CopyTo ); commandProcessor.Post(reminderCommand); return(new OperationResult.OK() { StatusCode = (int)HttpStatusCode.Accepted }); }
public override AddTaskCommand Handle(AddTaskCommand addTaskCommand) { var inserted = _tasksDAO.Add( new Task( taskName: addTaskCommand.TaskName, taskDecription: addTaskCommand.TaskDescription, dueDate: addTaskCommand.TaskDueDate ) ); addTaskCommand.TaskId = inserted.Id; _commandProcessor.Post(new TaskAddedEvent(addTaskCommand.Id, addTaskCommand.TaskId, addTaskCommand.TaskName, addTaskCommand.TaskDescription, addTaskCommand.TaskDueDate)); return(base.Handle(addTaskCommand)); }
public override async Task <AddToDoCommand> HandleAsync(AddToDoCommand command, CancellationToken cancellationToken = new CancellationToken()) { using (var uow = new ToDoContext(_options)) { var repository = new ToDoItemRepositoryAsync(uow); var savedItem = await repository.AddAsync( new ToDoItem { Title = command.Title, Completed = command.Commpleted, Order = command.Order }, cancellationToken ); command.ToDoItemId = savedItem.Id; } _commandProcessor.Post(new TaskCreatedEvent(command.Title)); return(await base.HandleAsync(command, cancellationToken)); }
public override EditTaskCommand Handle(EditTaskCommand editTaskCommand) { using (var scope = _tasksDAO.BeginTransaction()) { Task task = _tasksDAO.FindById(editTaskCommand.TaskId); task.TaskName = editTaskCommand.TaskName; task.TaskDescription = editTaskCommand.TaskDescription; task.DueDate = editTaskCommand.TaskDueDate; _tasksDAO.Update(task); scope.Commit(); } _commandProcessor.Post(new TaskEditedEvent(editTaskCommand.Id, editTaskCommand.TaskId, editTaskCommand.TaskName, editTaskCommand.TaskDescription, editTaskCommand.TaskDueDate)); return(base.Handle(editTaskCommand)); }
public override CompleteTaskCommand Handle(CompleteTaskCommand completeTaskCommand) { var task = _tasksDAO.FindById(completeTaskCommand.TaskId); if (task != null) { task.CompletionDate = completeTaskCommand.CompletionDate; _tasksDAO.Update(task); } else { throw new ArgumentOutOfRangeException(nameof(completeTaskCommand), completeTaskCommand, "Could not find the task to complete"); } _commandProcessor.Post(new TaskCompletedEvent(completeTaskCommand.Id, completeTaskCommand.TaskId, completeTaskCommand.CompletionDate)); return(base.Handle(completeTaskCommand)); }
public async Task StartAsync(CancellationToken cancellationToken) { using (new TransactionScope(TransactionScopeOption.RequiresNew, new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted }, TransactionScopeAsyncFlowOption.Enabled)) { Console.WriteLine($"Sending {_repeatCount} command messages"); var sequenceNumber = 1; for (int i = 0; i < _repeatCount; i++) { _commandProcessor.Post(new CompetingConsumerCommand(sequenceNumber++)); } // We do NOT complete the transaction here to show that a message is // always queued, whether the transaction commits or aborts! } await Task.CompletedTask; }
private void DoWork(object state) { _iteration++; var greetingEvent = new GreetingEvent { Id = Guid.NewGuid(), Greeting = $"Hello # {_iteration}" }; try { _processor.Post(greetingEvent); } catch (Exception e) { _logger.LogError($"Kafka Message Generator is stopping due to {e.Message}"); _appLifetime.StopApplication(); } _logger.LogInformation($"Sending message with id {greetingEvent.Id} and greeting {greetingEvent.Greeting}"); }
public override AddTaskCommand Handle(AddTaskCommand addTaskCommand) { using (var scope = _tasksDAO.BeginTransaction()) { var inserted = _tasksDAO.Add( new Task( taskName: addTaskCommand.TaskName, taskDecription: addTaskCommand.TaskDescription, dueDate: addTaskCommand.TaskDueDate ) ); scope.Commit(); addTaskCommand.TaskId = inserted.Id; } _commandProcessor.Post(new TaskAddedEvent(addTaskCommand.Id, addTaskCommand.TaskId, addTaskCommand.TaskName, addTaskCommand.TaskDescription, addTaskCommand.TaskDueDate)); return(base.Handle(addTaskCommand)); }
public override CompleteTaskCommand Handle(CompleteTaskCommand completeTaskCommand) { using (var scope = _tasksDAO.BeginTransaction()) { Task task = _tasksDAO.FindById(completeTaskCommand.TaskId); if (task != null) { task.CompletionDate = completeTaskCommand.CompletionDate; _tasksDAO.Update(task); scope.Commit(); } else { throw new ArgumentOutOfRangeException("completeTaskCommand", completeTaskCommand, "Could not find the task to complete"); } } _commandProcessor.Post(new TaskCompletedEvent(completeTaskCommand.Id, completeTaskCommand.TaskId, completeTaskCommand.CompletionDate)); return(base.Handle(completeTaskCommand)); }
public override GreetingRequest Handle(GreetingRequest request) { string salutation; switch (request.Language) { case ("en-gb"): case ("en-us"): salutation = "Hello"; break; case ("fr-fr"): salutation = "Bonjour"; break; case ("de-de"): salutation = "Hallo"; break; case ("tlh"): salutation = "nuqneH"; break; default: salutation = "Salution"; break; } salutation += " " + request.Name; var response = new GreetingReply(request.ReplyAddress) { Salutation = salutation }; _commandProcessor.Post(response); return(base.Handle(request)); }
public override async Task <UpdateToDoCommand> HandleAsync(UpdateToDoCommand command, CancellationToken cancellationToken = new CancellationToken()) { string title; using (var uow = new ToDoContext(_options)) { var repository = new ToDoItemRepositoryAsync(uow); var toDoItem = await repository.GetAsync(command.ToDoId, cancellationToken); if (command.Title != null) { toDoItem.Title = command.Title; } if (command.Complete.HasValue) { toDoItem.Completed = command.Complete.Value; } if (command.Order.HasValue) { toDoItem.Order = command.Order.Value; } await repository.UpdateAsync(toDoItem, cancellationToken); title = toDoItem.Title; } if (command.Complete.HasValue && command.Complete.Value) { var taskCompleteEvent = new TaskCompletedEvent(title); _commandProcessor.Post(taskCompleteEvent); } return(await base.HandleAsync(command, cancellationToken)); }
public override GreetingRequest Handle(GreetingRequest request) { var salutation = request.Language switch { ("en-gb") => "Hello", ("en-us") => "Hello", ("fr-fr") => "Bonjour", ("de-de") => "Hallo", ("tlh") => "nuqneH", _ => "Salution" }; salutation += " " + request.Name; var response = new GreetingReply(request.ReplyAddress) { Salutation = salutation }; _commandProcessor.Post(response); return(base.Handle(request)); }
public override AddOrderCommand Handle(AddOrderCommand addOrderCommand) { _commandProcessor.Post(addOrderCommand); return(base.Handle(addOrderCommand)); }
public void Post <T>(T request) where T : class, IRequest { _commandProcessor.Post(request); }