public void Startup(ConfigurationLoader loader)
{
HomeURI = loader.HomeURI;
m_AgentInventoryService = loader.GetService <InventoryServiceInterface>(m_AgentInventoryServiceName);
m_AgentAssetService = loader.GetService <AssetServiceInterface>(m_AgentAssetServiceName);
if (m_AgentProfileServiceName?.Length != 0)
{
m_AgentProfileService = loader.GetService <ProfileServiceInterface>(m_AgentProfileServiceName);
}
m_AgentFriendsService = loader.GetService <FriendsServiceInterface>(m_AgentFriendsServiceName);
m_UserSessionService = loader.GetService <UserSessionServiceInterface>(m_UserSessionServiceName);
m_GridService = loader.GetService <GridServiceInterface>(m_GridServiceName);
if (m_OfflineIMServiceName?.Length != 0)
{
m_OfflineIMService = loader.GetService <OfflineIMServiceInterface>(m_OfflineIMServiceName);
}
if (m_AgentExperienceServiceName?.Length != 0)
{
loader.GetService(m_AgentExperienceServiceName, out m_AgentExperienceService);
}
if (m_AgentGroupsServiceName?.Length != 0)
{
loader.GetService(m_AgentGroupsServiceName, out m_AgentGroupsService);
}
m_UserAccountService = loader.GetService <UserAccountServiceInterface>(m_UserAccountServiceName);
m_AgentUserAgentService = new LocalUserAgentService(m_UserSessionService, m_UserAccountService, m_RequiresInventoryIDAsIMSessionID, HomeURI);
m_Scenes = loader.Scenes;
m_Commands = loader.CommandRegistry;
m_CapsRedirector = loader.CapsRedirector;
m_PacketHandlerPlugins = loader.GetServicesByValue <IProtocolExtender>();
}
public void Startup(ConfigurationLoader loader)
{
m_Scenes = loader.Scenes;
m_EstateService = loader.GetService <EstateServiceInterface>(m_EstateServiceName);
m_RegionStorage = loader.GetService <GridServiceInterface>(m_RegionStorageName);
loader.CommandRegistry.AddShowCommand("estates", ShowEstatesCmd);
loader.CommandRegistry.AddChangeCommand("estate", ChangeEstateCmd);
loader.CommandRegistry.AddCreateCommand("estate", CreateEstateCmd);
loader.CommandRegistry.AddDeleteCommand("estate", DeleteEstateCmd);
loader.CommandRegistry.AddAlertCommand("estate", AlertEstateCmd);
var avatarNameServicesList = new RwLockedList <AvatarNameServiceInterface>();
IConfig sceneConfig = loader.Config.Configs["DefaultSceneImplementation"];
if (sceneConfig != null)
{
string avatarNameServices = sceneConfig.GetString("AvatarNameServices", string.Empty);
if (!string.IsNullOrEmpty(avatarNameServices))
{
foreach (string p in avatarNameServices.Split(','))
{
avatarNameServicesList.Add(loader.GetService <AvatarNameServiceInterface>(p.Trim()));
}
}
}
m_AvatarNameService = new AggregatingAvatarNameService(avatarNameServicesList);
}
public RestartObject(SceneList scenes, SceneInterface scene, SceneImplementationFactory sceneFactory, GridServiceInterface regionStorage)
{
m_Scenes = scenes;
m_WeakScene = new WeakReference(scene);
m_SceneFactory = sceneFactory;
m_RegionStorage = regionStorage;
RestartTimer.Elapsed += RestartTimerHandler;
}
public void Startup(ConfigurationLoader loader)
{
m_GatekeeperUri = loader.GatekeeperURI;
m_Scenes = loader.Scenes;
m_ExternalHostNameService = loader.ExternalHostNameService;
m_SceneFactory = loader.GetService <SceneFactoryInterface>("DefaultSceneImplementation");
m_RegionService = loader.GetService <GridServiceInterface>(m_RegionStorage);
}
public void Startup(ConfigurationLoader loader)
{
m_GridService = loader.GetService <GridServiceInterface>(m_GridServiceName);
m_RegionDefaultFlagsService = loader.GetService <RegionDefaultFlagsServiceInterface>(m_RegionDefaultFlagsServiceName);
loader.CommandRegistry.AddChangeCommand("regionflags", ChangeRegionFlagDefaultsCmd);
loader.CommandRegistry.AddClearCommand("regionflags", ClearRegionFlagDefaultsCmd);
loader.CommandRegistry.AddShowCommand("defaultregionflags", ShowRegionFlagDefaultsCmd);
loader.CommandRegistry.AddUnregisterCommand("gridregion", UnregisterRegionCmd);
loader.CommandRegistry.AddShowCommand("gridregions", ShowRegionsCmd);
}
public static List <RegionInfo> GetNeighbors(this GridServiceInterface gridService, RegionInfo ownRegion)
{
var southWestCorner = ownRegion.Location;
var northEastCorner = ownRegion.Location + ownRegion.Size;
var southWestViewCorner = ownRegion.Location;
var northEastViewCorner = ownRegion.Location + ownRegion.Size;
southWestViewCorner.X -= MAXIMUM_VIEW_RANGE;
southWestViewCorner.Y -= MAXIMUM_VIEW_RANGE;
northEastViewCorner.X += MAXIMUM_VIEW_RANGE;
northEastViewCorner.Y += MAXIMUM_VIEW_RANGE;
southWestCorner.X -= MAXIMUM_REGION_SIZE;
southWestCorner.Y -= MAXIMUM_REGION_SIZE;
northEastCorner.X += MAXIMUM_VIEW_RANGE;
northEastCorner.Y += MAXIMUM_VIEW_RANGE;
var regions = gridService.GetRegionsByRange(southWestCorner, northEastCorner);
var actualNeighbors = new List <RegionInfo>();
foreach (var ri in regions)
{
var northEastNeighborCorner = ri.Location + ri.Size;
if (ownRegion.ID == ri.ID)
{
/* skip we are not our own neighbor */
}
// The r.RegionFlags == null check only needs to be made for simulators before 2015-01-14 (pre 0.8.1).
else if ((ri.Flags & RegionFlags.RegionOnline) == 0)
{
/* skip offline regions */
}
else if (northEastNeighborCorner.X < southWestViewCorner.X ||
northEastNeighborCorner.Y < southWestViewCorner.Y ||
ri.Location.X > northEastViewCorner.X ||
ri.Location.Y > northEastViewCorner.Y)
{
/* not a neighbour at all */
}
else
{
actualNeighbors.Add(ri);
}
}
return(actualNeighbors);
}
public void Startup(ConfigurationLoader loader)
{
m_WebIF = loader.GetAdminWebIF();
m_RegionDefaultFlagsService = loader.GetService <RegionDefaultFlagsServiceInterface>(m_RegionDefaultFlagsServiceName);
m_GridService = loader.GetService <GridServiceInterface>(m_GridServiceName);
m_WebIF.ModuleNames.Add("mapserver");
m_WebIF.AutoGrantRights["mapserver.unregister"].Add("mapserver.view");
m_WebIF.AutoGrantRights["mapserver.manage"].Add("mapserver.view");
m_WebIF.JsonMethods.Add("mapserver.search", HandleMapServerSearch);
m_WebIF.JsonMethods.Add("mapserver.getdefaultregions", HandleMapServerGetDefaultRegions);
m_WebIF.JsonMethods.Add("mapserver.getdefaulthgregions", HandleMapServerGetDefaultHGRegions);
m_WebIF.JsonMethods.Add("mapserver.getfallbackregions", HandleMapServerGetFallbackRegions);
m_WebIF.JsonMethods.Add("mapserver.unregister", HandleMapServerUnregisterRegion);
m_WebIF.JsonMethods.Add("mapserver.defaultregionflags.list", HandleMapServerGetDefaultRegionFlags);
m_WebIF.JsonMethods.Add("mapserver.defaultregionflags.change", HandleMapServerChangeDefaultRegionFlags);
}
public void Startup(ConfigurationLoader loader)
{
m_Scenes = loader.Scenes;
m_EstateService = loader.GetService <EstateServiceInterface>(m_EstateServiceName);
m_RegionStorageService = loader.GetService <GridServiceInterface>(m_RegionStorageName);
IAdminWebIF webif = loader.GetAdminWebIF();
m_WebIF = webif;
webif.ModuleNames.Add("estates");
webif.JsonMethods.Add("estates.list", HandleList);
webif.JsonMethods.Add("estate.get", HandleGet);
webif.JsonMethods.Add("estate.update", HandleUpdate);
webif.JsonMethods.Add("estate.delete", HandleDelete);
webif.JsonMethods.Add("estate.create", HandleCreate);
webif.JsonMethods.Add("estate.notice", HandleNotice);
webif.AutoGrantRights["estates.manage"].Add("estates.view");
webif.AutoGrantRights["estate.notice"].Add("estates.view");
}
public void Startup(ConfigurationLoader loader)
{
m_CommandRegistry = loader.CommandRegistry;
m_TeleportProtocols = loader.GetServicesByValue <ITeleportHandlerFactoryServiceInterface>();
m_UserSessionStatusServices = loader.GetServicesByValue <IUserSessionStatusHandler>();
m_Scenes = loader.Scenes;
m_CapsRedirector = loader.CapsRedirector;
m_AuthorizationServices = loader.GetServicesByValue <AuthorizationServiceInterface>();
m_HttpServer = loader.HttpServer;
m_GridService = loader.GetService <GridServiceInterface>(m_GridServiceName);
Commands = loader.CommandRegistry;
m_PacketHandlerPlugins = loader.GetServicesByValue <IProtocolExtender>();
m_GatekeeperURI = loader.GatekeeperURI;
loader.GetService(m_LocalUserAccountServiceName, out m_LocalUserAccountService);
loader.GetService(m_LocalAssetServiceName, out m_LocalAssetService);
loader.GetService(m_LocalInventoryServiceName, out m_LocalInventoryService);
if (!string.IsNullOrEmpty(m_LocalProfileServiceName))
{
loader.GetService(m_LocalProfileServiceName, out m_LocalProfileService);
}
loader.GetService(m_LocalFriendsServiceName, out m_LocalFriendsService);
loader.GetService(m_LocalUserSessionServiceName, out m_LocalUserSessionService);
loader.GetService(m_LocalOfflineIMServiceName, out m_LocalOfflineIMService);
if (!string.IsNullOrEmpty(m_LocalGroupsServiceName))
{
loader.GetService(m_LocalGroupsServiceName, out m_LocalGroupsService);
}
if (!string.IsNullOrEmpty(m_LocalExperienceServiceName))
{
loader.GetService(m_LocalExperienceServiceName, out m_LocalExperienceService);
}
if (!loader.TryGetService(m_LocalEconomyServiceName, out m_LocalEconomyService))
{
m_LocalEconomyService = null;
}
}
public void Startup(ConfigurationLoader loader)
{
m_Scenes = loader.Scenes;
m_Loader = loader;
m_GatekeeperURI = loader.GatekeeperURI;
IConfig config = loader.Config.Configs[GetType().FullName];
/* we use same asset id keying here so to make them compatible with the other scripts */
foreach (string key in config.GetKeys())
{
if (UUID.TryParse(key, out m_AssetID))
{
m_ScriptFile = config.GetString(key);
break;
}
}
m_ObjectPermissionsBase = GetPermissions(config, "ObjectPermisionsBase");
m_ObjectPermissionsOwner = GetPermissions(config, "ObjectPermisionsOwner");
m_ObjectPermissionsGroup = GetPermissions(config, "ObjectPermisionsGroup");
m_ObjectPermissionsNext = GetPermissions(config, "ObjectPermisionsNext");
m_ObjectPermissionsEveryone = GetPermissions(config, "ObjectPermisionsEveryone");
m_ScriptPermissionsBase = GetPermissions(config, "ScriptPermisionsBase");
m_ScriptPermissionsOwner = GetPermissions(config, "ScriptPermisionsOwner");
m_ScriptPermissionsGroup = GetPermissions(config, "ScriptPermisionsGroup");
m_ScriptPermissionsNext = GetPermissions(config, "ScriptPermisionsNext");
m_ScriptPermissionsEveryone = GetPermissions(config, "ScriptPermisionsEveryone");
m_LoadOarFileName = config.GetString("OarFilename", string.Empty);
m_TimeoutMs = config.GetInt("RunTimeout", 1000);
m_RegionID = UUID.Parse(config.GetString("RegionID"));
m_RegionOwner = new UGUIWithName(config.GetString("RegionOwner"))
{
IsAuthoritative = true
};
m_EstateOwner = new UGUIWithName(config.GetString("EstateOwner", m_RegionOwner.ToString()))
{
IsAuthoritative = true
};
m_EstateID = (uint)config.GetInt("EstateID", 100);
m_EstateName = config.GetString("EstateName", "My Estate");
m_ObjectID = UUID.Parse(config.GetString("ID", UUID.Random.ToString()));
m_RegionName = config.GetString("RegionName", "Testing Region");
m_ProductName = config.GetString("RegionProductName", "Mainland");
m_RegionLocation = new GridVector(config.GetString("RegionLocation", "10000,10000"), 256);
m_RegionSize = new GridVector(config.GetString("RegionSize", "1,1"), 256);
m_RegionAccess = (RegionAccess)Enum.Parse(typeof(RegionAccess), config.GetString("RegionAccess", "PG"));
m_RegionPort = config.GetInt("RegionPort", 9300);
m_Runner = loader.GetServicesByValue <TestRunner>()[0];
m_Position = Vector3.Parse(config.GetString("Position", "<128, 128, 23>"));
m_Rotation = Quaternion.Parse(config.GetString("Rotation", "<0,0,0,1>"));
m_ItemID = UUID.Parse(config.GetString("ScriptItemID", UUID.Random.ToString()));
m_RezzingObjID = UUID.Parse(config.GetString("RezzingObjectID", UUID.Zero.ToString()));
m_ObjectName = config.GetString("ObjectName", "Object");
m_ScriptName = config.GetString("ScriptName", "Script");
string experienceName = config.GetString("ExperienceName", "My Experience");
UUID experienceID;
UUID.TryParse(config.GetString("ExperienceID", UUID.Zero.ToString()), out experienceID);
m_ExperienceID = new UEI(experienceID, experienceName, null);
m_ObjectDescription = config.GetString("ObjectDescription", "");
m_ScriptDescription = config.GetString("ScriptDescription", "");
m_RegionStorage = loader.GetService <GridServiceInterface>("RegionStorage");
m_SceneFactory = loader.GetService <SceneFactoryInterface>("DefaultSceneImplementation");
m_EstateService = loader.GetService <EstateServiceInterface>("EstateService");
m_AvatarNameService = loader.GetService <AvatarNameServiceInterface>("AvatarNameStorage");
m_UserAccountService = loader.GetService <UserAccountServiceInterface>("UserAccountService");
m_AvatarNameService.Store(m_RegionOwner);
m_AvatarNameService.Store(m_EstateOwner);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_RegionOwner,
IsLocalToGrid = true,
});
}
catch
{
m_Log.Info("UserAccount creation failed for RegionOwner");
}
if (!m_EstateOwner.EqualsGrid(m_RegionOwner))
{
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_RegionOwner,
IsLocalToGrid = true,
});
}
catch
{
m_Log.Info("UserAccount creation failed for EstateOwner");
}
}
m_ObjectOwner = new UGUIWithName(config.GetString("ObjectOwner"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ObjectOwner);
if (config.Contains("ObjectCreator"))
{
m_ObjectCreator = new UGUIWithName(config.GetString("ObjectCreator"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ObjectCreator);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_ObjectCreator,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
}
else
{
m_ObjectCreator = m_ObjectOwner;
}
if (config.Contains("ObjectLastOwner"))
{
m_ObjectLastOwner = new UGUIWithName(config.GetString("ObjectLastOwner"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ObjectLastOwner);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_ObjectLastOwner,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
}
else
{
m_ObjectLastOwner = m_ObjectOwner;
}
m_ScriptOwner = new UGUIWithName(config.GetString("ScriptOwner"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ScriptOwner);
if (config.Contains("ScriptCreator"))
{
m_ScriptCreator = new UGUIWithName(config.GetString("ScriptCreator"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ScriptCreator);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_ScriptCreator,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
}
else
{
m_ScriptCreator = m_ScriptOwner;
}
if (config.Contains("ScriptLastOwner"))
{
m_ScriptLastOwner = new UGUIWithName(config.GetString("ScriptLastOwner"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ScriptLastOwner);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_ScriptLastOwner,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
}
else
{
m_ScriptLastOwner = m_ScriptOwner;
}
m_StartParameter = config.GetInt("StartParameter", 0);
if (string.IsNullOrEmpty(m_ScriptFile))
{
throw new ArgumentException("Script filename and UUID missing");
}
m_AdditionalObjectConfigs = config.GetString("AdditionalObjects", string.Empty).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (m_AdditionalObjectConfigs.Length == 1 && m_AdditionalObjectConfigs[0] == string.Empty)
{
m_AdditionalObjectConfigs = new string[0];
}
m_AdditionalInventoryConfigs = config.GetString("AdditionalInventories", string.Empty).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (m_AdditionalInventoryConfigs.Length == 1 && m_AdditionalInventoryConfigs[0] == string.Empty)
{
m_AdditionalInventoryConfigs = new string[0];
}
m_AssetSourcesConfig = config.GetString("AssetSources", string.Empty);
m_ScriptStatesConfig = config.GetString("ScriptStates", string.Empty);
CompilerRegistry.ScriptCompilers.DefaultCompilerName = config.GetString("DefaultCompiler");
}
private void PostAgent_Local(UserAccount account, ClientInfo clientInfo, SessionInfo sessionInfo, DestinationInfo destinationInfo, CircuitInfo circuitInfo, AppearanceInfo appearance, UUID capsId, int maxAllowedWearables, out string capsPath)
{
SceneInterface scene;
if (!m_Scenes.TryGetValue(destinationInfo.ID, out scene))
{
throw new LoginFailedException(string.Format("No destination for agent {0}", account.Principal.FullName));
}
/* We have established trust of home grid by verifying its agent.
* At least agent and grid belong together.
*
* Now, we can validate the access of the agent.
*/
var ad = new AuthorizationServiceInterface.AuthorizationData
{
ClientInfo = clientInfo,
SessionInfo = sessionInfo,
AccountInfo = account,
DestinationInfo = destinationInfo,
AppearanceInfo = appearance
};
foreach (AuthorizationServiceInterface authService in m_AuthorizationServices)
{
authService.Authorize(ad);
}
try
{
IAgent sceneAgent = scene.Agents[account.Principal.ID];
if (sceneAgent.Owner.EqualsGrid(account.Principal))
{
if (circuitInfo.IsChild && !sceneAgent.IsInScene(scene))
{
/* already got an agent here */
m_Log.WarnFormat("Failed to create agent due to duplicate agent id. {0} != {1}", sceneAgent.Owner.ToString(), account.Principal.ToString());
throw new LoginFailedException("Failed to create agent due to duplicate agent id");
}
else if (!circuitInfo.IsChild && !sceneAgent.IsInScene(scene))
{
/* child becomes root */
throw new LoginFailedException("Teleport destination not yet implemented");
}
}
else if (sceneAgent.Owner.ID == account.Principal.ID)
{
/* we got an agent already and no grid match? */
m_Log.WarnFormat("Failed to create agent due to duplicate agent id. {0} != {1}", sceneAgent.Owner.ToString(), account.Principal.ToString());
throw new LoginFailedException("Failed to create agent due to duplicate agent id");
}
}
catch
{
/* no action needed */
}
GridServiceInterface gridService = scene.GridService;
var serviceList = new AgentServiceList
{
m_LocalAssetService,
m_LocalInventoryService
};
if (m_LocalGroupsService != null)
{
serviceList.Add(m_LocalGroupsService);
}
if (m_LocalExperienceService != null)
{
serviceList.Add(m_LocalExperienceService);
}
if (m_LocalProfileService != null)
{
serviceList.Add(m_LocalProfileService);
}
serviceList.Add(m_LocalFriendsService);
serviceList.Add(new StandalonePresenceService(m_LocalUserAccountService, account.Principal, m_LocalUserSessionService, sessionInfo.SessionID, m_UserSessionStatusServices));
serviceList.Add(gridService);
serviceList.Add(m_LocalOfflineIMService);
if (m_LocalEconomyService != null)
{
serviceList.Add(m_LocalEconomyService);
}
foreach (ITeleportHandlerFactoryServiceInterface factory in m_TeleportProtocols)
{
serviceList.Add(factory.Instantiate(m_CommandRegistry, m_CapsRedirector, m_PacketHandlerPlugins, m_Scenes));
}
var agent = new ViewerAgent(
m_Scenes,
account.Principal.ID,
account.Principal.FirstName,
account.Principal.LastName,
account.Principal.HomeURI,
sessionInfo.SessionID,
sessionInfo.SecureSessionID,
clientInfo,
account,
serviceList)
{
ServiceURLs = account.ServiceURLs,
Appearance = appearance
};
try
{
scene.DetermineInitialAgentLocation(agent, destinationInfo.TeleportFlags, destinationInfo.Location, destinationInfo.LookAt);
}
catch (Exception e)
{
m_Log.InfoFormat("Failed to determine initial location for agent {0}: {1}: {2}", account.Principal.FullName, e.GetType().FullName, e.Message);
#if DEBUG
m_Log.Debug("Exception", e);
#endif
throw new LoginFailedException(e.Message);
}
var udpServer = (UDPCircuitsManager)scene.UDPServer;
IPAddress ipAddr;
if (!IPAddress.TryParse(clientInfo.ClientIP, out ipAddr))
{
m_Log.InfoFormat("Invalid IP address for agent {0}", account.Principal.FullName);
throw new LoginFailedException("Invalid IP address");
}
var ep = new IPEndPoint(ipAddr, 0);
var circuit = new AgentCircuit(
Commands,
agent,
udpServer,
circuitInfo.CircuitCode,
m_CapsRedirector,
circuitInfo.CapsPath,
agent.ServiceURLs,
m_GatekeeperURI,
m_PacketHandlerPlugins,
ep)
{
LastTeleportFlags = destinationInfo.TeleportFlags,
Agent = agent,
AgentID = account.Principal.ID,
SessionID = sessionInfo.SessionID
};
agent.Circuits.Add(circuit.Scene.ID, circuit);
try
{
scene.Add(agent);
try
{
udpServer.AddCircuit(circuit);
}
catch
{
scene.Remove(agent);
throw;
}
}
catch (Exception e)
{
m_Log.Debug("Failed agent post", e);
agent.Circuits.Clear();
throw new LoginFailedException(e.Message);
}
try
{
agent.EconomyService?.Login(destinationInfo.ID, account.Principal, sessionInfo.SessionID, sessionInfo.SecureSessionID);
}
catch (Exception e)
{
m_Log.Warn("Could not contact EconomyService", e);
}
if (!circuitInfo.IsChild)
{
/* make agent a root agent */
agent.SceneID = scene.ID;
try
{
m_LocalUserAccountService.SetPosition(account.Principal.ID, new UserRegionData
{
RegionID = scene.ID,
Position = agent.GlobalPosition,
LookAt = agent.LookAt,
GatekeeperURI = new URI(scene.GatekeeperURI)
});
}
catch (Exception e)
{
m_Log.Warn("Could not contact UserAccountService", e);
}
}
try
{
m_LocalUserSessionService[agent.SessionID, KnownUserSessionInfoVariables.LocationRegionID] = scene.ID.ToString();
}
catch (Exception e)
{
m_Log.Warn("Could not contact PresenceService", e);
}
circuit.LogIncomingAgent(m_Log, circuitInfo.IsChild);
capsPath = m_CapsRedirector.NewCapsURL(circuitInfo.CapsPath);
}
