public void PostStart(IConfigSource config, IRegistryCore registry)
        {
            IConfig handlerConfig = config.Configs["Handlers"];
            if (handlerConfig.GetString("SimulationInHandler", "") != Name)
                return;

            bool secure = handlerConfig.GetBoolean("SecureSimulation", true);
            IHttpServer server = registry.RequestModuleInterface<ISimulationBase>().GetHttpServer((uint)handlerConfig.GetInt("SimulationInHandlerPort"));

            m_LocalSimulationService = registry.RequestModuleInterface<ISimulationService>();
            
            string path = "/" + UUID.Random().ToString() + "/agent/";

            IGridRegisterModule registerModule = registry.RequestModuleInterface<IGridRegisterModule>();
            if (registerModule != null && secure)
                registerModule.AddGenericInfo("SimulationAgent", path);
            else
            {
                secure = false;
                path = "/agent/";
            }

            server.AddHTTPHandler(path, new AgentHandler(m_LocalSimulationService.GetInnerService(), secure).Handler);
            server.AddHTTPHandler("/object/", new ObjectHandler(m_LocalSimulationService.GetInnerService()).Handler);
        }
        public virtual void Initialize(IConfigSource config, IRegistryCore registry)
        {
            _config = config;
            m_registry = registry;
            IConfig agentConfig = config.Configs["AgentProcessing"];
            if (agentConfig != null)
            {
                m_enabled = agentConfig.GetString("Module", "AgentProcessing") == "AgentProcessing";
                VariableRegionSight = agentConfig.GetBoolean("UseVariableRegionSightDistance", VariableRegionSight);
                MaxVariableRegionSight = agentConfig.GetInt("MaxDistanceVariableRegionSightDistance",
                                                            MaxVariableRegionSight);
            }
            if (m_enabled)
            {
                m_registry.RegisterModuleInterface<IAgentProcessing>(this);

                IConfig auroraConfig = _config.Configs["AuroraConnectors"];
                IGenericsConnector genericsConnector = Aurora.DataManager.DataManager.RequestPlugin<IGenericsConnector>();
                if (!auroraConfig.GetBoolean("CapsServiceDoRemoteCalls", false))
                {
                    genericsConnector.AddGeneric(UUID.Zero, "CapsServiceURL", "CapsURL", new OSDWrapper { Info = MainServer.Instance.ServerURI }.ToOSD());
                    genericsConnector.AddGeneric(UUID.Zero, "CapsServiceURL", "CapsPassword", new OSDWrapper { Info = new System.Random().NextDouble() * 1000 }.ToOSD());
                }

                Init(registry, "CapsService");
            }
        }
 public void Initialize(IConfigSource config, IRegistryCore registry)
 {
     ReadConfig(config);
     IConfig handlers = config.Configs["Handlers"];
     if (handlers.GetString("NeighborHandler", "") == Name)
         registry.RegisterModuleInterface<INeighborService>(this);
 }
        public void Initialize(IConfigSource config, IRegistryCore registry)
        {
            registry.RegisterModuleInterface<IAuthorizationService>(this);
            m_registry = registry;

            MainConsole.Instance.Debug("[Authorization Service]: Local Authorization service enabled");
        }
        public void LoadLibrary(ILibraryService service, IConfigSource source, IRegistryCore registry)
        {
            m_service = service;
            m_registry = registry;
            m_Database = Framework.Utilities.DataManager.RequestPlugin<IInventoryData>();

            IConfig libConfig = source.Configs["InventoryIARLoader"];
            const string pLibrariesLocation = "DefaultInventory/";
            AddDefaultAssetTypes();
            if (libConfig != null)
            {
                if (libConfig.GetBoolean("WipeLibrariesOnNextLoad", false))
                {
                    service.ClearDefaultInventory(); //Nuke it
                    libConfig.Set("WipeLibrariesOnNextLoad", false);
                    source.Save();
                }
                if (libConfig.GetBoolean("PreviouslyLoaded", false))
                    return; //If it is loaded, don't reload
                foreach (string iarFileName in Directory.GetFiles(pLibrariesLocation, "*.iar"))
                {
                    LoadLibraries(iarFileName);
                }
            }
        }
 public AuroraDataServerPostHandler(string url, string SessionID, IRegistryCore registry) :
     base("POST", url)
 {
     m_SessionID = SessionID;
     m_registry = registry;
     GroupsHandler = new GroupsServiceHandler(registry);
 }
        public void Initialize(IConfigSource config, IRegistryCore registry)
        {
            if (MainConsole.Instance != null)
            {
                MainConsole.Instance.Commands.AddCommand(
                    "save archive",
                    "save archive",
                    "Saves a WhiteCore '.abackup' archive (deprecated)",
                    SaveWhiteCoreArchive, true, false);

                MainConsole.Instance.Commands.AddCommand(
                    "load archive",
                    "load archive",
                    "Loads a WhiteCore '.abackupArchive",
                    LoadWhiteCoreArchive, true, false);
            }
            //Register the extension
            const string ext = ".abackup";
            try
            {
                if(Util.IsWindows())
                {
                    RegistryKey key = Registry.ClassesRoot.CreateSubKey(ext + "\\DefaultIcon");
                    key.SetValue("", Application.StartupPath + "\\CrateDownload.ico");
                    key.Close();
                }
            }
            catch
            {
            }
            //Register the interface
            registry.RegisterModuleInterface<IWhiteCoreBackupArchiver>(this);
        }
        public void LoadLibrary(ILibraryService service, IConfigSource source, IRegistryCore registry)
        {
            m_service = service;

            IConfig assetConfig = source.Configs["DefaultXMLAssetLoader"];
            if (assetConfig == null){
                return;
            }
            string loaderArgs = assetConfig.GetString("AssetLoaderArgs",
                        String.Empty);
            bool assetLoaderEnabled = !assetConfig.GetBoolean("PreviouslyLoaded", false);

            if (!assetLoaderEnabled)
                return;

            registry.RegisterModuleInterface<DefaultAssetXMLLoader>(this);

            MainConsole.Instance.InfoFormat("[DefaultXMLAssetLoader]: Loading default asset set from {0}", loaderArgs);
            IAssetService assetService = registry.RequestModuleInterface<IAssetService>();
            ForEachDefaultXmlAsset(loaderArgs,
                    delegate(AssetBase a)
                    {
                        if (!assetLoaderEnabled && assetService.GetExists(a.IDString))
                            return;
                        assetService.Store(a);
                    });
        }
