public void SendToAllTest()
{
// message handlers
NetworkServer.RegisterHandler <ConnectMessage>((conn, msg) => {}, false);
NetworkServer.RegisterHandler <DisconnectMessage>((conn, msg) => {}, false);
NetworkServer.RegisterHandler <ErrorMessage>((conn, msg) => {}, false);
// listen
NetworkServer.Listen(1);
Assert.That(NetworkServer.connections.Count, Is.EqualTo(0));
// add connection
ULocalConnectionToClient connection = new ULocalConnectionToClient();
connection.connectionToServer = new ULocalConnectionToServer();
// set a client handler
int called = 0;
connection.connectionToServer.SetHandlers(new Dictionary <int, NetworkMessageDelegate>()
{
{ MessagePacker.GetId <TestMessage>(), ((conn, reader, channelId) => ++ called) }
});
NetworkServer.AddConnection(connection);
// create a message
TestMessage message = new TestMessage {
IntValue = 1, DoubleValue = 2, StringValue = "3"
};
// send it to all
bool result = NetworkServer.SendToAll(message);
Assert.That(result, Is.True);
// update local connection once so that the incoming queue is processed
connection.connectionToServer.Update();
// was it send to and handled by the connection?
Assert.That(called, Is.EqualTo(1));
// clean up
NetworkServer.Shutdown();
}
public void SpawnMessageTest()
{
DoTest(0);
DoTest(42);
void DoTest(ulong testSceneId)
{
// try setting value with constructor
SpawnMessage message = new SpawnMessage
{
netId = 42,
isLocalPlayer = true,
isOwner = true,
sceneId = testSceneId,
assetId = Guid.NewGuid(),
position = UnityEngine.Vector3.one,
rotation = UnityEngine.Quaternion.identity,
scale = UnityEngine.Vector3.one,
payload = new ArraySegment <byte>(new byte[] { 0x01, 0x02 })
};
byte[] arr = MessagePacker.Pack(message);
SpawnMessage fresh = MessagePacker.Unpack <SpawnMessage>(arr);
Assert.That(fresh.netId, Is.EqualTo(message.netId));
Assert.That(fresh.isLocalPlayer, Is.EqualTo(message.isLocalPlayer));
Assert.That(fresh.isOwner, Is.EqualTo(message.isOwner));
Assert.That(fresh.sceneId, Is.EqualTo(message.sceneId));
if (fresh.sceneId == 0)
{
Assert.That(fresh.assetId, Is.EqualTo(message.assetId));
}
Assert.That(fresh.position, Is.EqualTo(message.position));
Assert.That(fresh.rotation, Is.EqualTo(message.rotation));
Assert.That(fresh.scale, Is.EqualTo(message.scale));
Assert.That(fresh.payload.Count, Is.EqualTo(message.payload.Count));
for (int i = 0; i < fresh.payload.Count; ++i)
{
Assert.That(fresh.payload.Array[fresh.payload.Offset + i],
Is.EqualTo(message.payload.Array[message.payload.Offset + i]));
}
}
}
public void UpdateVarsMessageTest()
{
// try setting value with constructor
var message = new UpdateVarsMessage
{
netId = 42,
payload = new ArraySegment <byte>(new byte[] { 0x01, 0x02 })
};
var arr = MessagePacker.Pack(message);
var fresh = MessagePacker.Unpack <UpdateVarsMessage>(arr);
Assert.That(fresh.netId, Is.EqualTo(message.netId));
Assert.That(fresh.payload.Count, Is.EqualTo(message.payload.Count));
for (var i = 0; i < fresh.payload.Count; ++i)
{
Assert.That(fresh.payload.Array[fresh.payload.Offset + i],
Is.EqualTo(message.payload.Array[message.payload.Offset + i]));
}
}
public void OnDataReceivedInvalidConnectionIdTest()
{
// message handlers
NetworkServer.RegisterHandler <ConnectMessage>((conn, msg) => { }, false);
NetworkServer.RegisterHandler <DisconnectMessage>((conn, msg) => { }, false);
NetworkServer.RegisterHandler <ErrorMessage>((conn, msg) => { }, false);
// add one custom message handler
bool wasReceived = false;
NetworkConnection connectionReceived = null;
TestMessage messageReceived = new TestMessage();
NetworkServer.RegisterHandler <TestMessage>((conn, msg) =>
{
wasReceived = true;
connectionReceived = conn;
messageReceived = msg;
}, false);
// listen
NetworkServer.Listen(1);
Assert.That(NetworkServer.connections.Count, Is.EqualTo(0));
// serialize a test message into an arraysegment
TestMessage testMessage = new TestMessage {
IntValue = 13, DoubleValue = 14, StringValue = "15"
};
NetworkWriter writer = new NetworkWriter();
MessagePacker.Pack(testMessage, writer);
ArraySegment <byte> segment = writer.ToArraySegment();
// call transport.OnDataReceived with an invalid connectionId
// an error log is expected.
LogAssert.ignoreFailingMessages = true;
Transport.activeTransport.OnServerDataReceived.Invoke(42, segment, 0);
LogAssert.ignoreFailingMessages = false;
// message handler should never be called
Assert.That(wasReceived, Is.False);
Assert.That(connectionReceived, Is.Null);
}
/// <summary>
/// Does not supress errors invloving clients that already have visibility of this Network Behaviour.
/// Server only.
/// </summary>
/// <param name="clientIDs"></param>
public void NetworkShow(List <ulong> clientIDs, Stream spawnPayload = null)
{
//A faster message send bypassing MessageSender completely
if (clientIDs == null)
{
throw new ArgumentNullException(nameof(clientIDs));
}
using (PooledBitStream baseStream = PooledBitStream.Get())
{
DoVisibleShowWrite(baseStream, spawnPayload);
baseStream.PadStream();
if (clientIDs.Count == 0)
{
return; //No one to send to.
}
using (BitStream stream = MessagePacker.WrapMessage(networkBehaviourManager.spawnMessageType, 0, baseStream, SecuritySendFlags.None))
{
for (int i = 0; i < clientIDs.Count; i++)
{
if (clientIDs[i] == NetworkManager.Get().serverID)
{
continue;
}
if (m_PendingObservers.Contains(clientIDs[i]))
{
Debug.LogError("This Network Behaviour is already pending visibility to client '" + clientIDs[i] + "'. Watch for a call to NetworkStart for when it successfully connects.", this);
continue;
}
if (m_Observers.Contains(clientIDs[i]))
{
Debug.LogError("This Network Behaviour is already pending visibility to client '" + clientIDs[i] + "'. Watch for a call to NetworkStart for when it successfully connects.", this);
continue;
}
m_PendingObservers.Add(clientIDs[i]);
NetworkManager.Get().transport.Send(clientIDs[i], new ArraySegment <byte>(stream.GetBuffer(), 0, (int)stream.Length), networkManager.networkInternalChannel);
}
}
}
}
static public void SendToAll(byte messageType, byte channel, BitStream messageStream)
{
messageStream.PadStream();
using (BitStream stream = MessagePacker.WrapMessage(messageType, 0, messageStream, SecuritySendFlags.None))
{
using (List <ulong> .Enumerator clients = NetworkManager.Get().clients)
{
while (clients.MoveNext())
{
if (NetworkManager.Get().isServer&& clients.Current == NetworkManager.Get().serverID)
{
continue;
}
NetworkManager.Get().transport.Send(clients.Current, new ArraySegment <byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);
}
}
}
}
public void MessageInheirtanceWorksWithMultipleLayers()
{
const int value1 = 10;
const int value2 = 13;
const int value3 = 15;
Layer3Message intMessage = new Layer3Message
{
value1 = value1,
value2 = value2,
value3 = value3
};
byte[] data = MessagePacker.Pack(intMessage);
Layer3Message unpacked = MessagePacker.Unpack <Layer3Message>(data);
Assert.That(unpacked.value1, Is.EqualTo(value1));
Assert.That(unpacked.value2, Is.EqualTo(value2));
Assert.That(unpacked.value3, Is.EqualTo(value3));
}
internal static void Send(byte messageType, string channelName, BitStream messageStream, SecuritySendFlags flags, NetworkedObject targetObject)
{
bool encrypted = ((flags & SecuritySendFlags.Encrypted) == SecuritySendFlags.Encrypted) && NetworkingManager.Singleton.NetworkConfig.EnableEncryption;
bool authenticated = ((flags & SecuritySendFlags.Authenticated) == SecuritySendFlags.Authenticated) && NetworkingManager.Singleton.NetworkConfig.EnableEncryption;
if (authenticated || encrypted)
{
for (int i = 0; i < NetworkingManager.Singleton.ConnectedClientsList.Count; i++)
{
Send(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, messageType, channelName, messageStream, flags, targetObject);
}
}
else
{
messageStream.PadStream();
using (BitStream stream = MessagePacker.WrapMessage(messageType, 0, messageStream, flags))
{
NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);
for (int i = 0; i < NetworkingManager.Singleton.ConnectedClientsList.Count; i++)
{
if (NetworkingManager.Singleton.IsServer && NetworkingManager.Singleton.ConnectedClientsList[i].ClientId == NetworkingManager.Singleton.ServerClientId)
{
continue;
}
if (targetObject != null && !targetObject.observers.Contains(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
{
NetworkLog.LogWarning("Silently suppressed send(all) call because it was directed to an object without visibility");
}
continue;
}
NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, new ArraySegment <byte>(stream.GetBuffer(), 0, (int)stream.Length), channelName);
}
NetworkProfiler.EndEvent();
}
}
}
public void HideForConnection()
{
// listen
NetworkServer.Listen(1);
Assert.That(NetworkServer.connections.Count, Is.EqualTo(0));
// add connection
ULocalConnectionToClient connection = new ULocalConnectionToClient();
// required for ShowForConnection
connection.isReady = true;
connection.connectionToServer = new ULocalConnectionToServer();
// set a client handler
int called = 0;
connection.connectionToServer.SetHandlers(new Dictionary <int, NetworkMessageDelegate>()
{
{ MessagePacker.GetId <ObjectHideMessage>(), ((conn, reader, channelId) => ++ called) }
});
NetworkServer.AddConnection(connection);
// create a gameobject and networkidentity
NetworkIdentity identity = new GameObject().AddComponent <NetworkIdentity>();
identity.connectionToClient = connection;
// call HideForConnection
NetworkServer.HideForConnection(identity, connection);
// update local connection once so that the incoming queue is processed
connection.connectionToServer.Update();
// was it sent to and handled by the connection?
Assert.That(called, Is.EqualTo(1));
// clean up
NetworkServer.Shutdown();
// destroy GO after shutdown, otherwise isServer is true in OnDestroy and it tries to call
// GameObject.Destroy (but we need DestroyImmediate in Editor)
GameObject.DestroyImmediate(identity.gameObject);
}
public void TestUnpackIdMismatch()
{
// Unpack<T> has a id != msgType case that throws a FormatException.
// let's try to trigger it.
SceneMessage message = new SceneMessage()
{
sceneName = "Hello world",
sceneOperation = SceneOperation.LoadAdditive
};
byte[] data = MessagePacker.Pack(message);
// overwrite the id
data[0] = 0x01;
data[1] = 0x02;
Assert.Throws <FormatException>(() => {
SceneMessage unpacked = MessagePacker.Unpack <SceneMessage>(data);
});
}
private void HandleIncomingData(ulong sendingClientID, byte channel, ArraySegment <byte> data, float receiveTime)
{
if (enableLogging)
{
Debug.Log("Unwrapping Data Header");
}
inputStreamWrapper.SetTarget(data.Array);
inputStreamWrapper.SetLength(data.Count + data.Offset);
inputStreamWrapper.Position = data.Offset;
using (BitStream messageStream = MessagePacker.UnwrapMessage(inputStreamWrapper, sendingClientID, out byte messageType, out SecuritySendFlags security))
{
if (messageStream == null)
{
Debug.LogError("Message unwrap could not be completed. Was the header corrupt? Crypto error?");
return;
}
else if (messageType == (byte)MessageType.INVALID)
{
Debug.LogError("Message unwrap read an invalid messageType");
return;
}
uint headerByteSize = (uint)Arithmetic.VarIntSize(messageType);
//if(enableLogging)
//Debug.Log("Data Header: messageType=" + m_MessageHandler.GetMessageName(messageType) + "(" + messageType + ")");
// Client tried to send a network message that was not the connection request before they were accepted
if (m_PendingClientsDictionary.ContainsKey(sendingClientID) && m_PendingClientsDictionary[sendingClientID].connectionState == PendingClient.State.PendingConnection && messageType != (byte)MessageType.NETWORK_CONNECTION_REQUEST)
{
Debug.LogWarning("Message received from clientID " + sendingClientID + " before it has been accepted. Message type: (" + messageType.ToString() + ") " + m_MessageHandler.GetMessageName(messageType));
return;
}
//Handle Message
m_MessageHandler.HandleMessage(sendingClientID, messageType, messageStream, receiveTime);
}
}
public void SendsData()
{
Message message = new Message
{
collection = new string[]
{
"Some", "String", "Value"
}
};
byte[] data = MessagePackerTest.PackToByteArray(message);
Message unpacked = MessagePacker.Unpack <Message>(data);
string[] unpackedCollection = unpacked.collection;
Assert.IsNotNull(unpackedCollection);
Assert.IsNotEmpty(unpackedCollection);
Assert.That(unpackedCollection[0], Is.EqualTo("Some"));
Assert.That(unpackedCollection[1], Is.EqualTo("String"));
Assert.That(unpackedCollection[2], Is.EqualTo("Value"));
}
public void SendsData()
{
Message message = new Message
{
collection = new Vector3[]
{
new Vector3(1, 2, 3), new Vector3(4, 5, 6), new Vector3(7, 8, 9)
}
};
byte[] data = MessagePackerTest.PackToByteArray(message);
Message unpacked = MessagePacker.Unpack <Message>(data);
Vector3[] unpackedCollection = unpacked.collection;
Assert.IsNotNull(unpackedCollection);
Assert.IsNotEmpty(unpackedCollection);
Assert.That(unpackedCollection[0], Is.EqualTo(new Vector3(1, 2, 3)));
Assert.That(unpackedCollection[1], Is.EqualTo(new Vector3(4, 5, 6)));
Assert.That(unpackedCollection[2], Is.EqualTo(new Vector3(7, 8, 9)));
}
public void TestUnpackIdMismatch()
{
// Unpack<T> has a id != msgType case that throws a FormatException.
// let's try to trigger it.
var message = new SceneMessage
{
MainActivateScene = "Hello world",
SceneOperation = SceneOperation.LoadAdditive
};
var data = MessagePacker.Pack(message);
// overwrite the id
data[0] = 0x01;
data[1] = 0x02;
Assert.Throws <FormatException>(delegate
{
_ = MessagePacker.Unpack <SceneMessage>(data);
});
}
public void SendsData()
{
Message message = new Message
{
collection = new int[]
{
3, 4, 5
}
};
byte[] data = MessagePackerTest.PackToByteArray(message);
Message unpacked = MessagePacker.Unpack <Message>(data);
int[] unpackedCollection = unpacked.collection;
Assert.IsNotNull(unpackedCollection);
Assert.IsNotEmpty(unpackedCollection);
Assert.That(unpackedCollection[0], Is.EqualTo(3));
Assert.That(unpackedCollection[1], Is.EqualTo(4));
Assert.That(unpackedCollection[2], Is.EqualTo(5));
}
internal static void Send(ulong clientId, byte messageType, NetworkChannel networkChannel, NetworkBuffer messageBuffer)
{
messageBuffer.PadBuffer();
if (NetworkManager.Singleton.IsServer && clientId == NetworkManager.Singleton.ServerClientId)
{
return;
}
using (var buffer = MessagePacker.WrapMessage(messageType, messageBuffer))
{
NetworkProfiler.StartEvent(TickType.Send, (uint)buffer.Length, networkChannel, NetworkConstants.MESSAGE_NAMES[messageType]);
NetworkManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, new ArraySegment <byte>(buffer.GetBuffer(), 0, (int)buffer.Length), networkChannel);
ProfilerStatManager.BytesSent.Record((int)buffer.Length);
PerformanceDataManager.Increment(ProfilerConstants.ByteSent, (int)buffer.Length);
#if !UNITY_2020_2_OR_NEWER
NetworkProfiler.EndEvent();
#endif
}
}
public void RpcMessageTest()
{
// try setting value with constructor
var message = new RpcMessage
{
netId = 42,
componentIndex = 4,
functionIndex = 3,
payload = new ArraySegment <byte>(new byte[] { 0x01, 0x02 })
};
var arr = MessagePacker.Pack(message);
var fresh = MessagePacker.Unpack <RpcMessage>(arr);
Assert.That(fresh.netId, Is.EqualTo(message.netId));
Assert.That(fresh.componentIndex, Is.EqualTo(message.componentIndex));
Assert.That(fresh.functionIndex, Is.EqualTo(message.functionIndex));
Assert.That(fresh.payload.Count, Is.EqualTo(message.payload.Count));
for (var i = 0; i < fresh.payload.Count; ++i)
{
Assert.That(fresh.payload.Array[fresh.payload.Offset + i],
Is.EqualTo(message.payload.Array[message.payload.Offset + i]));
}
}
/// <summary>
/// Hides an object from a specific clients.
/// Server only.
/// </summary>
/// <param name="clientIDs">The clients to hide the object from.</param>
public void NetworkHide(List <ulong> clientIDs)
{
//A faster message send bypassing MessageSender completely
if (clientIDs == null)
{
throw new ArgumentNullException(nameof(clientIDs));
}
using (PooledBitStream baseStream = PooledBitStream.Get())
{
DoVisibleHideWrite(baseStream);
baseStream.PadStream();
if (clientIDs.Count == 0)
{
return; //No one to send to.
}
using (BitStream stream = MessagePacker.WrapMessage(networkBehaviourManager.unspawnMessageType, 0, baseStream, SecuritySendFlags.None))
{
for (int i = 0; i < clientIDs.Count; i++)
{
if (clientIDs[i] == networkManager.serverID)
{
continue;
}
if (!m_PendingObservers.Remove(clientIDs[i]) && !m_Observers.Remove(clientIDs[i]))
{
Debug.LogError("This Network Behaviour is already not visible to client '" + clientIDs[i] + "'.", this);
continue;
}
networkManager.transport.Send(clientIDs[i], new ArraySegment <byte>(stream.GetBuffer(), 0, (int)stream.Length), networkManager.networkInternalChannel);
}
}
}
}
public void SyncEventMessageTest()
{
// try setting value with constructor
SyncEventMessage message = new SyncEventMessage
{
netId = 42,
componentIndex = 4,
functionHash = 0xABCDEF,
payload = new ArraySegment <byte>(new byte[] { 0x01, 0x02 })
};
byte[] arr = MessagePacker.Pack(message);
SyncEventMessage fresh = MessagePacker.Unpack <SyncEventMessage>(arr);
Assert.That(fresh.netId, Is.EqualTo(message.netId));
Assert.That(fresh.componentIndex, Is.EqualTo(message.componentIndex));
Assert.That(fresh.functionHash, Is.EqualTo(message.functionHash));
Assert.That(fresh.payload.Count, Is.EqualTo(message.payload.Count));
for (int i = 0; i < fresh.payload.Count; ++i)
{
Assert.That(fresh.payload.Array[fresh.payload.Offset + i],
Is.EqualTo(message.payload.Array[message.payload.Offset + i]));
}
}
public void TestUnpackMessageNonGeneric()
{
// try a regular message
SceneMessage message = new SceneMessage()
{
sceneName = "Hello world",
sceneOperation = SceneOperation.LoadAdditive
};
byte[] data = MessagePacker.Pack(message);
NetworkReader reader = new NetworkReader(data);
bool result = MessagePacker.UnpackMessage(reader, out int msgType);
Assert.That(result, Is.EqualTo(true));
Assert.That(msgType, Is.EqualTo(BitConverter.ToUInt16(data, 0)));
// try an invalid message
NetworkReader reader2 = new NetworkReader(new byte[0]);
bool result2 = MessagePacker.UnpackMessage(reader2, out int msgType2);
Assert.That(result2, Is.EqualTo(false));
Assert.That(msgType2, Is.EqualTo(0));
}
/// <summary>
/// Changes the owner of the object. Can only be called from the server or the owner of this Network Behaviour.
/// </summary>
/// <param name="targetClientID">The new owner clientId</param>
public void SetOwner(ulong targetClientID)
{
if (!networkManager.isRunning)
{
Debug.LogError("Cannot set ownership. The network is not running.");
return;
}
if (!isServer)
{
if (isOwner && targetClientID == networkManager.serverID)
{
RemoveOwnership();
return;
}
throw new NotServerException("Only the server can call NetworkBehaviour.SetOwner to target anything but the server.");
}
if (!isNetworkSpawned)
{
throw new NetworkException("Cannot change ownership. This Network Behaviour is not spawned.");
}
if (!IsNetworkVisibleTo(targetClientID))
{
throw new NetworkException("Cannot change ownership to a client that does not have visibility of this Network Behaviour.");
}
//Owner does not change
if (targetClientID == ownerID)
{
return;
}
if (targetClientID == networkManager.serverID)
{
RemoveOwnership();
return;
}
if (isOwner)
{
m_OwnerClientID = targetClientID;
OnLostOwnership();
}
else //This may seem redundant but we want ownership changes to be set before the OnLostOwnership call
{
m_OwnerClientID = targetClientID;
}
//Send to all (not pending)observers
using (PooledBitStream baseStream = PooledBitStream.Get())
{
DoOwnershipWrite(baseStream, targetClientID);
baseStream.PadStream();
using (BitStream stream = MessagePacker.WrapMessage(networkBehaviourManager.ownerChangeMessageType, 0, baseStream, SecuritySendFlags.None))
{
using (HashSet <ulong> .Enumerator observers = GetObservers())
{
while (observers.MoveNext())
{
if (observers.Current == NetworkManager.Get().serverID)
{
continue;
}
NetworkManager.Get().transport.Send(observers.Current, new ArraySegment <byte>(stream.GetBuffer(), 0, (int)stream.Length), networkManager.networkInternalChannel);
}
}
}
}
}
public void CommandMessageCallsCommandTest()
{
// listen
NetworkServer.Listen(1);
Assert.That(NetworkServer.connections.Count, Is.EqualTo(0));
// add connection
ULocalConnectionToClient connection = new ULocalConnectionToClient();
connection.connectionToServer = new ULocalConnectionToServer();
NetworkServer.AddConnection(connection);
// set as authenticated, otherwise removeplayer is rejected
connection.isAuthenticated = true;
// add an identity with two networkbehaviour components
GameObject go = new GameObject();
NetworkIdentity identity = go.AddComponent <NetworkIdentity>();
identity.netId = 42;
// for authority check
identity.connectionToClient = connection;
CommandTestNetworkBehaviour comp0 = go.AddComponent <CommandTestNetworkBehaviour>();
Assert.That(comp0.called, Is.EqualTo(0));
CommandTestNetworkBehaviour comp1 = go.AddComponent <CommandTestNetworkBehaviour>();
Assert.That(comp1.called, Is.EqualTo(0));
connection.identity = identity;
// register the command delegate, otherwise it's not found
NetworkBehaviour.RegisterCommandDelegate(typeof(CommandTestNetworkBehaviour), nameof(CommandTestNetworkBehaviour.CommandGenerated), CommandTestNetworkBehaviour.CommandGenerated);
// identity needs to be in spawned dict, otherwise command handler
// won't find it
NetworkIdentity.spawned[identity.netId] = identity;
// serialize a removeplayer message into an arraysegment
CommandMessage message = new CommandMessage
{
componentIndex = 0,
functionHash = NetworkBehaviour.GetMethodHash(typeof(CommandTestNetworkBehaviour), nameof(CommandTestNetworkBehaviour.CommandGenerated)),
netId = identity.netId,
payload = new ArraySegment <byte>(new byte[0])
};
NetworkWriter writer = new NetworkWriter();
MessagePacker.Pack(message, writer);
ArraySegment <byte> segment = writer.ToArraySegment();
// call transport.OnDataReceived with the message
// -> calls NetworkServer.OnRemovePlayerMessage
// -> destroys conn.identity and sets it to null
Transport.activeTransport.OnServerDataReceived.Invoke(0, segment, 0);
// was the command called in the first component, not in the second one?
Assert.That(comp0.called, Is.EqualTo(1));
Assert.That(comp1.called, Is.EqualTo(0));
// send another command for the second component
comp0.called = 0;
message.componentIndex = 1;
writer = new NetworkWriter();
MessagePacker.Pack(message, writer);
segment = writer.ToArraySegment();
Transport.activeTransport.OnServerDataReceived.Invoke(0, segment, 0);
// was the command called in the second component, not in the first one?
Assert.That(comp0.called, Is.EqualTo(0));
Assert.That(comp1.called, Is.EqualTo(1));
// sending a command without authority should fail
// (= if connectionToClient is not what we received the data on)
// set wrong authority
identity.connectionToClient = new ULocalConnectionToClient();
comp0.called = 0;
comp1.called = 0;
Transport.activeTransport.OnServerDataReceived.Invoke(0, segment, 0);
Assert.That(comp0.called, Is.EqualTo(0));
Assert.That(comp1.called, Is.EqualTo(0));
// restore authority
identity.connectionToClient = connection;
// sending a component with wrong netId should fail
// wrong netid
message.netId += 1;
writer = new NetworkWriter();
// need to serialize the message again with wrong netid
MessagePacker.Pack(message, writer);
ArraySegment <byte> segmentWrongNetId = writer.ToArraySegment();
comp0.called = 0;
comp1.called = 0;
Transport.activeTransport.OnServerDataReceived.Invoke(0, segmentWrongNetId, 0);
Assert.That(comp0.called, Is.EqualTo(0));
Assert.That(comp1.called, Is.EqualTo(0));
// clean up
NetworkBehaviour.ClearDelegates();
NetworkIdentity.spawned.Clear();
NetworkBehaviour.ClearDelegates();
NetworkServer.Shutdown();
// destroy the test gameobject AFTER server was stopped.
// otherwise isServer is true in OnDestroy, which means it would try
// to call Destroy(go). but we need to use DestroyImmediate in
// Editor
GameObject.DestroyImmediate(go);
}
void Send(long sid, MsgBase msg)
{
byte[] data = MessagePacker.Pack(msg);
server.Send(sid, data);
}
public void Initialize()
{
_packer = new MessagePacker("test");
}
public void Initialize()
{
_packer = new MessagePacker("test");
}
public void MessageHandlerReceivedMessageServerClient()
{
// Init
var gameObject = new GameObject(nameof(MessageHandlerReceivedMessageServerClient));
var networkManager = gameObject.AddComponent <NetworkManager>();
var transport = gameObject.AddComponent <DummyTransport>();
// MLAPI sets this in validate
networkManager.NetworkConfig = new NetworkConfig()
{
// Set the current scene to prevent unexpected log messages which would trigger a failure
RegisteredScenes = new List <string>()
{
SceneManager.GetActiveScene().name
}
};
// Set dummy transport that does nothing
networkManager.NetworkConfig.NetworkTransport = transport;
// Replace the real message handler with a dummy one that just prints a result
networkManager.MessageHandler = new DummyMessageHandler();
using (var inputBuffer = new NetworkBuffer())
{
// Start server since pre-message-handler passes IsServer & IsClient checks
networkManager.StartServer();
// Disable batching to make the RPCs come straight through
// This has to be done post start
networkManager.RpcQueueContainer.EnableBatchedRpcs(false);
// Should cause log (server only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleConnectionRequest));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.CONNECTION_REQUEST, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (client only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.CONNECTION_APPROVED, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (client only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.ADD_OBJECT, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (client only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.DESTROY_OBJECT, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (client only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.SWITCH_SCENE, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (client only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.CHANGE_OWNER, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (client only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.ADD_OBJECTS, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (client only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.DESTROY_OBJECTS, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (client only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.TIME_SYNC, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (server and client)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleNetworkVariableDelta));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.NETWORK_VARIABLE_DELTA, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (server and client)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleNetworkVariableUpdate));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.NETWORK_VARIABLE_UPDATE, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (server and client)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleUnnamedMessage));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.UNNAMED_MESSAGE, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (server and client)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleNamedMessage));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.NAMED_MESSAGE, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (server only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleClientSwitchSceneCompleted));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.CLIENT_SWITCH_SCENE_COMPLETED, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (server only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleNetworkLog));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.SERVER_LOG, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (server only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.RpcReceiveQueueItem));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.SERVER_RPC, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (client only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.CLIENT_RPC, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Stop server to trigger full shutdown
networkManager.StopServer();
// Replace the real message handler with a dummy one that just prints a result
networkManager.MessageHandler = new DummyMessageHandler();
// Start client since pre-message-handler passes IsServer & IsClient checks
networkManager.StartClient();
// Disable batching to make the RPCs come straight through
// This has to be done post start (and post restart since the queue container is reset)
networkManager.RpcQueueContainer.EnableBatchedRpcs(false);
// Should not cause log (server only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.CONNECTION_REQUEST, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (client only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleConnectionApproved));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.CONNECTION_APPROVED, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (client only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleAddObject));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.ADD_OBJECT, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (client only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleDestroyObject));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.DESTROY_OBJECT, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (client only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleSwitchScene));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.SWITCH_SCENE, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (client only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleChangeOwner));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.CHANGE_OWNER, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (client only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleAddObjects));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.ADD_OBJECTS, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (client only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleDestroyObjects));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.DESTROY_OBJECTS, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (client only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleTimeSync));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.TIME_SYNC, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (server and client)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleNetworkVariableDelta));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.NETWORK_VARIABLE_DELTA, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (server and client)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleNetworkVariableUpdate));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.NETWORK_VARIABLE_UPDATE, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (server and client)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleUnnamedMessage));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.UNNAMED_MESSAGE, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (server and client)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.HandleNamedMessage));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.NAMED_MESSAGE, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (server only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.CLIENT_SWITCH_SCENE_COMPLETED, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (server only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.SERVER_LOG, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should not cause log (server only)
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.SERVER_RPC, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Should cause log (client only)
LogAssert.Expect(LogType.Log, nameof(MessageHandlerReceivedMessageServerClient) + " " + nameof(DummyMessageHandler.RpcReceiveQueueItem));
using (var messageStream = MessagePacker.WrapMessage(NetworkConstants.CLIENT_RPC, inputBuffer))
{
networkManager.HandleIncomingData(0, NetworkChannel.Internal, new ArraySegment <byte>(messageStream.GetBuffer(), 0, (int)messageStream.Length), 0, true);
}
// Full cleanup
networkManager.StopClient();
}
// Ensure no missmatches with expectations
LogAssert.NoUnexpectedReceived();
// Cleanup
Object.DestroyImmediate(gameObject);
}
public void RegisterUnregisterClearHandlerTest()
{
// message handlers that are needed for the test
NetworkServer.RegisterHandler <ConnectMessage>((conn, msg) => { }, false);
NetworkServer.RegisterHandler <DisconnectMessage>((conn, msg) => { }, false);
NetworkServer.RegisterHandler <ErrorMessage>((conn, msg) => { }, false);
// RegisterHandler(conn, msg) variant
int variant1Called = 0;
NetworkServer.RegisterHandler <TestMessage>((conn, msg) => { ++variant1Called; }, false);
// RegisterHandler(msg) variant
int variant2Called = 0;
NetworkServer.RegisterHandler <WovenTestMessage>(msg => { ++variant2Called; }, false);
// listen
NetworkServer.Listen(1);
Assert.That(NetworkServer.connections.Count, Is.EqualTo(0));
// add a connection
NetworkConnectionToClient connection = new NetworkConnectionToClient(42);
NetworkServer.AddConnection(connection);
Assert.That(NetworkServer.connections.Count, Is.EqualTo(1));
// serialize first message, send it to server, check if it was handled
NetworkWriter writer = new NetworkWriter();
MessagePacker.Pack(new TestMessage(), writer);
Transport.activeTransport.OnServerDataReceived.Invoke(42, writer.ToArraySegment(), 0);
Assert.That(variant1Called, Is.EqualTo(1));
// serialize second message, send it to server, check if it was handled
writer = new NetworkWriter();
MessagePacker.Pack(new WovenTestMessage(), writer);
Transport.activeTransport.OnServerDataReceived.Invoke(42, writer.ToArraySegment(), 0);
Assert.That(variant2Called, Is.EqualTo(1));
// unregister first handler, send, should fail
NetworkServer.UnregisterHandler <TestMessage>();
writer = new NetworkWriter();
MessagePacker.Pack(new TestMessage(), writer);
// log error messages are expected
LogAssert.ignoreFailingMessages = true;
Transport.activeTransport.OnServerDataReceived.Invoke(42, writer.ToArraySegment(), 0);
LogAssert.ignoreFailingMessages = false;
// still 1, not 2
Assert.That(variant1Called, Is.EqualTo(1));
// unregister second handler via ClearHandlers to test that one too. send, should fail
NetworkServer.ClearHandlers();
// (only add this one to avoid disconnect error)
NetworkServer.RegisterHandler <DisconnectMessage>((conn, msg) => { }, false);
writer = new NetworkWriter();
MessagePacker.Pack(new TestMessage(), writer);
// log error messages are expected
LogAssert.ignoreFailingMessages = true;
Transport.activeTransport.OnServerDataReceived.Invoke(42, writer.ToArraySegment(), 0);
LogAssert.ignoreFailingMessages = false;
// still 1, not 2
Assert.That(variant2Called, Is.EqualTo(1));
// clean up
NetworkServer.Shutdown();
}
public TcpClient()
{
packetPool = new PacketPool();
messagePacker = new MessagePacker();
isConnected = 0;
}
