public async Task PayloadSender_WhenLengthSet_Sends()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var header = new Header()
{
Type = PayloadTypes.Stream,
Id = Guid.NewGuid(),
PayloadLength = 55,
End = false,
};
var stream = new MemoryStream(new byte[100]);
TaskCompletionSource <string> done = new TaskCompletionSource <string>();
sender.SendPayload(header, stream, true, (Header sentHeader) =>
{
Assert.AreEqual(55, sentHeader.PayloadLength);
Assert.IsFalse(sentHeader.End);
done.SetResult("done");
return(Task.CompletedTask);
});
await done.Task;
Assert.AreEqual(2, transport.Buffers.Count);
Assert.AreEqual(55, stream.Position);
}
public async Task SendRequestAsync_WaitsTillAllDataSent()
{
var payLoadSender = new PayloadSender();
var tcs = new TaskCompletionSource <bool>();
DisconnectedEventHandler eventHandler = (sender, args) =>
{
tcs.TrySetException(new Exception(args.Reason));
};
payLoadSender.Disconnected += eventHandler;
payLoadSender.Connect(GetMockedTransportSender(tcs, TransportConstants.MaxPayloadLength * 4));
var sendOperations = new SendOperations(payLoadSender);
try
{
using (var stream = GetMockedStream(TransportConstants.MaxPayloadLength * 4))
{
var request = new StreamingRequest();
request.AddStream(new StreamContent(stream));
await sendOperations.SendRequestAsync(Guid.NewGuid(), request);
}
await tcs.Task;
}
finally
{
payLoadSender.Disconnected -= eventHandler;
}
}
public async Task PayloadSender_WhenLengthNotSet_AndNoData_SendsZeroLengthEnd()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var header = new Header()
{
Type = PayloadTypes.Stream,
Id = Guid.NewGuid(),
PayloadLength = 555,
End = false,
};
var stream = new MemoryStream(new byte[100]);
stream.Position = 100;
var done = new TaskCompletionSource <string>();
sender.SendPayload(header, stream, false, (Header sentHeader) =>
{
Assert.Equal(0, sentHeader.PayloadLength);
Assert.True(sentHeader.End);
done.SetResult("done");
return(Task.CompletedTask);
});
await done.Task;
Assert.Single(transport.Buffers);
}
/// <inheritdoc />
public async Task Start()
{
ProjectVersionStage.AssertAlpha();
//TODO: We need this? Can we add support to GladNet3 to queue up unconnected messages?
//await Task.Delay(1500);
//TODO: We're sending with Bearer but there is nothing validating both sides expect that.
await PayloadSender.SendMessage(new ClientSessionClaimRequestPayload(AuthTokenRepo.RetrieveWithType(), CharacterRepository.CharacterId));
}
public void PayloadSender_Connect_ShouldFail()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
Assert.Throws <InvalidOperationException>(() => sender.Connect(transport));
}
public async Task RequestDisassembler_SendsAsFixedLength()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var disassembler = new RequestDisassembler(sender, Guid.NewGuid(), StreamingRequest.CreateGet("/a/b/c"));
await disassembler.DisassembleAsync();
Assert.Equal(2, transport.Buffers.Count);
}
public async Task ResponseDisassembler_SendsAsFixedLength()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var disassembler = new ResponseDisassembler(sender, Guid.NewGuid(), StreamingResponse.OK());
await disassembler.DisassembleAsync();
Assert.AreEqual(2, transport.Buffers.Count);
}
public async Task SendResponseAsync()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var ops = new SendOperations(sender);
var content = new StringContent("/a/b", Encoding.ASCII);
var response = StreamingResponse.CreateResponse(HttpStatusCode.OK, content);
await ops.SendResponseAsync(Guid.NewGuid(), response);
Assert.Equal(4, transport.Buffers.Count);
}
public async Task RequestDisassembler_WithJsonStream_Sends()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var ops = new SendOperations(sender);
var request = StreamingRequest.CreatePost("/a/b");
request.AddStream(new StringContent("abc", Encoding.ASCII));
await ops.SendRequestAsync(Guid.NewGuid(), request);
Assert.AreEqual(4, transport.Buffers.Count);
}
public UdpDispatcherImpl(Identity identity, UdpClient udpClient, DuplicateFilter duplicateFilter, PayloadSender payloadSender, AcknowledgementCoordinator acknowledgementCoordinator, RoutingTable routingTable, PeerTable peerTable, InboundMessageDispatcher inboundMessageDispatcher, MultiPartPacketReassembler multiPartPacketReassembler, IUdpUnicasterFactory udpUnicasterFactory, IAuditCounter announcementsReceivedCounter, IAuditCounter tossedCounter, IAuditCounter duplicateReceivesCounter, IAuditAggregator<int> multiPartChunksBytesReceivedAggregator) {
this.identity = identity;
this.udpClient = udpClient;
this.duplicateFilter = duplicateFilter;
this.payloadSender = payloadSender;
this.acknowledgementCoordinator = acknowledgementCoordinator;
this.routingTable = routingTable;
this.peerTable = peerTable;
this.inboundMessageDispatcher = inboundMessageDispatcher;
this.multiPartPacketReassembler = multiPartPacketReassembler;
this.udpUnicasterFactory = udpUnicasterFactory;
this.announcementsReceivedCounter = announcementsReceivedCounter;
this.tossedCounter = tossedCounter;
this.duplicateReceivesCounter = duplicateReceivesCounter;
this.multiPartChunksBytesReceivedAggregator = multiPartChunksBytesReceivedAggregator;
}
public async Task ResponseDisassembler_With_HttpContent_SendsAsFixedLength()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var content = new StringContent("{'a': 55}", Encoding.UTF8, "application/json");
var response = StreamingResponse.CreateResponse(System.Net.HttpStatusCode.OK, content);
var disassembler = new ResponseDisassembler(sender, Guid.NewGuid(), response);
await disassembler.DisassembleAsync();
Assert.Equal(2, transport.Buffers.Count);
}
public async Task RequestDisassembler_WithVariableStream_Sends()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var ops = new SendOperations(sender);
var request = StreamingRequest.CreatePost("/a/b");
var stream = new PayloadStream(new PayloadStreamAssembler(null, Guid.NewGuid(), "blah", 100));
stream.Write(new byte[100], 0, 100);
request.AddStream(new StreamContent(stream));
await ops.SendRequestAsync(Guid.NewGuid(), request);
Assert.AreEqual(5, transport.Buffers.Count);
}
public async Task HttpContentStreamDisassembler_ObjectContent_SendsAsFixedLength()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var content = new ResponseMessageStream(Guid.NewGuid())
{
Content = new StringContent("{'a': 55}", Encoding.UTF8, "application/json"),
};
var disassembler = new ResponseMessageStreamDisassembler(sender, content);
await disassembler.DisassembleAsync();
Assert.AreEqual(2, transport.Buffers.Count);
}
public void PayloadSender_Dispose()
{
var sender = new PayloadSender();
var header = new Header()
{
Type = PayloadTypes.Stream,
Id = Guid.NewGuid(),
PayloadLength = 55,
End = false,
};
var stream = new MemoryStream(new byte[100]);
sender.Dispose();
Assert.Throws <ObjectDisposedException>(() => sender.SendPayload(header, stream, true, (Header sentHeader) => Task.CompletedTask));
}
public async Task HttpContentStreamDisassembler_StringContent_SendsAsFixedLength()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var content = new ResponseMessageStream(Guid.NewGuid())
{
Content = new StringContent("blah blah blah", Encoding.ASCII),
};
var disassembler = new ResponseMessageStreamDisassembler(sender, content);
await disassembler.DisassembleAsync();
Assert.Equal(2, transport.Buffers.Count);
}
public async Task HttpContentStreamDisassembler_ObjectContent_SendsAsFixedLength()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var content = new ResponseMessageStream(Guid.NewGuid())
{
Content = new ObjectContent(typeof(string), "{'a': 55}", new JsonMediaTypeFormatter()),
};
var disassembler = new ResponseMessageStreamDisassembler(sender, content);
await disassembler.DisassembleAsync();
Assert.AreEqual(2, transport.Buffers.Count);
}
public Task<ITransport> CreateAsync(MobOperations mobOperations, Identity identity, RoutingTable routingTable, PeerTable peerTable, InboundMessageDispatcher inboundMessageDispatcher, AuditService auditService) {
// setup identity
identity.Properties[UdpConstants.kUnicastPortIdentityPropertyKey] = configuration.UnicastReceiveEndpoint.Port.ToString();
var duplicateFilter = new DuplicateFilter();
duplicateFilter.Initialize();
var inboundBytesAggregator = auditService.GetAggregator<double>(DataSetNames.kInboundBytes);
var outboundBytesAggregator = auditService.GetAggregator<double>(DataSetNames.kOutboundBytes);
var inboundReceiveProcessDispatchLatencyAggregator = auditService.GetAggregator<double>(DataSetNames.kInboundProcessDispatchLatency);
var resendsCounter = auditService.GetCounter(DataSetNames.kTotalResends);
var resendsAggregator = auditService.GetAggregator<int>(DataSetNames.kMessageResends);
var tossedCounter = auditService.GetCounter(DataSetNames.kTossed);
var duplicatesReceivedCounter = auditService.GetCounter(DataSetNames.kDuplicatesReceived);
var announcementsReceivedCounter = auditService.GetCounter(DataSetNames.kAnnouncementsReceived);
var multiPartChunksSentCounter = auditService.GetCounter(DataSetNames.kMultiPartChunksSent);
var multiPartChunksReceivedAggregator = auditService.GetAggregator<int>(DataSetNames.kMultiPartChunksBytesReceived);
var outboundMessageRateLimitAggregator = auditService.GetAggregator<double>(DataSetNames.kOutboundMessageRateLimit);
var sendQueueDepthAggregator = auditService.GetAggregator<double>(DataSetNames.kSendQueueDepth);
mobOperations.RegisterMob(new UdpDebugMob());
var shutdownCts = new CancellationTokenSource();
var acknowledgementCoordinator = new AcknowledgementCoordinator(identity);
var udpUnicastScheduler = SchedulerFactory.CreateWithCustomThreadPool($"Courier.Udp({identity.Id.ToShortString()}).Unicast");
var sendReceiveBufferPool = ObjectPool.CreateStackBacked(() => new byte[UdpConstants.kMaximumTransportSize]);
var client = UdpClient.Create(configuration, udpUnicastScheduler, sendReceiveBufferPool, inboundBytesAggregator, outboundBytesAggregator, inboundReceiveProcessDispatchLatencyAggregator);
var payloadSender = new PayloadSender(client);
var multiPartPacketReassembler = new MultiPartPacketReassembler();
var udpUnicasterFactory = new UdpUnicasterFactory(identity, client, acknowledgementCoordinator, sendReceiveBufferPool, resendsCounter, resendsAggregator, outboundMessageRateLimitAggregator, sendQueueDepthAggregator);
var udpDispatcher = new UdpDispatcherImpl(identity, client, duplicateFilter, payloadSender, acknowledgementCoordinator, routingTable, peerTable, inboundMessageDispatcher, multiPartPacketReassembler, udpUnicasterFactory, announcementsReceivedCounter, tossedCounter, duplicatesReceivedCounter, multiPartChunksReceivedAggregator);
multiPartPacketReassembler.SetUdpDispatcher(udpDispatcher);
var announcer = new Announcer(identity, payloadSender, shutdownCts.Token);
announcer.Initialize();
var udpFacade = new UdpFacade(client, udpDispatcher, shutdownCts);
var udpBroadcaster = new UdpBroadcaster(identity, client);
var transport = new UdpTransport(udpBroadcaster, udpFacade);
client.StartReceiving(udpDispatcher);
return Task.FromResult<ITransport>(transport);
}
public async Task HttpContentStreamDisassembler_StreamContent_SendsAsVariableLength()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var stream = new PayloadStream(new PayloadStreamAssembler(null, Guid.NewGuid(), "blah", 100));
var content = new ResponseMessageStream(Guid.NewGuid())
{
Content = new StreamContent(stream),
};
stream.Write(new byte[100], 0, 100);
var disassembler = new ResponseMessageStreamDisassembler(sender, content);
await disassembler.DisassembleAsync();
Assert.AreEqual(3, transport.Buffers.Count);
}
public void PayloadSentWithBearerToken()
{
AuthenticationHeaderValue authHeader = null;
var handler = new MockHttpMessageHandler((r, c) =>
{
authHeader = r.Headers.Authorization;
return(Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)));
});
var secretToken = "SecretToken";
var logger = ConsoleLogger.Instance;
var payloadSender = new PayloadSender(logger, new TestAgentConfigurationReader(logger, secretToken: secretToken), handler);
using (var agent = new ApmAgent(new TestAgentComponents(secretToken: secretToken, payloadSender: payloadSender)))
agent.PayloadSender.QueuePayload(new Payload());
// ideally, introduce a mechanism to flush payloads
Thread.Sleep(TimeSpan.FromSeconds(2));
Assert.NotNull(authHeader);
Assert.Equal("Bearer", authHeader.Scheme);
Assert.Equal(secretToken, authHeader.Parameter);
}
public Announcer(Identity identity, PayloadSender payloadSender, CancellationToken shutdownCancellationToken) {
this.identity = identity;
this.payloadSender = payloadSender;
this.shutdownCancellationToken = shutdownCancellationToken;
}
