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));
}
