/// <summary> /// Create a server that can set up sessions for virtual world client <-> server communications /// </summary> /// <param name="_listenIP"></param> /// <param name="port"></param> /// <param name="proxyPortOffset"></param> /// <param name="allow_alternate_port"></param> /// <param name="assetCache"></param> /// <param name="authenticateClass"></param> /// <returns></returns> public IClientNetworkServer CreateServer( IPAddress _listenIP, ref uint port, int proxyPortOffset, bool allow_alternate_port, IAssetCache assetCache, AgentCircuitManager authenticateClass) { return(CreateServer( _listenIP, ref port, proxyPortOffset, allow_alternate_port, null, assetCache, authenticateClass)); }
/// <summary> /// Create a server that can set up sessions for virtual world client <-> server communications /// </summary> /// <param name="_listenIP"></param> /// <param name="port"></param> /// <param name="proxyPortOffset"></param> /// <param name="allow_alternate_port"></param> /// <param name="configSource"> /// Can be null, in which case default values are used /// </param> /// <param name="assetCache"></param> /// <param name="authenticateClass"></param> /// <returns></returns> public List <IClientNetworkServer> CreateServers( IPAddress _listenIP, ref uint port, int proxyPortOffset, bool allow_alternate_port, IConfigSource configSource, AgentCircuitManager authenticateClass) { if (m_log.IsDebugEnabled) { m_log.DebugFormat("{0} called", System.Reflection.MethodBase.GetCurrentMethod().Name); } List <IClientNetworkServer> servers = new List <IClientNetworkServer>(); if (plugin != null) { for (int i = 0; i < plugin.Count; i++) { IClientNetworkServer server = (IClientNetworkServer)Activator.CreateInstance(pluginAssembly[i].GetType(plugin[i].ToString())); server.Initialise( _listenIP, ref port, proxyPortOffset, allow_alternate_port, configSource, authenticateClass); servers.Add(server); } return(servers); } m_log.Error("[CLIENTSTACK]: Couldn't initialize a new server"); return(null); }
public void ValidateLoginTest() { AgentCircuitManager agentCircuitManager = new AgentCircuitManager(); agentCircuitManager.AddNewCircuit(circuitcode1, m_agentCircuitData1); agentCircuitManager.AddNewCircuit(circuitcode2, m_agentCircuitData2); // should be authorized AuthenticateResponse resp = agentCircuitManager.AuthenticateSession(SessionId1, AgentId1, circuitcode1); Assert.That(resp.Authorised); //should not be authorized resp = agentCircuitManager.AuthenticateSession(SessionId1, UUID.Random(), circuitcode1); Assert.That(!resp.Authorised); resp = agentCircuitManager.AuthenticateSession(UUID.Random(), AgentId1, circuitcode1); Assert.That(!resp.Authorised); resp = agentCircuitManager.AuthenticateSession(SessionId1, AgentId1, circuitcode2); Assert.That(!resp.Authorised); resp = agentCircuitManager.AuthenticateSession(SessionId2, AgentId1, circuitcode2); Assert.That(!resp.Authorised); agentCircuitManager.RemoveCircuit(circuitcode2); resp = agentCircuitManager.AuthenticateSession(SessionId2, AgentId2, circuitcode2); Assert.That(!resp.Authorised); }
/// <summary> /// Initialize the server /// </summary> /// <param name="_listenIP"></param> /// <param name="port"></param> /// <param name="proxyPortOffsetParm"></param> /// <param name="allow_alternate_port"></param> /// <param name="configSource"></param> /// <param name="assetCache"></param> /// <param name="circuitManager"></param> public void Initialise( IPAddress _listenIP, ref uint port, int proxyPortOffsetParm, bool allow_alternate_port, IConfigSource configSource, IAssetCache assetCache, AgentCircuitManager circuitManager) { ClientStackUserSettings userSettings = new ClientStackUserSettings(); IConfig config = configSource.Configs["ClientStack.LindenUDP"]; if (config != null) { if (config.Contains("client_throttle_multiplier")) { userSettings.ClientThrottleMultipler = config.GetFloat("client_throttle_multiplier"); } } m_log.DebugFormat("[CLIENT]: client_throttle_multiplier = {0}", userSettings.ClientThrottleMultipler); proxyPortOffset = proxyPortOffsetParm; listenPort = (uint)(port + proxyPortOffsetParm); listenIP = _listenIP; Allow_Alternate_Port = allow_alternate_port; m_assetCache = assetCache; m_circuitManager = circuitManager; CreatePacketServer(userSettings); // Return new port // This because in Grid mode it is not really important what port the region listens to as long as it is correctly registered. // So the option allow_alternate_ports="true" was added to default.xml port = (uint)(listenPort - proxyPortOffsetParm); }
/// <summary> /// Set up a scene. If it's more then one scene, use the same CommunicationsManager to link regions /// or a different, to get a brand new scene with new shared region modules. /// </summary> /// <param name="name">Name of the region</param> /// <param name="id">ID of the region</param> /// <param name="x">X co-ordinate of the region</param> /// <param name="y">Y co-ordinate of the region</param> /// <param name="cm">This should be the same if simulating two scenes within a standalone</param> /// <returns></returns> public static TestScene SetupScene(string name, UUID id, uint x, uint y, CoreAssetCache cache) { Console.WriteLine("Setting up test scene {0}", name); // We must set up a console otherwise setup of some modules may fail MainConsole.Instance = new MockConsole("TEST PROMPT"); RegionInfo regInfo = new RegionInfo(x, y, new IPEndPoint(IPAddress.Loopback, 9000), "127.0.0.1"); regInfo.RegionName = name; regInfo.RegionID = id; AgentCircuitManager acm = new AgentCircuitManager(); SceneCommunicationService scs = new SceneCommunicationService(); ISimulationDataService simDataService = OpenSim.Server.Base.ServerUtils.LoadPlugin <ISimulationDataService>("OpenSim.Tests.Common.dll", null); IEstateDataService estateDataService = null; IConfigSource configSource = new IniConfigSource(); TestScene testScene = new TestScene( regInfo, acm, scs, simDataService, estateDataService, null, false, configSource, null); IRegionModule godsModule = new GodsModule(); godsModule.Initialise(testScene, new IniConfigSource()); testScene.AddModule(godsModule.Name, godsModule); LocalAssetServicesConnector assetService = StartAssetService(testScene, cache); StartAuthenticationService(testScene); LocalInventoryServicesConnector inventoryService = StartInventoryService(testScene); StartGridService(testScene); LocalUserAccountServicesConnector userAccountService = StartUserAccountService(testScene); LocalPresenceServicesConnector presenceService = StartPresenceService(testScene); inventoryService.PostInitialise(); assetService.PostInitialise(); userAccountService.PostInitialise(); presenceService.PostInitialise(); testScene.RegionInfo.EstateSettings.EstateOwner = UUID.Random(); testScene.SetModuleInterfaces(); testScene.LandChannel = new TestLandChannel(testScene); testScene.LoadWorldMap(); PhysicsPluginManager physicsPluginManager = new PhysicsPluginManager(); physicsPluginManager.LoadPluginsFromAssembly("Physics/OpenSim.Region.Physics.BasicPhysicsPlugin.dll"); testScene.PhysicsScene = physicsPluginManager.GetPhysicsScene("basicphysics", "ZeroMesher", new IniConfigSource(), "test"); testScene.RegionInfo.EstateSettings = new EstateSettings(); testScene.LoginsDisabled = false; testScene.RegisterRegionWithGrid(); return(testScene); }
/// <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, int proxyOffset, IConfigSource configSource, out IClientNetworkServer clientServer) { AgentCircuitManager circuitManager = new AgentCircuitManager(); IPAddress listenIP = regionInfo.InternalEndPoint.Address; uint port = (uint) regionInfo.InternalEndPoint.Port; if (m_autoCreateClientStack) { clientServer = m_clientStackManager.CreateServer(listenIP, ref port, proxyOffset, regionInfo.m_allow_alternate_ports, configSource, m_assetCache, circuitManager); } else { clientServer = null; } regionInfo.InternalEndPoint.Port = (int) port; Scene scene = CreateScene(regionInfo, m_storageManager, circuitManager); if (m_autoCreateClientStack) { clientServer.AddScene(scene); } scene.LoadWorldMap(); scene.PhysicsScene = GetPhysicsScene(scene.RegionInfo.RegionName); scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised()); scene.PhysicsScene.SetWaterLevel((float) regionInfo.RegionSettings.WaterHeight); // TODO: Remove this cruft once MasterAvatar is fully deprecated //Master Avatar Setup UserProfileData masterAvatar; if (scene.RegionInfo.MasterAvatarAssignedUUID == UUID.Zero) { masterAvatar = m_commsManager.UserService.SetupMasterUser(scene.RegionInfo.MasterAvatarFirstName, scene.RegionInfo.MasterAvatarLastName, scene.RegionInfo.MasterAvatarSandboxPassword); } else { masterAvatar = m_commsManager.UserService.SetupMasterUser(scene.RegionInfo.MasterAvatarAssignedUUID); scene.RegionInfo.MasterAvatarFirstName = masterAvatar.FirstName; scene.RegionInfo.MasterAvatarLastName = masterAvatar.SurName; } if (masterAvatar == null) { m_log.Info("[Parcel]: No master avatar found, using null."); scene.RegionInfo.MasterAvatarAssignedUUID = UUID.Zero; } else { m_log.InfoFormat("[Parcel]: Found master avatar {0} {1} [" + masterAvatar.ID.ToString() + "]", scene.RegionInfo.MasterAvatarFirstName, scene.RegionInfo.MasterAvatarLastName); scene.RegionInfo.MasterAvatarAssignedUUID = masterAvatar.ID; } return scene; }
private void AddUdpServer(IniConfigSource configSource) { uint port = 0; AgentCircuitManager acm = m_scene.AuthenticateHandler; m_udpServer = new TestLLUDPServer(IPAddress.Any, ref port, 0, false, configSource, acm); m_udpServer.AddScene(m_scene); }
/// <summary> /// Set up a client for tests which aren't concerned with this process itself and where only one client is being /// tested /// </summary> /// <param name="circuitCode"></param> /// <param name="epSender"></param> /// <param name="testLLUDPServer"></param> /// <param name="acm"></param> protected void AddClient( uint circuitCode, EndPoint epSender, TestLLUDPServer testLLUDPServer, AgentCircuitManager acm) { UUID myAgentUuid = UUID.Parse("00000000-0000-0000-0000-000000000001"); UUID mySessionUuid = UUID.Parse("00000000-0000-0000-0000-000000000002"); AddClient(circuitCode, epSender, myAgentUuid, mySessionUuid, testLLUDPServer, acm); }
protected override Scene CreateScene(RegionInfo regionInfo, ISimulationDataService simDataService, IEstateDataService estateDataService, AgentCircuitManager circuitManager) { return(new Scene( regionInfo, circuitManager, simDataService, estateDataService, Config, m_version)); }
public TestScene( RegionInfo regInfo, AgentCircuitManager authen, ISimulationDataService simDataService, IEstateDataService estateDataService, IConfigSource config, string simulatorVersion) : base(regInfo, authen, simDataService, estateDataService, config, simulatorVersion) { }
public TestScene( RegionInfo regInfo, AgentCircuitManager authen, PhysicsScene physicsScene, SceneCommunicationService sceneGridService, ISimulationDataService simDataService, IEstateDataService estateDataService, IConfigSource config, string simulatorVersion) : base(regInfo, authen, physicsScene, sceneGridService, simDataService, estateDataService, config, simulatorVersion) { }
public static Scene CreateScene(RegionInfo regionInfo, AgentCircuitManager circuitManager, CommunicationsManager m_commsManager, StorageManager storageManager, ModuleLoader m_moduleLoader, ConfigSettings m_configSettings, OpenSimConfigSource m_config, string m_version) { HGSceneCommunicationService sceneGridService = new HGSceneCommunicationService(m_commsManager, HGServices); return(new HGScene(regionInfo, circuitManager, m_commsManager, sceneGridService, storageManager, m_moduleLoader, m_configSettings.DumpAssetsToFile, m_configSettings.PhysicalPrim, m_configSettings.See_into_region_from_neighbor, m_config.Source, m_version)); }
public TestScene( RegionInfo regInfo, AgentCircuitManager authen, SceneCommunicationService sceneGridService, ISimulationDataService simDataService, IEstateDataService estateDataService, ModuleLoader moduleLoader, bool dumpAssetsToFile, bool physicalPrim, bool SeeIntoRegionFromNeighbor, IConfigSource config, string simulatorVersion) : base(regInfo, authen, sceneGridService, simDataService, estateDataService, moduleLoader, dumpAssetsToFile, physicalPrim, SeeIntoRegionFromNeighbor, config, simulatorVersion) { }
protected override Scene CreateScene(RegionInfo regionInfo, ISimulationDataService simDataService, IEstateDataService estateDataService, AgentCircuitManager circuitManager) { SceneCommunicationService sceneGridService = new SceneCommunicationService(); return(new Scene( regionInfo, circuitManager, sceneGridService, simDataService, estateDataService, m_moduleLoader, false, m_config.Source, m_version)); }
protected override Scene CreateScene(RegionInfo regionInfo, ISimulationDataService simDataService, IEstateDataService estateDataService, AgentCircuitManager circuitManager) { SceneCommunicationService sceneGridService = new SceneCommunicationService(); return(new Scene( regionInfo, circuitManager, sceneGridService, simDataService, estateDataService, m_moduleLoader, false, m_configSettings.PhysicalPrim, m_configSettings.See_into_region_from_neighbor, m_config.Source, m_version)); }
public static TestLLUDPServer AddUdpServer(Scene scene, IniConfigSource configSource) { uint port = 0; AgentCircuitManager acm = scene.AuthenticateHandler; TestLLUDPServer udpServer = new TestLLUDPServer(IPAddress.Any, ref port, 0, false, configSource, acm); udpServer.AddScene(scene); return(udpServer); }
/// <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, int proxyOffset, IConfigSource configSource) { //List<IClientNetworkServer> clientNetworkServers = null; AgentCircuitManager circuitManager = new AgentCircuitManager(); Scene scene = CreateScene(regionInfo, m_simulationDataService, m_estateDataService, circuitManager); scene.LoadWorldMap(); return(scene); }
public void RemoveAgentCircuitTest() { AgentCircuitManager agentCircuitManager = new AgentCircuitManager(); agentCircuitManager.AddNewCircuit(circuitcode1, m_agentCircuitData1); agentCircuitManager.AddNewCircuit(circuitcode2, m_agentCircuitData2); agentCircuitManager.RemoveCircuit(circuitcode2); AgentCircuitData agent = agentCircuitManager.GetAgentCircuitData(circuitcode2); Assert.That(agent == null); }
protected override Scene CreateScene(RegionInfo regionInfo, ISimulationDataService simDataService, IEstateDataService estateDataService, AgentCircuitManager circuitManager) { Vector3 regionExtent = new Vector3(regionInfo.RegionSizeX, regionInfo.RegionSizeY, regionInfo.RegionSizeZ); PhysicsScene physicsScene = GetPhysicsScene(regionInfo.RegionName, regionExtent); SceneCommunicationService sceneGridService = new SceneCommunicationService(); return(new Scene( regionInfo, circuitManager, physicsScene, sceneGridService, simDataService, estateDataService, Config, m_version)); }
public HGScene(RegionInfo regInfo, AgentCircuitManager authen, CommunicationsManager commsMan, SceneCommunicationService sceneGridService, StorageManager storeManager, ModuleLoader moduleLoader, bool dumpAssetsToFile, bool physicalPrim, bool SeeIntoRegionFromNeighbor, IConfigSource config, string simulatorVersion) : base(regInfo, authen, commsMan, sceneGridService, storeManager, moduleLoader, dumpAssetsToFile, physicalPrim, SeeIntoRegionFromNeighbor, config, simulatorVersion) { m_log.Info("[HGScene]: Starting HGScene."); m_assMapper = new HGAssetMapper(this); EventManager.OnNewInventoryItemUploadComplete += UploadInventoryItem; }
/// <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, int proxyOffset, IConfigSource configSource, out List <IClientNetworkServer> clientServer) { if (m_log.IsDebugEnabled) { m_log.DebugFormat("{0} called", System.Reflection.MethodBase.GetCurrentMethod().Name); } List <IClientNetworkServer> clientNetworkServers = null; AgentCircuitManager circuitManager = new AgentCircuitManager(); IPAddress listenIP = regionInfo.InternalEndPoint.Address; //if (!IPAddress.TryParse(regionInfo.InternalEndPoint, out listenIP)) // listenIP = IPAddress.Parse("0.0.0.0"); uint port = (uint)regionInfo.InternalEndPoint.Port; if (m_autoCreateClientStack) { clientNetworkServers = m_clientStackManager.CreateServers( listenIP, ref port, proxyOffset, regionInfo.m_allow_alternate_ports, configSource, circuitManager); } else { clientServer = null; } regionInfo.InternalEndPoint.Port = (int)port; Scene scene = CreateScene(regionInfo, m_simulationDataService, m_estateDataService, circuitManager); if (m_autoCreateClientStack) { foreach (IClientNetworkServer clientnetserver in clientNetworkServers) { clientnetserver.AddScene(scene); } } clientServer = clientNetworkServers; scene.LoadWorldMap(); scene.PhysicsScene = GetPhysicsScene(scene.RegionInfo.RegionName); scene.PhysicsScene.RequestAssetMethod = scene.PhysicsRequestAsset; scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised()); scene.PhysicsScene.SetWaterLevel((float)regionInfo.RegionSettings.WaterHeight); return(scene); }
protected override Scene CreateScene(RegionInfo regionInfo, ISimulationDataService simDataService, IEstateDataService estateDataService, AgentCircuitManager circuitManager) { if (m_log.IsDebugEnabled) { m_log.DebugFormat("{0} called", System.Reflection.MethodBase.GetCurrentMethod().Name); } SceneCommunicationService sceneGridService = new SceneCommunicationService(); return(new Scene( regionInfo, circuitManager, sceneGridService, simDataService, estateDataService, Config, m_version)); }
/// <summary> /// Check whether a given client is authorized to connect. /// </summary> /// <param name="useCircuit"></param> /// <param name="circuitManager"></param> /// <param name="sessionInfo"></param> /// <returns></returns> public virtual bool IsClientAuthorized( UseCircuitCodePacket useCircuit, AgentCircuitManager circuitManager, out AuthenticateResponse sessionInfo) { UUID agentId = useCircuit.CircuitCode.ID; UUID sessionId = useCircuit.CircuitCode.SessionID; uint circuitCode = useCircuit.CircuitCode.Code; sessionInfo = circuitManager.AuthenticateSession(sessionId, agentId, circuitCode); if (!sessionInfo.Authorised) { return(false); } return(true); }
/// <summary> /// Add a client for testing /// </summary> /// <param name="scene"></param> /// <param name="testLLUDPServer"></param> /// <param name="testPacketServer"></param> /// <param name="acm">Agent circuit manager used in setting up the stack</param> protected void SetupStack( IScene scene, out TestLLUDPServer testLLUDPServer, out TestLLPacketServer testPacketServer, out AgentCircuitManager acm) { IConfigSource configSource = new IniConfigSource(); ClientStackUserSettings userSettings = new ClientStackUserSettings(); testLLUDPServer = new TestLLUDPServer(); acm = new AgentCircuitManager(); uint port = 666; testLLUDPServer.Initialise(null, ref port, 0, false, configSource, acm); testPacketServer = new TestLLPacketServer(testLLUDPServer, userSettings); testLLUDPServer.LocalScene = scene; }
/// <summary> /// Set up a test scene /// </summary> /// <param name="name">Name of the region</param> /// <param name="id">ID of the region</param> /// <param name="x">X co-ordinate of the region</param> /// <param name="y">Y co-ordinate of the region</param> /// <param name="cm">This should be the same if simulating two scenes within a standalone</param> /// <param name="startServices">Start associated threads for the services used by the scene</param> /// <returns></returns> public static TestScene SetupScene( string name, UUID id, uint x, uint y, TestCommunicationsManager cm, bool startServices) { Console.WriteLine("Setting up test scene {0}", name); RegionInfo regInfo = new RegionInfo(x, y, new IPEndPoint(IPAddress.Loopback, 9000), "127.0.0.1"); regInfo.RegionName = name; regInfo.RegionID = id; AgentCircuitManager acm = new AgentCircuitManager(); SceneCommunicationService scs = new SceneCommunicationService(cm); StorageManager sm = new StorageManager("OpenSim.Data.Null.dll", "", ""); IConfigSource configSource = new IniConfigSource(); TestScene testScene = new TestScene( regInfo, acm, cm, scs, sm, null, false, false, false, configSource, null); IRegionModule capsModule = new CapabilitiesModule(); capsModule.Initialise(testScene, new IniConfigSource()); testScene.AddModule(capsModule.Name, capsModule); IRegionModule godsModule = new GodsModule(); godsModule.Initialise(testScene, new IniConfigSource()); testScene.AddModule(godsModule.Name, godsModule); testScene.SetModuleInterfaces(); testScene.LandChannel = new TestLandChannel(); testScene.LoadWorldMap(); PhysicsPluginManager physicsPluginManager = new PhysicsPluginManager(); physicsPluginManager.LoadPluginsFromAssembly("Physics/OpenSim.Region.Physics.BasicPhysicsPlugin.dll"); testScene.PhysicsScene = physicsPluginManager.GetPhysicsScene("basicphysics", "ZeroMesher", configSource, "test"); if (startServices) { cm.StartServices(); } return(testScene); }
/// <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 = 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); } AsyncScene scene = new AsyncScene(); scene.AddModuleInterfaces(m_openSimBase.ApplicationRegistry.GetInterfaces()); scene.Initialize(regionInfo, dataStore, circuitManager, allClientServers); return scene; }
public void ChangeAgentCircuitCodeTest() { AgentCircuitManager agentCircuitManager = new AgentCircuitManager(); agentCircuitManager.AddNewCircuit(circuitcode1, m_agentCircuitData1); agentCircuitManager.AddNewCircuit(circuitcode2, m_agentCircuitData2); bool result = false; result = agentCircuitManager.TryChangeCiruitCode(circuitcode1, 393930); AgentCircuitData agent = agentCircuitManager.GetAgentCircuitData(393930); AgentCircuitData agent2 = agentCircuitManager.GetAgentCircuitData(circuitcode1); Assert.That(agent != null); Assert.That(agent2 == null); Assert.That(result); }
/// <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; }
protected override Scene CreateScene(RegionInfo regionInfo, StorageManager storageManager, AgentCircuitManager circuitManager) { bool hgrid = ConfigSource.Source.Configs["Startup"].GetBoolean("hypergrid", false); if (hgrid) { return(HGCommands.CreateScene(regionInfo, circuitManager, m_commsManager, storageManager, m_moduleLoader, m_configSettings, m_config, m_version)); } SceneCommunicationService sceneGridService = new SceneCommunicationService(m_commsManager); return(new Scene( regionInfo, circuitManager, m_commsManager, sceneGridService, storageManager, m_moduleLoader, false, m_configSettings.PhysicalPrim, m_configSettings.See_into_region_from_neighbor, m_config.Source, m_version)); }
/// <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); }
/// <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); }
/// <summary> /// Create a server that can set up sessions for virtual world client <-> server communications /// </summary> /// <param name="_listenIP"></param> /// <param name="port"></param> /// <param name="proxyPortOffset"></param> /// <param name="allow_alternate_port"></param> /// <param name="configSource"> /// Can be null, in which case default values are used /// </param> /// <param name="assetCache"></param> /// <param name="authenticateClass"></param> /// <returns></returns> public IClientNetworkServer CreateServer( IPAddress _listenIP, ref uint port, int proxyPortOffset, bool allow_alternate_port, IConfigSource configSource, IAssetCache assetCache, AgentCircuitManager authenticateClass) { if (plugin != null) { IClientNetworkServer server = (IClientNetworkServer)Activator.CreateInstance(pluginAssembly.GetType(plugin.ToString())); server.Initialise( _listenIP, ref port, proxyPortOffset, allow_alternate_port, configSource, assetCache, authenticateClass); return(server); } m_log.Error("[CLIENTSTACK]: Couldn't initialize a new server"); return(null); }
/// <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; }
public void AddAgentCircuitTest() { AgentCircuitManager agentCircuitManager = new AgentCircuitManager(); agentCircuitManager.AddNewCircuit(circuitcode1,m_agentCircuitData1); agentCircuitManager.AddNewCircuit(circuitcode2, m_agentCircuitData2); AgentCircuitData agent = agentCircuitManager.GetAgentCircuitData(circuitcode1); Assert.That((m_agentCircuitData1.AgentID == agent.AgentID)); Assert.That((m_agentCircuitData1.BaseFolder == agent.BaseFolder)); Assert.That((m_agentCircuitData1.CapsPath == agent.CapsPath)); Assert.That((m_agentCircuitData1.child == agent.child)); Assert.That((m_agentCircuitData1.ChildrenCapSeeds.Count == agent.ChildrenCapSeeds.Count)); Assert.That((m_agentCircuitData1.circuitcode == agent.circuitcode)); Assert.That((m_agentCircuitData1.firstname == agent.firstname)); Assert.That((m_agentCircuitData1.InventoryFolder == agent.InventoryFolder)); Assert.That((m_agentCircuitData1.lastname == agent.lastname)); Assert.That((m_agentCircuitData1.SecureSessionID == agent.SecureSessionID)); Assert.That((m_agentCircuitData1.SessionID == agent.SessionID)); Assert.That((m_agentCircuitData1.startpos == agent.startpos)); }
/// <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, out IClientNetworkServer clientServer) { 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"); clientServer = AuroraModuleLoader.LoadPlugin<IClientNetworkServer>(ClientstackDll); clientServer.Initialise( listenIP, ref port, 0, regionInfo.m_allow_alternate_ports, m_config, circuitManager); regionInfo.InternalEndPoint.Port = (int)port; Scene scene = new Scene(regionInfo, circuitManager, this); StartModules(scene); clientServer.AddScene(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 Initialise(IPAddress listenIP, ref uint port, int proxyPortOffsetParm, bool allow_alternate_port, IConfigSource configSource, AgentCircuitManager circuitManager) { m_udpServer = new LLUDPServer(listenIP, ref port, proxyPortOffsetParm, allow_alternate_port, configSource, circuitManager); }
public Scene(RegionInfo regInfo, AgentCircuitManager authen, SceneManager manager) : this(regInfo) { m_sceneManager = manager; m_config = manager.ConfigSource; m_authenticateHandler = authen; m_AuroraEventManager = new AuroraEventManager(); m_eventManager = new EventManager(); m_permissions = new ScenePermissions(this); // Load region settings m_regInfo.RegionSettings = m_sceneManager.SimulationDataService.LoadRegionSettings(m_regInfo.RegionID); m_sceneGraph = new SceneGraph(this, m_regInfo); #region Region Config IConfig aurorastartupConfig = m_config.Configs["AuroraStartup"]; if (aurorastartupConfig != null) { MaxLowValue = aurorastartupConfig.GetFloat("MaxLowValue", -1000); m_DefaultObjectName = aurorastartupConfig.GetString("DefaultObjectName", m_DefaultObjectName); CheckForObjectCulling = aurorastartupConfig.GetBoolean("CheckForObjectCulling", CheckForObjectCulling); //Region specific is still honored here, the RegionInfo checks for it RegionInfo.ObjectCapacity = aurorastartupConfig.GetInt("ObjectCapacity", 80000); } //Animation states IConfig animationConfig = m_config.Configs["Animations"]; if (animationConfig != null) { m_usePreJump = animationConfig.GetBoolean("enableprejump", m_usePreJump); m_useSplatAnimation = animationConfig.GetBoolean("enableSplatAnimation", m_useSplatAnimation); } IConfig packetConfig = m_config.Configs["PacketPool"]; if (packetConfig != null) { PacketPool.Instance.RecyclePackets = packetConfig.GetBoolean("RecyclePackets", true); PacketPool.Instance.RecycleDataBlocks = packetConfig.GetBoolean("RecycleDataBlocks", true); } #endregion Region Config m_basesimfps = 45f; m_basesimphysfps = 45f; m_basesimphysfps = Config.Configs["Physics"].GetFloat("BasePhysicsFPS", 45f); if (m_basesimphysfps > 45f) m_basesimphysfps = 45f; m_basesimfps = Config.Configs["Protection"].GetFloat("BaseRateFramesPerSecond", 45f); if (m_basesimfps > 45f) m_basesimfps = 45f; if (m_basesimphysfps > m_basesimfps) m_basesimphysfps = m_basesimfps; m_updatetimespan = 1 / m_basesimfps; m_physicstimespan = 1 / m_basesimphysfps; #region Startup Complete config EventManager.OnAddToStartupQueue += AddToStartupQueue; EventManager.OnModuleFinishedStartup += FinishedStartup; EventManager.OnStartupComplete += StartupComplete; AddToStartupQueue("Startup"); #endregion }
public Scene(RegionInfo regInfo, AgentCircuitManager authen, SceneCommunicationService sceneGridService, IConfigSource config, string simulatorVersion, ISimulationDataService simDataService, IStatsCollector stats) { //THIS NEEDS RESET TO FIX RESTARTS shuttingdown = false; m_stats = stats; m_config = config; Random random = new Random(); m_lastAllocatedLocalId = (uint)(random.NextDouble() * (double)(uint.MaxValue / 2)) + (uint)(uint.MaxValue / 4); m_authenticateHandler = authen; m_sceneGridService = sceneGridService; m_regInfo = regInfo; m_lastUpdate = Util.EnvironmentTickCount(); BordersLocked = true; Border northBorder = new Border(); northBorder.BorderLine = new Vector3(float.MinValue, float.MaxValue, (int)Constants.RegionSize); //<--- northBorder.CrossDirection = Cardinals.N; NorthBorders.Add(northBorder); Border southBorder = new Border(); southBorder.BorderLine = new Vector3(float.MinValue, float.MaxValue, 0); //---> southBorder.CrossDirection = Cardinals.S; SouthBorders.Add(southBorder); Border eastBorder = new Border(); eastBorder.BorderLine = new Vector3(float.MinValue, float.MaxValue, (int)Constants.RegionSize); //<--- eastBorder.CrossDirection = Cardinals.E; EastBorders.Add(eastBorder); Border westBorder = new Border(); westBorder.BorderLine = new Vector3(float.MinValue, float.MaxValue, 0); //---> westBorder.CrossDirection = Cardinals.W; WestBorders.Add(westBorder); BordersLocked = false; AuroraEventManager = new AuroraEventManager(); m_eventManager = new EventManager(); m_permissions = new ScenePermissions(this); m_asyncSceneObjectDeleter = new AsyncSceneObjectGroupDeleter(this); m_asyncSceneObjectDeleter.Enabled = true; m_SimulationDataService = simDataService; // Load region settings m_regInfo.RegionSettings = m_SimulationDataService.LoadRegionSettings(m_regInfo.RegionID); FindEstateInfo(); //Bind Storage Manager functions to some land manager functions for this scene IParcelServiceConnector conn = DataManager.RequestPlugin<IParcelServiceConnector>(); if(conn != null) { EventManager.OnLandObjectAdded += new EventManager.LandObjectAdded(conn.StoreLandObject); EventManager.OnLandObjectRemoved += new EventManager.LandObjectRemoved(conn.RemoveLandObject); } else { EventManager.OnLandObjectAdded += new EventManager.LandObjectAdded(SimulationDataService.StoreLandObject); EventManager.OnLandObjectRemoved += new EventManager.LandObjectRemoved(SimulationDataService.RemoveLandObject); } m_sceneGraph = new SceneGraph(this, m_regInfo); StatsReporter = new SimStatsReporter(this); StatsReporter.OnSendStatsResult += SendSimStatsPackets; StatsReporter.OnStatsIncorrect += m_sceneGraph.RecalculateStats; m_simulatorVersion = simulatorVersion + " (" + Util.GetRuntimeInformation() + ")"; #region Region Config try { DirectionsToBlockChildAgents = new bool[3,3]; DirectionsToBlockChildAgents.Initialize(); IConfig aurorastartupConfig = m_config.Configs["AuroraStartup"]; if (aurorastartupConfig != null) { RunScriptsInAttachments = aurorastartupConfig.GetBoolean("AllowRunningOfScriptsInAttachments", false); m_UseSelectionParticles = aurorastartupConfig.GetBoolean("UseSelectionParticles", true); EnableFakeRaycasting = aurorastartupConfig.GetBoolean("EnableFakeRaycasting", false); MaxLowValue = aurorastartupConfig.GetFloat("MaxLowValue", -1000); Util.RegionViewSize = aurorastartupConfig.GetInt("RegionSightSize", 1); Util.CloseLocalRegions = aurorastartupConfig.GetBoolean("CloseLocalAgents", true); m_DefaultObjectName = aurorastartupConfig.GetString("DefaultObjectName", m_DefaultObjectName); CheckForObjectCulling = aurorastartupConfig.GetBoolean("CheckForObjectCulling", CheckForObjectCulling); SetObjectCapacity(aurorastartupConfig.GetInt("ObjectCapacity", ObjectCapacity)); } IConfig regionConfig = m_config.Configs[this.RegionInfo.RegionName]; if (regionConfig != null) { #region Block Child Agents config // [{0,2}, {1, 2}, {2,2}] // [{0,1}, {1, 1}, {2,1}] 1,1 is the current region // [{0,0}, {1, 0}, {2,0}] //SouthWest DirectionsToBlockChildAgents[0, 0] = regionConfig.GetBoolean("BlockChildAgentsSouthWest", false); //South DirectionsToBlockChildAgents[1, 0] = regionConfig.GetBoolean("BlockChildAgentsSouth", false); //SouthEast DirectionsToBlockChildAgents[2, 0] = regionConfig.GetBoolean("BlockChildAgentsSouthEast", false); //West DirectionsToBlockChildAgents[0, 1] = regionConfig.GetBoolean("BlockChildAgentsWest", false); //East DirectionsToBlockChildAgents[2, 1] = regionConfig.GetBoolean("BlockChildAgentsEast", false); //NorthWest DirectionsToBlockChildAgents[0, 2] = regionConfig.GetBoolean("BlockChildAgentsNorthWest", false); //North DirectionsToBlockChildAgents[1, 2] = regionConfig.GetBoolean("BlockChildAgentsNorth", false); //NorthEast DirectionsToBlockChildAgents[2, 2] = regionConfig.GetBoolean("BlockChildAgentsNorthEast", false); #endregion } // Region config overrides global config // IConfig startupConfig = m_config.Configs["Startup"]; //Animation states IConfig animationConfig = m_config.Configs["Animations"]; if (animationConfig != null) { m_UseNewStyleMovement = animationConfig.GetBoolean("enableNewMovement", m_UseNewStyleMovement); m_usePreJump = animationConfig.GetBoolean("enableprejump", m_usePreJump); m_useSplatAnimation = animationConfig.GetBoolean("enableSplatAnimation", m_useSplatAnimation); } m_seeIntoRegionFromNeighbor = RegionInfo.SeeIntoThisSimFromNeighbor; m_trustBinaries = RegionInfo.TrustBinariesFromForeignSims; m_allowScriptCrossings = RegionInfo.AllowScriptCrossing; IConfig persistanceConfig = m_config.Configs["Persistance"]; if (persistanceConfig != null) { m_dontPersistBefore = persistanceConfig.GetLong("MinimumTimeBeforePersistenceConsidered", DEFAULT_MIN_TIME_FOR_PERSISTENCE); m_dontPersistBefore *= 10000000; m_persistAfter = persistanceConfig.GetLong("MaximumTimeBeforePersistenceConsidered", DEFAULT_MAX_TIME_FOR_PERSISTENCE); m_persistAfter *= 10000000; } else { m_dontPersistBefore = DEFAULT_MIN_TIME_FOR_PERSISTENCE; m_dontPersistBefore *= 10000000; m_persistAfter = DEFAULT_MAX_TIME_FOR_PERSISTENCE; m_persistAfter *= 10000000; } IConfig scriptEngineConfig = m_config.Configs["ScriptEngines"]; if (scriptEngineConfig != null) m_defaultScriptEngine = scriptEngineConfig.GetString("DefaultScriptEngine", "AuroraDotNetEngine"); IConfig packetConfig = m_config.Configs["PacketPool"]; if (packetConfig != null) { PacketPool.Instance.RecyclePackets = packetConfig.GetBoolean("RecyclePackets", true); PacketPool.Instance.RecycleDataBlocks = packetConfig.GetBoolean("RecycleDataBlocks", true); } m_strictAccessControl = startupConfig.GetBoolean("StrictAccessControl", m_strictAccessControl); } catch { m_log.Warn("[SCENE]: Failed to load StartupConfig"); } #endregion Region Config #region Interest Management if (m_config != null) { IConfig interestConfig = m_config.Configs["InterestManagement"]; if (interestConfig != null) { string update_prioritization_scheme = interestConfig.GetString("UpdatePrioritizationScheme", "Time").Trim().ToLower(); try { m_priorityScheme = (UpdatePrioritizationSchemes)Enum.Parse(typeof(UpdatePrioritizationSchemes), update_prioritization_scheme, true); } catch (Exception) { m_log.Warn("[PRIORITIZER]: UpdatePrioritizationScheme was not recognized, setting to default prioritizer Time"); m_priorityScheme = UpdatePrioritizationSchemes.Time; } m_reprioritizationEnabled = interestConfig.GetBoolean("ReprioritizationEnabled", true); m_reprioritizationInterval = interestConfig.GetDouble("ReprioritizationInterval", 5000.0); m_rootReprioritizationDistance = interestConfig.GetDouble("RootReprioritizationDistance", 10.0); m_childReprioritizationDistance = interestConfig.GetDouble("ChildReprioritizationDistance", 20.0); } } //m_log.Info("[SCENE]: Using the " + m_priorityScheme + " prioritization scheme"); #endregion Interest Management #region Startup Complete config EventManager.OnAddToStartupQueue += AddToStartupQueue; EventManager.OnFinishedStartup += FinishedStartup; EventManager.OnStartupComplete += StartupComplete; AddToStartupQueue("Startup"); #endregion LoadWorldMap(); //Add stats handlers MainServer.Instance.AddStreamHandler(new RegionStatsHandler(RegionInfo)); }
public void Initialize(RegionInfo regionInfo, ISimulationDataStore dataStore, AgentCircuitManager authen, List<IClientNetworkServer> clientServers) { Initialize(regionInfo); //Set up the clientServer m_clientServers = clientServers; foreach (IClientNetworkServer clientServer in clientServers) { clientServer.AddScene(this); } m_sceneManager = RequestModuleInterface<ISceneManager>(); m_simDataStore = dataStore; m_config = m_sceneManager.ConfigSource; m_authenticateHandler = authen; m_AuroraEventManager = new AuroraEventManager(); m_eventManager = new EventManager(); m_permissions = new ScenePermissions(this); m_sceneGraph = new SceneGraph(this, m_regInfo); #region Region Config IConfig aurorastartupConfig = m_config.Configs["AuroraStartup"]; if (aurorastartupConfig != null) { //Region specific is still honored here, the RegionInfo checks for it, and if it is 0, it didn't set it if (RegionInfo.ObjectCapacity == 0) RegionInfo.ObjectCapacity = aurorastartupConfig.GetInt("ObjectCapacity", 80000); } IConfig packetConfig = m_config.Configs["PacketPool"]; if (packetConfig != null) { PacketPool.Instance.RecyclePackets = packetConfig.GetBoolean("RecyclePackets", true); PacketPool.Instance.RecycleDataBlocks = packetConfig.GetBoolean("RecycleDataBlocks", true); } #endregion Region Config m_basesimfps = 45f; m_basesimphysfps = 45f; m_basesimphysfps = Config.Configs["Physics"].GetFloat("BasePhysicsFPS", 45f); if (m_basesimphysfps > 45f) m_basesimphysfps = 45f; m_basesimfps = Config.Configs["Protection"].GetFloat("BaseRateFramesPerSecond", 45f); if (m_basesimfps > 45f) m_basesimfps = 45f; if (m_basesimphysfps > m_basesimfps) m_basesimphysfps = m_basesimfps; m_updatetimespan = 1000/m_basesimfps; m_physicstimespan = 1000/m_basesimphysfps; #region Startup Complete config EventManager.OnAddToStartupQueue += AddToStartupQueue; EventManager.OnModuleFinishedStartup += FinishedStartup; //EventManager.OnStartupComplete += StartupComplete; AddToStartupQueue("Startup"); #endregion }
public void Initialise (int port, IConfigSource configSource, AgentCircuitManager circuitManager) { base.Initialise (IPAddress.Any, port); #region Environment.TickCount Measurement // Measure the resolution of Environment.TickCount TickCountResolution = 0f; for (int i = 0; i < 5; i++) { int start = Environment.TickCount; int now = start; while (now == start) now = Environment.TickCount; TickCountResolution += (float)(now - start) * 0.2f; } //m_log.Info("[LLUDPSERVER]: Average Environment.TickCount resolution: " + TickCountResolution + "ms"); TickCountResolution = (float)Math.Ceiling(TickCountResolution); #endregion Environment.TickCount Measurement m_circuitManager = circuitManager; int sceneThrottleBps = 0; IConfig config = configSource.Configs["ClientStack.LindenUDP"]; if (config != null) { m_asyncPacketHandling = config.GetBoolean("async_packet_handling", false); m_recvBufferSize = config.GetInt("client_socket_rcvbuf_size", 0); sceneThrottleBps = config.GetInt("scene_throttle_max_bps", 0); PrimUpdatesPerCallback = config.GetInt("PrimUpdatesPerCallback", 60); AvatarUpdatesPerCallBack = config.GetInt("AvatarUpdatesPerCallback", 80); TextureSendLimit = config.GetInt("TextureSendLimit", 25); m_defaultRTO = config.GetInt("DefaultRTO", 1000); m_maxRTO = config.GetInt("MaxRTO", 20000); ClientTimeOut = config.GetInt("ClientTimeOut", 500); m_disableFacelights = config.GetBoolean("DisableFacelights", false); } else { PrimUpdatesPerCallback = 60; AvatarUpdatesPerCallBack = 80; TextureSendLimit = 25; ClientTimeOut = 500; } #region BinaryStats config = configSource.Configs["Statistics.Binary"]; m_shouldCollectStats = false; if (config != null) { if (config.Contains("enabled") && config.GetBoolean("enabled")) { if (config.Contains("collect_packet_headers")) m_shouldCollectStats = config.GetBoolean("collect_packet_headers"); if (config.Contains("packet_headers_period_seconds")) { binStatsMaxFilesize = TimeSpan.FromSeconds(config.GetInt("region_stats_period_seconds")); } if (config.Contains("stats_dir")) { binStatsDir = config.GetString("stats_dir"); } } else { m_shouldCollectStats = false; } } #endregion BinaryStats if(sceneThrottleBps != 0) m_throttle = new TokenBucket(null, sceneThrottleBps, 0); m_throttleRates = new ThrottleRates(configSource); }
/// <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, int proxyOffset, IConfigSource configSource, out IClientNetworkServer clientServer) { AgentCircuitManager circuitManager = new AgentCircuitManager(); IPAddress listenIP = regionInfo.InternalEndPoint.Address; //if (!IPAddress.TryParse(regionInfo.InternalEndPoint, 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"); clientServer = Aurora.Framework.AuroraModuleLoader.LoadPlugin<IClientNetworkServer>(ClientstackDll, "IClientNetworkServer"); clientServer.Initialise( listenIP, ref port, proxyOffset, regionInfo.m_allow_alternate_ports, m_config, circuitManager); regionInfo.InternalEndPoint.Port = (int)port; SceneCommunicationService sceneGridService = new SceneCommunicationService(); Scene scene = new Scene(regionInfo, circuitManager, sceneGridService, m_config, m_OpenSimBase.Version, m_simulationDataService, m_OpenSimBase.Stats); FindEstateInfo(scene); clientServer.AddScene(scene); m_clientServers.Add(clientServer); //Do this here so that we don't have issues later when startup complete messages start coming in Add(scene); scene.PhysicsScene = GetPhysicsScene(m_config, scene.RegionInfo.RegionName); return scene; }