Example #9
0
        public void Start(IConfigSource config, IRegistryCore registry)
        {
            if (config.Configs["Currency"] == null ||
                config.Configs["Currency"].GetString("Module", "") != "SimpleCurrency")
                return;
            if (!config.Configs["Currency"].GetBoolean("RunServer", false))
                return;

            m_connector = DataManager.RequestPlugin<ISimpleCurrencyConnector>() as SimpleCurrencyConnector;

            if (m_connector.GetConfig().ClientPort == 0 && MainServer.Instance == null)
                return;
            IHttpServer server =
                registry.RequestModuleInterface<ISimulationBase>()
                        .GetHttpServer((uint) m_connector.GetConfig().ClientPort);
            server.AddXmlRPCHandler("getCurrencyQuote", QuoteFunc);
            server.AddXmlRPCHandler("buyCurrency", BuyFunc);
            server.AddXmlRPCHandler("preflightBuyLandPrep", PreflightBuyLandPrepFunc);
            server.AddXmlRPCHandler("buyLandPrep", LandBuyFunc);
            server.AddXmlRPCHandler("getBalance", GetbalanceFunc);
            server.AddXmlRPCHandler("/currency.php", GetbalanceFunc);
            server.AddXmlRPCHandler("/landtool.php", GetbalanceFunc);

            m_syncMessagePoster = registry.RequestModuleInterface<ISyncMessagePosterService>();
            m_agentInfoService = registry.RequestModuleInterface<IAgentInfoService>();
        }
Example #10
0
        public virtual void Configure(IConfigSource config, IRegistryCore registry)
        {
            m_registry = registry;

            m_database = DataManager.RequestPlugin<IAssetDataPlugin>();
            if (m_database == null)
                throw new Exception("Could not find a storage interface in the given module");

            registry.RegisterModuleInterface<IAssetService>(this);

            IConfig handlers = config.Configs["Handlers"];
            if (handlers != null)
                doDatabaseCaching = handlers.GetBoolean("AssetHandlerUseCache", false);

            if (MainConsole.Instance != null)
            {
                MainConsole.Instance.Commands.AddCommand("show digest",
                                                         "show digest <ID>",
                                                         "Show asset digest", HandleShowDigest);

                MainConsole.Instance.Commands.AddCommand("delete asset",
                                                         "delete asset <ID>",
                                                         "Delete asset from database", HandleDeleteAsset);
            }

            MainConsole.Instance.Debug("[ASSET SERVICE]: Local asset service enabled");
        }
 public void Initialize(IConfigSource config, IRegistryCore registry)
 {
     IConfig handlerConfig = config.Configs["Handlers"];
     if (handlerConfig.GetString("AssetHandler", "") != Name)
         return;
     Configure(config, registry);
 }
