public void Consume(IConsumeContext <RequestVote> context) { // reject outdated requests if (context.Message.Term >= _state.CurrentTerm) { _state.CurrentTerm = context.Message.Term; if (_state.VotedFor == null || context.Message.Candidate.ControlUri == _state.VotedFor) { // check last RPC commit index if it's not recently up to date, don't vote if (_state.LastCommitIndex <= context.Message.LastLogIndex && _state.LastCommitTerm <= context.Message.LastLogTerm) { _state.VotedFor = context.Message.Candidate.ControlUri; // ScheduleElectionTimeout(); context.Respond <VoteFor>(new VoteForResponse(_state.Node, _state.CurrentTerm)); return; } } } context.Respond <VoteAgainst>(new VoteAgainstResponse(_state.CurrentTerm)); }
public void Consume(IConsumeContext<RequestVote> context) { // reject outdated requests if (context.Message.Term >= _state.CurrentTerm) { _state.CurrentTerm = context.Message.Term; if (_state.VotedFor == null || context.Message.Candidate.ControlUri == _state.VotedFor) { // check last RPC commit index if it's not recently up to date, don't vote if (_state.LastCommitIndex <= context.Message.LastLogIndex && _state.LastCommitTerm <= context.Message.LastLogTerm) { _state.VotedFor = context.Message.Candidate.ControlUri; // ScheduleElectionTimeout(); context.Respond<VoteFor>(new VoteForResponse(_state.Node, _state.CurrentTerm)); return; } } } context.Respond<VoteAgainst>(new VoteAgainstResponse(_state.CurrentTerm)); }
public void Consume(IConsumeContext <ExecuteHttpRequest> context) { Console.WriteLine("Sending Request to {0}", context.Message.Url); try { var cancellationTokenSource = new CancellationTokenSource(); cancellationTokenSource.CancelAfter(30000); DateTime startTime = DateTime.UtcNow; Stopwatch timer = Stopwatch.StartNew(); Task task = _client.GetAsync(context.Message.Url, HttpCompletionOption.ResponseHeadersRead, cancellationTokenSource.Token) .ContinueWith(x => { timer.Stop(); Console.WriteLine("Request completing as {0} ({1})", x.Result.StatusCode, context.Message.Url); if (x.Result.IsSuccessStatusCode) { context.Respond(new HttpRequestSucceededEvent(x.Result.StatusCode)); context.NotifyResourceUsageCompleted(context.Message.Url, startTime, timer.Elapsed); } else { context.Respond(new HttpRequestFaultedEvent(x.Result.StatusCode)); context.NotifyResourceUsageFailed(context.Message.Url, x.Result.ReasonPhrase); } x.Result.Dispose(); }, TaskContinuationOptions.OnlyOnRanToCompletion) .ContinueWith( x => { context.Respond( new HttpRequestFaultedEvent(HttpStatusCode.InternalServerError)); }, TaskContinuationOptions.OnlyOnFaulted); task.Wait(cancellationTokenSource.Token); } catch (Exception ex) { context.GenerateFault(ex); } }
public void Consume(IConsumeContext <CommandBusTestCommand> consumeContext) { try { if (consumeContext.Message.ShouldThrowException) { throw new InvalidOperationException("This is an expected exception!"); } consumeContext.Respond(CommandResult.Successful); } catch (Exception ex) { consumeContext.Respond(ex.ToCommandResult()); } }
public void Consume(IConsumeContext <ChangeElectionAmount> context) { var response = new CommandResponse { CommandId = context.Message.ElectionId, }; try { Handle(context.Message); response.CommandStatus = CommandStatusEnum.Succeeded; response.ContainsException = false; response.ExceptionDetail = string.Empty; response.Message = string.Empty; } catch (Exception exception) { response.CommandStatus = CommandStatusEnum.Failed; response.ContainsException = true; response.ExceptionDetail = exception.ToString(); response.Message = exception.Message; } context.Respond(response); }
public void Consume(IConsumeContext <TCommand> context) { var response = new CommandResponse { CommandId = _expressionToGetTheMessageId.Compile()(context.Message).ToString() }; try { Handle(context.Message); response.CommandStatus = CommandStatusEnum.Succeeded; response.ContainsException = false; response.ExceptionDetail = string.Empty; response.Message = string.Empty; } catch (Exception exception) { response.CommandStatus = CommandStatusEnum.Failed; response.ContainsException = true; response.ExceptionDetail = exception.ToString(); response.Message = exception.Message; } context.Respond(response); }
public void Respond(IConsumeContext <Input> context) { Thread.Sleep(TimeSpan.FromSeconds(2)); context.Respond(new Output { Id = context.Message.Id }); }
public void Consume(IConsumeContext <TCommand> context) { var response = new CommandResponse { CommandId = _getMessageIdDelegate(context.Message), }; try { _commandHandlerToWrap.Handle(context.Message); response.CommandStatus = CommandStatusEnum.Succeeded; response.ContainsException = false; response.ExceptionDetail = string.Empty; response.Message = string.Empty; } catch (Exception exception) { response.CommandStatus = CommandStatusEnum.Failed; response.ContainsException = true; response.ExceptionDetail = exception.ToString(); response.Message = exception.Message; } context.Respond(response); }
public void Consume(IConsumeContext <SampleCommandRequest> context) { Console.WriteLine("Received request {0}", context.Message.Id); context.Respond(GetResponseMessage(context.Message)); //Action action = () => SendResponse(context); //Parallel.Invoke(action); }
void FirstCommandConsumer(IConsumeContext <FirstCommand> context, FirstCommand message) { ThreadUtil.Sleep(10.Milliseconds()); var response = new FirstResponse(message.CorrelationId); context.Respond(response); }
public void Consume(IConsumeContext <NodeSetupRequest> message) { var response = new NodeSetupResponse { CorrelationId = this.CorrelationId }; message.Respond(response); }
public void Consume(IConsumeContext <TCommand> context) { var command = context.Message; var response = this.commandHandler.Handle(command); if (command.ExpectResponse) { context.Respond(response); } }
protected void Respond <T>(T message, Dictionary <string, string> headers) where T : class { _consumeContext.Respond(message, ctx => { foreach (var header in headers) { ctx.SetHeader(header.Key, header.Value); } }); }
public void Consume(IConsumeContext <AuthenticateRequest> context) { var user = _AuthenticateUserRequestToUserMapper.Map(context.Message); var response = new AuthenticateResponse { Authenticated = _UserService.Authenticate(user), CorrelationId = context.Message.CorrelationId }; context.Respond(response); }
public void Execute(Composer composer, TInstance instance, TData value) { composer.Execute(() => { IConsumeContext <TData> context = ContextStorage.MessageContext <TData>(); TMessage message = _messageFactory(instance, context); context.Respond(message, _contextCallback); }); }
public void Consume(IConsumeContext <GetBusStatus> context) { DiagnosticsProbe probe = _bus.Probe(); context.Respond(new BusStatusImpl { Entries = probe.Entries .Select(x => (BusStatusEntry) new BusStatusEntryImpl(x.Context, x.Key, x.Value)) .ToArray(), }); }
public void Consume(IConsumeContext <GetStatusRequest> context) { var message = context.Message; var status = _DbContext.Statuses.Find(message.StatusId); context.Respond(new GetStatusResponse { CorrelationId = message.CorrelationId, Result = status != null ? MessageResult.Success : MessageResult.NotFound, Status = _Mapper.Map <Status>(status) }); }
public void Consume(IConsumeContext <RequestMessage> context) { var request = context.Message; var response = new ResponseMessage { CorrelationId = request.CorrelationId, Result = true }; context.Respond(response); Console.WriteLine("Request {0} consumed", request.CorrelationId); }
public void Consume(IConsumeContext <RegisterUserRequest> context) { var user = _RegisterUserRequestToUserMapper.Map(context.Message); var result = _UserService.Register(user); var response = _Mapper.Map <RegisterUserResponse>(result); response.Registered = !result.ValidationErrors.Any(); response.UserId = result.Entity.Id; response.CorrelationId = context.Message.CorrelationId; context.Respond(response); }
public void Consume(IConsumeContext <FindPlugin> context) { FindPlugin message = context.Message; log.DebugFormat("Responding to query for {0}", message.Filter); IEnumerable <PluginDescriptor> plugins = pluginRepository.Plugins(message.Filter); FindPluginResponse reply = new FindPluginResponse(message); reply.FoundPlugins = plugins.ToArray(); context.Respond(reply, cb => cb.SetRetryCount(0)); }
public void Consume(IConsumeContext <GetCategoryRequest> context) { var request = context.Message; var category = _DbContext.Categories.Find(request.CategoryId); var response = new GetCategoryResponse { Category = _Mapper.Map <Category>(category), CorrelationId = request.CorrelationId, Result = category != null ? MessageResult.Success : MessageResult.NotFound }; context.Respond(response); }
public void Consume(IConsumeContext <FetchAssembly> context) { FetchAssembly message = context.Message; byte[] bytes = assemblyRepository.Fetch(message.Name); log.DebugFormat("Returning {0} bytes for {1}", bytes != null ? bytes.Length : 0, message.Name); FetchAssemblyResponse response = new FetchAssemblyResponse(message); response.Bytes = bytes; context.Respond(response); }
public void Consume(IConsumeContext <AddEvidenceToLockup> message) { var msg = message.Message; Console.WriteLine("PROVEABLESLOW > Right away officer."); Thread.Sleep(1000); Console.WriteLine("PROVEABLESLOW > Time to file this {0} for case number {1}", msg.Evidence, msg.CaseNumber); Thread.Sleep(1000); Console.WriteLine("PROVEABLESLOW > Alright filed that in case {0}", msg.CaseNumber); message.Respond(new EvidenceAddedEvent() { ClerkName = "PROVEABLESLOW" }); }
public void Consume(IConsumeContext <CreateStatusRequest> context) { var message = context.Message; var status = _Mapper.Map <Domain.Status>(message.Status); _DbContext.Statuses.Add(status); _DbContext.SaveChanges(); context.Respond(new CreateStatusResponse { CorrelationId = message.CorrelationId, Result = MessageResult.Success, Status = _Mapper.Map <Status>(status) }); }
private void HandleConnectionRequest(IConsumeContext <ConnectionConnectRequest> ctx) { _connections.AddOrUpdate(ctx.Message.ConnectionId, id => new UserConnection(ctx.Message.ConnectionId, ctx.Message.UserId, _mBus, _log), (id, con) => { // only attach the session if the user id is the same if (con.UserId == ctx.Message.UserId) { con.IsConnected = true; return(con); } return(new UserConnection(ctx.Message.ConnectionId, _systemInfo.Guid(), _mBus, _log)); }); ctx.Respond(new ConnectionConnectResponse(ctx.Message.ConnectionId, ctx.Message.UserId)); }
public void Consume(IConsumeContext <CreateCategoryRequest> context) { var request = context.Message; var category = _Mapper.Map <Domain.Category>(request.Category); _DbContext.Categories.Add(category); _DbContext.SaveChanges(); var response = new CreateCategoryResponse { Category = _Mapper.Map <Category>(category), CorrelationId = request.CorrelationId, Result = MessageResult.Success }; context.Respond(response); }
public void Consume(IConsumeContext <PingWorker> context) { try { var message = new WorkerAvailable <TMessage>(_worker.ControlUri, _worker.DataUri, _inProgress, _inProgressLimit, _pending.PendingMessageCount(), _pendingLimit); context.Respond(message); if (_log.IsDebugEnabled) { _log.DebugFormat("Worker {0}: {1} in progress, {2} pending", _worker.DataUri, _inProgress, _pending); } } catch { } }
public void Consume(IConsumeContext <ValidRequest> context) { Debug.WriteLine("Request Handled"); context.Respond(new Replay()); }
void Handle(IConsumeContext<SimpleRequest> context, SimpleRequest message) { context.Respond(new SimpleResponse(message.Headers)); }
public void Consume(IConsumeContext<RequestVote> context) { context.Respond<VoteAgainst>(new VoteAgainstResponse(_state.CurrentTerm)); }
private void HandleConnectionRequest(IConsumeContext<ConnectionConnectRequest> ctx) { _connections.AddOrUpdate(ctx.Message.ConnectionId, id => new UserConnection(ctx.Message.ConnectionId, ctx.Message.UserId, _mBus, _log), (id, con) => { // only attach the session if the user id is the same if (con.UserId == ctx.Message.UserId) { con.IsConnected = true; return con; } return new UserConnection(ctx.Message.ConnectionId, _systemInfo.Guid(), _mBus, _log); }); ctx.Respond(new ConnectionConnectResponse(ctx.Message.ConnectionId, ctx.Message.UserId)); }
public void Respond(IConsumeContext<Input> context) { Thread.Sleep(TimeSpan.FromSeconds(2)); context.Respond(new Output { Id = context.Message.Id }); }
public void Consume(IConsumeContext <DoSimpleWorkItem> context) { _log.InfoFormat("Responding to {0}", context.Message.CorrelationId); context.Respond(new CompletedSimpleWorkItem(context.Message.CorrelationId, context.Message.CreatedAt)); }
public static void Respond <T>(this IConsumeContext context, T message) where T : class { context.Respond(message, x => { }); }
public void Consume(IConsumeContext <RequestVote> context) { context.Respond <VoteAgainst>(new VoteAgainstResponse(_state.CurrentTerm)); }