private static void WritePayLoadMessage(PayloadMessage message, Utf8JsonWriter writer)
{
WritePayloadType(message, writer);
WriteSource(message, writer);
WriteDestination(message, writer);
WritePayload(message, writer);
}
public async Task TrySendAsync_StateUnderTest_ExpectedBehavior()
{
// Arrange
var mocker = new AutoMoqer();
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var messageSender = mocker.Create <MessageSender>();
SixtyNineSendibleMessage requestMessage =
new PayloadMessage("source", "destination", Encoding.UTF8.GetBytes("payload"));
var cancellationToken = default(CancellationToken);
mocker.GetMock <ConnectionStore>()
.Setup(x => x[It.IsAny <string>()]).Returns(fixture.Create <DefaultConnectionContext>());
// Act
await messageSender.TrySendAsync(
requestMessage,
cancellationToken);
// Assert
mocker.GetMock <IMessageWriter <SixtyNineSendibleMessage> >()
.Verify(x =>
x.WriteMessage(requestMessage, It.IsAny <PipeWriter>()), Times.Once);
mocker.GetMock <ConnectionStore>()
.Verify(x =>
x[requestMessage.Destination], Times.Once);
}
public bool PreProcess(PayloadMessage message)
{
IGrain sender = message.SenderIdentifer;
ulong sequenceNum = message.SequenceNumber;
switch (CheckMessage(sender, sequenceNum))
{
case MessageStatus.Vaild:
inSequenceNumberMap[sender]++;
return(true);
case MessageStatus.Ahead:
if (!stashedPayloadMessages.ContainsKey(sender))
{
stashedPayloadMessages[sender] = new Dictionary <ulong, Pair <bool, List <TexeraTuple> > >();
}
if (!stashedPayloadMessages[sender].ContainsKey(sequenceNum))
{
stashedPayloadMessages[sender].Add(sequenceNum, new Pair <bool, List <TexeraTuple> >(message.IsEnd, message.Payload));
}
break;
case MessageStatus.Duplicated:
break;
}
return(false);
}
public static void ProduceMessage(string message, string key = "")
{
PayloadMessage payloadMessage = new PayloadMessage
{
Value = message,
Key = key
};
switch (KafkaDriver)
{
case JAVA:
Console.WriteLine("In JavaPublisher");
LogResult.Report(Log, "log_ForInfo", "In JavaPublisher");
if (JavaPublisher != null)
{
JavaPublisher.Publish(payloadMessage);
}
else
{
Console.WriteLine("Javapublisher is null " + JavaPublisher);
LogResult.Report(Log, "log_ForInfo", "Javapublisher is null" + JavaPublisher);
}
break;
}
}
public void CreateMessageWithPayload()
{
var m = "This message has a payload!";
IMessage payload = new BasicMessage("And this is the payload!");
IPayloadMessage message = new PayloadMessage(m, payload);
Assert.AreEqual(m, message.GetMessage());
Assert.AreEqual(payload.GetMessage(), ((IMessage)message.GetPayload()).GetMessage());
}
protected async Task StartSendingMessageAsync(int index, string targetUserId,
byte[] messageBlob, int duration, int interval, Counter counter)
{
var messageSize = (ulong)messageBlob.Length;
await Task.Delay(StartTimeOffsetGenerator.Delay(TimeSpan.FromSeconds(interval)));
using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(duration)))
{
while (!cts.IsCancellationRequested)
{
_ = Task.Run(async() =>
{
try
{
var url = GenRestUrl(_serviceUtils, targetUserId);
var request = new HttpRequestMessage(HttpMethod.Post, GetUrl(url));
// Corefx changed the default version and High Sierra curlhandler tries to upgrade request
request.Version = new Version(1, 1);
request.Headers.Authorization =
new AuthenticationHeaderValue("Bearer",
_serviceUtils.GenerateAccessToken(url, _serverName));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var payloadRequest = new PayloadMessage
{
Target = ServiceUtils.MethodName,
Arguments = new[]
{
_serverName,
$"{DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}",
_content
}
};
request.Content = new StringContent(JsonConvert.SerializeObject(payloadRequest), Encoding.UTF8, "application/json");
// ResponseHeadersRead instructs SendAsync to return once headers are read
// rather than buffer the entire response. This gives a small perf boost.
// Note that it is important to dispose of the response when doing this to
// avoid leaving the connection open.
using (var response = await _tk.HttpClients[index].SendAsync(request, HttpCompletionOption.ResponseHeadersRead))
{
response.EnsureSuccessStatusCode();
}
counter.IncreaseSentMessageSize(messageSize);
counter.IncreseSentMsg();
}
catch (Exception ex)
{
Util.Log($"exception in sending message of {index}th connection: {ex}");
//counter.IncreaseConnectionError();
counter.IncreseNotSentFromClientMsg();
}
});
// sleep for the fixed interval
await Task.Delay(TimeSpan.FromSeconds(interval));
}
}
}
private static void WritePayLoadMessage(PayloadMessage message, Utf8JsonWriter writer)
{
WritePayloadType(message, writer);
WriteSource(message, writer);
WriteDestination(message.Destination, writer);
if (message.Payload != null)
{
WritePayload(message.Payload.Value, writer);
}
}
public SixtyNineSendibleMessage?HandleMessage(ConnectionContext connection, SixtyNineMessage message)
{
return(message switch
{
null => null,
InitMessage x => HandleInitMessage(x, connection),
CloseMessage => HandleCloseMessage(connection),
ErrorMessage x => x,
PayloadMessage x => x,
_ => new ErrorMessage(connection.ConnectionId, Encoding.UTF8.GetBytes("Invalid type"))
});
public override void SendEndMessages(IGrain senderIdentifier)
{
foreach (Pair <int, List <TexeraTuple> > pair in MakeLastPayload())
{
receivers[pair.First].Send(new PayloadMessage(senderIdentifier, outputSequenceNumbers[pair.First]++, pair.Second, false));
}
for (int i = 0; i < receivers.Count; ++i)
{
PayloadMessage message = new PayloadMessage(senderIdentifier, outputSequenceNumbers[i]++, null, true);
receivers[i].Send(message);
}
}
public override void SendEndMessages(string senderIdentifier)
{
foreach (Pair <int, List <TexeraTuple> > pair in MakeLastPayload())
{
SendMessageTo(receivers[pair.First], new PayloadMessage(senderIdentifier, outputSequenceNumbers[pair.First]++, pair.Second, false).AsImmutable(), 0);
}
for (int i = 0; i < receivers.Count; ++i)
{
PayloadMessage message = new PayloadMessage(senderIdentifier, outputSequenceNumbers[i]++, null, true);
SendMessageTo(receivers[i], message.AsImmutable(), 0);
}
}
public override void SendBatchedMessages(string senderIdentifier)
{
while (true)
{
PayloadMessage message = MakeBatchedMessage(senderIdentifier, outputSequenceNumbers[roundRobinIndex]);
if (message == null)
{
break;
}
RoundRobinSending(message.AsImmutable());
}
}
private object[] SafeConvertToObjectArray(PayloadMessage payload)
{
try
{
return(JsonObjectConverter.ConvertToObjectArray(payload.Arguments));
}
catch (Exception ex)
{
_logger.LogError("Failed to parse argument", ex);
return(null);
}
}
public void SendEndMessages(string senderIdentifier)
{
PayloadMessage message = MakeLastMessage(senderIdentifier, sequenceNumber);
if (message != null)
{
++sequenceNumber;
stream.OnNextAsync(message.AsImmutable());
}
message = new PayloadMessage(senderIdentifier, sequenceNumber++, null, true);
stream.OnNextAsync(message.AsImmutable());
}
public void SendEndMessages(IGrain senderIdentifier)
{
PayloadMessage message = MakeLastMessage(senderIdentifier, seqNum);
if (message != null)
{
seqNum++;
unit.Send(message);
}
message = new PayloadMessage(senderIdentifier, seqNum, null, true);
unit.Send(message);
}
public async Task SendAsync(string hubName, string methodName, params object[] args)
{
var payload = new PayloadMessage()
{
Target = methodName,
Arguments = args
};
var url = $"{endpoint}:5002/api/v1-preview/hub/{hubName}";
var bearer = GenerateJwtBearer(null, url, null, DateTime.UtcNow.AddMinutes(30), accessKey);
await PostJsonAsync(url, payload, bearer);
}
public async Task SendAsync(SignalRMessage message)
{
var payload = new PayloadMessage
{
Target = message.Target,
Arguments = message.Arguments
};
var destinationUrl = GetDestinationUrl(message);
var bearer = GenerateJwtBearer(null, destinationUrl, null, DateTime.UtcNow.AddMinutes(30), accessKey);
await PostJsonAsync(destinationUrl, payload, bearer);
}
public void SendBatchedMessages(IGrain senderIdentifier)
{
while (true)
{
PayloadMessage message = MakeBatchedMessage(senderIdentifier, seqNum);
if (message == null)
{
break;
}
seqNum++;
unit.Send(message);
}
}
public Task ReceivePayloadMessage(PayloadMessage message)
{
if (message.IsEnd)
{
endflags++;
if (endflags == targetflags)
{
principalGrain.OnWorkerReceivedAllBatches(self);
}
}
Process(message);
return(Task.CompletedTask);
}
public static GenericMessage MakeLocationResponse(long id, double lat, double lon, string lang)
{
string image_url = $"https://maps.googleapis.com/maps/api/staticmap?size=764x400¢er={lat},{lon}&zoom=15&markers={lat},{lon}";
string item_url = $"http://maps.apple.com/maps?q={lat},{lon}&z=16";
LocationElement element = new LocationElement(DataConstants.GetMessage("CLOSEST_TOILET", lang), image_url, "", null, item_url);
List <Element> elements = new List <Element>();
elements.Add(element);
IPayload payload = new PayloadMessage("generic", elements, true, "horizontal");
Attachment attachment = new Attachment("template", payload);
return(new GenericMessage(id, attachment));
}
public void SendBatchedMessages(string senderIdentifier)
{
while (true)
{
PayloadMessage message = MakeBatchedMessage(senderIdentifier, sequenceNumber);
if (message == null)
{
break;
}
++sequenceNumber;
stream.OnNextAsync(message.AsImmutable());
}
}
public override void SendEndMessages(IGrain senderIdentifier)
{
PayloadMessage message = MakeLastMessage(senderIdentifier, outputSequenceNumbers[roundRobinIndex]);
if (message != null)
{
RoundRobinSending(message);
}
for (int i = 0; i < receivers.Count; ++i)
{
message = new PayloadMessage(senderIdentifier, outputSequenceNumbers[i]++, null, true);
receivers[i].Send(message);
}
}
public static void Main(string[] args)
{
var payloadMessage = new PayloadMessage();
var nodeConfig = args.Length > 0 ? GetNodeConfigFromArgs(args) : new NodeConfig();
var nodeService = new NodeService(nodeConfig);
nodeService.StartAsync();
Console.WriteLine(nodeConfig);
Console.ReadKey();
nodeService.Stop();
Console.WriteLine("\nServer stoped.\nPress any key to exit.");
Console.ReadKey();
}
public override void SendEndMessages(string senderIdentifier)
{
PayloadMessage message = MakeLastMessage(senderIdentifier, outputSequenceNumbers[roundRobinIndex]);
if (message != null)
{
RoundRobinSending(message.AsImmutable());
}
for (int i = 0; i < receivers.Count; ++i)
{
message = new PayloadMessage(senderIdentifier, outputSequenceNumbers[i]++, null, true);
SendMessageTo(receivers[i], message.AsImmutable(), 0);
}
}
protected PayloadMessage MakeBatchedMessage(string senderIdentifier, ulong sequenceNumber)
{
PayloadMessage outputMessage = null;
if (outputRows.Count >= batchingLimit)
{
List <TexeraTuple> payload = new List <TexeraTuple>();
for (int i = 0; i < batchingLimit; ++i)
{
payload.Add(outputRows.Dequeue());
}
outputMessage = new PayloadMessage(senderIdentifier, sequenceNumber, payload, false);
}
return(outputMessage);
}
public override async Task <IActionResult> Broadcast(string hub, [FromBody] PayloadMessage message, [FromQuery(Name = "excluded")] IReadOnlyList <string> excluded)
{
if (_store.TryGetLifetimeContext(hub, out var c))
{
var clients = c.ClientManager;
var arguments = SafeConvertToObjectArray(message);
await SendAsync(clients.AllExcept(excluded), message.Target, arguments);
return(Accepted());
}
else
{
return(NotFound());
}
}
public void Handle(PayloadMessage message)
{
try
{
if (message.Value == null || message.Value == "null")
{
LogResult.Report(Log, "log_ForInfo", "Kafka Message is Null");
return;
}
if (CreateCustomerModel != null && CreateCustomerModel.ActionUTC != null)
{
if (CreateCustomerModel.ActionUTC.ToString() != null && message.Value.Contains(CreateCustomerModel.ActionUTC.ToString("yyyy-MM-ddTHH:mm:ss")) && message.Value.Contains(CreateCustomerModel.ReceivedUTC.ToString()) &&
CreateCustomerModel.CustomerUID.ToString() != null && message.Value.Contains(CreateCustomerModel.CustomerUID.ToString()))
{
customerServiceCreateResponse = JsonConvert.DeserializeObject <CreateCustomerModel>(message.Value);
}
LogResult.Report(Log, "log_ForInfo", string.Format("Response Received With Offset {0}: {1}", message.OffSet, message.Value));
if (UpdateCustomerModel != null && UpdateCustomerModel.ActionUTC != null && UpdateCustomerModel.CustomerUID != Guid.Empty)
{
if (UpdateCustomerModel.ActionUTC.ToString() != null && message.Value.Contains(UpdateCustomerModel.ActionUTC.ToString("yyyy-MM-ddTHH:mm:ss")) && message.Value.Contains(UpdateCustomerModel.ReceivedUTC.ToString()) &&
UpdateCustomerModel.CustomerUID.ToString() != null && message.Value.Contains(UpdateCustomerModel.CustomerUID.ToString()))
{
customerServiceUpdateResponse = JsonConvert.DeserializeObject <UpdateCustomerModel>(message.Value);
}
LogResult.Report(Log, "log_ForInfo", string.Format("Response Received With Offset {0}: {1}", message.OffSet, message.Value));
}
if (DeleteCustomerModel != null && DeleteCustomerModel.ActionUTC != null && DeleteCustomerModel.CustomerUID != Guid.Empty)
{
if (DeleteCustomerModel.ActionUTC.ToString() != null && message.Value.Contains(DeleteCustomerModel.ActionUTC.ToString("yyyy-MM-ddTHH:mm:ss")) && message.Value.Contains(DeleteCustomerModel.ReceivedUTC.ToString()) &&
DeleteCustomerModel.CustomerUID.ToString() != null && message.Value.Contains(DeleteCustomerModel.CustomerUID.ToString()))
{
customerServiceDeleteResponse = JsonConvert.DeserializeObject <DeleteCustomerModel>(message.Value);
}
LogResult.Report(Log, "log_ForInfo", string.Format("Response Received With Offset {0}: {1}", message.OffSet, message.Value));
}
}
}
catch (Exception e)
{
LogResult.Report(Log, "log_ForError", "Got Error While Handling Response", e);
throw new Exception(e + "Got Error While Handling Response");
}
}
public static void ProduceMessage(string message, string key = "")
{
PayloadMessage payloadMessage = new PayloadMessage
{
Value = message,
Key = key
};
if (KafkaDriver.Equals(RPL))
{
RPLPublisher.Publish(payloadMessage);
}
else if (KafkaDriver.Equals(MISAKAI))
{
MisakaiPublisher.Publish(payloadMessage);
}
}
private HttpRequestMessage BuildRequest(
ConnectionString connectionString,
string url,
PayloadMessage payloadMessage
)
{
var request = new HttpRequestMessage(HttpMethod.Post, GetUri(url));
request.Headers.Authorization = new AuthenticationHeaderValue(
"Bearer",
_accessTokensService.GenerateAccessToken(connectionString, url)
);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(_mimeType));
request.Content = new StringContent(JsonConvert.SerializeObject(payloadMessage), _encoding, _mimeType);
return(request);
}
public override void Send(PayloadMessage message)
{
PayloadMessage dequeuedMessage = null;
lock (toBeSentBuffer) lock (messagesOnTheWay)
{
toBeSentBuffer.Enqueue(message);
if (!isPaused && messagesOnTheWay.Count < windowSize)
{
dequeuedMessage = toBeSentBuffer.Dequeue();
}
}
if (dequeuedMessage != null)
{
SendInternal(dequeuedMessage, 0);
}
}
public void WriteMessage_WithPayloadMessage_ShouldWrite()
{
// Arrange
var mocker = new AutoMoqer();
var sixtyNineWriter = mocker.Create <SixtyNineWriter>();
var message = new PayloadMessage("src1", "dst1", Encoding.UTF8.GetBytes("contains"));
var stream = new ArrayBufferWriter <byte>(1024);
// Act
sixtyNineWriter.WriteMessage(
message,
stream);
// Assert
stream.WrittenSpan.ToArray().Should().Contain(Encoding.UTF8.GetBytes("dst1"));
stream.WrittenSpan.ToArray().Should().Contain(Encoding.UTF8.GetBytes("MESSAGE"));
stream.WrittenSpan.ToArray().Should().Contain(Encoding.UTF8.GetBytes("destination"));
stream.WrittenSpan.ToArray().Should().Contain(Encoding.UTF8.GetBytes("contains"));
stream.WrittenSpan.ToArray().Should().Contain(Encoding.UTF8.GetBytes("src1"));
}