Example #12
0
        public void Start(IConfigSource config, IRegistryCore registry)
        {
            IConfig handlerConfig = config.Configs["Handlers"];
            if (handlerConfig.GetString("AssetInHandler", "") != Name)
                return;

            m_registry = registry;
            m_port = handlerConfig.GetUInt("AssetInHandlerPort");

            if (handlerConfig.GetBoolean("UnsecureUrls", false))
            {
                IHttpServer server = m_registry.RequestModuleInterface<ISimulationBase>().GetHttpServer(m_port);
                m_port = server.Port;
                string url = "/assets";

                IAssetService m_AssetService = m_registry.RequestModuleInterface<IAssetService>();
                server.AddStreamHandler(new AssetServerGetHandler(m_AssetService, url, 0, registry));
                server.AddStreamHandler(new AssetServerPostHandler(m_AssetService, url, 0, registry));
                server.AddStreamHandler(new AssetServerDeleteHandler(m_AssetService, m_allowDelete, url, 0, registry));
            }

            IConfig serverConfig = config.Configs[m_ConfigName];
            m_allowDelete = serverConfig != null ? serverConfig.GetBoolean("AllowRemoteDelete", false) : false;

            m_registry.RequestModuleInterface<IGridRegistrationService>().RegisterModule(this);
        }
Example #13
0
 public void Start(IConfigSource config, IRegistryCore registry)
 {
     m_Database = Framework.Utilities.DataManager.RequestPlugin<IAvatarData>();
     m_ArchiveService = registry.RequestModuleInterface<IAvatarAppearanceArchiver>();
     registry.RequestModuleInterface<ISimulationBase>()
             .EventManager.RegisterEventHandler("DeleteUserInformation", DeleteUserInformation);
 }
        public virtual void Initialize (IConfigSource config, IRegistryCore registry)
        {
            IConfig handlerConfig = config.Configs ["Handlers"];
            if (handlerConfig.GetString ("AssetHandler", "") != "FileBased" + Name)
                return;
            m_enabled = true;
            Configure (config, registry);
            Init (registry, Name, serverPath: "/asset/", serverHandlerName: "AssetServerURI");

            // set defaults
            var simbase = registry.RequestModuleInterface<ISimulationBase> ();
            var defpath = simbase.DefaultDataPath;
            m_assetsDirectory = Path.Combine (defpath, Constants.DEFAULT_FILEASSETS_DIR);
            m_migrateSQL = true;

            IConfig fileConfig = config.Configs ["FileBasedAssetService"];
            if (fileConfig != null)
            {
                var assetsPath = fileConfig.GetString ("AssetFolderPath", m_assetsDirectory);
                if (assetsPath != "")
                    m_assetsDirectory = assetsPath;

                // try and migrate sql assets if they are missing?
                m_migrateSQL = fileConfig.GetBoolean ("MigrateSQLAssets", true);
            }
            SetUpFileBase (m_assetsDirectory);

        }
