public void GivenIHaveARunningServer(string serverConfig, string clusterConfig)
{
NameValueCollection parameters = new NameValueCollection {
{ "port", GetFreePort().ToString() }
};
DarkRiftServerConfigurationBuilder serverConfigurationBuilder = DarkRiftServerConfigurationBuilder.CreateFromXml("Configurations/Server/" + serverConfig, parameters);
#if PRO
serverConfigurationBuilder.AddPluginType(typeof(InMemoryServerRegistryConnector));
DarkRiftServer server = new DarkRiftServer(
serverConfigurationBuilder.ServerSpawnData,
ClusterSpawnData.CreateFromXml("Configurations/Cluster/" + clusterConfig, new NameValueCollection())
);
#else
DarkRiftServer server = new DarkRiftServer(
serverConfigurationBuilder.ServerSpawnData
);
#endif
server.StartServer();
world.AddServer(server);
#if DEBUG
// We've just requested a load of objects that wont be returned until we close
// UDP receive TCP accept
performanceSteps.ExpectedUnaccountedForSocketAsyncEventArgs += 2;
#endif
}
/// <summary>
/// Start a server with our listener and a basic configuration.
/// </summary>
/// <returns>The created server.</returns>
private DarkRiftServer StartServer()
{
ServerSpawnData serverSpawnData = new ServerSpawnData();
// Add listener type
serverSpawnData.PluginSearch.PluginTypes.Add(typeof(NetworkListener1));
// Create listener config
serverSpawnData.Listeners.NetworkListeners.Add(new ServerSpawnData.ListenersSettings.NetworkListenerSettings
{
Name = "ListenerUnderTest",
Type = nameof(NetworkListener1),
Address = IPAddress.Loopback,
Port = GetFreePort()
});
// Add a logger
serverSpawnData.Logging.LogWriters.Add(new ServerSpawnData.LoggingSettings.LogWriterSettings {
Name = "ConsoleWriter",
Type = "ConsoleWriter",
LogLevels = new LogType[] { LogType.Trace, LogType.Info, LogType.Warning, LogType.Error, LogType.Fatal }
});
serverSpawnData.Logging.LogWriters[0].Settings.Add("useFastAnsiColoring", "false");
DarkRiftServer server = new DarkRiftServer(serverSpawnData);
server.Start();
return(server);
}
/// <summary>
/// Creates the server.
/// </summary>
public void Create(NameValueCollection variables)
{
if (Server != null)
throw new InvalidOperationException("The server has already been created! (Is CreateOnEnable enabled?)");
if (configuration != null)
{
//Create spawn data from config
ServerSpawnData spawnData = ServerSpawnData.CreateFromXml(XDocument.Parse(configuration.text), variables);
//Inaccessible from xml, set from inspector
spawnData.EventsFromDispatcher = eventsFromDispatcher;
//Unity is broken, work around it...
//This is an obsolete property but is still used if the user is using obsolete <server> tag properties
#pragma warning disable 0618
spawnData.Server.UseFallbackNetworking = true;
#pragma warning restore 0618
//Add types
spawnData.PluginSearch.PluginTypes.AddRange(UnityServerHelper.SearchForPlugins());
spawnData.PluginSearch.PluginTypes.Add(typeof(UnityConsoleWriter));
//Create server
Server = new DarkRiftServer(spawnData);
Server.Start();
enetListener = Server.NetworkListenerManager.GetNetworkListenersByType<EnetListenerPlugin>().First();
}
else
Debug.LogError("No configuration file specified!");
}
void Start()
{
xmlServer = GetComponent <XmlUnityServer>();
server = xmlServer.Server;
server.ClientManager.ClientConnected += OnClientConnected;
server.ClientManager.ClientDisconnected += OnClientDisconnected;
}
/// <summary>
/// Creates the server.
/// </summary>
public void Create(NameValueCollection variables)
{
if (Server != null)
{
throw new InvalidOperationException("The server has already been created! (Is CreateOnEnable enabled?)");
}
if (configuration != null)
{
//Create spawn data from config
ServerSpawnData spawnData = ServerSpawnData.CreateFromXml(XDocument.Parse(configuration.text), variables);
//Inaccessible from xml, set from inspector
spawnData.EventsFromDispatcher = eventsFromDispatcher;
//Unity is broken, work around it...
spawnData.Server.UseFallbackNetworking = true;
//Add types
spawnData.PluginSearch.PluginTypes.AddRange(UnityServerHelper.SearchForPlugins());
spawnData.PluginSearch.PluginTypes.Add(typeof(UnityConsoleWriter));
//Create server
Server = new DarkRiftServer(spawnData);
Server.Start();
}
else
{
Debug.LogError("No configuration file specified!");
}
}
public Connector()
{
InstallSubdirectory(
new Dictionary <string, byte[]>
{
{ "settings.cnf", System.Text.Encoding.ASCII.GetBytes("ConnectionString:\t\tSERVER=localhost;DATABASE=DarkRift;USERNAME=username;PASSWORD=password") }
}
);
try
{
ConfigReader reader = new ConfigReader(GetSubdirectory() + @"\settings.cnf");
if (reader["ConnectionString"] == null)
{
Interface.LogFatal("ConnectionString was not defined in the MySQLConnector's settings.cnf file!");
DarkRiftServer.Close(true);
}
connectionString = reader["ConnectionString"];
}
catch (System.IO.FileNotFoundException)
{
Interface.LogFatal("MySQLConnector's settings file is missing!");
DarkRiftServer.Close(true);
}
}
void Awake()
{
//Start the server in embedded mode so with given parameters. The Debug functions pointers redirect Interface
//messages to Unity, the this will tell the server not the use the thread pool to dispatch events but instead
//let this script sort it out.
DarkRiftServer.Bootstrap(Mode.Embedded, port, maxConnections, logData, Debug.Log, Debug.LogWarning, Debug.LogError, Debug.LogError, this, forceLoadPlugins);
}
private void Shutdown()
{
if (this.server != null)
{
this.server.Dispose();
this.server = null;
}
}
public void FindConnections(string [] parts)
{
ConnectionService[] allCons = DarkRiftServer.GetAllConnections();
Interface.Log("Amount of connected connections are " + allCons.Length);
for (int i = 0; i < allCons.Length; i++)
{
Interface.Log("The connection id is " + allCons[i].id);
}
}
public void ClearConnections(string [] parts)
{
ConnectionService[] allCons = DarkRiftServer.GetAllConnections();
Interface.Log("Amount of connected connections are " + allCons.Length);
for (int i = 0; i < allCons.Length; i++)
{
allCons[i].SendNetworkMessage(new NetworkMessage(0, DistributionType.Reply, 0, 255, 0, 0));
allCons[i].Close();
}
}
void IServerTransportLayer.Start(int port)
{
if (this.server != null)
{
this.Shutdown();
}
this.server = new DarkRiftServer(new ServerSpawnData(IPAddress.Parse("127.0.0.1"), 9999, DarkRift.IPVersion.IPv4));
this.server.Start();
}
void OnDestroy()
{
DarkRiftServer server = Server.Server;
if (server != null)
{
server.ClientManager.ClientConnected -= OnClientConnect;
server.ClientManager.ClientDisconnected -= OnClientDisconnect;
}
}
void OnApplicationQuit()
{
//Because Unity stops calling Update/FixedUpdate/LateUpdate before OnApplicationQuit the wait handles
//required will cause DarkRift to wait forever and crash Unity, therefore if we're closing we just need
//to execute stuff as it comes to us.
closing = true;
//Close the server when we close unity!
DarkRiftServer.Close(false);
}
/// <summary>
/// Connect a client with our client connection to the given server.
/// </summary>
/// <returns>The created client.</returns>
private DarkRiftClient ConnectClient(DarkRiftServer server)
{
NetworkClientConnection1 connection = new NetworkClientConnection1(IPAddress.Loopback, server.NetworkListenerManager.GetNetworkListenerByName("ListenerUnderTest").Port);
DarkRiftClient client = new DarkRiftClient();
client.Connect(connection);
return(client);
}
void Update()
{
//Broadcast all positions to all clients constantly
foreach (ConnectionService cs in DarkRiftServer.GetAllConnections())
{
for (int i = 0; i < cubes.Length; i++)
{
cs.SendReply(0, (ushort)i, (Vector3Carrier)cubes[i].position);
}
}
}
private void Awake()
{
if (Instance != null)
{
Destroy(gameObject);
return;
}
Instance = this;
XmlServer.Create();
Server = XmlServer.Server;
DontDestroyOnLoad(this);
}
/// <summary>
/// Closes the server.
/// </summary>
public void Close()
{
if (Server != null)
{
Server.Dispose();
}
else
{
return;
}
Server = null;
}
private void OnRoomCreated(object sender, RoomModel e)
{
if (e == null)
{
return;
}
foreach (var player in e.Players)
{
var connection = DarkRiftServer
.GetConnectionServiceByID((ushort)player.PlayerID);
//do stuff here -> connection.SendReply()
}
}
public void TestClientCanConnectToServer()
{
// GIVEN a running server
DarkRiftServer server = StartServer();
// WHEN I connect a client
DarkRiftClient client = ConnectClient(server);
// THEN the client is connected
Assert.AreEqual(ConnectionState.Connected, client.ConnectionState);
// AND the server contains one client
Assert.AreEqual(1, server.ClientManager.Count);
}
public void TestServerCanJoin()
{
// GIVEN a server running in group 1
DarkRiftServer server1 = StartServer("Group1", true);
// WHEN a second server starts
DarkRiftServer server2 = StartServer("Group2", true);
// THEN the first server discovers the second server
WaitUntil("Timed out waiting for server 1 to discover server 2.", () => Assert.AreEqual(1, server1.RemoteServerManager.GetGroup("Group2").Count), TimeSpan.FromSeconds(30));
// AND the second server discovers the first server
WaitUntil("Timed out waiting for server 2 to discover server 1.", () => Assert.AreEqual(1, server2.RemoteServerManager.GetGroup("Group1").Count), TimeSpan.FromSeconds(30));
}
/// <summary>
/// Creates the server.
/// </summary>
public void Create(NameValueCollection variables)
{
if (Server != null)
{
if (Server.Disposed)
{
Server.StartServer();
}
else
{
throw new InvalidOperationException("The server has already been created! (Is CreateOnEnable enabled?)");
}
}
if (configuration != null)
{
// Create spawn data from config
ServerSpawnData spawnData = ServerSpawnData.CreateFromXml(XDocument.Parse(configuration.text), variables);
if (spawnData == null)
{
throw new Exception("SpawnData not defined");
}
// Allow only this thread to execute dispatcher tasks to enable deadlock protection
spawnData.DispatcherExecutorThreadID = Thread.CurrentThread.ManagedThreadId;
// Inaccessible from XML, set from inspector
spawnData.EventsFromDispatcher = eventsFromDispatcher;
// Unity is broken, work around it...
// This is an obsolete property but is still used if the user is using obsolete <server> tag properties
#pragma warning disable 0618
spawnData.Server.UseFallbackNetworking = true;
#pragma warning restore 0618
// Add types
spawnData.PluginSearch.PluginTypes.AddRange(UnityServerHelper.SearchForPlugins());
spawnData.Listeners.NetworkListeners[0].Port = port;
// Create server
Server = new DarkRiftServer(spawnData);
Server.StartServer();
}
else
{
throw new Exception("Configuration file not set");
}
}
public void Init(DarkRiftServer server)
{
this.server = server;
this.turrets = new ServerTurretController[turretSpawns.Length];
for (var i = 0; i < turrets.Length; ++i)
{
turrets[i] = Instantiate(
turretPrefab,
turretSpawns[i].position,
turretSpawns[i].rotation);
turrets[i].Manager = this;
turrets[i].Server = this.server;
}
}
private void BroadcastToRoom(NetworkMessage data)
{
RoomModel room = null;
if (RoomsManager.TryGetPlayerRoom(data.senderID, out room))
{
foreach (var player in room.Players)
{
var connection = DarkRiftServer
.GetConnectionServiceByID((ushort)player.PlayerID);
connection.SendReply((byte)data.subject, 0, data.data);
}
}
}
public bool StartServer(int port, int maxConnections)
{
if (IsServerStarted)
{
return(false);
}
ServerMaxConnections = maxConnections;
serverPeers.Clear();
serverEventQueue.Clear();
Server = new DarkRiftServer(new ServerSpawnData(IPAddress.Any, (ushort)port, IPVersion.IPv4));
Server.ClientManager.ClientConnected += Server_ClientManager_ClientConnected;
Server.ClientManager.ClientDisconnected += Server_ClientManager_ClientDisconnected;
Server.Start();
return(true);
}
public void Create()
{
if (Server != null)
{
throw new InvalidOperationException("The server has already been created! (Is CreateOnEnable enabled?)");
}
var spawnData = new ServerSpawnData(Address, Port, IpVersion);
//Data settings
spawnData.Data.Settings["directory"] = DataDirectory;
//Logging settings
spawnData.Plugins.PluginTypes.Add(typeof(UnityConsoleWriter));
var fileWriter = new ServerSpawnData.LoggingSettings.LogWriterSettings
{
Name = "FileWriter1",
Type = "FileWriter",
LogLevels = new[] { LogType.Trace, LogType.Info, LogType.Warning, LogType.Error, LogType.Fatal }
};
fileWriter.Settings["file"] = LogFileString;
var consoleWriter = new ServerSpawnData.LoggingSettings.LogWriterSettings
{
Name = "UnityConsoleWriter1",
Type = "UnityConsoleWriter",
LogLevels = new[] { LogType.Info, LogType.Warning, LogType.Error, LogType.Fatal }
};
var debugWriter = new ServerSpawnData.LoggingSettings.LogWriterSettings
{
Name = "DebugWriter1",
Type = "DebugWriter",
LogLevels = new[] { LogType.Warning, LogType.Error, LogType.Fatal }
};
spawnData.Logging.LogWriters.Add(fileWriter);
spawnData.Logging.LogWriters.Add(consoleWriter);
spawnData.Logging.LogWriters.Add(debugWriter);
// Plugins
// spawnData.Plugins.PluginTypes.Add(typeof(DbConnector));
Server = new DarkRiftServer(spawnData);
Server.Start();
}
public void TestServerCanTimeout()
{
// GIVEN a server running in group 1 without a health check
DarkRiftServer server1 = StartServer("Group1", false);
// AND a server running in group 2
DarkRiftServer server2 = StartServer("Group2", true);
// AND the servers know of each other
WaitUntil("Timed out waiting for server 1 to discover server 2.", () => Assert.AreEqual(1, server1.RemoteServerManager.GetGroup("Group2").Count), TimeSpan.FromSeconds(30));
WaitUntil("Timed out waiting for server 2 to discover server 1.", () => Assert.AreEqual(1, server2.RemoteServerManager.GetGroup("Group1").Count), TimeSpan.FromSeconds(30));
// WHEN waiting (a long time)
// THEN the second server sees server 1 timeout
WaitUntil("Timed out waiting for server 2 to see server 1 left.", () => Assert.AreEqual(1, server2.RemoteServerManager.GetGroup("Group1").Count), TimeSpan.FromMinutes(2));
}
public void TestServerCanLeave()
{
// GIVEN a server running in group 1 and another in group 2
DarkRiftServer server1 = StartServer("Group1", true);
DarkRiftServer server2 = StartServer("Group2", true);
// AND the servers know of each other
WaitUntil("Timed out waiting for server 1 to discover server 2.", () => Assert.AreEqual(1, server1.RemoteServerManager.GetGroup("Group2").Count), TimeSpan.FromSeconds(30));
WaitUntil("Timed out waiting for server 2 to discover server 1.", () => Assert.AreEqual(1, server2.RemoteServerManager.GetGroup("Group1").Count), TimeSpan.FromSeconds(30));
// WHEN the first server closes
server1.Dispose();
// THEN the second server knows of the closure
WaitUntil("Timed out waiting for server 2 to see server 1 left.", () => Assert.AreEqual(1, server2.RemoteServerManager.GetGroup("Group1").Count), TimeSpan.FromSeconds(30));
}
public void GivenIHaveARunningServer(string serverConfig)
{
NameValueCollection parameters = new NameValueCollection {
{ "port", GetFreePort().ToString() }
};
DarkRiftServer server = new DarkRiftServer(ServerSpawnData.CreateFromXml("Configurations/Server/" + serverConfig, parameters));
server.StartServer();
world.AddServer(server);
#if DEBUG
// We've just requested a load of objects that wont be returned until we close
// UDP receive TCP accept
performanceSteps.ExpectedUnaccountedForSocketAsyncEventArgs += 2;
#endif
}
/// <summary>
/// Adds a new server to the world.
/// </summary>
/// <param name="server">The serverto add.</param>
public void AddServer(DarkRiftServer server)
{
#if PRO
servers.Add(server.RemoteServerManager.ServerID, server);
server.ClientManager.ClientConnected += (s, a) => ClientConnected(s, a, server.RemoteServerManager.ServerID);
foreach (IServerGroup group in server.RemoteServerManager.GetAllGroups())
{
group.ServerJoined += (s, a) => ServerJoinedGroup(s, a, server.RemoteServerManager.ServerID);
group.ServerLeft += (s, a) => ServerLeftGroup(s, a, server.RemoteServerManager.ServerID);
}
#else
servers.Add(0, server);
server.ClientManager.ClientConnected += (s, a) => ClientConnected(s, a, 0);
#endif
}
public void GivenTheServerIsUsingTheDispatcher(ushort serverID)
{
world.GetServer(serverID).ThreadHelper.EventsFromDispatcher = true;
// Create a snapshot view of the server so we have a consistent reference to it between tests
DarkRiftServer server = world.GetServer(serverID);
dispatcherThread = new Thread(() =>
{
while (!server.Disposed)
{
server.DispatcherWaitHandle.WaitOne();
server.ExecuteDispatcherTasks();
}
});
dispatcherThread.Start();
}
