private static object EncoderTest(MessageSerializer target, IExtensible msg)
{
byte[] buf1 = target.Serialize(msg);
byte[] buf2 = target.Serialize(target.Deserialize(buf1));
Assert.IsNotNull(buf1);
Assert.IsNotNull(buf2);
Assert.AreEqual(buf1.Length, buf2.Length);
Assert.IsTrue(buf1.SequenceEqual(buf2));
return msg;
}
public void Generic_properties_should_be_supported()
{
IMessageMapper mapper = new MessageMapper();
var serializer = new MessageSerializer
{
MessageMapper = mapper,
MessageTypes = new List <Type>(new[] { typeof(MessageWithGenericProperty) })
};
using (var stream = new MemoryStream())
{
var message = new MessageWithGenericProperty
{
GenericProperty = new GenericProperty <string>("test")
{
WhatEver = "a property"
}
};
serializer.Serialize(new IMessage[] { message }, stream);
stream.Position = 0;
Debug.WriteLine(new StreamReader(stream).ReadToEnd());
stream.Position = 0;
var result = serializer.Deserialize(stream)[0] as MessageWithGenericProperty;
Assert.NotNull(result);
Assert.AreEqual(message.GenericProperty.WhatEver, result.GenericProperty.WhatEver);
}
}
/// <summary>
///
/// </summary>
/// <param name="propertyApiObj"></param>
/// <param name="userPrivateKeys"></param>
/// <param name="token">Throws a <see cref="T:System.OperationCanceledException" /> if this token has had cancellation requested.</param>
/// <param name="operations"></param>
/// <returns></returns>
/// <exception cref="T:System.OperationCanceledException">The token has had cancellation requested.</exception>
public Task <SignedTransaction> CreateTransaction(DynamicGlobalPropertyObject propertyApiObj, IList <byte[]> userPrivateKeys, BaseOperation[] operations, CancellationToken token)
{
return(Task.Run(() =>
{
var transaction = new SignedTransaction
{
ChainId = ChainId,
RefBlockNum = (ushort)(propertyApiObj.HeadBlockNumber & 0xffff),
RefBlockPrefix = (uint)BitConverter.ToInt32(Hex.HexToBytes(propertyApiObj.HeadBlockId), 4),
Expiration = propertyApiObj.Time.Value.AddSeconds(30),
Operations = operations.Select(o => new Operation(o)).ToArray()
};
var msg = MessageSerializer.Serialize <SignedTransaction>(transaction);
var data = Sha256Manager.GetHash(msg);
transaction.Signatures = new string[userPrivateKeys.Count];
for (var i = 0; i < userPrivateKeys.Count; i++)
{
token.ThrowIfCancellationRequested();
var userPrivateKey = userPrivateKeys[i];
var sig = Secp256K1Manager.SignCompressedCompact(data, userPrivateKey);
transaction.Signatures[i] = Hex.ToString(sig);
}
return transaction;
}, token));
}
public override void SendMessage(Message message)
{
var currentClient = GetAvailableClient();
var bytes = serializer.Serialize(message);
currentClient.Send(bytes);
}
public static byte[] Create(N3Message messageBody)
{
IntPtr pEngine = N3Engine_t.GetInstance();
if (pEngine == IntPtr.Zero)
{
return(null);
}
int localDynelInstance = N3EngineClient_t.GetClientInst(pEngine);
messageBody.Identity = new Identity(IdentityType.SimpleChar, localDynelInstance);
var message = new Message
{
Body = messageBody,
Header = new Header
{
MessageId = BitConverter.ToUInt16(new byte[] { 0xFF, 0xFF }, 0),
PacketType = messageBody.PacketType,
Unknown = 0x0001,
Sender = localDynelInstance,
Receiver = 0x02
}
};
using (MemoryStream stream = new MemoryStream())
{
_serializer.Serialize(stream, message);
return(stream.ToArray());
}
}
public void Publish <TPayload>(IMessage message, TPayload payload) where TPayload : IPayload
{
if (!_isInitialized)
{
throw new InvalidOperationException("Not initialized yet, " +
"don't forget to call 'Init()' method at least once");
}
var wrapper = CreateWrapper(payload);
var body = MessageSerializer.Serialize(wrapper);
var channel = GetConnection().CreateModel();
channel.BasicPublish(
exchange: RabbitConsts.ExchangeName,
routingKey: message.RoutingKey,
basicProperties: new BasicProperties()
{
DeliveryMode = 2,
Persistent = true,
ContentType = "application/json",
ContentEncoding = "UTF-8",
AppId = RabbitConsts.QueuePrefix
},
body: body);
}
public async Task CallHandlerAsync <TRequest, TResponse, TIntegrationEventHandler>(ILifetimeScope scope,
QueueOptions options) where TRequest : IntegrationEvent
where TResponse : IntegrationEvent
{
EventingBasicConsumer consumer = BuildChannel(options);
consumer.Received += async(model, args) =>
{
TRequest request = null;
using (ILifetimeScope innerScope = scope.BeginLifetimeScope())
using (MessageSerializer serializaer = new MessageSerializer())
using (IIntegrationEventHandler <TRequest, TResponse> handler = innerScope.Resolve <IIntegrationEventHandler <TRequest, TResponse> >())
{
IBasicProperties props = args.BasicProperties;
IBasicProperties replyProps = Channel.CreateBasicProperties();
replyProps.CorrelationId = props.CorrelationId;
request = Activator.CreateInstance <TRequest>();
if (args.Body.Length > 0)
{
request = serializaer.Deserialize <TRequest>(args.Body.ToArray())[0];
}
TResponse response = await handler.Handle(request);
Channel.BasicPublish("", props.ReplyTo, replyProps, serializaer.Serialize(response)[0]);
Channel.BasicAck(args.DeliveryTag, false);
}
};
}
public void Serialize_WithNullInput_ThrowsArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() =>
{
string result = MessageSerializer.Serialize(null);
});
}
public bool SendMessage(Message message)
{
try
{
string serializedMessage = MessageSerializer.Serialize(message);
byte[] jsonbytes = Encoding.UTF8.GetBytes(serializedMessage);
int size = IPAddress.HostToNetworkOrder(jsonbytes.Length);
byte[] sizeByte = BitConverter.GetBytes(size);
byte[] bytes = new byte[jsonbytes.Length + messageSizeBitLength];
sizeByte.CopyTo(bytes, 0);
jsonbytes.CopyTo(bytes, messageSizeBitLength);
client.Client.Send(bytes);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(false);
}
return(true);
}
public async Task PublishMessage(TMessage message, bool retained = false)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var payload = _serializer.Serialize(message);
var packedMessage = new MqttApplicationMessageBuilder()
.WithTopic(Topic)
.WithPayload(payload)
.WithQualityOfServiceLevel(_qosLevel)
.WithRetainFlag(retained)
.Build();
try
{
await _client.PublishAsync(packedMessage, _cancellationToken.Token);
}
catch (Exception e)
{
Log.Error($"Failed to publish message on topic \"{Topic}\". Exception: {e}");
throw;
}
}
public override void SendMessage(Message message)
{
var channel = GetAvailableChannel();
var bytes = serializer.Serialize(message);
channel.Send(bytes, 0, bytes.Length);
}
public void Culture()
{
var mapper = new MessageMapper();
var serializer = new MessageSerializer();
serializer.MessageMapper = mapper;
serializer.MessageTypes = new List <Type>(new[] { typeof(MessageWithDouble) });
double val = 65.36;
var msg = new MessageWithDouble {
Double = val
};
Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE");
var stream = new MemoryStream();
serializer.Serialize(new[] { msg }, stream);
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
stream.Position = 0;
var msgArray = serializer.Deserialize(stream);
var m = msgArray[0] as MessageWithDouble;
Assert.AreEqual(val, m.Double);
stream.Dispose();
}
/// <summary>
/// Send messages using underlying transport.
/// Serializes message bodies, adds unique ids
/// </summary>
/// <param name="lst"></param>
/// <param name="dbTran">External transaction to be used for sending messages (optional)</param>
internal void SendMessages(IList <MessageContainer> lst, object dbTran)
{
if (lst == null || lst.Count == 0)
{
return;
}
object prevbody = null;
string prevstr = null;
foreach (MessageContainer mc in lst)
{
if (string.IsNullOrEmpty(mc.To))
{
throw new Exception("Message destination missing");
}
if (mc.Body == null)
{
throw new NullReferenceException("Message body is null");
}
if (mc.From == null)
{
mc.From = MessageTransport.Endpoint;
}
if (mc.UniqueId == null || mc.UniqueId.Length == 0)
{
mc.UniqueId = CreateNewMessageUniqueId();
}
if (mc.Body == prevbody)
{
mc.BodyStr = prevstr;
}
else
{
prevbody = mc.Body;
StringWriter sw = new StringWriter();
MessageSerializer.Serialize(mc.Body, sw);
//MessageSerializer.Serialize(mc.Body, sw);
mc.BodyStr = sw.ToString();
prevstr = mc.BodyStr;
}
}
if (Transaction.Current == null || BatchOutgoingMessagesInTransaction == false)
{
MessageTransport.SendBatch(lst, dbTran);
}
else
{
MessageBatchingRM rm = GetCreateMessageBatchForCurrentTransaction();
if (!rm.TransactionOpen)
{
throw new Exception("Transaction is not open: " + rm.TransactionId);
}
foreach (MessageContainer mw in lst)
{
rm.Messages.Add(mw);
}
}
}
public void GetSerializerAndVerifySerialization()
{
IHost host = CreateHubHost();
MessageSerializer serializer = host.GetService <MessageSerializer>();
byte[] bytes = serializer.Serialize(new AckMessage("1234"));
Assert.NotEmpty(bytes);
}
private byte[] Serialize(MessageSerializer messageSerializer, Message message)
{
using (var memoryStream = new MemoryStream())
{
messageSerializer.Serialize(memoryStream, message);
return(memoryStream.ToArray());
}
}
public void Should_serialize()
{
var request = Examples.Basic_get_request_causing_a_piggy_backed_response();
var bytes = _serializer.Serialize(request);
Assert.AreEqual(16, bytes.Length);
}
public void Subscribe(string destination)
{
var message = new SubscriptionMessage
{
Topic = destination
};
_websocket.Send(_serializer.Serialize(message));
}
public static TransportMessage ToTransportMessage(this IMessage message, Peer sender = null)
{
sender = sender ?? new Peer(new PeerId("Abc.Testing.Peer"), "tcp://abctest:159");
var serializer = new MessageSerializer();
var messageBytes = serializer.Serialize(message);
return(new TransportMessage(message.TypeId(), messageBytes, sender));
}
public override void SendMessage(Message message)
{
var bytes = serializer.Serialize(message);
httpContext.Response.StatusCode = (int)HttpStatusCode.OK;
httpContext.Response.ContentLength64 = bytes.Length;
httpContext.Response.ContentType = "application/octet-stream";
httpContext.Response.OutputStream.Write(bytes, 0, bytes.Length);
}
public void SendMessage(IMessage message)
{
var payload = MessageSerializer.Serialize(message);
TcpClient.Client.Send(payload);
Console.WriteLine("Sent message[{0},{1}]: {2}",
User != null ? User.Username : "******",
User != null ? User.UserId : -1,
message);
}
public SaveState GetSaveState()
{
return(new SaveState
{
Entities = _systemContainer.EntityEngine.MutableEntities.Select(e => EntitySerializer.Serialize(e)).ToList(),
Maps = _systemContainer.MapSystem.MapCollection.AllMaps.Select(m => MapSerializer.Serialize(m)).ToList(),
Time = _systemContainer.TimeSystem.CurrentTime,
Messages = _systemContainer.MessageSystem.AllMessages.Select(m => MessageSerializer.Serialize(m)).ToList()
});
}
public async Task <TResponseEvent> CallAsync <TRequestEvent, TResponseEvent>(TRequestEvent request, IComponentContext context, QueueOptions options) where TRequestEvent : IntegrationEvent
where TResponseEvent : IntegrationEvent
{
MessageSerializer serializaer = new MessageSerializer();
byte[] byteRequest = serializaer.Serialize(request)[0];
byte[] byteResponse = await CallAsync(byteRequest, options);
return(serializaer.Deserialize <TResponseEvent>(byteResponse)[0]);;
}
/// <summary>
/// Updates all relevant players.
/// </summary>
/// <param name="playerId">Player that has changed.</param>
private void Update(string playerId)
{
// TODO: Update only clients that are correlating with changed player.
foreach (var client in _connectedClients)
{
var status = GetStatus(client.PlayerId);
MessageSerializer.Serialize(client.Stream, status);
}
}
public void SendTo(string ip, IMessage msg)
{
var ms = MessageSerializer.Serialize(msg);
IPAddress serverAddr = IPAddress.Parse(ip);
IPEndPoint endPoint = new IPEndPoint(serverAddr, 28888);
m_Client.Connect(endPoint);
m_Client.Send(ms.GetBuffer(), (int)ms.Length);
}
public void MessageSerializer_SerializeRequestWithParameterTest()
{
Message message = Message.CreateRequest("test");
message.Params = new JObject {
{ "xx", "val" }
};
string jsonMessage = MessageSerializer.Serialize(message);
Assert.AreEqual($@"{{""jsonrpc"":""2.0"",""method"":""test"",""id"":{message.Id},""params"":{{""xx"":""val""}}}}", jsonMessage);
}
public void SetClientSocketForUDPListening()
{
listeningUDPSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
IPAddress IPaddress = CommonInfo.GetHostsIPAddress();
IPEndPoint IPLocalPoint = new IPEndPoint(IPaddress, SERVERUDPPORT);
listeningUDPSocket.Bind(IPLocalPoint);
var message = new Message(IPaddress.ToString(), SERVERUDPPORT, Message.MessageType[6]);
IPAddress broadcastIPaddress = CommonInfo.GetHostsBroadcastIPAddress();
IPEndPoint IPendPoint = new IPEndPoint(broadcastIPaddress, SERVERUDPPORT);
listeningUDPSocket.SendTo(messageSerializer.Serialize(message), IPendPoint);
Thread threadReceiveUDPMessages = new Thread(ReceiveUDPMessages);
threadsList.Add(threadReceiveUDPMessages);
threadReceiveUDPMessages.Start();
}
public void SaveSystem_WithMessage_SerialisesMessage()
{
var message = new Message {
Text = "message", Color = Color.AliceBlue
};
_messages.Add(message);
var result = _saveSystem.GetSaveState();
result.Messages.Single().Should().Be(MessageSerializer.Serialize(message));
}
public static TransportMessage ToTransportMessage(this IMessage message, Peer sender = null, bool?wasPersisted = null)
{
sender = sender ?? new Peer(new PeerId("Abc.Testing.Peer"), "tcp://abctest:159");
var serializer = new MessageSerializer();
var content = serializer.Serialize(message);
return(new TransportMessage(message.TypeId(), content, sender)
{
WasPersisted = wasPersisted
});
}
/// <summary>
/// Publish a message.
/// </summary>
/// <param name="messageType">Type of the message.</param>
/// <param name="message">The message to publish.</param>
/// <param name="routingKey">The routingkey to use (RabbitMQ specific).</param>
public Task PublishMessageAsync(string messageType, object message, string routingKey)
{
return(Task.Run(() =>
{
string data = MessageSerializer.Serialize(message);
var body = Encoding.UTF8.GetBytes(data);
IBasicProperties properties = _model.CreateBasicProperties();
properties.Headers = new Dictionary <string, object> {
{ "MessageType", messageType }
};
_model.BasicPublish(_exchange, routingKey, properties, body);
}));
}
public async Task PushAsync(QueueMessage <T> message)
{
var body = await MessageSerializer.Serialize(message.Item);
using (var brokeredMessage = new BrokeredMessage(body))
{
brokeredMessage.CorrelationId = message.CorrelationId.ToString();
await _queueClient.SendAsync(brokeredMessage);
message.MessageId = brokeredMessage.MessageId;
}
}
private void SendToFailoverQueue(TransportMessage transportMessage, string destination)
{
Message toSend = new Message();
if (transportMessage.Body == null && transportMessage.BodyStream != null)
{
toSend.BodyStream = transportMessage.BodyStream;
}
else
{
MessageSerializer.Serialize(transportMessage.Body, toSend.BodyStream);
}
if (transportMessage.CorrelationId != null)
{
toSend.CorrelationId = transportMessage.CorrelationId;
}
else
{
toSend.CorrelationId = toSend.Id;
transportMessage.CorrelationId = toSend.Id;
transportMessage.IdForCorrelation = toSend.Id;
}
toSend.Recoverable = transportMessage.Recoverable;
toSend.ResponseQueue = new MessageQueue(GetFullPath(transportMessage.ReturnAddress));
FillLabel(toSend, transportMessage);
if (transportMessage.TimeToBeReceived < MessageQueue.InfiniteTimeout)
{
toSend.TimeToBeReceived = transportMessage.TimeToBeReceived;
}
if (transportMessage.Headers == null)
{
transportMessage.Headers = new List <HeaderInfo>();
}
transportMessage.Headers.Add(new HeaderInfo {
Key = "destination", Value = destination
});
if (transportMessage.Headers != null && transportMessage.Headers.Count > 0)
{
MemoryStream stream = new MemoryStream();
HeaderSerializer.Serialize(stream, transportMessage.Headers);
toSend.Extension = stream.GetBuffer();
}
FailoverQueue.Send(toSend, GetTransactionTypeForSend());
}
public void CanSerializeAndBack()
{
var serializer = new MessageSerializer
{
MessageMapper = new MessageMapper(),
MessageTypes = new List<Type> { typeof(MessageWithArray) }
};
var message = new MessageWithArray(Guid.NewGuid(), new int[] { 1234, 5323 });
var stream = new MemoryStream();
serializer.Serialize(new object[] { message }, stream);
stream.Position = 0;
var messages = serializer.Deserialize(stream);
Assert.NotNull(messages);
Assert.That(messages, Has.Length.EqualTo(1));
Assert.That(messages[0], Is.TypeOf(typeof(MessageWithArray)));
var m = (MessageWithArray)messages[0];
Assert.IsNotNull(m.SomeInts);
Assert.That(m.SomeInts, Has.Length.EqualTo(2));
Assert.AreEqual(1234, m.SomeInts[0]);
Assert.AreEqual(5323, m.SomeInts[1]);
}
