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 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 CreateAndConnect_NetworkConnection_ToRemoteEndPoint() { var connection = Driver.Connect(RemoteDriver.LocalEndPoint()); Assert.That(connection.IsCreated); RemoteDriver.Update(); Assert.That(RemoteDriver.Accept().IsCreated); Driver.Update(); BitSlice slice; Assert.That(connection.PopEvent(Driver, out slice) == NetworkEvent.Type.Connect); }
public void CreateAndConnect_NetworkConnection_ToRemoteEndPoint() { var connection = Driver.Connect(RemoteDriver.LocalEndPoint()); Assert.That(connection.IsCreated); Driver.ScheduleUpdate().Complete(); RemoteDriver.ScheduleUpdate().Complete(); Assert.That(RemoteDriver.Accept().IsCreated); Driver.ScheduleUpdate().Complete(); DataStreamReader reader; Assert.That(connection.PopEvent(Driver, out reader) == NetworkEvent.Type.Connect); }
public void Accept() { Driver.Bind(IPCManager.Instance.CreateEndPoint("network_host")); Driver.Listen(); Assert.That(Driver.Listening); // create connection to test to connect. /*var remote =*/ RemoteDriver.Connect(Driver.LocalEndPoint()); NetworkConnection id; DataStreamReader reader; const int maximumIterations = 10; int count = 0; bool connected = false; while (count++ < maximumIterations) { // Clear pending events Driver.PopEvent(out id, out reader); RemoteDriver.PopEvent(out id, out reader); Driver.ScheduleUpdate().Complete(); RemoteDriver.ScheduleUpdate().Complete(); var connection = Driver.Accept(); if (connection != default(NetworkConnection)) { connected = true; } } Assert.That(connected); }
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 Execute() { for (int i = 0; i < connections.Length; ++i) { connections[i] = driver.Accept(); } }
public void Tick() { //NetworkConnection connection; while ((/*connection =*/ m_Driver.Accept()) != default(NetworkConnection)) { //m_Connections.Add(connection); } }
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 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 NetworkConnection Accept() { return(m_LocalDriver.Accept()); }
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 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 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(); } } }