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);
}
private void Update()
{
m_Driver.ScheduleUpdate().Complete();
//Não está conectado
if (!m_Connection.IsCreated)
{
if (!Done)
{
return;
}
}
while ((cmd = m_Driver.PopEvent(out m_Connection, out DataStreamReader reader)) != NetworkEvent.Type.Empty)
{
//Receiving data from client
if (cmd == NetworkEvent.Type.Data)
{
int num = reader.ReadInt();
Debug.Log("Numero recebido: " + num);
total += num;
var writer = m_Driver.BeginSend(NetworkPipeline.Null, m_Connections[i]);
writer.WriteInt(total);
m_Driver.EndSend(writer);
}
//Check if the message of client is a disconnection
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Cliente " + i + " desconectou");
m_Connections[i] = default(NetworkConnection);
}
}
}
public void SetupServerAndClientAndConnectThem(int bufferSize)
{
//setup server
server_driver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = bufferSize
});
NetworkEndPoint server_endpoint = NetworkEndPoint.LoopbackIpv4;
server_endpoint.Port = 1337;
server_driver.Bind(server_endpoint);
server_driver.Listen();
//setup client
client_driver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = bufferSize
});
clientToServerConnection = client_driver.Connect(server_endpoint);
//update drivers
client_driver.ScheduleUpdate().Complete();
server_driver.ScheduleUpdate().Complete();
//accept connection
connectionToClient = server_driver.Accept();
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClient, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Empty, "Not empty NetworkEvent on the server appeared");
client_driver.ScheduleUpdate().Complete();
ev = clientToServerConnection.PopEvent(client_driver, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Connect, "NetworkEvent should have Type.Connect on the client");
}
public unsafe void Assert_PopEvent(out NetworkConnection connection, NetworkEvent.Type evnt)
{
BitSlice slice;
var retval = m_LocalDriver.PopEvent(out connection, out slice);
Assert.True(retval == evnt);
}
public unsafe void Assert_PopEvent(out NetworkConnection connection, NetworkEvent.Type evnt)
{
DataStreamReader reader;
var retval = m_LocalDriver.PopEvent(out connection, out reader);
Assert.True(retval == evnt);
}
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);
}
public void ConnectAttemptWithRetriesToARemoteEndPoint()
{
NetworkConnection connection;
NetworkEvent.Type eventType = 0;
DataStreamReader reader;
var hostAddress = IPCManager.Instance.CreateEndPoint(Utilities.Random.String(32));
// Tiny connect timeout for this test to be quicker
using (var client = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
},
new NetworkConfigParameter {
connectTimeoutMS = 1, maxConnectAttempts = 10
}))
{
client.Connect(hostAddress);
// Wait past the connect timeout so there will be unanswered connect requests
long timeout = m_timer.ElapsedMilliseconds + 2;
while (m_timer.ElapsedMilliseconds < timeout)
{
client.ScheduleUpdate().Complete();
}
using (var host = new LocalDriverHelper(hostAddress))
{
host.Host();
// Now give the next connect attempt time to happen
// TODO: Would be better to be able to see internal state here and explicitly wait until next connect attempt happens
timeout = m_timer.ElapsedMilliseconds + 10;
while (m_timer.ElapsedMilliseconds < timeout)
{
client.ScheduleUpdate().Complete();
}
host.Assert_GotConnectionRequest(client.LocalEndPoint(), true);
// Wait for the client to get the connect event back
timeout = m_timer.ElapsedMilliseconds + 2;
while (m_timer.ElapsedMilliseconds < timeout)
{
client.ScheduleUpdate().Complete();
eventType = client.PopEvent(out connection, out reader);
if (eventType != NetworkEvent.Type.Empty)
{
break;
}
}
Assert.AreEqual(NetworkEvent.Type.Connect, eventType);
}
}
}
public void DisconnectAndCleanup()
{
clientToServerConnection.Close(client_driver);
//update drivers
client_driver.ScheduleUpdate().Complete();
ev = PollDriverAndFindDataEvent(ref server_driver, connectionToClient, NetworkEvent.Type.Disconnect);
Assert.IsTrue(ev == NetworkEvent.Type.Disconnect, "NetworkEvent.Type.Disconnect was expected to appear, but " + ev + " appeared");
server_driver.Dispose();
client_driver.Dispose();
}
NetworkEvent.Type PollDriverAndFindDataEvent(ref NetworkDriver driver, NetworkConnection connection, NetworkEvent.Type eventType, int maxRetryCount = 10)
{
for (int retry = 0; retry < maxRetryCount; ++retry)
{
driver.ScheduleUpdate().Complete();
ev = driver.PopEventForConnection(connection, out stream);
if (ev == eventType || ev != NetworkEvent.Type.Empty)
{
return(ev);
}
}
return(NetworkEvent.Type.Empty);
}
public void DisconnectAndCleanup()
{
clientToServerConnection.Close(client_driver);
//update drivers
client_driver.ScheduleUpdate().Complete();
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClient, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Disconnect, "NetworkEvent.Type.Disconnect was expected to appear, but " + ev + "appeared");
server_driver.Dispose();
client_driver.Dispose();
}
public void SetupServerAndClientAndConnectThem(int bufferSize)
{
//setup server
server_driver = NetworkDriver.Create(new NetworkDataStreamParameter {
size = bufferSize
});
NetworkEndPoint server_endpoint = NetworkEndPoint.LoopbackIpv4;
server_endpoint.Port = 1337;
var ret = server_driver.Bind(server_endpoint);
int maxRetry = 10;
while (ret != 0 && --maxRetry > 0)
{
server_endpoint.Port += 17;
ret = server_driver.Bind(server_endpoint);
}
;
Assert.AreEqual(ret, 0, "Failed to bind the socket");
server_driver.Listen();
//setup client
client_driver = NetworkDriver.Create(new NetworkDataStreamParameter {
size = bufferSize
});
clientToServerConnection = client_driver.Connect(server_endpoint);
//update drivers
client_driver.ScheduleUpdate().Complete();
for (int i = 0; i < 10; ++i)
{
server_driver.ScheduleUpdate().Complete();
//accept connection
connectionToClient = server_driver.Accept();
if (connectionToClient.IsCreated)
{
break;
}
}
Assert.IsTrue(connectionToClient.IsCreated, "Failed to accept the connection");
ev = PollDriverAndFindDataEvent(ref server_driver, connectionToClient, NetworkEvent.Type.Empty);
Assert.IsTrue(ev == NetworkEvent.Type.Empty, $"Not empty NetworkEvent on the server appeared, got {ev} using {backend}");
ev = PollDriverAndFindDataEvent(ref client_driver, clientToServerConnection, NetworkEvent.Type.Connect);
Assert.IsTrue(ev == NetworkEvent.Type.Connect, $"NetworkEvent should have Type.Connect on the client, but got {ev} using {backend}");
}
public void ConnectAttemptWithRetriesToARemoteEndPoint()
{
NetworkConnection connection;
NetworkEvent.Type eventType = 0;
DataStreamReader reader;
// Tiny connect timeout for this test to be quicker
using (var client = new NetworkDriver(new IPCNetworkInterface(), new NetworkDataStreamParameter {
size = 64
},
new NetworkConfigParameter {
connectTimeoutMS = 15, maxConnectAttempts = 10, fixedFrameTimeMS = 10
}))
{
var hostAddress = NetworkEndPoint.LoopbackIpv4.WithPort(1);
client.Connect(hostAddress);
// Wait past the connect timeout so there will be unanswered connect requests
client.ScheduleUpdate().Complete();
client.ScheduleUpdate().Complete();
using (var host = new LocalDriverHelper(hostAddress))
{
host.Host();
// Now give the next connect attempt time to happen
// TODO: Would be better to be able to see internal state here and explicitly wait until next connect attempt happens
//client.ScheduleUpdate().Complete();
host.Assert_GotConnectionRequest(client.LocalEndPoint(), true);
// Wait for the client to get the connect event back
for (int i = 0; i < 2; ++i)
{
client.ScheduleUpdate().Complete();
eventType = client.PopEvent(out connection, out reader);
if (eventType != NetworkEvent.Type.Empty)
{
break;
}
}
Assert.AreEqual(NetworkEvent.Type.Connect, eventType);
}
}
}
public void DisconnectTimeoutOnServer()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint),
new NetworkConfigParameter {
disconnectTimeoutMS = 40, fixedFrameTimeMS = 10
}))
using (var client = new NetworkDriver(new IPCNetworkInterface(), new NetworkConfigParameter {
disconnectTimeoutMS = 40, fixedFrameTimeMS = 10
}))
{
NetworkConnection id;
NetworkEvent.Type popEvent = NetworkEvent.Type.Empty;
DataStreamReader reader;
byte reason = 0;
host.Host();
client.Connect(host.EndPoint);
client.ScheduleUpdate().Complete();
host.Assert_GotConnectionRequest(client.LocalEndPoint(), true);
// Host sends stuff but gets nothing back, until disconnect timeout happens
for (int frm = 0; frm < 10; ++frm)
{
if (host.m_LocalDriver.BeginSend(NetworkPipeline.Null, host.ClientConnections[0], out var stream) == 0)
{
for (int i = 0; i < 100; i++)
{
stream.WriteByte((byte)i);
}
host.m_LocalDriver.EndSend(stream);
}
if ((popEvent = host.m_LocalDriver.PopEvent(out id, out reader)) != NetworkEvent.Type.Empty)
{
reason = (reader.IsCreated && reader.Length > 0) ? reason = reader.ReadByte() : (byte)0;
break;
}
host.Update();
}
Assert.AreEqual(NetworkEvent.Type.Disconnect, popEvent);
Assert.AreEqual((byte)DisconnectReason.Timeout, reason);
}
}
private void Update()
{
m_Driver.ScheduleUpdate().Complete();
// CleanUp the Connections
CleanupClients();
// Accept hte New Connections
NetworkConnection c;
while ((c = m_Driver.Accept()) != default(NetworkConnection))
{
OnConnect(c);
}
DataStreamReader stream;
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
Assert.IsTrue(true);
}
NetworkEvent.Type cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream);
while (cmd != NetworkEvent.Type.Empty)
{
//Receiving Data from Client
if (cmd == NetworkEvent.Type.Data)
{
OnData(stream, i);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
m_Connections[i] = default(NetworkConnection);
continue;
}
cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream);
}
}
}
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);
}
}
private void Update()
{
m_Driver.ScheduleUpdate().Complete();
CleanupConnection();
if (m_Connections.Length >= 2)
{
timer += Time.deltaTime;
}
NetworkConnection c;
while ((c = m_Driver.Accept()) != default(NetworkConnection))
{
OnConnect(c);
}
DataStreamReader stream;
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
Assert.IsTrue(true);
}
NetworkEvent.Type cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream);
while (cmd != NetworkEvent.Type.Empty)
{
//When received data from client
if (cmd == NetworkEvent.Type.Data)
{
OnData(stream, i);
}
cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream);
}
}
}
void Update()
{
ValidateConnection();
string inputString = GenerateInputString();
while ((cmd = m_Connection.PopEvent(m_Driver, out stream)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
clientStatus.text = "Client Status: Online";
SendMessage(inputString, m_Driver, m_Connection);
}
else if (cmd == NetworkEvent.Type.Data)
{
var receivedString = ReadMessage(stream);
messageReceived.text = "Server:\n" + receivedString;
clientPositions = PopulateClientPositions(receivedString);
ManageCubes();
SendMessage(inputString, m_Driver, m_Connection);
}
}
}
public void AddEvent(NetworkEvent.Type type)
{
m_IncomingEvents->Add(new DriverEvent {
Type = type
});
}
public void AddEvent(NetworkEvent.Type type)
{
m_IncomingEvents->Add(type);
}
static void PrintEventError(NetworkEvent.Type evt)
{
UnityEngine.Debug.LogError("Received unknown network event " + evt);
}
public IEnumerator ServerAnd5Clients_Connect_Successfully()
{
int numberOfClients = 5;
NativeArray <NetworkConnection> connectionToClientArray;
NetworkDriver[] client_driversArray = new NetworkDriver[numberOfClients];
NativeArray <NetworkConnection> clientToServerConnectionsArray;
//setup server
connectionToClientArray = new NativeArray <NetworkConnection>(numberOfClients, Allocator.Persistent);
server_driver = NetworkDriver.Create(new NetworkDataStreamParameter {
size = 0
});
NetworkEndPoint server_endpoint = NetworkEndPoint.LoopbackIpv4;
server_endpoint.Port = 1337;
server_driver.Bind(server_endpoint);
server_driver.Listen();
//setup clients
clientToServerConnectionsArray = new NativeArray <NetworkConnection>(numberOfClients, Allocator.Persistent);
for (int i = 0; i < numberOfClients; i++)
{
client_driversArray[i] = NetworkDriver.Create(new NetworkDataStreamParameter {
size = 0
});
clientToServerConnectionsArray[i] = client_driversArray[i].Connect(server_endpoint);
}
//update drivers
for (int i = 0; i < numberOfClients; i++)
{
client_driversArray[i].ScheduleUpdate().Complete();
}
server_driver.ScheduleUpdate().Complete();
//accept connections
for (int i = 0; i < numberOfClients; i++)
{
connectionToClientArray[i] = server_driver.Accept();
ev = PollDriverAndFindDataEvent(ref server_driver, connectionToClientArray[i], NetworkEvent.Type.Empty);
Assert.IsTrue(ev == NetworkEvent.Type.Empty, "Not empty NetworkEvent on the server appeared");
ev = PollDriverAndFindDataEvent(ref client_driversArray[i], clientToServerConnectionsArray[i], NetworkEvent.Type.Connect);
Assert.IsTrue(ev == NetworkEvent.Type.Connect, "NetworkEvent should have Type.Connect on the client");
}
//close connections
for (int i = 0; i < numberOfClients; i++)
{
clientToServerConnectionsArray[i].Close(client_driversArray[i]);
//update drivers
client_driversArray[i].ScheduleUpdate().Complete();
ev = PollDriverAndFindDataEvent(ref server_driver, connectionToClientArray[i], NetworkEvent.Type.Disconnect);
Assert.IsTrue(ev == NetworkEvent.Type.Disconnect, "NetworkEvent.Type.Disconnect was expected to appear, but " + ev + " appeared");
}
server_driver.Dispose();
for (int i = 0; i < numberOfClients; i++)
{
client_driversArray[i].Dispose();
}
connectionToClientArray.Dispose();
clientToServerConnectionsArray.Dispose();
yield return(null);
}
