public void RegisteringCallbackPoint_SetsCallbackIdentityAndCallbackReceiverIdentity() { var message = Message.CreateFlowStartMessage(new SimpleMessage()).As <Message>(); var callbackReceiverIdentity = Guid.NewGuid().ToByteArray(); var callbackReceiverNodeIdentity = Guid.NewGuid().ToByteArray(); var callbackMessageIdentifier = new MessageIdentifier(Guid.NewGuid().ToByteArray(), Randomizer.UInt16(), Guid.NewGuid().ToByteArray()); var callbackKey = Randomizer.Int32(); message.RegisterCallbackPoint(callbackReceiverNodeIdentity, callbackReceiverIdentity, callbackMessageIdentifier, callbackKey); var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); CollectionAssert.Contains(message.CallbackPoint, callbackMessageIdentifier); CollectionAssert.AreEqual(callbackReceiverIdentity, message.CallbackReceiverIdentity); CollectionAssert.AreEqual(callbackReceiverNodeIdentity, message.CallbackReceiverNodeIdentity); CollectionAssert.IsEmpty(message.ReceiverIdentity); }
public Task <IMessage> HandleMultipartMessage(ISession session, MultipartMessage message) { _logger.Verbose( $"Handling {nameof(MultipartMessage)} " + $"(MultipartMessageId={message.MultipartMessageId}, " + $"Offset={message.Offset}, " + $"Length={message.Length}, " + $"TotalLength={message.TotalLength}, " + $"Data='{BitConverter.ToString(message.Data)}')." ); bool isNewMultipartMessageWaiter = false; var multipartMessageWaiter = _multipartMessageWaiters.GetOrAdd(message.MultipartMessageId, key => { isNewMultipartMessageWaiter = true; return(new MultipartMessageWaiter( message.MultipartMessageId, message.TotalLength, this )); }); multipartMessageWaiter.AddMessage(message); if (isNewMultipartMessageWaiter) { return(multipartMessageWaiter.Wait()); } return(Task.FromResult <IMessage>(null)); }
public void AddMessage(MultipartMessage message) { if (message.MultipartMessageId != _multipartMessageId) { return; } if (_receivedLength >= _totalLength) { return; } if (!_messages.TryAdd(message.Offset, message)) { return; } if (Interlocked.Add(ref _receivedLength, message.Length) >= _totalLength) { var buffer = new GrowingSpanBuffer(stackalloc byte[(int)_totalLength]); foreach (var kvp in _messages.OrderBy(kvp => kvp.Key)) { buffer.WriteBytes(kvp.Value.Data); } var bufferReader = new SpanBufferReader(buffer.Data); var fullMessage = _service._messageReader.ReadFrom(ref bufferReader, 0x00); Complete(fullMessage); } }
public void SendMessage(IMessage message) { var multipart = new MultipartMessage((Message)message); var frames = (IList <byte[]>)multipart.Frames; var msg = new Msg(); try { var framesCount = frames.Count; for (var i = 0; i < framesCount;) { var buffer = frames[i]; msg.InitGC(buffer, buffer.Length); var sendingTimeout1 = config.SendTimeout; if (!socket.TrySend(ref msg, sendingTimeout1, ++i < framesCount)) { throw new TimeoutException($"Sending timed out after {sendingTimeout1.TotalMilliseconds} ms!"); } } SendRate?.Increment(); } finally { msg.Close(); } }
public void MessageDistribution_IsConsistentlyTransferredViaMultipartMessage(DistributionPattern distributionPattern) { var message = Message.Create(new SimpleMessage(), distributionPattern).As <Message>(); var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); Assert.AreEqual(distributionPattern, message.Distribution); }
public void MessageTraceOptions_IsConsistentlyTransferredViaMultipartMessage(MessageTraceOptions routeOptions) { var message = (Message)Message.CreateFlowStartMessage(new SimpleMessage()); message.TraceOptions = routeOptions; var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); Assert.AreEqual(routeOptions, message.TraceOptions); }
public void SecurityDomain_IsConsistentlyTransferredViaMultipartMessage() { var securityDomain = Guid.NewGuid().ToString(); var message = Message.CreateFlowStartMessage(new SimpleMessage()).As <Message>(); message.SetDomain(securityDomain); var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); Assert.AreEqual(securityDomain, message.Domain); }
public void ReceiverNode_IsConsistentlyTransferredViaMultipartMessage() { var message = Message.CreateFlowStartMessage(new SimpleMessage()).As <Message>(); var receiverNode = ReceiverIdentifier.Create(); message.SetReceiverNode(receiverNode); var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); CollectionAssert.AreEqual(receiverNode.Identity, message.ReceiverNodeIdentity); }
public void CorrelationId_IsConsistentlyTransferredViaMultipartMessage() { var message = (Message)Message.CreateFlowStartMessage(new SimpleMessage()); var correlationId = Guid.NewGuid().ToByteArray(); message.SetCorrelationId(correlationId); var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); CollectionAssert.AreEqual(correlationId, message.CorrelationId); }
public void MessageTTL_IsConsistentlyTransferredViaMultipartMessage() { var ttl = TimeSpan.FromSeconds(Randomizer.Int32(2, 60)); var message = (Message)Message.CreateFlowStartMessage(new SimpleMessage()); message.TTL = ttl; var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); Assert.AreEqual(ttl, message.TTL); }
public void ParseMessageWithBinaryData() { string boundary = "-----Test"; byte[] requestData; using (MemoryStream stream = new MemoryStream()) { using (MultipartStreamWriter writer = new MultipartStreamWriter( stream, boundary, Encoding.UTF8)) { writer.WritePart("text/plain", "my text", Encoding.UTF8); writer.WritePart("application/xml", "<tag/>", Encoding.UTF8); byte[] pdfData = File.ReadAllBytes(@"..\..\..\samples\pdf-test.pdf"); List <HeaderField> headers = new List <HeaderField>(); headers.Add(new HeaderField("Content-type", "application/pdf")); headers.Add(new HeaderField("Content-id", "PDF")); writer.WritePart(headers, pdfData); writer.WriteCloseDelimiter(); } requestData = stream.ToArray(); } log.DebugFormat("Message body: {0}", Encoding.UTF8.GetString(requestData)); string requestContentType = string.Format( CultureInfo.InvariantCulture, "multipart/mixed;boundary=\"{0}\"", boundary); MultipartMessage message = StartReading(requestContentType, requestData); Assert.IsTrue(message.IsMultipart); Assert.AreEqual(MultipartMessage.MediaTypeMultipartMixed, message.MediaType); MultipartMessagePart part; part = reader.ReadNextPart(); part = reader.ReadNextPart(); part = reader.ReadNextPart(); Assert.AreEqual("application/pdf", part.GetHeader("content-type").FieldValue); File.WriteAllBytes("test.pdf", part.Data); Assert.IsNull(reader.ReadNextPart()); }
public void MessageWireFormatVersion_IsConsistentlyTransferredViaMultipartMessage() { const int wireMessageFormat = 5; var message = Message.CreateFlowStartMessage(new SimpleMessage()).As <Message>(); Assert.AreEqual(wireMessageFormat, message.WireFormatVersion); var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); Assert.AreEqual(wireMessageFormat, message.WireFormatVersion); }
public void MessagePartition_IsConsistentlyTransferredViaMultipartMessage() { var message = (Message)Message.CreateFlowStartMessage(new SimpleMessage { Partition = Guid.NewGuid().ToByteArray() }); var partition = message.Partition; var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); Assert.IsTrue(Unsafe.ArraysEqual(partition, message.Partition)); }
public void MessageContent_IsConsistentlyTransferredViaMultipartMessage() { var messageText = Guid.NewGuid().ToString(); var message = (Message)Message.CreateFlowStartMessage(new SimpleMessage { Content = messageText }); var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); Assert.AreEqual(messageText, message.GetPayload <SimpleMessage>().Content); Assert.IsTrue(message.Equals(MessageIdentifier.Create <SimpleMessage>())); }
public void MessageHops_AreConsistentlyTransferredViaMultipartMessage() { var message = (Message)Message.CreateFlowStartMessage(new SimpleMessage()); message.AddHop(); message.AddHop(); var hops = message.Hops; var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); Assert.AreEqual(hops, message.Hops); }
public void MessageSignature_IsConsistentlyTransferredViaMultipartMessage() { var simpleMessage = new SimpleMessage(); var securityDomain = securityProvider.GetDomain(simpleMessage.Identity); var message = Message.CreateFlowStartMessage(simpleMessage).As <Message>(); message.SetDomain(securityDomain); message.SignMessage(securityProvider); var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); message.VerifySignature(securityProvider); }
public void CallbackKey_IsConsistentlyTransferredViaMultipartMessage() { var message = Message.CreateFlowStartMessage(new SimpleMessage()).As <Message>(); var callbackKey = Randomizer.Int32(1, Int32.MaxValue); var callbackMessageIdentifier = MessageIdentifier.Create <SimpleMessage>(); message.RegisterCallbackPoint(Guid.NewGuid().ToByteArray(), Guid.NewGuid().ToByteArray(), callbackMessageIdentifier, callbackKey); var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); Assert.AreEqual(callbackKey, message.CallbackKey); }
public void ParseMessageWithTwoParts() { string contentType = "multipart/mixed; boundary=\"abcd\""; string content = "\r\n--abcd\r\nContent-Type: application/xml;charset=UTF-8\r\n\r\n<movie>...</movie>\r\n--abcd\r\n\r\nplain text\r\n--abcd--"; MultipartMessage message = ParseMessage(contentType, content); Assert.IsTrue(message.IsMultipart); Assert.AreEqual(MultipartMessage.MediaTypeMultipartMixed, message.MediaType); Assert.AreEqual("abcd", message.Boundary); Assert.AreEqual(2, message.Parts.Count); MultipartMessagePart part = message.Parts[0]; Assert.IsTrue(part.HasHeader("content-type")); Assert.AreEqual("application/xml", part.GetHeader("content-type").FieldValue); Assert.AreEqual("<movie>...</movie>", Encoding.UTF8.GetString(part.Data)); }
public void ParseMessageWithBoundaryWithoutQuotes() { string contentType = "multipart/mixed; boundary=abcd"; string content = "\r\n--abcd\r\nContent-Type: application/xml;charset=UTF-8\r\n\r\n<movie>...</movie>\r\n--abcd--"; MultipartMessage message = StartReading(contentType, content); Assert.IsTrue(message.IsMultipart); Assert.AreEqual(MultipartMessage.MediaTypeMultipartMixed, message.MediaType); Assert.AreEqual("abcd", message.Boundary); MultipartMessagePart part = reader.ReadNextPart(); Assert.IsTrue(part.HasHeader("content-type")); Assert.AreEqual("application/xml", part.GetHeader("content-type").FieldValue); Assert.AreEqual("<movie>...</movie>", Encoding.UTF8.GetString(part.Data)); Assert.IsNull(reader.ReadNextPart()); }
public void MessageRouting_IsConsistentlyTransferredViaMultipartMessage() { var message = (Message)Message.CreateFlowStartMessage(new SimpleMessage()); message.TraceOptions = MessageTraceOptions.Routing; var socketEnpoints = new[] { new SocketEndpoint(new Uri("tcp://localhost:40"), Guid.NewGuid().ToByteArray()), new SocketEndpoint(new Uri("tcp://localhost:40"), Guid.NewGuid().ToByteArray()) }; foreach (var socketEndpoint in socketEnpoints) { message.PushRouterAddress(socketEndpoint); } var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); CollectionAssert.AreEquivalent(socketEnpoints, message.GetMessageRouting()); }
public void IfCallbackIdentityIsEqualToMessageIdentity_ReceiverIdentitiesAreSetToCallbackReceiverIdentities() { var message = Message.CreateFlowStartMessage(new SimpleMessage()).As <Message>(); var callbackReceiverIdentity = Guid.NewGuid().ToByteArray(); var callbackReceiverNodeIdentity = Guid.NewGuid().ToByteArray(); var callbackMessageIdentifier = MessageIdentifier.Create <SimpleMessage>(); var callbackKey = Randomizer.Int32(); message.RegisterCallbackPoint(callbackReceiverNodeIdentity, callbackReceiverIdentity, callbackMessageIdentifier, callbackKey); var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); CollectionAssert.Contains(message.CallbackPoint, callbackMessageIdentifier); CollectionAssert.AreEqual(callbackReceiverIdentity, message.CallbackReceiverIdentity); CollectionAssert.AreEqual(callbackReceiverIdentity, message.ReceiverIdentity); CollectionAssert.AreEqual(callbackReceiverNodeIdentity, message.CallbackReceiverNodeIdentity); CollectionAssert.AreEqual(callbackReceiverNodeIdentity, message.ReceiverNodeIdentity); }
public void WriteMessageAsAWhole() { string boundary = "-----Test"; MultipartMessage message = new MultipartMessage(HeaderField.Parse("Content-type: multipart/mixed; boundary=-----Test")); MultipartMessagePart part; part = new MultipartMessagePart(); part.AddHeader(new HeaderField("Content-Type", "text/plain")); part.Data = Encoding.UTF8.GetBytes("my text"); message.AddPart(part); part = new MultipartMessagePart(); part.AddHeader(new HeaderField("Content-Type", "application/xml")); part.Data = Encoding.UTF8.GetBytes("<tag/>"); message.AddPart(part); using (MemoryStream stream = new MemoryStream()) { long writtenBytes; using (MultipartStreamWriter writer = new MultipartStreamWriter( stream, boundary, Encoding.UTF8)) { writer.WriteWholeMessage(message); writtenBytes = writer.BytesWritten; } byte[] bytes = stream.ToArray(); Assert.AreEqual(bytes.Length, writtenBytes); string result = Encoding.UTF8.GetString(bytes); Assert.AreEqual("\r\n-------Test\r\nContent-Type: text/plain\r\n\r\nmy text\r\n-------Test\r\nContent-Type: application/xml\r\n\r\n<tag/>\r\n-------Test--", result); } }
public void ProcessMultipartMessage(ref byte[] data) { // create the multipart message byte[] partData = new byte[data.Length - MultipartHeaderLength]; for (int i = 0; i < partData.Length; i++) { partData[i] = data[i + MultipartHeaderLength]; } MultipartMessage message = new MultipartMessage() { Data = partData, MessageID = BitConverter.ToUInt32(data, OffsetMultipartMessageID - MessageHeaderLength), PartIndex = BitConverter.ToUInt16(data, OffsetMultipartPartIndex - MessageHeaderLength), PartCount = BitConverter.ToUInt16(data, OffsetMultipartPartCount - MessageHeaderLength) }; Console.WriteLine("< !MULTIPART-COMPRESSED!: {0} ({1} / {2})", message.MessageID, message.PartIndex + 1, message.PartCount); // lock this crucial part to preven conflicts lock (_MultipartMessageLock) { // add the message to the list if (!_MultipartMessageCache.ContainsKey(message.MessageID)) { _MultipartMessageCache.Add(message.MessageID, new List<MultipartMessage>()); } List<MultipartMessage> messages = _MultipartMessageCache[message.MessageID]; messages.Add(message); if (messages.Count == message.PartCount) { // all parts have arrived // sort the list messages.Sort(); // write the parts into a stream MemoryStream inData = new MemoryStream(); foreach (MultipartMessage part in messages) { inData.Write(part.Data, 0, part.Data.Length); } inData.Position = 0; // decompress the stream MemoryStream outData = new MemoryStream(); Decoder decompressor = new Decoder(); // Read the decoder properties byte[] properties = new byte[5]; inData.Read(properties, 0, 5); // Read in the decompress file size. byte[] dataLengthBytes = new byte[8]; inData.Read(dataLengthBytes, 0, 8); long dataLength = BitConverter.ToInt64(dataLengthBytes, 0); decompressor.SetDecoderProperties(properties); decompressor.Code(inData, outData, inData.Length, dataLength, null); outData.Position = 0; // extract the actual message data byte messageCode = (byte)outData.ReadByte(); byte[] messageLengthData = new byte[4]; outData.Read(messageLengthData, 0, 4); int messageLength = BitConverter.ToInt32(messageLengthData, 0); byte[] messageData = new byte[messageLength]; outData.Read(messageData, 0, messageLength); // close the streams inData.Close(); outData.Close(); // fire the completed multipart message callback _CompletedReceivedMultipartCallback(this, ref messageCode, ref messageData); } } }