Пример #1
0
 /// <summary>
 /// User services used when OpenSim is running in standalone mode.
 /// </summary>
 /// <param name="defaultHomeLocX"></param>
 /// <param name="defaultHomeLocY"></param>
 /// <param name="commsManager"></param>
 public LocalUserServices(
     uint defaultHomeLocX, uint defaultHomeLocY, CommunicationsManager commsManager)
     : base(commsManager)
 {
     m_defaultHomeX = defaultHomeLocX;
     m_defaultHomeY = defaultHomeLocY;
 }
 public InventoryArchiveReadRequest(
     CachedUserInfo userInfo, string invPath, Stream loadStream, CommunicationsManager commsManager)
 {
     m_userInfo = userInfo;
     m_invPath = invPath;
     m_loadStream = loadStream;
     m_commsManager = commsManager;
 }
Пример #3
0
 public InventoryArchiveReadRequest(
     CachedUserInfo userInfo, string invPath, string loadPath, CommunicationsManager commsManager)
     : this(
         userInfo,
         invPath,
         new GZipStream(new FileStream(loadPath, FileMode.Open), CompressionMode.Decompress),
         commsManager)
 {
 }
Пример #4
0
 public TestScene(
     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)
 {
 }
Пример #5
0
 /// <summary>
 /// Create a test user with a standard inventory
 /// </summary>
 /// <param name="commsManager"></param>
 /// <param name="userId">Explicit user id to use for user creation</param>
 /// <returns></returns>
 public static CachedUserInfo CreateUserWithInventory(CommunicationsManager commsManager, UUID userId)
 {                        
     LocalUserServices lus = (LocalUserServices)commsManager.UserService;           
     lus.AddUser("Bill", "Bailey", "troll", "*****@*****.**", 1000, 1000, userId);
     
     CachedUserInfo userInfo = commsManager.UserProfileCacheService.GetUserDetails(userId);
     userInfo.FetchInventory();
     
     return userInfo;
 }
Пример #6
0
//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

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

            return
                new HGScene(
                    regionInfo, circuitManager, m_commsManager, sceneGridService, storageManager,
                    m_moduleLoader, false, m_configSettings.PhysicalPrim,
                    m_configSettings.See_into_region_from_neighbor, m_config.Source, m_version);
        }
Пример #7
0
 /// <summary>
 /// Create a test user with a standard inventory
 /// </summary>
 /// <param name="commsManager"></param>
 /// <param name="firstName">First name of user</param>
 /// <param name="lastName">Last name of user</param>
 /// <param name="userId">User ID</param>
 /// <param name="callback">
 /// Callback to invoke when inventory has been loaded.  This is required because
 /// loading may be asynchronous, even on standalone
 /// </param>
 /// <returns></returns>
 public static CachedUserInfo CreateUserWithInventory(
     CommunicationsManager commsManager, string firstName, string lastName, 
     UUID userId, OnInventoryReceivedDelegate callback)
 {
     LocalUserServices lus = (LocalUserServices)commsManager.UserService;
     lus.AddUser(firstName, lastName, "troll", "*****@*****.**", 1000, 1000, userId);
     
     CachedUserInfo userInfo = commsManager.UserProfileCacheService.GetUserDetails(userId);
     userInfo.OnInventoryReceived += callback;
     userInfo.FetchInventory();
     
     return userInfo;
 }
Пример #8
0
        //private UserDataBase m_userDb;

        public OGS1UserDataPlugin(CommunicationsManager commsManager, ConfigSettings settings)
        {
            m_log.DebugFormat("[OGS1 USER SERVICES]: {0} initialized", Name);
            m_commsManager = commsManager;

            //we short circuit some OGS calls to the user server due to numerous problems with user
            //profile data causing issues with data transfer via XML 

            //TODO: This sucks, all of this should be stripped out to remove the reliance on the 
            //user server. There is no reason to have yet another point of failure between the sim
            //and the database
            //m_userDb = 
        }
Пример #9
0
        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;
        }
