public void Dispose()
{
if (IsCreated)
{
var connections = m_Connections.GetValueArray(Allocator.Temp);
foreach (var con in connections)
{
if (!Listening && Library.Initialized)
{
m_Sockets.CloseConnection(con.Id);
}
con.Dispose();
}
if (Listening && Library.Initialized)
{
m_Sockets.CloseListenSocket(m_ListeningSocket);
}
}
m_Connections.Dispose();
m_QueuedConnections.Dispose();
m_PipelineReliableIds.Dispose();
m_PipelineUnreliableIds.Dispose();
m_DataStream.Dispose();
}
public void AddConnectedGhostClientsToNewClient(NetworkConnection connection)
{
var length = Server.Connections.Length;
var size = 8 + (8 * length);
var writer = new DataStreamWriter(size, Allocator.Temp);
writer.Write(AddPreviousGhostSenderId);
writer.Write(length - 1);
/*
* foreach (var c in Server.Connections)
* {
* if (c.InternalId == connection.InternalId)
* continue;
*
* var ghost = Spawner.Instances.SingleOrDefault(x => x.ConnectionId == c.InternalId);
* writer.Write(ghost.PrefabId);
* writer.Write(ghost.GetInstanceID());
*
* }
*/
Server.Driver.Send(NetworkPipeline.Null, connection, writer);
writer.Dispose();
}
static NetworkConnection ProcessSingleConnection(UdpCNetworkDriver.Concurrent driver, NetworkConnection connection)
{
DataStreamReader strm;
NetworkEvent.Type cmd;
// Pop all events for the connection
while ((cmd = driver.PopEventForConnection(connection, out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
// For ping requests we reply with a pong message
// A DataStreamReader.Context is required to keep track of current read position since
// DataStreamReader is immutable
var readerCtx = default(DataStreamReader.Context);
int id = strm.ReadInt(ref readerCtx);
// Create a temporary DataStreamWriter to keep our serialized pong message
var pongData = new DataStreamWriter(4, Allocator.Temp);
pongData.Write(id);
// Send the pong message with the same id as the ping
driver.Send(connection, pongData);
pongData.Dispose();
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
// When disconnected we make sure the connection return false to IsCreated so the next frames
// DriverUpdateJob will remove it
return(default(NetworkConnection));
}
}
return(connection);
}
public IEnumerator ServerAndClient_SendMessageWithMaxLength_SentAndReceivedWithoutErrors()
{
SetupServerAndClientAndConnectThem(0);
//send data from client
DataStreamWriter m_OutStream = new DataStreamWriter(1500, Allocator.Persistent);
m_OutStream.Clear();
int messageLength = 1400;
byte[] messageToSend = new byte[messageLength];
for (int i = 0; i < messageLength; i++)
{
messageToSend[i] = (byte)(33 + (i % 93));
}
m_OutStream.Write(messageToSend);
clientToServerConnection.Send(client_driver, m_OutStream);
m_OutStream.Dispose();
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClient, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Data, "Expected to get Type.Data");
var readerCtx = default(DataStreamReader.Context);
var msg = stream.ReadBytesAsArray(ref readerCtx, stream.Length);
Assert.IsTrue(msg.Length == messageLength, "Lenghts of sent and received messages are different");
DisconnectAndCleanup();
yield return(null);
}
public IEnumerator ServerAndClient_SendMessageWithMoreThenMaxLength_OverflowsIncomingDriverBuffer()
{
SetupServerAndClientAndConnectThem(0);
//send data from client
DataStreamWriter m_OutStream = new DataStreamWriter(1500, Allocator.Persistent);
m_OutStream.Clear();
int messageLength = 1401;
byte[] messageToSend = new byte[messageLength];
for (int i = 0; i < messageLength; i++)
{
messageToSend[i] = (byte)(33 + (i % 93));
}
m_OutStream.Write(messageToSend);
clientToServerConnection.Send(client_driver, m_OutStream);
LogAssert.Expect(LogType.Error, "Error on receive 10040");
m_OutStream.Dispose();
//handle sent data
server_driver.ScheduleUpdate().Complete();
client_driver.ScheduleUpdate().Complete();
Assert.AreEqual(10040, server_driver.ReceiveErrorCode);
DisconnectAndCleanup();
yield return(null);
}
public void IPC_TearDown()
{
Driver.Dispose();
RemoteDriver.Dispose();
Stream.Dispose();
IPCManager.Instance.Destroy();
}
public void Execute()
{
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
connection.Send(driver, strmWriter);
strmWriter.Dispose();
}
public void WriteToAllConnections(DataStreamWriter writer)
{
foreach (var connection in m_Connections)
{
m_Driver.Send(NetworkPipeline.Null, connection, writer);
writer.Dispose();
}
}
public void SendReceiveInParallelJobWorks()
{
var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var clientDriver0 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var clientDriver1 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var serverToClient = new NativeArray <NetworkConnection>(2, Allocator.TempJob);
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
var clientToServer0 = clientDriver0.Connect(serverDriver.LocalEndPoint());
var clientToServer1 = clientDriver1.Connect(serverDriver.LocalEndPoint());
WaitForConnected(clientDriver0, serverDriver, clientToServer0);
serverToClient[0] = serverDriver.Accept();
Assert.IsTrue(serverToClient[0].IsCreated);
WaitForConnected(clientDriver1, serverDriver, clientToServer1);
serverToClient[1] = serverDriver.Accept();
Assert.IsTrue(serverToClient[1].IsCreated);
clientToServer0.Send(clientDriver0, strmWriter);
clientToServer1.Send(clientDriver1, strmWriter);
strmWriter.Dispose();
clientDriver0.ScheduleUpdate().Complete();
clientDriver1.ScheduleUpdate().Complete();
var sendRecvJob = new SendReceiveParallelJob {
driver = serverDriver.ToConcurrent(), connections = serverToClient
};
var jobHandle = serverDriver.ScheduleUpdate();
jobHandle = sendRecvJob.Schedule(serverToClient.Length, 1, jobHandle);
serverDriver.ScheduleUpdate(jobHandle).Complete();
DataStreamReader strmReader;
clientDriver0.ScheduleUpdate().Complete();
Assert.AreEqual(NetworkEvent.Type.Data, clientToServer0.PopEvent(clientDriver0, out strmReader));
var ctx = default(DataStreamReader.Context);
Assert.AreEqual(43, strmReader.ReadInt(ref ctx));
clientDriver1.ScheduleUpdate().Complete();
Assert.AreEqual(NetworkEvent.Type.Data, clientToServer1.PopEvent(clientDriver1, out strmReader));
ctx = default(DataStreamReader.Context);
Assert.AreEqual(43, strmReader.ReadInt(ref ctx));
serverToClient.Dispose();
clientDriver0.Dispose();
clientDriver1.Dispose();
serverDriver.Dispose();
}
public IEnumerator ServerAndClient_PingPong_Successfully()
{
SetupServerAndClientAndConnectThem(0);
//send data from client
DataStreamWriter m_OutStream = new DataStreamWriter(16, Allocator.Persistent);
m_OutStream.Clear();
m_OutStream.Write(SharedConstants.ping);
clientToServerConnection.Send(client_driver, m_OutStream);
//handle sent data
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClient, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Data, "Expected to get Type.Data");
var readerCtx = default(DataStreamReader.Context);
var msg = stream.ReadBytesAsArray(ref readerCtx, stream.Length);
if (msg.Length == SharedConstants.ping.Length)
{
for (var i = 0; i < msg.Length; i++)
{
if (SharedConstants.ping[i] != msg[i])
{
Assert.Fail("Data reading error");
}
}
}
client_driver.ScheduleUpdate().Complete();
//send data from server
m_OutStream.Clear();
m_OutStream.Write(SharedConstants.pong);
connectionToClient.Send(server_driver, m_OutStream);
m_OutStream.Dispose();
//handle sent data
server_driver.ScheduleUpdate().Complete();
client_driver.ScheduleUpdate().Complete();
ev = clientToServerConnection.PopEvent(client_driver, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Data, "Expected to get Type.Data");
readerCtx = default(DataStreamReader.Context);
msg = stream.ReadBytesAsArray(ref readerCtx, stream.Length);
if (msg.Length == SharedConstants.pong.Length)
{
for (var i = 0; i < msg.Length; i++)
{
if (SharedConstants.pong[i] != msg[i])
{
Assert.Fail("Data reading error");
}
}
}
DisconnectAndCleanup();
yield return(null);
}
void FixedUpdate()
{
// Update the ping client UI with the ping statistics computed by teh job scheduled previous frame since that
// is now guaranteed to have completed
PingClientUIBehaviour.UpdateStats(m_numPingsSent, m_lastPingTime);
// Update the NetworkDriver. It schedules a job so we must wait for that job with Complete
m_ClientDriver.ScheduleUpdate().Complete();
// If the client ui indicates we should be sending pings but we do not have an active connection we create one
if (PingClientUIBehaviour.ServerEndPoint.IsValid && !m_clientToServerConnection.IsCreated)
{
m_clientToServerConnection = m_ClientDriver.Connect(PingClientUIBehaviour.ServerEndPoint);
}
// If the client ui indicates we should not be sending pings but we do have a connection we close that connection
if (!PingClientUIBehaviour.ServerEndPoint.IsValid && m_clientToServerConnection.IsCreated)
{
m_clientToServerConnection.Disconnect(m_ClientDriver);
m_clientToServerConnection = default(NetworkConnection);
}
DataStreamReader strm;
NetworkEvent.Type cmd;
// Process all events on the connection. If the connection is invalid it will return Empty immediately
while ((cmd = m_clientToServerConnection.PopEvent(m_ClientDriver, out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
// When we get the connect message we can start sending data to the server
// Set the ping id to a sequence number for the new ping we are about to send
m_pendingPing = new PendingPing {
id = m_numPingsSent, time = Time.fixedTime
};
// Create a 4 byte data stream which we can store our ping sequence number in
var pingData = new DataStreamWriter(4, Allocator.Temp);
pingData.Write(m_numPingsSent);
m_clientToServerConnection.Send(m_ClientDriver, pingData);
pingData.Dispose();
// Update the number of sent pings
++m_numPingsSent;
}
else if (cmd == NetworkEvent.Type.Data)
{
// When the pong message is received we calculate the ping time and disconnect
m_lastPingTime = (int)((Time.fixedTime - m_pendingPing.time) * 1000);
m_clientToServerConnection.Disconnect(m_ClientDriver);
m_clientToServerConnection = default(NetworkConnection);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
// If the server disconnected us we clear out connection
m_clientToServerConnection = default(NetworkConnection);
}
}
}
public void Dispose()
{
UpdateHandle.Complete();
DriverHandle.Dispose();
ConnectionHandle.Dispose();
PendingSoakMessages.Dispose();
SoakClientStreamWriter.Dispose();
SoakJobDataPacket.Dispose();
SoakJobContextsHandle.Dispose();
SoakStatisticsHandle.Dispose();
}
protected override void OnDestroy()
{
m_DataStream.Dispose();
foreach (var kvp in m_SerializeLookup)
{
kvp.Value.Data.Dispose();
}
m_SerializeLookup.Clear();
}
void FixedUpdate()
{
// Update the NetworkDriver. It schedules a job so we must wait for that job with Complete
m_ServerDriver.ScheduleUpdate().Complete();
// Accept all new connections
while (true)
{
var con = m_ServerDriver.Accept();
// "Nothing more to accept" is signaled by returning an invalid connection from accept
if (!con.IsCreated)
{
break;
}
m_connections.Add(con);
}
for (int i = 0; i < m_connections.Length; ++i)
{
DataStreamReader strm;
NetworkEvent.Type cmd;
// Pop all events for the connection
while ((cmd = m_ServerDriver.PopEventForConnection(m_connections[i], out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
// For ping requests we reply with a pong message
// A DataStreamReader.Context is required to keep track of current read position since
// DataStreamReader is immutable
var readerCtx = default(DataStreamReader.Context);
int id = strm.ReadInt(ref readerCtx);
// Create a temporary DataStreamWriter to keep our serialized pong message
var pongData = new DataStreamWriter(4, Allocator.Temp);
pongData.Write(id);
// Send the pong message with the same id as the ping
m_ServerDriver.Send(m_connections[i], pongData);
pongData.Dispose();
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
// This connection no longer exist, remove it from the list
// The next iteration will operate on the new connection we swapped in so as long as it exist the
// loop can continue
m_connections.RemoveAtSwapBack(i);
if (i >= m_connections.Length)
{
break;
}
}
}
}
}
protected override void OnDestroy()
{
m_SerialSpawnChunks.Dispose();
m_CompressionModel.Dispose();
m_AllocatedGhostIds.Dispose();
m_FreeGhostIds.Dispose();
m_DataStream.Dispose();
foreach (var connectionState in m_ConnectionStates)
{
connectionState.Dispose();
}
m_ConnectionStateLookup.Dispose();
}
public void Execute()
{
if (serverEP.IsValid && connections.Length == 0)
{
commandBuffer.CreateEntity();
commandBuffer.AddComponent(new PingClientConnectionComponentData {
connection = driver.Connect(serverEP)
});
}
if (!serverEP.IsValid && connections.Length > 0)
{
for (int con = 0; con < connections.Length; ++con)
{
connections[con].connection.Disconnect(driver);
commandBuffer.DestroyEntity(connectionEntities[con]);
}
return;
}
for (int con = 0; con < connections.Length; ++con)
{
DataStreamReader strm;
NetworkEvent.Type cmd;
while ((cmd = connections[con].connection.PopEvent(driver, out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
pendingPings[0] = new PendingPing {
id = pingStats[0], time = fixedTime
};
var pingData = new DataStreamWriter(4, Allocator.Temp);
pingData.Write(pingStats[0]);
connections[con].connection.Send(driver, pingData);
pingData.Dispose();
pingStats[0] = pingStats[0] + 1;
}
else if (cmd == NetworkEvent.Type.Data)
{
pingStats[1] = (int)((fixedTime - pendingPings[0].time) * 1000);
connections[con].connection.Disconnect(driver);
commandBuffer.DestroyEntity(connectionEntities[con]);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
commandBuffer.DestroyEntity(connectionEntities[con]);
}
}
}
}
public void Execute(int i)
{
SoakMessage inbound = default(SoakMessage);
SoakMessage outbound = default(SoakMessage);
if (connections[i].Connection.IsCreated)
{
var ctx = connections[i];
DataStreamReader strm;
NetworkEvent.Type cmd;
bool close = false;
while ((cmd = driver.PopEventForConnection(ctx.Connection, out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
unsafe
{
if (!strm.IsCreated)
{
Debug.Log("wtf not created.");
}
strm.ReadBytes(ref readerCtx, inbound.data, strm.Length);
Assert.AreEqual(strm.Length, inbound.length + SoakMessage.HeaderLength);
outbound.id = inbound.id;
outbound.sequence = ctx.NextSequenceId++;
var soakData = new DataStreamWriter(SoakMessage.HeaderLength, Allocator.Temp);
soakData.WriteBytes(outbound.data, SoakMessage.HeaderLength);
driver.Send(connections[i].Connection, soakData);
soakData.Dispose();
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
close = true;
}
}
if (close)
{
ctx.Connection = default(NetworkConnection);
ctx.NextSequenceId = -1;
}
connections[i] = ctx;
}
}
public void Execute()
{
// If the client ui indicates we should be sending pings but we do not have an active connection we create one
if (serverEP.IsValid && !connection[0].IsCreated)
{
connection[0] = driver.Connect(serverEP);
}
// If the client ui indicates we should not be sending pings but we do have a connection we close that connection
if (!serverEP.IsValid && connection[0].IsCreated)
{
connection[0].Disconnect(driver);
connection[0] = default(NetworkConnection);
}
DataStreamReader strm;
NetworkEvent.Type cmd;
// Process all events on the connection. If the connection is invalid it will return Empty immediately
while ((cmd = connection[0].PopEvent(driver, out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
// When we get the connect message we can start sending data to the server
// Set the ping id to a sequence number for the new ping we are about to send
pendingPings[0] = new PendingPing {
id = pingStats[0], time = fixedTime
};
// Create a 4 byte data stream which we can store our ping sequence number in
var pingData = new DataStreamWriter(4, Allocator.Temp);
pingData.Write(pingStats[0]);
connection[0].Send(driver, pingData);
pingData.Dispose();
// Update the number of sent pings
pingStats[0] = pingStats[0] + 1;
}
else if (cmd == NetworkEvent.Type.Data)
{
// When the pong message is received we calculate the ping time and disconnect
pingStats[1] = (int)((fixedTime - pendingPings[0].time) * 1000);
connection[0].Disconnect(driver);
connection[0] = default(NetworkConnection);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
// If the server disconnected us we clear out connection
connection[0] = default(NetworkConnection);
}
}
}
public unsafe void StartInfoQuery()
{
Debug.Assert(m_State == SQPClientState.Idle);
StartTime = m_Timer.ElapsedMilliseconds;
var writer = new DataStreamWriter(BufferSize, Allocator.Temp);
var req = new ChallangeRequest();
req.ToStream(ref writer);
writer.CopyTo(0, writer.Length, ref m_Buffer);
m_Socket.SendTo(m_Buffer, writer.Length, SocketFlags.None, m_Server);
m_State = SQPClientState.WaitingForChallange;
writer.Dispose();
}
unsafe void SendServerInfoQuery()
{
StartTime = m_Timer.ElapsedMilliseconds;
var req = new QueryRequest();
req.Header.ChallangeId = ChallangeId;
req.RequestedChunks = (byte)SQPChunkType.ServerInfo;
var writer = new DataStreamWriter(BufferSize, Allocator.Temp);
req.ToStream(ref writer);
m_State = SQPClientState.WaitingForResponse;
writer.CopyTo(0, writer.Length, ref m_Buffer);
m_Socket.SendTo(m_Buffer, writer.Length, SocketFlags.None, m_Server);
writer.Dispose();
}
public void Execute(int i)
{
DataStreamReader strmReader;
// Data
if (driver.PopEventForConnection(connections[i], out strmReader) != NetworkEvent.Type.Data)
{
throw new InvalidOperationException("Expected data: " + i);
}
var ctx = default(DataStreamReader.Context);
int result = strmReader.ReadInt(ref ctx);
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(result + 1);
driver.Send(connections[i], strmWriter);
strmWriter.Dispose();
}
void SendServerInfoQuery(SQPQuery q)
{
q.StartTime = NetworkUtils.stopwatch.ElapsedMilliseconds;
var req = new QueryRequest();
req.Header.ChallangeId = q.ChallangeId;
req.RequestedChunks = (byte)SQPChunkType.ServerInfo;
var writer = new DataStreamWriter(m_Buffer.Length, Unity.Collections.Allocator.Temp);
req.ToStream(ref writer);
q.m_State = SQPClientState.WaitingForResponse;
writer.CopyTo(0, writer.Length, ref m_Buffer);
m_Socket.SendTo(m_Buffer, writer.Length, SocketFlags.None, q.m_Server);
writer.Dispose();
}
internal void BrodcastRpc(byte componentIndex, byte methodId, DataStreamWriter rpcPacket, QosType qosType, bool important)
{
if (!isSyncComplete)
{
return;
}
var writer = new DataStreamWriter(rpcPacket.Length + 9, Allocator.Temp);
CreateRpcPacket(ref writer, ref rpcPacket, componentIndex, methodId);
GamePacketManager.Brodcast(writer, qosType);
//if (important) {
// GamePacketManager.Brodcast (writer, qosType);
//} else {
// GamePacketManager.Brodcast (writer, qosType, gridId);
//}
writer.Dispose();
}
public void DisconnectTimeoutOnServer()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint),
new NetworkConfigParameter {
disconnectTimeoutMS = 40
}))
using (var client = new LocalNetworkDriver(new NetworkConfigParameter {
disconnectTimeoutMS = 40
}))
{
NetworkConnection id;
NetworkEvent.Type popEvent = NetworkEvent.Type.Empty;
DataStreamReader reader;
host.Host();
client.Connect(host.Address);
client.ScheduleUpdate().Complete();
host.Assert_GotConnectionRequest(client.LocalEndPoint(), true);
var stream = new DataStreamWriter(100, Allocator.Persistent);
for (int i = 0; i < 100; i++)
{
stream.Write((byte)i);
}
// Host sends stuff but gets nothing back, until disconnect timeout happens
var timeout = m_timer.ElapsedMilliseconds + 100;
while (m_timer.ElapsedMilliseconds < timeout)
{
host.m_LocalDriver.Send(host.ClientConnections[0], stream);
popEvent = host.m_LocalDriver.PopEvent(out id, out reader);
if (popEvent != NetworkEvent.Type.Empty)
{
break;
}
host.Update();
}
stream.Dispose();
Assert.AreEqual(NetworkEvent.Type.Disconnect, popEvent);
}
}
public IEnumerator ServerAndClient_SendMessageWithoutReadingIt_GivesErrorOnDriverUpdate()
{
SetupServerAndClientAndConnectThem(0);
//send data from client
DataStreamWriter m_OutStream = new DataStreamWriter(16, Allocator.Persistent);
m_OutStream.Clear();
m_OutStream.Write(SharedConstants.ping);
clientToServerConnection.Send(client_driver, m_OutStream);
m_OutStream.Dispose();
server_driver.ScheduleUpdate().Complete();
client_driver.ScheduleUpdate().Complete();
LogAssert.Expect(LogType.Error, "Resetting event queue with pending events (Count=1, ConnectionID=0) Listening: 1");
server_driver.ScheduleUpdate().Complete();
DisconnectAndCleanup();
yield return(null);
}
public void ReceiveInJobWorks()
{
var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var clientDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var clientToServer = clientDriver.Connect(serverDriver.LocalEndPoint());
WaitForConnected(clientDriver, serverDriver, clientToServer);
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
clientToServer.Send(clientDriver, strmWriter);
strmWriter.Dispose();
clientDriver.ScheduleUpdate().Complete();
var serverToClient = new NativeArray <NetworkConnection>(1, Allocator.TempJob);
var result = new NativeArray <int>(1, Allocator.TempJob);
var recvJob = new ReceiveJob {
driver = serverDriver, connections = serverToClient, result = result
};
Assert.AreNotEqual(42, result[0]);
var acceptJob = new AcceptJob {
driver = serverDriver, connections = serverToClient
};
recvJob.Schedule(serverDriver.ScheduleUpdate(acceptJob.Schedule())).Complete();
Assert.AreEqual(42, result[0]);
result.Dispose();
serverToClient.Dispose();
clientDriver.Dispose();
serverDriver.Dispose();
}
public IEnumerator ServerAndClient_SendBigMessage_OverflowsIncomingDriverBuffer()
{
SetupServerAndClientAndConnectThem(8);
//send data from client
DataStreamWriter m_OutStream = new DataStreamWriter(16, Allocator.Persistent);
m_OutStream.Clear();
m_OutStream.Write(SharedConstants.ping);
clientToServerConnection.Send(client_driver, m_OutStream);
LogAssert.Expect(LogType.Error, "Error on receive 10040");
m_OutStream.Dispose();
//handle sent data
server_driver.ScheduleUpdate().Complete();
client_driver.ScheduleUpdate().Complete();
Assert.AreEqual(10040, server_driver.ReceiveErrorCode);
DisconnectAndCleanup();
yield return(null);
}
public void DataStremReaderIsOnlyUsableUntilUpdate()
{
var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var clientDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var clientToServer = clientDriver.Connect(serverDriver.LocalEndPoint());
WaitForConnected(clientDriver, serverDriver, clientToServer);
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
clientToServer.Send(clientDriver, strmWriter);
strmWriter.Dispose();
clientDriver.ScheduleUpdate().Complete();
var serverToClient = serverDriver.Accept();
serverDriver.ScheduleUpdate().Complete();
DataStreamReader strmReader;
Assert.AreEqual(NetworkEvent.Type.Data, serverToClient.PopEvent(serverDriver, out strmReader));
var ctx = default(DataStreamReader.Context);
Assert.AreEqual(42, strmReader.ReadInt(ref ctx));
ctx = default(DataStreamReader.Context);
Assert.AreEqual(42, strmReader.ReadInt(ref ctx));
serverDriver.ScheduleUpdate().Complete();
ctx = default(DataStreamReader.Context);
Assert.Throws <InvalidOperationException>(() => { strmReader.ReadInt(ref ctx); });
clientDriver.Dispose();
serverDriver.Dispose();
}
public void Execute(int i)
{
DataStreamReader strm;
NetworkEvent.Type cmd;
while ((cmd = driver.PopEventForConnection(connections[i].connection, out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
int id = strm.ReadInt(ref readerCtx);
var pongData = new DataStreamWriter(4, Allocator.Temp);
pongData.Write(id);
driver.Send(connections[i].connection, pongData);
pongData.Dispose();
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
connections[i] = new PingServerConnectionComponentData {
connection = default(NetworkConnection)
};
}
}
}
public void Write(DataStreamWriter writer, NetworkConnection connection)
{
m_Driver.Send(NetworkPipeline.Null, connection, writer);
writer.Dispose();
}