public void AcceptInJobWorks()
{
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());
clientDriver.ScheduleUpdate().Complete();
var serverToClient = new NativeArray <NetworkConnection>(1, Allocator.TempJob);
var acceptJob = new AcceptJob {
driver = serverDriver, connections = serverToClient
};
Assert.IsFalse(serverToClient[0].IsCreated);
acceptJob.Schedule(serverDriver.ScheduleUpdate()).Complete();
Assert.IsTrue(serverToClient[0].IsCreated);
serverToClient.Dispose();
clientDriver.Dispose();
serverDriver.Dispose();
}
public void SendInJobWorks()
{
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 sendJob = new SendJob {
driver = clientDriver, connection = clientToServer
};
clientDriver.ScheduleUpdate(sendJob.Schedule()).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));
clientDriver.Dispose();
serverDriver.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 void BindDriverToAEndPoint()
{
var driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
driver.Bind(IPCManager.Instance.CreateEndPoint("host"));
driver.Dispose();
}
public void SendReceiveWithPipelineInParallelJobWorks()
{
var timeoutParam = new NetworkConfigParameter
{
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
disconnectTimeoutMS = 90 * 1000,
maxFrameTimeMS = 16
};
NativeArray <NetworkConnection> serverToClient;
using (var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam))
using (var clientDriver0 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam))
using (var clientDriver1 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam))
using (serverToClient = new NativeArray <NetworkConnection>(2, Allocator.Persistent))
{
var serverPipeline = serverDriver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var client0Pipeline = clientDriver0.CreatePipeline(typeof(ReliableSequencedPipelineStage));
var client1Pipeline = clientDriver1.CreatePipeline(typeof(ReliableSequencedPipelineStage));
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, client0Pipeline, strmWriter);
clientToServer1.Send(clientDriver1, client1Pipeline, strmWriter);
clientDriver0.ScheduleUpdate().Complete();
clientDriver1.ScheduleUpdate().Complete();
var sendRecvJob = new SendReceiveWithPipelineParallelJob
{
driver = serverDriver.ToConcurrent(), connections = serverToClient, pipeline = serverPipeline
};
var jobHandle = serverDriver.ScheduleUpdate();
jobHandle = sendRecvJob.Schedule(serverToClient.Length, 1, jobHandle);
serverDriver.ScheduleUpdate(jobHandle).Complete();
AssertDataReceived(serverDriver, serverToClient, clientDriver0, clientToServer0, 43, false);
AssertDataReceived(serverDriver, serverToClient, clientDriver1, clientToServer1, 43, false);
}
}
public void ListenOnDriver()
{
var driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
// Make sure we Bind before we Listen.
driver.Bind(IPCManager.Instance.CreateEndPoint("host"));
driver.Listen();
Assert.True(driver.Listening);
driver.Dispose();
}
public void IPC_Setup()
{
IPCManager.Instance.Initialize(100);
Stream = new BitStream(64, Allocator.Persistent);
Driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
RemoteDriver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
RemoteDriver.Bind(IPCManager.Instance.CreateEndPoint("remote_host"));
RemoteDriver.Listen();
}
public void SendReceiveInParallelJobWorks()
{
NativeArray <NetworkConnection> serverToClient;
using (var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}))
using (var clientDriver0 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}))
using (var clientDriver1 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}))
using (serverToClient = new NativeArray <NetworkConnection>(2, Allocator.Persistent))
{
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
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);
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();
AssertDataReceived(serverDriver, serverToClient, clientDriver0, clientToServer0, 43, true);
AssertDataReceived(serverDriver, serverToClient, clientDriver1, clientToServer1, 43, true);
}
}
public void AcceptNewConnectionsOnDriver()
{
var driver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
// Make sure we Bind before we Listen.
driver.Bind(IPCManager.Instance.CreateEndPoint("host"));
driver.Listen();
Assert.True(driver.Listening);
NetworkConnection connection;
while ((connection = driver.Accept()) != default(NetworkConnection))
{
//Assert.True(connectionId != NetworkParameterConstants.InvalidConnectionId);
}
driver.Dispose();
}
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 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 Host()
{
m_LocalDriver.Bind(Address);
m_LocalDriver.Listen();
}
public void SendAndReceiveMessage()
{
using (var clientSendData = new BitStream(64, Allocator.Persistent))
{
BitSlice stream;
var serverEndpoint = IPCManager.Instance.CreateEndPoint("server");
var serverDriver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
serverDriver.Bind(serverEndpoint);
serverDriver.Listen();
var clientDriver = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
});
clientDriver.Bind(IPCManager.Instance.CreateEndPoint("client"));
var clientToServerId = clientDriver.Connect(serverEndpoint);
serverDriver.Update();
NetworkConnection serverToClientId = serverDriver.Accept();
Assert.That(serverToClientId != default(NetworkConnection));
var eventId = serverDriver.PopEventForConnection(serverToClientId, out stream);
Assert.That(eventId == NetworkEvent.Type.Connect);
clientDriver.Update();
eventId = clientDriver.PopEventForConnection(clientToServerId, out stream);
Assert.That(eventId == NetworkEvent.Type.Connect);
int testInt = 100;
float testFloat = 555.5f;
byte[] testByteArray = Encoding.ASCII.GetBytes("Some bytes blablabla 1111111111111111111");
clientSendData.Write(testInt);
clientSendData.Write(testFloat);
clientSendData.Write(testByteArray.Length);
clientSendData.Write(testByteArray);
var sentBytes = clientDriver.Send(clientToServerId, clientSendData);
// Header size is included in the sent bytes count (4 bytes overhead)
Assert.AreEqual(clientSendData.GetBytesWritten() + 4, sentBytes);
clientDriver.Update();
serverDriver.Update();
BitSlice serverReceiveBitSlice;
eventId = serverDriver.PopEventForConnection(serverToClientId, out serverReceiveBitSlice);
Assert.True(eventId == NetworkEvent.Type.Data);
var receivedInt = serverReceiveBitSlice.ReadInt();
var receivedFloat = serverReceiveBitSlice.ReadFloat();
var byteArrayLength = serverReceiveBitSlice.ReadInt();
var receivedBytes = serverReceiveBitSlice.ReadBytesAsArray(byteArrayLength);
Assert.True(testInt == receivedInt);
Assert.That(Mathf.Approximately(testFloat, receivedFloat));
Assert.AreEqual(testByteArray, receivedBytes);
clientDriver.Dispose();
serverDriver.Dispose();
}
}
public void SendReceiveWithPipelineInParallelJobWorks()
{
var timeoutParam = new NetworkConfigParameter
{
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
disconnectTimeoutMS = 90 * 1000
};
var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam);
var serverPipeline = serverDriver.CreatePipeline(typeof(UnreliableSequencedPipelineStage));
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var clientDriver0 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam);
var clientDriver1 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam);
var client0Pipeline = clientDriver0.CreatePipeline(typeof(UnreliableSequencedPipelineStage));
var client1Pipeline = clientDriver1.CreatePipeline(typeof(UnreliableSequencedPipelineStage));
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, client0Pipeline, strmWriter);
clientToServer1.Send(clientDriver1, client1Pipeline, strmWriter);
clientDriver0.ScheduleUpdate().Complete();
clientDriver1.ScheduleUpdate().Complete();
var sendRecvJob = new SendReceiveWithPipelineParallelJob {
driver = serverDriver.ToConcurrent(), connections = serverToClient, pipeline = serverPipeline
};
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 void ParallelSendReceiveStressTest()
{
var timeoutParam = new NetworkConfigParameter
{
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
disconnectTimeoutMS = 90 * 1000,
maxFrameTimeMS = 16
};
NativeArray <NetworkConnection> serverToClient;
var clientDrivers = new List <LocalNetworkDriver>();
var clientPipelines = new List <NetworkPipeline>();
var clientToServer = new List <NetworkConnection>();
try
{
for (int i = 0; i < 250; ++i)
{
clientDrivers.Add(new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}, timeoutParam));
clientPipelines.Add(clientDrivers[i].CreatePipeline(typeof(ReliableSequencedPipelineStage)));
}
using (var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 17 * clientDrivers.Count
}, timeoutParam))
using (serverToClient = new NativeArray <NetworkConnection>(clientDrivers.Count, Allocator.Persistent))
{
var serverPipeline = serverDriver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
for (var i = 0; i < clientDrivers.Count; ++i)
{
var drv = clientDrivers[i];
var con = drv.Connect(serverDriver.LocalEndPoint());
WaitForConnected(drv, serverDriver, con);
clientToServer.Add(con);
serverToClient[i] = serverDriver.Accept();
Assert.IsTrue(serverToClient[i].IsCreated);
}
for (var i = 0; i < clientDrivers.Count; ++i)
{
clientToServer[i].Send(clientDrivers[i], clientPipelines[i], strmWriter);
clientDrivers[i].ScheduleUpdate().Complete();
}
var sendRecvJob = new SendReceiveWithPipelineParallelJob
{
driver = serverDriver.ToConcurrent(), connections = serverToClient, pipeline = serverPipeline
};
var jobHandle = serverDriver.ScheduleUpdate();
jobHandle = sendRecvJob.Schedule(serverToClient.Length, 1, jobHandle);
serverDriver.ScheduleUpdate(jobHandle).Complete();
for (var i = 0; i < clientDrivers.Count; ++i)
{
AssertDataReceived(serverDriver, serverToClient, clientDrivers[i], clientToServer[i], 43, false);
}
}
}
finally
{
foreach (var drv in clientDrivers)
{
drv.Dispose();
}
}
}
public void FillInternalBitStreamBuffer()
{
const int k_InternalBufferSize = 1000;
const int k_PacketCount = 21; // Exactly enough to fill the receive buffer + 1 too much
const int k_PacketSize = 50;
using (var host = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = k_InternalBufferSize
}))
using (var client = new LocalNetworkDriver(new NetworkBitStreamParameter {
size = 64
}))
using (var stream = new BitStream(64, Allocator.Persistent))
{
host.Bind(IPCManager.Instance.CreateEndPoint(Utilities.Random.String(32)));
host.Listen();
NetworkConnection connectionId = client.Connect(host.LocalEndPoint());
client.Update();
host.Update();
NetworkConnection poppedId;
BitSlice slice;
var retval = host.PopEvent(out poppedId, out slice);
Assert.AreEqual(retval, NetworkEvent.Type.Connect);
host.Accept();
client.Update();
retval = client.PopEvent(out poppedId, out slice);
Assert.AreEqual(retval, NetworkEvent.Type.Connect);
var dataBlob = new Dictionary <int, byte[]>();
for (int i = 0; i < k_PacketCount; ++i)
{
// Scramble each packet contents so you can't match reading the same data twice as success
dataBlob.Add(i, Encoding.ASCII.GetBytes(Utilities.Random.String(k_PacketSize)));
}
for (int i = 0; i < k_PacketCount; ++i)
{
stream.Reset();
stream.Write(dataBlob[i]);
client.Send(connectionId, stream);
}
// Process the pending events
client.Update();
host.Update();
for (int i = 0; i < k_PacketCount; ++i)
{
retval = host.PopEvent(out poppedId, out slice);
if (i == k_PacketCount - 1)
{
Assert.AreEqual(retval, NetworkEvent.Type.Empty);
Assert.AreEqual(slice.Length, 0);
host.Update();
retval = host.PopEvent(out poppedId, out slice);
}
Assert.AreEqual(retval, NetworkEvent.Type.Data);
Assert.AreEqual(k_PacketSize, slice.Length);
for (int j = 0; j < k_PacketSize; ++j)
{
Assert.AreEqual(dataBlob[i][j], slice.ReadByte());
}
}
}
}
public void Listen()
{
Driver.Bind(IPCManager.Instance.CreateEndPoint("network_host"));
Driver.Listen();
Assert.That(Driver.Listening);
}
public void Host(NetworkEndPoint endpoint)
{
m_Driver.Bind(endpoint);
m_Driver.Listen();
}