Пример #10
0
 public void Initialise(Scene scene, IConfigSource source)
 {            
     if (m_scenes.Count == 0)
     {
         scene.RegisterModuleInterface<IInventoryArchiverModule>(this);
         CommsManager = scene.CommsManager;
         OnInventoryArchiveSaved += SaveInvConsoleCommandCompleted;
         
         scene.AddCommand(
             this, "load iar",
             "load iar <first> <last> <inventory path> [<archive path>]",
             "Load user inventory archive.  EXPERIMENTAL, PLEASE DO NOT USE YET", HandleLoadInvConsoleCommand); 
         
         scene.AddCommand(
             this, "save iar",
             "save iar <first> <last> <inventory path> [<archive path>]",
             "Save user inventory archive.  EXPERIMENTAL, PLEASE DO NOT USE YET", HandleSaveInvConsoleCommand);           
     }
                 
     m_scenes[scene.RegionInfo.RegionID] = scene;            
 }
Пример #11
0
        public Scene(RegionInfo regInfo, AgentCircuitManager authen,
                     CommunicationsManager commsMan, SceneCommunicationService sceneGridService,
                     StorageManager storeManager,
                     ModuleLoader moduleLoader, bool dumpAssetsToFile, bool physicalPrim,
                     bool SeeIntoRegionFromNeighbor, IConfigSource config, string simulatorVersion)
        {
            m_config = config;

            Random random = new Random();
            m_lastAllocatedLocalId = (uint)(random.NextDouble() * (double)(uint.MaxValue/2))+(uint)(uint.MaxValue/4);
            m_moduleLoader = moduleLoader;
            m_authenticateHandler = authen;
            CommsManager = commsMan;
            m_sceneGridService = sceneGridService;
            m_storageManager = storeManager;
            m_regInfo = regInfo;
            m_regionHandle = m_regInfo.RegionHandle;
            m_regionName = m_regInfo.RegionName;
            m_datastore = m_regInfo.DataStore;

            m_physicalPrim = physicalPrim;
            m_seeIntoRegionFromNeighbor = SeeIntoRegionFromNeighbor;

            m_eventManager = new EventManager();
            m_permissions = new ScenePermissions(this);

            m_asyncSceneObjectDeleter = new AsyncSceneObjectGroupDeleter(this);
            m_asyncSceneObjectDeleter.Enabled = true;

            // Load region settings
            m_regInfo.RegionSettings = m_storageManager.DataStore.LoadRegionSettings(m_regInfo.RegionID);
            if (m_storageManager.EstateDataStore != null)
            {
                m_regInfo.EstateSettings = m_storageManager.EstateDataStore.LoadEstateSettings(m_regInfo.RegionID);
            }

            //Bind Storage Manager functions to some land manager functions for this scene
            EventManager.OnLandObjectAdded +=
                new EventManager.LandObjectAdded(m_storageManager.DataStore.StoreLandObject);
            EventManager.OnLandObjectRemoved +=
                new EventManager.LandObjectRemoved(m_storageManager.DataStore.RemoveLandObject);

            m_sceneGraph = new SceneGraph(this, m_regInfo);

            // If the scene graph has an Unrecoverable error, restart this sim.
            // Currently the only thing that causes it to happen is two kinds of specific
            // Physics based crashes.
            //
            // Out of memory
            // Operating system has killed the plugin
            m_sceneGraph.UnRecoverableError += RestartNow;

            RegisterDefaultSceneEvents();

            DumpAssetsToFile = dumpAssetsToFile;

            m_scripts_enabled = !RegionInfo.RegionSettings.DisableScripts;

            m_physics_enabled = !RegionInfo.RegionSettings.DisablePhysics;

            StatsReporter = new SimStatsReporter(this);
            StatsReporter.OnSendStatsResult += SendSimStatsPackets;
            StatsReporter.OnStatsIncorrect += m_sceneGraph.RecalculateStats;

            StatsReporter.SetObjectCapacity(objectCapacity);

            m_simulatorVersion = simulatorVersion
                + " (OS " + Util.GetOperatingSystemInformation() + ")"
                + " ChilTasks:" + m_seeIntoRegionFromNeighbor.ToString()
                + " PhysPrim:" + m_physicalPrim.ToString();

            try
            {
                // Region config overrides global config
                //
                IConfig startupConfig = m_config.Configs["Startup"];

                //Animation states
                m_useFlySlow = startupConfig.GetBoolean("enableflyslow", false);
                // TODO: Change default to true once the feature is supported
                m_usePreJump = startupConfig.GetBoolean("enableprejump", false);

                m_maxNonphys = startupConfig.GetFloat("NonPhysicalPrimMax", m_maxNonphys);
                if (RegionInfo.NonphysPrimMax > 0)
                {
                    m_maxNonphys = RegionInfo.NonphysPrimMax;
                }

                m_maxPhys = startupConfig.GetFloat("PhysicalPrimMax", m_maxPhys);

                if (RegionInfo.PhysPrimMax > 0)
                {
                    m_maxPhys = RegionInfo.PhysPrimMax;
                }

                // Here, if clamping is requested in either global or
                // local config, it will be used
                //
                m_clampPrimSize = startupConfig.GetBoolean("ClampPrimSize", m_clampPrimSize);
                if (RegionInfo.ClampPrimSize)
                {
                    m_clampPrimSize = true;
                }

                m_trustBinaries = startupConfig.GetBoolean("TrustBinaries", m_trustBinaries);
                m_allowScriptCrossings = startupConfig.GetBoolean("AllowScriptCrossing", m_allowScriptCrossings);
                m_dontPersistBefore =
                  startupConfig.GetLong("MinimumTimeBeforePersistenceConsidered", DEFAULT_MIN_TIME_FOR_PERSISTENCE);
                m_dontPersistBefore *= 10000000;
                m_persistAfter =
                  startupConfig.GetLong("MaximumTimeBeforePersistenceConsidered", DEFAULT_MAX_TIME_FOR_PERSISTENCE);
                m_persistAfter *= 10000000;

                m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "DotNetEngine");

                m_maxPrimsPerFrame = startupConfig.GetInt("MaxPrimsPerFrame", 200);
                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");
            }
        }
 public SceneCommunicationService(CommunicationsManager commsMan)
 {
     m_commsProvider = commsMan;
     m_agentsInTransit = new List<UUID>();
 }
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="commsManager"></param>
        public UserProfileManager(CommunicationsManager commsManager)
        {
            m_commsManager = commsManager;
            m_userInfoByUUID.OnItemPurged += _cachedUserInfo_OnItemPurged;

            m_isUserServer = System.Diagnostics.Process.GetCurrentProcess().ProcessName.Contains("OpenSim.Grid.UserServer");
        }
