/// <summary>
/// The serialize event.
/// </summary>
/// <param name="eventData">The event data.</param>
/// <returns> The serialized event</returns>
public byte[] SerializeEventData(EventData eventData)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
BigEndianBinaryWriter binaryWriter = new BigEndianBinaryWriter(stream);
stream.Position = this.headerSize;
stream.WriteByte(eventData.Code);
if ((eventData.Parameters == null) || (eventData.Parameters.Count == 0))
{
binaryWriter.WriteInt16(0);
}
else
{
binaryWriter.WriteInt16((short)eventData.Parameters.Count);
Amf3Writer writer2 = new Amf3Writer(binaryWriter);
foreach (KeyValuePair <byte, object> pair in eventData.Parameters)
{
writer2.WriteInteger((long)((ulong)pair.Key));
writer2.Write(pair.Value);
}
}
stream.Position = 0L;
this.headerWriter.WriteHeader(stream, RtsMessageType.Event, false);
return(stream.ToArray());
}
}
/// <summary>
/// The serialize event.
/// </summary>
/// <param name="eventData">The event data.</param>
/// <returns>The serialized event.</returns>
/// <exception cref="T:System.IO.InvalidDataException">
///A value can not be serialized.
///</exception>
///<exception cref="T:System.ArrayTypeMismatchException">
/// A collection with different types can not be serialized.
///</exception>
public byte[] SerializeEventData(EventData eventData)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.WriteByte(0xf3);
stream.WriteByte(4);
SerializeEventData(stream, eventData);
return(stream.ToArray());
}
}
/// <summary>
/// Serializes an <see cref="T:Photon.SocketServer.OperationResponse"/>.
/// </summary>
/// <param name="operationResponse">The operation response to serialize.</param>
/// <param name="messageType">
/// The message type.
/// Should be eiter <see
/// cref="F:Photon.SocketServer.Rpc.Protocols.RtsMessageType.OperationResponse"/> or <see
/// cref="F:Photon.SocketServer.Rpc.Protocols.RtsMessageType.InternalOperationResponse"/>.
/// </param>
/// <returns>A serialized operation response.</returns>
private byte[] SerializeOperationResponse(OperationResponse operationResponse, RtsMessageType messageType)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.WriteByte(0xf3);
stream.WriteByte((byte)messageType);
SerializeOperationResponse(stream, operationResponse);
return(stream.ToArray());
}
}
/// <summary>
/// Serializes an operation request.
/// </summary>
/// <param name="operationRequest">The operation request.</param>
/// <returns>a serialized operation request message</returns>
public byte[] SerializeOperationRequest(OperationRequest operationRequest)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.WriteByte(0xf3);
stream.WriteByte(2);
SerializeOperationRequest(stream, operationRequest);
return(stream.ToArray());
}
}
/// <summary>
/// The serialize event.
/// </summary>
/// <param name="eventData"> The event data.</param>
/// <returns>The serialized event.</returns>
/// <exception cref="T:System.IO.InvalidDataException">
/// A value can not be serialized.
///</exception>
///<exception cref="T:System.ArrayTypeMismatchException">
/// A collection with different types can not be serialized.
///</exception>
public byte[] SerializeEventData(EventData eventData)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
this.SerializeEventData(stream, eventData);
stream.Position = 0L;
this.headerWriter.WriteHeader(stream, RtsMessageType.Event, false);
return(stream.ToArray());
}
}
public byte[] SerializeOperationRequest(OperationRequest operationRequest)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.Position = this.headerSize;
SerializeOperationRequest(stream, operationRequest);
stream.Position = 0L;
this.headerWriter.WriteHeader(stream, RtsMessageType.Operation, false);
return(stream.ToArray());
}
}
private byte[] SerializeOperationResponse(OperationResponse operationResponse, RtsMessageType messageType)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.Position = this.headerSize;
SerializeOperationResponse(stream, operationResponse);
stream.Position = 0L;
this.headerWriter.WriteHeader(stream, messageType, false);
return(stream.ToArray());
}
}
/// <summary>
/// The serialize init response.
/// </summary>
/// <param name="headerWriter">The header writer.</param>
/// <returns> the init response</returns>
internal static byte[] SerializeInitResponse(IRtsMessageHeaderConverter headerWriter)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.Position = headerWriter.HeaderSize;
RtsInitResponseMessage.Serialize(stream);
stream.Position = 0L;
headerWriter.WriteHeader(stream, RtsMessageType.InitResponse, false);
return(stream.ToArray());
}
}
/// <summary>
/// The serialize init request.
/// </summary>
/// <param name="headerWriter">The header Writer.</param>
/// <param name="protocolVersion">The protocol version</param>
/// <param name="clientVersion">The client version.</param>
/// <param name="applicationId">The application id.</param>
/// <returns>the serialized init request</returns>
internal static byte[] SerializeInitRequest(IRtsMessageHeaderConverter headerWriter, Version protocolVersion, Version clientVersion, string applicationId)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
stream.Position = headerWriter.HeaderSize;
new RtsInitMessage(new byte[] { (byte)protocolVersion.Major, (byte)protocolVersion.Minor }, new byte[] { (byte)clientVersion.Major, (byte)clientVersion.Minor, (byte)clientVersion.Build }, applicationId).Serialize(stream);
stream.Position = 0L;
headerWriter.WriteHeader(stream, RtsMessageType.Init, false);
return(stream.ToArray());
}
}
public async Task TestNoAckFlow()
{
const string data = "The cuiqk brwon fox jumps over the zaly god.";
var server = new FakeServer(SimulationMode.Success);
var connection = new Connection(server.EndPoint, Connection.DefaultSocketFactory, BPool, RPool, 16, 16);
const int correlationId = 379821;
const byte ack = 1;
var buffer = new ReusableMemoryStream(null);
BigEndianConverter.Write(buffer, 4 + 4 + 1 + data.Length - 4);
BigEndianConverter.Write(buffer, correlationId);
buffer.WriteByte(ack);
var s = Encoding.UTF8.GetBytes(data);
buffer.Write(s, 0, s.Length);
var bdata = buffer.ToArray();
var p = new TaskCompletionSource <Response>();
connection.Response +=
(con, cor, b) => p.SetResult(new Response {
Connection = con, CorrelationId = cor, Data = b
});
await connection.ConnectAsync();
buffer.Position = 8;
buffer.WriteByte(0);
await connection.SendAsync(correlationId, buffer, false);
buffer = new ReusableMemoryStream(null);
buffer.Write(bdata, 0, bdata.Length);
buffer.Position = 8;
buffer.WriteByte(1);
await connection.SendAsync(correlationId, buffer, true);
var r = await p.Task;
server.Stop();
Assert.AreSame(connection, r.Connection);
Assert.AreEqual(correlationId, r.CorrelationId);
Assert.AreEqual(data, Encoding.UTF8.GetString(r.Data.ToArray()));
}
/// <summary>
/// Serializes an <see cref="T:Photon.SocketServer.OperationResponse"/>.
/// The operation response data will be encrypted using the specified <see cref="T:Photon.SocketServer.Security.ICryptoProvider"/>.
/// </summary>
/// <param name="operationResponse"> The response.</param>
/// <param name="cryptoProvider">An <see cref="T:Photon.SocketServer.Security.ICryptoProvider"/> instance used to encrypt the operation response.</param>
/// <returns>The serialized operation response.</returns>
public byte[] SerializeOperationResponseEncrypted(OperationResponse operationResponse, ICryptoProvider cryptoProvider)
{
byte[] buffer;
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
SerializeOperationResponse(stream, operationResponse);
byte[] data = stream.ToArray();
buffer = cryptoProvider.Encrypt(data);
}
using (ReusableMemoryStream stream2 = new ReusableMemoryStream())
{
stream2.Position = this.headerSize;
stream2.Write(buffer, 0, buffer.Length);
stream2.Position = 0L;
this.headerWriter.WriteHeader(stream2, RtsMessageType.OperationResponse, true);
return(stream2.ToArray());
}
}
/// <summary>
/// Serializes an <see cref="T:Photon.SocketServer.OperationRequest"/>.
/// </summary>
/// <param name="operationRequest">The operation request.</param>
/// <returns>The serialized operation request.</returns>
public byte[] SerializeOperationRequest(OperationRequest operationRequest)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
IBinaryWriter binaryWriter = new BigEndianBinaryWriter(stream);
stream.Position = this.headerSize;
binaryWriter.WriteByte(operationRequest.OperationCode);
binaryWriter.WriteInt16((short)operationRequest.Parameters.Count);
Amf3Writer writer2 = new Amf3Writer(binaryWriter);
foreach (KeyValuePair <byte, object> pair in operationRequest.Parameters)
{
writer2.WriteInteger((long)((ulong)pair.Key));
writer2.Write(pair.Value);
}
stream.Position = 0L;
this.headerWriter.WriteHeader(stream, RtsMessageType.Operation, false);
return(stream.ToArray());
}
}
/// <summary>
/// Encrypts an event.
/// </summary>
/// <param name="eventData"> The event data.</param>
/// <param name="cryptoProvider">The crypto provider.</param>
/// <returns>the encrypted event.</returns>
/// <exception cref="T:System.ArgumentNullException">
/// cryptoProvider is null.
/// </exception>
public byte[] SerializeEventDataEncrypted(IEventData eventData, ICryptoProvider cryptoProvider)
{
byte[] buffer;
if (cryptoProvider == null)
{
throw new ArgumentNullException("cryptoProvider");
}
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
SerializeEventData(stream, eventData);
byte[] data = stream.ToArray();
buffer = cryptoProvider.Encrypt(data, 0, data.Length);
}
using (ReusableMemoryStream stream2 = new ReusableMemoryStream())
{
stream2.WriteByte(0xf3);
stream2.WriteByte(0x84);
stream2.Write(buffer, 0, buffer.Length);
return(stream2.ToArray());
}
}
/// <summary>
/// Serializes an <see cref="T:Photon.SocketServer.OperationResponse"/>.
/// The operation response data will be encrypted using the specified <see cref="T:Photon.SocketServer.Security.ICryptoProvider"/>.
/// </summary>
/// <param name="operationResponse"> The response.</param>
/// <param name="cryptoProvider">An <see cref="T:Photon.SocketServer.Security.ICryptoProvider"/> instance used to encrypt the operation response.</param>
/// <returns>The serialized operation response.</returns>
public byte[] SerializeOperationResponseEncrypted(OperationResponse operationResponse, ICryptoProvider cryptoProvider)
{
byte[] buffer;
if (cryptoProvider == null)
{
throw new ArgumentNullException("cryptoProvider");
}
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
SerializeOperationResponse(stream, operationResponse);
byte[] data = stream.ToArray();
buffer = cryptoProvider.Encrypt(data);
}
using (ReusableMemoryStream stream2 = new ReusableMemoryStream())
{
stream2.WriteByte(0xf3);
stream2.WriteByte(0x83);
stream2.Write(buffer, 0, buffer.Length);
return(stream2.ToArray());
}
}
public byte[] SerializeEventDataEncrypted(IEventData eventData, ICryptoProvider cryptoProvider)
{
byte[] buffer;
if (cryptoProvider == null)
{
throw new ArgumentNullException("cryptoProvider");
}
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
SerializeEventData(stream, eventData);
byte[] data = stream.ToArray();
buffer = cryptoProvider.Encrypt(data, 0, data.Length);
}
using (ReusableMemoryStream stream2 = new ReusableMemoryStream())
{
stream2.Position = this.headerSize;
stream2.Write(buffer, 0, buffer.Length);
stream2.Position = 0L;
this.headerWriter.WriteHeader(stream2, RtsMessageType.Event, true);
return(stream2.ToArray());
}
}
/// <summary>
/// Serializes an <see cref="T:Photon.SocketServer.OperationResponse"/>.
/// </summary>
/// <param name="operationResponse">The operation response to serialize.</param>
/// <returns>The serialized operation response.</returns>
public byte[] SerializeOperationResponse(OperationResponse operationResponse)
{
using (ReusableMemoryStream stream = new ReusableMemoryStream())
{
BigEndianBinaryWriter binaryWriter = new BigEndianBinaryWriter(stream);
stream.Position = this.headerSize;
binaryWriter.WriteByte(operationResponse.OperationCode);
binaryWriter.WriteInt16(operationResponse.ReturnCode);
if (string.IsNullOrEmpty(operationResponse.DebugMessage))
{
binaryWriter.WriteByte(0x2a);
}
else
{
binaryWriter.WriteByte(0x73);
binaryWriter.WriteUTF(operationResponse.DebugMessage);
}
if ((operationResponse.Parameters == null) || (operationResponse.Parameters.Count == 0))
{
binaryWriter.WriteInt16(0);
}
else
{
binaryWriter.WriteInt16((short)operationResponse.Parameters.Count);
Amf3Writer writer2 = new Amf3Writer(binaryWriter);
foreach (KeyValuePair <byte, object> pair in operationResponse.Parameters)
{
writer2.WriteInteger((long)((ulong)pair.Key));
writer2.Write(pair.Value);
}
}
stream.Position = 0L;
this.headerWriter.WriteHeader(stream, RtsMessageType.OperationResponse, false);
return(stream.ToArray());
}
}
