public IEnumerable <Action <IConsumeContext <TMessage> > > GetConsumer <TMessage>(
IConsumeContext <TMessage> context, InstanceHandlerSelector <TConsumer, TMessage> selector)
where TMessage : class
{
TConsumer consumer = _factoryMethod();
if (consumer == null)
{
throw new ConfigurationException(string.Format("Unable to resolve consumer type '{0}'.", typeof(TConsumer)));
}
try
{
foreach (var handler in selector(consumer, context))
{
yield return(handler);
}
}
finally
{
var disposable = consumer as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
GetConsumer <TMessage>(IConsumeContext <TMessage> context,
InstanceHandlerSelector <TConsumer, TMessage> selector)
where TMessage : class
{
IEnumerable <Action <IConsumeContext <TMessage> > > consumers = _consumerFactory.GetConsumer(context, selector);
foreach (var action in consumers)
{
Action <IConsumeContext <TMessage> > consumer = action;
yield return(message =>
{
var received = new ReceivedMessageImpl <TMessage>(message);
try
{
consumer(message);
}
catch (Exception ex)
{
received.SetException(ex);
}
finally
{
_received.Add(received);
}
});
}
}
public void Setup()
{
_repository = new InMemorySagaRepository <SimpleSaga>();
var initiatePolicy = new InitiatingSagaPolicy <SimpleSaga, InitiateSimpleSaga>(x => x.CorrelationId, x => false);
_sagaId = CombGuid.Generate();
_initiateSaga = new InitiateSimpleSaga {
CorrelationId = _sagaId, Name = "Chris"
};
var context = _initiateSaga.ToConsumeContext();
_repository.GetSaga(context, _sagaId,
(i, c) => InstanceHandlerSelector.ForInitiatedBy <SimpleSaga, InitiateSimpleSaga>(i), initiatePolicy)
.Each(x => x(context));
_initiateOtherSaga = new InitiateSimpleSaga {
CorrelationId = _otherSagaId, Name = "Dru"
};
_otherSagaId = Guid.NewGuid();
context = _initiateOtherSaga.ToConsumeContext();
_repository.GetSaga(context, _otherSagaId,
(i, c) => InstanceHandlerSelector.ForInitiatedBy <SimpleSaga, InitiateSimpleSaga>(i), initiatePolicy)
.Each(x => x(context));
_observeSaga = new ObservableSagaMessage {
Name = "Chris"
};
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetConsumer <TMessage>(
IConsumeContext <TMessage> context, InstanceHandlerSelector <T, TMessage> selector)
where TMessage : class
{
var activationBlock = _kernel.BeginBlock();
var consumer = activationBlock.Get <T>();
if (consumer == null)
{
throw new ConfigurationException(string.Format("Unable to resolve type '{0}' from container: ", typeof(T)));
}
try
{
IEnumerable <Action <IConsumeContext <TMessage> > > result = selector(consumer, context);
foreach (var handler in result)
{
yield return(handler);
}
}
finally
{
activationBlock.Dispose();
}
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetConsumer <TMessage>(
IConsumeContext <TMessage> context, InstanceHandlerSelector <T, TMessage> selector)
where TMessage : class
{
using (_container.BeginScope())
{
var consumer = _container.Resolve <T>();
if (consumer == null)
{
throw new ConfigurationException(string.Format("Unable to resolve type '{0}' from container: ", typeof(T)));
}
try
{
foreach (var handler in selector(consumer, context))
{
yield return(handler);
}
}
finally
{
_container.Release(consumer);
}
}
}
protected SagaMessageSinkBase(ISagaRepository <TSaga> repository, ISagaPolicy <TSaga, TMessage> policy,
ISagaLocator <TMessage> locator, InstanceHandlerSelector <TSaga, TMessage> selector)
{
_selector = selector;
_locator = locator;
Repository = repository;
Policy = policy;
}
/// <summary> Enumerates get saga in this collection. </summary>
/// <exception cref="ArgumentNullException"> Thrown when one or more required arguments are null. </exception>
/// <exception cref="SagaException"> Thrown when a saga error condition occurs. </exception>
/// <typeparam name="TMessage"> Type of the message. </typeparam>
/// <param name="context"> The context. </param>
/// <param name="sagaId"> Identifier for the saga. </param>
/// <param name="selector"> The selector. </param>
/// <param name="policy"> The policy. </param>
/// <returns> An enumerator that allows foreach to be used to process get saga< t message> in this collection. </returns>
public IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(
IConsumeContext <TMessage> context,
Guid sagaId,
InstanceHandlerSelector <TSaga, TMessage> selector,
ISagaPolicy <TSaga, TMessage> policy) where TMessage : class
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (selector == null)
{
throw new ArgumentNullException("selector");
}
if (policy == null)
{
throw new ArgumentNullException("policy");
}
TSaga instance = Queryable.FirstOrDefault(x => x.CorrelationId == sagaId);
if (instance == null)
{
if (policy.CanCreateInstance(context))
{
yield return(CreateNewSagaAction(sagaId, selector, policy));
}
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(UseExistingSagaAction(sagaId, selector, policy, instance));
}
else
{
if (Log.IsDebugEnabled)
{
Log.DebugFormat(
"SAGA: {0} Ignoring Existing {1} for {2}",
typeof(TSaga).ToFriendlyName(),
sagaId,
typeof(TMessage).ToFriendlyName());
}
}
}
}
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 => {
using (_container.BeginLifetimeScope())
consumer(x);
})));
}
/// <summary>
/// Creates new saga action.
/// </summary>
/// <exception cref="SagaException"> Thrown when a saga error condition occurs.</exception>
/// <typeparam name="TMessage"> Type of the message.</typeparam>
/// <param name="sagaId"> Identifier for the saga.</param>
/// <param name="selector"> The selector.</param>
/// <param name="policy"> The policy.</param>
/// <returns>
/// The new new saga action< t message>
/// </returns>
Action <IConsumeContext <TMessage> > CreateNewSagaAction <TMessage>(
Guid sagaId,
InstanceHandlerSelector <TSaga, TMessage> selector,
ISagaPolicy <TSaga, TMessage> policy)
where TMessage : class
{
return(x =>
{
if (Log.IsDebugEnabled)
{
Log.DebugFormat(
"SAGA: {0} Creating New {1} for {2}",
typeof(TSaga).ToFriendlyName(),
sagaId,
typeof(TMessage).ToFriendlyName());
}
try
{
TSaga instance = policy.CreateInstance(x, sagaId);
foreach (var callback in selector(instance, x))
{
callback(x);
}
if (!policy.CanRemoveInstance(instance))
{
Collection.Insert(instance, WriteConcern.Acknowledged);
}
else
{
Collection.Save(instance, WriteConcern.Acknowledged);
}
}
catch (Exception ex)
{
var sagaException = new SagaException(
"Create Saga Instance Exception",
typeof(TSaga),
typeof(TMessage),
sagaId,
ex);
if (Log.IsErrorEnabled)
{
Log.Error(sagaException);
}
throw sagaException;
}
});
}
/// <summary>
/// Use existing saga action.
/// </summary>
/// <exception cref="SagaException"> Thrown when a saga error condition occurs.</exception>
/// <typeparam name="TMessage"> Type of the message.</typeparam>
/// <param name="sagaId"> Identifier for the saga.</param>
/// <param name="selector"> The selector.</param>
/// <param name="policy"> The policy.</param>
/// <param name="instance"> The instance.</param>
/// <returns>
/// .
/// </returns>
Action <IConsumeContext <TMessage> > UseExistingSagaAction <TMessage>(
Guid sagaId,
InstanceHandlerSelector <TSaga, TMessage> selector,
ISagaPolicy <TSaga, TMessage> policy,
TSaga instance)
where TMessage : class
{
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))
{
Collection.Remove(
GetMongoQuery(Queryable.Where(q => q.CorrelationId == sagaId)),
RemoveFlags.Single,
WriteConcern.Acknowledged);
}
}
catch (Exception ex)
{
var sagaException = new SagaException(
"Existing Saga Instance Exception",
typeof(TSaga),
typeof(TMessage),
sagaId,
ex);
if (Log.IsErrorEnabled)
{
Log.Error(sagaException);
}
throw sagaException;
}
});
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetConsumer <TMessage>
(IConsumeContext <TMessage> context, InstanceHandlerSelector <T, TMessage> selector)
where TMessage : class
{
using (_container.BeginLifetimeScope()) {
T consumer = _container.GetInstance <T>();
if (consumer == null)
{
throw new ConfigurationException(string.Format("Unable to resolve type '{0}' from container: ", typeof(T)));
}
foreach (Action <IConsumeContext <TMessage> > action in selector(consumer, context))
{
yield return(action);
}
}
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetConsumer <TMessage>(
IConsumeContext <TMessage> context, InstanceHandlerSelector <T, TMessage> selector)
where TMessage : class
{
//lookup TMessage against all the types we loaded from the assembly we scanned and get back the handler
if (!_messageHandlerMap.ContainsKey(typeof(T)))
{
throw new InvalidOperationException(string.Format("There is no consumer registered to handle commands of type '{0}'.", typeof(T)));
}
var consumerType = _messageHandlerMap[typeof(TMessage)];
var consumerInstance = (T)Activator.CreateInstance(consumerType);
IEnumerable <Action <IConsumeContext <TMessage> > > result = selector(consumerInstance, context);
return(result);
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(IConsumeContext <TMessage> context, Guid sagaId,
InstanceHandlerSelector <TSaga, TMessage>
selector, ISagaPolicy <TSaga, TMessage> policy)
where TMessage : class
{
ISagaPolicy <TSaga, TMessage> sagaPolicy = new SagaPolicyTestDecorator <TSaga, TMessage>(policy, sagaId, _created);
InstanceHandlerSelector <TSaga, TMessage> interceptSelector = (s, c) =>
{
IEnumerable <Action <IConsumeContext <TMessage> > > result = selector(s, c);
return(DecorateSelector(s, result));
};
IEnumerable <Action <IConsumeContext <TMessage> > > consumers = _sagaRepository.GetSaga(context, sagaId, interceptSelector,
sagaPolicy);
foreach (var action in consumers)
{
Action <IConsumeContext <TMessage> > consumer = action;
yield return(message =>
{
var received = new ReceivedMessage <TMessage>(message);
try
{
consumer(message);
}
catch (Exception ex)
{
received.SetException(ex);
}
finally
{
_received.Add(received);
}
});
}
}
public void Setup()
{
_sagaId = NewId.NextGuid();
_repository = new InMemorySagaRepository <TestSaga>();
var initiatePolicy = new InitiatingSagaPolicy <TestSaga, InitiateSimpleSaga>(x => x.CorrelationId, x => false);
var message = new InitiateSimpleSaga(_sagaId);
IConsumeContext <InitiateSimpleSaga> context = message.ToConsumeContext();
_repository.GetSaga(context, message.CorrelationId,
(i, c) => InstanceHandlerSelector.ForDataEvent(i, TestSaga.Initiate), initiatePolicy)
.Each(x => x(context));
message = new InitiateSimpleSaga(NewId.NextGuid());
context = message.ToConsumeContext();
_repository.GetSaga(context, message.CorrelationId,
(i, c) => InstanceHandlerSelector.ForDataEvent(i, TestSaga.Initiate), initiatePolicy)
.Each(x => x(context));
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetConsumer <TMessage>(
IConsumeContext <TMessage> context, InstanceHandlerSelector <T, TMessage> selector)
where TMessage : class
{
using (var innerScope = _scope.BeginLifetimeScope(_name))
{
T consumer = null;
try
{
consumer = innerScope.Resolve <T>();
}
catch (Exception ex)
{
var message = "Could not resolve '{0}' from container '{1}'->'{2}'".FormatWith(typeof(T).Name, _scope.Tag, innerScope.Tag);
throw new ConfigurationException(message, ex);
}
foreach (var handler in selector(consumer, context))
{
yield return(handler);
}
}
}
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 IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(IConsumeContext <TMessage> context, Guid sagaId,
InstanceHandlerSelector <TSaga, TMessage> selector,
ISagaPolicy <TSaga, TMessage> policy) where TMessage : class
{
using (var db = dbProvider.Open())
using (var transaction = db.BeginTransaction())
{
TSaga instance = db.Get <TSaga>(sagaId, transaction);
Console.WriteLine("Got instance: {0}", instance == null ? "no instance" : instance.ToString());
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))
{
try
{
db.Insert(instance, transaction);
}
catch (Exception)
{
// if insert fails update
db.Update(instance, transaction);
}
}
}
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 is always active
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
{
Console.WriteLine("Have existing instance " + instance.ToString());
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))
{
db.Delete(instance, transaction);
}
else
{
db.Update(instance, transaction);
}
}
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 is always active
transaction.Rollback();
throw sex;
}
});
}
else
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("SAGA: {0} Ignoring Existing {1} for {2}", typeof(TSaga).ToFriendlyName(), sagaId,
typeof(TMessage).ToFriendlyName());
}
}
}
transaction.Commit();
}
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(IConsumeContext <TMessage> context,
Guid sagaId, InstanceHandlerSelector <TInstance, TMessage> selector, ISagaPolicy <TInstance, TMessage> policy)
where TMessage : class
{
return(_repository.GetSaga(context, sagaId, selector, policy));
}
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 IEnumerable <Action <IConsumeContext <TMessage> > > GetConsumer <TMessage>(
IConsumeContext <TMessage> context, InstanceHandlerSelector <TConsumer, TMessage> selector)
where TMessage : class
{
return(_delegate.GetConsumer(context, selector));
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(IConsumeContext <TMessage> context, Guid sagaId,
InstanceHandlerSelector <TSaga, TMessage> selector,
ISagaPolicy <TSaga, TMessage> policy)
where TMessage : class
{
return(_repository.GetSaga(context, sagaId, (saga, message) =>
{
_callback(saga);
return selector(saga, message);
}, policy));
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetConsumer <TMessage>(IConsumeContext <TMessage> context,
InstanceHandlerSelector <TConsumer, TMessage> selector)
where TMessage : class
{
yield return(x =>
{
_interceptor(() =>
{
foreach (var consumer in _consumerFactory.GetConsumer(context, selector))
{
consumer(x);
}
});
});
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(IConsumeContext <TMessage> context, Guid sagaId,
InstanceHandlerSelector <TSaga, TMessage> selector, ISagaPolicy <TSaga, TMessage> policy) where TMessage : class
{
using (CreateContainerScope(context))
{
foreach (var handler in _repository.GetSaga(context, sagaId, selector, policy))
{
yield return(handler);
}
}
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetConsumer <TMessage>(IConsumeContext <TMessage> context,
InstanceHandlerSelector
<RequestConsumer, TMessage> selector)
where TMessage : class
{
var consumer = new RequestConsumer(_bus);
IEnumerable <Action <IConsumeContext <TMessage> > > result = selector(consumer, context);
return(result);
}
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();
}
}
}
IEnumerable <Action <IConsumeContext <TMessage> > > IConsumerFactory <TConsumer> .GetConsumer <TMessage>(IConsumeContext <TMessage> context,
InstanceHandlerSelector <TConsumer, TMessage> selector)
{
using (ICodeSwitchContainerScope innerScope = CreateContainerScope(context))
{
TConsumer consumer;
if (!innerScope.TryResolve(out consumer))
{
throw new ConfigurationException(string.Format("The consumer type {0} could not be resolved from the container.",
typeof(TConsumer).ToShortTypeName()));
}
foreach (var handler in selector(consumer, context))
{
yield return(handler);
}
}
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(
IConsumeContext <TMessage> context,
Guid sagaId,
InstanceHandlerSelector <TSaga, TMessage> selector,
ISagaPolicy <TSaga, TMessage> policy) where TMessage : class
{
using (var session = this.documentStore.OpenSession())
{
session.Advanced.UseOptimisticConcurrency = true;
var instance = session.Load <TSaga>(sagaId);
if (instance == null)
{
if (policy.CanCreateInstance(context))
{
yield return(x =>
{
try
{
instance = policy.CreateInstance(x, sagaId);
foreach (var callback in selector(instance, x))
{
callback(x);
}
if (policy.CanRemoveInstance(instance))
{
return;
}
session.Store(instance);
session.SaveChanges();
}
catch (Exception ex)
{
var sex = new SagaException(
"Create Saga Instance Exception",
typeof(TSaga),
typeof(TMessage),
sagaId,
ex);
throw sex;
}
});
}
}
else
{
if (policy.CanUseExistingInstance(context))
{
yield return(x =>
{
try
{
const int NbtriesMax = 5;
foreach (var callback in selector(instance, x))
{
callback(x);
}
if (policy.CanRemoveInstance(instance))
{
session.Delete(instance);
}
try
{
session.SaveChanges();
}
catch (ConcurrencyException)
{
if (x.RetryCount <= NbtriesMax)
{
x.RetryLater();
}
else
{
throw;
}
}
}
catch (Exception ex)
{
var sex = new SagaException(
"Existing Saga Instance Exception",
typeof(TSaga),
typeof(TMessage),
sagaId,
ex);
throw sex;
}
});
}
}
}
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(IConsumeContext <TMessage> context,
Guid sagaId, InstanceHandlerSelector <TInstance, TMessage> selector, ISagaPolicy <TInstance, TMessage> policy)
where TMessage : class
{
var handlers = _repository.GetSaga(context, sagaId, selector, policy);
int handlerCount = 0;
foreach (var handler in handlers)
{
handlerCount++;
yield return(handler);
}
int retryLimit;
if (handlerCount == 0 && IsRetryEvent(context.Message, out retryLimit))
{
int attempts = context.RetryCount;
if (attempts < retryLimit)
{
yield return(msgContext =>
{
_log.DebugFormat("Queuing {0} {1} for retry {2}", typeof(TMessage).Name, context.MessageId, attempts + 1);
msgContext.RetryLater();
});
}
else
{
_log.DebugFormat("Retry limit for {0} {1} reached {2}", typeof(TMessage).Name, context.MessageId, attempts + 1);
}
}
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetConsumer <TMessage>(IConsumeContext <TMessage> context,
InstanceHandlerSelector <TConsumer, TMessage> selector)
where TMessage : class
{
foreach (var action in _consumerFactory.GetConsumer(context, selector))
{
Action <IConsumeContext <TMessage> > consumer = action;
yield return(x =>
{
DateTime startTime = DateTime.UtcNow;
Stopwatch timer = Stopwatch.StartNew();
try
{
consumer(x);
timer.Stop();
x.NotifyResourceUsageCompleted(x.Bus.Endpoint.Address.Uri, startTime, timer.Elapsed);
}
catch (Exception)
{
throw;
}
});
}
}
public IEnumerable <Action <IConsumeContext <TMessage> > > GetSaga <TMessage>(IConsumeContext <TMessage> context, Guid sagaId, InstanceHandlerSelector <TSaga, TMessage> selector, ISagaPolicy <TSaga, TMessage> policy) where TMessage : class
{
return(_inner.GetSaga(context, sagaId, (saga, message) =>
{
_context.InjectProperties(saga);
return selector(saga, message);
}, policy));
}
