public void FinishedStartup()
{
if (m_registry == null)
return; //Not enabled
m_CapsService = m_registry.RequestModuleInterface<ICapsService> ();
m_GridService = m_registry.RequestModuleInterface<IGridService> ();
m_PresenceService = m_registry.RequestModuleInterface<IAgentInfoService> ();
m_UserAccountService = m_registry.RequestModuleInterface<IUserAccountService> ();
m_UserAgentService = m_registry.RequestModuleInterface<IUserAgentService> ();
m_SimulationService = m_registry.RequestModuleInterface<ISimulationService> ();
m_DefaultGatewayRegion = FindDefaultRegion ();
}
public ClientDetailQueries(IDapperContext dapperContext, IIdentityService identityService, ISystemDateTimeService systemDateTimeService, IGridService gridQueries)
: base(dapperContext)
{
_identityService = identityService ?? throw new ArgumentNullException(nameof(identityService));
_systemDateTimeService = systemDateTimeService ?? throw new ArgumentNullException(nameof(systemDateTimeService));
_gridQueries = gridQueries ?? throw new ArgumentNullException(nameof(gridQueries));
}
public HGInstantMessageService(IConfigSource config, IInstantMessageSimConnector imConnector)
{
if (imConnector != null)
{
m_IMSimConnector = imConnector;
}
if (!m_Initialized)
{
m_Initialized = true;
IConfig serverConfig = config.Configs["HGInstantMessageService"];
if (serverConfig == null)
{
throw new Exception(String.Format("No section HGInstantMessageService in config file"));
}
string gridService = serverConfig.GetString("GridService", String.Empty);
string presenceService = serverConfig.GetString("PresenceService", String.Empty);
string userAgentService = serverConfig.GetString("UserAgentService", String.Empty);
m_InGatekeeper = serverConfig.GetBoolean("InGatekeeper", false);
m_log.DebugFormat("[HG IM SERVICE]: Starting... InRobust? {0}", m_InGatekeeper);
if (gridService == string.Empty || presenceService == string.Empty)
{
throw new Exception(String.Format("Incomplete specifications, InstantMessage Service cannot function."));
}
Object[] args = new Object[] { config };
m_GridService = ServerUtils.LoadPlugin <IGridService>(gridService, args);
m_PresenceService = ServerUtils.LoadPlugin <IPresenceService>(presenceService, args);
try
{
m_UserAgentService = ServerUtils.LoadPlugin <IUserAgentService>(userAgentService, args);
}
catch
{
m_log.WarnFormat("[HG IM SERVICE]: Unable to create User Agent Service. Missing config var in [HGInstantMessageService]?");
}
m_RegionCache = new ExpiringCache <UUID, GridRegion>();
IConfig cnf = config.Configs["Messaging"];
if (cnf == null)
{
return;
}
m_ForwardOfflineGroupMessages = cnf.GetBoolean("ForwardOfflineGroupMessages", false);
if (m_InGatekeeper)
{
string offlineIMService = cnf.GetString("OfflineIMService", string.Empty);
if (offlineIMService != string.Empty)
{
m_OfflineIMService = ServerUtils.LoadPlugin <IOfflineIMService>(offlineIMService, args);
}
}
}
}
private static void checkGridServices()
{
if (gridServicesByKey == null)
{
gridServicesByKey = new Dictionary <string, IGridService>();
var attributes = AppController.Instance.AssemblyAttributes[typeof(AppServiceAttribute)];
foreach (AppServiceAttribute attr in attributes)
{
if (attr.ServiceInterface != typeof(IGridService))
{
continue;
}
var service = (IGridService)attr.ServiceType.GetConstructor(new Type[0]).Invoke(new object[0]);
var keys = service.GetAvailableKeys();
if (keys == null)
{
defaultGridService = service;
}
else
{
foreach (var key in keys)
{
gridServicesByKey[key] = service;
}
}
}
if (defaultGridService == null)
{
defaultGridService = new GridService();
}
}
}
/// <summary>
/// Server side
/// </summary>
/// <param name="FunctionName"></param>
/// <param name="parameters"></param>
/// <returns></returns>
protected object OnGenericEvent(string FunctionName, object parameters)
{
if (FunctionName == "EstateUpdated")
{
EstateSettings es = (EstateSettings)parameters;
IEstateConnector estateConnector = Framework.Utilities.DataManager.RequestPlugin <IEstateConnector>();
ISyncMessagePosterService asyncPoster =
m_registry.RequestModuleInterface <ISyncMessagePosterService>();
IGridService gridService = m_registry.RequestModuleInterface <IGridService>();
if (estateConnector != null)
{
List <UUID> regions = estateConnector.GetRegions((int)es.EstateID);
if (regions != null)
{
foreach (UUID region in regions)
{
//Send the message to update all regions that are in this estate, as a setting changed
if (gridService != null && asyncPoster != null)
{
GridRegion r = gridService.GetRegionByUUID(null, region);
if (r != null)
{
asyncPoster.Post(r.ServerURI,
SyncMessageHelper.UpdateEstateInfo(es.EstateID, region));
}
}
}
}
}
}
return(null);
}
/// <summary>
/// Gets user information for change user info page on site
/// </summary>
/// <param name="map">UUID</param>
/// <returns>Verified, HomeName, HomeUUID, Online, Email, FirstName, LastName</returns>
byte[] GetGridUserInfo(OSDMap map)
{
string uuid = String.Empty;
uuid = map["UUID"].AsString();
IUserAccountService accountService = m_registry.RequestModuleInterface <IUserAccountService>();
UserAccount user = accountService.GetUserAccount(UUID.Zero, map["UUID"].AsUUID());
IAgentInfoService agentService = m_registry.RequestModuleInterface <IAgentInfoService>();
UserInfo userinfo;
OSDMap resp = new OSDMap();
bool verified = user != null;
resp["Verified"] = OSD.FromBoolean(verified);
if (verified)
{
userinfo = agentService.GetUserInfo(uuid);
IGridService gs = m_registry.RequestModuleInterface <IGridService>();
Services.Interfaces.GridRegion gr = gs.GetRegionByUUID(UUID.Zero, userinfo.HomeRegionID);
resp["HomeUUID"] = OSD.FromUUID(userinfo.HomeRegionID);
resp["HomeName"] = OSD.FromString(gr.RegionName);
resp["Online"] = OSD.FromBoolean(userinfo.IsOnline);
resp["Email"] = OSD.FromString(user.Email);
resp["Name"] = OSD.FromString(user.Name);
}
string xmlString = OSDParser.SerializeJsonString(resp);
UTF8Encoding encoding = new UTF8Encoding();
return(encoding.GetBytes(xmlString));
}
public void RegisterCaps(IRegionClientCapsService service)
{
m_service = service;
m_gridService = service.Registry.RequestModuleInterface <IGridService>();
IConfig config =
service.ClientCaps.Registry.RequestModuleInterface <ISimulationBase>().ConfigSource.Configs["MapCaps"];
if (config != null)
{
m_allowCapsMessage = config.GetBoolean("AllowCapsMessage", m_allowCapsMessage);
}
HttpServerHandle method = delegate(string path, Stream request, OSHttpRequest httpRequest,
OSHttpResponse httpResponse)
{
return(MapLayerRequest(request.ReadUntilEnd(), httpRequest, httpResponse, m_service.AgentID));
};
m_service.AddStreamHandler("MapLayer",
new GenericStreamHandler("POST", m_service.CreateCAPS("MapLayer", ""),
method));
m_service.AddStreamHandler("MapLayerGod",
new GenericStreamHandler("POST", m_service.CreateCAPS("MapLayerGod", ""),
method));
}
public void Close(IScene scene)
{
//Deregister the interface
scene.UnregisterModuleInterface <IGridRegisterModule>(this);
m_scenes.Remove(scene);
MainConsole.Instance.InfoFormat("[RegisterRegionWithGrid]: Deregistering region {0} from the grid...",
scene.RegionInfo.RegionName);
//Deregister from the grid server
IGridService GridService = scene.RequestModuleInterface <IGridService>();
GridRegion r = BuildGridRegion(scene.RegionInfo);
r.IsOnline = false;
string error = "";
if (scene.RegionInfo.HasBeenDeleted)
{
GridService.DeregisterRegion(r);
}
else if ((error = GridService.UpdateMap(r)) != "")
{
MainConsole.Instance.WarnFormat("[RegisterRegionWithGrid]: Deregister from grid failed for region {0}, {1}",
scene.RegionInfo.RegionName, error);
}
}
public MapAddServiceConnector(IConfigSource config, IHttpServer server, string configName) :
base(config, server, configName)
{
IConfig serverConfig = config.Configs[m_ConfigName];
if (serverConfig == null)
throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
string mapService = serverConfig.GetString("LocalServiceModule",
String.Empty);
if (mapService == String.Empty)
throw new Exception("No LocalServiceModule in config file");
Object[] args = new Object[] { config };
m_MapService = ServerUtils.LoadPlugin<IMapImageService>(mapService, args);
string gridService = serverConfig.GetString("GridService", String.Empty);
if (gridService != string.Empty)
m_GridService = ServerUtils.LoadPlugin<IGridService>(gridService, args);
if (m_GridService != null)
m_log.InfoFormat("[MAP IMAGE HANDLER]: GridService check is ON");
else
m_log.InfoFormat("[MAP IMAGE HANDLER]: GridService check is OFF");
bool proxy = serverConfig.GetBoolean("HasProxy", false);
IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
server.AddStreamHandler(new MapServerPostHandler(m_MapService, m_GridService, proxy, auth));
}
private bool InitialiseServices(IConfigSource source)
{
IConfig gridConfig = source.Configs["GridService"];
if (gridConfig == null)
{
m_log.Error("[REMOTE GRID CONNECTOR]: GridService missing from OpenSim.ini");
return(false);
}
string networkConnector = gridConfig.GetString("NetworkConnector", string.Empty);
if (networkConnector == string.Empty)
{
m_log.Error("[REMOTE GRID CONNECTOR]: Please specify a network connector under [GridService]");
return(false);
}
Object[] args = new Object[] { source };
m_RemoteGridService = ServerUtils.LoadPlugin <IGridService>(networkConnector, args);
m_LocalGridService = new LocalGridServicesConnector(source, m_RegionInfoCache);
if (m_LocalGridService == null)
{
m_log.Error("[REMOTE GRID CONNECTOR]: failed to load local connector");
return(false);
}
if (m_RegionInfoCache == null)
{
m_RegionInfoCache = new RegionInfoCache();
}
return(true);
}
public DefaultRailsEditViewFactoryBase(
IRailsIndexViewFactory <UIElement> railsIndexViewFactory,
IRailsEditViewModelFactory <Binding> railsEditViewModelFactory,
IGridService gridService)
: base(railsIndexViewFactory, railsEditViewModelFactory, gridService)
{
}
private bool InitialiseService(IConfigSource source, RegionInfoCache ric)
{
if(ric == null && m_RegionInfoCache == null)
m_RegionInfoCache = new RegionInfoCache();
else
m_RegionInfoCache = ric;
IConfig config = source.Configs["GridService"];
if (config == null)
{
m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: GridService missing from OpenSim.ini");
return false;
}
string serviceDll = config.GetString("LocalServiceModule", String.Empty);
if (serviceDll == String.Empty)
{
m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: No LocalServiceModule named in section GridService");
return false;
}
Object[] args = new Object[] { source };
m_GridService = ServerUtils.LoadPlugin<IGridService>(serviceDll, args);
if (m_GridService == null)
{
m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: Can't load grid service");
return false;
}
m_Enabled = true;
return true;
}
protected DefaultRailsEditViewFactoryBase(
IRailsIndexViewFactory railsIndexViewFactory,
IRailsEditViewModelFactory railsEditViewModelFactory,
IGridService gridService)
: base(railsIndexViewFactory, railsEditViewModelFactory, gridService)
{
}
public GridServiceConnector(IConfigSource config, IHttpServer server, string configName) :
base(config, server, configName)
{
IConfig serverConfig = config.Configs[m_ConfigName];
if (serverConfig == null)
{
throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
}
string gridService = serverConfig.GetString("LocalServiceModule",
String.Empty);
if (gridService == String.Empty)
{
throw new Exception("No LocalServiceModule in config file");
}
Object[] args = new Object[] { config };
m_GridService = ServerUtils.LoadPlugin <IGridService>(gridService, args);
IServiceAuth auth = ServiceAuth.Create(config, m_ConfigName);
server.AddStreamHandler(new GridServerPostHandler(m_GridService, auth));
}
public SectionQueries(IDapperContext dapperContext, IIdentityService identityService, ISystemDateTimeService systemDateTimeService, IUserService userService, IMapper mapper, IGridService gridQueries)
: base(dapperContext)
{
_identityService = identityService ?? throw new ArgumentNullException(nameof(identityService));
_systemDateTimeService = systemDateTimeService ?? throw new ArgumentNullException(nameof(systemDateTimeService));
_userService = userService ?? throw new ArgumentNullException(nameof(userService));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_gridQueries = gridQueries ?? throw new ArgumentNullException(nameof(gridQueries));
SqlMapper.SetTypeMap(
typeof(SectionSummaryDto),
new ColumnAttributeTypeMapper <SectionSummaryDto>());
SqlMapper.SetTypeMap(
typeof(PhysicalContractDtoDeprecated),
new ColumnAttributeTypeMapper <PhysicalContractDtoDeprecated>());
SqlMapper.SetTypeMap(
typeof(TradeDto),
new ColumnAttributeTypeMapper <TradeDto>());
SqlMapper.SetTypeMap(
typeof(CostDto),
new ColumnAttributeTypeMapper <CostDto>());
SqlMapper.SetTypeMap(
typeof(SectionDto),
new ColumnAttributeTypeMapper <SectionDto>());
SqlMapper.SetTypeMap(
typeof(TradeCostGenerateMonthEndDto),
new ColumnAttributeTypeMapper <TradeCostGenerateMonthEndDto>());
SqlMapper.SetTypeMap(
typeof(FxDealDetailsGenerateMonthEndDto),
new ColumnAttributeTypeMapper <FxDealDetailsGenerateMonthEndDto>());
}
private void InitialiseService(IConfigSource source)
{
IConfig config = source.Configs["GridService"];
if (config == null)
{
m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: GridService missing from OpenSim.ini");
return;
}
string serviceDll = config.GetString("LocalServiceModule", String.Empty);
if (serviceDll == String.Empty)
{
m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: No LocalServiceModule named in section GridService");
return;
}
Object[] args = new Object[] { source };
m_GridService =
ServerUtils.LoadPlugin <IGridService>(serviceDll,
args);
if (m_GridService == null)
{
m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: Can't load grid service");
return;
}
m_Enabled = true;
}
public MapServerPostHandler(IMapImageService service, IGridService grid, bool proxy, IServiceAuth auth) :
base("POST", "/map", auth)
{
m_MapService = service;
m_GridService = grid;
m_Proxy = proxy;
}
protected void HandleResetMainlandEstate(IScene scene, string [] cmd)
{
CheckSystemEstateInfo(Constants.MainlandEstateID, mainlandEstateName, (UUID)Constants.GovernorUUID);
IGridService gridService = m_registry.RequestModuleInterface <IGridService> ();
IEstateConnector estateConnector = Framework.Utilities.DataManager.RequestPlugin <IEstateConnector> ();
var regions = gridService.GetRegionsByName(null, "", null, null);
if (regions == null || regions.Count < 1)
{
return;
}
int updated = 0;
foreach (var region in regions)
{
string regType = region.RegionType.ToLower();
if (regType.StartsWith("m", StringComparison.Ordinal))
{
estateConnector.LinkRegion(region.RegionID, Constants.MainlandEstateID);
updated++;
}
}
if (updated > 0)
{
MainConsole.Instance.InfoFormat("Relinked {0} mainland regions", updated);
}
}
public GatekeeperService(IConfigSource config, ISimulationService simService)
{
if (!m_Initialized)
{
m_Initialized = true;
IConfig serverConfig = config.Configs["GatekeeperService"];
if (serverConfig == null)
{
throw new Exception(String.Format("No section GatekeeperService in config file"));
}
string accountService = serverConfig.GetString("UserAccountService", String.Empty);
string homeUsersService = serverConfig.GetString("UserAgentService", string.Empty);
string gridService = serverConfig.GetString("GridService", String.Empty);
string presenceService = serverConfig.GetString("PresenceService", String.Empty);
string simulationService = serverConfig.GetString("SimulationService", String.Empty);
// These 3 are mandatory, the others aren't
if (gridService == string.Empty || presenceService == string.Empty)
{
throw new Exception("Incomplete specifications, Gatekeeper Service cannot function.");
}
string scope = serverConfig.GetString("ScopeID", UUID.Zero.ToString());
UUID.TryParse(scope, out m_ScopeID);
//m_WelcomeMessage = serverConfig.GetString("WelcomeMessage", "Welcome to OpenSim!");
m_AllowTeleportsToAnyRegion = serverConfig.GetBoolean("AllowTeleportsToAnyRegion", true);
m_ExternalName = serverConfig.GetString("ExternalName", string.Empty);
Object[] args = new Object[] { config };
m_GridService = ServerUtils.LoadPlugin <IGridService>(gridService, args);
m_PresenceService = ServerUtils.LoadPlugin <IPresenceService>(presenceService, args);
if (accountService != string.Empty)
{
m_UserAccountService = ServerUtils.LoadPlugin <IUserAccountService>(accountService, args);
}
if (homeUsersService != string.Empty)
{
m_UserAgentService = ServerUtils.LoadPlugin <IUserAgentService>(homeUsersService, args);
}
if (simService != null)
{
m_SimulationService = simService;
}
else if (simulationService != string.Empty)
{
m_SimulationService = ServerUtils.LoadPlugin <ISimulationService>(simulationService, args);
}
if (m_GridService == null || m_PresenceService == null || m_SimulationService == null)
{
throw new Exception("Unable to load a required plugin, Gatekeeper Service cannot function.");
}
m_log.Debug("[GATEKEEPER SERVICE]: Starting...");
}
}
public MapServerRemoveHandler(IMapImageService service, IGridService grid, bool proxy) :
base("POST", "/removemap")
{
m_MapService = service;
m_GridService = grid;
m_Proxy = proxy;
}
public MessageRegionModule(MessageServerConfig config, IGridServiceCore messageCore)
{
m_cfg = config;
m_messageCore = messageCore;
m_GridService = new GridServicesConnector(m_cfg.GridServerURL);
}
public void RegisterCaps(IRegionClientCapsService service)
{
m_service = service;
m_gridService = service.Registry.RequestModuleInterface <IGridService>();
IConfig config =
service.ClientCaps.Registry.RequestModuleInterface <ISimulationBase>().ConfigSource.Configs["MapCaps"];
if (config != null)
{
m_allowCapsMessage = config.GetBoolean("AllowCapsMessage", m_allowCapsMessage);
}
#if (!ISWIN)
RestMethod method = delegate(string request, string path, string param,
OSHttpRequest httpRequest, OSHttpResponse httpResponse)
{
return(MapLayerRequest(request, path, param, httpRequest, httpResponse, m_service.AgentID));
};
#else
RestMethod method =
(request, path, param, httpRequest, httpResponse) =>
MapLayerRequest(request, path, param, httpRequest, httpResponse,
m_service.AgentID);
#endif
m_service.AddStreamHandler("MapLayer",
new RestStreamHandler("POST", m_service.CreateCAPS("MapLayer", m_mapLayerPath),
method));
m_service.AddStreamHandler("MapLayerGod",
new RestStreamHandler("POST", m_service.CreateCAPS("MapLayerGod", m_mapLayerPath),
method));
}
public void IncomingCapsRequest(UUID agentID, Aurora.Framework.Services.GridRegion region, ISimulationBase simbase, ref OSDMap capURLs)
{
m_agentID = agentID;
m_region = region;
m_userScopeIDs = simbase.ApplicationRegistry.RequestModuleInterface <IUserAccountService>().GetUserAccount(null, m_agentID).AllScopeIDs;
m_gridService = simbase.ApplicationRegistry.RequestModuleInterface <IGridService>();
IConfig config =
simbase.ConfigSource.Configs["MapCaps"];
if (config != null)
{
m_allowCapsMessage = config.GetBoolean("AllowCapsMessage", m_allowCapsMessage);
}
HttpServerHandle method = delegate(string path, Stream request, OSHttpRequest httpRequest,
OSHttpResponse httpResponse)
{
return(MapLayerRequest(HttpServerHandlerHelpers.ReadString(request), httpRequest, httpResponse));
};
m_uri = "/CAPS/MapLayer/" + UUID.Random() + "/";
capURLs["MapLayer"] = MainServer.Instance.ServerURI + m_uri;
capURLs["MapLayerGod"] = MainServer.Instance.ServerURI + m_uri;
MainServer.Instance.AddStreamHandler(new GenericStreamHandler("POST", m_uri, method));
}
public void RegisterCaps(IRegionClientCapsService service)
{
m_service = service;
m_gridService = service.Registry.RequestModuleInterface<IGridService>();
IConfig config =
service.ClientCaps.Registry.RequestModuleInterface<ISimulationBase>().ConfigSource.Configs["MapCaps"];
if (config != null)
m_allowCapsMessage = config.GetBoolean("AllowCapsMessage", m_allowCapsMessage);
#if (!ISWIN)
RestMethod method = delegate(string request, string path, string param,
OSHttpRequest httpRequest, OSHttpResponse httpResponse)
{
return MapLayerRequest(request, path, param, httpRequest, httpResponse, m_service.AgentID);
};
#else
RestMethod method =
(request, path, param, httpRequest, httpResponse) =>
MapLayerRequest(request, path, param, httpRequest, httpResponse,
m_service.AgentID);
#endif
m_service.AddStreamHandler("MapLayer",
new RestStreamHandler("POST", m_service.CreateCAPS("MapLayer", m_mapLayerPath),
method));
m_service.AddStreamHandler("MapLayerGod",
new RestStreamHandler("POST", m_service.CreateCAPS("MapLayerGod", m_mapLayerPath),
method));
}
public void Initialize()
{
_userInput = new UserInput();
_userInput.ApplicationUserInput();
_gridService = new GridService(_userInput.Rows, _userInput.Cols);
_gridService.CreateGrid(_userInput.Rows, _userInput.Cols);
}
/// <summary>
/// Constructor sets dependent components.
/// </summary>
/// <param name="administrationPortalService">Provides generic administration features.</param>
/// <param name="gridService">Used to construct grid view models.</param>
/// <param name="masterPageService">Provides access to master pages.</param>
/// <param name="masterPageConverter">Converts between master page business and view models.</param>
/// <param name="webHelperService">Provides access to low level web components.</param>
public MasterPagePortalService(IAdministrationPortalService administrationPortalService, IGridService gridService, IMasterPageService masterPageService, IModelConverter <MasterPage, MasterPageViewModel> masterPageConverter, IWebHelperService webHelperService)
{
_administrationPortalService = administrationPortalService;
_gridService = gridService;
_masterPageService = masterPageService;
_masterPageConverter = masterPageConverter;
_webHelperService = webHelperService;
}
public void RegionLoaded(Scene scene)
{
if (m_gridservice == null)
{
m_gridservice = scene.GridService;
m_stupidScope = scene.RegionInfo.ScopeID;
}
}
public UserAccountService(IConfigSource config)
: base(config)
{
IConfig userConfig = config.Configs["UserAccountService"];
if (userConfig == null)
throw new Exception("No UserAccountService configuration");
string gridServiceDll = userConfig.GetString("GridService", string.Empty);
if (gridServiceDll != string.Empty)
m_GridService = LoadPlugin<IGridService>(gridServiceDll, new Object[] { config });
string authServiceDll = userConfig.GetString("AuthenticationService", string.Empty);
if (authServiceDll != string.Empty)
m_AuthenticationService = LoadPlugin<IAuthenticationService>(authServiceDll, new Object[] { config });
string presenceServiceDll = userConfig.GetString("GridUserService", string.Empty);
if (presenceServiceDll != string.Empty)
m_GridUserService = LoadPlugin<IGridUserService>(presenceServiceDll, new Object[] { config });
string invServiceDll = userConfig.GetString("InventoryService", string.Empty);
if (invServiceDll != string.Empty)
m_InventoryService = LoadPlugin<IInventoryService>(invServiceDll, new Object[] { config });
string avatarServiceDll = userConfig.GetString("AvatarService", string.Empty);
if (avatarServiceDll != string.Empty)
m_AvatarService = LoadPlugin<IAvatarService>(avatarServiceDll, new Object[] { config });
m_CreateDefaultAvatarEntries = userConfig.GetBoolean("CreateDefaultAvatarEntries", false);
// In case there are several instances of this class in the same process,
// the console commands are only registered for the root instance
if (m_RootInstance == null && MainConsole.Instance != null)
{
m_RootInstance = this;
MainConsole.Instance.Commands.AddCommand("Users", false,
"create user",
"create user [<first> [<last> [<pass> [<email> [<user id>]]]]]",
"Create a new user", HandleCreateUser);
MainConsole.Instance.Commands.AddCommand("Users", false,
"reset user password",
"reset user password [<first> [<last> [<password>]]]",
"Reset a user password", HandleResetUserPassword);
MainConsole.Instance.Commands.AddCommand("Users", false,
"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);
MainConsole.Instance.Commands.AddCommand("Users", false,
"show account",
"show account <first> <last>",
"Show account details for the given user", HandleShowAccount);
}
}
public UserAgentService(IConfigSource config, IFriendsSimConnector friendsConnector)
{
// Let's set this always, because we don't know the sequence
// of instantiations
if (friendsConnector != null)
{
m_FriendsLocalSimConnector = friendsConnector;
}
if (!m_Initialized)
{
m_Initialized = true;
m_log.DebugFormat("[HOME USERS SECURITY]: Starting...");
m_FriendsSimConnector = new FriendsSimConnector();
IConfig serverConfig = config.Configs["UserAgentService"];
if (serverConfig == null)
{
throw new Exception(String.Format("No section UserAgentService in config file"));
}
string gridService = serverConfig.GetString("GridService", String.Empty);
string gridUserService = serverConfig.GetString("GridUserService", String.Empty);
string gatekeeperService = serverConfig.GetString("GatekeeperService", String.Empty);
string friendsService = serverConfig.GetString("FriendsService", String.Empty);
string presenceService = serverConfig.GetString("PresenceService", String.Empty);
string userAccountService = serverConfig.GetString("UserAccountService", String.Empty);
m_BypassClientVerification = serverConfig.GetBoolean("BypassClientVerification", false);
if (gridService == string.Empty || gridUserService == string.Empty || gatekeeperService == string.Empty)
{
throw new Exception(String.Format("Incomplete specifications, UserAgent Service cannot function."));
}
Object[] args = new Object[] { config };
m_GridService = ServerUtils.LoadPlugin <IGridService>(gridService, args);
m_GridUserService = ServerUtils.LoadPlugin <IGridUserService>(gridUserService, args);
m_GatekeeperConnector = new GatekeeperServiceConnector();
m_GatekeeperService = ServerUtils.LoadPlugin <IGatekeeperService>(gatekeeperService, args);
m_FriendsService = ServerUtils.LoadPlugin <IFriendsService>(friendsService, args);
m_PresenceService = ServerUtils.LoadPlugin <IPresenceService>(presenceService, args);
m_UserAccountService = ServerUtils.LoadPlugin <IUserAccountService>(userAccountService, args);
m_GridName = serverConfig.GetString("ExternalName", string.Empty);
if (m_GridName == string.Empty)
{
serverConfig = config.Configs["GatekeeperService"];
m_GridName = serverConfig.GetString("ExternalName", string.Empty);
}
if (!m_GridName.EndsWith("/"))
{
m_GridName = m_GridName + "/";
}
}
}
public LoginSwitch( UserLoginService service,
IInterServiceInventoryServices interInventoryService,
IInventoryService inventoryService,
IGridService gridService,
UserConfig config)
{
m_UserLoginService = service;
m_RealXtendLogin = new RealXtendLogin(service, interInventoryService, inventoryService, this, gridService, config);
}
public GridServerPostHandler (string url, IRegistryCore registry, IGridService service, bool secure, string SessionID) :
base("POST", url)
{
m_secure = secure;
m_GridService = service;
m_registry = registry;
m_SessionID = SessionID;
TelehubConnector = DataManager.RequestPlugin<IRegionConnector>();
}
// Construction ----------------------------------------
public MainPageViewModel(IGridService gridService)
{
_gridService = gridService;
InitSudoku();
// Register Event Handler for this Page
RegisterPropertyChangedHandler(MainPage_PropertyChanged);
}
public DefaultRailsIndexViewFactory(
IRailsEditViewFactory railsEditViewFactory = null,
IRailsEditViewModelFactory editViewModelFactory = null,
IGridService gridService = null)
{
this.editViewModelFactory = editViewModelFactory.Resolve();
this.railsEditViewFactory = railsEditViewFactory.Resolve(this);
this.gridService = gridService.Resolve();
}
public GridServerPostHandler(string url, IRegistryCore registry, IGridService service, bool secure, ulong regionHandle) :
base("POST", url)
{
m_secure = secure;
m_GridService = service;
m_registry = registry;
m_regionHandle = regionHandle;
TelehubConnector = DataManager.RequestPlugin <IRegionConnector>();
}
public void Start(IConfigSource config, IRegistryCore registry)
{
m_AssetService = registry.RequestModuleInterface <IAssetService> ();
m_GridService = registry.RequestModuleInterface <IGridService> ();
m_GatekeeperConnector = new GatekeeperServiceConnector(m_AssetService);
m_Database = Aurora.DataManager.DataManager.RequestPlugin <IRegionData> ();
MainConsole.Instance.Debug("[HYPERGRID LINKER]: Loaded all services...");
}
public HGFriendsService(IConfigSource config, String configName, IFriendsSimConnector localSimConn)
{
if (m_FriendsLocalSimConnector == null)
{
m_FriendsLocalSimConnector = localSimConn;
}
if (!m_Initialized)
{
m_Initialized = true;
if (configName != String.Empty)
{
m_ConfigName = configName;
}
Object[] args = new Object[] { config };
IConfig serverConfig = config.Configs[m_ConfigName];
if (serverConfig == null)
{
throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
}
string theService = serverConfig.GetString("FriendsService", string.Empty);
if (theService == String.Empty)
{
throw new Exception("No FriendsService in config file " + m_ConfigName);
}
m_FriendsService = ServerUtils.LoadPlugin <IFriendsService>(theService, args);
theService = serverConfig.GetString("UserAccountService", string.Empty);
if (theService == String.Empty)
{
throw new Exception("No UserAccountService in " + m_ConfigName);
}
m_UserAccountService = ServerUtils.LoadPlugin <IUserAccountService>(theService, args);
theService = serverConfig.GetString("GridService", string.Empty);
if (theService == String.Empty)
{
throw new Exception("No GridService in " + m_ConfigName);
}
m_GridService = ServerUtils.LoadPlugin <IGridService>(theService, args);
theService = serverConfig.GetString("PresenceService", string.Empty);
if (theService == String.Empty)
{
throw new Exception("No PresenceService in " + m_ConfigName);
}
m_PresenceService = ServerUtils.LoadPlugin <IPresenceService>(theService, args);
m_FriendsSimConnector = new FriendsSimConnector();
m_log.DebugFormat("[HGFRIENDS SERVICE]: Starting...");
}
}
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 Builder(IMovementService _movementService, IGridService _gridService, IDrawingService _drawingService)
{
gridService = _gridService;
movementService = _movementService;
drawingService = _drawingService;
gridService.SetNewGrid();
mainGrid = gridService.mainGrid;
drawingService.PrintTable(mainGrid);
}
public PresenceService(IConfigSource config)
: base(config)
{
IConfig presenceConfig = config.Configs["PresenceService"];
string gridServiceDll = presenceConfig.GetString("GridService", string.Empty);
if (gridServiceDll != string.Empty)
m_GridService = LoadPlugin<IGridService>(gridServiceDll, new Object[] { config });
m_log.Debug("[PRESENCE SERVICE]: Starting presence service");
}
public void PostStart(IConfigSource config, IRegistryCore registry)
{
IConfig handlerConfig = config.Configs["Handlers"];
if (handlerConfig.GetString("GridInHandler", "") != Name)
return;
IHttpServer server = registry.RequestModuleInterface<ISimulationBase>().GetHttpServer((uint)handlerConfig.GetInt("GridInHandlerPort"));
m_GridService = registry.RequestModuleInterface<IGridService>();
GridServerPostHandler handler = new GridServerPostHandler(m_GridService);
server.AddStreamHandler(handler);
}
public void RegisterCaps(IRegionClientCapsService service)
{
m_service = service;
m_gridService = service.Registry.RequestModuleInterface<IGridService>();
RestMethod method = delegate(string request, string path, string param,
OSHttpRequest httpRequest, OSHttpResponse httpResponse)
{
return MapLayerRequest(request, path, param, httpRequest, httpResponse, m_service.AgentID);
};
m_service.AddStreamHandler("MapLayer", new RestStreamHandler("POST", m_service.CreateCAPS("MapLayer", m_mapLayerPath),
method));
}
public UserLoginService(
UserManagerBase userManager, IInterServiceInventoryServices inventoryService,
LibraryRootFolder libraryRootFolder,
UserConfig config, string welcomeMess, IRegionProfileRouter regionProfileService)
: base(userManager, libraryRootFolder, welcomeMess)
{
m_config = config;
m_defaultHomeX = m_config.DefaultX;
m_defaultHomeY = m_config.DefaultY;
m_interInventoryService = inventoryService;
m_regionProfileService = regionProfileService;
m_GridService = new GridServicesConnector(config.GridServerURL.ToString());
}
public MapActivityDetector(Scene scene)
{
m_GridService = scene.GridService;
//m_log.DebugFormat("[MAP ACTIVITY DETECTOR]: starting ");
// For now the only events we listen to are these
// But we could trigger the position update more often
scene.EventManager.OnMakeRootAgent += OnMakeRootAgent;
scene.EventManager.OnNewClient += OnNewClient;
scene.EventManager.OnClosingClient += OnClosingClient;
//scene.EventManager.OnAvatarEnteringNewParcel += OnEnteringNewParcel;
if (m_aScene == null)
m_aScene = scene;
}
public EntityController(
IContentManager iContentManager,
IOrchardServices orchardServices,
IProjectionManager projectionManager,
ITokenizer tokenizer,
IGridService gridService,
IRepository<FilterRecord> filterRepository,
IRepository<FilterGroupRecord> filterGroupRepository) {
_contentManager = iContentManager;
Services = orchardServices;
_projectionManager = projectionManager;
_tokenizer = tokenizer;
_gridService = gridService;
_filterRepository = filterRepository;
_filterGroupRepository = filterGroupRepository;
}
public WebStoreRobustConnector(IConfigSource config, IHttpServer server, string configName)
: base(config, server, configName)
{
if (configName != string.Empty)
{
m_ConfigName = configName;
}
IConfig config2 = config.Configs["WebStore"];
if (config2 == null)
{
this.m_Enabled = false;
WebStoreRobustConnector.m_log.DebugFormat("[Web.Store.Robust.Connector]: Configuration Error Not Enabled", new object[0]);
return;
}
this.m_Enabled = true;
string @string = config2.GetString("StorageProvider", string.Empty);
string string2 = config2.GetString("ConnectionString", string.Empty);
string string3 = config2.GetString("Realm", "store_transactions");
string string4 = config2.GetString("GridService", string.Empty);
string string5 = config2.GetString("UserAccountService", string.Empty);
string string6 = config2.GetString("PresenceService", string.Empty);
if (@string == string.Empty || string2 == string.Empty || string4 == string.Empty || string5 == string.Empty || string6 == string.Empty)
{
this.m_Enabled = false;
WebStoreRobustConnector.m_log.ErrorFormat("[Web.Store.Robust.Connector]: missing service specifications Not Enabled", new object[0]);
return;
}
object[] args = new object[]
{
config
};
this.m_GridService = ServerUtils.LoadPlugin<IGridService>(string4, args);
this.m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(string5, args);
this.m_PresenceService = ServerUtils.LoadPlugin<IPresenceService>(string6, args);
this.m_Database = ServerUtils.LoadPlugin<IStoreData>(@string, new object[]
{
string2,
string3
});
this.m_Funcs = new Functions();
WebStoreRobustConnector.m_log.DebugFormat("[Web.Store.Robust.Connector]: Initialzing", new object[0]);
if (MainConsole.Instance != null)
{
MainConsole.Instance.Commands.AddCommand("Debug", false, "Web Store Debug", "Web Store Debug <true|false>", "This setting turns on Web Store Debug", new CommandDelegate(this.HandleDebugStoreVerbose));
}
server.AddXmlRPCHandler("ProcessTransaction", new XmlRpcMethod(this.ProcessTransaction));
}
public RealXtendLogin(UserLoginService service,
IInterServiceInventoryServices interInventoryService,
IInventoryService inventoryService,
LoginSwitch loginSwitch,
IGridService gridService,
UserConfig config)
{
m_UserLoginService = service;
m_interInventoryService = interInventoryService;
m_InventoryService = inventoryService;
m_LoginSwitch = loginSwitch;
m_GridService = gridService;
m_UserConfig = config;
m_defaultHomeX = m_UserConfig.DefaultX;
m_defaultHomeY = m_UserConfig.DefaultY;
m_OpenSimMap = new OpenSimMap(config.GridServerURL, m_GridService);
}
public GridServiceConnector(IConfigSource config, IHttpServer server, string configName) :
base(config, server, configName)
{
IConfig serverConfig = config.Configs[m_ConfigName];
if (serverConfig == null)
throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
string gridService = serverConfig.GetString("LocalServiceModule",
String.Empty);
if (gridService == String.Empty)
throw new Exception("No LocalServiceModule in config file");
Object[] args = new Object[] { config };
m_GridService = ServerUtils.LoadPlugin<IGridService>(gridService, args);
server.AddStreamHandler(new GridServerPostHandler(m_GridService));
}
public void IncomingCapsRequest (UUID agentID, GridRegion region, ISimulationBase simbase, ref OSDMap capURLs)
{
m_agentID = agentID;
m_region = region;
m_userScopeIDs = simbase.ApplicationRegistry.RequestModuleInterface<IUserAccountService> ().GetUserAccount (null, m_agentID).AllScopeIDs;
m_gridService = simbase.ApplicationRegistry.RequestModuleInterface<IGridService> ();
IConfig config = simbase.ConfigSource.Configs ["MapCAPS"];
if (config != null)
m_allowCapsMessage = config.GetBoolean ("AllowCapsMessage", m_allowCapsMessage);
HttpServerHandle method = (path, request, httpRequest, httpResponse) => MapLayerRequest (HttpServerHandlerHelpers.ReadString (request), httpRequest, httpResponse);
m_uri = "/CAPS/MapLayer/" + UUID.Random () + "/";
capURLs ["MapLayer"] = MainServer.Instance.ServerURI + m_uri;
capURLs ["MapLayerGod"] = MainServer.Instance.ServerURI + m_uri;
MainServer.Instance.AddStreamHandler (new GenericStreamHandler ("POST", m_uri, method));
}
public PresenceService(IConfigSource config)
: base(config)
{
IConfig presenceConfig = config.Configs["PresenceService"];
if (presenceConfig != null)
{
m_allowDuplicatePresences =
presenceConfig.GetBoolean("AllowDuplicatePresences",
m_allowDuplicatePresences);
m_checkLastSeen =
presenceConfig.GetBoolean("CheckLastSeen",
m_checkLastSeen);
string gridServiceDll = presenceConfig.GetString("GridService", string.Empty);
if (gridServiceDll != string.Empty)
m_GridService = LoadPlugin<IGridService>(gridServiceDll, new Object[] { config });
}
m_log.Debug("[PRESENCE SERVICE]: Starting presence service");
}
public UserAccountService(IConfigSource config)
: base(config)
{
IConfig userConfig = config.Configs["UserAccountService"];
if (userConfig == null)
throw new Exception("No UserAccountService configuration");
// In case there are several instances of this class in the same process,
// the console commands are only registered for the root instance
if (m_RootInstance == null)
{
m_RootInstance = this;
string gridServiceDll = userConfig.GetString("GridService", string.Empty);
if (gridServiceDll != string.Empty)
m_GridService = LoadPlugin<IGridService>(gridServiceDll, new Object[] { config });
string authServiceDll = userConfig.GetString("AuthenticationService", string.Empty);
if (authServiceDll != string.Empty)
m_AuthenticationService = LoadPlugin<IAuthenticationService>(authServiceDll, new Object[] { config });
string presenceServiceDll = userConfig.GetString("PresenceService", string.Empty);
if (presenceServiceDll != string.Empty)
m_PresenceService = LoadPlugin<IPresenceService>(presenceServiceDll, new Object[] { config });
string invServiceDll = userConfig.GetString("InventoryService", string.Empty);
if (invServiceDll != string.Empty)
m_InventoryService = LoadPlugin<IInventoryService>(invServiceDll, new Object[] { config });
if (MainConsole.Instance != null)
{
MainConsole.Instance.Commands.AddCommand("UserService", false,
"create user",
"create user [<first> [<last> [<pass> [<email>]]]]",
"Create a new user", HandleCreateUser);
MainConsole.Instance.Commands.AddCommand("UserService", false, "reset user password",
"reset user password [<first> [<last> [<password>]]]",
"Reset a user password", HandleResetUserPassword);
}
}
}
public void Initialize(IConfigSource config, IRegistryCore registry)
{
IConfig handlerConfig = config.Configs["Handlers"];
if (handlerConfig.GetString("GridHandler", "") != Name)
return;
string localHandler = handlerConfig.GetString("LocalGridHandler", "GridService");
List<IGridService> services = Aurora.Framework.AuroraModuleLoader.PickupModules<IGridService>();
foreach(IGridService s in services)
if(s.GetType().Name == localHandler)
m_localService = s;
m_registry = registry;
if(m_localService == null)
m_localService = new GridService();
m_localService.Configure(config, registry);
m_remoteService = new GridServicesConnector();
m_remoteService.Initialize(config, registry);
registry.RegisterModuleInterface<IGridService>(this);
}
public void RegisterCaps(IRegionClientCapsService service)
{
m_service = service;
m_gridService = service.Registry.RequestModuleInterface<IGridService>();
IConfig config =
service.ClientCaps.Registry.RequestModuleInterface<ISimulationBase>().ConfigSource.Configs["MapCaps"];
if (config != null)
m_allowCapsMessage = config.GetBoolean("AllowCapsMessage", m_allowCapsMessage);
HttpServerHandle method = delegate(string path, Stream request, OSHttpRequest httpRequest,
OSHttpResponse httpResponse)
{
return MapLayerRequest(request.ReadUntilEnd(), httpRequest, httpResponse, m_service.AgentID);
};
m_service.AddStreamHandler("MapLayer",
new GenericStreamHandler("POST", m_service.CreateCAPS("MapLayer", ""),
method));
m_service.AddStreamHandler("MapLayerGod",
new GenericStreamHandler("POST", m_service.CreateCAPS("MapLayerGod", ""),
method));
}
public UserAgentService(IConfigSource config)
{
if (!m_Initialized)
{
m_log.DebugFormat("[HOME USERS SECURITY]: Starting...");
IConfig serverConfig = config.Configs["UserAgentService"];
if (serverConfig == null)
throw new Exception(String.Format("No section UserAgentService in config file"));
string gridService = serverConfig.GetString("GridService", String.Empty);
string gridUserService = serverConfig.GetString("GridUserService", String.Empty);
if (gridService == string.Empty || gridUserService == string.Empty)
throw new Exception(String.Format("Incomplete specifications, UserAgent Service cannot function."));
Object[] args = new Object[] { config };
m_GridService = ServerUtils.LoadPlugin<IGridService>(gridService, args);
m_GridUserService = ServerUtils.LoadPlugin<IGridUserService>(gridUserService, args);
m_GatekeeperConnector = new GatekeeperServiceConnector();
m_Initialized = true;
}
}
public AuthorizationService(IConfig config, Scene scene)
{
m_Scene = scene;
m_UserManagement = scene.RequestModuleInterface<IUserManagement>();
m_GridService = scene.GridService;
if (config != null)
{
string accessStr = config.GetString("Region_" + scene.RegionInfo.RegionName.Replace(' ', '_'), String.Empty);
if (accessStr != string.Empty)
{
try
{
m_accessValue = (AccessFlags)Enum.Parse(typeof(AccessFlags), accessStr);
}
catch (ArgumentException)
{
m_log.WarnFormat("[AuthorizationService]: {0} is not a valid access flag", accessStr);
}
}
m_log.DebugFormat("[AuthorizationService]: Region {0} access restrictions: {1}", m_Scene.RegionInfo.RegionName, m_accessValue);
}
}
public void Start(IConfigSource config, IRegistryCore registry)
{
m_gridService = registry.RequestModuleInterface<IGridService>();
m_simService = registry.RequestModuleInterface<ISimulationService>();
}
private void InitialiseService(IConfigSource source)
{
IConfig assetConfig = source.Configs["GridService"];
if (assetConfig == null)
{
m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: GridService missing from OpenSim.ini");
return;
}
string serviceDll = assetConfig.GetString("LocalServiceModule",
String.Empty);
if (serviceDll == String.Empty)
{
m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: No LocalServiceModule named in section GridService");
return;
}
Object[] args = new Object[] { source };
m_GridService =
ServerUtils.LoadPlugin<IGridService>(serviceDll,
args);
if (m_GridService == null)
{
m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: Can't load grid service");
return;
}
m_Enabled = true;
}
// IConfig m_ClientsConfig;
public LLLoginService(IConfigSource config, ISimulationService simService, ILibraryService libraryService)
{
m_LoginServerConfig = config.Configs["LoginService"];
if (m_LoginServerConfig == null)
throw new Exception(String.Format("No section LoginService in config file"));
string accountService = m_LoginServerConfig.GetString("UserAccountService", String.Empty);
string gridUserService = m_LoginServerConfig.GetString("GridUserService", String.Empty);
string agentService = m_LoginServerConfig.GetString("UserAgentService", String.Empty);
string authService = m_LoginServerConfig.GetString("AuthenticationService", String.Empty);
string invService = m_LoginServerConfig.GetString("InventoryService", String.Empty);
string gridService = m_LoginServerConfig.GetString("GridService", String.Empty);
string presenceService = m_LoginServerConfig.GetString("PresenceService", String.Empty);
string libService = m_LoginServerConfig.GetString("LibraryService", String.Empty);
string friendsService = m_LoginServerConfig.GetString("FriendsService", String.Empty);
string avatarService = m_LoginServerConfig.GetString("AvatarService", String.Empty);
string simulationService = m_LoginServerConfig.GetString("SimulationService", String.Empty);
m_DefaultRegionName = m_LoginServerConfig.GetString("DefaultRegion", String.Empty);
m_WelcomeMessage = m_LoginServerConfig.GetString("WelcomeMessage", "Welcome to OpenSim!");
m_RequireInventory = m_LoginServerConfig.GetBoolean("RequireInventory", true);
m_AllowRemoteSetLoginLevel = m_LoginServerConfig.GetBoolean("AllowRemoteSetLoginLevel", false);
m_MinLoginLevel = m_LoginServerConfig.GetInt("MinLoginLevel", 0);
m_GatekeeperURL = Util.GetConfigVarFromSections<string>(config, "GatekeeperURI",
new string[] { "Startup", "Hypergrid", "LoginService" }, String.Empty);
m_MapTileURL = m_LoginServerConfig.GetString("MapTileURL", string.Empty);
m_ProfileURL = m_LoginServerConfig.GetString("ProfileServerURL", string.Empty);
m_OpenIDURL = m_LoginServerConfig.GetString("OpenIDServerURL", String.Empty);
m_SearchURL = m_LoginServerConfig.GetString("SearchURL", string.Empty);
m_Currency = m_LoginServerConfig.GetString("Currency", string.Empty);
m_ClassifiedFee = m_LoginServerConfig.GetString("ClassifiedFee", string.Empty);
m_DestinationGuide = m_LoginServerConfig.GetString ("DestinationGuide", string.Empty);
m_AvatarPicker = m_LoginServerConfig.GetString ("AvatarPicker", string.Empty);
m_AllowedClients = m_LoginServerConfig.GetString("AllowedClients", string.Empty);
m_DeniedClients = m_LoginServerConfig.GetString("DeniedClients", string.Empty);
m_DSTZone = m_LoginServerConfig.GetString("DSTZone", "America/Los_Angeles;Pacific Standard Time");
// Clean up some of these vars
if (m_MapTileURL != String.Empty)
{
m_MapTileURL = m_MapTileURL.Trim();
if (!m_MapTileURL.EndsWith("/"))
m_MapTileURL = m_MapTileURL + "/";
}
// These are required; the others aren't
if (accountService == string.Empty || authService == string.Empty)
throw new Exception("LoginService is missing service specifications");
// replace newlines in welcome message
m_WelcomeMessage = m_WelcomeMessage.Replace("\\n", "\n");
Object[] args = new Object[] { config };
m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(accountService, args);
m_GridUserService = ServerUtils.LoadPlugin<IGridUserService>(gridUserService, args);
m_AuthenticationService = ServerUtils.LoadPlugin<IAuthenticationService>(authService, args);
m_InventoryService = ServerUtils.LoadPlugin<IInventoryService>(invService, args);
if (gridService != string.Empty)
m_GridService = ServerUtils.LoadPlugin<IGridService>(gridService, args);
if (presenceService != string.Empty)
m_PresenceService = ServerUtils.LoadPlugin<IPresenceService>(presenceService, args);
if (avatarService != string.Empty)
m_AvatarService = ServerUtils.LoadPlugin<IAvatarService>(avatarService, args);
if (friendsService != string.Empty)
m_FriendsService = ServerUtils.LoadPlugin<IFriendsService>(friendsService, args);
if (simulationService != string.Empty)
m_RemoteSimulationService = ServerUtils.LoadPlugin<ISimulationService>(simulationService, args);
if (agentService != string.Empty)
m_UserAgentService = ServerUtils.LoadPlugin<IUserAgentService>(agentService, args);
// Get the Hypergrid inventory service (exists only if Hypergrid is enabled)
string hgInvServicePlugin = m_LoginServerConfig.GetString("HGInventoryServicePlugin", String.Empty);
if (hgInvServicePlugin != string.Empty)
{
string hgInvServiceArg = m_LoginServerConfig.GetString("HGInventoryServiceConstructorArg", String.Empty);
Object[] args2 = new Object[] { config, hgInvServiceArg };
m_HGInventoryService = ServerUtils.LoadPlugin<IInventoryService>(hgInvServicePlugin, args2);
}
//
// deal with the services given as argument
//
m_LocalSimulationService = simService;
if (libraryService != null)
{
m_log.DebugFormat("[LLOGIN SERVICE]: Using LibraryService given as argument");
m_LibraryService = libraryService;
}
else if (libService != string.Empty)
{
m_log.DebugFormat("[LLOGIN SERVICE]: Using instantiated LibraryService");
m_LibraryService = ServerUtils.LoadPlugin<ILibraryService>(libService, args);
}
m_GatekeeperConnector = new GatekeeperServiceConnector();
if (!Initialized)
{
Initialized = true;
RegisterCommands();
}
m_log.DebugFormat("[LLOGIN SERVICE]: Starting...");
}
public void Start(IConfigSource config, IRegistryCore registry)
{
m_UserAccountService = registry.RequestModuleInterface<IUserAccountService>().InnerService;
m_agentInfoService = registry.RequestModuleInterface<IAgentInfoService>().InnerService;
m_AuthenticationService = registry.RequestModuleInterface<IAuthenticationService>();
m_InventoryService = registry.RequestModuleInterface<IInventoryService>();
m_GridService = registry.RequestModuleInterface<IGridService>();
m_AvatarService = registry.RequestModuleInterface<IAvatarService>().InnerService;
m_FriendsService = registry.RequestModuleInterface<IFriendsService>();
m_SimulationService = registry.RequestModuleInterface<ISimulationService>();
m_AssetService = registry.RequestModuleInterface<IAssetService>().InnerService;
m_LibraryService = registry.RequestModuleInterface<ILibraryService>();
m_CapsService = registry.RequestModuleInterface<ICapsService>();
m_ArchiveService = registry.RequestModuleInterface<IAvatarAppearanceArchiver>();
if (!Initialized)
{
Initialized = true;
RegisterCommands();
}
LoginModules = WhiteCoreModuleLoader.PickupModules<ILoginModule>();
foreach (ILoginModule module in LoginModules)
{
module.Initialize(this, m_config, registry);
}
MainConsole.Instance.DebugFormat("[LLOGIN SERVICE]: Starting...");
}
public GridServerPostHandler(IGridService service) :
base("POST", "/grid")
{
m_GridService = service;
TelehubConnector = DataManager.RequestPlugin<IRegionConnector>();
}
public virtual void Initialise(IGridService gridServices)
{
m_GridService = gridServices;
}
