public void CreateServerDriver(World world, out NetworkDriver driver, out NetworkPipeline unreliablePipeline, out NetworkPipeline reliablePipeline, out NetworkPipeline unreliableFragmentedPipeline)
{
var reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
var fragmentationParams = new FragmentationUtility.Parameters {
PayloadCapacity = 16 * 1024
};
#if UNITY_EDITOR || DEVELOPMENT_BUILD
var netParams = new NetworkConfigParameter
{
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
disconnectTimeoutMS = NetworkParameterConstants.DisconnectTimeoutMS,
maxFrameTimeMS = 100
};
driver = NetworkDriver.Create(netParams, reliabilityParams, fragmentationParams);
#else
driver = NetworkDriver.Create(reliabilityParams);
#endif
unreliablePipeline = driver.CreatePipeline(typeof(NullPipelineStage));
reliablePipeline = driver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
unreliableFragmentedPipeline = driver.CreatePipeline(typeof(FragmentationPipelineStage));
}
private void Start()
{
//Debug.Log("ServerConnectionsComponent::Start called");
// Set timeout to something larger
NetworkConfigParameter config = new NetworkConfigParameter();
config.connectTimeoutMS = connectTimeoutMs;
config.disconnectTimeoutMS = disconnectTimeoutMs;
NetworkEndPoint addr = NetworkEndPoint.AnyIpv4;
addr.Port = 9000;
m_Driver = new UdpNetworkDriver(config);
if (m_Driver.Bind(addr) != 0)
{
Debug.Log("ServerConnectionsComponent::Start Failed to bind to port 9000");
}
else
{
m_Driver.Listen();
}
m_Connections = new NativeList <NetworkConnection>(MAX_NUM_PLAYERS, Allocator.Persistent);
}
protected void init()
{
//
var reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
var configParameter = new NetworkConfigParameter
{
maxConnectAttempts = maxConnectAttempts,
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
disconnectTimeoutMS = disconnectTimeoutMS
};
#if UNITY_EDITOR
int networkRate = (int)(1f / Time.fixedDeltaTime); // TODO: read from some better place
// All 3 packet types every frame stored for maximum delay, doubled for safety margin
int maxPackets = 2 * (networkRate * 3 * clientPacketDelay + 999) / 1000;
var simulatorParams = new SimulatorUtility.Parameters
{
MaxPacketSize = NetworkParameterConstants.MTU, MaxPacketCount = maxPackets, PacketDelayMs = clientPacketDelay, PacketDropPercentage = clientPacketDrop
};
_driver = new UdpNetworkDriver(simulatorParams, reliabilityParams, configParameter);
#else
_driver = new UdpNetworkDriver(reliabilityParams, configParameter);
#endif
_concurrentDriver = _driver.ToConcurrent();
_unreliablePipeline = NetworkPipeline.Null;
_reliablePipeline = NetworkPipeline.Null;
_listening = false;
}
public static void StartServer()
{
Console.Log("Starting server..");
var config = new NetworkConfigParameter
{
connectTimeoutMS = CONNECT_TIMEOUT,
disconnectTimeoutMS = DISCONNECT_TIMEOUT,
maxConnectAttempts = MAX_CONNECTION_ATTEMPTS
};
Driver = NetworkDriver.Create(config);
var endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = PORT;
if (Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to port " + PORT);
}
else
{
Driver.Listen(); // Sets the NetworkDriver in the Listen state
}
connections = new NativeList <NetworkConnection>(MAX_CONNECTIONS, Allocator.Persistent);
Console.Log("Server is up and running!");
}
public void CreateClientDriver(World world, out NetworkDriver driver, out NetworkPipeline unreliablePipeline, out NetworkPipeline reliablePipeline, out NetworkPipeline unreliableFragmentedPipeline)
{
var reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
var netParams = new NetworkConfigParameter
{
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
disconnectTimeoutMS = NetworkParameterConstants.DisconnectTimeoutMS,
maxFrameTimeMS = 100,
fixedFrameTimeMS = DriverFixedTime
};
var packetDelay = DriverSimulatedDelay;
int networkRate = 60;
// All 3 packet types every frame stored for maximum delay, doubled for safety margin
int maxPackets = 2 * (networkRate * 3 * packetDelay + 999) / 1000;
var fuzzFactor = 0;
const int kStringLength = 10; // we name it ClientTest e.g. 10 bytes long.
var worldId = int.Parse(world.Name.Substring(kStringLength, world.Name.Length - kStringLength));
if (DriverFuzzFactor?.Length >= worldId + 1)
{
fuzzFactor = DriverFuzzFactor[worldId];
}
var simParams = new SimulatorUtility.Parameters
{
MaxPacketSize = NetworkParameterConstants.MTU, MaxPacketCount = maxPackets,
PacketDelayMs = packetDelay,
FuzzFactor = fuzzFactor,
FuzzOffset = DriverFuzzOffset,
RandomSeed = DriverRandomSeed
};
driver = new NetworkDriver(new IPCNetworkInterface(), netParams, reliabilityParams, simParams);
if (DriverSimulatedDelay + fuzzFactor > 0)
{
unreliablePipeline = driver.CreatePipeline(
typeof(SimulatorPipelineStage),
typeof(SimulatorPipelineStageInSend));
reliablePipeline = driver.CreatePipeline(
typeof(SimulatorPipelineStage),
typeof(ReliableSequencedPipelineStage),
typeof(SimulatorPipelineStageInSend));
unreliableFragmentedPipeline = driver.CreatePipeline(
typeof(SimulatorPipelineStage),
typeof(FragmentationPipelineStage),
typeof(SimulatorPipelineStageInSend));
}
else
{
unreliablePipeline = driver.CreatePipeline(typeof(NullPipelineStage));
reliablePipeline = driver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
unreliableFragmentedPipeline = driver.CreatePipeline(typeof(FragmentationPipelineStage));
}
}
protected override void OnCreate()
{
if (!Library.Initialized)
{
if (!Library.Initialize())
{
throw new InvalidOperationException("Library not initialized");
}
Application.quitting += Library.Deinitialize;
}
var reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
#if UNITY_EDITOR || DEVELOPMENT_BUILD
var netParams = new NetworkConfigParameter
{
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
disconnectTimeoutMS = NetworkParameterConstants.DisconnectTimeoutMS,
maxFrameTimeMS = 100
};
m_ClientPacketDelay = ClientPacketDelayMs;
var jitter = ClientPacketJitterMs;
if (jitter > m_ClientPacketDelay)
{
jitter = m_ClientPacketDelay;
}
m_ClientPacketDrop = ClientPacketDropRate;
int networkRate = 60; // TODO: read from some better place
// All 3 packet types every frame stored for maximum delay, doubled for safety margin
int maxPackets = 2 * (networkRate * 3 * m_ClientPacketDelay + 999) / 1000;
var simulatorParams = new SimulatorUtility.Parameters
{
MaxPacketSize = NetworkParameterConstants.MTU, MaxPacketCount = maxPackets,
PacketDelayMs = m_ClientPacketDelay, PacketJitterMs = jitter,
PacketDropPercentage = m_ClientPacketDrop
};
m_Driver = new ENetDriver(16);
UnityEngine.Debug.Log($"Using simulator with latency={m_ClientPacketDelay} packet drop={m_ClientPacketDrop}");
#else
m_Driver = new ENetDriver(16);
#endif
m_UnreliablePipeline = NetworkPipeline.Null;
m_ReliablePipeline = NetworkPipeline.Null;
m_DriverListening = false;
m_Barrier = World.GetOrCreateSystem <BeginSimulationEntityCommandBufferSystem>();
numNetworkIds = new NativeArray <int>(1, Allocator.Persistent);
freeNetworkIds = new NativeQueue <int>(Allocator.Persistent);
rpcQueue = World.GetOrCreateSystem <RpcSystem>().GetRpcQueue <RpcSetNetworkId>();
m_NetworkStreamConnectionQuery = EntityManager.CreateEntityQuery(typeof(NetworkStreamConnection));
}
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);
}
}
//[Ignore("https://favro.com/organization/c564ede4ed3337f7b17986b6/215d676dd474c0744d2574f8?card=Uni-90284")]
public void UdpC_Timeout_ShouldDisconnect()
{
int customTimeout = 1000;
var config = new NetworkConfigParameter {
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
disconnectTimeoutMS = customTimeout,
};
using (var server = new UdpNetworkDriver(config))
using (var client = new UdpNetworkDriver(config))
{
var serverPort = 50006;
server.Bind(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort));
client.Bind(NetworkEndPoint.LoopbackIpv4);
server.Listen();
var id = client.Connect(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort));
NetworkConnection serverConnection, clientConnection;
int maxIterations = 100;
ConnectTogether(server, client, maxIterations, out serverConnection, out clientConnection);
Assert.AreEqual(id, serverConnection);
// Force timeout
Thread.Sleep(customTimeout + 500);
var message = new DataStreamWriter(7, Allocator.Persistent);
message.Write((byte)'m');
message.Write((byte)'e');
message.Write((byte)'s');
message.Write((byte)'s');
message.Write((byte)'a');
message.Write((byte)'g');
message.Write((byte)'e');
clientConnection.Send(server, message);
var data = new byte[1472];
int size = -1;
NetworkConnection from;
Assert.AreEqual(ExperimentalEventType.Disconnect, PollEvent(ExperimentalEventType.Disconnect, maxIterations, server, ref data, out size, out from));
Assert.AreEqual(from, clientConnection);
}
}
void Start()
{
Application.targetFrameRate = 30;
Application.runInBackground = true;
DontDestroyOnLoad(gameObject);
var config = new NetworkConfigParameter
{
connectTimeoutMS = CONNECT_TIMEOUT,
disconnectTimeoutMS = DISCONNECT_TIMEOUT,
maxConnectAttempts = MAX_CONNECTION_ATTEMPTS
};
Driver = NetworkDriver.Create(config);
Connection = default(NetworkConnection);
}
public void CreateClientDriver(World world, out NetworkDriver driver, out NetworkPipeline unreliablePipeline, out NetworkPipeline reliablePipeline, out NetworkPipeline unreliableFragmentedPipeline)
{
var reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
var fragmentationParams = new FragmentationUtility.Parameters {
PayloadCapacity = 16 * 1024
};
#if UNITY_EDITOR || DEVELOPMENT_BUILD
var netParams = new NetworkConfigParameter
{
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
disconnectTimeoutMS = NetworkParameterConstants.DisconnectTimeoutMS,
maxFrameTimeMS = 100
};
var simulatorParams = ClientSimulatorParameters;
driver = NetworkDriver.Create(netParams, simulatorParams, reliabilityParams, fragmentationParams);
#else
driver = NetworkDriver.Create(reliabilityParams);
#endif
#if UNITY_EDITOR || DEVELOPMENT_BUILD
if (simulatorParams.PacketDelayMs > 0 || simulatorParams.PacketDropInterval > 0)
{
unreliablePipeline = driver.CreatePipeline(
typeof(SimulatorPipelineStage),
typeof(SimulatorPipelineStageInSend));
reliablePipeline = driver.CreatePipeline(
typeof(SimulatorPipelineStage),
typeof(ReliableSequencedPipelineStage),
typeof(SimulatorPipelineStageInSend));
unreliableFragmentedPipeline = driver.CreatePipeline(
typeof(SimulatorPipelineStage),
typeof(FragmentationPipelineStage),
typeof(SimulatorPipelineStageInSend));
}
else
#endif
{
unreliablePipeline = driver.CreatePipeline(typeof(NullPipelineStage));
reliablePipeline = driver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
unreliableFragmentedPipeline = driver.CreatePipeline(typeof(FragmentationPipelineStage));
}
}
public void CreateServerDriver(World world, out NetworkDriver driver, out NetworkPipeline unreliablePipeline, out NetworkPipeline reliablePipeline)
{
var reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
var netParams = new NetworkConfigParameter
{
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
disconnectTimeoutMS = NetworkParameterConstants.DisconnectTimeoutMS,
maxFrameTimeMS = 100,
fixedFrameTimeMS = DriverFixedTime
};
driver = new NetworkDriver(new IPCNetworkInterface(), netParams, reliabilityParams);
unreliablePipeline = driver.CreatePipeline(typeof(NullPipelineStage));
reliablePipeline = driver.CreatePipeline(typeof(ReliableSequencedPipelineStage));
}
public void IPC_Setup()
{
TempDropPacketPipelineStageCollection.Register();
var timeoutParam = new NetworkConfigParameter
{
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
disconnectTimeoutMS = 90 * 1000,
fixedFrameTimeMS = 16
};
m_ServerDriver =
TestNetworkDriver.Create(
new NetworkDataStreamParameter {
size = 0
},
timeoutParam,
new ReliableUtility.Parameters {
WindowSize = 32
},
new FragmentationUtility.Parameters {
PayloadCapacity = 4 * 1024
});
m_ServerDriver.Bind(NetworkEndPoint.LoopbackIpv4);
m_ServerDriver.Listen();
m_ClientDriver =
TestNetworkDriver.Create(
new NetworkDataStreamParameter {
size = 0
},
timeoutParam,
new ReliableUtility.Parameters {
WindowSize = 32
},
new SimulatorUtility.Parameters {
MaxPacketCount = 30, MaxPacketSize = 16, PacketDelayMs = 0, /*PacketDropInterval = 8,*/ PacketDropPercentage = 10
},
new FragmentationUtility.Parameters {
PayloadCapacity = 4 * 1024
});
}
public void IPC_Setup()
{
var timeoutParam = new NetworkConfigParameter
{
connectTimeoutMS = NetworkParameterConstants.ConnectTimeoutMS,
maxConnectAttempts = NetworkParameterConstants.MaxConnectAttempts,
disconnectTimeoutMS = NetworkParameterConstants.DisconnectTimeoutMS,
fixedFrameTimeMS = 16
};
// NOTE: MaxPacketSize should be 64 for all the tests using simulator except needs to account for header size as well (one test has 2x2B headers)
var simulatorParams = new SimulatorUtility.Parameters()
{
MaxPacketSize = 72, MaxPacketCount = 30, PacketDelayMs = 100
};
TestNetworkPipelineStageCollection.Register();
m_ServerDriver = TestNetworkDriver.Create(timeoutParam, simulatorParams);
m_ServerDriver.Bind(NetworkEndPoint.LoopbackIpv4);
m_ServerDriver.Listen();
m_ClientDriver = TestNetworkDriver.Create(timeoutParam, simulatorParams);
m_ClientDriver2 = TestNetworkDriver.Create(timeoutParam, simulatorParams);
}
private void Start()
{
NetworkConfigParameter config = new NetworkConfigParameter();
config.connectTimeoutMS = connectTimeoutMs;
config.disconnectTimeoutMS = disconnectTimeoutMs;
//Debug.Log("ClientConnectionsComponent::Start called");
m_Driver = new UdpNetworkDriver(config);
m_BroadcastDriver = new UdpNetworkDriver(config);
m_Connection = default;
m_BroadcastConnection = default;
if (ipAddress == null)
{
ipAddress = "127.0.0.1";
}
//var endpoint = new IPEndPoint(ipAddress, 9000);
NetworkEndPoint endpoint = new NetworkEndPoint();
if (!NetworkEndPoint.TryParse(ipAddress, 9000, out endpoint))
{
Debug.LogError("ClientConnectionsComponent::Start Could not parse IP Address");
}
//Debug.Log("ClientConnectionsComponent::Start endpoint = " + ipAddress + ":" + endpoint.Port);
m_Connection = m_Driver.Connect(endpoint);
//Debug.Log("ClientConnectionsComponent::Start Connection state = " + m_Driver.GetConnectionState(m_Connection));
//Debug.Log("ClientConnectionsComponent::Start Remote Endpoint port = " + m_Driver.RemoteEndPoint(m_Connection).Port);
//Debug.Log("ClientConnectionsComponent::Start Local Endpoint port = " + m_Driver.LocalEndPoint().Port);
/*
* var broadcastEndpoint = new IPEndPoint(IPAddress.Any, 6677);
* m_BroadcastConnection = m_BroadcastDriver.Connect(broadcastEndpoint);
*/
}
/// <summary>
/// クライアント接続開始
/// </summary>
public void Start(IPAddress adress, int port)
{
serverAdress = adress;
serverPort = port;
if (!driver.IsCreated)
{
var parm = new NetworkConfigParameter()
{
connectTimeoutMS = 1000 * 5,
disconnectTimeoutMS = 1000 * 5,
};
driver = new UdpCNetworkDriver(new INetworkParameter[] { parm });
}
var endpoint = new IPEndPoint(serverAdress, port);
state = State.Connecting;
networkLinkerHandle = NetworkLinkerPool.CreateLinkerHandle(driver, driver.Connect(endpoint));
Debug.Log("StartClient");
}
/// <summary>
/// サーバー起動
/// </summary>
public void Start(int port)
{
if (state != State.Offline)
{
Debug.LogError("Start Failed currentState = " + state);
return;
}
leaderStatTime = System.DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
if (!driver.IsCreated)
{
var parm = new NetworkConfigParameter()
{
connectTimeoutMS = 1000 * 5,
disconnectTimeoutMS = 1000 * 5,
};
driver = new UdpCNetworkDriver(new INetworkParameter[] { parm });
}
state = State.Connecting;
var endPoint = new IPEndPoint(IPAddress.Any, port);
if (driver.Bind(endPoint) != 0)
{
Debug.Log("Failed to bind to port 9000");
}
else
{
driver.Listen();
}
networkLinkerHandles = new NativeList <NetworkLinkerHandle> (16, Allocator.Persistent);
//networkLinkerHandles.Add (default);
RegisterPlayerId(0, endPoint, default(NetworkConnection));
Debug.Log("StartServer");
}
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();
}
}
}
