/// <summary>
/// Load all plugins in assemblies at the given path
/// </summary>
/// <param name="assembliesPath"></param>
public void LoadPluginsFromAssemblies(string assembliesPath)
{
List <IPhysicsPlugin> physicsPlugins =
UniverseModuleLoader.LoadModules <IPhysicsPlugin>(assembliesPath);
List <IMeshingPlugin> meshingPlugins =
UniverseModuleLoader.LoadModules <IMeshingPlugin>(assembliesPath);
meshingPlugins.AddRange(UniverseModuleLoader.LoadModules <IMeshingPlugin>(""));
foreach (IPhysicsPlugin plug in physicsPlugins)
{
try
{
_PhysPlugins.Add(plug.GetName(), plug);
}
catch
{
}
}
foreach (IMeshingPlugin plug in meshingPlugins)
{
try
{
_MeshPlugins.Add(plug.GetName(), plug);
}
catch
{
}
}
}
public void LoadLibraries()
{
if (!m_enabled)
{
return;
}
else if (!File.Exists("DefaultInventory/Inventory.ini") &&
!File.Exists("DefaultInventory/Inventory.ini.example"))
{
MainConsole.Instance.Error(
"Could not find DefaultInventory/Inventory.ini or DefaultInventory/Inventory.ini.example");
return;
}
List <IDefaultLibraryLoader> Loaders = UniverseModuleLoader.PickupModules <IDefaultLibraryLoader>();
try
{
if (!File.Exists("DefaultInventory/Inventory.ini"))
{
File.Copy("DefaultInventory/Inventory.ini.example", "DefaultInventory/Inventory.ini");
}
IniConfigSource iniSource = new IniConfigSource("DefaultInventory/Inventory.ini",
IniFileType.AuroraStyle);
if (iniSource != null)
{
foreach (IDefaultLibraryLoader loader in Loaders)
{
loader.LoadLibrary(this, iniSource, m_registry);
}
}
}
catch
{
}
}
private void SetUpConsole(IConfigSource config, IRegistryCore registry)
{
List <ICommandConsole> Plugins = UniverseModuleLoader.PickupModules <ICommandConsole>();
foreach (ICommandConsole plugin in Plugins)
{
plugin.Initialize(config, registry.RequestModuleInterface <ISimulationBase>());
}
if (MainConsole.Instance == null)
{
Console.WriteLine("[Console]: No Console located");
return;
}
MainConsole.Instance.Threshold = Level.Info;
MainConsole.Instance.Fatal(String.Format("[Console]: Console log level is {0}",
MainConsole.Instance.Threshold));
MainConsole.Instance.Commands.AddCommand("set log level",
"set log level [level]",
"Set the console logging level",
HandleLogLevel, false, true);
MainConsole.Instance.Commands.AddCommand("get log level",
"get log level",
"Returns the current console logging level",
HandleGetLogLevel, false, true);
}
void SetUpConsole(IConfigSource config, ISimulationBase simbase)
{
List <ICommandConsole> Plugins = UniverseModuleLoader.PickupModules <ICommandConsole> ();
foreach (ICommandConsole plugin in Plugins)
{
plugin.Initialize(config, simbase);
}
if (MainConsole.Instance == null)
{
Console.WriteLine("[Console]: No Console configured, falling back to 'LocalConsole'");
new LocalConsole().LocalInitialize(config, simbase);
}
MainConsole.Instance.Threshold = Level.Info;
MainConsole.Instance.Fatal(string.Format("[Console]: Console log level is {0}", MainConsole.Instance.Threshold));
MainConsole.Instance.Commands.AddCommand(
"set log level",
"set log level [level]",
"Set the console logging level",
HandleLogLevel, false, true);
MainConsole.Instance.Commands.AddCommand(
"get log level",
"get log level",
"Returns the current console logging level",
HandleGetLogLevel, false, true);
}
private void SetupCompilers()
{
converters = UniverseModuleLoader.PickupModules <IScriptConverter>();
foreach (IScriptConverter convert in converters)
{
convert.Initialise(this);
}
}
void FindChatPlugins()
{
AllChatPlugins = UniverseModuleLoader.PickupModules <IChatPlugin> ();
foreach (IChatPlugin plugin in AllChatPlugins)
{
plugin.Initialize(this);
}
}
public List <ICapsServiceConnector> GetServiceConnectors()
{
if (m_connectors.Count == 0)
{
m_connectors = UniverseModuleLoader.PickupModules <ICapsServiceConnector>();
}
return(m_connectors);
}
public virtual void InitializeModules()
{
m_applicationPlugins = UniverseModuleLoader.PickupModules <IApplicationPlugin>();
foreach (IApplicationPlugin plugin in m_applicationPlugins)
{
plugin.PreStartup(this);
}
}
public MigrationManager(IDataConnector genericData, string migratorName, bool validateTables)
{
this.genericData = genericData;
this.migratorName = migratorName;
this.validateTables = validateTables;
List <IMigrator> allMigrators = UniverseModuleLoader.PickupModules <IMigrator>();
foreach (
IMigrator m in
allMigrators.Where(m => m.MigrationName != null).Where(m => m.MigrationName == migratorName))
{
migrators.Add((Migrator)m);
}
}
public void Initialise(IConfigSource source, IRegistryCore simBase, List <Type> types)
{
IConfig m_config = source.Configs["UniverseData"];
if (m_config != null)
{
StorageProvider = m_config.GetString("StorageProvider", StorageProvider);
ConnectionString = m_config.GetString("ConnectionString", ConnectionString);
}
IGenericData DataConnector = null;
if (StorageProvider == "MySQL")
//Allow for fallback when UniverseData isn't set
{
MySQLDataLoader GenericData = new MySQLDataLoader();
DataConnector = GenericData;
}
else if (StorageProvider == "SQLite")
//Allow for fallback when UniverseData isn't set
{
SQLiteLoader GenericData = new SQLiteLoader();
DataConnector = GenericData;
}
foreach (Type t in types)
{
List <dynamic> Plugins = UniverseModuleLoader.PickupModules(t);
foreach (dynamic plugin in Plugins)
{
try
{
plugin.Initialize(DataConnector.Copy(), source, simBase, ConnectionString);
}
catch (Exception ex)
{
if (MainConsole.Instance != null)
{
MainConsole.Instance.Warn("[DataService]: Exception occurred starting data plugin " +
plugin.Name + ", " + ex.ToString());
}
}
}
}
}
/// <summary>
/// Create a scene and its initial base structures.
/// </summary>
/// <param name="regionInfo"></param>
/// <param name="configSource"></param>
/// <returns></returns>
public IScene CreateScene(ISimulationDataStore dataStore, RegionInfo regionInfo)
{
AgentCircuitManager circuitManager = new AgentCircuitManager();
List <IClientNetworkServer> clientServers = UniverseModuleLoader.PickupModules <IClientNetworkServer>();
List <IClientNetworkServer> allClientServers = new List <IClientNetworkServer>();
foreach (IClientNetworkServer clientServer in clientServers)
{
clientServer.Initialize((uint)regionInfo.RegionPort, m_configSource, circuitManager);
allClientServers.Add(clientServer);
}
AsyncScene scene = new AsyncScene();
scene.AddModuleInterfaces(m_simBase.ApplicationRegistry.GetInterfaces());
scene.Initialize(regionInfo, dataStore, circuitManager, allClientServers);
return(scene);
}
public void Start()
{
IConfig handlerConfig = m_simBase.ConfigSource.Configs["ApplicationPlugins"];
if (handlerConfig.GetString("ServicesLoader", "") != Name)
{
return;
}
List <IService> serviceConnectors = UniverseModuleLoader.PickupModules <IService>();
foreach (IService connector in serviceConnectors)
{
try
{
connector.Initialize(m_simBase.ConfigSource, m_simBase.ApplicationRegistry);
}
catch
{
}
}
foreach (IService connector in serviceConnectors)
{
try
{
connector.Start(m_simBase.ConfigSource, m_simBase.ApplicationRegistry);
}
catch
{
}
}
foreach (IService connector in serviceConnectors)
{
try
{
connector.FinishedStartup();
}
catch
{
}
}
}
public virtual void InitializeModules()
{
LocalDataService lds = new LocalDataService();
lds.Initialize(ConfigSource, ApplicationRegistry, m_dataPlugins);
List <dynamic> modules = new List <dynamic>();
foreach (Type t in m_servicePlugins)
{
var mods = UniverseModuleLoader.PickupModules(t);
modules.AddRange(mods);
}
foreach (dynamic service in modules)
{
if (!(service is IService))
{
continue;
}
((IService)service).Initialize(ConfigSource, ApplicationRegistry);
}
foreach (dynamic service in modules)
{
if (!(service is IService))
{
continue;
}
((IService)service).Start(ConfigSource, ApplicationRegistry);
}
foreach (dynamic service in modules)
{
if (!(service is IService))
{
continue;
}
((IService)service).FinishedStartup();
}
}
private void LoadModulesFromDllFile(string copiedDllFile)
{
List <IService> services = UniverseModuleLoader.LoadPlugins <IService>(copiedDllFile);
List <IApplicationPlugin> appPlugins = UniverseModuleLoader.LoadPlugins <IApplicationPlugin>(copiedDllFile);
List <INonSharedRegionModule> nsregionModule =
UniverseModuleLoader.LoadPlugins <INonSharedRegionModule>(copiedDllFile);
foreach (IService service in services)
{
service.Initialize(m_config, m_registry);
service.Start(m_config, m_registry);
service.FinishedStartup();
}
foreach (IApplicationPlugin plugin in appPlugins)
{
plugin.PreStartup(m_registry.RequestModuleInterface <ISimulationBase>());
plugin.Initialize(m_registry.RequestModuleInterface <ISimulationBase>());
plugin.PostInitialize();
plugin.Start();
plugin.PostStart();
}
IRegionModulesController rmc = m_registry.RequestModuleInterface <IRegionModulesController>();
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>();
if (manager != null)
{
foreach (INonSharedRegionModule nsrm in nsregionModule)
{
foreach (IScene scene in manager.Scenes)
{
nsrm.Initialize(m_config);
nsrm.AddRegion(scene);
nsrm.RegionLoaded(scene);
rmc.AllModules.Add(nsrm);
}
}
}
}
public void AddRegion(IScene scene)
{
m_scene = scene;
if (m_enabled)
{
//MainConsole.Instance.InfoFormat("[WIND] Enabled with an update rate of {0} frames.", m_frameUpdateRate);
m_frame = 0;
// Register all the Wind Model Plug-ins
foreach (IWindModelPlugin windPlugin in UniverseModuleLoader.PickupModules <IWindModelPlugin>())
{
//MainConsole.Instance.InfoFormat("[WIND] Found Plugin: {0}", windPlugin.Name);
m_availableWindPlugins.Add(windPlugin.Name, windPlugin);
}
// Check for desired plugin
if (m_availableWindPlugins.ContainsKey(desiredWindPlugin))
{
m_activeWindPlugin = m_availableWindPlugins [desiredWindPlugin];
//MainConsole.Instance.InfoFormat("[WIND] {0} plugin found, initializing.", desiredWindPlugin);
if (windConfig != null)
{
m_activeWindPlugin.Initialize();
m_activeWindPlugin.WindConfig(m_scene, windConfig);
}
}
// if the plug-in wasn't found, default to no wind.
if (m_activeWindPlugin == null)
{
MainConsole.Instance.ErrorFormat("[WIND] Could not find specified wind plug-in: {0}",
desiredWindPlugin);
MainConsole.Instance.ErrorFormat("[WIND] Defaulting to no wind.");
}
if (MainConsole.Instance != null)
{
// Get a list of the parameters for each plugin
foreach (IWindModelPlugin windPlugin in m_availableWindPlugins.Values)
{
MainConsole.Instance.Commands.AddCommand(
String.Format("wind base wind_plugin {0}", windPlugin.Name),
String.Format("wind base wind_plugin {0}", windPlugin.Name),
String.Format("{0} - {1}", windPlugin.Name, windPlugin.Description),
HandleConsoleBaseCommand, true, false);
MainConsole.Instance.Commands.AddCommand(
String.Format("wind base wind_update_rate"),
"wind base wind_update_rate <value>",
"Change the wind update rate.",
HandleConsoleBaseCommand, true, false);
foreach (KeyValuePair <string, string> kvp in windPlugin.WindParams())
{
MainConsole.Instance.Commands.AddCommand(
String.Format("wind {0} {1}", windPlugin.Name, kvp.Key),
String.Format("wind {0} {1}", windPlugin.Name, kvp.Key),
String.Format("{0} : {1} - {2}", windPlugin.Name, kvp.Key, kvp.Value),
HandleConsoleParamCommand, true, false);
}
}
}
// Register event handlers for when Avatars enter the region, and frame ticks
m_scene.EventManager.OnFrame += WindUpdate;
m_scene.EventManager.OnMakeRootAgent += OnAgentEnteredRegion;
// Register the wind module
m_scene.RegisterModuleInterface <IWindModule> (this);
// Generate initial wind values
GenWindPos();
// Mark Module Ready for duty
m_ready = true;
}
}
public void AddRegionToModules(IScene scene)
{
Dictionary <Type, INonSharedRegionModule> deferredNonSharedModules =
new Dictionary <Type, INonSharedRegionModule>();
// We need this to see if a module has already been loaded and
// has defined a replaceable interface. It's a generic call,
// so this can't be used directly. It will be used later
Type s = scene.GetType();
MethodInfo mi = s.GetMethod("RequestModuleInterface");
// Scan for, and load, non-shared modules
List <INonSharedRegionModule> list = new List <INonSharedRegionModule>();
List <INonSharedRegionModule> m_nonSharedModules = UniverseModuleLoader.PickupModules <INonSharedRegionModule>();
foreach (INonSharedRegionModule module in m_nonSharedModules)
{
Type replaceableInterface = module.ReplaceableInterface;
if (replaceableInterface != null)
{
MethodInfo mii = mi.MakeGenericMethod(replaceableInterface);
if (mii.Invoke(scene, new object[0]) != null)
{
MainConsole.Instance.DebugFormat("[REGIONMODULE]: Not loading {0} because another module has registered {1}",
module.Name, replaceableInterface);
continue;
}
deferredNonSharedModules[replaceableInterface] = module;
MainConsole.Instance.DebugFormat("[REGIONMODULE]: Deferred load of {0}", module.Name);
continue;
}
//MainConsole.Instance.DebugFormat("[REGIONMODULE]: Adding scene {0} to non-shared module {1}",
// scene.RegionInfo.RegionName, module.Name);
// Initialize the module
module.Initialize(m_simBase.ConfigSource);
IRegionModuleBaseModules.Add(module);
list.Add(module);
}
// Now add the modules that we found to the scene. If a module
// wishes to override a replaceable interface, it needs to
// register it in Initialize, so that the deferred module
// won't load.
foreach (INonSharedRegionModule module in list)
{
try
{
module.AddRegion(scene);
}
catch (Exception ex)
{
MainConsole.Instance.ErrorFormat("[RegionModulesControllerPlugin]: Failed to load module {0}: {1}", module.Name, ex.ToString());
}
AddRegionModule(scene, module.Name, module);
}
// Same thing for non-shared modules, load them unless overridden
List <INonSharedRegionModule> deferredlist =
new List <INonSharedRegionModule>();
foreach (INonSharedRegionModule module in deferredNonSharedModules.Values)
{
// Check interface override
Type replaceableInterface = module.ReplaceableInterface;
if (replaceableInterface != null)
{
MethodInfo mii = mi.MakeGenericMethod(replaceableInterface);
if (mii.Invoke(scene, new object[0]) != null)
{
MainConsole.Instance.DebugFormat("[REGIONMODULE]: Not loading {0} because another module has registered {1}",
module.Name, replaceableInterface);
continue;
}
}
MainConsole.Instance.DebugFormat("[REGIONMODULE]: Adding scene {0} to non-shared module {1} (deferred)",
scene.RegionInfo.RegionName, module.Name);
try
{
module.Initialize(m_simBase.ConfigSource);
}
catch (Exception ex)
{
MainConsole.Instance.ErrorFormat("[RegionModulesControllerPlugin]: Failed to load module {0}: {1}", module.Name, ex.ToString());
}
IRegionModuleBaseModules.Add(module);
list.Add(module);
deferredlist.Add(module);
}
// Finally, load valid deferred modules
foreach (INonSharedRegionModule module in deferredlist)
{
try
{
module.AddRegion(scene);
}
catch (Exception ex)
{
MainConsole.Instance.ErrorFormat("[RegionModulesControllerPlugin]: Failed to load module {0}: {1}", module.Name, ex.ToString());
}
AddRegionModule(scene, module.Name, module);
}
// This is needed for all module types. Modules will register
// Interfaces with scene in AddScene, and will also need a means
// to access interfaces registered by other modules. Without
// this extra method, a module attempting to use another modules's
// interface would be successful only depending on load order,
// which can't be depended upon, or modules would need to resort
// to ugly kludges to attempt to request interfaces when needed
// and unnecessary caching logic repeated in all modules.
// The extra function stub is just that much cleaner
//
foreach (INonSharedRegionModule module in list)
{
try
{
module.RegionLoaded(scene);
}
catch (Exception ex)
{
MainConsole.Instance.ErrorFormat("[RegionModulesControllerPlugin]: Failed to load module {0}: {1}", module.Name, ex.ToString());
}
}
}
public void Initialize(IConfigSource config, IRegistryCore registry)
{
IConfig m_config = config.Configs["UniverseData"];
if (m_config != null)
{
StorageProvider = m_config.GetString("StorageProvider", StorageProvider);
ConnectionString = m_config.GetString("ConnectionString", ConnectionString);
}
IGenericData DataConnector = null;
if (StorageProvider == "MySQL")
//Allow for fallback when UniverseData isn't set
{
MySQLDataLoader GenericData = new MySQLDataLoader();
DataConnector = GenericData;
}
/*else if (StorageProvider == "MSSQL2008")
* {
* MSSQLDataLoader GenericData = new MSSQLDataLoader();
*
* DataConnector = GenericData;
* }
* else if (StorageProvider == "MSSQL7")
* {
* MSSQLDataLoader GenericData = new MSSQLDataLoader();
*
* DataConnector = GenericData;
* }*/
else if (StorageProvider == "SQLite")
//Allow for fallback when UniverseData isn't set
{
SQLiteLoader GenericData = new SQLiteLoader();
// set default data directory in case it is needed
var simBase = registry.RequestModuleInterface <ISimulationBase> ();
GenericData.DefaultDataPath = simBase.DefaultDataPath;
DataConnector = GenericData;
}
List <IUniverseDataPlugin> Plugins = UniverseModuleLoader.PickupModules <IUniverseDataPlugin>();
foreach (IUniverseDataPlugin plugin in Plugins)
{
try
{
plugin.Initialize(DataConnector == null ? null : DataConnector.Copy(), config, registry,
ConnectionString);
}
catch (Exception ex)
{
if (MainConsole.Instance != null)
{
MainConsole.Instance.Warn("[DataService]: Exception occurred starting data plugin " +
plugin.Name + ", " + ex);
}
}
}
}
