/// <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 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);
}
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);
}
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);
}
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;
}