Example #15
0
 public virtual void Start(IConfigSource config, IRegistryCore registry)
 {
     m_Database = Aurora.DataManager.DataManager.RequestPlugin<IInventoryData> ();
     m_UserAccountService = registry.RequestModuleInterface<IUserAccountService>();
     m_LibraryService = registry.RequestModuleInterface<ILibraryService>();
     m_AssetService = registry.RequestModuleInterface<IAssetService>();
 }
        public virtual void Configure(IConfigSource config, IRegistryCore registry)
        {
            if (!m_enabled)
                return;
            m_registry = registry;

            registry.RegisterModuleInterface<IAssetService>(this);

            IConfig handlers = config.Configs["Handlers"];
            if (handlers != null)
                doDatabaseCaching = handlers.GetBoolean("AssetHandlerUseCache", false);

            if (MainConsole.Instance != null && !DoRemoteCalls)
            {
                MainConsole.Instance.Commands.AddCommand(
                    "show digest",
                    "show digest <ID>",
                    "Show asset digest",
                    HandleShowDigest, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "delete asset",
                    "delete asset <ID>",
                    "Delete asset from database",
                    HandleDeleteAsset, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "get asset",
                    "get asset <ID>",
                    "Gets info about asset from database",
                    HandleGetAsset, false, true);

                MainConsole.Instance.Info("[FILE ASSET SERVICE]: File based asset service enabled");
            }
        }
        public void Initialize(IConfigSource config, IRegistryCore registry)
        {
            IConfig handlerConfig = config.Configs["Handlers"];
            if (handlerConfig.GetString("FriendsHandler", "") != Name)
                return;

            string localHandler = handlerConfig.GetString("LocalFriendsHandler", "FriendsService");
            List<IFriendsService> services = AuroraModuleLoader.PickupModules<IFriendsService>();
#if (!ISWIN)
            foreach (IFriendsService s in services)
            {
                if (s.GetType().Name == localHandler) m_localService = s;
            }
#else
            foreach (IFriendsService s in services.Where(s => s.GetType().Name == localHandler))
                m_localService = s;
#endif

            if (m_localService == null)
                m_localService = new FriendsService();
            m_localService.Initialize(config, registry);
            m_remoteService = new FriendsServicesConnector();
            m_remoteService.Initialize(config, registry);
            registry.RegisterModuleInterface<IFriendsService>(this);
            m_registry = registry;
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore registry,
                               string defaultConnectionString)
        {
            m_gd = GenericData;
            m_registry = registry;

            IConfig config = source.Configs["Currency"];
            if (config == null || source.Configs["Currency"].GetString("Module", "") != "SimpleCurrency")
                return;

            if (source.Configs[Name] != null)
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

            if (GenericData != null)
                GenericData.ConnectToDatabase(defaultConnectionString, "SimpleCurrency", true);
            DataManager.RegisterPlugin(Name, this);

            m_config = new SimpleCurrencyConfig(config);

            Init(m_registry, Name, "", "/currency/", "CurrencyServerURI");

            if (!m_doRemoteCalls)
            {
                MainConsole.Instance.Commands.AddCommand("money add", "money add", "Adds money to a user's account.",
                                                         AddMoney);
                MainConsole.Instance.Commands.AddCommand("money set", "money set",
                                                         "Sets the amount of money a user has.",
                                                         SetMoney);
                MainConsole.Instance.Commands.AddCommand("money get", "money get",
                                                         "Gets the amount of money a user has.",
                                                         GetMoney);
            }
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase,
                               string defaultConnectionString)
        {
            GD = GenericData;

            if (source.Configs[Name] != null)
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

            GD.ConnectToDatabase(defaultConnectionString, "AbuseReports",
                                 source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));

            DataManager.DataManager.RegisterPlugin(Name + "Local", this);
            if (source.Configs["AuroraConnectors"].GetString("AbuseReportsConnector", "LocalConnector") ==
                "LocalConnector")
            {
                WebPassword = Util.Md5Hash(source.Configs["Handlers"].GetString("WireduxHandlerPassword", String.Empty));

                //List<string> Results = GD.Query("Method", "abusereports", "passwords", "Password");
                //if (Results.Count == 0)
                //{
                //    string newPass = MainConsole.Instance.PasswdPrompt("Password to access Abuse Reports");
                //    GD.Insert("passwords", new object[] { "abusereports", Util.Md5Hash(Util.Md5Hash(newPass)) });
                //}
                DataManager.DataManager.RegisterPlugin(Name, this);
            }
        }
