internal override async Task SendAsync(Packet packet)
{
try
{
if (!IsAvailable)
{
return;
}
var buffer = PacketSerializer.Serialize(packet, Key, Type == GSLiveType.Command);
if (_clientStream != null)
{
await _clientStream.WriteAsync(buffer, 0, buffer.Length, OperationCancellationToken.Token);
await _clientStream.FlushAsync(OperationCancellationToken.Token);
}
}
catch (Exception e)
{
if (!(e is OperationCanceledException || e is ObjectDisposedException ||
e is ArgumentOutOfRangeException))
{
e.LogException <GsTcpClient>(
Type == GSLiveType.TurnBased ? DebugLocation.TurnBased : DebugLocation.Command, "SendAsync");
OnClosed(new ErrorArg {
Error = e.ToString()
});
}
}
}
internal override void Send(Packet packet)
{
Task.Factory.StartNew(() =>
{
try
{
var buffer = PacketSerializer.Serialize(packet, Key, Type == GSLiveType.Command);
if (_clientStream == null)
{
return;
}
_clientStream.Write(buffer, 0, buffer.Length);
_clientStream.Flush();
}
catch (Exception e)
{
if (!(e is OperationCanceledException || e is ObjectDisposedException ||
e is ArgumentOutOfRangeException))
{
e.LogException <GsTcpClient>(
Type == GSLiveType.TurnBased ? DebugLocation.TurnBased : DebugLocation.Command,
"Send");
OnClosed(new ErrorArg {
Error = e.ToString()
});
}
}
}, OperationCancellationToken.Token);
}
public void Send <T>(T packet, NetworkerProtocol protocol = NetworkerProtocol.Tcp)
where T : NetworkerPacketBase
{
var serializer = new PacketSerializer();
var serialisedPacket = serializer.Serialize(packet);
if (protocol == NetworkerProtocol.Tcp)
{
if (!this.clientConfiguration.UseTcp)
{
throw new Exception("Cannot send TCP when TCP not enabled.");
}
this._tcpSocket.Send(serialisedPacket);
}
else if (protocol == NetworkerProtocol.Udp)
{
if (!this.clientConfiguration.UseUdp)
{
throw new Exception("Cannot send UDP when UDP not enabled.");
}
this._udpClient.SendAsync(serialisedPacket,
serialisedPacket.Length,
this.clientConfiguration.Ip,
this.clientConfiguration.UdpPortRemote);
}
}
public virtual bool Send(BasePacket packet)
{
if (!Listening)
{
return(false);
}
try
{
var packetDeserialized = PacketSerializer.Serialize(packet);
var stream = TcpClient.GetStream();
// first we write the size of the packet so we know how much to read later
Int32 packetSize = (Int32)packetDeserialized.Length;
var packetSizeBytes = BitConverter.GetBytes(packetSize);
stream.Write(packetSizeBytes, 0, packetSizeBytes.Length);
stream.Write(packetDeserialized, 0, packetDeserialized.Length);
if (packet.GetType() != typeof(PingPacket)) // f*****g spam...
{
Log.Debug("Sent Packet " + packet.GetType().Name);
}
}
catch (Exception e)
{
if (Listening)
{
Listening = false;
DisconnectClient();
}
}
return(Listening);
}
public void SerializeDeserialize()
{
const int Count = 255;
var packets = new List <IPacket>();
var contents = new List <string>();
for (int i = 0; i < Count; i++)
{
contents.Add("STR: " + i.ToString());
}
for (int i = 0; i < Count / 2; i++)
{
packets.Add(new PingPacket(contents[i]));
}
for (int i = Count / 2; i < Count; i++)
{
packets.Add(new AuthenticationPacket(contents[i], contents[i]));
}
var bytes = PacketSerializer.Serialize(packets.ToArray());
packets = PacketSerializer.Deserialize(bytes).ToList();
for (int i = 0; i < Count / 2; i++)
{
Assert.AreEqual(contents[i], ((PingPacket)packets[i]).contents);
}
for (int i = Count / 2; i < Count; i++)
{
Assert.AreEqual(contents[i], ((AuthenticationPacket)packets[i]).time);
}
}
internal override Task SendAsync(Packet packet)
{
try
{
if (!IsAvailable)
{
return(Task.CompletedTask);
}
var buffer = PacketSerializer.Serialize(packet, Key, Type == GSLiveType.Command);
_client?.SendAsync(buffer, null);
}
catch (Exception e)
{
if (e is OperationCanceledException || e is ObjectDisposedException ||
e is ArgumentOutOfRangeException)
{
return(Task.CompletedTask);
}
e.LogException <GsWebSocketClient>(
Type == GSLiveType.TurnBased ? DebugLocation.TurnBased : DebugLocation.Command,
"SendAsync");
OnClosed(new ErrorArg {
Error = e.ToString()
});
}
return(Task.CompletedTask);
}
public void Serialize_Valid_ReturnsValidXml()
{
PacketSerializer serializer = PacketSerializer.Create("application/xml");
Payment payment = new Payment {
OrderId = "1", AmountKop = 100, CardHolderName = "POVYSHEV NIKOLAY", CardNumber = "9999000088881111", CVV = "100", ExpiryMonth = 12, ExpiryYear = 2017
};
const string etalon = "<?xml version=\"1.0\" encoding=\"utf-8\"?><packet version=\"v1\"><Payment order_id=\"1\" card_number=\"9999000088881111\" expiry_month=\"12\" expiry_year=\"2017\" cvv=\"100\" cardholder_name=\"POVYSHEV NIKOLAY\" amount_kop=\"100\" /></packet>";
string xml = null;
using (MemoryStream stream = new MemoryStream())
using (StreamReader reader = new StreamReader(stream))
{
serializer.Serialize(new Packet <Payment>(payment)
{
Version = "v1"
}, stream);
stream.Position = 0;
xml = reader.ReadToEnd();
}
Assert.Equal(etalon, xml);
}
public void Send(IPacket packet)
{
if (!Connected)
{
return;
}
byte[] serializedPacket = null;
using (MemoryStream stream = new MemoryStream())
{
serializer.Serialize(stream, packet);
serializedPacket = stream.ToArray();
stream.SetLength(0L);
stream.WriteByte((byte)serializedPacket.Length);
stream.WriteByte((byte)(serializedPacket.Length >> 8));
stream.WriteByte((byte)(serializedPacket.Length >> 16));
stream.WriteByte((byte)(serializedPacket.Length >> 24));
stream.Write(serializedPacket, 0, serializedPacket.Length);
serializedPacket = stream.ToArray();
}
socket.BeginSend(serializedPacket, 0, serializedPacket.Length, SocketFlags.None, EndSend, this);
}
public void Send <T>(T packet)
where T : NetworkerPacketBase
{
var serializer = new PacketSerializer();
this.socket.SendTo(serializer.Serialize(packet), this.socket.RemoteEndPoint);
}
/// <summary>
/// Sendet ein object an den Server.
/// </summary>
/// <param name="bytes"></param>
public bool SendPacket(object data)
{
// Wenn der Client nicht verbunden ist kann nichts gesendet werden.
if (!tcpClient.Connected)
{
return(false);
}
try
{
// Stream holen und Asynchron das Paket in den Stream schreiben (neuer Thread).
NetworkStream networkStream = tcpClient.GetStream();
var d = PacketSerializer.Serialize(data);
networkStream.BeginWrite(d, 0, d.Length, SendCallback, null);
return(true);
}
catch (Exception ex)
{
if (ex.InnerException is SocketException)
{
return(false);
}
throw new Exception("Fehler beim Senden des Paketes.", ex);
}
}
static void Main(string[] args)
{
// memory for the packet
MemoryStream memory = new MemoryStream();
// create a packet
Packet packet = new Packet(PacketType.Message, Encoding.UTF8.GetBytes("hello, server"));
// serialize the packet to the memorystream
PacketSerializer serializer = new PacketSerializer();
serializer.Serialize(memory, packet);
// save a copy
File.WriteAllBytes("TestPacket.bin", memory.ToArray());
// reset the position of the stream
memory.Seek(0L, SeekOrigin.Begin);
// deserialize the packet
Packet deserialized = serializer.Deserialize(memory);
// print the packet data
Console.WriteLine(Encoding.UTF8.GetString(deserialized.Data, 0, (int)deserialized.Length));
Console.ReadLine();
}
private async Task Sending()
{
try
{
IsSendingQueue = true;
lock (SendTempQueueLock)
{
SendQueue.InsertRange(0, SendTempQueue);
SendTempQueue.Clear();
}
await SendAsync(PacketSerializer.Serialize(SendQueue, Key, Type == GSLiveType.Command));
}
catch (Exception e)
{
e.LogException <GsTcpClient>(
Type == GSLiveType.TurnBased ? DebugLocation.TurnBased : DebugLocation.Command,
"Sending");
lock (SendTempQueueLock)
{
SendTempQueue.InsertRange(0, SendQueue);
}
}
finally
{
IsSendingQueue = false;
SendQueue.Clear();
}
}
public virtual bool Send(BasePacket packet)
{
try
{
var packetDeserialized = PacketSerializer.Serialize(packet);
var stream = TcpClient.GetStream();
// first we write the size of the packet so we know how much to read later
Int32 packetSize = (Int32)packetDeserialized.Length;
var packetSizeBytes = BitConverter.GetBytes(packetSize);
stream.Write(packetSizeBytes, 0, packetSizeBytes.Length);
stream.Write(packetDeserialized, 0, packetDeserialized.Length);
if (packet.GetType() != typeof(PingPacket)) // f*****g spam...
{
Log.Debug("Sent Packet " + packet.GetType().Name);
}
}
catch (Exception e)
{
Log.Error("Error sending packet " + e.Message);
Log.Error(System.Environment.StackTrace);
Listening = false;
}
return(Listening);
}
static void SendPacket(WebSocket ws, PacketBase packet)
{
var json = PacketSerializer.Serialize(packet);
Console.WriteLine(json);
ws.Send(json);
}
/// <summary>
/// Sendet ein object an alle Clienten
/// </summary>
/// <param name="bytes"></param>
public void SendPacket(object data)
{
// Sendet das Paket an jeden Clienten.
foreach (Client c in clients)
{
SendPacket(c.Tcpclient, PacketSerializer.Serialize(data));
}
}
private void Send(PacketBase packet)
{
Debug.Log("Send : " + packet);
var json = PacketSerializer.Serialize(packet);
ws.SendAsync(json, x => { });
}
public void Deserialize()
{
var pingPacket = new PingPacket("hello");
var bytes = PacketSerializer.Serialize(pingPacket);
var packets = PacketSerializer.Deserialize(bytes);
Assert.IsTrue(packets.Length == 1);
Assert.AreEqual("hello", ((PingPacket)packets[0]).contents);
}
public static void Broadcast <T>(
this IEnumerable <Service <T> > sessions,
PacketBase packet)
{
var json = Encoding.UTF8.GetString(PacketSerializer.Serialize(packet));
foreach (var session in sessions)
{
session.SendRawPacket(json);
}
}
public void SendPacket(object packet)
{
packetSerializer.Serialize(packet);
for (int i = 0; i < packetSerializer.SegmentCount; i++)
{
int fullSegmentLength = packetSerializer.GetSerializedSegment(SendBuffer);
SendData(fullSegmentLength);
}
packetSerializer.Clear();
}
public void Serialize()
{
var pingPacket = new PingPacket("hello");
var bytes = PacketSerializer.Serialize(pingPacket);
var header = 4;
var packets = 1;
var packetSize = Marshal.SizeOf(pingPacket);
Assert.AreEqual(header + packets + packetSize, bytes.Length);
}
public void Send(IPacket packet)
{
if (IsConnected == false)
{
Debug.LogError("Please Connect First!!");
return;
}
// ClearBuffer();
byte[] sendBuffer = PacketSerializer.Serialize(packet);
_networkStream.Write(sendBuffer, 0, sendBuffer.Length);
Debug.Log("[Send] name: " + packet.GetPacketType());
}
protected virtual void SendPacket(PacketBase packet)
{
try
{
var json = PacketSerializer.Serialize(packet);
SendRawPacket(json);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public bool SendPacket(object packet)
{
if (_packetSerializer == null)
{
return(false);
}
_packetSerializer.Serialize(packet);
for (int i = 0; i < _packetSerializer.SegmentCount; i++)
{
int fullSegmentLength = _packetSerializer.GetSerializedSegment(SendBuffer);
SendData(fullSegmentLength);
}
_packetSerializer.Clear();
return(true);
}
protected internal virtual void SendPacket(PacketBase packet)
{
try
{
if (packet.PacketId == 0)
{
packet.PacketId = Interlocked.Increment(ref LastPacketId);
}
var json = Encoding.UTF8.GetString(PacketSerializer.Serialize(packet));
SendRawPacket(json);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void TestLoginPacketSerialization()
{
LoginPacket loginPacket = new LoginPacket()
{
Login = "******",
Password = "******"
};
byte[] serialized = PacketSerializer.Serialize(loginPacket);
object deserialized = PacketSerializer.Deserialize(serialized);
Assert.That(deserialized is LoginPacket);
LoginPacket deserializedLoginPacket = (LoginPacket)deserialized;
Assert.AreEqual(deserializedLoginPacket.Login, loginPacket.Login);
Assert.AreEqual(deserializedLoginPacket.Password, loginPacket.Password);
}
public void Authenticate(TcpClient client)
{
var guid = Guid.NewGuid();
var packet = new AuthenticationPacket(Configuration.Version, DateTime.Now.ToString(), guid.ToString());
var buffer = PacketSerializer.Serialize(packet);
client.Client.BeginSend(buffer,
0,
buffer.Length,
SocketFlags.None,
BeginSendCallback,
new AuthenticationState()
{
client = client,
buffer = new byte[4096],
auth = packet,
guid = guid
});
}
public TResp SendRequest <TReq, TResp>(TReq content)
where TReq : IPacketContent
where TResp : IPacketContent
{
HttpWebRequest request = WebRequest.Create(endpoint) as HttpWebRequest;
request.Method = "POST";
request.ContentType = contentType;
request.Timeout = 3000;
PacketSerializer serializer = PacketSerializer.Create(request.ContentType);
try
{
using (MemoryStream stream = new MemoryStream())
{
serializer.Serialize(new Packet <TReq>(content)
{
Version = "v1"
}, stream);
request.ContentLength = stream.Length;
stream.Position = 0;
stream.CopyTo(request.GetRequestStream());
}
HttpWebResponse response = request.GetResponse() as HttpWebResponse;
Stream responseStream = response.GetResponseStream();
Packet <TResp> responsePacket = serializer.Deserialize <TResp>(responseStream);
return(responsePacket.Content);
}
catch (WebException ex)
{
throw new PacketTransportException("Ошибка соединения с сервером", ex);
}
}
// use this only inside the server to send to a client
public void Send(BasePacket packet)
{
try
{
var packetDeserialized = PacketSerializer.Serialize(packet);
var stream = TcpClient.GetStream();
// first we write the size of the packet so we know how much to read later, its out header
Int32 packetSize = (Int32)packetDeserialized.Length;
var packetSizeBytes = BitConverter.GetBytes(packetSize);
stream.Write(packetSizeBytes, 0, packetSizeBytes.Length);
// then write the friggin packet
stream.Write(packetDeserialized, 0, packetDeserialized.Length);
// Debug.Log("Sent Packet " + packet.GetType().Name);
}
catch (Exception e)
{
// Call in main thread
Debug.Log("SOCKET ERROR");
this.Stop();
}
}
public bool Serialize(byte[] bytes, ref int position)
{
if (!ChannelID.Serialize(bytes, ref position))
{
return(false);
}
if (!ParentID.Serialize(bytes, ref position))
{
return(false);
}
if (!Name.Serialize(bytes, ref position))
{
return(false);
}
if (!PacketSerializer.Serialize(type, bytes, ref position))
{
return(false);
}
return(true);
}
public void TestSerialize()
{
var serializer = new PacketSerializer();
var originalPayload = new SentMessagePayload
{
Id = Guid.NewGuid(),
Text = "Hello There hi",
ChannelId = Guid.NewGuid(),
AuthorId = Guid.NewGuid(),
PostedAt = DateTimeOffset.Now,
};
var json = serializer.Serialize(originalPayload);
var deserializedPayload = (SentMessagePayload)serializer.Deserialize(json);
Assert.That(deserializedPayload.Id, Is.EqualTo(originalPayload.Id), "Id was incorrect");
Assert.That(deserializedPayload.Text, Is.EqualTo(originalPayload.Text), "Text was incorrect");
Assert.That(deserializedPayload.ChannelId, Is.EqualTo(originalPayload.ChannelId), "ChannelId was incorrect");
Assert.That(deserializedPayload.AuthorId, Is.EqualTo(originalPayload.AuthorId), "AuthorId was incorrect");
Assert.That(deserializedPayload.PostedAt, Is.EqualTo(originalPayload.PostedAt), "PostedAt was incorrect");
}
