public SagaStateMachineMessageSinkFactory(ISubscriberContext context, ISagaPolicyFactory policyFactory)
{
_context = context;
_policyFactory = policyFactory;
_bus = _context.Data as IServiceBus;
_repository = _context.Builder.GetInstance <ISagaRepository <TSaga> >();
}
protected virtual UnsubscribeAction Connect <TComponent, TMessage>(ISubscriberContext context)
where TMessage : class
where TComponent : class, Observes <TMessage, TComponent>, ISaga
{
MessageRouterConfigurator routerConfigurator = MessageRouterConfigurator.For(context.Pipeline);
var router = routerConfigurator.FindOrCreate <TMessage>();
var instance = (Observes <TMessage, TComponent>) FastActivator <TComponent> .Create(Guid.Empty);
Expression <Func <TComponent, TMessage, bool> > selector = instance.GetBindExpression();
var repository = context.Builder.GetInstance <ISagaRepository <TComponent> >();
var policy = new ExistingSagaPolicy <TComponent, TMessage>(x => false);
var sink = new PropertySagaMessageSink <TComponent, TMessage>(context, context.Data as IServiceBus, repository, policy, selector);
if (sink == null)
{
throw new ConfigurationException("Could not build the message sink for " + typeof(TComponent).FullName);
}
var result = router.Connect(sink);
UnsubscribeAction remove = context.SubscribedTo <TMessage>();
return(() => result() && (router.SinkCount == 0) && remove());
}
protected virtual UnsubscribeAction Connect <TMessage>(ISubscriberContext context, Consumes <TMessage> .All consumer)
where TMessage : class
{
var sink = new InstanceMessageSink <TMessage>(message => consumer.Consume);
return(context.Pipeline.ConnectToRouter(sink, () => context.SubscribedTo <TMessage>()));
}
protected virtual UnsubscribeAction Connect <TComponent, TMessage>(ISubscriberContext context)
where TMessage : class
where TComponent : class, Consumes <TMessage> .Selected
{
var sink = new SelectedComponentMessageSink <TComponent, TMessage>(context);
return(context.Pipeline.ConnectToRouter(sink, () => context.SubscribedTo <TMessage>()));
}
public CorrelatedSagaMessageSink(ISubscriberContext context,
IServiceBus bus,
ISagaRepository <TSaga> repository,
ISagaPolicy <TSaga, TMessage> policy)
: base(context, bus, repository, policy)
{
_selector = CreateCorrelatedSelector();
}
public PropertySagaMessageSink(ISubscriberContext context,
IServiceBus bus,
ISagaRepository <TSaga> repository,
ISagaPolicy <TSaga, TMessage> policy,
Expression <Func <TSaga, TMessage, bool> > selector)
: base(context, bus, repository, policy)
{
Selector = selector;
}
protected virtual UnsubscribeAction Connect <TMessage>(ISubscriberContext context, Consumes <TMessage> .Selected consumer)
where TMessage : class
{
var sink = new InstanceMessageSink <TMessage>(message =>
{
// rock it
return(consumer.Accept(message) ? (Action <TMessage>)consumer.Consume : null);
});
return(context.Pipeline.ConnectToRouter(sink, () => context.SubscribedTo <TMessage>()));
}
public CorrelatedSagaStateMachineMessageSink(ISubscriberContext context,
IServiceBus bus,
ISagaRepository <TSaga> repository,
ISagaPolicy <TSaga, TMessage> policy,
DataEvent <TSaga, TMessage> dataEvent)
: base(context, bus, repository, policy)
{
_dataEvent = dataEvent;
_selector = CreateCorrelatedSelector();
}
private UnsubscribeAction ConnectToSink <TSaga, TMessage>(ISubscriberContext context, ISagaWorker <TSaga> worker, DataEvent <TSaga, TMessage> eevent, IEnumerable <State> states)
where TSaga : SagaStateMachine <TSaga>, ISaga
where TMessage : class
{
var factory = new SagaStateMachineMessageSinkFactory <TSaga, TMessage>(context, _policyFactory);
IPipelineSink <TMessage> sink = factory.Create(eevent, states);
var workerSink = new SagaWorkerMessageSink <TSaga, TMessage>(worker, sink);
return(context.Pipeline.ConnectToRouter(workerSink, () => context.SubscribedTo <Distributed <TMessage> >()));
}
public PropertySagaStateMachineMessageSink(ISubscriberContext context,
IServiceBus bus,
ISagaRepository <TSaga> repository,
ISagaPolicy <TSaga, TMessage> policy,
Expression <Func <TSaga, TMessage, bool> > selector,
DataEvent <TSaga, TMessage> dataEvent)
: base(context, bus, repository, policy)
{
Selector = selector;
DataEvent = dataEvent;
}
protected virtual UnsubscribeAction ConnectWorker <TComponent, TMessage>(ISubscriberContext context, Consumes <Distributed <TMessage> > .Selected consumer)
where TComponent : Consumes <Distributed <TMessage> > .Selected
where TMessage : class
{
var sink = new WorkerMessageSink <Distributed <TMessage> >(message =>
{
// rock it
return(consumer.Accept(message) ? (Action <Distributed <TMessage> >)consumer.Consume : null);
});
return(context.Pipeline.ConnectToRouter(sink, () => context.SubscribedTo <Distributed <TMessage> >()));
}
protected SagaMessageSinkBase(ISubscriberContext context,
IServiceBus bus,
ISagaRepository <TSaga> repository,
ISagaPolicy <TSaga, TMessage> policy)
{
Repository = repository;
Builder = context.Builder;
Bus = bus;
Policy = policy;
SetBuilder = GetSetBuilderAction();
}
protected virtual UnsubscribeAction Connect <TMessage, TKey>(ISubscriberContext context, Consumes <TMessage> .For <TKey> consumer)
where TMessage : class, CorrelatedBy <TKey>
{
var correlatedConfigurator = CorrelatedMessageRouterConfigurator.For(context.Pipeline);
var router = correlatedConfigurator.FindOrCreate <TMessage, TKey>();
UnsubscribeAction result = router.Connect(consumer.CorrelationId, new InstanceMessageSink <TMessage>(message => consumer.Consume));
UnsubscribeAction remove = context.SubscribedTo <TMessage, TKey>(consumer.CorrelationId);
return(() => result() && remove());
}
protected virtual UnsubscribeAction Connect <TMessage, TBatchId>(ISubscriberContext context, Consumes <Batch <TMessage, TBatchId> > .All consumer)
where TMessage : class, BatchedBy <TBatchId>
{
var configurator = BatchMessageRouterConfigurator.For(context.Pipeline);
var router = configurator.FindOrCreate <TMessage, TBatchId>();
var result = router.Connect(new InstanceMessageSink <Batch <TMessage, TBatchId> >(message => consumer.Consume));
UnsubscribeAction remove = context.SubscribedTo <TMessage>();
return(() => result() && (router.SinkCount == 0) && remove());
}
public override IEnumerable <UnsubscribeAction> Subscribe <TComponent>(ISubscriberContext context, TComponent instance)
{
Func <BatchSubscriber, ISubscriberContext, object, UnsubscribeAction> invoker = GetInvokerForInstance <TComponent>();
if (invoker == null)
{
yield break;
}
foreach (Func <BatchSubscriber, ISubscriberContext, object, UnsubscribeAction> action in invoker.GetInvocationList())
{
yield return(action(this, context, instance));
}
}
public override IEnumerable <UnsubscribeAction> Subscribe <TComponent>(ISubscriberContext context)
{
if (!typeof(TComponent).IsSagaStateMachine())
{
yield break;
}
var results = this.FastInvoke <SagaStateMachineSubscriber, IEnumerable <UnsubscribeAction> >(new[] { typeof(TComponent) }, "Connect", context);
foreach (var unsubscribeAction in results)
{
yield return(unsubscribeAction);
}
}
public override IEnumerable <UnsubscribeAction> Subscribe <TComponent>(ISubscriberContext context)
{
Func <TInterceptor, ISubscriberContext, UnsubscribeAction> invoker = GetInvoker <TComponent>();
if (invoker == null)
{
yield break;
}
foreach (Func <TInterceptor, ISubscriberContext, UnsubscribeAction> action in invoker.GetInvocationList())
{
yield return(action(this.TranslateTo <TInterceptor>(), context));
}
}
protected virtual IEnumerable <UnsubscribeAction> Connect <TComponent>(ISubscriberContext context)
where TComponent : SagaStateMachine <TComponent>, ISaga
{
var component = FastActivator <TComponent> .Create(CombGuid.Generate());
var inspector = new SagaStateMachineEventInspector <TComponent>();
component.Inspect(inspector);
var subscriber = new SagaEventSubscriber <TComponent>(context, new SagaPolicyFactory());
foreach (var result in inspector.GetResults())
{
yield return(subscriber.Connect(result.SagaEvent.MessageType, result.SagaEvent.Event, result.States));
}
}
public IResult Implement(ISubscriberContext context)
{
try
{
context.LogService.Info("Started EventProcessor...");
var blobUri = context.GetMessage <BlobUri>();
context.LogService.Info("Blob URI = " + blobUri.Uri);
var blob = new CloudBlockBlob(new Uri(blobUri.Uri), new StorageCredentials(AccountName, AccountKey));
string blobData = blob.DownloadText();
context.LogService.Info("Got blob data");
AmazonDynamoDBClient client = new AmazonDynamoDBClient(
new BasicAWSCredentials(AWSAccessKey, AWSSecretKey),
RegionEndpoint.GetBySystemName(AWSRegion));
Table table = Table.LoadTable(client, TableName);
var insertedRecords = blobData
.Split('\n')
.Where(s => s.IndexOf(',') > -1)
.Select(line => new Document
{
["id"] = line.Substring(0, line.IndexOf(',')),
["data"] = line.Substring(line.IndexOf(',') + 1)
})
.Select(document => table.PutItem(document))
.Count();
context.LogService.Info($"Inserted {insertedRecords} records");
blob.Delete();
context.LogService.Info("deleted blob.");
return(context.CreateSuccessResult());
}
catch (Exception e)
{
return(context.CreateErrorResult(e.Message));
}
}
public override IEnumerable <UnsubscribeAction> Subscribe <TComponent>(ISubscriberContext context, TComponent instance)
{
Type distributorInterface = typeof(TComponent).GetInterfaces()
.Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(ISagaWorker <>))
.SingleOrDefault();
if (distributorInterface != null)
{
Type sagaType = distributorInterface.GetGenericArguments().First();
var argumentTypes = new[] { typeof(TComponent), sagaType };
var results = this.FastInvoke <SagaDistributorSubscriber, IEnumerable <UnsubscribeAction> >(argumentTypes, "ConnectSinks", context, instance);
foreach (UnsubscribeAction result in results)
{
yield return(result);
}
}
yield break;
}
private IEnumerable <UnsubscribeAction> ConnectSinks <TComponent, TSaga>(ISubscriberContext context, TComponent instance)
where TComponent : ISagaWorker <TSaga>
where TSaga : SagaStateMachine <TSaga>, ISaga
{
var saga = FastActivator <TSaga> .Create(CombGuid.Generate());
var inspector = new SagaStateMachineEventInspector <TSaga>();
saga.Inspect(inspector);
foreach (var result in inspector.GetResults())
{
Type distributedType = typeof(Distributed <>).MakeGenericType(result.SagaEvent.MessageType);
if (!context.HasMessageTypeBeenDefined(distributedType))
{
context.MessageTypeWasDefined(distributedType);
yield return(ConnectSink(context, instance, result.SagaEvent.MessageType, result.SagaEvent.Event, result.States));
}
}
}
protected virtual UnsubscribeAction Connect <TComponent, TMessage>(ISubscriberContext context)
where TMessage : class, CorrelatedBy <Guid>
where TComponent : class, Orchestrates <TMessage>, ISaga
{
MessageRouterConfigurator routerConfigurator = MessageRouterConfigurator.For(context.Pipeline);
var router = routerConfigurator.FindOrCreate <TMessage>();
var repository = context.Builder.GetInstance <ISagaRepository <TComponent> >();
var policy = new ExistingSagaPolicy <TComponent, TMessage>(x => false);
var sink = new CorrelatedSagaMessageSink <TComponent, TMessage>(context, context.Data as IServiceBus, repository, policy);
if (sink == null)
{
throw new ConfigurationException("Could not build the message sink for " + typeof(TComponent).FullName);
}
var result = router.Connect(sink);
UnsubscribeAction remove = context.SubscribedTo <TMessage>();
return(() => result() && (router.SinkCount == 0) && remove());
}
public override IEnumerable <UnsubscribeAction> Subscribe <TComponent>(ISubscriberContext context, TComponent instance)
{
Type distributorInterface = typeof(TComponent).GetInterfaces()
.Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IDistributor <>))
.SingleOrDefault();
if (distributorInterface != null)
{
Type messageType = distributorInterface.GetGenericArguments().First();
if (!context.HasMessageTypeBeenDefined(messageType))
{
context.MessageTypeWasDefined(messageType);
yield return(this.FastInvoke <DistributorSubscriber, UnsubscribeAction>(new[] { typeof(TComponent), messageType }, "ConnectDistributor", context, instance));
}
}
distributorInterface = typeof(TComponent).GetInterfaces()
.Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IWorker <>))
.SingleOrDefault();
if (distributorInterface != null)
{
Type messageType = distributorInterface.GetGenericArguments().First();
Type distributedMessageType = typeof(Distributed <>).MakeGenericType(messageType);
if (!context.HasMessageTypeBeenDefined(distributedMessageType))
{
context.MessageTypeWasDefined(distributedMessageType);
yield return(this.FastInvoke <DistributorSubscriber, UnsubscribeAction>(new[] { typeof(TComponent), messageType }, "ConnectWorker", context, instance));
}
}
}
public SubscriberRepository(ISubscriberContext context)
{
this.context = context;
}
public override IEnumerable <UnsubscribeAction> Subscribe <TComponent>(ISubscriberContext context)
{
yield break;
}
public NotificationsController()
{
_db = new SubscriberContext();
}
public NotificationsController(ISubscriberContext db)
{
_db = db;
}
public NotificationsController(ISubscriberContext db)
{
_db = db;
}
public NotificationsController()
{
_db = new SubscriberContext();
}
public ComponentMessageSink(ISubscriberContext context)
{
_builder = context.Builder;
}
public abstract IEnumerable <UnsubscribeAction> Subscribe <TComponent>(ISubscriberContext context, TComponent instance);
private UnsubscribeAction ConnectSink <TSaga>(ISubscriberContext context, ISagaWorker <TSaga> worker, Type messageType, Event @event, IEnumerable <State> states)
{
return(this.FastInvoke <SagaDistributorSubscriber, UnsubscribeAction>(new[] { typeof(TSaga), messageType }, "ConnectToSink", context, worker, @event, states));
}