Пример #14
0
        public Scene(RegionInfo regInfo, AgentCircuitManager authen,
                     CommunicationsManager commsMan, SceneCommunicationService sceneGridService,
                     StorageManager storeManager,
                     ModuleLoader moduleLoader, bool dumpAssetsToFile, bool physicalPrim,
                     bool SeeIntoRegionFromNeighbor, IConfigSource config, string simulatorVersion)
        {
            m_config = config;

            Random random = new Random();
            
            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;

            m_lastAllocatedLocalId = (uint)(random.NextDouble() * (double)(uint.MaxValue/2))+(uint)(uint.MaxValue/4);
            m_moduleLoader = moduleLoader;
            m_authenticateHandler = authen;
            CommsManager = commsMan;
            m_sceneGridService = sceneGridService;
            m_storageManager = storeManager;
            m_regInfo = regInfo;
            m_regionHandle = m_regInfo.RegionHandle;
            m_regionName = m_regInfo.RegionName;
            m_datastore = m_regInfo.DataStore;
            m_lastUpdate = Util.EnvironmentTickCount();

            m_physicalPrim = physicalPrim;
            m_seeIntoRegionFromNeighbor = SeeIntoRegionFromNeighbor;

            m_eventManager = new EventManager();
            m_permissions = new ScenePermissions(this);

            m_asyncSceneObjectDeleter = new AsyncSceneObjectGroupDeleter(this);
            m_asyncSceneObjectDeleter.Enabled = true;

            // Load region settings
            m_regInfo.RegionSettings = m_storageManager.DataStore.LoadRegionSettings(m_regInfo.RegionID);
            if (m_storageManager.EstateDataStore != null)
            {
                m_regInfo.EstateSettings = m_storageManager.EstateDataStore.LoadEstateSettings(m_regInfo.RegionID);
            }

            //Bind Storage Manager functions to some land manager functions for this scene
            EventManager.OnLandObjectAdded +=
                new EventManager.LandObjectAdded(m_storageManager.DataStore.StoreLandObject);
            EventManager.OnLandObjectRemoved +=
                new EventManager.LandObjectRemoved(m_storageManager.DataStore.RemoveLandObject);

            m_sceneGraph = new SceneGraph(this, m_regInfo);

            // If the scene graph has an Unrecoverable error, restart this sim.
            // Currently the only thing that causes it to happen is two kinds of specific
            // Physics based crashes.
            //
            // Out of memory
            // Operating system has killed the plugin
            m_sceneGraph.UnRecoverableError += RestartNow;

            RegisterDefaultSceneEvents();

            DumpAssetsToFile = dumpAssetsToFile;

            m_scripts_enabled = !RegionInfo.RegionSettings.DisableScripts;

            m_physics_enabled = !RegionInfo.RegionSettings.DisablePhysics;

            StatsReporter = new SimStatsReporter(this);
            StatsReporter.OnSendStatsResult += SendSimStatsPackets;
            StatsReporter.OnStatsIncorrect += m_sceneGraph.RecalculateStats;

            StatsReporter.SetObjectCapacity(objectCapacity);

            // Old
            /*
            m_simulatorVersion = simulatorVersion
                + " (OS " + Util.GetOperatingSystemInformation() + ")"
                + " ChilTasks:" + m_seeIntoRegionFromNeighbor.ToString()
                + " PhysPrim:" + m_physicalPrim.ToString();
            */

            m_simulatorVersion = simulatorVersion + " (" + Util.GetRuntimeInformation() + ")";

            try
            {
                // Region config overrides global config
                //
                IConfig startupConfig = m_config.Configs["Startup"];

                // Should we try to run loops synchronously or asynchronously?
                m_useAsyncWhenPossible = startupConfig.GetBoolean("use_async_when_possible", false);

                //Animation states
                m_useFlySlow = startupConfig.GetBoolean("enableflyslow", false);
                // TODO: Change default to true once the feature is supported
                m_usePreJump = startupConfig.GetBoolean("enableprejump", false);

                m_maxNonphys = startupConfig.GetFloat("NonPhysicalPrimMax", m_maxNonphys);
                if (RegionInfo.NonphysPrimMax > 0)
                {
                    m_maxNonphys = RegionInfo.NonphysPrimMax;
                }

                m_maxPhys = startupConfig.GetFloat("PhysicalPrimMax", m_maxPhys);

                if (RegionInfo.PhysPrimMax > 0)
                {
                    m_maxPhys = RegionInfo.PhysPrimMax;
                }

                // Here, if clamping is requested in either global or
                // local config, it will be used
                //
                m_clampPrimSize = startupConfig.GetBoolean("ClampPrimSize", m_clampPrimSize);
                if (RegionInfo.ClampPrimSize)
                {
                    m_clampPrimSize = true;
                }

                m_trustBinaries = startupConfig.GetBoolean("TrustBinaries", m_trustBinaries);
                m_allowScriptCrossings = startupConfig.GetBoolean("AllowScriptCrossing", m_allowScriptCrossings);
                m_dontPersistBefore =
                  startupConfig.GetLong("MinimumTimeBeforePersistenceConsidered", DEFAULT_MIN_TIME_FOR_PERSISTENCE);
                m_dontPersistBefore *= 10000000;
                m_persistAfter =
                  startupConfig.GetLong("MaximumTimeBeforePersistenceConsidered", DEFAULT_MAX_TIME_FOR_PERSISTENCE);
                m_persistAfter *= 10000000;

                m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "XEngine");

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

                IConfig interest_management_config = m_config.Configs["InterestManagement"];
                if (interest_management_config != null)
                {
                    string update_prioritization_scheme = interest_management_config.GetString("UpdatePrioritizationScheme", "Time").Trim().ToLower();
                    switch (update_prioritization_scheme)
                    {
                        case "time":
                            m_update_prioritization_scheme = UpdatePrioritizationSchemes.Time;
                            break;
                        case "distance":
                            m_update_prioritization_scheme = UpdatePrioritizationSchemes.Distance;
                            break;
                        case "simpleangulardistance":
                            m_update_prioritization_scheme = UpdatePrioritizationSchemes.SimpleAngularDistance;
                            break;
                        case "frontback":
                            m_update_prioritization_scheme = UpdatePrioritizationSchemes.FrontBack;
                            break;
                        default:
                            m_log.Warn("[SCENE]: UpdatePrioritizationScheme was not recognized, setting to default settomg of Time");
                            m_update_prioritization_scheme = UpdatePrioritizationSchemes.Time;
                            break;
                    }

                    m_reprioritization_enabled = interest_management_config.GetBoolean("ReprioritizationEnabled", true);
                    m_reprioritization_interval = interest_management_config.GetDouble("ReprioritizationInterval", 5000.0);
                    m_root_reprioritization_distance = interest_management_config.GetDouble("RootReprioritizationDistance", 10.0);
                    m_child_reprioritization_distance = interest_management_config.GetDouble("ChildReprioritizationDistance", 20.0);
                }

                m_log.Info("[SCENE]: Using the " + m_update_prioritization_scheme + " prioritization scheme");

                #region BinaryStats

                try
                {
                    IConfig statConfig = m_config.Configs["Statistics.Binary"];
                    if (statConfig.Contains("enabled") && statConfig.GetBoolean("enabled"))
                    {
                        if (statConfig.Contains("collect_region_stats"))
                        {
                            if (statConfig.GetBoolean("collect_region_stats"))
                            {
                                // if enabled, add us to the event. If not enabled, I won't get called
                                StatsReporter.OnSendStatsResult += LogSimStats;
                            }
                        }
                        if (statConfig.Contains("region_stats_period_seconds"))
                        {
                            m_statLogPeriod = TimeSpan.FromSeconds(statConfig.GetInt("region_stats_period_seconds"));
                        }
                        if (statConfig.Contains("stats_dir"))
                        {
                            m_statsDir = statConfig.GetString("stats_dir");
                        }
                    }
                }
                catch
                {
                    // if it doesn't work, we don't collect anything
                }

                #endregion BinaryStats
            }
            catch
            {
                m_log.Warn("[SCENE]: Failed to load StartupConfig");
            }
        }
