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);
        }
Example #11
0
 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));
 }
Example #14
0
        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();
                    }
                }
        }
Example #15
0
 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);
 }
Example #23
0
 public void Consume(IConsumeContext <IAdPriceChanged> message)
 {
     //throw new NotImplementedException();
 }
 public void Respond(IConsumeContext<Input> context)
 {
     throw _expectedException;
 }
 public void PostDispatch(IConsumeContext context)
 {
     _afterConsume();
 }
 public void PreDispatch(IConsumeContext context)
 {
     MessageScope.BeginScope();
 }
Example #27
0
 /// <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();
 }
Example #29
0
 public void Consume(IConsumeContext <ISecureCommand <IBusinessCommand> > context)
 {
     CommandReceived.Set(context.Message.Credentials);
 }
Example #30
0
 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);
                
            }
        }
Example #32
0
 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)
 {
 }
Example #37
0
        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();
 }
Example #39
0
        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();
 }
Example #42
0
 public void Consume(IConsumeContext <Heartbeat> context)
 {
     // do nothing, we're stopped, so bugger off
 }
 public void PreDispatch(IConsumeContext context)
 {
     _beforeConsume();
 }
Example #44
0
 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));
        }
Example #46
0
 public void Consume(IConsumeContext <VoteFor> message)
 {
 }
Example #47
0
 public static IDisposable CreateScope <T>(this IConsumeContext <T> context)
     where T : class
 {
     return(ContextScope.FromConsumeContext(context));
 }
Example #48
0
 public void Consume(IConsumeContext <VoteAgainst> message)
 {
 }
Example #49
0
        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);
                    }
                });
            }
        }
Example #50
0
 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));
 }
Example #53
0
        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));
 }
Example #56
0
 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);
 }