private async Task <UInt64> SendPacketBatchAsync(IEnumerable <RawPacket> processRawPacketRequests, Int64 batchSeqId)
{
if (!this.DistributionSw.IsRunning)
{
this.DistributionSw.Start();
}
var processRawPacketRequestsList = processRawPacketRequests as List <RawPacket> ?? processRawPacketRequests.ToList();
if (!processRawPacketRequestsList.Any())
{
return(0);
}
var entityId = processRawPacketRequestsList[0].EntityId;
var batch = new RawPacketBatchRequest(processRawPacketRequestsList, batchSeqId);
// return (UInt64) processRawPacketRequestsList.Count;
// var envelope = new ReassemblerEntityMessageEnvelope(entityId, batch);
// this.ClusterProxy.Tell(envelope, this.SelfLoadBalancerActor);
var receiveTask = (Task)this.ReassemblerMessageProxy.Ask <RawPacketBatchAck>(entityId, batch);
await Task.WhenAny(receiveTask, Task.Delay(this.Settings.AskableMessageReplyTimeout)).ConfigureAwait(false);
if (!receiveTask.IsCompleted)
{
throw new TimeoutException($"Failed to receive RawPacketBatchAck on time ({this.Settings.AskableMessageReplyTimeout.Seconds} s)");
}
var sentRawPacketRequests = (UInt64)processRawPacketRequestsList.Count;
return(sentRawPacketRequests);
}
public void Process_PacketBatch_TwoPacket()
{
var randomIPNonTcpPacket = IPPacket.RandomPacket(IPVersion.IPv4);
var randomIPPacket = IPPacket.RandomPacket(IPVersion.IPv4);
var randomTCPPacket = TcpPacket.RandomPacket();
randomIPPacket.PayloadPacket = randomTCPPacket;
//Arrange
var posixTimeval = new PosixTimeval();
var rawTCPCapture = new RawCapture(LinkLayers.Raw, posixTimeval, randomIPPacket.Bytes);
var rawNonTCPCapture = new RawCapture(LinkLayers.Raw, posixTimeval, randomIPNonTcpPacket.Bytes);
var rawPacketBatchRequest =
new RawPacketBatchRequest(
new[] { new RawPacket(rawTCPCapture), new RawPacket(rawNonTCPCapture), new RawPacket(rawTCPCapture) }, 1);
//Act
this._rawPacketBatchParserActorRefSUT.Tell(rawPacketBatchRequest);
//Assert
this._captureActorTestProbe.ExpectMsg <Frame>(frame => frame.TimestampTicks == posixTimeval.Date.Ticks);
this._captureActorTestProbe.ExpectMsg <Frame>(frame => frame.TimestampTicks == posixTimeval.Date.Ticks);
this._captureActorTestProbe.ExpectNoMsg();
}
public void Enumerate_OneItem_And_Store_Back()
{
//Arrange
var rawPacketBatchRequest = new RawPacketBatchRequest()
{
SeqId = 0
};
this._reorderingBufferSUT.Store(rawPacketBatchRequest);
var isFirstIteration = true;
//Act & Assert
foreach (var item in this._reorderingBufferSUT)
{
Assert.Equal(rawPacketBatchRequest, item);
Assert.True(isFirstIteration);
isFirstIteration = false;
}
Assert.True(this._reorderingBufferSUT.IsEmpty);
this._reorderingBufferSUT.Store(rawPacketBatchRequest);
Assert.False(this._reorderingBufferSUT.IsEmpty);
}
public void SendBatch(PacketBatch packetBatch)
{
var batchRequest = new RawPacketBatchRequest(packetBatch.Batch, this._batchSeqNum++)
{
MessageId = this._messageCounter++
};
this.DistributedPackets += (UInt64)packetBatch.Count;
this._rawPacketParserActor.Tell(batchRequest, this._loadBalancerActor);
}
public void Process_PacketBatch_NonTransportPacket()
{
var randomIPPacket = IPPacket.RandomPacket(IPVersion.IPv4);
//Arrange
var posixTimeval = new PosixTimeval();
var rawCapture = new RawCapture(LinkLayers.Raw, posixTimeval, randomIPPacket.Bytes);
var rawPacketBatchRequest = new RawPacketBatchRequest(new[] { new RawPacket(rawCapture) }, 1);
//Act
this._rawPacketBatchParserActorRefSUT.Tell(rawPacketBatchRequest);
//Assert
this._captureActorTestProbe.ExpectNoMsg();
}
public void OnProcessRawPacketBatch(RawPacketBatchRequest request)
{
var ack = new RawPacketBatchAck {
MessageId = request.MessageId
};
this._contractor.Tell(ack, this._captureControllerActor);
// Is actor spawned for given Sender?
if (this._rawPacketBatchParserActor == null)
{
if (!this._isCaptureInfoRequested)
{
this._contractor.Tell(CaptureInfoRequest.Instance);
this._isCaptureInfoRequested = true;
}
this._reorderingBuffer.Store(request);
return;
}
try
{
var batchSeqId = request.SeqId;
if (batchSeqId == this._currentBatchSeqId)
{
this.SendBatch(request);
if (!this._reorderingBuffer.IsEmpty)
{
this.ReplayPacketBatchReorderBuffer();
}
}
else if (batchSeqId > this._currentBatchSeqId)
{
this._reorderingBuffer.Store(request);
}
else
{
throw new Exception(
$"Received batch from the past (possible duplicate). Current {this._currentBatchSeqId}, got {batchSeqId}");
}
}
catch (Exception e)
{
this.Logger.Error(e.ToString());
}
}
private void OnProcessRawPacketBatch(RawPacketBatchRequest request)
{
#if DROP_BATCHES
this.Sender.Tell(new RawPacketBatchAck {
MessageId = request.MessageId
});
return;
#endif
if (!this._contractorToCaptureControllerMap.TryGetValue(this.Sender, out var captureController))
{
captureController = new CaptureController(Context, this.Sender, this.Self, this._rawPacketBatchParserActorFactory);
this._contractorToCaptureControllerMap.Add(this.Sender, captureController);
}
captureController.OnProcessRawPacketBatch(request);
}
private void OnRawPacketBatchRequest(RawPacketBatchRequest rawPacketBatchRequest)
{
var ack = new RawPacketBatchAck {
MessageId = rawPacketBatchRequest.MessageId
};
this.Contractor.Tell(ack);
try
{
foreach (var rawPacket in rawPacketBatchRequest.RawPackets)
{
if (rawPacket.RawPacketData == null)
{
this._logger.Error("RawPacket has no packet data");
continue;
}
var parsedPacket = Packet.ParsePacket(rawPacket.LinkType, rawPacket.RawPacketData);
if (!(parsedPacket.PayloadPacket is IPPacket))
{
//this._logger.Debug("Ignoring non-IP packet");
continue;
}
var frame = FrameFactory.CreateFromPacket(parsedPacket, rawPacket.DateTimeTicks);
if (frame.IsValidTransportPacket || frame.IsIpv4Fragmented)
{
this.CaptureTrackingActor.Tell(frame);
}
//else //TODO ALL NON TCP or UDP traffic
//{
// this._logger.Error($"Frame is invalid: {frame}");
//}
}
}
catch (Exception e)
{
this._logger.Error(e, "Exception during Raw packet parsing.");
}
}
private void OnRawPacketBatchRequest(RawPacketBatchRequest rawPacketBatchRequest)
{
var ack = new RawPacketBatchAck {
MessageId = rawPacketBatchRequest.MessageId
};
this.Contractor.Tell(ack);
foreach (var rawPacket in rawPacketBatchRequest.RawPackets)
{
if (rawPacket.RawPacketData == null)
{
this._logger.Error("RawPacket has no packet data");
continue;
}
try
{
var parsedPacket = Packet.ParsePacket(rawPacket.LinkType, rawPacket.RawPacketData);
if (!(parsedPacket.PayloadPacket is IPPacket))
{
//this._logger.Debug("Ignoring non-IP packet");
continue;
}
var frame = FrameFactory.CreateFromPacket(parsedPacket, rawPacket.DateTimeTicks);
if (frame.IsValidTransportPacket || frame.IsIpv4Fragmented)
{
this.CaptureTrackingActor.Tell(frame);
}
}
catch (Exception e)
{
this._logger.Error(e, $"Parsing of a raw packet ({rawPacket}) caused exception.");
}
}
}
private void SendBatch(RawPacketBatchRequest batch)
{
this._rawPacketBatchParserActor.Tell(batch);
this._currentBatchSeqId = batch.SeqId + 1;
}
