/// <summary>
/// Loads the plugins found by the plugin factory.
/// </summary>
/// <param name="settings">The settings to load plugins with.</param>
internal void LoadPlugins(ServerSpawnData.PluginsSettings settings)
{
Type[] types = pluginFactory.GetAllSubtypes(typeof(Plugin));
foreach (Type type in types)
{
var s = settings.Plugins.FirstOrDefault(p => p.Type == type.Name);
PluginLoadData loadData = new PluginLoadData(
type.Name,
server,
s?.Settings ?? new NameValueCollection(),
logManager.GetLoggerFor(type.Name),
#if PRO
metricsManager.GetMetricsCollectorFor(type.Name),
#endif
dataManager.GetResourceDirectory(type.Name)
);
if (s?.Load ?? settings.LoadByDefault)
{
LoadPlugin(type.Name, type, loadData, null, true);
}
}
}
/// <summary>
/// Creates a type as a specified plugin.
/// </summary>
/// <typeparam name="T">The type of plugin to load it as.</typeparam>
/// <param name="type">The type to load.</param>
/// <param name="loadData">The data to load into the plugin.</param>
/// <param name="backupLoadData">The backup load data to try for backwards compatability.</param>
/// <returns>The new plugin.</returns>
internal T Create<T>(Type type, PluginBaseLoadData loadData, PluginLoadData backupLoadData = null) where T : PluginBase
{
//Create an instance of the plugin
T plugin;
try
{
plugin = (T)Activator.CreateInstance(type, loadData);
}
catch (MissingMethodException)
{
//Failed, perhaps using backup PluginLoadData would help?
if (backupLoadData != null)
{
plugin = (T)Activator.CreateInstance(type, backupLoadData);
logger.Warning($"Plugin {type.Name} was loaded using a PluginLoadData object instead of the desired {loadData.GetType().Name}. Consider replacing the constructor with one accepting a " + loadData.GetType().Name + " object instead.");
}
else
{
throw;
}
}
//Log creation
if (!plugin.Hidden)
logger.Trace($"Created plugin '{type.Name}'.");
return plugin;
}
/// <summary>
/// Creates a named type as a specified plugin.
/// </summary>
/// <typeparam name="T">The type of plugin to load it as.</typeparam>
/// <param name="type">The name of the type to load.</param>
/// <param name="loadData">The data to load into the plugin.</param>
/// <param name="backupLoadData">The backup load data to try for backwards compatablity.</param>
/// <returns>The new plugin.</returns>
internal T Create<T>(string type, PluginBaseLoadData loadData, PluginLoadData backupLoadData = null) where T : PluginBase
{
try
{
return Create<T>(types[type], loadData, backupLoadData);
}
catch (KeyNotFoundException e)
{
throw new KeyNotFoundException($"No plugin of type {type} is available to load. Check the plugin is in the plugin search paths, you can see the plugins that are found by setting startup log levels to show trace level logs.", e);
}
}
/// <summary>
/// Creates a new plugin using the given plugin load data.
/// </summary>
/// <param name="pluginLoadData">The plugin load data for this plugin.</param>
public Plugin(PluginLoadData pluginLoadData)
: base(pluginLoadData)
{
ClientManager = pluginLoadData.ClientManager;
PluginManager = pluginLoadData.PluginManager;
NetworkListenerManager = pluginLoadData.NetworkListenerManager;
#if PRO
ServerRegistryConnectorManager = pluginLoadData.ServerRegistryConnectorManager;
RemoteServerManager = pluginLoadData.RemoteServerManager;
#endif
ResourceDirectory = pluginLoadData.ResourceDirectory;
}
public LogWriter(PluginLoadData pluginLoadData)
: base(pluginLoadData)
{
}
/// <summary>
/// Load the plugin given.
/// </summary>
/// <param name="name">The name of the plugin instance.</param>
/// <param name="type">The plugin type to load.</param>
/// <param name="pluginLoadData">The data for this plugin.</param>
/// <param name="backupLoadData">The data for this plugin if the first fails.</param>
/// <param name="createResourceDirectory">Whether to create a resource directory or not.</param>
protected virtual T LoadPlugin(string name, string type, PluginBaseLoadData pluginLoadData, PluginLoadData backupLoadData, bool createResourceDirectory)
{
//Ensure the resource directory is present
if (createResourceDirectory)
{
dataManager.CreateResourceDirectory(type);
}
T plugin = pluginFactory.Create <T>(type, pluginLoadData);
plugins.Add(name, plugin);
return(plugin);
}
/// <summary>
/// Load the plugin given.
/// </summary>
/// <param name="name">The name of the plugin instance.</param>
/// <param name="type">The plugin type to load.</param>
/// <param name="pluginLoadData">The data for this plugin.</param>
/// <param name="backupLoadData">The data for this plugin if the first fails.</param>
/// <param name="createResourceDirectory">Whether to create a resource directory or not.</param>
protected override T LoadPlugin(string name, string type, PluginBaseLoadData pluginLoadData, PluginLoadData backupLoadData, bool createResourceDirectory)
{
T plugin = base.LoadPlugin(name, type, pluginLoadData, backupLoadData, createResourceDirectory);
HandleThreadSafe(plugin);
HandleInstallUpgrade(plugin);
return(plugin);
}
/// <summary>
/// Loads the writers found by the plugin factory.
/// </summary>
/// <param name="settings">The settings to load writers from.</param>
/// <param name="pluginFactory">The server's plugin factory.</param>
internal void LoadWriters(ServerSpawnData.LoggingSettings settings, PluginFactory pluginFactory)
{
if (logWriters != null)
{
throw new InvalidOperationException("Cannot load writers if writers are already present. This suggests that writers have already been loaded into the server.\n\nThis is likely an internal DR issue, please consider creating an issue here: https://github.com/DarkRiftNetworking/DarkRift/issues");
}
List <LogWriter> traceWriters = new List <LogWriter>();
List <LogWriter> infoWriters = new List <LogWriter>();
List <LogWriter> warningWriters = new List <LogWriter>();
List <LogWriter> errorWriters = new List <LogWriter>();
List <LogWriter> fatalWriters = new List <LogWriter>();
logWriters = new LogWriter[settings.LogWriters.Count];
for (int i = 0; i < settings.LogWriters.Count; i++)
{
ServerSpawnData.LoggingSettings.LogWriterSettings s = settings.LogWriters[i];
//Create a load data object and backup
LogWriterLoadData loadData = new LogWriterLoadData(s.Name, server, s.Settings, GetLoggerFor(nameof(s.Name)));
PluginLoadData backupLoadData = new PluginLoadData(s.Name, server, s.Settings, GetLoggerFor(nameof(s.Name)),
#if PRO
null,
#endif
null);
LogWriter writer = pluginFactory.Create <LogWriter>(s.Type, loadData, backupLoadData);
logWriters[i] = writer;
if (s.LogLevels.Contains(LogType.Trace))
{
traceWriters.Add(writer);
}
if (s.LogLevels.Contains(LogType.Info))
{
infoWriters.Add(writer);
}
if (s.LogLevels.Contains(LogType.Warning))
{
warningWriters.Add(writer);
}
if (s.LogLevels.Contains(LogType.Error))
{
errorWriters.Add(writer);
}
if (s.LogLevels.Contains(LogType.Fatal))
{
fatalWriters.Add(writer);
}
}
writerMatrix = new LogWriter[][]
{
traceWriters.ToArray(),
infoWriters.ToArray(),
warningWriters.ToArray(),
errorWriters.ToArray(),
fatalWriters.ToArray()
};
}