Пример #15
0
 public OGS1UserDataPlugin(CommunicationsManager commsManager)
 {
     m_log.DebugFormat("[OGS1 USER SERVICES]: {0} initialized", Name);
     m_commsManager = commsManager;
 }
Пример #16
0
        protected virtual void InitialiseHGGridServices(LibraryRootFolder libraryRootFolder)
        {
            m_commsManager 
                = new HGCommunicationsGridMode(
                    m_openSim.NetServersInfo,
                    m_openSim.SceneManager, libraryRootFolder);

            m_httpServer.AddStreamHandler(new OpenSim.SimStatusHandler());
            m_httpServer.AddStreamHandler(new OpenSim.XSimStatusHandler(m_openSim));
            if (m_openSim.userStatsURI != String.Empty)
                m_httpServer.AddStreamHandler(new OpenSim.UXSimStatusHandler(m_openSim));
        }
        /// <summary>
        /// Initializes the backend services for standalone mode, and registers some http handlers
        /// </summary>
        /// <param name="libraryRootFolder"></param>
        protected virtual void InitializeStandaloneServices(LibraryRootFolder libraryRootFolder)
        {
            m_commsManager
                = new CommunicationsLocal(
                    m_openSim.ConfigurationSettings, m_openSim.NetServersInfo, 
                    m_httpServer, m_openSim.AssetCache, libraryRootFolder);

            CreateGridInfoService();
        }
