public void ChunkIfNeeded_SmallMessage_ReturnedWithoutChanges()
{
var message = new BinaryMessage
{
MessageId = Guid.NewGuid(),
Content = GetByteArray(100)
};
var headers = new MessageHeaderCollection();
var serializedMessage = _serializer.Serialize(message, headers);
var rawBrokerMessage =
new RawBrokerMessage(message, headers,
new TestProducerEndpoint("test")
{
Chunk = new ChunkSettings
{
Size = 500
}
})
{
RawContent = serializedMessage
};
var chunks = ChunkProducer.ChunkIfNeeded(rawBrokerMessage);
chunks.Should().HaveCount(1);
chunks.First().Should().BeEquivalentTo(rawBrokerMessage);
}
public void ChunkIfNeeded_LargeMessage_Chunked()
{
var message = new BinaryMessage
{
MessageId = Guid.NewGuid(),
Content = GetByteArray(1400)
};
var headers = new MessageHeaderCollection
{
{ MessageHeader.MessageIdKey, "1234" }
};
var serializedMessage = _serializer.Serialize(message, headers);
var rawBrokerMessage =
new RawBrokerMessage(message, headers,
new TestProducerEndpoint("test")
{
Chunk = new ChunkSettings
{
Size = 500
}
})
{
RawContent = serializedMessage
};
var chunks = ChunkProducer.ChunkIfNeeded(rawBrokerMessage);
chunks.Should().HaveCount(4);
chunks.Should().Match(c => c.All(m => m.RawContent.Length < 1000));
}
internal static void Push(RtmpConnection connection, IMessage message, IMessageClient messageClient)
{
if (connection != null)
{
object obj2 = message;
if (message is BinaryMessage)
{
BinaryMessage message2 = message as BinaryMessage;
message2.Update(messageClient);
byte[] body = message2.body as byte[];
RawBinary binary = new RawBinary(body);
obj2 = binary;
}
else
{
message.SetHeader("DSDstClientId", messageClient.ClientId);
message.clientId = messageClient.ClientId;
}
RtmpChannel channel = connection.GetChannel(3);
FlexInvoke invoke = new FlexInvoke {
Cmd = "receive",
InvokeId = connection.InvokeId,
Response = obj2
};
channel.Write(invoke);
}
}
public static Started ReadDataFrom(BinaryReader reader)
{
return(new Started
{
Command = BinaryMessage.ReadFrom(reader)
});
}
public override void DisAssembleBinaryResult(byte[] message, List <List <byte> > dataRequestBytes)
{
if (message != null)
{
m_messageFromPLC = new BinaryMessage(message, m_messageToPLC, dataRequestBytes);
}
}
private void send(IDestination destination, BinaryMessage message, int ttl, Action <IMessage> tuneMessage = null)
{
ITextMessage textMessage = m_Session.CreateTextMessage();
textMessage.Text = Encoding.UTF8.GetString(message.Bytes ?? new byte[0]);
IMessage sonicMessage = textMessage;
sonicMessage.SetStringProperty(TransportConstants.JAILED_PROPERTY_NAME, m_JailedTag);
sonicMessage.JMSType = message.Type;
if (tuneMessage != null)
{
tuneMessage(sonicMessage);
}
foreach (var param in m_CustomHeaders)
{
sonicMessage.SetStringProperty(param.Key, param.Value);
}
IMessageProducer producer = m_Session.CreateProducer(destination);
using (Disposable.Create(producer.Close))
{
producer.Send(sonicMessage, Constants.DeliveryMode.PERSISTENT, TransportConstants.MESSAGE_DEFAULT_PRIORITY, ttl);
}
}
private void send(BinaryMessage message, Endpoint endpoint, int ttl, string processingGroup)
{
if (endpoint.Destination == null)
{
throw new ArgumentException("Destination can not be null");
}
if (m_Disposing.WaitOne(0))
{
throw new InvalidOperationException("Engine is disposing");
}
using (m_RequestsTracker.Track())
{
try
{
var procGroup = m_TransportManager.GetProcessingGroup(endpoint.TransportId, processingGroup);
procGroup.Send(endpoint.Destination.Publish, message, ttl);
}
catch (Exception e)
{
m_Logger.ErrorException(string.Format("Failed to send message. Transport: {0}, Queue: {1}", endpoint.TransportId, endpoint.Destination), e);
throw;
}
}
}
#pragma warning restore 67
/// <inheritdoc />
public void Send(BinaryMessage message)
{
// Create bytes from message
var bytes = _validator.Interpreter.SerializeMessage(message);
_serialPort.Write(bytes, 0, bytes.Length);
}
private void send(Destination destination, BinaryMessage message, int ttl, Action <Message> tuneMessage = null)
{
Message sonicMessage;
switch (m_MessageFormat)
{
case MessageFormat.Text:
var textMessage = m_Session.createTextMessage();
textMessage.setText(Encoding.UTF8.GetString(message.Bytes ?? new byte[0]));
sonicMessage = textMessage;
break;
case MessageFormat.Binary:
default:
var bytesMessage = m_Session.createBytesMessage();
bytesMessage.writeBytes(message.Bytes ?? new byte[0]);
sonicMessage = bytesMessage;
break;
}
sonicMessage.setStringProperty(SonicTransportConstants.JAILED_PROPERTY_NAME, m_JailedTag);
sonicMessage.setJMSType(message.Type);
if (tuneMessage != null)
{
tuneMessage(sonicMessage);
}
MessageProducer producer = m_Session.createProducer(destination);
using (Disposable.Create(producer.close))
{
producer.send(sonicMessage, DeliveryMode.PERSISTENT, DefaultMessageProperties.DEFAULT_PRIORITY, ttl);
}
//TODO: destroy session
}
public void ProcessMessage(BinaryMessage t_recvdMsg)
{
GameMessageReader t_reader = new GameMessageReader();
t_reader.InitAdapter(ref t_recvdMsg);
switch(t_reader.GetFunctionCode())
{
case (ushort)Function_Codes.FUNCTION_USER_NEWROOM:
{
string t_name = "";
ushort t_roomType = 0;
t_reader.Decode_FunctionUserNewRoom(ref t_roomType,
ref t_name);
if(t_roomType == (ushort)Function_Codes.ROOM_TYPE_CHAT)
{
Debug.Log("NEW ROOM CHAT!");
Room t_room = new Room();
t_room.SetRoomInfo(ref t_name, ref t_roomType);
m_controller.m_liveController.SendRoomStateData(t_room);
if(!m_controller.m_liveController.CheckDataSaved())
{
m_controller.m_liveController.SendClientUserData(m_clientUser);
}
Application.LoadLevel(0);
}
break;
}
}
}
private void processMessage(BinaryMessage binaryMessage, Type type, Action <object> callback, AcknowledgeDelegate ack, Endpoint endpoint)
{
object message = null;
try
{
message = m_SerializationManager.Deserialize(endpoint.SerializationFormat, binaryMessage.Bytes, type);
}
catch (Exception e)
{
m_Logger.ErrorException(string.Format("Failed to deserialize message. Transport: {0}, Destination: {1}, Message Type: {2}",
endpoint.TransportId, endpoint.Destination, type.Name), e);
//TODO: need to unack without requeue
ack(DEFAULT_UNACK_DELAY, false);
}
try
{
callback(message);
}
catch (Exception e)
{
m_Logger.ErrorException(string.Format("Failed to handle message. Transport: {0}, Destination: {1}, Message Type: {2}",
endpoint.TransportId, endpoint.Destination, type.Name), e);
ack(DEFAULT_UNACK_DELAY, false);
}
}
public async Task WritingNotifiesCallbackWhenHostHasClosed()
{
var wroteMessage = new TaskCompletionSource <Unit>();
var hostClosed = new AutoResetEvent(false);
var exception = new TaskCompletionSource <Exception>();
var disposed = false;
var hostTask = Pipe.Host(_pipeName);
var task = Task.Run(() =>
{
using (_pipeName.BeginWritingMessages("name", e => exception.SetResult(e), Observable.Create <IBinaryMessage>(obs =>
{
obs.OnNext(IntMessage.Compose(42));
wroteMessage.SetResult(Unit.Default);
hostClosed.WaitOne();
obs.OnNext(IntMessage.Compose(43));
return(Disposable.Create(() => disposed = true));
}))){}
});
var host = await hostTask;
await wroteMessage.Task;
using (var reader = new BinaryReader(host))
{
var msg = IntMessage.TryParse(BinaryMessage.ReadFrom(reader));
Assert.AreEqual(42, msg.Value);
}
Assert.IsFalse(exception.Task.IsCompleted);
host.Close();
hostClosed.Set();
await task;
Assert.IsNotNull(await exception.Task);
Assert.IsTrue(disposed);
}
public byte[] GetToken()
{
Send(BinaryMessage.Make(CMD_GETTOKEN).Complete());
var reply = GetReply();
return(reply.Type == 0 ? reply.GetData() : null);
}
public void Send(
object message,
Endpoint endpoint,
string processingGroup = null,
Dictionary <string, string> headers = null)
{
var type = GetMessageType(message.GetType());
var bytes = m_SerializationManager.SerializeObject(endpoint.SerializationFormat, message);
var serializedMessage = new BinaryMessage
{
Bytes = bytes,
Type = type,
};
if (headers != null)
{
foreach (var header in headers)
{
serializedMessage.Headers[header.Key] = header.Value;
}
}
Send(
serializedMessage,
endpoint,
MESSAGE_DEFAULT_LIFESPAN,
processingGroup);
}
public bool AddMessage(ref BinaryMessage t_msg)
{
bool messageAdded = false;
int count = 0;
byte[] t_buff = t_msg.GetMessageDataWithLen();
int i = m_endPos;
int finIndex = GetNextValidIndex(m_endPos, t_msg.GetMessageLen_wLen());
if (finIndex < m_endPos)
{
for (; i < m_bufferSize; i++)
{
m_buffer[i] = t_buff[count];
count++;
}
i = GetNextValidIndex(i);
for (; i < finIndex; i = GetNextValidIndex(i))
{
m_buffer[i] = t_buff[count];
count++;
}
}
else
{
for (; i < finIndex; i = GetNextValidIndex(i))
{
m_buffer[i] = t_buff[count];
count++;
}
}
m_endPos = GetNextValidIndex(m_endPos, t_msg.GetMessageLen_wLen());
messageAdded = true;
return messageAdded;
}
private void Send(
BinaryMessage message,
Endpoint endpoint,
int ttl,
string processingGroup)
{
if (endpoint.Destination == null)
{
throw new ArgumentException("Destination can not be null");
}
if (m_Disposing.WaitOne(0))
{
throw new InvalidOperationException("Engine is disposing");
}
using (m_RequestsTracker.Track())
{
try
{
m_ProcessingGroupManager.Send(
endpoint,
message,
ttl,
GetProcessingGroup(endpoint, processingGroup));
}
catch (Exception e)
{
_log.WriteError(nameof(Send), $"Failed to send message. Transport: {endpoint.TransportId}, Queue: {endpoint.Destination}", e);
throw;
}
}
}
public void BinaryMessageBasicSerialization ()
{
var m = new BinaryMessage ("Test");
m.AddArgument ("string", "foo");
m.AddArgument ("bool", true);
m.AddArgument ("float", 44f);
m.AddArgument ("double", 45d);
m.AddArgument ("short", (short)46);
m.AddArgument ("int", 47);
m.AddArgument ("long", 48L);
m.AddArgument ("byte", (byte)49);
m.AddArgument ("DateTime", new DateTime (2016, 2, 17));
m.AddArgument ("TimeSpan", TimeSpan.FromSeconds (44));
MemoryStream ms = new MemoryStream ();
m.Write (ms);
ms.Position = 0;
m = BinaryMessage.Read (ms);
Assert.AreEqual (10, m.Args.Count);
Assert.AreEqual ("foo", m.GetArgument ("string"));
Assert.AreEqual (true, m.GetArgument ("bool"));
Assert.AreEqual (44f, m.GetArgument ("float"));
Assert.AreEqual (45d, m.GetArgument ("double"));
Assert.AreEqual ((short)46, m.GetArgument ("short"));
Assert.AreEqual (47, m.GetArgument ("int"));
Assert.AreEqual (48L, m.GetArgument ("long"));
Assert.AreEqual ((byte)49, m.GetArgument ("byte"));
Assert.AreEqual (new DateTime (2016, 2, 17), m.GetArgument ("DateTime"));
Assert.AreEqual (TimeSpan.FromSeconds (44), m.GetArgument ("TimeSpan"));
}
public void DataAndTypeAreReadWriteInvariant()
{
var pipe = PipeName.New();
var outbox = new []
{
BinaryMessage.Compose("Elm1", writer => { }),
BinaryMessage.Compose("Elm1", writer => { }),
BinaryMessage.Compose("Elm2", writer => writer.Write(new byte[] { 13, 37 })),
BinaryMessage.Compose("Elm3", writer => writer.Write(new byte[] { 19, 11 })),
BinaryMessage.Compose("Elm4", writer => { })
};
pipe.BeginWritingMessages("Test", ex => Assert.Fail("Write failed: " + ex.Message), outbox.ToObservable());
var inbox = pipe.ReadMessages("test").RefCount().ToEnumerable().Take(outbox.Length).ToArray();
Assert.AreEqual(outbox.Length, inbox.Length);
for (int i = 0; i < outbox.Length; i++)
{
Assert.AreEqual(outbox[i].Type, inbox[i].Type);
CollectionAssert.AreEqual(outbox[i].DumpBytes(), inbox[i].DumpBytes());
}
}
public void BinaryMessageArraySerialization ()
{
var m = new BinaryMessage ("Test");
m.AddArgument ("string", new [] { "foo", "bar" });
m.AddArgument ("bool", new [] { true, false });
m.AddArgument ("float", new [] { 44f, 45f });
m.AddArgument ("double", new [] { 45d, 46d });
m.AddArgument ("short", new short [] { 46, 47 });
m.AddArgument ("int", new int [] { 47, 48 });
m.AddArgument ("long", new [] { 48L, 49L });
m.AddArgument ("byte", new byte [] { 49, 50 });
m.AddArgument ("DateTime", new [] { new DateTime (2016, 2, 17), new DateTime (2016, 2, 18) });
m.AddArgument ("TimeSpan", new [] { TimeSpan.FromSeconds (44), TimeSpan.FromSeconds (45) });
MemoryStream ms = new MemoryStream ();
m.Write (ms);
ms.Position = 0;
m = BinaryMessage.Read (ms);
Assert.AreEqual (10, m.Args.Count);
Assert.AreEqual (new [] { "foo", "bar" }, m.GetArgument ("string"));
Assert.AreEqual (new [] { true, false }, m.GetArgument ("bool"));
Assert.AreEqual (new [] { 44f, 45f }, m.GetArgument ("float"));
Assert.AreEqual (new [] { 45d, 46d }, m.GetArgument ("double"));
Assert.AreEqual (new short [] { 46, 47 }, m.GetArgument ("short"));
Assert.AreEqual (new int [] { 47, 48 }, m.GetArgument ("int"));
Assert.AreEqual (new [] { 48L, 49L }, m.GetArgument ("long"));
Assert.AreEqual (new byte [] { 49, 50 }, m.GetArgument ("byte"));
Assert.AreEqual (new [] { new DateTime (2016, 2, 17), new DateTime (2016, 2, 18) }, m.GetArgument ("DateTime"));
Assert.AreEqual (new [] { TimeSpan.FromSeconds (44), TimeSpan.FromSeconds (45) }, m.GetArgument ("TimeSpan"));
}
private void Send(PublicationAddress destination, BinaryMessage message, Action <IBasicProperties> tuneMessage = null)
{
try
{
var properties = m_Model.CreateBasicProperties();
properties.Headers = new Dictionary <string, object>();
properties.DeliveryMode = 2; //persistent
foreach (var header in message.Headers)
{
properties.Headers[header.Key] = header.Value;
}
if (message.Type != null)
{
properties.Type = message.Type;
}
tuneMessage?.Invoke(properties);
properties.Headers.Add("initialRoute", destination.ToString());
lock (m_Model)
{
m_Model.BasicPublish(destination.ExchangeName, destination.RoutingKey, true, properties, message.Bytes);
if (m_ConfirmedSending)
{
m_Model.WaitForConfirmsOrDie();
}
}
}
catch (AlreadyClosedException e)
{
m_OnSendFail(this, destination, e);
throw;
}
}
public void BinaryMessageBasicSerialization()
{
var m = new BinaryMessage("Test");
m.AddArgument("string", "foo");
m.AddArgument("bool", true);
m.AddArgument("float", 44f);
m.AddArgument("double", 45d);
m.AddArgument("short", (short)46);
m.AddArgument("int", 47);
m.AddArgument("long", 48L);
m.AddArgument("byte", (byte)49);
m.AddArgument("DateTime", new DateTime(2016, 2, 17));
m.AddArgument("TimeSpan", TimeSpan.FromSeconds(44));
MemoryStream ms = new MemoryStream();
m.Write(ms);
ms.Position = 0;
m = BinaryMessage.Read(ms);
Assert.AreEqual(10, m.Args.Count);
Assert.AreEqual("foo", m.GetArgument("string"));
Assert.AreEqual(true, m.GetArgument("bool"));
Assert.AreEqual(44f, m.GetArgument("float"));
Assert.AreEqual(45d, m.GetArgument("double"));
Assert.AreEqual((short)46, m.GetArgument("short"));
Assert.AreEqual(47, m.GetArgument("int"));
Assert.AreEqual(48L, m.GetArgument("long"));
Assert.AreEqual((byte)49, m.GetArgument("byte"));
Assert.AreEqual(new DateTime(2016, 2, 17), m.GetArgument("DateTime"));
Assert.AreEqual(TimeSpan.FromSeconds(44), m.GetArgument("TimeSpan"));
}
internal static void Push(RtmpConnection connection, IMessage message, IMessageClient messageClient)
{
if (connection != null)
{
object response = message;
if (message is BinaryMessage)
{
BinaryMessage binaryMessage = message as BinaryMessage;
binaryMessage.Update(messageClient);
byte[] binaryContent = binaryMessage.body as byte[];
//byte[] destClientBinaryId = messageClient.GetBinaryId();
//Array.Copy(destClientBinaryId, 0, binaryContent, binaryMessage.PatternPosition, destClientBinaryId.Length);
RawBinary result = new RawBinary(binaryContent);
response = result;
}
else
{
//This should be a clone of the original message
message.SetHeader(MessageBase.DestinationClientIdHeader, messageClient.ClientId);
message.clientId = messageClient.ClientId;
}
RtmpChannel channel = connection.GetChannel(3);
FlexInvoke reply = new FlexInvoke();
Call call = new Call("receive", new object[] { response });
reply.ServiceCall = call;
//reply.Cmd = "receive";
//reply.Response = response;
reply.InvokeId = connection.InvokeId;
channel.Write(reply);
}
}
public override void Send <TMessage>(TMessage message)
{
var gridRequest = message as MapRequestGrid;
if (gridRequest != null)
{
var msg = BinaryMessage.Make(MSG_MAPREQ)
.Coord(gridRequest.Coord)
.Complete();
Send(msg);
return;
}
var widgetMessage = message as WidgetMessage;
if (widgetMessage != null)
{
var msg = BinaryMessage.Make(RMSG_WDGMSG)
.UInt16(widgetMessage.WidgetId)
.String(widgetMessage.Name);
if (widgetMessage.Args != null)
{
msg.List(widgetMessage.Args);
}
SendSeqMessage(msg.Complete());
return;
}
throw new ArgumentException($"Unsupported outgoing message type '{message.GetType().Name}'");
}
private async void SendExecuteAsync()
{
var textMessage = new AVIMTextMessage(this.InputText);
//await ConversationInSession.SendMessageAsync(textMessage);
var emojiMessage = new Emoji()
{
Ecode = "#e001",
};
//await ConversationInSession.SendMessageAsync(emojiMessage);
var emojiV2Message = new EmojiV2("#e001");
//await ConversationInSession.SendMessageAsync(emojiV2Message);
var text = "I love Unity";
var textBytes = System.Text.Encoding.UTF8.GetBytes(text);
var binaryMessage = new BinaryMessage(textBytes);
await ConversationInSession.SendMessageAsync(binaryMessage);
//await SendBinaryMessageAsync();
//App.Current.Dispatcher.Invoke((Action)delegate
//{
// var item = new MessageViewModel(textMessage);
// MessagesInSession.Add(item);
// this.SelectedItem = item;
//});
this.InputText = "";
}
public int PumpMessageReader(ref Socket t_sock, ref BinaryMessage t_msg)
{
int messageRead = -1;
if (AmountBuffered() > 0)
{
ushort t_len = BitConverter.ToUInt16(m_buffer, m_startPos);
if (AmountBuffered() > t_len)
{
byte[] t_msgBuff = new byte[t_len];
Get(ref t_msgBuff);
t_msg.AddToMessage(ref t_msgBuff, t_len);
messageRead = 1;
return messageRead;
}
}
if (t_sock.Available > 0)
{
//Debug.Log("Im inside!");
byte[] t_buffer = new byte[1024];
int recvdBytes = t_sock.Receive(t_buffer);
Put(ref t_buffer, recvdBytes);
messageRead = 2;
return messageRead;
}
return messageRead;
}
public void Send(Endpoint endpoint, BinaryMessage message, int ttl, string processingGroup)
{
var group = GetProcessingGroup(processingGroup);
var session = m_TransportManager.GetMessagingSession(endpoint, GetSessionName(group, 0));
group.Send(session, endpoint.Destination.Publish, message, ttl);
}
public void BinaryMessageArraySerialization()
{
var m = new BinaryMessage("Test");
m.AddArgument("string", new [] { "foo", "bar" });
m.AddArgument("bool", new [] { true, false });
m.AddArgument("float", new [] { 44f, 45f });
m.AddArgument("double", new [] { 45d, 46d });
m.AddArgument("short", new short [] { 46, 47 });
m.AddArgument("int", new int [] { 47, 48 });
m.AddArgument("long", new [] { 48L, 49L });
m.AddArgument("byte", new byte [] { 49, 50 });
m.AddArgument("DateTime", new [] { new DateTime(2016, 2, 17), new DateTime(2016, 2, 18) });
m.AddArgument("TimeSpan", new [] { TimeSpan.FromSeconds(44), TimeSpan.FromSeconds(45) });
MemoryStream ms = new MemoryStream();
m.Write(ms);
ms.Position = 0;
m = BinaryMessage.Read(ms);
Assert.AreEqual(10, m.Args.Count);
Assert.AreEqual(new [] { "foo", "bar" }, m.GetArgument("string"));
Assert.AreEqual(new [] { true, false }, m.GetArgument("bool"));
Assert.AreEqual(new [] { 44f, 45f }, m.GetArgument("float"));
Assert.AreEqual(new [] { 45d, 46d }, m.GetArgument("double"));
Assert.AreEqual(new short [] { 46, 47 }, m.GetArgument("short"));
Assert.AreEqual(new int [] { 47, 48 }, m.GetArgument("int"));
Assert.AreEqual(new [] { 48L, 49L }, m.GetArgument("long"));
Assert.AreEqual(new byte [] { 49, 50 }, m.GetArgument("byte"));
Assert.AreEqual(new [] { new DateTime(2016, 2, 17), new DateTime(2016, 2, 18) }, m.GetArgument("DateTime"));
Assert.AreEqual(new [] { TimeSpan.FromSeconds(44), TimeSpan.FromSeconds(45) }, m.GetArgument("TimeSpan"));
}
public void ParseFullDelimiterMessage(int leadingChunk)
{
var text = Encoding.Unicode.GetBytes("Wie passend, du kämpfst wie eine Kuh!");
// Arrange
var message = new List <byte>();
for (var i = 1; i <= leadingChunk; i++)
{
message.Add((byte)i);
}
message.AddRange(TestDelimiterInterpreter.TestStartDelimiter);
message.AddRange(text);
message.AddRange(EndDelimiterOnlyInterpreter.TestEndDelimiter);
var readMessage = message.ToArray();
// Act
BinaryMessage published = null;
Array.Copy(readMessage, 0, _context.ReadBuffer, 0, readMessage.Length);
_interpreter.ProcessReadBytes(_context, readMessage.Length, m => published = m);
// Assert
Assert.IsFalse(_context.StartFound);
Assert.AreEqual(0, _context.CurrentIndex);
Assert.NotNull(published);
Assert.AreEqual(readMessage.Length - leadingChunk, published.Payload.Length);
Assert.AreEqual(readMessage.Skip(leadingChunk).Sum(e => (short)e), published.Payload.Sum(e => (short)e));
}
/// <summary>
/// Create a new Example
/// </summary>
public Example()
{
Log = new LogMessage();
Structures = new StructuresMessage();
Binary = new BinaryMessage();
Types = new TypesMessage();
}
public void BinaryMessageMapSerialization()
{
Dictionary <string, object> data1 = new Dictionary <string, object> ();
data1 ["one"] = 1;
data1 ["two"] = true;
Dictionary <string, string> data2 = new Dictionary <string, string> ();
data2 ["one"] = "uno";
data2 ["two"] = "dos";
Dictionary <int, double[]> data3 = new Dictionary <int, double[]> ();
data3 [1] = new double[] { 11, 111 };
data3 [2] = new double[] { 22, 222 };
var m = new BinaryMessage("Test");
m.AddArgument("map1", data1);
m.AddArgument("map2", data2);
m.AddArgument("map3", data3);
MemoryStream ms = new MemoryStream();
m.Write(ms);
ms.Position = 0;
m = BinaryMessage.Read(ms);
Assert.AreEqual(3, m.Args.Count);
Assert.AreEqual(data1, m.GetArgument("map1"));
Assert.AreEqual(data2, m.GetArgument("map2"));
Assert.AreEqual(data3, m.GetArgument("map3"));
}
public OnMessageEvent(
BinaryMessage message,
uint sequenceNumber,
uint lifeTimeMilliSeconds
) : base(RealtimeEventType.OnMessage, sequenceNumber, lifeTimeMilliSeconds)
{
Message = message;
}
IBinaryMessage MessageFromStream(MemoryStream stream)
{
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new BinaryReader(stream))
{
return(BinaryMessage.ReadFrom(reader));
}
}
public static Ended ReadDataFrom(BinaryReader reader)
{
return(new Ended
{
Command = BinaryMessage.ReadFrom(reader),
Success = reader.ReadBoolean(),
BuildDirectory = AbsoluteDirectoryPath.Read(reader)
});
}
public void Send(
IMessagingSession messagingSession,
string publish,
BinaryMessage message,
int ttl)
{
messagingSession.Send(publish, message, ttl);
Interlocked.Increment(ref m_SentMessages);
}
public static IBinaryMessage Compose(OpenGlVersion openGlVersion)
{
return(BinaryMessage.Compose(Type, writer =>
{
writer.Write(openGlVersion.GlVersion);
writer.Write(openGlVersion.GlVendor);
writer.Write(openGlVersion.GlRenderer);
}));
}
public void Connect (int port, object processListener, bool debugMode = false)
{
DebugMode = debugMode;
socket = new TcpClient ("127.0.0.1", port);
outStream = socket.GetStream ();
inStream = outStream;
AddListener (processListener);
Start ();
BinaryMessage msg = new BinaryMessage ("Connect");
WriteMessage (1, msg);
}
// Update is called once per frame
void Update()
{
if(m_controller.m_liveController != null)
m_controller.m_liveController.ProcessController();
if (Input.GetKey("p"))
{
BinaryMessage t_msg = new BinaryMessage();
t_msg.Init(1024);
GameMessageWriter t_writer = new GameMessageWriter();
t_writer.InitAdapter(ref t_msg);
t_writer.Encode_FunctionRequestLeaveGame();
m_controller.m_liveController.QueueMessage(t_msg);
}
}
public void ProcessMessage(BinaryMessage t_recvdMsg)
{
GameMessageReader t_reader = new GameMessageReader();
t_reader.InitAdapter(ref t_recvdMsg);
Debug.Log(t_reader.GetFunctionCode().ToString() + " tank movement recd\n");
switch( t_reader.GetFunctionCode ())
{
case (ushort)Function_Codes.FUNCTION_TANKROOM_USER_MOVE_TANK:
{
float x = 0;
float y = 0;
float z = 0;
float h = 0;
float p = 0;
float r = 0;
t_reader.Decode_FunctionTankUpdatePOSHPR(ref x ,
ref y ,
ref z ,
ref h ,
ref p ,
ref r );
transform.position = new Vector3(x, y, z);
print(h.ToString() + p.ToString() + r.ToString());
Quaternion newOrientation = Quaternion.Euler(new Vector3(h,p,r));
transform.rotation = newOrientation;
break;
}
//case (ushort)Function_Codes.FUNCTION_TANKROOM_USER_ROTATE_TANK:
// {
// short direction = 0;
// t_reader.Decode_FunctionTankUpdateRotation(ref direction);
// if(direction == 1 )
// {
// transform.RotateAroundLocal(Vector3.up, -.02F);
// }
// if(direction == -1)
// {
// transform.RotateAroundLocal(Vector3.up, .02F);
// }
// break;
// }
}
}
//End message specific process functions-----------------------------------
public void ProcessMessage(BinaryMessage t_recvdMsg)
{
GameMessageReader msgReader = new GameMessageReader();
msgReader.InitAdapter(ref t_recvdMsg);
print("FunctionCode " + msgReader.GetFunctionCode());
switch (msgReader.GetFunctionCode())
{
case (ushort)Function_Codes.FUNCTION_USER_LOGIN_RESP:
{
int return_code = 0;
msgReader.Decode_FunctionUserLoginResp(ref return_code,
ref ClientUser.m_id,
ref ClientUser.m_username);
m_currentRoom.AddUserToWindow(ref ClientUser.m_username);
break;
}
case (ushort)Function_Codes.FUNCTION_USER_NEWROOM:
{
ProcessFunctionUserNewRoom(ref msgReader);
break;
}
case (ushort)Function_Codes.FUNCTION_USER_IN_ROOM:
{
ProcessClientUserInRoom(ref msgReader);
break;
}
case (ushort)Function_Codes.FUNCTION_USER_OUT_ROOM:
{
ProcessUserOutRoom(ref msgReader);
break;
}
case (ushort)Function_Codes.FUNCTION_USER_CHAT:
{
ProcessClientChatMsg(ref msgReader);
break;
}
}
}
public void SendMessage (BinaryMessage msg)
{
WriteMessage (1, msg);
}
//Function: QueueMessage
//Argument: none
//Purpose: Simply to add a message from the Intrested Object to the
// buffered writer.
public void QueueMessage(BinaryMessage t_msg)
{
m_writer.AddMessage(ref t_msg);
}
//Function: PumpRPCQueue()
//Argument: none
//Purpose: Function checks the socket for a buffered message. If yes then
// check the code of the message through the current function
// codes and then send the message off to the Intrested Objects
// of that function code.
private void PumpRPCQueue()
{
BinaryMessage t_msg = new BinaryMessage();
t_msg.Init();
int pumped = m_reader.PumpMessageReader(ref m_sock, ref t_msg);
if (pumped == 1)
{
GameMessageReader t_readerAdapter = new GameMessageReader();
t_readerAdapter.InitAdapter(ref t_msg);
List<IntrestedObj> t_list;
if (m_funcCodeIntrestList.TryGetValue(t_readerAdapter.GetFunctionCode(),
out t_list))
{
t_readerAdapter.ResetToFuncCode();
foreach (IntrestedObj t_obj in t_list)
{
t_obj.ProcessMessage(t_msg);
}
}
}
}
public void InitAdapter(ref BinaryMessage t_msg)
{
m_readAdapterMsg = t_msg;
GetInt2u(ref m_functionCode);
}
//Helper functions for the client class and interfacing into the GUI
void KeyUpdater()
{
if (m_chatClientState == (int)ChatState.CHAT)
{
if ((Input.GetKey("enter") || sendButton || Input.GetKey("return")) && textfield != "")
{
//do something with textfieldstring here... send it off in chat message
//ProcessChatMessage( textfield) ????
m_currentRoom.AddMessageToChatWindow(ClientUser.m_username + ": " + textfield);
BinaryMessage t_msg = new BinaryMessage();
t_msg.Init();
GameMessageWriter t_writer = new GameMessageWriter();
t_writer.InitAdapter(ref t_msg);
t_writer.Encode_FunctionUserChat(ref ClientUser.m_username, ref textfield,
ref ClientUser.m_id);
m_controller.m_liveController.QueueMessage(t_msg);
sendButton = false;
textfield = "";
}
}
else if( m_chatClientState == (int)ChatState.LOGON)
{
if ((Input.GetKey("enter") || loginButton || Input.GetKey("return")) && t_userName != "" && t_password != "")
{
BinaryMessage t_msg = new BinaryMessage();
t_msg.Init();
GameMessageWriter t_writer = new GameMessageWriter();
t_writer.InitAdapter(ref t_msg);
t_writer.Encode_FunctionUserLogin(ref t_userName, ref t_password);
m_controller.m_liveController.QueueMessage(t_msg);
m_chatClientState = (int)ChatState.CHAT;
}
}
}
void OnGUI()
{
if(m_chatClientState == (int)ChatState.LOGON)
{
GUI.Box(new Rect(((Screen.width / 2) - 100), 200, 200, 108),
"Accts. disabled, enter any info.");
GUI.Label(new Rect((Screen.width / 2) - 90, 225, 70, 20), "Username:"******"Password:"******"Login"))
{
loginButton = true;
}
}
if (m_chatClientState == (int)ChatState.CHAT)
{
if (GUI.Button(new Rect(GetPercent(.785F, Screen.width),
GetPercent(.857F, Screen.height),
GetPercent(.205F, Screen.width),
GetPercent(.07F, Screen.height)),
"Play Game"))
{
BinaryMessage t_msg = new BinaryMessage();
t_msg.Init();
GameMessageWriter t_writer = new GameMessageWriter();
t_writer.InitAdapter(ref t_msg);
t_writer.Encode_FunctionRequestGame();
m_controller.m_liveController.QueueMessage(t_msg);
}
if (GUI.Button(new Rect(GetPercent(.785F, Screen.width),
GetPercent(.928F, Screen.height),
GetPercent(.205F, Screen.width),
GetPercent(.07F, Screen.height)),
"Exit."))
{
}
GUI.Box(new Rect(GetPercent(.015F, Screen.width),
GetPercent(.19F, Screen.height),
GetPercent(.749F, Screen.width),
GetPercent(.61F, Screen.height)), "");
GUI.Box(new Rect(GetPercent(.785F, Screen.width),
GetPercent(.066F, Screen.height),
GetPercent(.2F, Screen.width),
GetPercent(.773F, Screen.height)), "");
//GUI.Label(new Rect(GetPercent(.1F, Screen.width),
// GetPercent(.02F, Screen.height),
// 300,
// 25), "Vesmar Entertainment - Chat Client Alpha");
// Begin the ScrollView ----- ChatWindow
int numChatMsg = m_currentRoom.GetChatWindowLen();
float extraLines = (float)(((numChatMsg + 1) - 28) * 13.1F);
if (numChatMsg < 28)
{
chatWindow = GUI.BeginScrollView(new Rect(GetPercent(.015F, Screen.width),
GetPercent(.19F, Screen.height),
GetPercent(.749F, Screen.width),
GetPercent(.61F, Screen.height))
, chatWindow,
new Rect(0,
0,
GetPercent(.55F, Screen.width),
GetPercent(.61F, Screen.height)));
//, false, true);
GUI.Label(new Rect(5,
0,
GetPercent(.72F, Screen.width),
GetPercent(.65F, Screen.height)),
//GetPercent(.8F, Screen.height)),
m_currentRoom.GetChatWindowString());
}
else
{
//Debug.Log(chatWindow);
float size = GetPercent(.61F, Screen.height) + extraLines;
//print(m_chatBarPriorFramePos.ToString() + System.Convert.ToInt32(chatWindow.y).ToString());
//if (m_lastFrameNumChatLines != System.Convert.ToInt32(chatWindow.y))
//{
// //Debug.Log("Oh noes");
//}
chatWindow = GUI.BeginScrollView(new Rect(GetPercent(.015F, Screen.width),
GetPercent(.19F, Screen.height),
GetPercent(.749F, Screen.width),
GetPercent(.6F, Screen.height))
, chatWindow,
new Rect(0,
0,
GetPercent(.55F, Screen.width),
GetPercent(.61F, Screen.height) + extraLines));
if (GUI.changed && (numChatMsg == m_lastFrameNumChatLines))
{
m_chatBarPinned = false;
if (extraLines - chatWindow.y <= 0.5)
{
m_chatBarPinned = true;
}
//print("Pls work");
}
if (m_chatBarPinned)
{
chatWindow.y = GetPercent(.61F, Screen.height) + extraLines;
}
m_lastFrameNumChatLines = m_currentRoom.GetChatWindowLen();
GUI.Label(new Rect(5,
0,
GetPercent(.72F, Screen.width),
5000),
//GetPercent(.8F, Screen.height)),
m_currentRoom.GetChatWindowString());
}
// Put something inside the ScrollView
//innerText = m_currentRoom.GetChatWindowString();
//innerText = "";
// End the ScrollView
GUI.EndScrollView();
int numUsers = m_currentRoom.GetUserWindowLen();
//int x = 50;
float extraLines2 = (float)(((numUsers + 1) - 36) * 13.1F);
if (numUsers < 36)
{
// Begin the ScrollView -- UserWindow
userWindow = GUI.BeginScrollView(new Rect(GetPercent(.79F, Screen.width),
GetPercent(.066F, Screen.height),
GetPercent(.198F, Screen.width),
GetPercent(.775F, Screen.height))
, userWindow,
new Rect(0,
0,
GetPercent(.09F, Screen.width),
GetPercent(.775F, Screen.height)));//m_currentRoom.GetUserWindowLen())
//,false, true);
//string testString = "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n49\n50\n";
// Put something inside the ScrollView --- UserWindow
//innerText = m_currentRoom.GetChatWindowString();
GUI.Label(new Rect(0,
0,
GetPercent(.9F, Screen.width),
GetPercent(.765F, Screen.height)),
m_currentRoom.GetUserWindowString());
//GetPercent(.8F, Screen.height)),
//m_currentRoom.GetUserWindowString());
//innerText = "";
}
else
{
userWindow = GUI.BeginScrollView(new Rect(GetPercent(.79F, Screen.width),
GetPercent(.066F, Screen.height),
GetPercent(.1955F, Screen.width),
GetPercent(.772F, Screen.height))
, userWindow,
new Rect(0,
0,
GetPercent(.09F, Screen.width),
GetPercent(.765F, Screen.height) + extraLines2));//m_currentRoom.GetUserWindowLen())
//,false, true);
//string testString = "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n49\n50\n";
// Put something inside the ScrollView --- UserWindow
//innerText = m_currentRoom.GetChatWindowString();
GUI.Label(new Rect(0,
0,
GetPercent(.9F, Screen.width),
5000),
//testString);
m_currentRoom.GetUserWindowString());
}
// End the ScrollView
GUI.EndScrollView();
GUI.Box(new Rect(0,
GetPercent(.85F, Screen.height),
GetPercent(.78F, Screen.width),
GetPercent(.61F, Screen.height)), "$Banner Advertisement$");
GUI.Label(new Rect(0, -3, Screen.width + 8, Screen.height + 9), GUITexture);
textfield = GUI.TextField(new Rect(GetPercent(.115F, Screen.width),
GetPercent(.807F, Screen.height),
GetPercent(.649F, Screen.width),
18)
, textfield);
if(GUI.Button(new Rect(GetPercent(.0155F, Screen.width),
GetPercent(.805F, Screen.height),
GetPercent(.096F, Screen.width),
19), "Send"))
{
sendButton = true;
}
GUI.Label(new Rect(GetPercent(.82F, Screen.width),
GetPercent(.008F, Screen.height),
300,
25), m_currentRoom.GetRoomName());
m_currentRoom.UpdateChatWindows();
}
}
public void SendResponse (BinaryMessage response)
{
WriteMessage (0, response);
}
public void InitAdapter(ref BinaryMessage t_bmsg)
{
m_adapterMessage = t_bmsg;
}
public void WriteMessage (byte type, BinaryMessage msg)
{
msg.ReadCustomData ();
lock (listeners) {
if (DebugMode)
Console.WriteLine ("[SERVER] XS << RP " + type + " [" + msg.ProcessingTime + "ms] " + msg);
outStream.WriteByte (type);
try {
msg.Write (outStream);
} catch (Exception ex) {
msg.CreateErrorResponse (ex.ToString (), true).Write (outStream);
}
}
}
BinaryMessage LoadMessageData (BinaryMessage msg)
{
Type type;
if (messageTypes.TryGetValue (msg.Name, out type)) {
var res = (BinaryMessage)Activator.CreateInstance (type);
res.CopyFrom (msg);
return res;
}
return msg;
}
public void DispatchMessage (BinaryMessage msg)
{
ThreadPool.QueueUserWorkItem ((state) => { ExecuteMessage (msg); });
}
public void InitAdapter(ref BinaryMessage t_bmsg)
{
m_readAdapterMsg = t_bmsg;
}
void ExecuteMessage (BinaryMessage msg)
{
BinaryMessage response = null;
var sw = System.Diagnostics.Stopwatch.StartNew ();
try {
if (msg.Name == "FlushMessages") {
response = msg.CreateResponse ();
} else
response = listener.ProcessMessage (msg);
} catch (Exception ex) {
if (ex is TargetInvocationException)
ex = ((TargetInvocationException)ex).InnerException;
server.LogError (ex);
response = msg.CreateErrorResponse (ex.Message, !(ex is RemoteProcessException));
Console.WriteLine (ex);
}
if (response != null) {
response.Id = msg.Id;
response.ProcessingTime = sw.ElapsedMilliseconds;
server.SendResponse (response);
} else if (!msg.OneWay)
server.SendResponse (msg.CreateErrorResponse ("Got no response from server", true));
}
