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 Setup_quartz_service() { ISchedulerFactory schedulerFactory = new StdSchedulerFactory(); _scheduler = schedulerFactory.GetScheduler(); _receivedA = new ManualResetEvent(false); _bus = ServiceBusFactory.New(x => { x.ReceiveFrom("loopback://localhost/quartz"); x.UseJsonSerializer(); x.Subscribe(s => { s.Handler<A>((msg, context) => { _received = msg; _receivedA.Set(); }); s.Consumer(() => new ScheduleMessageConsumer(_scheduler)); }); }); _scheduler.JobFactory = new MassTransitJobFactory(_bus); _scheduler.Start(); }
void Consume(IConsumeContext<SubscriptionRefresh> context) { if (_subscriptionEndpoint.Address.Uri.Equals(context.SourceAddress)) { _ready.Set(); } }
public void Consume(IConsumeContext<VoteAgainst> context) { if (context.Message.Term > _candidateTerm) { _state.CurrentTerm = context.Message.Term; _state.ChangeTo<FollowerBehavior>(); return; } // _votes[context.Message.Supporter.ControlUri] = false; }
public NextActivityResult(IConsumeContext context, RoutingSlip routingSlip, string activityName, Guid activityTrackingNumber, IDictionary<string, object> results) { _timestamp = DateTime.UtcNow; _context = context; _routingSlip = routingSlip; _activityName = activityName; _activityTrackingNumber = activityTrackingNumber; _results = results; _bus = context.Bus; }
public CompensateResult(IConsumeContext context, RoutingSlip routingSlip, Activity activity, Guid activityTrackingNumber, Exception exception) { _timestamp = DateTime.UtcNow; _context = context; _bus = context.Bus; _routingSlip = routingSlip; _activity = activity; _exception = exception; _activityTrackingNumber = activityTrackingNumber; }
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; } else return new UserConnection(ctx.Message.ConnectionId, _systemInfo.Guid(), _mBus, _log); }); ctx.Respond(new ConnectionConnectResponse(ctx.Message.ConnectionId, ctx.Message.UserId)); }
public void Consume(IConsumeContext<Heartbeat> context) { // if (context.Message.Term < _state.CurrentTerm) // context.Respond(new YouAreNotMyMommy(_state.CurrentTerm)); // // _state.CurrentTerm = context.Message.Term; // // _state.SuspendPeers(); // ScheduleElectionTimeout(); // if this heartbeat's previous entry id is not equal to the last one received, that's bad // update our to the latest version // update commit index // context.Respond(new ByYourCommand(_state.CurrentTerm, _commitIndex)); }
public void Consume(IConsumeContext<VoteFor> context) { if (context.Message.Term > _candidateTerm) { _state.CurrentTerm = context.Message.Term; _state.ChangeTo<FollowerBehavior>(); return; } _votes[context.Message.Supporter.ControlUri] = true; var votesGranted = _votes.Count(x => x); if (votesGranted >= _state.QuorumSize) { _elected = true; } if (_elected) { // if (_state.PromoteToLeader(_candidateTerm, lastLogIndex, lastLogTerm)) // _state.ChangeTo<LeaderBehavior>(); } }
public Task ConsumeAsync(IConsumeContext <CloudEvent <NewCustomerModel> > context, CancellationToken cancellationToken = default) { _cache.Set(context.Message.TransactionId, context.Message.Data, TimeSpan.FromDays(1)); return(Task.CompletedTask); }
public void Consume(IConsumeContext <Customer> message) { Console.WriteLine($"Customer - CustomerId : {message.Message.CustomerId}"); }
public void Setup_quartz_service() { _receivedA = new ManualResetEvent(false); _bus = ServiceBusFactory.New(x => { x.ReceiveFrom("rabbitmq://localhost/test_quartz_client"); x.UseJsonSerializer(); x.UseRabbitMq(); x.Subscribe(s => { s.Handler<A>((msg, context) => { _received = msg; _receivedA.Set(); }); }); }); }
void Handle(IConsumeContext<SimpleRequest> context, SimpleRequest message) { context.Respond(new SimpleResponse(message.Headers)); }
public IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(IConsumeContext <TMessage> context, Guid sagaId, InstanceHandlerSelector <TSaga, TMessage> selector, ISagaPolicy <TSaga, TMessage> policy) where TMessage : class { using (ISession session = _sessionFactory.OpenSession()) using (ITransaction transaction = session.BeginTransaction()) { var instance = session.Get <TSaga>(sagaId, LockMode.Upgrade); if (instance == null) { if (policy.CanCreateInstance(context)) { yield return(x => { if (_log.IsDebugEnabled) { _log.DebugFormat("SAGA: {0} Creating New {1} for {2}", typeof(TSaga).ToFriendlyName(), sagaId, typeof(TMessage).ToFriendlyName()); } try { instance = policy.CreateInstance(x, sagaId); foreach (var callback in selector(instance, x)) { callback(x); } if (!policy.CanRemoveInstance(instance)) { session.Save(instance); } } catch (Exception ex) { var sex = new SagaException("Create Saga Instance Exception", typeof(TSaga), typeof(TMessage), sagaId, ex); if (_log.IsErrorEnabled) { _log.Error(sex); } if (transaction.IsActive) { transaction.Rollback(); } throw sex; } }); } else { if (_log.IsDebugEnabled) { _log.DebugFormat("SAGA: {0} Ignoring Missing {1} for {2}", typeof(TSaga).ToFriendlyName(), sagaId, typeof(TMessage).ToFriendlyName()); } } } else { if (policy.CanUseExistingInstance(context)) { yield return(x => { if (_log.IsDebugEnabled) { _log.DebugFormat("SAGA: {0} Using Existing {1} for {2}", typeof(TSaga).ToFriendlyName(), sagaId, typeof(TMessage).ToFriendlyName()); } try { foreach (var callback in selector(instance, x)) { callback(x); } if (policy.CanRemoveInstance(instance)) { session.Delete(instance); } } catch (Exception ex) { var sex = new SagaException("Existing Saga Instance Exception", typeof(TSaga), typeof(TMessage), sagaId, ex); if (_log.IsErrorEnabled) { _log.Error(sex); } if (transaction.IsActive) { transaction.Rollback(); } throw sex; } }); } else { if (_log.IsDebugEnabled) { _log.DebugFormat("SAGA: {0} Ignoring Existing {1} for {2}", typeof(TSaga).ToFriendlyName(), sagaId, typeof(TMessage).ToFriendlyName()); } } } if (transaction.IsActive) { transaction.Commit(); } } }
public void Consume(IConsumeContext <IMessage> message) { Console.WriteLine("Recieved: {0}", message.Message.Text); }
public IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(IConsumeContext <TMessage> context, Guid sagaId, InstanceHandlerSelector <T, TMessage> selector, ISagaPolicy <T, TMessage> policy) where TMessage : class { return(_repository.GetSaga(context, sagaId, selector, policy) .Select(consumer => (Action <IConsumeContext <TMessage> >)(x => { IActivationBlock activationBlock = _kernel.BeginBlock(); try { consumer(x); } finally { activationBlock.Dispose(); } }))); }
public void PostDispatch(IConsumeContext context) { _afterConsume(); }
public void PreDispatch(IConsumeContext context) { _beforeConsume(); }
public void Consume(IConsumeContext<RequestVote> message) { throw new NotImplementedException(); }
public void Consume(IConsumeContext<Heartbeat> message) { throw new NotImplementedException(); }
public void Consume(IConsumeContext<VoteAgainst> message) { }
public void Consume(IConsumeContext<Heartbeat> message) { _behavior.Consume(message); }
public void Consume(IConsumeContext <IAdPriceChanged> message) { //throw new NotImplementedException(); }
public void Respond(IConsumeContext<Input> context) { throw _expectedException; }
public void PreDispatch(IConsumeContext context) { MessageScope.BeginScope(); }
/// <summary> /// Forwards the message to the endpoint /// </summary> /// <typeparam name="T"></typeparam> /// <param name="endpoint">The destination endpoint to which the message should be sent</param> /// <param name="context">The message context</param> public static void Forward <T>(this IEndpoint endpoint, IConsumeContext <T> context) where T : class { endpoint.Send(context.Message, x => x.ForwardUsingOriginalContext(context)); }
public void PostDispatch(IConsumeContext context) { MessageScope.EndScope(); }
public void Consume(IConsumeContext <ISecureCommand <IBusinessCommand> > context) { CommandReceived.Set(context.Message.Credentials); }
IEnumerable <Action <IConsumeContext <InitiateSimpleSaga> > > GetHandlers(TestSaga instance, IConsumeContext <InitiateSimpleSaga> context) { yield return(x => instance.RaiseEvent(TestSaga.Initiate, x.Message)); }
void Consume(IConsumeContext<SubscriptionRefresh> context) { var subscriptionUri = _subscriptionEndpoint.Address.Uri.AbsoluteUri; if(_subscriptionEndpoint.Address.Uri.Query.Length > 0) subscriptionUri = subscriptionUri.Replace(_subscriptionEndpoint.Address.Uri.Query, ""); var sourceUri = context.SourceAddress.AbsoluteUri; if (context.SourceAddress.Query.Length > 0) sourceUri = sourceUri.Replace(context.SourceAddress.Query, ""); if (subscriptionUri.Equals(sourceUri)) { if (_log.IsDebugEnabled) _log.DebugFormat("SubscriptionRefresh received, setting ready event"); _ready.Set(); } else { if (_log.IsErrorEnabled) _log.ErrorFormat("SubscriptionRefresh source address invalid: {0} (expected {1})", sourceUri, subscriptionUri); } }
static void DefaultHandler(IConsumeContext <TMessage> bus, TMessage message) { }
public void Consume(IConsumeContext<VoteAgainst> message) { _behavior.Consume(message); }
public void Consume(IConsumeContext<VoteFor> message) { _behavior.Consume(message); }
public IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(IConsumeContext <TMessage> context, Guid sagaId, InstanceHandlerSelector <TSaga, TMessage> selector, ISagaPolicy <TSaga, TMessage> policy) where TMessage : class { bool needToLeaveSagas = true; Monitor.Enter(_sagas); try { TSaga instance = _sagas[sagaId]; if (instance == null) { if (policy.CanCreateInstance(context)) { instance = policy.CreateInstance(context, sagaId); _sagas.Add(instance); lock (instance) { Monitor.Exit(_sagas); needToLeaveSagas = false; yield return(x => { if (_log.IsDebugEnabled) { _log.DebugFormat("SAGA: {0} Creating New {1} for {2}", typeof(TSaga).ToFriendlyName(), sagaId, typeof(TMessage).ToFriendlyName()); } try { foreach (var callback in selector(instance, x)) { callback(x); } if (policy.CanRemoveInstance(instance)) { _sagas.Remove(instance); } } catch (Exception ex) { var sex = new SagaException("Create Saga Instance Exception", typeof(TSaga), typeof(TMessage), sagaId, ex); if (_log.IsErrorEnabled) { _log.Error(sex); } throw sex; } }); } } else { if (_log.IsDebugEnabled) { _log.DebugFormat("SAGA: {0} Ignoring Missing {1} for {2}", typeof(TSaga).ToFriendlyName(), sagaId, typeof(TMessage).ToFriendlyName()); } } } else { if (policy.CanUseExistingInstance(context)) { Monitor.Exit(_sagas); needToLeaveSagas = false; lock (instance) { yield return(x => { if (_log.IsDebugEnabled) { _log.DebugFormat("SAGA: {0} Using Existing {1} for {2}", typeof(TSaga).ToFriendlyName(), sagaId, typeof(TMessage).ToFriendlyName()); } try { foreach (var callback in selector(instance, x)) { callback(x); } if (policy.CanRemoveInstance(instance)) { _sagas.Remove(instance); } } catch (Exception ex) { var sex = new SagaException("Existing Saga Instance Exception", typeof(TSaga), typeof(TMessage), sagaId, ex); if (_log.IsErrorEnabled) { _log.Error(sex); } throw sex; } }); } } else { if (_log.IsDebugEnabled) { _log.DebugFormat("SAGA: {0} Ignoring Existing {1} for {2}", typeof(TSaga).ToFriendlyName(), sagaId, typeof(TMessage).ToFriendlyName()); } } } } finally { if (needToLeaveSagas) { Monitor.Exit(_sagas); } } }
public void Consume(IConsumeContext<VoteFor> message) { }
static IEnumerable <Action <IConsumeContext <TMessage> > > GetHandlers(TSaga instance, IConsumeContext <TMessage> context) { yield return(x => { instance.Bus = context.Bus; context.BaseContext.NotifyConsume(context, typeof(TSaga).ToShortTypeName(), instance.CorrelationId.ToString()); using (x.CreateScope()) { instance.Consume(x.Message); } }); }
public void Consume(IConsumeContext<VoteAgainst> message) { throw new System.NotImplementedException(); }
public void Consume(IConsumeContext <PoisonMessage> context) { Console.WriteLine("Processing poison message..."); throw new NotImplementedException(); }
static IEnumerable <Action <IConsumeContext <TMessage> > > GetHandlers(StateMachine <TInstance> stateMachine, TInstance instance, IConsumeContext <TMessage> context, Event <TMessage> @event) { State <TInstance> currentState = stateMachine.InstanceStateAccessor.Get(instance); IEnumerable <Event> nextEvents = stateMachine.NextEvents(currentState); if (nextEvents.Contains(@event)) { yield return(x => { instance.Bus = context.Bus; context.BaseContext.NotifyConsume(context, typeof(TInstance).ToShortTypeName(), instance.CorrelationId.ToString()); using (x.CreateScope()) stateMachine.RaiseEvent(instance, @event, x.Message); }); } else { _log.DebugFormat("{0} {1} in {2} does not accept {3}", stateMachine.GetType().Name, instance.CorrelationId, currentState.Name, @event.Name); } }
public bool TryGetContext <T>(out IConsumeContext <T> context) where T : class { throw CreateException(); }
public void Consume(IConsumeContext <Heartbeat> context) { // do nothing, we're stopped, so bugger off }
public void Consume(IConsumeContext <RequestVote> context) { context.Respond <VoteAgainst>(new VoteAgainstResponse(_state.CurrentTerm)); }
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 void Consume(IConsumeContext <VoteFor> message) { }
public static IDisposable CreateScope <T>(this IConsumeContext <T> context) where T : class { return(ContextScope.FromConsumeContext(context)); }
public void Consume(IConsumeContext <VoteAgainst> message) { }
IEnumerable <Action <IConsumeContext <TMessage> > > Selector(TConsumer instance, IConsumeContext <TMessage> messageContext) { bool accept; using (messageContext.CreateScope()) { accept = instance.Accept(messageContext.Message); } if (accept) { yield return(context => { context.BaseContext.NotifyConsume(context, typeof(TConsumer).ToShortTypeName(), null); using (context.CreateScope()) { instance.Consume(context.Message); } }); } }
public void Consume(IConsumeContext <SubmitOrder> context) { }
public void Respond(IConsumeContext<Input> context) { Thread.Sleep(TimeSpan.FromSeconds(2)); context.Respond(new Output { Id = context.Message.Id }); }
public void Consume(IConsumeContext<RequestVote> context) { context.Respond<VoteAgainst>(new VoteAgainstResponse(_state.CurrentTerm)); }
private async Task ProcessProcessManagerHandlers(byte[] objectMessage, Type type, IConsumeContext context) { IProcessManagerFinder processManagerFinder = Configuration.GetProcessManagerFinder(); var processManagerProcessor = _container.GetInstance <IProcessManagerProcessor>(new Dictionary <string, object> { { "container", _container }, { "processManagerFinder", processManagerFinder } }); MethodInfo processManagerProcessorMethod = processManagerProcessor.GetType().GetMethod("ProcessMessage"); MethodInfo genericProcessManagerProcessorMethod = processManagerProcessorMethod.MakeGenericMethod(type); await(Task) genericProcessManagerProcessorMethod.Invoke(processManagerProcessor, new object[] { Encoding.UTF8.GetString(objectMessage), context }); }
public void Consume(IConsumeContext <ValidRequest> context) { Debug.WriteLine("Request Handled"); context.Respond(new Replay()); }
public IEnumerable <Action <IConsumeContext <TMessage> > > Enumerate(IConsumeContext <TMessage> context) { return(_consumerFactory.GetConsumer(context, Selector)); }
public IEnumerable <Action <IConsumeContext <TMessage> > > GetConsumer <TMessage>( IConsumeContext <TMessage> context, InstanceHandlerSelector <TConsumer, TMessage> selector) where TMessage : class { return(_delegate.GetConsumer(context, selector)); }
void ReportConsumerCount(IConsumeContext context, int count) { var message = new MessageConsumed { Context = context, ConsumeCount = count, }; _eventChannel.Send(message); }
private IEnumerable<Action<IConsumeContext<InitiateSimpleSaga>>> GetHandlers( TestSaga instance, IConsumeContext<InitiateSimpleSaga> context) { yield return x => instance.RaiseEvent(TestSaga.Initiate, x.Message); }
public void Consume(IConsumeContext <InvalidRequest> message) { Debug.WriteLine("Request Handled"); throw new InvalidOperationException("Some Invalid Request!"); }
public void Consume(IConsumeContext<RequestVote> message) { _behavior.Consume(message); }