Пример #18
0
 public HGSceneCommunicationService(CommunicationsManager commsMan, IHyperlink hg) : base(commsMan)
 {
     m_hg = hg;
 }
Пример #19
0
 public UserDataBaseService(CommunicationsManager commsManager)
     : base(commsManager)
 {
 }
Пример #20
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="commsManager"></param>
        public UserManagerBase(CommunicationsManager commsManager)
        {
            m_commsManager = commsManager;
            _cachedProfileData.OnItemPurged += _cachedProfileData_OnItemPurged;

            m_isUserServer = System.Diagnostics.Process.GetCurrentProcess().ProcessName.Contains("OpenSim.Grid.UserServer");
        }
Пример #21
0
 /// <summary>
 /// Create a test user with a standard inventory
 /// </summary>
 /// <param name="commsManager"></param>
 /// <param name="callback">
 /// Callback to invoke when inventory has been loaded.  This is required because
 /// loading may be asynchronous, even on standalone
 /// </param>
 /// <returns></returns>
 public static CachedUserInfo CreateUserWithInventory(
     CommunicationsManager commsManager, OnInventoryReceivedDelegate callback)
 {
     UUID userId = UUID.Parse("00000000-0000-0000-0000-000000000099");
     return CreateUserWithInventory(commsManager, userId, callback);
 }
