public async void One_Run_Through_Pipeline_With_No_TransportMessage_Does_Nothing()
{
var messageSource = new TestMessageSource <TransportMessage>();
IIocManagement <TransportMessage> iocManagement =
new SimpleTestIocManagement(Guid.NewGuid());
// Initialize Ioc
IServiceCollection serviceCollection = iocManagement.CreateServiceCollection();
ServiceProvider rootServiceProvider = serviceCollection.BuildServiceProvider();
Either <IPipelineError, Tuple <TransportMessage, object> >
processedMessage = await MessagePipeline.Run(
messageSource,
new SimpleMessageTransform(),
rootServiceProvider,
iocManagement);
messageSource.AckCount.Should().Be(0);
rootServiceProvider.GetService <TestEventHandlerInvocationStats>()
.HandledEvents.Count.Should().Be(0);
processedMessage.BiIter(
right =>
{
"Should be right".AssertFail();
},
left => left.Should().BeOfType <NoTransportMessageAvailable>()
);
}
static void Main(string[] args)
{
//Create dependecies
var _elastic = new ElasticContext();
var iishelper = new IISLogHelper();
var receiver = new RabbitReceiver();
var pipeline = new MessagePipeline(_elastic, iishelper);
var correlationEngine = new CorrelationEngine(_elastic);
//Init
_elastic.Init();
Console.WriteLine("init");
Console.ReadKey();
// pipeline.OnReceiveMessage_Pipeline("IISConnector:2021-05-10 18:13:04 192.168.0.103 GET /Home/Bad1avLogin - 80 - 192.168.0.116 200 0 0 3");
// pipeline.OnReceiveMessage_Pipeline("IISConnector:2021-05-11 18:13:04 192.168.0.103 GET /Home/Bad3avLogin - 80 - 192.168.0.116 200 0 0 3");
// pipeline.OnReceiveMessage_Pipeline("IISConnector:2021-05-12 18:13:04 192.168.0.103 GET /Home/Bad4avLogin - 80 - 192.168.0.116 200 0 0 3");
//Start proccesses
Task.Run(() => correlationEngine.Start());
//receiver.onMessageReceived += pipeline.OnReceiveMessage_Pipeline;
// receiver.onMessageReceived += Receiver_onMessageReceived_InFile;
// receiver.onMessageReceived += Receiver_onMessageReceived_InConsole;
//receiver.Receive();
Console.ReadKey();
}
public async ValueTask <int> SendAsync(object message, params IPEndPoint[] ips)
{
if (ips == null)
{
throw new ArgumentNullException(nameof(ips));
}
var length = ips.Length;
if (length == 0)
{
throw new ArgumentNullException(nameof(ips));
}
using (var owner = MessagePipeline.Pack(0, message))
{
if (MemoryMarshal.TryGetArray <byte>(owner.Memory, out var buffer) == false)
{
return(0);
}
var tasks = new Task <int> [ips.Length];
var data = buffer.Array;
var count = buffer.Count;
for (int i = 0; i < length; ++i)
{
tasks[i] = this.Udp.SendAsync(data, count, ips[i]);
}
var retData = await Task.WhenAll(tasks);
return(retData.Sum());
}
}
private void StartExport(object sender, RoutedEventArgs e)
{
foreach (var userAccount in UserAccounts)
{
if (!String.IsNullOrWhiteSpace(userAccount.Username) && !String.IsNullOrWhiteSpace(userAccount.Password))
{
_pstWriter = new PstTarget(userAccount.Username + "@" + Server.Text, SaveFolder.Text);
_rawToMsgProcessor = new RawToMsgProcessor()
{
Name = userAccount.Username,
NextReader = _pstWriter
};
_imapExporter = new ImapExporter(userAccount.Username, userAccount.Password, Server.Text, SSL.IsChecked == true, TestOnlyCheckBox.IsChecked == true)
{
Provider = UseGmailCheckBox.IsChecked == true ? MailProvider.GmailImap : MailProvider.DefaultImap,
NextReader = _rawToMsgProcessor
};
var importer = new MessagePipeline(new List <IMessageProcessor>()
{
_imapExporter, _rawToMsgProcessor, _pstWriter
});
userAccount.StartExporter(importer);
}
}
}
/// <summary>
/// Initializes a new instance of <see cref="GraphQLWebSocketProtocol"/>
/// </summary>
/// <param name="socketClient">
/// The client where this protocol is using
/// </param>
public GraphQLWebSocketProtocol(ISocketClient socketClient)
{
_socketClient = socketClient ??
throw new ArgumentNullException(nameof(socketClient));
_receiver = new MessagePipeline(socketClient, ProcessAsync);
_sender = new SynchronizedMessageWriter(socketClient);
}
public void PipelineBuilding()
{
var builder = MockRepository.GenerateMock <IObjectBuilder>();
MessagePipeline pipeline = MessagePipelineConfigurator.CreateDefault(builder, null);
pipeline.Subscribe <MetadataConsumer>();
pipeline.Subscribe <MetadataPConsumer>();
PipelineViewer.Trace(pipeline);
}
public static MessagePipeline <Message> AsPipeline(this Connection connection)
{
var pipeline = new MessagePipeline <Message>();
connection.OnMessage += async(_, message) =>
{
await pipeline.FillPipe(message).ConfigureAwait(false);
};
return(pipeline);
}
public async void Multiple_Runs_Through_Pipeline_Processes_Provided_Messages()
{
int runCount = 10;
var scopeIds = Enumerable.Range(0, runCount)
.Select(i => Guid.NewGuid())
.ToList();
var testEvents = Enumerable.Range(0, runCount)
.Select(i => new TestEvent(Guid.NewGuid())).ToList();
var transportEvents = testEvents
.Select(t => new TransportMessage(t))
.ToArray();
List <Tuple <Guid, TransportMessage, TestEvent> > expectedHandledEvents =
scopeIds
.Zip(transportEvents)
.Zip(testEvents, (a, b) => Tuple.Create(a.Item1, a.Item2, b))
.ToList();
var messageSource = new TestMessageSource <TransportMessage>(transportEvents);
IIocManagement <TransportMessage> iocManagement =
new SimpleTestIocManagement(scopeIds.ToArray());
// Initialize Ioc
IServiceCollection serviceCollection = iocManagement.CreateServiceCollection();
ServiceProvider rootServiceProvider = serviceCollection.BuildServiceProvider();
List <Either <IPipelineError, Tuple <TransportMessage, object> > > runResults =
new List <Either <IPipelineError, Tuple <TransportMessage, object> > >();
for (var i = 0; i < runCount; i++)
{
Either <IPipelineError, Tuple <TransportMessage, object> >
processedMessage = await MessagePipeline.Run(
messageSource,
new SimpleMessageTransform(),
rootServiceProvider,
iocManagement);
runResults.Add(processedMessage);
}
runResults.Count.Should().Be(runCount);
messageSource.AckCount.Should().Be(runCount);
rootServiceProvider.GetService <TestEventHandlerInvocationStats>()
.HandledEvents.Count.Should().Be(runCount);
rootServiceProvider.GetService <TestEventHandlerInvocationStats>()
.HandledEvents.Should().BeEquivalentTo(expectedHandledEvents);
}
public void StartExporter(MessagePipeline exporter)
{
if (Exporter == null || Exporter.Failed)
{
Exporter = exporter;
OnExportStarted();
try
{
exporter.Start();
}
catch (Exception ex)
{
Logger.Error("Failed to start exporter", ex);
}
}
}
protected bool Inspect(MessagePipeline element)
{
if (typeof(TMessage) == typeof(object))
{
InsertAfter = (sink =>
{
return(element
.ReplaceOutputSink(sink.TranslateTo <IPipelineSink <object> >())
.TranslateTo <IPipelineSink <TMessage> >());
});
return(false);
}
return(true);
}
public void StartExporter(MessagePipeline exporter)
{
if (_exporter == null || _exporter.Failed)
{
_exporter = exporter;
_exporter.SucceededMail += ExporterOnSucceededMail;
_exporter.StateChanged += (sender, args) => OnPropertyChanged("ProgressText");
try
{
exporter.Start();
}
catch (Exception ex)
{
Logger.Error("Failed to start exporter", ex);
}
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposing || _disposed)
{
return;
}
if (_interceptors != null)
{
_interceptors.Dispose();
}
_pipeline = null;
_interceptors = null;
_subscriptionEventHandlers = null;
_disposed = true;
}
public void How_many_messages_can_the_pipe_send_per_second()
{
long count = 0;
long count2 = 0;
long limit = 2500000;
var messageSink = new InstanceMessageSink <ClaimModified>(m => msg => { count++; });
var messageSink2 = new InstanceMessageSink <ClaimModified>(m => msg => { count2++; });
var router = new MessageRouter <ClaimModified>();
router.Connect(messageSink);
router.Connect(messageSink2);
var translater = new MessageTranslator <object, ClaimModified>(router);
var objectRouter = new MessageRouter <object>();
objectRouter.Connect(translater);
var pipeline = new MessagePipeline(objectRouter, MockRepository.GenerateMock <IPipelineConfigurator>());
var message = new ClaimModified();
for (int i = 0; i < 100; i++)
{
pipeline.Dispatch(message);
}
count = 0;
count2 = 0;
Stopwatch timer = Stopwatch.StartNew();
for (int i = 0; i < limit; i++)
{
pipeline.Dispatch(message);
}
timer.Stop();
Trace.WriteLine("Received: " + (count + count2) + ", expected " + limit * 2);
Trace.WriteLine("Elapsed Time: " + timer.ElapsedMilliseconds + "ms");
Trace.WriteLine("Messages Per Second: " + limit * 1000 / timer.ElapsedMilliseconds);
}
private MessagePipelineConfigurator(IObjectBuilder builder, object data)
{
_builder = builder;
_bus = data;
var router = new MessageRouter <object>();
_pipeline = new MessagePipeline(router, this);
// interceptors are inserted at the front of the list, so do them from least to most specific
_interceptors.Register(new ConsumesAllSubscriber());
_interceptors.Register(new ConsumesSelectedSubscriber());
_interceptors.Register(new ConsumesForSubscriber());
_interceptors.Register(new BatchSubscriber());
_interceptors.Register(new SagaStateMachineSubscriber());
_interceptors.Register(new ObservesSubscriber());
_interceptors.Register(new OrchestratesSubscriber());
_interceptors.Register(new InitiatesSubscriber());
_interceptors.Register(new DistributorSubscriber());
_interceptors.Register(new SagaDistributorSubscriber());
}
public async void One_Run_Through_Pipeline_With_TransportMessage_Succeeds()
{
TestEvent testEvent = new TestEvent(Guid.NewGuid());
TransportMessage transportMessage = new TransportMessage(testEvent);
var scopeId = Guid.NewGuid();
var messageSource = new TestMessageSource <TransportMessage>(transportMessage);
IIocManagement <TransportMessage> iocManagement =
new SimpleTestIocManagement(scopeId);
// Initialize Ioc
IServiceCollection serviceCollection = iocManagement.CreateServiceCollection();
ServiceProvider rootServiceProvider = serviceCollection.BuildServiceProvider();
Either <IPipelineError, Tuple <TransportMessage, object> >
processedMessage = await MessagePipeline.Run(
messageSource,
new SimpleMessageTransform(),
rootServiceProvider,
iocManagement);
messageSource.AckCount.Should().Be(1);
rootServiceProvider.GetService <TestEventHandlerInvocationStats>()
.HandledEvents.Single().Should().BeEquivalentTo(
Tuple.Create(scopeId, transportMessage, testEvent));
processedMessage.BiIter(
right =>
{
// Sadly, have to cast )-:
var castTestValue = Tuple.Create(right.Item1,
(TestEvent)right.Item2);
castTestValue.Should()
.BeEquivalentTo(Tuple.Create(transportMessage,
testEvent));
},
left => "Should be right".AssertFail()
);
}
protected bool Inspect(MessagePipeline element)
{
InsertAfter = (sink => element.ReplaceOutputSink(sink.TranslateTo <IPipelineSink <object> >()));
return(false);
}
public bool Inspect(MessagePipeline element)
{
Append("Pipeline");
return(true);
}