Example #20
0
 public void Configure(IConfigSource config, IRegistryCore registry)
 {
     if (MainConsole.Instance != null)
     {
         MainConsole.Instance.Commands.AddCommand(
             "create user",
             "create user [<first> [<last> [<pass> [<email>]]]]",
             "Create a new user", HandleCreateUser);
         MainConsole.Instance.Commands.AddCommand("reset user password",
                                                  "reset user password [<first> [<last> [<password>]]]",
                                                  "Reset a user password", HandleResetUserPassword);
         MainConsole.Instance.Commands.AddCommand(
             "show account",
             "show account <first> <last>",
             "Show account details for the given user", HandleShowAccount);
         MainConsole.Instance.Commands.AddCommand(
             "set user level",
             "set user level [<first> [<last> [<level>]]]",
             "Set user level. If the user's level is > 0, "
             + "this account will be treated as god-moded. "
             + "It will also affect the 'login level' command. ",
             HandleSetUserLevel);
         MainConsole.Instance.Commands.AddCommand(
             "set user profile title",
             "set user profile title [<first> [<last> [<Title>]]]",
             "Sets the title (Normally resident) in a user's title to some custom value.",
             HandleSetTitle);
     }
     registry.RegisterModuleInterface<IUserAccountService>(this);
 }
        public virtual void Configure(IConfigSource config, IRegistryCore registry)
        {
            m_registry = registry;

            m_database = Framework.Utilities.DataManager.RequestPlugin<IAssetDataPlugin>();

            registry.RegisterModuleInterface<IAssetService>(this);

            IConfig handlers = config.Configs["Handlers"];
            if (handlers != null)
                doDatabaseCaching = handlers.GetBoolean("AssetHandlerUseCache", false);

            if (MainConsole.Instance != null && !DoRemoteCalls)
            {
                MainConsole.Instance.Commands.AddCommand(
                    "show digest",
                    "show digest <ID>",
                    "Show asset digest",
                    HandleShowDigest, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "delete asset",
                    "delete asset <ID>",
                    "Delete asset from database",
                    HandleDeleteAsset, false, true);

                MainConsole.Instance.Commands.AddCommand("get asset",
                    "get asset <ID>",
                    "Gets info about asset from database",
                    HandleGetAsset, false, true);

            }

            MainConsole.Instance.Debug("[ASSET SERVICE]: Local asset service enabled");
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore registry,
                               string defaultConnectionString)
        {
            GD = GenericData;
            m_registry = registry;

            IConfig config = source.Configs["Currency"];
            if (config == null || source.Configs["Currency"].GetString("Module", "") != "BaseCurrency")
                return;

            IConfig gridInfo = source.Configs["GridInfoService"];
            if (gridInfo != null)
            {
                InWorldCurrency = gridInfo.GetString ("CurrencySymbol", string.Empty) + " ";
                RealCurrency = gridInfo.GetString ("RealCurrencySymbol", string.Empty) + " ";
            }

            if (source.Configs[Name] != null)
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

            if (GenericData != null)
                GenericData.ConnectToDatabase(defaultConnectionString, "SimpleCurrency", true);
            Framework.Utilities.DataManager.RegisterPlugin(Name, this);

            m_config = new BaseCurrencyConfig(config);

            Init(m_registry, Name, "", "/currency/", "CurrencyServerURI");

        }
        public void Initialize (IConfigSource config, IRegistryCore registry)
        {
            IConfig handlerConfig = config.Configs ["Handlers"];
            if (handlerConfig.GetString ("UserAccountHandler", "") != Name)
                return;

            var simBase = registry.RequestModuleInterface<ISimulationBase> ();
            m_defaultDataPath = simBase.DefaultDataPath;

            Configure (config, registry);
            Init (registry, Name, serverPath: "/user/", serverHandlerName: "UserAccountServerURI");

            // check for user name seed
            IConfig loginConfig = config.Configs ["LoginService"];
            if (loginConfig != null) {
                string userNameSeed = loginConfig.GetString ("UserNameSeed", "");
                if (userNameSeed != "")
                    m_userNameSeed = userNameSeed.Split (',');
            }

            // check for initial stipend payment for new users
            IConfig currConfig = config.Configs ["Currency"];
            if (currConfig != null)
                m_newUserStipend = currConfig.GetInt ("NewUserStipend", 0);

        }
 public void Configure(IConfigSource config, IRegistryCore registry)
 {
     if (MainConsole.Instance != null)
     {
         MainConsole.Instance.Commands.AddCommand(
                 "create user",
                 "create user [<first> [<last> [<pass> [<email>]]]]",
                 "Create a new user", HandleCreateUser);
         MainConsole.Instance.Commands.AddCommand("reset user password",
                 "reset user password [<first> [<last> [<password>]]]",
                 "Reset a user password", HandleResetUserPassword);
         MainConsole.Instance.Commands.AddCommand (
                 "show account",
                 "show account <first> <last>",
                 "Show account details for the given user", HandleShowAccount);
         MainConsole.Instance.Commands.AddCommand (
                     "set user level",
                     "set user level [<first> [<last> [<level>]]]",
                     "Set user level. If >= 200 and 'allow_grid_gods = true' in OpenSim.ini, "
                         + "this account will be treated as god-moded. "
                         + "It will also affect the 'login level' command. ",
                         HandleSetUserLevel);
     }
     registry.RegisterModuleInterface<IUserAccountService>(this);
 }
 public void Initialize(IConfigSource config, IRegistryCore registry)
 {
     m_config = config;
     m_registry = registry;
     registry.RequestModuleInterface<ISimulationBase>().EventManager.RegisterEventHandler("PreRegisterRegion",
                                                                                          EventManager_OnGenericEvent);
 }
 public AbuseReportsHandler(string url, IAbuseReports service, IRegistryCore reg, string SessionID) :
     base("POST", url)
 {
     m_AbuseReportsService = service;
     m_registry = reg;
     m_SessionID = SessionID;
 }
 public AvatarServerPostHandler(string url, IAvatarService service, string SessionID, IRegistryCore registry) :
     base("POST", url)
 {
     m_AvatarService = service;
     m_SessionID = SessionID;
     m_registry = registry;
 }
        public void Initialize (ILoginService service, IConfigSource config, IRegistryCore registry)
        {
            IConfig loginServerConfig = config.Configs ["LoginService"];
            if (loginServerConfig != null) {
                m_UseTOS = loginServerConfig.GetBoolean ("UseTermsOfServiceOnFirstLogin", false);
                m_TOSLocation = loginServerConfig.GetString ("FileNameOfTOS", "");

                if (m_TOSLocation.Length > 0) {
                    // html appears to be broken
                    if (m_TOSLocation.ToLower ().StartsWith ("http://", StringComparison.Ordinal))
                        m_TOSLocation = m_TOSLocation.Replace ("ServersHostname", MainServer.Instance.HostName);
                    else {
                        var simBase = registry.RequestModuleInterface<ISimulationBase> ();
                        var TOSFileName = PathHelpers.VerifyReadFile (m_TOSLocation, ".txt", simBase.DefaultDataPath);
                        if (TOSFileName == "") {
                            m_UseTOS = false;
                            MainConsole.Instance.ErrorFormat ("Unable to locate the Terms of Service file : '{0}'", m_TOSLocation);
                            MainConsole.Instance.Error (" Show 'Terms of Service' for a new user login is disabled!");
                        } else
                            m_TOSLocation = TOSFileName;
                    }
                } else
                    m_UseTOS = false;

            }
            m_AuthenticationService = registry.RequestModuleInterface<IAuthenticationService> ();
            m_LoginService = service;
        }
 public AssetServerGetHandler(IAssetService service, string url, string SessionID, IRegistryCore registry) :
     base("GET", url)
 {
     m_AssetService = service;
     m_SessionID = SessionID;
     m_registry = registry;
 }
 public MessagingServiceInPostHandler (string url, IRegistryCore registry, MessagingServiceInHandler handler, string SessionID) :
         base("POST", url)
 {
     m_handler = handler;
     m_SessionID = SessionID;
     ulong.TryParse (SessionID, out m_ourRegionHandle);
 }
