private void SetUpConsole(IConfigSource config, IRegistryCore registry)
{
List <ICommandConsole> Plugins = AuroraModuleLoader.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);
}
private void LoadModulesFromDllFile(string copiedDllFile)
{
List <IService> services = AuroraModuleLoader.LoadPlugins <IService>(copiedDllFile);
List <IApplicationPlugin> appPlugins = AuroraModuleLoader.LoadPlugins <IApplicationPlugin>(copiedDllFile);
List <INonSharedRegionModule> nsregionModule =
AuroraModuleLoader.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.PostInitialise();
plugin.Start();
plugin.PostStart();
}
IRegionModulesController rmc = m_registry.RequestModuleInterface <IRegionModulesController>();
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>();
if (manager != null)
{
foreach (INonSharedRegionModule nsrm in nsregionModule)
{
nsrm.Initialise(m_config);
nsrm.AddRegion(manager.Scene);
nsrm.RegionLoaded(manager.Scene);
rmc.AllModules.Add(nsrm);
}
}
}
public void Initialise(IConfigSource source, IRegistryCore simBase, List <Type> types)
{
IConfig m_config = source.Configs["AuroraData"];
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 AuroraData 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 AuroraData isn't set
{
SQLiteLoader GenericData = new SQLiteLoader();
DataConnector = GenericData;
}
foreach (Type t in types)
{
List <dynamic> Plugins = AuroraModuleLoader.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]: Exeception occured starting data plugin " +
plugin.Name + ", " + ex.ToString());
}
}
}
}
}
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 = AuroraModuleLoader.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
{
}
}
/// <summary>
/// Load all plugins in assemblies at the given path
/// </summary>
/// <param name="assembliesPath"></param>
public void LoadPluginsFromAssemblies(string assembliesPath)
{
List <IPhysicsPlugin> physicsPlugins =
AuroraModuleLoader.LoadModules <IPhysicsPlugin>(assembliesPath);
List <IMeshingPlugin> meshingPlugins =
AuroraModuleLoader.LoadModules <IMeshingPlugin>(assembliesPath);
meshingPlugins.AddRange(AuroraModuleLoader.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 Initialize(IConfigSource config, IRegistryCore registry)
{
IConfig handlerConfig = config.Configs["Handlers"];
if (handlerConfig.GetString("AgentInfoHandler", "") != Name)
{
return;
}
string localAssetHandler = handlerConfig.GetString("LocalAgentInfoHandler", "AgentInfoService");
List <IAgentInfoService> services = AuroraModuleLoader.PickupModules <IAgentInfoService>();
#if (!ISWIN)
foreach (IAgentInfoService s in services)
{
if (s.GetType().Name == localAssetHandler)
{
m_localService = s;
}
}
#else
foreach (IAgentInfoService s in services.Where(s => s.GetType().Name == localAssetHandler))
{
m_localService = s;
}
#endif
if (m_localService == null)
{
m_localService = new AgentInfoService();
}
m_localService.Initialize(config, registry);
registry.RegisterModuleInterface <IAgentInfoService>(this);
m_registry = registry;
Init(registry, Name);
}
public MigrationManager(IDataConnector genericData, string migratorName, bool validateTables)
{
this.genericData = genericData;
this.migratorName = migratorName;
this.validateTables = validateTables;
List <IMigrator> allMigrators = AuroraModuleLoader.PickupModules <IMigrator>();
#if (!ISWIN)
foreach (IMigrator m in allMigrators)
{
if (m.MigrationName != null)
{
if (m.MigrationName == migratorName)
{
migrators.Add((Migrator)m);
}
}
}
#else
foreach (IMigrator m in allMigrators.Where(m => m.MigrationName != null).Where(m => m.MigrationName == migratorName))
{
migrators.Add((Migrator)m);
}
#endif
}
public void Initialize(ISimulationBase openSim)
{
m_openSim = openSim;
IConfig handlerConfig = openSim.ConfigSource.Configs["ApplicationPlugins"];
if (handlerConfig.GetString("RegionModulesControllerPlugin", "") != Name)
{
return;
}
m_openSim.ApplicationRegistry.RegisterModuleInterface <IRegionModulesController>(this);
// Scan modules and load all that aren't disabled
m_sharedInstances = AuroraModuleLoader.PickupModules <ISharedRegionModule>();
foreach (ISharedRegionModule module in m_sharedInstances)
{
try
{
module.Initialise(m_openSim.ConfigSource);
}
catch (Exception ex)
{
MainConsole.Instance.ErrorFormat("[RegionModulesControllerPlugin]: Failed to load module {0}: {1}", module.Name, ex.ToString());
}
}
}
public void PostStart()
{
IConfig handlerConfig = m_openSim.ConfigSource.Configs["ApplicationPlugins"];
if (handlerConfig.GetString("LoadRegionsPlugin", "") != Name)
{
return;
}
List <IRegionLoader> regionLoaders = AuroraModuleLoader.PickupModules <IRegionLoader>();
List <RegionInfo[]> regions = new List <RegionInfo[]>();
SceneManager manager = m_openSim.ApplicationRegistry.RequestModuleInterface <SceneManager>();
foreach (IRegionLoader loader in regionLoaders)
{
loader.Initialise(m_openSim.ConfigSource, m_openSim);
if (!loader.Enabled)
{
continue;
}
m_log.Info("[LoadRegionsPlugin]: Checking for region configurations from " + loader.Name + " plugin...");
while (true)
{
RegionInfo[] regionsToLoad = loader.LoadRegions();
if (regionsToLoad == null)
{
break; //No regions, end
}
string reason;
if (!CheckRegionsForSanity(regionsToLoad, out reason))
{
m_log.Error("[LoadRegionsPlugin]: Halting startup due to conflicts in region configurations");
if (!loader.FailedToStartRegions(reason))
{
throw new Exception(); //If it doesn't fix it, end the program
}
}
else
{
//They are sanitized, load them
manager.AllRegions += regionsToLoad.Length;
regions.Add(regionsToLoad);
break;
}
}
}
foreach (RegionInfo[] regionsToLoad in regions)
{
for (int i = 0; i < regionsToLoad.Length; i++)
{
IScene scene = null;
m_log.Info("[LoadRegionsPlugin]: Creating Region: " + regionsToLoad[i].RegionName);
manager.CreateRegion(regionsToLoad[i], out scene);
}
}
}
public void PostStart()
{
IConfig handlerConfig = m_openSim.ConfigSource.Configs["ApplicationPlugins"];
if (handlerConfig.GetString("LoadRegionsPlugin", "") != Name || !Enabled)
{
return;
}
List <IRegionLoader> regionLoaders = AuroraModuleLoader.PickupModules <IRegionLoader>();
List <RegionInfo[]> regions = new List <RegionInfo[]>();
SceneManager manager = m_openSim.ApplicationRegistry.RequestModuleInterface <SceneManager>();
foreach (IRegionLoader loader in regionLoaders)
{
loader.Initialise(m_openSim.ConfigSource, m_openSim);
if (!loader.Enabled)
{
continue;
}
MainConsole.Instance.Info("[LoadRegionsPlugin]: Checking for region configurations from " + loader.Name + " plugin...");
RegionInfo[] regionsToLoad = loader.LoadRegions();
if (regionsToLoad == null)
{
continue; //No regions, end for this module
}
string reason;
if (!CheckRegionsForSanity(regionsToLoad, out reason))
{
MainConsole.Instance.Error("[LoadRegionsPlugin]: Halting startup due to conflicts in region configurations");
if (!loader.FailedToStartRegions(reason))
{
throw new Exception(); //If it doesn't fix it, end the program
}
}
else
{
//They are sanitized, load them
manager.AllRegions += regionsToLoad.Length;
regions.Add(regionsToLoad);
}
}
#if (!ISWIN)
foreach (RegionInfo[] regionsToLoad in regions)
{
foreach (RegionInfo t in regionsToLoad)
{
manager.StartNewRegion(t);
}
}
#else
foreach (RegionInfo t in regions.SelectMany(regionsToLoad => regionsToLoad))
{
manager.StartNewRegion(t);
}
#endif
}
public virtual void InitializeModules()
{
m_applicationPlugins = AuroraModuleLoader.PickupModules <IApplicationPlugin>();
foreach (IApplicationPlugin plugin in m_applicationPlugins)
{
plugin.PreStartup(this);
}
}
public List <ICapsServiceConnector> GetServiceConnectors()
{
if (m_connectors.Count == 0)
{
m_connectors = AuroraModuleLoader.PickupModules <ICapsServiceConnector>();
}
return(m_connectors);
}
private void FindChatPlugins()
{
AllChatPlugins = AuroraModuleLoader.PickupModules <IChatPlugin>();
foreach (IChatPlugin plugin in AllChatPlugins)
{
plugin.Initialize(this);
}
}
private void SetupCompilers()
{
converters = AuroraModuleLoader.PickupModules <IScriptConverter>();
foreach (IScriptConverter convert in converters)
{
convert.Initialise(this);
}
}
public void Initialise(IConfigSource source, IRegistryCore simBase)
{
//
// Try reading the [DatabaseService] section, if it exists
//
IConfig dbConfig = source.Configs["DatabaseService"];
if (dbConfig != null)
{
StorageProvider = dbConfig.GetString("StorageProvider", String.Empty);
ConnectionString = dbConfig.GetString("ConnectionString", String.Empty);
}
//
// [AuroraData] section overrides [DatabaseService], if it exists
//
IConfig m_config = source.Configs["AuroraData"];
if (m_config != null)
{
StorageProvider = m_config.GetString("StorageProvider", StorageProvider);
ConnectionString = m_config.GetString("ConnectionString", ConnectionString);
}
IGenericData DataConnector = null;
if (StorageProvider == "MySQL" || StorageProvider == "OpenSim.Data.MySQL.dll") //Allow for fallback when AuroraData 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" || StorageProvider == "OpenSim.Data.SQLite.dll") //Allow for fallback when AuroraData isn't set
{
SQLiteLoader GenericData = new SQLiteLoader();
DataConnector = GenericData;
}
List <IAuroraDataPlugin> Plugins = AuroraModuleLoader.PickupModules <IAuroraDataPlugin>();
foreach (IAuroraDataPlugin plugin in Plugins)
{
plugin.Initialize(DataConnector.Copy(), source, simBase, ConnectionString);
}
}
public void Initialize(ISimulationBase openSim)
{
m_OpenSimBase = openSim;
IConfig handlerConfig = openSim.ConfigSource.Configs["ApplicationPlugins"];
if (handlerConfig.GetString("SceneManager", "") != Name)
{
return;
}
m_config = openSim.ConfigSource;
string name = String.Empty;
// Try reading the [SimulationDataStore] section
IConfig simConfig = openSim.ConfigSource.Configs["SimulationDataStore"];
if (simConfig != null)
{
name = simConfig.GetString("DatabaseLoaderName", "FileBasedDatabase");
}
ISimulationDataStore[] stores = AuroraModuleLoader.PickupModules <ISimulationDataStore> ().ToArray();
List <string> storeNames = new List <string>();
foreach (ISimulationDataStore store in stores)
{
if (store.Name.ToLower() == name.ToLower())
{
m_simulationDataService = store;
break;
}
storeNames.Add(store.Name);
}
if (m_simulationDataService == null)
{
MainConsole.Instance.ErrorFormat("[SceneManager]: FAILED TO LOAD THE SIMULATION SERVICE AT '{0}', ONLY OPTIONS ARE {1}, QUITING...", name, string.Join(", ", storeNames.ToArray()));
Console.Read(); //Wait till they see
Environment.Exit(0);
}
m_simulationDataService.Initialise();
AddConsoleCommands();
//Load the startup modules for the region
m_startupPlugins = AuroraModuleLoader.PickupModules <ISharedRegionStartupModule>();
//Register us!
m_OpenSimBase.ApplicationRegistry.RegisterModuleInterface <SceneManager>(this);
m_OpenSimBase.EventManager.RegisterEventHandler("RegionInfoChanged", RegionInfoChanged);
}
private void FinishStartUp()
{
//Tell modules about it
StartupCompleteModules();
m_OpenSimBase.RunStartupCommands();
TimeSpan timeTaken = DateTime.Now - m_OpenSimBase.StartupTime;
MainConsole.Instance.InfoFormat("[SceneManager]: All regions are started. This took {0}m {1}.{2}s", timeTaken.Minutes, timeTaken.Seconds, timeTaken.Milliseconds);
AuroraModuleLoader.ClearCache();
// In 99.9% of cases it is a bad idea to manually force garbage collection. However,
// this is a rare case where we know we have just went through a long cycle of heap
// allocations, and there is no more work to be done until someone logs in
GC.Collect();
}
public void Initialize(IConfigSource config, IRegistryCore registry)
{
Registry = registry;
var webPages = AuroraModuleLoader.PickupModules <IWebInterfacePage>();
foreach (var pages in webPages)
{
foreach (var page in pages.FilePath)
{
_pages.Add(page, pages);
}
}
_translators = AuroraModuleLoader.PickupModules <ITranslator>();
_defaultTranslator = _translators[0];
}
/// <summary>
/// Create a scene and its initial base structures.
/// </summary>
/// <param name="regionInfo"></param>
/// <returns></returns>
public IScene CreateScene(ISimulationDataStore dataStore, RegionInfo regionInfo)
{
AgentCircuitManager circuitManager = new AgentCircuitManager();
List <IClientNetworkServer> clientServers = AuroraModuleLoader.PickupModules <IClientNetworkServer>();
List <IClientNetworkServer> allClientServers = new List <IClientNetworkServer>();
foreach (IClientNetworkServer clientServer in clientServers)
{
clientServer.Initialise((uint)regionInfo.RegionPort, m_configSource, circuitManager);
allClientServers.Add(clientServer);
}
Scene scene = new Scene();
scene.AddModuleInterfaces(m_simBase.ApplicationRegistry.GetInterfaces());
scene.Initialize(regionInfo, dataStore, circuitManager, allClientServers);
return(scene);
}
/// <summary>
/// Create a scene and its initial base structures.
/// </summary>
/// <param name="regionInfo"></param>
/// <param name="configSource"></param>
/// <returns></returns>
protected IScene SetupScene(RegionInfo regionInfo, IConfigSource configSource)
{
AgentCircuitManager circuitManager = new AgentCircuitManager();
List <IClientNetworkServer> clientServers = AuroraModuleLoader.PickupModules <IClientNetworkServer>();
List <IClientNetworkServer> allClientServers = new List <IClientNetworkServer>();
foreach (IClientNetworkServer clientServer in clientServers)
{
clientServer.Initialise(MainServer.Instance.Port, m_configSource, circuitManager);
allClientServers.Add(clientServer);
}
AsyncScene scene = new AsyncScene();
scene.AddModuleInterfaces(m_openSimBase.ApplicationRegistry.GetInterfaces());
scene.Initialize(regionInfo, circuitManager, allClientServers);
return(scene);
}
public void Initialize(ISimulationBase openSim)
{
m_openSim = openSim;
IConfig handlerConfig = openSim.ConfigSource.Configs["ApplicationPlugins"];
if (handlerConfig.GetString("RegionModulesControllerPlugin", "") != Name)
{
return;
}
m_openSim.ApplicationRegistry.RegisterModuleInterface <IRegionModulesController>(this);
// Scan modules and load all that aren't disabled
m_sharedInstances = AuroraModuleLoader.PickupModules <ISharedRegionModule>();
foreach (ISharedRegionModule module in m_sharedInstances)
{
module.Initialise(m_openSim.ConfigSource);
}
}
public void Start()
{
IConfig handlerConfig = m_openSim.ConfigSource.Configs["ApplicationPlugins"];
if (handlerConfig.GetString("ServicesLoader", "") != Name)
{
return;
}
List <IService> serviceConnectors = AuroraModuleLoader.PickupModules <IService>();
foreach (IService connector in serviceConnectors)
{
try
{
connector.Initialize(m_openSim.ConfigSource, m_openSim.ApplicationRegistry);
}
catch
{
}
}
foreach (IService connector in serviceConnectors)
{
try
{
connector.Start(m_openSim.ConfigSource, m_openSim.ApplicationRegistry);
}
catch
{
}
}
foreach (IService connector in serviceConnectors)
{
try
{
connector.FinishedStartup();
}
catch
{
}
}
}
public virtual void InitializeModules()
{
LocalDataService lds = new LocalDataService();
lds.Initialise(ConfigSource, ApplicationRegistry, m_dataPlugins);
List <dynamic> modules = new List <dynamic>();
foreach (Type t in m_servicePlugins)
{
var mods = AuroraModuleLoader.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();
}
}
/// <summary>
/// Create a scene and its initial base structures.
/// </summary>
/// <param name = "regionInfo"></param>
/// <param name = "proxyOffset"></param>
/// <param name = "configSource"></param>
/// <param name = "clientServer"> </param>
/// <returns></returns>
protected IScene SetupScene(RegionInfo regionInfo, IConfigSource configSource)
{
AgentCircuitManager circuitManager = new AgentCircuitManager();
List <IClientNetworkServer> clientServers = AuroraModuleLoader.PickupModules <IClientNetworkServer>();
List <IClientNetworkServer> allClientServers = new List <IClientNetworkServer>();
foreach (IClientNetworkServer clientServer in clientServers)
{
foreach (int port in regionInfo.UDPPorts)
{
IClientNetworkServer copy = clientServer.Copy();
copy.Initialise(port, m_configSource, circuitManager);
allClientServers.Add(copy);
}
}
Scene scene = new Scene();
scene.AddModuleInterfaces(m_openSimBase.ApplicationRegistry.GetInterfaces());
scene.Initialize(regionInfo, circuitManager, allClientServers);
return(scene);
}
/// <summary>
/// Start the application modules
/// </summary>
public virtual void StartModules()
{
m_applicationPlugins = AuroraModuleLoader.PickupModules <IApplicationPlugin>();
foreach (IApplicationPlugin plugin in m_applicationPlugins)
{
plugin.Initialize(this);
}
foreach (IApplicationPlugin plugin in m_applicationPlugins)
{
plugin.PostInitialise();
}
foreach (IApplicationPlugin plugin in m_applicationPlugins)
{
plugin.Start();
}
foreach (IApplicationPlugin plugin in m_applicationPlugins)
{
plugin.PostStart();
}
}
/// <summary>
/// Load all plugins in assemblies at the given path
/// </summary>
/// <param name="pluginsPath"></param>
public void LoadPluginsFromAssemblies(string assembliesPath)
{
List <IPhysicsPlugin> physicsPlugins = AuroraModuleLoader.LoadModules <IPhysicsPlugin>(assembliesPath);
List <IMeshingPlugin> meshingPlugins = AuroraModuleLoader.LoadModules <IMeshingPlugin>(assembliesPath);
foreach (IPhysicsPlugin plug in physicsPlugins)
{
_PhysPlugins.Add(plug.GetName(), plug);
}
foreach (IMeshingPlugin plug in meshingPlugins)
{
_MeshPlugins.Add(plug.GetName(), plug);
}
/*// Walk all assemblies (DLLs effectively) and see if they are home
* // of a plugin that is of interest for us
* string[] pluginFiles = Directory.GetFiles(assembliesPath, "*.dll");
*
* for (int i = 0; i < pluginFiles.Length; i++)
* {
* LoadPluginsFromAssembly(pluginFiles[i]);
* }*/
}
/// <summary>
/// Create a scene and its initial base structures.
/// </summary>
/// <param name="regionInfo"></param>
/// <param name="proxyOffset"></param>
/// <param name="configSource"></param>
/// <param name="clientServer"> </param>
/// <returns></returns>
protected Scene SetupScene(RegionInfo regionInfo, IConfigSource configSource)
{
AgentCircuitManager circuitManager = new AgentCircuitManager();
IPAddress listenIP = regionInfo.InternalEndPoint.Address;
if (!IPAddress.TryParse(regionInfo.InternalEndPoint.Address.ToString(), out listenIP))
{
listenIP = IPAddress.Parse("0.0.0.0");
}
uint port = (uint)regionInfo.InternalEndPoint.Port;
string ClientstackDll = m_config.Configs["Startup"].GetString("ClientStackPlugin", "OpenSim.Region.ClientStack.LindenUDP.dll");
IClientNetworkServer clientServer = AuroraModuleLoader.LoadPlugin <IClientNetworkServer> (Util.BasePathCombine(ClientstackDll));
clientServer.Initialise(
listenIP, ref port, 0, regionInfo.m_allow_alternate_ports,
m_config, circuitManager);
regionInfo.InternalEndPoint.Port = (int)port;
Scene scene = new Scene();
scene.AddModuleInterfaces(m_OpenSimBase.ApplicationRegistry.GetInterfaces());
scene.Initialize(regionInfo, circuitManager, clientServer);
StartModules(scene);
m_clientServers.Add(clientServer);
//Do this here so that we don't have issues later when startup complete messages start coming in
m_localScenes.Add(scene);
return(scene);
}
public void LoadLibraries(IRegistryCore registry)
{
if (!m_enabled)
{
return;
}
List <IDefaultLibraryLoader> Loaders = AuroraModuleLoader.PickupModules <IDefaultLibraryLoader>();
try
{
IniConfigSource iniSource = new IniConfigSource("DefaultInventory/Inventory.ini",
IniFileType.AuroraStyle);
if (iniSource != null)
{
foreach (IDefaultLibraryLoader loader in Loaders)
{
loader.LoadLibrary(this, iniSource, registry);
}
}
}
catch
{
}
}
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 AuroraModuleLoader.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.Initialise();
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("{0} - {1}", windPlugin.Name, windPlugin.Description), "",
HandleConsoleBaseCommand);
MainConsole.Instance.Commands.AddCommand(
String.Format("wind base wind_update_rate"), "Change the wind update rate.", "",
HandleConsoleBaseCommand);
foreach (KeyValuePair <string, string> kvp in windPlugin.WindParams())
{
MainConsole.Instance.Commands.AddCommand(
String.Format("wind {0} {1}", windPlugin.Name, kvp.Key),
String.Format("{0} : {1} - {2}", windPlugin.Name, kvp.Key, kvp.Value), "",
HandleConsoleParamCommand);
}
}
}
// 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 PostStart()
{
IConfig handlerConfig = m_openSim.ConfigSource.Configs["ApplicationPlugins"];
if (handlerConfig.GetString("LoadRegionsPlugin", "") != Name || !Enabled)
{
return;
}
List <IRegionLoader> regionLoaders = AuroraModuleLoader.PickupModules <IRegionLoader>();
ISceneManager manager = m_openSim.ApplicationRegistry.RequestModuleInterface <ISceneManager>();
MainConsole.Instance.DefaultPrompt = "Region (root)";//Set this up
reload:
List <RegionInfo[]> regions = new List <RegionInfo[]>();
foreach (IRegionLoader loader in regionLoaders)
{
loader.Initialise(m_openSim.ConfigSource, m_openSim);
if (!loader.Enabled)
{
continue;
}
MainConsole.Instance.Info("[LoadRegions]: Checking for regions from " + loader.Name + "");
RegionInfo[] regionsToLoad = loader.LoadRegions();
if (regionsToLoad == null)
{
continue; //No regions, end for this module
}
string reason;
if (!CheckRegionsForSanity(regionsToLoad, out reason))
{
MainConsole.Instance.Error("[LoadRegions]: Halting startup due to conflicts in region configurations");
if (!loader.FailedToStartRegions(reason))
{
bool foundSomeRegions = false;
foreach (IRegionLoader l in regionLoaders)
{
l.Initialise(m_openSim.ConfigSource, m_openSim);
if (!loader.Enabled)
{
continue;
}
RegionInfo[] rs = loader.LoadRegions();
if (rs == null)
{
continue; //No regions, end for this module
}
if (CheckRegionsForSanity(regionsToLoad, out reason))
{
foundSomeRegions = true;
break;
}
}
if (!foundSomeRegions)
{
throw new Exception(); //If it doesn't fix it, and we don't have regions now, end the program
}
}
goto reload;
}
else
{
//They are sanitized, load them
manager.AllRegions += regionsToLoad.Length;
regions.Add(regionsToLoad);
}
}
while (regions.Count == 0)
{
foreach (IRegionLoader loader in regionLoaders)
{
if (loader.Default && loader.Enabled)
{
MainConsole.Instance.Info("[LoadRegions]: Attempting to create new region with " + loader.Name);
loader.CreateRegion();
goto reload;
}
}
}
#if (!ISWIN)
foreach (RegionInfo[] regionsToLoad in regions)
{
foreach (RegionInfo r in regionsToLoad)
{
RegionInfo reg = r;
//System.Threading.Thread t = new System.Threading.Thread(delegate()
// {
manager.StartNewRegion(reg);
// });
//t.Start();
}
}
#else
foreach (RegionInfo t in regions.SelectMany(regionsToLoad => regionsToLoad))
{
manager.StartNewRegion(t);
}
#endif
}
