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 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 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 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); }
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 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>(); }
public void Start(IConfigSource config, IRegistryCore registry) { registry.RequestModuleInterface<ISimulationBase>().EventManager.OnGenericEvent += OnGenericEvent; //Also look for incoming messages to display registry.RequestModuleInterface<IAsyncMessageRecievedService>().OnMessageReceived += OnMessageReceived; }
public void Start(IConfigSource config, IRegistryCore registry) { m_GridService = registry.RequestModuleInterface<IGridService>(); m_AuthenticationService = registry.RequestModuleInterface<IAuthenticationService>(); m_InventoryService = registry.RequestModuleInterface<IInventoryService>(); m_Database = DataManager.RequestPlugin<IUserAccountData>(); if (m_Database == null) throw new Exception("Could not find a storage interface in the given module"); }
public virtual void Start(IConfigSource config, IRegistryCore registry) { m_Database = DataManager.RequestPlugin<IInventoryData>(); m_UserAccountService = registry.RequestModuleInterface<IUserAccountService>(); m_LibraryService = registry.RequestModuleInterface<ILibraryService>(); m_AssetService = registry.RequestModuleInterface<IAssetService>(); registry.RequestModuleInterface<ISimulationBase>().EventManager.RegisterEventHandler("DeleteUserInformation", DeleteUserInformation); }
public void PostStart(IConfigSource config, IRegistryCore registry) { IConfig handlerConfig = config.Configs["Handlers"]; if (handlerConfig.GetString("PresenceInHandler", "") != Name) return; IHttpServer server = registry.RequestModuleInterface<ISimulationBase>().GetHttpServer((uint)handlerConfig.GetInt("PresenceInHandlerPort")); m_PresenceService = registry.RequestModuleInterface<IPresenceService>(); server.AddStreamHandler(new PresenceServerPostHandler(m_PresenceService)); }
public void PostStart(IConfigSource config, IRegistryCore registry) { IConfig handlerConfig = config.Configs["Handlers"]; if (handlerConfig.GetString("EventQueueInHandler", "") != Name) return; IHttpServer server = registry.RequestModuleInterface<ISimulationBase>().GetHttpServer((uint)handlerConfig.GetInt("EventQueueInHandlerPort")); IEventQueueService service = registry.RequestModuleInterface<IEventQueueService>(); ICapsService capsService = registry.RequestModuleInterface<ICapsService>(); server.AddStreamHandler(new EQMEventPoster(service, capsService)); }
public void PostStart(IConfigSource config, IRegistryCore registry) { IConfig handlerConfig = config.Configs["Handlers"]; if (handlerConfig.GetString("FreeswitchInHandler", "") != Name) return; IHttpServer server = registry.RequestModuleInterface<ISimulationBase>().GetHttpServer((uint)handlerConfig.GetInt("FreeswitchInHandlerPort")); m_FreeswitchService = registry.RequestModuleInterface<IFreeswitchService>(); server.AddHTTPHandler(String.Format("{0}/freeswitch-config", m_freeSwitchAPIPrefix), FreeSwitchConfigHTTPHandler); server.AddHTTPHandler(String.Format("{0}/region-config", m_freeSwitchAPIPrefix), RegionConfigHTTPHandler); }
public void Start(IConfigSource config, IRegistryCore registry) { IConfig hgConfig = config.Configs["HyperGrid"]; if (hgConfig == null || !hgConfig.GetBoolean ("Enabled", false)) return; IConfig friendConfig = config.Configs["HGFriends"]; if (friendConfig == null || !friendConfig.GetBoolean ("Enabled", false)) return; MainServer.Instance.AddStreamHandler (new HGFriendsServerPostHandler (registry.RequestModuleInterface<IFriendsService>(), registry.RequestModuleInterface<IUserAgentService>())); }
public void PostStart(IConfigSource config, IRegistryCore registry) { IConfig handlerConfig = config.Configs["Handlers"]; if (handlerConfig.GetString("LLLoginHandler", "") != Name) return; IHttpServer server = registry.RequestModuleInterface<ISimulationBase>().GetHttpServer((uint)handlerConfig.GetInt("LLLoginHandlerPort")); m_log.Debug("[LLLOGIN IN CONNECTOR]: Starting..."); ReadLocalServiceFromConfig(config); m_LoginService = registry.RequestModuleInterface<ILoginService>(); InitializeHandlers(server); }
public void PostStart(IConfigSource config, IRegistryCore registry) { IConfig handlerConfig = config.Configs["Handlers"]; if (handlerConfig.GetString("CAPSHandler", "") != Name) return; ICapsService m_capsService = registry.RequestModuleInterface<ICapsService>(); string Password = handlerConfig.GetString("CAPSHandlerPassword", String.Empty); if (Password != "" & m_capsService != null) { m_server = registry.RequestModuleInterface<ISimulationBase>().GetHttpServer(handlerConfig.GetUInt("CAPSHandlerPort")); //This handler allows sims to post CAPS for their sims on the CAPS server. m_server.AddStreamHandler(new CAPSHandler(Password, m_capsService)); } }
public void Start (IConfigSource config, IRegistryCore registry) { IConfig externalConfig = config.Configs ["ExternalCaps"]; if (externalConfig == null) return; m_allowedCapsModules = Util.ConvertToList (externalConfig.GetString ("CapsHandlers"), true); ISyncMessageRecievedService service = registry.RequestModuleInterface<ISyncMessageRecievedService> (); service.OnMessageReceived += service_OnMessageReceived; m_syncPoster = registry.RequestModuleInterface<ISyncMessagePosterService> (); m_registry = registry; registry.RegisterModuleInterface<IExternalCapsHandler> (this); Init (registry, GetType ().Name); }
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 Start (IConfigSource config, IRegistryCore registry) { if (config.Configs ["Currency"] == null || config.Configs ["Currency"].GetString ("Module", "") != "BaseCurrency") return; // we only want this if we are local.. bool remoteCalls = false; IConfig connectorConfig = config.Configs ["UniverseConnectors"]; if ((connectorConfig != null) && connectorConfig.Contains ("DoRemoteCalls")) remoteCalls = connectorConfig.GetBoolean ("DoRemoteCalls", false); if (remoteCalls) return; m_connector = Framework.Utilities.DataManager.RequestPlugin<IBaseCurrencyConnector> () as BaseCurrencyConnector; var curPort = m_connector.GetConfig ().ClientPort; if (curPort == 0 && MainServer.Instance == null) return; IHttpServer server = registry.RequestModuleInterface<ISimulationBase> ().GetHttpServer ((uint)curPort); 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> (); }
private void SetUpConsole(IConfigSource config, IRegistryCore registry) { List<ICommandConsole> Plugins = AuroraModuleLoader.PickupModules<ICommandConsole>(); foreach (ICommandConsole plugin in Plugins) { plugin.Initialize(config, registry.RequestModuleInterface<ISimulationBase>()); } if (MainConsole.Instance == null) { Console.WriteLine("[Console]: No Console located"); return; } MainConsole.Instance.Threshold = Level.Info; MainConsole.Instance.Fatal(String.Format("[Console]: Console log level is {0}", MainConsole.Instance.Threshold)); MainConsole.Instance.Commands.AddCommand("set log level", "set log level [level]", "Set the console logging level", HandleLogLevel); MainConsole.Instance.Commands.AddCommand("get log level", "get log level", "Returns the current console logging level", HandleGetLogLevel); }
public AuroraDataServerPostOSDHandler(string url, string SessionID, IRegistryCore registry) : base("POST", url) { DirectoryHandler = new DirectoryInfoOSDHandler (registry.RequestModuleInterface<ISimulationBase>().ConfigSource); m_SessionID = SessionID; m_registry = registry; }
public void Start(IConfigSource config, IRegistryCore registry) { ISimulationBase simBase = registry.RequestModuleInterface<ISimulationBase>(); m_server = simBase.GetHttpServer(0); MainConsole.Instance.Commands.AddCommand("CapsService", false, "show presences", "show presences", "Shows all presences in the grid", ShowUsers); }
public void Start (IConfigSource config, IRegistryCore registry) { if (!m_enabled) return; m_assetService = registry.RequestModuleInterface<IAssetService> (); m_inventoryService = registry.RequestModuleInterface<IInventoryService> (); m_avatarService = registry.RequestModuleInterface<IAvatarService> (); m_assetService = registry.RequestModuleInterface<IAssetService> (); MainConsole.Instance.Commands.AddCommand ( "bake avatar", "bake avatar [firstname lastname]", "Bakes an avatar's appearance", HandleBakeAvatar, false, true); }
public void Initialize(IConfigSource config, IRegistryCore registry) { m_config = config; m_registry = registry; registry.RequestModuleInterface<ISimulationBase>().EventManager.RegisterEventHandler("PreRegisterRegion", EventManager_OnGenericEvent); }
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); }); }
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); }
public void Start (IConfigSource config, IRegistryCore registry) { if (!m_enabled) return; m_registry = registry; m_registry.RequestModuleInterface<IGridRegistrationService> ().RegisterModule (this); }
public void Initialize(IGenericData unneeded, IConfigSource source, IRegistryCore simBase, string defaultConnectionString) { if (source.Configs["AuroraConnectors"].GetString("OfflineMessagesConnector", "LocalConnector") == "SimianConnector") { m_ServerURIs = simBase.RequestModuleInterface<IConfigurationService>().FindValueOf("RemoteServerURI"); DataManager.DataManager.RegisterPlugin(Name, this); } }
public void Start(IConfigSource config, IRegistryCore registry) { IConfig handlerConfig = config.Configs["Handlers"]; if (handlerConfig.GetString("NeighborInHandler", "") != Name) return; IHttpServer server = registry.RequestModuleInterface<ISimulationBase>().GetHttpServer((uint)handlerConfig.GetInt("NeighborInHandlerPort")); m_NeighborService = registry.RequestModuleInterface<INeighborService>(); m_AuthenticationService = registry.RequestModuleInterface<IAuthenticationService>(); if (m_NeighborService == null) { m_log.Error("[NEIGHBOR IN CONNECTOR]: neighbor service was not provided"); return; } server.AddStreamHandler(new NeighborHandler(m_NeighborService.InnerService, m_AuthenticationService, config)); }
public void FinishedStartup() { IMoneyModule moneyModule = m_registry.RequestModuleInterface <IMoneyModule>(); if (moneyModule != null) //Only register if money is enabled { // Register the GroupPayments Engine } }
public void Start(IConfigSource config, IRegistryCore registry) { m_registry = registry; //MainConsole.Instance.Commands.AddCommand("UrlNegotiationProcessing", true, "switch servers", // "switch servers", "Moves all regions to use a new URL base", NegotiateUrls); //Also look for incoming messages to display registry.RequestModuleInterface <IAsyncMessageRecievedService>().OnMessageReceived += OnMessageReceived; }
public void Init(IRegistryCore registry, string name) { m_registry = registry; m_name = name; IConfigSource source = registry.RequestModuleInterface<ISimulationBase>().ConfigSource; IConfig config; if ((config = source.Configs["AuroraConnectors"]) != null) m_doRemoteCalls = config.GetBoolean("DoRemoteCalls", false); }
public void Start(IConfigSource config, IRegistryCore registry) { if (!m_enabled) { return; } m_assetService = registry.RequestModuleInterface <IAssetService> (); m_inventoryService = registry.RequestModuleInterface <IInventoryService> (); m_avatarService = registry.RequestModuleInterface <IAvatarService> (); m_assetService = registry.RequestModuleInterface <IAssetService> (); MainConsole.Instance.Commands.AddCommand( "bake avatar", "bake avatar [firstname lastname]", "Bakes an avatar's appearance", HandleBakeAvatar, false, true); }
public void Start(IConfigSource config, IRegistryCore registry) { SceneManager man = registry.RequestModuleInterface<SceneManager>() ; if (man != null) { man.OnAddedScene += Init; man.OnCloseScene += RemoveScene; } }
private object CreateUserInformation(string functionname, object parameters) { UUID userid = (UUID)parameters; IUserAccountService userService = m_registry.RequestModuleInterface <IUserAccountService>(); UserAccount user = userService.GetUserAccount(null, userid); if (user == null) { return(null); } if ((m_options.StipendsPremiumOnly) && ((user.UserFlags & Constants.USER_FLAG_MEMBER) != Constants.USER_FLAG_MEMBER)) { return(null); } // Don't set a StipendPayment for System Users if (Utilities.IsSystemUser(user.PrincipalID)) { return(null); } SchedulerItem i = m_scheduler.Get(user.PrincipalID.ToString(), "StipendsPayout"); if (i != null) { return(null); } // Scheduler needs to get 1 date/time to set for "PayDay" - Fly 17/11/2014 RepeatType runevertype = (RepeatType)Enum.Parse(typeof(RepeatType), m_options.StipendsEveryType); int runevery = m_options.StipendsEvery; m_scheduler.Save(new SchedulerItem("StipendsPayout", OSDParser.SerializeJsonString( new StipendsInfo() { AgentID = user.PrincipalID }.ToOSD()), false, UnixTimeStampToDateTime(user.Created), runevery, runevertype, user.PrincipalID) { HistoryKeep = true, HistoryReceipt = true }); return(null); }
public void Start(IConfigSource config, IRegistryCore registry) { SceneManager man = registry.RequestModuleInterface <SceneManager>(); if (man != null) { man.OnAddedScene += Init; man.OnCloseScene += RemoveScene; } }
public void Start(IConfigSource config, IRegistryCore registry) { if (config.Configs["Currency"] == null || config.Configs["Currency"].GetString("Module", "") != "SimpleCurrency") { return; } // we only want this if we are local.. bool remoteCalls = false; IConfig connectorConfig = config.Configs["UniverseConnectors"]; if ((connectorConfig != null) && connectorConfig.Contains("DoRemoteCalls")) { remoteCalls = connectorConfig.GetBoolean("DoRemoteCalls", false); } if (remoteCalls) { return; } m_connector = Framework.Utilities.DataManager.RequestPlugin <ISimpleCurrencyConnector>() as BaseCurrencyConnector; var curPort = m_connector.GetConfig().ClientPort; if (curPort == 0 && MainServer.Instance == null) { return; } IHttpServer server = registry.RequestModuleInterface <ISimulationBase>().GetHttpServer((uint)curPort); 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>(); }
public void Start(IConfigSource config, IRegistryCore registry) { IConfig hgConfig = config.Configs["HyperGrid"]; if (hgConfig == null || !hgConfig.GetBoolean("Enabled", false)) { return; } IConfig friendConfig = config.Configs["HGFriends"]; if (friendConfig == null || !friendConfig.GetBoolean("Enabled", false)) { return; } MainServer.Instance.AddStreamHandler(new HGFriendsServerPostHandler(registry.RequestModuleInterface <IFriendsService>(), registry.RequestModuleInterface <IUserAgentService>())); }
public MuteList[] GetMuteList(UUID PrincipalID) { Dictionary <string, object> sendData = new Dictionary <string, object>(); sendData["PRINCIPALID"] = PrincipalID.ToString(); sendData["METHOD"] = "getmutelist"; string reqString = WebUtils.BuildQueryString(sendData); List <MuteList> Mutes = new List <MuteList>(); try { List <string> m_ServerURIs = m_registry.RequestModuleInterface <IConfigurationService>().FindValueOf(PrincipalID.ToString(), "RemoteServerURI"); foreach (string m_ServerURI in m_ServerURIs) { string reply = SynchronousRestFormsRequester.MakeRequest("POST", m_ServerURI + "/auroradata", reqString); if (reply != string.Empty) { Dictionary <string, object> replyData = WebUtils.ParseXmlResponse(reply); foreach (object f in replyData) { KeyValuePair <string, object> value = (KeyValuePair <string, object>)f; if (value.Value is Dictionary <string, object> ) { Dictionary <string, object> valuevalue = value.Value as Dictionary <string, object>; MuteList mute = new MuteList(); mute.FromKVP(valuevalue); Mutes.Add(mute); } } } } return(Mutes.ToArray()); } catch (Exception e) { m_log.DebugFormat("[AuroraRemoteMuteListConnector]: Exception when contacting server: {0}", e.ToString()); } return(Mutes.ToArray()); }
public void FinishedStartup() { if (m_registry != null) { uint port = m_config.Configs["Network"].GetUInt("http_listener_port", 8003); IHttpServer server = m_registry.RequestModuleInterface <ISimulationBase>().GetHttpServer(port); server.AddStreamHandler(new ServerHandler("/server/", m_registry, null)); } }
public void Start(IConfigSource config, IRegistryCore registry) { if (!m_enabled) { return; } m_registry = registry; m_registry.RequestModuleInterface <IGridRegistrationService>().RegisterModule(this); }
public void Initialize(IGenericData unneeded, IConfigSource source, IRegistryCore simBase, string defaultConnectionString) { if (source.Configs["AuroraConnectors"].GetString("OfflineMessagesConnector", "LocalConnector") == "SimianConnector") { m_ServerURIs = simBase.RequestModuleInterface <IConfigurationService>().FindValueOf("RemoteServerURI"); DataManager.DataManager.RegisterPlugin(this); } }
public void Start(IConfigSource config, IRegistryCore registry) { IConfig externalConfig = config.Configs ["ExternalCaps"]; if (externalConfig == null) { return; } m_allowedCapsModules = Util.ConvertToList(externalConfig.GetString("CapsHandlers"), true); ISyncMessageRecievedService service = registry.RequestModuleInterface <ISyncMessageRecievedService> (); service.OnMessageReceived += service_OnMessageReceived; m_syncPoster = registry.RequestModuleInterface <ISyncMessagePosterService> (); m_registry = registry; registry.RegisterModuleInterface <IExternalCapsHandler> (this); Init(registry, GetType().Name); }
public void Start(IConfigSource config, IRegistryCore registry) { IConfig handlerConfig = config.Configs["Handlers"]; if (handlerConfig.GetString("LLLoginHandler", "") != Name) { return; } IHttpServer server = registry.RequestModuleInterface <ISimulationBase>().GetHttpServer( (uint)handlerConfig.GetInt("LLLoginHandlerPort")); MainConsole.Instance.Debug("[LLLOGIN IN CONNECTOR]: Starting..."); ReadLocalServiceFromConfig(config); m_loginService = registry.RequestModuleInterface <ILoginService>(); InitializeHandlers(server); }
public void CacheWearableData(UUID principalID, AvatarWearable wearable) { if (!m_enableCacheBakedTextures) { IAssetService service = m_registry.RequestModuleInterface <IAssetService>(); if (service != null) { //Remove the old baked textures then from the DB as we don't want to keep them around foreach (UUID texture in wearable.GetItems().Values) { service.Delete(texture.ToString()); } } return; } wearable.MaxItems = 0; //Unlimited items /*AvatarBaseData baseData = new AvatarBaseData(); * AvatarBaseData[] av = m_CacheDatabase.Get("PrincipalID", principalID.ToString()); * foreach (AvatarBaseData abd in av) * { * //If we have one already made, keep what is already there * if (abd.Data["Name"] == "CachedWearables") * { * baseData = abd; * OSDArray array = (OSDArray)OSDParser.DeserializeJson(abd.Data["Value"]); * AvatarWearable w = new AvatarWearable(); * w.MaxItems = 0; //Unlimited items * w.Unpack(array); * foreach (KeyValuePair<UUID, UUID> kvp in w.GetItems()) * { * wearable.Add(kvp.Key, kvp.Value); * } * } * } * //If we don't have one, set it up for saving a new one * if (baseData.Data == null) * { * baseData.PrincipalID = principalID; * baseData.Data = new Dictionary<string, string>(); * baseData.Data.Add("Name", "CachedWearables"); * } * baseData.Data["Value"] = OSDParser.SerializeJsonString(wearable.Pack()); * try * { * bool store = m_CacheDatabase.Store(baseData); * if (!store) * { * m_log.Warn("[AvatarService]: Issue saving the cached wearables to the database."); * } * } * catch * { * }*/ }
private bool AddToQueue(OSD ev, UUID avatarID, ulong regionHandle, bool runasync) { //MainConsole.Instance.DebugFormat("[EVENTQUEUE]: Enqueuing event for {0} in region {1}", avatarID, m_scene.RegionInfo.RegionName); if (ev == null) { return(false); } try { OSDMap request = new OSDMap { { "AgentID", avatarID }, { "RegionHandle", regionHandle } }; OSDArray events = new OSDArray { OSDParser.SerializeLLSDXmlString(ev) }; //Note: we HAVE to convert it to xml, otherwise things like byte[] arrays will not be passed through correctly! request.Add("Events", events); IConfigurationService configService = m_registry.RequestModuleInterface <IConfigurationService>(); List <string> serverURIs = configService.FindValueOf(avatarID.ToString(), regionHandle.ToString(), "EventQueueServiceURI"); foreach (string serverURI in serverURIs) { if (serverURI != "") { if (runasync) { /*AsynchronousRestObjectRequester.MakeRequest("POST", serverURI + "/CAPS/EQMPOSTER", * OSDParser.SerializeJsonString(request), * delegate(string resp) * { * return RequestHandler(resp, events, avatarID, regionHandle); * }); * * return true;*/ string resp = SynchronousRestFormsRequester.MakeRequest("POST", serverURI + "/CAPS/EQMPOSTER", OSDParser.SerializeJsonString(request)); return(RequestHandler(resp, events, avatarID, regionHandle)); } else { string resp = SynchronousRestFormsRequester.MakeRequest("POST", serverURI + "/CAPS/EQMPOSTER", OSDParser.SerializeJsonString(request)); return(RequestHandler(resp, events, avatarID, regionHandle)); } } } } catch (Exception e) { MainConsole.Instance.Error("[EVENTQUEUE] Caught exception: " + e); } return(false); }
public void FinishedStartup() { if (m_registry == null) { return; } m_registry.RegisterModuleInterface <IMoneyModule>(this); ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>(); if (manager != null) { manager.OnAddedScene += (scene) => { m_scenes.Add(scene); scene.EventManager.OnNewClient += OnNewClient; scene.EventManager.OnClosingClient += OnClosingClient; scene.EventManager.OnMakeRootAgent += OnMakeRootAgent; scene.EventManager.OnValidateBuyLand += EventManager_OnValidateBuyLand; scene.RegisterModuleInterface <IMoneyModule>(this); }; manager.OnCloseScene += (scene) => { scene.EventManager.OnNewClient -= OnNewClient; scene.EventManager.OnClosingClient -= OnClosingClient; scene.EventManager.OnMakeRootAgent -= OnMakeRootAgent; scene.EventManager.OnValidateBuyLand -= EventManager_OnValidateBuyLand; scene.RegisterModuleInterface <IMoneyModule>(this); m_scenes.Remove(scene); }; } if (!m_connector.DoRemoteCalls) { if ((m_connector.GetConfig().GiveStipends) && (m_connector.GetConfig().Stipend > 0)) { new GiveStipends(m_connector.GetConfig(), m_registry, m_connector); } } }
public void AddAbuseReport(AbuseReport abuse_report) { try { List <string> m_ServerURIs = m_registry.RequestModuleInterface <IConfigurationService>().FindValueOf("RemoteServerURI"); foreach (string m_ServerURI in m_ServerURIs) { Dictionary <string, object> ar = abuse_report.ToKeyValuePairs(); ar.Add("METHOD", "AddAbuseReport"); SynchronousRestFormsRequester.MakeRequest("POST", m_ServerURI + "/abusereport", WebUtils.BuildQueryString(ar)); } } catch (Exception e) { m_log.DebugFormat("[ABUSEREPORT CONNECTOR]: Exception when contacting friends server: {0}", e.Message); } }
/// <summary> /// Remove the all of the user's CAPS from the system /// </summary> /// <param name="agentID"></param> public void RemoveCAPS(UUID agentID) { if (m_ClientCapsServices.ContainsKey(agentID)) { IClientCapsService perClient = m_ClientCapsServices [agentID]; perClient.Close(); m_ClientCapsServices.Remove(agentID); m_registry.RequestModuleInterface <ISimulationBase> () .EventManager.FireGenericEventHandler("UserLogout", agentID); } }
public virtual AssetBase Get(string id) { IImprovedAssetCache cache = m_registry.RequestModuleInterface <IImprovedAssetCache>(); if (cache != null) { AssetBase cachedAsset = cache.Get(id); if (cachedAsset != null && cachedAsset.Data.Length != 0) { return(cachedAsset); } } AssetBase asset = m_database.GetAsset(UUID.Parse(id)); if (cache != null && asset != null) { cache.Cache(asset); } return(asset); }
public virtual void Start(IConfigSource config, IRegistryCore registry) { IConfig handlerConfig = config.Configs["Handlers"]; if (handlerConfig.GetString("AssetHandler", "") != Name) { return; } SetCache(registry.RequestModuleInterface <IImprovedAssetCache>()); }
public void FinishedStartup() { m_accountService = m_registry.RequestModuleInterface <IUserAccountService> (); // these are only valid if we are local if (m_accountService.IsLocalConnector) { // check and/or create default RealEstate user CheckSystemUserInfo(); // if this is the initial run, create the grid system user var users = m_accountService.NumberOfUserAccounts(null, ""); if (users == 0) { CreateGridOwnerUser(); } AddCommands(); } }
public void Start(IConfigSource config, IRegistryCore registry) { ISimulationBase simBase = registry.RequestModuleInterface <ISimulationBase>(); m_server = simBase.GetHttpServer(0); if (MainConsole.Instance != null) { MainConsole.Instance.Commands.AddCommand("show presences", "show presences", "Shows all presences in the grid", ShowUsers); } }
private void LoadPreviouslyLoadedArchives(IRegistryCore registry) { IUserAccountService UserAccountService = registry.RequestModuleInterface <IUserAccountService>(); UserAccount uinfo = UserAccountService.GetUserAccount(UUID.Zero, LibraryOwner); IInventoryService InventoryService = registry.RequestModuleInterface <IInventoryService>(); //Make the user account for the default IAR if (uinfo == null) { uinfo = new UserAccount(LibraryOwner); uinfo.Name = LibraryOwnerName; uinfo.Email = ""; uinfo.ServiceURLs = new Dictionary <string, object>(); uinfo.UserLevel = 0; uinfo.UserFlags = 0; uinfo.ScopeID = UUID.Zero; uinfo.UserTitle = ""; UserAccountService.StoreUserAccount(uinfo); InventoryService.CreateUserInventory(uinfo.PrincipalID); uinfo = UserAccountService.GetUserAccount(UUID.Zero, LibraryOwner); if (uinfo == null) { //Grid mode, can't create the user... leave return; } } InventoryCollection col = InventoryService.GetFolderContent(LibraryOwner, UUID.Zero); foreach (InventoryFolderBase folder in col.Folders) { if (folder.Name == "My Inventory") { continue; //Pass My Inventory by } InventoryFolderImpl f = new InventoryFolderImpl(folder); TraverseFolders(f, folder.ID, InventoryService); //This is our loaded folder AddToDefaultInventory(f); } }
public void FinishedStartup() { if (m_registry == null) { return; } m_registry.RegisterModuleInterface <IMoneyModule>(this); ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager> (); if (manager != null) { manager.OnAddedScene += (scene) => { m_scenes.Add(scene); scene.EventManager.OnNewClient += OnNewClient; scene.EventManager.OnClosingClient += OnClosingClient; scene.EventManager.OnMakeRootAgent += OnMakeRootAgent; scene.EventManager.OnValidateBuyLand += EventManager_OnValidateBuyLand; scene.RegisterModuleInterface <IMoneyModule> (this); }; manager.OnCloseScene += (scene) => { scene.EventManager.OnNewClient -= OnNewClient; scene.EventManager.OnClosingClient -= OnClosingClient; scene.EventManager.OnMakeRootAgent -= OnMakeRootAgent; scene.EventManager.OnValidateBuyLand -= EventManager_OnValidateBuyLand; scene.RegisterModuleInterface <IMoneyModule> (this); m_scenes.Remove(scene); }; } // these are only valid if we are local if (m_connector.IsLocalConnector) { m_userInfoService = m_registry.RequestModuleInterface <IAgentInfoService> (); m_userAccountService = m_registry.RequestModuleInterface <IUserAccountService> (); AddCommands(); } }
object EventManager_OnGenericEvent(string FunctionName, object parameters) { if (FunctionName != "PreRegisterRegion") { return(null); } IConfig handlerConfig = m_config.Configs["Handlers"]; if (handlerConfig.GetString("SimulationInHandler", "") != Name) { return(null); } if (m_LocalSimulationService != null) { return(null); } bool secure = handlerConfig.GetBoolean("SecureSimulation", true); IHttpServer server = m_registry.RequestModuleInterface <ISimulationBase>().GetHttpServer((uint)handlerConfig.GetInt("SimulationInHandlerPort")); m_LocalSimulationService = m_registry.RequestModuleInterface <ISimulationService>(); string path = "/" + UUID.Random().ToString() + "/agent/"; IGridRegisterModule registerModule = m_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(), m_config).Handler); return(null); }
public void FinishedStartup() { if (!m_enabled) { return; } IGridServerInfoService serverInfo = m_registry.RequestModuleInterface <IGridServerInfoService>(); if (serverInfo != null) { serverInfo.AddURI("SSAService", ServiceURI); } else { IGridInfo gridInfo = m_registry.RequestModuleInterface <IGridInfo>(); if (gridInfo != null) { gridInfo.AgentAppearanceURI = ServiceURI; } } }
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", ""); } m_AuthenticationService = registry.RequestModuleInterface <IAuthenticationService>(); m_LoginService = service; }
public string GetJsonConfig() { List <string> serverURIs = m_registry.RequestModuleInterface <IConfigurationService>().FindValueOf("FreeswitchServiceURL"); foreach (string m_ServerURI in serverURIs) { m_log.DebugFormat("[FREESWITCH CONNECTOR]: Requesting config from {0}", m_ServerURI); return(SynchronousRestFormsRequester.MakeRequest("GET", m_ServerURI, String.Empty)); } return(""); }
public void AddExistingUrlForClient(string SessionID, string url, uint port) { IHttpServer server = m_registry.RequestModuleInterface <ISimulationBase>().GetHttpServer(port); server.AddStreamHandler(new EQMEventPoster(url, m_registry.RequestModuleInterface <IEventQueueService>(). InnerService, m_registry.RequestModuleInterface <ICapsService>(), SessionID, m_registry)); }
public void Start(IConfigSource config, IRegistryCore registry) { IConfig handlerConfig = config.Configs["Handlers"]; if (handlerConfig.GetString("OpenIdHandler", "") != Name) { return; } IHttpServer server = registry.RequestModuleInterface <ISimulationBase>().GetHttpServer((uint)handlerConfig.GetInt("OpenIdHandlerPort")); m_AuthenticationService = registry.RequestModuleInterface <IAuthenticationService>(); m_UserAccountService = registry.RequestModuleInterface <IUserAccountService>(); // Handler for OpenID user identity pages server.AddStreamHandler(new OpenIdStreamHandler("GET", "/users/", m_UserAccountService, m_AuthenticationService)); // Handlers for the OpenID endpoint server server.AddStreamHandler(new OpenIdStreamHandler("POST", "/openid/server/", m_UserAccountService, m_AuthenticationService)); server.AddStreamHandler(new OpenIdStreamHandler("GET", "/openid/server/", m_UserAccountService, m_AuthenticationService)); m_log.Info("[OPENID]: OpenId service enabled"); }