Example #31
0
 public void Configure(IConfigSource config, IRegistryCore registry)
 {
 }
 /// <summary>
 ///     Instantiate a GridInfoService object.
 /// </summary>
 /// <param name="configSource">path to config path containing grid information</param>
 /// <param name="registry"></param>
 /// <remarks>
 ///     GridInfoService uses the [GridInfo] section of the
 ///     standard WhiteCore.ini file --- which is not optimal, but
 ///     anything else requires a general redesign of the config
 ///     system.
 /// </remarks>
 public GridInfoHandlers(IConfigSource configSource, IRegistryCore registry)
 {
     m_config   = configSource;
     m_registry = registry;
     UpdateGridInfo();
 }
Example #33
0
 public void Initialize(IConfigSource config, IRegistryCore registry)
 {
     registry.RegisterModuleInterface <IAbuseReports>(this);
     Init(registry, Name);
 }
 public virtual void Start(IConfigSource config, IRegistryCore registry)
 {
     m_Database = Framework.Utilities.DataManager.RequestPlugin <IFriendsData>();
 }
 public void Initialize(IConfigSource config, IRegistryCore registry)
 {
 }
Example #36
0
 public virtual void Start(IConfigSource config, IRegistryCore registry)
 {
     m_syncMessagePoster = registry.RequestModuleInterface <ISyncMessagePosterService>();
 }
Example #37
0
 public void Start(IConfigSource config, IRegistryCore registry)
 {
     m_Database = DataManager.RequestPlugin <IAvatarData>();
     registry.RequestModuleInterface <ISimulationBase>().EventManager.RegisterEventHandler("DeleteUserInformation", DeleteUserInformation);
 }
Example #38
0
 public IMesher GetMesher(IConfigSource config, IRegistryCore registry)
 {
     return(new ZeroMesher());
 }
 public virtual void Start(IConfigSource config, IRegistryCore registry)
 {
     m_service = registry.RequestModuleInterface <ICapsService> ();
 }
Example #40
0
 public void Start(IConfigSource config, IRegistryCore registry)
 {
     m_AssetService   = registry.RequestModuleInterface <IAssetService>();
     m_simulationBase = registry.RequestModuleInterface <ISimulationBase>();
 }
Example #41
0
 public void Start(IConfigSource config, IRegistryCore registry)
 {
     throw new System.NotImplementedException();
 }