Пример #22
0
 /// <summary>
 /// Create a test user with a standard inventory
 /// </summary>
 /// <param name="commsManager"></param>
 /// <param name="userId">User ID</param>
 /// <param name="callback">
 /// Callback to invoke when inventory has been loaded.  This is required because
 /// loading may be asynchronous, even on standalone
 /// </param>
 /// <returns></returns>
 public static CachedUserInfo CreateUserWithInventory(
     CommunicationsManager commsManager, UUID userId, OnInventoryReceivedDelegate callback)
 {
     return CreateUserWithInventory(commsManager, "Bill", "Bailey", userId, callback);
 }
Пример #23
0
 // Constructor called when running in standalone
 public HGUserServices(CommunicationsManager commsManager, LocalUserServices local)
     : base(commsManager)
 {
     m_localUserServices = local;
 }
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="commsManager"></param>
 public UserManagerBase(CommunicationsManager commsManager)
 {
     m_commsManager = commsManager;
 }
Пример #25
0
 protected virtual void InitialiseHGStandaloneServices(LibraryRootFolder libraryRootFolder)
 {
     m_commsManager 
         = new HGCommunicationsStandalone(
             m_openSim.ConfigurationSettings, m_openSim.NetServersInfo, m_httpServer, 
             libraryRootFolder, false);
     
     CreateGridInfoService();
 }
        protected virtual void InitializeGridServices(LibraryRootFolder libraryRootFolder)
        {
            m_commsManager
                = new CommunicationsOGS1(m_openSim.NetServersInfo, m_httpServer, m_openSim.AssetCache, libraryRootFolder,
                    m_openSim.ConfigurationSettings);

            m_httpServer.AddStreamHandler(new OpenSim.SimStatusHandler());
            m_httpServer.AddStreamHandler(new OpenSim.XSimStatusHandler(m_openSim));
            if (m_openSim.userStatsURI != String.Empty )
                m_httpServer.AddStreamHandler(new OpenSim.UXSimStatusHandler(m_openSim));
        }
Пример #27
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="commsManager"></param>
 public UserManagerBase(CommunicationsManager commsManager)
 {
     m_commsManager = commsManager;
 }
Пример #28
0
 // Constructor called when running in grid mode
 public HGUserServices(CommunicationsManager commsManager)
     : base(commsManager)
 {
 }
Пример #29
0
 /// <summary>
 /// Create a test user with a standard inventory
 /// </summary>
 /// <param name="commsManager"></param>
 /// <returns></returns>
 public static CachedUserInfo CreateUserWithInventory(CommunicationsManager commsManager)
 {
     UUID userId = UUID.Parse("00000000-0000-0000-0000-000000000099");
     return CreateUserWithInventory(commsManager, userId);
 }        
 protected virtual void InitOnce(Scene scene)
 {
     m_localBackend = new LocalInterregionComms();
     m_commsManager = scene.CommsManager;
     m_aScene = scene;
     m_regionClient = new RegionToRegionClient(m_aScene, _gridSendKey);
     m_thisIP = Util.GetHostFromDNS(scene.RegionInfo.ExternalHostName);
 }
 public HGSceneCommunicationService(CommunicationsManager commsMan) : base(commsMan)
 {
 }