Example #42
0
        public void Initialize(IConfigSource config, IRegistryCore registry)
        {
            IConfig moduleConfig = config.Configs["Modules"];

            if (moduleConfig != null)
            {
                string name = moduleConfig.GetString("AssetCaching", String.Empty);

                if (name == Name)
                {
                    m_MemoryCache = new ExpiringCache <string, AssetBase>();

                    //MainConsole.Instance.InfoFormat("[FLOTSAM ASSET CACHE]: {0} enabled", this.Name);

                    IConfig assetConfig = config.Configs["AssetCache"];
                    if (assetConfig == null)
                    {
                        //MainConsole.Instance.Warn("[FLOTSAM ASSET CACHE]: AssetCache missing from WhiteCore.ini, using defaults.");
                        //MainConsole.Instance.InfoFormat("[FLOTSAM ASSET CACHE]: Cache Directory", m_DefaultCacheDirectory);
                        return;
                    }

                    m_CacheDirectory = assetConfig.GetString("CacheDirectory", m_DefaultCacheDirectory);
                    //MainConsole.Instance.InfoFormat("[FLOTSAM ASSET CACHE]: Cache Directory", m_DefaultCacheDirectory);

                    m_MemoryCacheEnabled = assetConfig.GetBoolean("MemoryCacheEnabled", false);
                    m_MemoryExpiration   =
                        TimeSpan.FromHours(assetConfig.GetDouble("MemoryCacheTimeout", m_DefaultMemoryExpiration));

#if WAIT_ON_INPROGRESS_REQUESTS
                    m_WaitOnInprogressTimeout = assetConfig.GetInt("WaitOnInprogressTimeout", 3000);
#endif

                    m_logLevel       = assetConfig.GetInt("LogLevel", 0);
                    m_HitRateDisplay = (ulong)assetConfig.GetInt("HitRateDisplay", 1000);

                    m_FileExpiration =
                        TimeSpan.FromHours(assetConfig.GetDouble("FileCacheTimeout", m_DefaultFileExpiration));
                    m_FileExpirationCleanupTimer =
                        TimeSpan.FromHours(assetConfig.GetDouble("FileCleanupTimer", m_DefaultFileExpiration));
                    if ((m_FileExpiration > TimeSpan.Zero) && (m_FileExpirationCleanupTimer > TimeSpan.Zero))
                    {
                        m_CacheCleanTimer = new Timer(m_FileExpirationCleanupTimer.TotalMilliseconds)
                        {
                            AutoReset = true
                        };
                        m_CacheCleanTimer.Elapsed += CleanupExpiredFiles;
                        lock (m_CacheCleanTimer)
                            m_CacheCleanTimer.Start();
                    }

                    m_CacheDirectoryTiers = assetConfig.GetInt("CacheDirectoryTiers", 1);
                    if (m_CacheDirectoryTiers < 1)
                    {
                        m_CacheDirectoryTiers = 1;
                    }
                    else if (m_CacheDirectoryTiers > 3)
                    {
                        m_CacheDirectoryTiers = 3;
                    }

                    m_CacheDirectoryTierLen = assetConfig.GetInt("CacheDirectoryTierLength", 3);
                    if (m_CacheDirectoryTierLen < 1)
                    {
                        m_CacheDirectoryTierLen = 1;
                    }
                    else if (m_CacheDirectoryTierLen > 4)
                    {
                        m_CacheDirectoryTierLen = 4;
                    }

                    m_CacheWarnAt = assetConfig.GetInt("CacheWarnAt", 30000);

                    m_DeepScanBeforePurge = assetConfig.GetBoolean("DeepScanBeforePurge", false);

                    if (MainConsole.Instance != null)
                    {
                        MainConsole.Instance.Commands.AddCommand("fcache status",
                                                                 "fcache status",
                                                                 "Display cache status",
                                                                 HandleConsoleCommand, false, true);

                        MainConsole.Instance.Commands.AddCommand("fcache clear",
                                                                 "fcache clear [file] [memory]",
                                                                 "Remove all assets in the file and/or memory cache",
                                                                 HandleConsoleCommand, false, true);

                        MainConsole.Instance.Commands.AddCommand("fcache assets",
                                                                 "fcache assets",
                                                                 "Attempt a deep scan and cache of all assets in all scenes",
                                                                 HandleConsoleCommand, false, true);

                        MainConsole.Instance.Commands.AddCommand("fcache expire",
                                                                 "fcache expire <datetime>",
                                                                 "Purge cached assets older then the specified date/time",
                                                                 HandleConsoleCommand, false, true);
                    }
                    registry.RegisterModuleInterface <IImprovedAssetCache>(this);
                }
            }
        }
        public override void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase,
                                        string defaultConnectionString)
        {
            if (source.Configs["AuroraConnectors"].GetString("InventoryConnector", "LocalConnector") ==
                "RobustConnector")
            {
                GD         = GenericData;
                m_registry = simBase;

                string connectionString = defaultConnectionString;
                if (source.Configs[Name] != null)
                {
                    connectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);
                }

                GD.ConnectToDatabase(connectionString, "Inventory",
                                     source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));

                DataManager.RegisterPlugin(this);
            }
        }
 public void Start(IConfigSource config, IRegistryCore registry)
 {
     m_cache = registry.RequestModuleInterface <IImprovedAssetCache>();
 }
Example #45
0
 public void Initialise(IScene scene, IConfigSource source, ISimulationBase simBase)
 {
     scene.StackModuleInterface <IWhiteCoreBackupModule>(this);
     m_registry = simBase.ApplicationRegistry;
 }
Example #46
0
 public void Start(IConfigSource config, IRegistryCore registry)
 {
     registry.RequestModuleInterface <ISimulationBase>().EventManager.RegisterEventHandler("EstateUpdated",
                                                                                           OnGenericEvent);
 }
 public void PostInitialize(IConfigSource config, IRegistryCore registry)
 {
     m_AbuseReportsService = registry.RequestModuleInterface <IAbuseReports>();
 }
Example #48
0
 public void Start(IConfigSource config, IRegistryCore registry)
 {
     m_Database = Aurora.DataManager.DataManager.RequestPlugin <IAvatarData> ();
 }
 public void Initialize(ILoginService service, IConfigSource config, IRegistryCore registry)
 {
     m_AuthenticationService = registry.RequestModuleInterface <IAuthenticationService> ();
 }
 public void AddNewRegistry(IConfigSource config, IRegistryCore registry)
 {
 }
Example #51
0
 public void Initialize(IConfigSource config, IRegistryCore registry)
 {
     m_config   = config;
     m_registry = registry;
     registry.RequestModuleInterface <ISimulationBase>().EventManager.OnGenericEvent += new Aurora.Framework.OnGenericEventHandler(EventManager_OnGenericEvent);
 }
Example #52
0
 public IMesher GetMesher(IConfigSource config, IRegistryCore registry)
 {
     return(new Meshmerizer(config, registry));
 }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore registry,
                               string defaultConnectionString)
        {
            m_gd       = GenericData;
            m_registry = registry;

            IConfig config = source.Configs["Currency"];

            if (config == null || source.Configs["Currency"].GetString("Module", "") != "SimpleCurrency")
            {
                return;
            }

            IConfig gridInfo = source.Configs["GridInfoService"];

            if (gridInfo != null)
            {
                InWorldCurrency = gridInfo.GetString("CurrencySymbol", String.Empty) + " ";
                RealCurrency    = gridInfo.GetString("RealCurrencySymbol", String.Empty) + " ";
            }

            if (source.Configs[Name] != null)
            {
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);
            }

            if (GenericData != null)
            {
                GenericData.ConnectToDatabase(defaultConnectionString, "SimpleCurrency", true);
            }
            Framework.Utilities.DataManager.RegisterPlugin(Name, this);

            m_config = new BaseCurrencyConfig(config);

            Init(m_registry, Name, "", "/currency/", "CurrencyServerURI");

            if (!m_doRemoteCalls)
            {
                MainConsole.Instance.Commands.AddCommand(
                    "money add",
                    "money add",
                    "Adds money to a user's account.",
                    AddMoney, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "money set",
                    "money set",
                    "Sets the amount of money a user has.",
                    SetMoney, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "money get",
                    "money get",
                    "Gets the amount of money a user has.",
                    GetMoney, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "show user transactions",
                    "show user transactions",
                    "Display user transactions for a period.",
                    HandleShowTransactions, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "show user purchases",
                    "show user purchases",
                    "Display user purchases for a period.",
                    HandleShowPurchases, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "stipend set",
                    "stipend set",
                    "Sets the next date for stipend",
                    HandleStipendSet, false, true);
            }
        }
Example #54
0
 public void Initialize(ILoginService service, IConfigSource source, IRegistryCore registry)
 {
     m_module = new BanCheck(source, registry.RequestModuleInterface <IUserAccountService>());
 }
Example #55
0
 public void Start(IConfigSource config, IRegistryCore registry)
 {
     m_assetService = m_registry.RequestModuleInterface <IAssetService>();
     m_gridService  = m_registry.RequestModuleInterface <IGridService>();
 }
Example #56
0
 public AgentHandler(ISimulationService sim, IRegistryCore registry, bool secure)
 {
     m_registry          = registry;
     m_SimulationService = sim;
     m_secure            = secure;
 }
 public void Initialize(IConfigSource config, IRegistryCore registry)
 {
     registry.RegisterModuleInterface <ISyncMessageRecievedService>(this);
 }
 /// <summary>
 ///     Initialize the service
 /// </summary>
 /// <param name="regionID"></param>
 /// <param name="registry"></param>
 public void Initialize(UUID regionID, IRegistryCore registry)
 {
     m_RegionID = regionID;
     m_registry = registry;
 }
 public void Start(IConfigSource config, IRegistryCore registry)
 {
 }
Example #60
0
 public RobustAssetServicesConnector(IRegistryCore registry, string URL)
 {
     m_registry  = registry;
     m_serverURL = URL;
 }