/**
* Agent-related communications
*/
public bool CreateAgent(GridRegion destination, AgentCircuitData aCircuit, uint teleportFlags, out CreateAgentResponse response)
{
response = new CreateAgentResponse();
IScene Scene = destination == null ? null : GetScene(destination.RegionID);
if (destination == null || Scene == null)
{
response.Reason = "Given destination was null";
response.Success = false;
return false;
}
if (Scene.RegionInfo.RegionID != destination.RegionID)
{
response.Reason = "Did not find region " + destination.RegionName;;
response.Success = false;
return false;
}
IEntityTransferModule transferModule = Scene.RequestModuleInterface<IEntityTransferModule>();
if (transferModule != null)
return transferModule.NewUserConnection(Scene, aCircuit, teleportFlags, out response);
response.Reason = "Did not find region " + destination.RegionName;
response.Success = false;
return false;
}
public bool CloseAgent(GridRegion destination, UUID agentID)
{
CloseAgentRequest request = new CloseAgentRequest();
request.AgentID = agentID;
request.Destination = destination;
m_syncMessagePoster.Post(destination.ServerURI, request.ToOSD());
return true;
}
/// <summary>
/// Define equality as two regions having the same, non-zero UUID.
/// </summary>
public bool Equals(GridRegion region)
{
if (region == null)
{
return(false);
}
// Return true if the non-zero UUIDs are equal:
return((RegionID != UUID.Zero) && RegionID.Equals(region.RegionID));
}
public bool CloseAgent(GridRegion destination, UUID agentID)
{
CloseAgentRequest request = new CloseAgentRequest();
request.AgentID = agentID;
request.Destination = destination;
m_syncMessagePoster.Post(destination.ServerURI, request.ToOSD());
return(true);
}
public bool UpdateAgent(GridRegion destination, AgentPosition data)
{
if (m_blackListedRegions.ContainsKey(destination.ServerURI))
{
//Check against time
if (m_blackListedRegions[destination.ServerURI] > 3 &&
Util.EnvironmentTickCountSubtract(m_blackListedRegions[destination.ServerURI]) > 0)
{
MainConsole.Instance.Warn("[SimServiceConnector]: Blacklisted region " + destination.RegionName +
" requested");
//Still blacklisted
return(false);
}
}
UpdateAgentPositionRequest request = new UpdateAgentPositionRequest();
request.Update = data;
request.Destination = destination;
AutoResetEvent resetEvent = new AutoResetEvent(false);
OSDMap result = null;
m_syncMessagePoster.Get(destination.ServerURI, request.ToOSD(), (response) =>
{
result = response;
resetEvent.Set();
});
bool success = resetEvent.WaitOne(10000) && result != null;
if (!success)
{
if (m_blackListedRegions.ContainsKey(destination.ServerURI))
{
if (m_blackListedRegions[destination.ServerURI] == 3)
{
//add it to the blacklist as the request completely failed 3 times
m_blackListedRegions[destination.ServerURI] = Util.EnvironmentTickCount() + 60 * 1000; //60 seconds
}
else if (m_blackListedRegions[destination.ServerURI] == 0)
{
m_blackListedRegions[destination.ServerURI]++;
}
}
else
{
m_blackListedRegions[destination.ServerURI] = 0;
}
return(false);
}
//Clear out the blacklist if it went through
m_blackListedRegions.Remove(destination.ServerURI);
return(result["Success"].AsBoolean());
}
public virtual void Teleport(IScenePresence sp, ulong regionHandle, Vector3 position, Vector3 lookAt,
uint teleportFlags)
{
int x = 0, y = 0;
Util.UlongToInts(regionHandle, out x, out y);
GridRegion reg = sp.Scene.GridService.GetRegionByPosition(sp.ControllingClient.AllScopeIDs, x, y);
if (reg == null)
{
List <GridRegion> regions = sp.Scene.GridService.GetRegionRange(
sp.ControllingClient.AllScopeIDs,
x - (sp.Scene.GridService.GetRegionViewSize() * sp.Scene.RegionInfo.RegionSizeX),
x + (sp.Scene.GridService.GetRegionViewSize() * sp.Scene.RegionInfo.RegionSizeX),
y - (sp.Scene.GridService.GetRegionViewSize() * sp.Scene.RegionInfo.RegionSizeY),
y + (sp.Scene.GridService.GetRegionViewSize() * sp.Scene.RegionInfo.RegionSizeY)
);
foreach (GridRegion r in regions)
{
if (r.RegionLocX <= x && r.RegionLocX + r.RegionSizeX > x &&
r.RegionLocY <= y && r.RegionLocY + r.RegionSizeY > y)
{
reg = r;
position.X += x - reg.RegionLocX;
position.Y += y - reg.RegionLocY;
break;
}
}
if (reg == null)
{
// TP to a place that doesn't exist (anymore)
// Inform the viewer about that
sp.ControllingClient.SendTeleportFailed("The region you tried to teleport to doesn't exist anymore");
// and set the map-tile to '(Offline)'
int regX, regY;
Util.UlongToInts(regionHandle, out regX, out regY);
MapBlockData block = new MapBlockData {
X = (ushort)(regX / Constants.RegionSize),
Y = (ushort)(regY / Constants.RegionSize),
Access = 254
};
// == not there
List <MapBlockData> blocks = new List <MapBlockData> {
block
};
sp.ControllingClient.SendMapBlock(blocks, 0);
return;
}
}
Teleport(sp, reg, position, lookAt, teleportFlags);
}
public bool FailedToMoveAgentIntoNewRegion(UUID agentID, GridRegion destination)
{
FailedToMoveAgentIntoNewRegionRequest request = new FailedToMoveAgentIntoNewRegionRequest();
request.AgentID = agentID;
request.RegionID = destination.RegionID;
m_syncMessagePoster.Post(destination.ServerURI, request.ToOSD());
return(true);
}
/// <summary>
/// Tries to teleport agent to other region.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="reg"></param>
/// <param name="position"></param>
/// <param name="lookAt"></param>
/// <param name="teleportFlags"></param>
public void RequestTeleportLocation(IClientAPI remoteClient, GridRegion reg, Vector3 position,
Vector3 lookAt, uint teleportFlags)
{
IScenePresence sp = remoteClient.Scene.GetScenePresence(remoteClient.AgentId);
if (sp != null)
{
Teleport(sp, reg, position, lookAt, teleportFlags);
}
}
public virtual void Teleport(IScenePresence sp, GridRegion finalDestination, Vector3 position, Vector3 lookAt,
uint teleportFlags)
{
sp.ControllingClient.SendTeleportStart(teleportFlags);
sp.ControllingClient.SendTeleportProgress(teleportFlags, "requesting");
// Reset animations; the viewer does that in teleports.
if (sp.Animator != null)
{
sp.Animator.ResetAnimations();
}
try {
string reason = "";
if (finalDestination.RegionHandle == sp.Scene.RegionInfo.RegionHandle)
{
// First check whether the user is allowed to move at all
if (!sp.Scene.Permissions.AllowedOutgoingLocalTeleport(sp.UUID, out reason))
{
sp.ControllingClient.SendTeleportFailed(reason);
return;
}
// Now respect things like parcel bans with this
if (
!sp.Scene.Permissions.AllowedIncomingTeleport(sp.UUID, position, teleportFlags, out position,
out reason))
{
sp.ControllingClient.SendTeleportFailed(reason);
return;
}
MainConsole.Instance.DebugFormat("[Entity transfer]: RequestTeleportToLocation {0} within {1}",
position, sp.Scene.RegionInfo.RegionName);
sp.ControllingClient.SendLocalTeleport(position, lookAt, teleportFlags);
sp.RequestModuleInterface <IScriptControllerModule> ()
.HandleForceReleaseControls(sp.ControllingClient, sp.UUID);
sp.Teleport(position);
}
else // Another region possibly in another simulator
{
// Make sure the user is allowed to leave this region
if (!sp.Scene.Permissions.AllowedOutgoingRemoteTeleport(sp.UUID, out reason))
{
sp.ControllingClient.SendTeleportFailed(reason);
return;
}
DoTeleport(sp, finalDestination, position, lookAt, teleportFlags);
}
} catch (Exception e) {
MainConsole.Instance.ErrorFormat("[Entity transfer]: Exception on teleport: {0}\n{1}",
e.Message, e.StackTrace);
sp.ControllingClient.SendTeleportFailed("Internal error");
}
}
public bool CloseAgent(GridRegion destination, UUID agentID)
{
IScene Scene = destination == null ? null : GetScene(destination.RegionID);
if (Scene == null || destination == null)
return false;
IEntityTransferModule transferModule = Scene.RequestModuleInterface<IEntityTransferModule>();
if (transferModule != null)
return transferModule.IncomingCloseAgent(Scene, agentID);
return false;
}
public bool MakeChildAgent(UUID agentID, GridRegion oldRegion, GridRegion destination, bool isCrossing)
{
MakeChildAgentRequest request = new MakeChildAgentRequest();
request.AgentID = agentID;
request.OldRegion = oldRegion;
request.Destination = destination;
request.IsCrossing = isCrossing;
m_syncMessagePoster.Post(oldRegion.ServerURI, request.ToOSD());
return(true);
}
public bool IsAuthorizedForRegion(GridRegion region, AgentCircuitData agent, bool isRootAgent, out string reason)
{
ISceneManager manager = m_registry.RequestModuleInterface<ISceneManager>();
IScene scene = manager == null ? null : manager.Scenes.Find((s) => s.RegionInfo.RegionID == region.RegionID);
if (scene != null)
{
//Found the region, check permissions
return scene.Permissions.AllowedIncomingAgent(agent, isRootAgent, out reason);
}
reason = "Not Authorized as region does not exist.";
return false;
}
void FillOutRegionData(AgentCircuitData circuitData, GridRegion destination)
{
IPEndPoint endPoint = destination.ExternalEndPoint;
//We don't need this anymore, we set this from what we get from the region
//endPoint = Util.ResolveAddressForClient (endPoint, circuitData.ClientIPEndPoint);
SimAddress = endPoint.Address.ToString();
SimPort = (uint)circuitData.RegionUDPPort;
RegionX = (uint)destination.RegionLocX;
RegionY = (uint)destination.RegionLocY;
RegionSizeX = destination.RegionSizeX;
RegionSizeY = destination.RegionSizeY;
}
public void IncomingCapsRequest (UUID agentID, GridRegion region, ISimulationBase simbase, ref OSDMap capURLs)
{
m_syncMessage = simbase.ApplicationRegistry.RequestModuleInterface<ISyncMessagePosterService> ();
m_appearanceService = simbase.ApplicationRegistry.RequestModuleInterface<IAgentAppearanceService> ();
m_region = region;
m_agentID = agentID;
if (m_appearanceService == null)
return;//Can't bake!
m_uri = "/CAPS/UpdateAvatarAppearance/" + UUID.Random () + "/";
MainServer.Instance.AddStreamHandler (new GenericStreamHandler ("POST", m_uri, UpdateAvatarAppearance));
capURLs ["UpdateAvatarAppearance"] = MainServer.Instance.ServerURI + m_uri;
}
public virtual bool TeleportHome(UUID id, IClientAPI client)
{
// MainConsole.Instance.DebugFormat[Entity transfer]r]: Request to teleport {0} {1} home", client.FirstName, client.LastName);
UserInfo uinfo =
client.Scene.RequestModuleInterface <IAgentInfoService> ().GetUserInfo(client.AgentId.ToString());
if (uinfo != null)
{
GridRegion regionInfo = client.Scene.GridService.GetRegionByUUID(client.AllScopeIDs, uinfo.HomeRegionID);
if (regionInfo == null)
{
// can't find the Home region: Tell viewer and abort
client.SendTeleportFailed("Your home region could not be found.");
return(false);
}
MainConsole.Instance.DebugFormat("[Entity transfer]: User's home region is {0} {1} ({2}-{3})",
regionInfo.RegionName, regionInfo.RegionID,
regionInfo.RegionLocX / Constants.RegionSize,
regionInfo.RegionLocY / Constants.RegionSize);
RequestTeleportLocation(
client, regionInfo, uinfo.HomePosition, uinfo.HomeLookAt,
(uint)(TeleportFlags.SetLastToTarget | TeleportFlags.ViaHome));
}
else
{
// Default region time...
List <GridRegion> defaultRegions = client.Scene.GridService.GetDefaultRegions(client.AllScopeIDs);
if (defaultRegions.Count > 0)
{
MainConsole.Instance.DebugFormat("[Entity transfer]: User's home region was not found, using {0} {1} ({2}-{3})",
defaultRegions [0].RegionName,
defaultRegions [0].RegionID,
defaultRegions [0].RegionLocX / Constants.RegionSize,
defaultRegions [0].RegionLocY / Constants.RegionSize);
RequestTeleportLocation(
client, defaultRegions [0], new Vector3(128, 128, 25), new Vector3(128, 128, 128),
(uint)(TeleportFlags.SetLastToTarget | TeleportFlags.ViaHome));
}
else
{
defaultRegions = null;
}
return(false);
}
return(true);
}
public bool FailedToTeleportAgent(GridRegion destination, UUID failedRegionID, UUID agentID, string reason,
bool isCrossing)
{
FailedToTeleportAgentRequest request = new FailedToTeleportAgentRequest();
request.AgentID = agentID;
request.Destination = destination;
request.IsCrossing = isCrossing;
request.FailedRegionID = failedRegionID;
request.Reason = reason;
m_syncMessagePoster.Post(destination.ServerURI, request.ToOSD());
return(true);
}
public void IncomingCapsRequest(UUID agentID, GridRegion region, ISimulationBase simbase, ref OSDMap capURLs)
{
m_syncMessage = simbase.ApplicationRegistry.RequestModuleInterface <ISyncMessagePosterService> ();
m_appearanceService = simbase.ApplicationRegistry.RequestModuleInterface <IAgentAppearanceService> ();
m_region = region;
m_agentID = agentID;
if (m_appearanceService == null)
{
return; // Can't bake!
}
m_uri = "/CAPS/UpdateAvatarAppearance/" + UUID.Random() + "/";
MainServer.Instance.AddStreamHandler(new GenericStreamHandler("POST", m_uri, UpdateAvatarAppearance));
capURLs ["UpdateAvatarAppearance"] = MainServer.Instance.ServerURI + m_uri;
}
public List <GridRegion> GetNeighbours(UUID regionID, List <UUID> scopeIDs, uint squareRangeFromCenterInMeters)
{
List <GridRegion> regions = new List <GridRegion> (0);
GridRegion region = Get(regionID, scopeIDs);
if (region != null)
{
int centerX = region.RegionLocX + (region.RegionSizeX / 2); // calculate center of region
int centerY = region.RegionLocY + (region.RegionSizeY / 2); // calculate center of region
regions = GetList(scopeIDs, region.RegionID, centerX, centerY, squareRangeFromCenterInMeters);
}
return(regions);
}
/* #region IService implementation
*
* public void Initialize(IConfigSource config, IRegistryCore registry)
* {
* throw new System.NotImplementedException();
* }
*
* public void Start(IConfigSource config, IRegistryCore registry)
* {
* throw new System.NotImplementedException();
* }
*
* public void FinishedStartup()
* {
* throw new System.NotImplementedException();
* }
*
#endregion
*/
#region user
/// <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>
OSDMap GetGridUserInfo(OSDMap map)
{
string uuid = string.Empty;
uuid = map ["UUID"].AsString();
IUserAccountService accountService = m_registry.RequestModuleInterface <IUserAccountService> ();
UserAccount userAcct = accountService.GetUserAccount(null, map ["UUID"].AsUUID());
IAgentInfoService agentService = m_registry.RequestModuleInterface <IAgentInfoService> ();
UserInfo userinfo;
OSDMap resp = new OSDMap();
bool usr_verified = userAcct.Valid;
resp ["Verified"] = OSD.FromBoolean(usr_verified);
resp ["UUID"] = OSD.FromUUID(userAcct.PrincipalID);
resp ["Email"] = OSD.FromString(userAcct.Email);
resp ["Name"] = OSD.FromString(userAcct.Name);
resp ["FirstName"] = OSD.FromString(userAcct.FirstName);
resp ["LastName"] = OSD.FromString(userAcct.LastName);
// just some defaults
resp ["HomeUUID"] = OSD.FromUUID(UUID.Zero);
resp ["HomeName"] = OSD.FromString("");
resp ["Online"] = OSD.FromBoolean(false);
if (verified)
{
userinfo = agentService.GetUserInfo(uuid);
if (userinfo != null)
{
resp ["HomeUUID"] = OSD.FromUUID(userinfo.HomeRegionID);
resp ["Online"] = OSD.FromBoolean(userinfo.IsOnline);
}
IGridService gs = m_registry.RequestModuleInterface <IGridService> ();
if (gs != null)
{
GridRegion gr = gs.GetRegionByUUID(null, userinfo.HomeRegionID);
if (gr != null)
{
resp ["HomeName"] = OSD.FromString(gr.RegionName);
}
}
}
return(resp);
}
public OSDMap GetExternalCaps(UUID agentID, GridRegion region)
{
if (m_registry == null)
{
return(new OSDMap());
}
OSDMap resp = new OSDMap();
if (m_registry.RequestModuleInterface <IGridServerInfoService>() != null)
{
m_servers = m_registry.RequestModuleInterface <IGridServerInfoService>().GetGridURIs("SyncMessageServerURI");
OSDMap req = new OSDMap();
req["AgentID"] = agentID;
req["Region"] = region.ToOSD();
req["Method"] = "GetCaps";
List <ManualResetEvent> events = new List <ManualResetEvent>();
foreach (string uri in m_servers.Where((u) => (!u.Contains(MainServer.Instance.Port.ToString()))))
{
ManualResetEvent even = new ManualResetEvent(false);
m_syncPoster.Get(uri, req, (r) =>
{
if (r == null)
{
return;
}
foreach (KeyValuePair <string, OSD> kvp in r)
{
resp.Add(kvp.Key, kvp.Value);
}
even.Set();
});
events.Add(even);
}
if (events.Count > 0)
{
ManualResetEvent.WaitAll(events.ToArray());
}
}
foreach (var h in GetHandlers(agentID, region.RegionID))
{
if (m_allowedCapsModules.Contains(h.Name))
{
h.IncomingCapsRequest(agentID, region, m_registry.RequestModuleInterface <ISimulationBase>(), ref resp);
}
}
return(resp);
}
public void RemoveExternalCaps(UUID agentID, GridRegion region)
{
OSDMap req = new OSDMap();
req["AgentID"] = agentID;
req["Region"] = region.ToOSD();
req["Method"] = "RemoveCaps";
foreach (string uri in m_servers)
m_syncPoster.Post(uri, req);
foreach (var h in GetHandlers(agentID, region.RegionID))
{
if (m_allowedCapsModules.Contains(h.Name))
h.IncomingCapsDestruction();
}
}
/// <summary>
/// Tries to teleport agent to other region.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="regionName"></param>
/// <param name="position"></param>
/// <param name="lookat"></param>
/// <param name="teleportFlags"></param>
public void RequestTeleportLocation(IClientAPI remoteClient, string regionName, Vector3 position,
Vector3 lookat, uint teleportFlags)
{
GridRegion regionInfo =
remoteClient.Scene.RequestModuleInterface <IGridService> ()
.GetRegionByName(remoteClient.AllScopeIDs, regionName);
if (regionInfo == null)
{
// can't find the region: Tell viewer and abort
remoteClient.SendTeleportFailed("The region '" + regionName + "' could not be found.");
return;
}
RequestTeleportLocation(remoteClient, regionInfo, position, lookat, teleportFlags);
}
private void FillOutHomeData(Framework.Services.UserInfo pinfo, GridRegion home)
{
int x = 1000 * Constants.RegionSize, y = 1000 * Constants.RegionSize;
if (home != null)
{
x = home.RegionLocX;
y = home.RegionLocY;
}
Home = string.Format(
"{{'region_handle':[r{0},r{1}], 'position':[r{2},r{3},r{4}], 'look_at':[r{5},r{6},r{7}]}}",
x,
y,
pinfo.HomePosition.X, pinfo.HomePosition.Y, pinfo.HomePosition.Z,
pinfo.HomeLookAt.X, pinfo.HomeLookAt.Y, pinfo.HomeLookAt.Z);
}
public bool CloseAgent(GridRegion destination, UUID agentID)
{
IScene Scene = destination == null ? null : GetScene(destination.RegionID);
if (Scene == null || destination == null)
{
return(false);
}
IEntityTransferModule transferModule = Scene.RequestModuleInterface <IEntityTransferModule> ();
if (transferModule != null)
{
return(transferModule.IncomingCloseAgent(Scene, agentID));
}
return(false);
}
public LLLoginResponse(UserAccount account, AgentCircuitData aCircuit, Framework.Services.UserInfo pinfo,
GridRegion destination, List <InventoryFolderBase> invSkel, FriendInfo[] friendsList,
IInventoryService invService, ILibraryService libService,
string where, string startlocation, Vector3 position, Vector3 lookAt,
List <InventoryItemBase> gestures,
GridRegion home, IPEndPoint clientIP, string AdultMax, string AdultRating,
ArrayList eventValues, ArrayList eventNotificationValues, ArrayList classifiedValues,
string seedCap, IConfigSource source,
string DisplayName, string cofversion, IGridInfo info)
: this()
{
m_source = source;
m_gridInfo = info;
SeedCapability = seedCap;
FillOutInventoryData(invSkel, libService, invService);
FillOutActiveGestures(gestures);
CircuitCode = (int)aCircuit.CircuitCode;
Lastname = account.LastName;
Firstname = account.FirstName;
this.DisplayName = DisplayName;
AgentID = account.PrincipalID;
SessionID = aCircuit.SessionID;
SecureSessionID = aCircuit.SecureSessionID;
BuddList = ConvertFriendListItem(friendsList);
StartLocation = where;
AgentAccessMax = AdultMax;
AgentAccess = AdultRating;
AgentRegionAccess = AgentRegionAccess;
AOTransition = AOTransition;
AgentFlag = AgentFlag;
eventCategories = eventValues;
eventNotifications = eventNotificationValues;
classifiedCategories = classifiedValues;
COFVersion = cofversion;
FillOutHomeData(pinfo, home);
LookAt = string.Format("[r{0},r{1},r{2}]", lookAt.X, lookAt.Y, lookAt.Z);
FillOutRegionData(aCircuit, destination);
login = "******";
ErrorMessage = "";
ErrorReason = LoginResponseEnum.OK;
}
public virtual void DoTeleport(IScenePresence sp, GridRegion finalDestination, Vector3 position, Vector3 lookAt,
uint teleportFlags)
{
sp.ControllingClient.SendTeleportProgress(teleportFlags, "sending_dest");
if (finalDestination == null)
{
sp.ControllingClient.SendTeleportFailed("Unable to locate destination");
return;
}
MainConsole.Instance.DebugFormat("[Entity transfer]: Request Teleport to {0}:{1}/{2}",
finalDestination.ServerURI, finalDestination.RegionName, position);
sp.ControllingClient.SendTeleportProgress(teleportFlags, "arriving");
sp.SetAgentLeaving(finalDestination);
// Fixing a bug where teleporting while sitting results in the avatar ending up removed from
// both regions
if (sp.ParentID != UUID.Zero)
{
sp.StandUp();
}
AgentCircuitData agentCircuit = BuildCircuitDataForPresence(sp, position);
AgentData agent = new AgentData();
sp.CopyTo(agent);
// Fix the position
agent.Position = position;
ISyncMessagePosterService syncPoster = sp.Scene.RequestModuleInterface <ISyncMessagePosterService> ();
if (syncPoster != null)
{
// This does CreateAgent and sends the EnableSimulator/EstablishAgentCommunication/TeleportFinish
// messages if they need to be called and deals with the callback
syncPoster.PostToServer(SyncMessageHelper.TeleportAgent((int)sp.DrawDistance,
agentCircuit,
agent,
teleportFlags,
finalDestination,
sp.Scene.RegionInfo.RegionID));
}
}
public void IncomingCapsRequest(UUID agentID, WhiteCore.Framework.Services.GridRegion region, ISimulationBase simbase, ref OSDMap capURLs)
{
m_AgentID = agentID;
m_assetService = simbase.ApplicationRegistry.RequestModuleInterface <IAssetService>();
m_j2kDecoder = simbase.ApplicationRegistry.RequestModuleInterface <IJ2KDecoder>();
m_getTextureURI = "/CAPS/GetTexture/" + UUID.Random() + "/";
capURLs["GetTexture"] = MainServer.Instance.ServerURI + m_getTextureURI;
MainServer.Instance.AddStreamHandler(new GenericStreamHandler("GET", m_getTextureURI, ProcessGetTexture));
m_bakedTextureURI = "/CAPS/UploadBakedTexture/" + UUID.Random() + "/";
capURLs["UploadBakedTexture"] = MainServer.Instance.ServerURI + m_bakedTextureURI;
MainServer.Instance.AddStreamHandler(new GenericStreamHandler("POST", m_bakedTextureURI, UploadBakedTexture));
m_getMeshURI = "/CAPS/GetMesh/" + UUID.Random() + "/";
capURLs["GetMesh"] = MainServer.Instance.ServerURI + m_getMeshURI;
MainServer.Instance.AddStreamHandler(new GenericStreamHandler("GET", m_getMeshURI, ProcessGetMesh));
}
public void FailedToTeleportAgent(GridRegion failedCrossingRegion, UUID agentID, string reason, bool isCrossing)
{
IScenePresence sp = m_scene.GetScenePresence(agentID);
if (sp == null)
{
return;
}
sp.IsChildAgent = false;
// Tell modules about it
sp.AgentFailedToLeave();
sp.ControllingClient.SendTeleportFailed(reason);
if (isCrossing)
{
sp.FailedCrossingTransit(failedCrossingRegion);
}
}
public bool MakeChildAgent(UUID AgentID, GridRegion oldRegion, GridRegion destination, bool isCrossing)
{
IScene Scene = oldRegion == null ? null : GetScene(oldRegion.RegionID);
if (Scene == null)
{
return(false);
}
IEntityTransferModule transferModule = Scene.RequestModuleInterface <IEntityTransferModule> ();
if (transferModule == null)
{
return(false);
}
transferModule.MakeChildAgent(Scene.GetScenePresence(AgentID), destination, isCrossing);
return(true);
}
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 bool CreateAgent(GridRegion destination, AgentCircuitData aCircuit, uint teleportFlags, out CreateAgentResponse response)
{
response = null;
if (destination == null)
{
response = new CreateAgentResponse();
response.Reason = "Could not connect to destination";
response.Success = false;
return(false);
}
CreateAgentRequest request = new CreateAgentRequest();
request.CircuitData = aCircuit;
request.Destination = destination;
request.TeleportFlags = teleportFlags;
AutoResetEvent resetEvent = new AutoResetEvent(false);
OSDMap result = null;
MainConsole.Instance.DebugFormat("[SimulationServiceConnector]: Sending Create Agent to " + destination.ServerURI);
m_syncMessagePoster.Get(destination.ServerURI, request.ToOSD(), (osdresp) =>
{
result = osdresp;
resetEvent.Set();
});
bool success = resetEvent.WaitOne(10000);
if (!success || result == null)
{
response = new CreateAgentResponse();
response.Reason = "Could not connect to destination";
response.Success = false;
return(false);
}
response = new CreateAgentResponse();
response.FromOSD(result);
if (!response.Success)
{
return(false);
}
return(response.Success);
}
public bool UpdateAgent(GridRegion destination, AgentPosition agentData)
{
IScene Scene = destination == null ? null : GetScene(destination.RegionID);
if (Scene == null || destination == null)
{
return(false);
}
//MainConsole.Instance.Debug("[LOCAL COMMS]: Found region to send ChildAgentUpdate");
IEntityTransferModule transferModule = Scene.RequestModuleInterface <IEntityTransferModule> ();
if (transferModule != null)
{
return(transferModule.IncomingChildAgentDataUpdate(Scene, agentData));
}
return(false);
}
public bool FailedToTeleportAgent(GridRegion destination, UUID failedRegionID, UUID agentID, string reason,
bool isCrossing)
{
IScene Scene = destination == null ? null : GetScene(destination.RegionID);
if (Scene == null)
{
return(false);
}
IEntityTransferModule transferModule = Scene.RequestModuleInterface <IEntityTransferModule> ();
if (transferModule == null)
{
return(false);
}
transferModule.FailedToTeleportAgent(destination, agentID, reason, isCrossing);
return(true);
}
/**
* Object-related communications
*/
public bool CreateObject(GridRegion destination, ISceneEntity sog)
{
IScene Scene = destination == null ? null : GetScene(destination.RegionID);
if (Scene == null || destination == null)
{
return(false);
}
//MainConsole.Instance.Debug("[LOCAL COMMS]: Found region to SendCreateObject");
IEntityTransferModule AgentTransferModule = Scene.RequestModuleInterface <IEntityTransferModule> ();
if (AgentTransferModule != null)
{
return(AgentTransferModule.IncomingCreateObject(Scene.RegionInfo.RegionID, sog));
}
return(false);
}
void FillOutHomeData(Framework.Services.UserInfo pinfo, GridRegion homeRegion)
{
// TODO: The region start positions should be retrieved from the SimulationBase MapCenterX/MapCenterY
// This is a fallback setting as the user's home region should have been set on login
int x = Constants.DEFAULT_REGIONSTART_X * Constants.RegionSize;
int y = Constants.DEFAULT_REGIONSTART_Y * Constants.RegionSize;
if (homeRegion != null)
{
x = homeRegion.RegionLocX;
y = homeRegion.RegionLocY;
}
Home = string.Format(
"{{'region_handle':[r{0},r{1}], 'position':[r{2},r{3},r{4}], 'look_at':[r{5},r{6},r{7}]}}",
x,
y,
pinfo.HomePosition.X, pinfo.HomePosition.Y, pinfo.HomePosition.Z,
pinfo.HomeLookAt.X, pinfo.HomeLookAt.Y, pinfo.HomeLookAt.Z);
}
public bool UpdateAgent(GridRegion destination, AgentData agentData)
{
IScene Scene = destination == null ? null : GetScene(destination.RegionID);
if (destination == null || Scene == null || agentData == null)
{
return(false);
}
bool retVal = false;
IEntityTransferModule transferModule = Scene.RequestModuleInterface <IEntityTransferModule> ();
if (transferModule != null)
{
retVal = transferModule.IncomingChildAgentDataUpdate(Scene, agentData);
}
// MainConsole.Instance.DebugFormat("[LOCAL COMMS]: Did not find region {0} for ChildAgentUpdate", regionHandle);
return(retVal);
}
public void Close(IScene scene)
{
//Deregister the interface
scene.UnregisterModuleInterface<IGridRegisterModule>(this);
m_scene = null;
MainConsole.Instance.InfoFormat("[RegisterRegionWithGrid]: Deregistering region {0} from the grid...",
scene.RegionInfo.RegionName);
//Deregister from the grid server
GridRegion r = new GridRegion(scene.RegionInfo);
r.IsOnline = false;
string error = "";
if (scene.RegionInfo.HasBeenDeleted || !m_markRegionsAsOffline)
scene.GridService.DeregisterRegion(r);
else if ((error = scene.GridService.UpdateMap(r, false)) != "")
MainConsole.Instance.WarnFormat(
"[RegisterRegionWithGrid]: Deregister from grid failed for region {0}, {1}",
scene.RegionInfo.RegionName, error);
}
public bool Store(GridRegion region)
{
if (region.EstateOwner == UUID.Zero)
{
IEstateConnector EstateConnector = Framework.Utilities.DataManager.RequestPlugin <IEstateConnector> ();
EstateSettings ES = null;
if (EstateConnector != null)
{
ES = EstateConnector.GetRegionEstateSettings(region.RegionID);
if ((ES != null) && (ES.EstateID != 0))
{
region.EstateOwner = ES.EstateOwner;
}
}
if (region.EstateOwner == UUID.Zero && ES != null && ES.EstateID != 0)
{
MainConsole.Instance.Error(
"[LocalGridConnector] Attempt to store region with owner of UUID.Zero detected:" +
(new System.Diagnostics.StackTrace()).GetFrame(1));
}
}
Dictionary <string, object> row = new Dictionary <string, object> (14);
row ["ScopeID"] = region.ScopeID;
row ["RegionUUID"] = region.RegionID;
row ["RegionName"] = region.RegionName;
row ["LocX"] = region.RegionLocX;
row ["LocY"] = region.RegionLocY;
row ["LocZ"] = region.RegionLocZ;
row ["OwnerUUID"] = region.EstateOwner;
row ["Access"] = region.Access;
row ["SizeX"] = region.RegionSizeX;
row ["SizeY"] = region.RegionSizeY;
row ["SizeZ"] = region.RegionSizeZ;
row ["Flags"] = region.Flags;
row ["SessionID"] = region.SessionID;
row ["Info"] = OSDParser.SerializeJsonString(region.ToOSD());
return(m_GD.Replace(m_realm, row));
}
public bool CreateAgent(GridRegion destination, AgentCircuitData aCircuit, uint teleportFlags, out CreateAgentResponse response)
{
response = null;
if (destination == null)
{
response = new CreateAgentResponse();
response.Reason = "Could not connect to destination";
response.Success = false;
return false;
}
CreateAgentRequest request = new CreateAgentRequest();
request.CircuitData = aCircuit;
request.Destination = destination;
request.TeleportFlags = teleportFlags;
AutoResetEvent resetEvent = new AutoResetEvent(false);
OSDMap result = null;
MainConsole.Instance.DebugFormat("[SimulationServiceConnector]: Sending Create Agent to " + destination.ServerURI);
m_syncMessagePoster.Get(destination.ServerURI, request.ToOSD(), (osdresp) =>
{
result = osdresp;
resetEvent.Set();
});
bool success = resetEvent.WaitOne(10000);
if (!success || result == null)
{
response = new CreateAgentResponse();
response.Reason = "Could not connect to destination";
response.Success = false;
return false;
}
response = new CreateAgentResponse();
response.FromOSD(result);
if (!response.Success)
return false;
return response.Success;
}
public OSDMap GetExternalCaps (UUID agentID, GridRegion region)
{
if (m_registry == null)
return new OSDMap ();
OSDMap resp = new OSDMap ();
if (m_registry.RequestModuleInterface<IGridServerInfoService> () != null)
{
m_servers = m_registry.RequestModuleInterface<IGridServerInfoService> ().GetGridURIs ("SyncMessageServerURI");
OSDMap req = new OSDMap ();
req ["AgentID"] = agentID;
req ["Region"] = region.ToOSD ();
req ["Method"] = "GetCaps";
List<ManualResetEvent> events = new List<ManualResetEvent> ();
foreach (string uri in m_servers.Where((u)=>(!u.Contains(MainServer.Instance.Port.ToString()))))
{
ManualResetEvent even = new ManualResetEvent (false);
m_syncPoster.Get (uri, req, (r) => {
if (r == null)
return;
foreach (KeyValuePair<string, OSD> kvp in r)
resp.Add (kvp.Key, kvp.Value);
even.Set ();
});
events.Add (even);
}
if (events.Count > 0)
ManualResetEvent.WaitAll (events.ToArray ());
}
foreach (var h in GetHandlers(agentID, region.RegionID))
{
if (m_allowedCapsModules.Contains (h.Name))
h.IncomingCapsRequest (agentID, region, m_registry.RequestModuleInterface<ISimulationBase> (), ref resp);
}
return resp;
}
/// <summary>
/// Tries to teleport agent to other region.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="reg"></param>
/// <param name="position"></param>
/// <param name="lookAt"></param>
/// <param name="teleportFlags"></param>
public void RequestTeleportLocation(IClientAPI remoteClient, GridRegion reg, Vector3 position,
Vector3 lookAt, uint teleportFlags)
{
IScenePresence sp = remoteClient.Scene.GetScenePresence(remoteClient.AgentId);
if (sp != null)
{
Teleport(sp, reg, position, lookAt, teleportFlags);
}
}
public void MakeChildAgent(IScenePresence sp, GridRegion finalDestination, bool isCrossing)
{
if (sp == null)
return;
sp.SetAgentLeaving(finalDestination);
//Kill the groups here, otherwise they will become ghost attachments
// and stay in the sim, they'll get readded below into the new sim
//KillAttachments(sp);
// Well, this is it. The agent is over there.
KillEntity(sp.Scene, sp);
//Make it a child agent for now... the grid will kill us later if we need to close
sp.MakeChildAgent(finalDestination);
if (isCrossing)
sp.SuccessfulCrossingTransit(finalDestination);
}
public virtual void InternalCross(IScenePresence agent, Vector3 attemptedPos, bool isFlying,
GridRegion crossingRegion)
{
MainConsole.Instance.DebugFormat("[EntityTransferModule]: Crossing agent {0} to region {1}", agent.Name,
crossingRegion.RegionName);
try
{
agent.SetAgentLeaving(crossingRegion);
AgentData cAgent = new AgentData();
agent.CopyTo(cAgent);
cAgent.Position = attemptedPos;
if (isFlying)
cAgent.ControlFlags |= (uint) AgentManager.ControlFlags.AGENT_CONTROL_FLY;
AgentCircuitData agentCircuit = BuildCircuitDataForPresence(agent, attemptedPos);
agentCircuit.TeleportFlags = (uint) TeleportFlags.ViaRegionID;
//This does UpdateAgent and closing of child agents
// messages if they need to be called
ISyncMessagePosterService syncPoster =
agent.Scene.RequestModuleInterface<ISyncMessagePosterService>();
if (syncPoster != null)
{
syncPoster.PostToServer(SyncMessageHelper.CrossAgent(crossingRegion, attemptedPos,
agent.Velocity, agentCircuit, cAgent,
agent.Scene.RegionInfo.RegionID));
}
}
catch (Exception ex)
{
MainConsole.Instance.Warn("[EntityTransferModule]: Exception in crossing: " + ex);
}
}
public void FailedToTeleportAgent(GridRegion failedCrossingRegion, UUID agentID, string reason, bool isCrossing)
{
IScenePresence sp = m_scene.GetScenePresence(agentID);
if (sp == null)
return;
sp.IsChildAgent = false;
//Tell modules about it
sp.AgentFailedToLeave();
sp.ControllingClient.SendTeleportFailed(reason);
if (isCrossing)
sp.FailedCrossingTransit(failedCrossingRegion);
}
public virtual void DoTeleport(IScenePresence sp, GridRegion finalDestination, Vector3 position, Vector3 lookAt,
uint teleportFlags)
{
sp.ControllingClient.SendTeleportProgress(teleportFlags, "sending_dest");
if (finalDestination == null)
{
sp.ControllingClient.SendTeleportFailed("Unable to locate destination");
return;
}
MainConsole.Instance.DebugFormat(
"[ENTITY TRANSFER MODULE]: Request Teleport to {0}:{1}/{2}",
finalDestination.ServerURI, finalDestination.RegionName, position);
sp.ControllingClient.SendTeleportProgress(teleportFlags, "arriving");
sp.SetAgentLeaving(finalDestination);
// Fixing a bug where teleporting while sitting results in the avatar ending up removed from
// both regions
if (sp.ParentID != UUID.Zero)
sp.StandUp();
AgentCircuitData agentCircuit = BuildCircuitDataForPresence(sp, position);
AgentData agent = new AgentData();
sp.CopyTo(agent);
//Fix the position
agent.Position = position;
ISyncMessagePosterService syncPoster = sp.Scene.RequestModuleInterface<ISyncMessagePosterService>();
if (syncPoster != null)
{
//This does CreateAgent and sends the EnableSimulator/EstablishAgentCommunication/TeleportFinish
// messages if they need to be called and deals with the callback
syncPoster.PostToServer(SyncMessageHelper.TeleportAgent((int) sp.DrawDistance,
agentCircuit, agent, teleportFlags,
finalDestination, sp.Scene.RegionInfo.RegionID));
}
}
/// <summary>
/// Move the given scene object into a new region depending on which region its absolute position has moved
/// into.
/// This method locates the new region handle and offsets the prim position for the new region
/// </summary>
/// <param name="attemptedPosition">the attempted out of region position of the scene object</param>
/// <param name="grp">the scene object that we're crossing</param>
/// <param name="destination"></param>
public bool CrossGroupToNewRegion(ISceneEntity grp, Vector3 attemptedPosition, GridRegion destination)
{
if (grp == null)
return false;
if (grp.IsDeleted)
return false;
if (grp.Scene == null)
return false;
if (grp.RootChild.DIE_AT_EDGE)
{
// We remove the object here
try
{
IBackupModule backup = grp.Scene.RequestModuleInterface<IBackupModule>();
if (backup != null)
return backup.DeleteSceneObjects(new[] {grp}, true, true);
}
catch (Exception)
{
MainConsole.Instance.Warn(
"[DATABASE]: exception when trying to remove the prim that crossed the border.");
}
return false;
}
if (grp.RootChild.RETURN_AT_EDGE)
{
// We remove the object here
try
{
List<ISceneEntity> objects = new List<ISceneEntity> {grp};
ILLClientInventory inventoryModule = grp.Scene.RequestModuleInterface<ILLClientInventory>();
if (inventoryModule != null)
return inventoryModule.ReturnObjects(objects.ToArray(), UUID.Zero);
}
catch (Exception)
{
MainConsole.Instance.Warn(
"[SCENE]: exception when trying to return the prim that crossed the border.");
}
return false;
}
Vector3 oldGroupPosition = grp.RootChild.GroupPosition;
// If we fail to cross the border, then reset the position of the scene object on that border.
if (destination != null && !CrossPrimGroupIntoNewRegion(destination, grp, attemptedPosition))
{
grp.OffsetForNewRegion(oldGroupPosition);
grp.ScheduleGroupUpdate(PrimUpdateFlags.ForcedFullUpdate);
return false;
}
return true;
}
public virtual void Cross(IScenePresence agent, bool isFlying, GridRegion crossingRegion)
{
Vector3 pos = new Vector3(agent.AbsolutePosition.X, agent.AbsolutePosition.Y, agent.AbsolutePosition.Z);
pos.X = (agent.Scene.RegionInfo.RegionLocX + pos.X) - crossingRegion.RegionLocX;
pos.Y = (agent.Scene.RegionInfo.RegionLocY + pos.Y) - crossingRegion.RegionLocY;
//Make sure that they are within bounds (velocity can push it out of bounds)
if (pos.X < 0)
pos.X = 1;
if (pos.Y < 0)
pos.Y = 1;
if (pos.X > crossingRegion.RegionSizeX)
pos.X = crossingRegion.RegionSizeX - 1;
if (pos.Y > crossingRegion.RegionSizeY)
pos.Y = crossingRegion.RegionSizeY - 1;
InternalCross(agent, pos, isFlying, crossingRegion);
}
/// <summary>
/// Recursive SendGridInstantMessage over XMLRPC method.
/// This is called from within a dedicated thread.
/// The first time this is called, prevRegionHandle will be 0 Subsequent times this is called from
/// itself, prevRegionHandle will be the last region handle that we tried to send.
/// If the handles are the same, we look up the user's location using the grid.
/// If the handles are still the same, we end. The send failed.
/// </summary>
/// <param name="im"></param>
/// <param name="prevRegion">
/// Pass in 0 the first time this method is called. It will be called recursively with the last
/// regionhandle tried
/// </param>
protected virtual void SendGridInstantMessageViaXMLRPCAsync (GridInstantMessage im,
GridRegion prevRegion)
{
UUID toAgentID = im.ToAgentID;
string HTTPPath = "";
lock (IMUsersCache) {
if (!IMUsersCache.TryGetValue (toAgentID, out HTTPPath))
HTTPPath = "";
}
if (HTTPPath != "") {
//We've tried to send an IM to them before, pull out their info
//Send the IM to their last location
if (!doIMSending (HTTPPath, im)) {
//If this fails, the user has either moved from their stored location or logged out
//Since it failed, let it look them up again and rerun
lock (IMUsersCache) {
IMUsersCache.Remove (toAgentID);
}
//Clear the path and let it continue trying again.
HTTPPath = "";
} else {
//Send the IM, and it made it to the user, return true
return;
}
}
//Now query the grid server for the agent
List<string> AgentLocations = m_agentInfoService.GetAgentsLocations (im.FromAgentID.ToString (),
new List<string> (new [] { toAgentID.ToString () }));
if (AgentLocations != null && AgentLocations.Count > 0) {
//No agents, so this user is offline
if (AgentLocations [0] == "NotOnline") {
lock (IMUsersCache) {
//Remove them so we keep testing against the db
IMUsersCache.Remove (toAgentID);
}
MainConsole.Instance.Debug ("[GRID INSTANT MESSAGE]: Unable to deliver an instant message as user is not online");
HandleUndeliveredMessage (im, "User is not online.");
return;
}
if (AgentLocations [0] == "NonExistant") {
IMUsersCache.Remove (toAgentID);
MainConsole.Instance.Info ("[GRID INSTANT MESSAGE]: Unable to deliver an instant message to " +
toAgentID +
", user does not exist");
HandleUndeliveredMessage (im, "User does not exist.");
return;
}
HTTPPath = AgentLocations [0];
}
//We found the agent's location, now ask them about the user
if (HTTPPath != "") {
if (!doIMSending (HTTPPath, im)) {
//It failed, stop now
lock (IMUsersCache) {
//Remove them so we keep testing against the db
IMUsersCache.Remove (toAgentID);
}
MainConsole.Instance.Info (
"[GRID INSTANT MESSAGE]: Unable to deliver an instant message as the region could not be found");
HandleUndeliveredMessage (im, "Failed to send IM to destination.");
return;
} else {
//Add to the cache
if (!IMUsersCache.ContainsKey (toAgentID))
IMUsersCache.Add (toAgentID, HTTPPath);
//Send the IM, and it made it to the user, return true
return;
}
} else {
//Couldn't find them, stop for now
lock (IMUsersCache) {
//Remove them so we keep testing against the db
IMUsersCache.Remove (toAgentID);
}
MainConsole.Instance.Info (
"[GRID INSTANT MESSAGE]: Unable to deliver an instant message as the region could not be found");
HandleUndeliveredMessage (im, "Agent Location was blank.");
}
}
protected bool TryFindGridRegionForAgentLogin(List<GridRegion> regions, UserAccount account,
UUID session, UUID secureSession,
uint circuitCode, Vector3 position,
IPEndPoint clientIP, AgentCircuitData aCircuit, List<UUID> friendsToInform,
out string seedCap, out string reason, out GridRegion destination)
{
LoginAgentArgs args = null;
foreach (GridRegion r in regions)
{
if (r == null)
continue;
MainConsole.Instance.DebugFormat("[LoginService]: Attempting to log {0} into {1} at {2}...", account.Name, r.RegionName, r.ServerURI);
args = m_registry.RequestModuleInterface<IAgentProcessing>().
LoginAgent(r, aCircuit, friendsToInform);
if (args.Success)
{
aCircuit = MakeAgent(r, account, session, secureSession, circuitCode, position, clientIP);
destination = r;
reason = args.Reason;
seedCap = args.SeedCap;
return true;
}
m_GridService.SetRegionUnsafe(r.RegionID);
}
if (args != null)
{
seedCap = args.SeedCap;
reason = args.Reason;
}
else
{
seedCap = "";
reason = "";
}
destination = null;
return false;
}
protected AgentCircuitData LaunchAgentAtGrid(GridRegion destination, TeleportFlags tpFlags, UserAccount account,
UUID session, UUID secureSession, Vector3 position,
string currentWhere,
IPEndPoint clientIP, List<UUID> friendsToInform, out string where, out string reason,
out string seedCap, out GridRegion dest)
{
where = currentWhere;
reason = string.Empty;
uint circuitCode = 0;
AgentCircuitData aCircuit = null;
dest = destination;
#region Launch Agent
circuitCode = (uint) Util.RandomClass.Next();
aCircuit = MakeAgent(destination, account, session, secureSession, circuitCode, position,
clientIP);
aCircuit.TeleportFlags = (uint) tpFlags;
MainConsole.Instance.DebugFormat("[LoginService]: Attempting to log {0} into {1} at {2}...", account.Name, destination.RegionName, destination.ServerURI);
LoginAgentArgs args = m_registry.RequestModuleInterface<IAgentProcessing>().
LoginAgent(destination, aCircuit, friendsToInform);
aCircuit.CachedUserInfo = args.CircuitData.CachedUserInfo;
aCircuit.RegionUDPPort = args.CircuitData.RegionUDPPort;
reason = args.Reason;
reason = "";
seedCap = args.SeedCap;
bool success = args.Success;
if (!success && m_GridService != null)
{
MainConsole.Instance.DebugFormat("[LoginService]: Failed to log {0} into {1} at {2}...", account.Name, destination.RegionName, destination.ServerURI);
//Remove the landmark flag (landmark is used for ignoring the landing points in the region)
aCircuit.TeleportFlags &= ~(uint) TeleportFlags.ViaLandmark;
m_GridService.SetRegionUnsafe(destination.RegionID);
// Make sure the client knows this isn't where they wanted to land
where = "safe";
// Try the default regions
List<GridRegion> defaultRegions = m_GridService.GetDefaultRegions(account.AllScopeIDs);
if (defaultRegions != null)
{
success = TryFindGridRegionForAgentLogin(defaultRegions, account,
session, secureSession, circuitCode, position,
clientIP, aCircuit, friendsToInform,
out seedCap, out reason, out dest);
}
if (!success)
{
// Try the fallback regions
List<GridRegion> fallbacks = m_GridService.GetFallbackRegions(account.AllScopeIDs,
destination.RegionLocX,
destination.RegionLocY);
if (fallbacks != null)
{
success = TryFindGridRegionForAgentLogin(fallbacks, account,
session, secureSession, circuitCode,
position,
clientIP, aCircuit, friendsToInform,
out seedCap, out reason, out dest);
}
if (!success)
{
//Try to find any safe region
List<GridRegion> safeRegions = m_GridService.GetSafeRegions(account.AllScopeIDs,
destination.RegionLocX,
destination.RegionLocY);
if (safeRegions != null)
{
success = TryFindGridRegionForAgentLogin(safeRegions, account,
session, secureSession, circuitCode,
position, clientIP, aCircuit, friendsToInform,
out seedCap, out reason, out dest);
if (!success)
reason = "No Region Found";
}
}
}
}
#endregion
if (success)
{
MainConsole.Instance.DebugFormat("[LoginService]: Successfully logged {0} into {1} at {2}...", account.Name, destination.RegionName, destination.ServerURI);
//Set the region to safe since we got there
m_GridService.SetRegionSafe(destination.RegionID);
return aCircuit;
}
return null;
}
/// <summary>
/// Move the given scene object into a new region
/// </summary>
/// <param name="destination"></param>
/// <param name="grp">Scene Object Group that we're crossing</param>
/// <param name="attemptedPos"></param>
/// <returns>
/// true if the crossing itself was successful, false on failure
/// </returns>
protected bool CrossPrimGroupIntoNewRegion(GridRegion destination, ISceneEntity grp, Vector3 attemptedPos)
{
bool successYN = false;
if (destination != null)
{
if (grp.SitTargetAvatar.Count != 0)
{
foreach (UUID avID in grp.SitTargetAvatar)
{
IScenePresence SP = grp.Scene.GetScenePresence(avID);
SP.Velocity = grp.RootChild.PhysActor.Velocity;
InternalCross(SP, attemptedPos, false, destination);
}
foreach (ISceneChildEntity part in grp.ChildrenEntities())
part.SitTargetAvatar = new List<UUID>();
IBackupModule backup = grp.Scene.RequestModuleInterface<IBackupModule>();
if (backup != null)
return backup.DeleteSceneObjects(new[] {grp}, false, false);
return true; //They do all the work adding the prim in the other region
}
ISceneEntity copiedGroup = grp.Copy(false);
copiedGroup.SetAbsolutePosition(true, attemptedPos);
if (grp.Scene != null)
successYN = grp.Scene.RequestModuleInterface<ISimulationService>()
.CreateObject(destination, copiedGroup);
if (successYN)
{
// We remove the object here
try
{
IBackupModule backup = grp.Scene.RequestModuleInterface<IBackupModule>();
if (backup != null)
return backup.DeleteSceneObjects(new[] {grp}, false, true);
}
catch (Exception e)
{
MainConsole.Instance.ErrorFormat(
"[ENTITY TRANSFER MODULE]: Exception deleting the old object left behind on a border crossing for {0}, {1}",
grp, e);
}
}
else
{
if (!grp.IsDeleted)
{
if (grp.RootChild.PhysActor != null)
{
grp.RootChild.PhysActor.CrossingFailure();
}
}
MainConsole.Instance.ErrorFormat("[ENTITY TRANSFER MODULE]: Prim crossing failed for {0}", grp);
}
}
else
{
MainConsole.Instance.Error(
"[ENTITY TRANSFER MODULE]: destination was unexpectedly null in Scene.CrossPrimGroupIntoNewRegion()");
}
return successYN;
}
public virtual void Teleport(IScenePresence sp, GridRegion finalDestination, Vector3 position, Vector3 lookAt,
uint teleportFlags)
{
sp.ControllingClient.SendTeleportStart(teleportFlags);
sp.ControllingClient.SendTeleportProgress(teleportFlags, "requesting");
// Reset animations; the viewer does that in teleports.
if (sp.Animator != null)
sp.Animator.ResetAnimations();
try
{
string reason = "";
if (finalDestination.RegionHandle == sp.Scene.RegionInfo.RegionHandle)
{
//First check whether the user is allowed to move at all
if (!sp.Scene.Permissions.AllowedOutgoingLocalTeleport(sp.UUID, out reason))
{
sp.ControllingClient.SendTeleportFailed(reason);
return;
}
//Now respect things like parcel bans with this
if (
!sp.Scene.Permissions.AllowedIncomingTeleport(sp.UUID, position, teleportFlags, out position,
out reason))
{
sp.ControllingClient.SendTeleportFailed(reason);
return;
}
MainConsole.Instance.DebugFormat(
"[ENTITY TRANSFER MODULE]: RequestTeleportToLocation {0} within {1}",
position, sp.Scene.RegionInfo.RegionName);
sp.ControllingClient.SendLocalTeleport(position, lookAt, teleportFlags);
sp.RequestModuleInterface<IScriptControllerModule>()
.HandleForceReleaseControls(sp.ControllingClient, sp.UUID);
sp.Teleport(position);
}
else // Another region possibly in another simulator
{
// Make sure the user is allowed to leave this region
if (!sp.Scene.Permissions.AllowedOutgoingRemoteTeleport(sp.UUID, out reason))
{
sp.ControllingClient.SendTeleportFailed(reason);
return;
}
DoTeleport(sp, finalDestination, position, lookAt, teleportFlags);
}
}
catch (Exception e)
{
MainConsole.Instance.ErrorFormat("[ENTITY TRANSFER MODULE]: Exception on teleport: {0}\n{1}", e.Message,
e.StackTrace);
sp.ControllingClient.SendTeleportFailed("Internal error");
}
}
/// <summary>
/// Verify if the user can connect to this region. Checks the banlist and ensures that the region is set for public access
/// </summary>
/// <param name="scene"></param>
/// <param name="agent">The circuit data for the agent</param>
/// <param name="reason">outputs the reason to this string</param>
/// <returns>
/// True if the region accepts this agent. False if it does not. False will
/// also return a reason.
/// </returns>
protected bool AuthorizeUser(IScene scene, AgentCircuitData agent, out string reason)
{
reason = String.Empty;
IAuthorizationService AuthorizationService = scene.RequestModuleInterface<IAuthorizationService>();
if (AuthorizationService != null)
{
GridRegion ourRegion = new GridRegion(scene.RegionInfo);
if (!AuthorizationService.IsAuthorizedForRegion(ourRegion, agent, !agent.IsChildAgent, out reason))
{
MainConsole.Instance.WarnFormat(
"[ConnectionBegin]: Denied access to {0} at {1} because the user does not have access to the region, reason: {2}",
agent.AgentID, scene.RegionInfo.RegionName, reason);
reason = String.Format("You do not have access to the region {0}, reason: {1}",
scene.RegionInfo.RegionName, reason);
return false;
}
}
return true;
}
protected virtual OSDMap OnMessageReceived(OSDMap message)
{
if (!message.ContainsKey("Method"))
return null;
if (m_capsService == null)
return null;
string method = message["Method"].AsString();
if (method != "RegionIsOnline" && method != "LogoutRegionAgents" &&
method != "ArrivedAtDestination" && method != "CancelTeleport" &&
method != "AgentLoggedOut" && method != "SendChildAgentUpdate" &&
method != "TeleportAgent" && method != "CrossAgent")
return null;
UUID AgentID = message["AgentID"].AsUUID();
UUID requestingRegion = message["RequestingRegion"].AsUUID();
IClientCapsService clientCaps = m_capsService.GetClientCapsService(AgentID);
IRegionClientCapsService regionCaps = null;
if (clientCaps != null)
regionCaps = clientCaps.GetCapsService(requestingRegion);
if (message["Method"] == "LogoutRegionAgents")
{
LogOutAllAgentsForRegion(requestingRegion);
}
else if (message["Method"] == "RegionIsOnline")
//This gets fired when the scene is fully finished starting up
{
//Log out all the agents first, then add any child agents that should be in this region
//Don't do this, we don't need to kill all the clients right now
//LogOutAllAgentsForRegion(requestingRegion);
IGridService GridService = m_registry.RequestModuleInterface<IGridService>();
if (GridService != null)
{
GridRegion requestingGridRegion = GridService.GetRegionByUUID(null, requestingRegion);
if (requestingGridRegion != null)
Util.FireAndForget((o) => EnableChildAgentsForRegion(requestingGridRegion));
}
}
else if (message["Method"] == "ArrivedAtDestination")
{
if (regionCaps == null || clientCaps == null)
return null;
//Recieved a callback
if (clientCaps.InTeleport) //Only set this if we are in a teleport,
// otherwise (such as on login), this won't check after the first tp!
clientCaps.CallbackHasCome = true;
regionCaps.Disabled = false;
//The agent is getting here for the first time (eg. login)
OSDMap body = ((OSDMap) message["Message"]);
//Parse the OSDMap
int DrawDistance = body["DrawDistance"].AsInteger();
AgentCircuitData circuitData = new AgentCircuitData();
circuitData.FromOSD((OSDMap)body["Circuit"]);
//Now do the creation
EnableChildAgents(AgentID, requestingRegion, DrawDistance, circuitData);
}
else if (message["Method"] == "CancelTeleport")
{
if (regionCaps == null || clientCaps == null)
return null;
//Only the region the client is root in can do this
IRegionClientCapsService rootCaps = clientCaps.GetRootCapsService();
if (rootCaps != null && rootCaps.RegionHandle == regionCaps.RegionHandle)
{
//The user has requested to cancel the teleport, stop them.
clientCaps.RequestToCancelTeleport = true;
regionCaps.Disabled = false;
}
}
else if (message["Method"] == "AgentLoggedOut")
{
//ONLY if the agent is root do we even consider it
if (regionCaps != null && regionCaps.RootAgent)
{
OSDMap body = ((OSDMap) message["Message"]);
AgentPosition pos = new AgentPosition();
pos.FromOSD((OSDMap)body["AgentPos"]);
regionCaps.Disabled = true;
Util.FireAndForget((o) =>
{
LogoutAgent(regionCaps, false); //The root is killing itself
SendChildAgentUpdate(pos, regionCaps);
});
}
}
else if (message["Method"] == "SendChildAgentUpdate")
{
if (regionCaps == null || clientCaps == null)
return null;
IRegionClientCapsService rootCaps = clientCaps.GetRootCapsService();
if (rootCaps != null && rootCaps.RegionHandle == regionCaps.RegionHandle) //Has to be root
{
OSDMap body = ((OSDMap) message["Message"]);
AgentPosition pos = new AgentPosition();
pos.FromOSD((OSDMap) body["AgentPos"]);
SendChildAgentUpdate(pos, regionCaps);
regionCaps.Disabled = false;
}
}
else if (message["Method"] == "TeleportAgent")
{
if (regionCaps == null || clientCaps == null)
return null;
IRegionClientCapsService rootCaps = clientCaps.GetRootCapsService();
if (rootCaps != null && rootCaps.RegionHandle == regionCaps.RegionHandle)
{
OSDMap body = ((OSDMap) message["Message"]);
GridRegion destination = new GridRegion();
destination.FromOSD((OSDMap) body["Region"]);
uint TeleportFlags = body["TeleportFlags"].AsUInteger();
AgentCircuitData Circuit = new AgentCircuitData();
Circuit.FromOSD((OSDMap)body["Circuit"]);
AgentData AgentData = new AgentData();
AgentData.FromOSD((OSDMap)body["AgentData"]);
regionCaps.Disabled = false;
//Don't need to wait for this to finish on the main http thread
Util.FireAndForget((o) =>
{
string reason = "";
TeleportAgent(ref destination, TeleportFlags,
Circuit, AgentData, AgentID, requestingRegion, out reason);
});
return null;
}
}
else if (message["Method"] == "CrossAgent")
{
if (regionCaps == null || clientCaps == null)
return null;
IRegionClientCapsService rootCaps = clientCaps.GetRootCapsService();
if (rootCaps == null || rootCaps.RegionHandle == regionCaps.RegionHandle)
{
//This is a simulator message that tells us to cross the agent
OSDMap body = ((OSDMap) message["Message"]);
Vector3 pos = body["Pos"].AsVector3();
Vector3 Vel = body["Vel"].AsVector3();
GridRegion Region = new GridRegion();
Region.FromOSD((OSDMap) body["Region"]);
AgentCircuitData Circuit = new AgentCircuitData();
Circuit.FromOSD((OSDMap)body["Circuit"]);
AgentData AgentData = new AgentData();
AgentData.FromOSD((OSDMap)body["AgentData"]);
regionCaps.Disabled = false;
Util.FireAndForget((o) =>
{
string reason = "";
CrossAgent(Region, pos, Vel, Circuit, AgentData,
AgentID, requestingRegion, out reason);
});
return null;
}
else if (clientCaps.InTeleport)
{
OSDMap result = new OSDMap();
result["success"] = false;
result["Note"] = false;
return result;
}
else
{
OSDMap result = new OSDMap();
result["success"] = false;
result["Note"] = false;
return result;
}
}
return null;
}
private void EventManager_OnMakeChildAgent(IScenePresence presence, GridRegion destination)
{
m_authorizedParticipants.Remove(presence.UUID);
m_userLogLevel.Remove(presence.UUID);
}
public void TriggerOnRegionUp(GridRegion otherRegion)
{
RegionUp handlerOnRegionUp = OnRegionUp;
if (handlerOnRegionUp != null)
{
foreach (RegionUp d in handlerOnRegionUp.GetInvocationList())
{
try
{
d(otherRegion);
}
catch (Exception e)
{
MainConsole.Instance.ErrorFormat(
"[EVENT MANAGER]: Delegate for TriggerOnRegionUp failed - continuing. {0} {1}",
e, e.StackTrace);
}
}
}
}
protected AgentCircuitData MakeAgent(GridRegion region, UserAccount account,
UUID session, UUID secureSession, uint circuit,
Vector3 position, IPEndPoint clientIP)
{
return new AgentCircuitData
{
AgentID = account.PrincipalID,
IsChildAgent = false,
CircuitCode = circuit,
SecureSessionID = secureSession,
SessionID = session,
StartingPosition = position,
IPAddress = clientIP.Address.ToString()
};
}
public void TriggerOnSetAgentLeaving(IScenePresence presence, GridRegion destination)
{
OnMakeChildAgentDelegate handlerMakeChildAgent = OnSetAgentLeaving;
if (handlerMakeChildAgent != null)
{
foreach (OnMakeChildAgentDelegate d in handlerMakeChildAgent.GetInvocationList())
{
try
{
d(presence, destination);
}
catch (Exception e)
{
MainConsole.Instance.ErrorFormat(
"[EVENT MANAGER]: Delegate for TriggerOnSetAgentLeaving failed - continuing. {0} {1}",
e, e.StackTrace);
}
}
}
}
protected GridRegion FindDestination(UserAccount account, UserInfo pinfo, UUID sessionID, string startLocation,
GridRegion home, out TeleportFlags tpFlags, out string where,
out Vector3 position, out Vector3 lookAt)
{
where = "home";
position = new Vector3(128, 128, 25);
lookAt = new Vector3(0, 1, 0);
tpFlags = TeleportFlags.ViaLogin;
if (m_GridService == null)
return null;
if (startLocation.Equals("home"))
{
tpFlags |= TeleportFlags.ViaLandmark;
// logging into home region
if (pinfo == null)
return null;
GridRegion region = null;
bool tryDefaults = false;
if (home == null)
{
MainConsole.Instance.WarnFormat(
"[LLOGIN SERVICE]: User {0} {1} tried to login to a 'home' start location but they have none set",
account.FirstName, account.LastName);
tryDefaults = true;
}
else
{
region = home;
position = pinfo.HomePosition;
lookAt = pinfo.HomeLookAt;
}
if (tryDefaults)
{
tpFlags &= ~TeleportFlags.ViaLandmark;
List<GridRegion> defaults = m_GridService.GetDefaultRegions(account.AllScopeIDs);
if (defaults != null && defaults.Count > 0)
{
region = defaults[0];
where = "safe";
}
else
{
List<GridRegion> fallbacks = m_GridService.GetFallbackRegions(account.AllScopeIDs, 0, 0);
if (fallbacks != null && fallbacks.Count > 0)
{
region = fallbacks[0];
where = "safe";
}
else
{
//Try to find any safe region
List<GridRegion> safeRegions = m_GridService.GetSafeRegions(account.AllScopeIDs, 0, 0);
if (safeRegions != null && safeRegions.Count > 0)
{
region = safeRegions[0];
where = "safe";
}
else
{
MainConsole.Instance.WarnFormat(
"[LLOGIN SERVICE]: User {0} {1} does not have a valid home and this grid does not have default locations. Attempting to find random region",
account.FirstName, account.LastName);
defaults = m_GridService.GetRegionsByName(account.AllScopeIDs, "", 0, 1);
if (defaults != null && defaults.Count > 0)
{
region = defaults[0];
where = "safe";
}
}
}
}
}
return region;
}
if (startLocation.Equals("last"))
{
tpFlags |= TeleportFlags.ViaLandmark;
// logging into last visited region
where = "last";
if (pinfo == null)
return null;
GridRegion region = null;
if (pinfo.CurrentRegionID.Equals(UUID.Zero) ||
(region = m_GridService.GetRegionByUUID(account.AllScopeIDs, pinfo.CurrentRegionID)) == null)
{
tpFlags &= ~TeleportFlags.ViaLandmark;
List<GridRegion> defaults = m_GridService.GetDefaultRegions(account.AllScopeIDs);
if (defaults != null && defaults.Count > 0)
{
region = defaults[0];
where = "safe";
}
else
{
defaults = m_GridService.GetFallbackRegions(account.AllScopeIDs, 0, 0);
if (defaults != null && defaults.Count > 0)
{
region = defaults[0];
where = "safe";
}
else
{
defaults = m_GridService.GetSafeRegions(account.AllScopeIDs, 0, 0);
if (defaults != null && defaults.Count > 0)
{
region = defaults[0];
where = "safe";
}
}
}
}
else
{
position = pinfo.CurrentPosition;
if (position.X < 0)
position.X = 0;
if (position.Y < 0)
position.Y = 0;
if (position.Z < 0)
position.Z = 0;
if (position.X > region.RegionSizeX)
position.X = region.RegionSizeX;
if (position.Y > region.RegionSizeY)
position.Y = region.RegionSizeY;
lookAt = pinfo.CurrentLookAt;
}
return region;
}
else
{
// free uri form
// e.g. New Moon&135&46 New [email protected]:8002&153&34
where = "url";
Regex reURI = new Regex(@"^uri:(?<region>[^&]+)&(?<x>\d+)&(?<y>\d+)&(?<z>\d+)$");
Match uriMatch = reURI.Match(startLocation);
position = new Vector3(float.Parse(uriMatch.Groups["x"].Value, Culture.NumberFormatInfo),
float.Parse(uriMatch.Groups["y"].Value, Culture.NumberFormatInfo),
float.Parse(uriMatch.Groups["z"].Value, Culture.NumberFormatInfo));
string regionName = uriMatch.Groups["region"].ToString();
if (!regionName.Contains("@"))
{
List<GridRegion> regions = m_GridService.GetRegionsByName(account.AllScopeIDs, regionName, 0, 1);
if ((regions == null) || (regions.Count == 0))
{
MainConsole.Instance.InfoFormat(
"[LLLOGIN SERVICE]: Got Custom Login URI {0}, can't locate region {1}. Trying defaults.",
startLocation, regionName);
regions = m_GridService.GetDefaultRegions(account.AllScopeIDs);
if (regions != null && regions.Count > 0)
{
where = "safe";
return regions[0];
}
List<GridRegion> fallbacks = m_GridService.GetFallbackRegions(account.AllScopeIDs, 0, 0);
if (fallbacks != null && fallbacks.Count > 0)
{
where = "safe";
return fallbacks[0];
}
//Try to find any safe region
List<GridRegion> safeRegions = m_GridService.GetSafeRegions(account.AllScopeIDs, 0, 0);
if (safeRegions != null && safeRegions.Count > 0)
{
where = "safe";
return safeRegions[0];
}
MainConsole.Instance.InfoFormat(
"[LLLOGIN SERVICE]: Got Custom Login URI {0}, Grid does not have any available regions.",
startLocation);
return null;
}
return regions[0];
}
//This is so that you can login to other grids via IWC (or HG), example"[email protected]:8002". All this really needs to do is inform the other grid that we have a user who wants to connect. IWC allows users to login by default to other regions (without the host names), but if one is provided and we don't have a link, we need to create one here.
string[] parts = regionName.Split(new char[] {'@'});
if (parts.Length < 2)
{
MainConsole.Instance.InfoFormat(
"[LLLOGIN SERVICE]: Got Custom Login URI {0}, can't locate region {1}",
startLocation, regionName);
return null;
}
// Valid specification of a remote grid
regionName = parts[0];
//Try now that we removed the domain locator
GridRegion region = m_GridService.GetRegionByName(account.AllScopeIDs, regionName);
if (region != null && region.RegionName == regionName)
//Make sure the region name is right too... it could just be a similar name
return region;
List<GridRegion> defaults = m_GridService.GetDefaultRegions(account.AllScopeIDs);
if (defaults != null && defaults.Count > 0)
{
where = "safe";
return defaults[0];
}
else
{
List<GridRegion> fallbacks = m_GridService.GetFallbackRegions(account.AllScopeIDs, 0, 0);
if (fallbacks != null && fallbacks.Count > 0)
{
where = "safe";
return fallbacks[0];
}
else
{
//Try to find any safe region
List<GridRegion> safeRegions = m_GridService.GetSafeRegions(account.AllScopeIDs, 0, 0);
if (safeRegions != null && safeRegions.Count > 0)
{
where = "safe";
return safeRegions[0];
}
MainConsole.Instance.InfoFormat(
"[LLLOGIN SERVICE]: Got Custom Login URI {0}, Grid does not have any available regions.",
startLocation);
return null;
}
}
}
}
/// <summary>
/// Register this region with the grid service
/// </summary>
/// <param name="scene"></param>
/// <param name="returnResponseFirstTime">Should we try to walk the user through what went wrong?</param>
/// <param name="continueTrying"> </param>
/// <param name="password"> </param>
public bool RegisterRegionWithGrid(IScene scene, bool returnResponseFirstTime, bool continueTrying,
string password)
{
if (password == null)
password = m_RegisterRegionPassword;
GridRegion region = new GridRegion (scene.RegionInfo);
IGridService GridService = scene.RequestModuleInterface<IGridService> ();
scene.RequestModuleInterface<ISimulationBase> ()
.EventManager.FireGenericEventHandler ("PreRegisterRegion", region);
//Tell the grid service about us
RegisterRegion error = GridService.RegisterRegion (region, scene.RegionInfo.GridSecureSessionID, password,
ProtocolVersion.MAJOR_PROTOCOL_VERSION,
ProtocolVersion.MINOR_PROTOCOL_VERSION);
if (error.Error == String.Empty)
{
//If it registered ok, we save the sessionID to the database and tell the neighbor service about it
scene.RegionInfo.GridSecureSessionID = error.SessionID;
//Update our local copy of what our region flags are
scene.RegionInfo.RegionFlags = error.RegionFlags;
scene.RegionInfo.ScopeID = error.Region.ScopeID;
scene.RegionInfo.AllScopeIDs = error.Region.AllScopeIDs;
scene.RequestModuleInterface<IConfigurationService> ().SetURIs (error.URIs);
m_knownNeighbors [scene.RegionInfo.RegionID] = error.Neighbors;
return true; //Success
}
if (returnResponseFirstTime && !continueTrying)
{
MainConsole.Instance.Error (
"[RegisterRegionWithGrid]: Registration of region with grid failed again - " + error.Error);
return false;
}
//Parse the error and try to do something about it if at all possible
if (error.Error == "Region location is reserved")
{
MainConsole.Instance.Error (
"[RegisterRegionWithGrid]: Registration of region with grid failed - The region location you specified is reserved. You must move your region.");
int X;
int Y;
int.TryParse (MainConsole.Instance.Prompt ("New Region Location X", "1000"), out X);
int.TryParse (MainConsole.Instance.Prompt ("New Region Location Y", "1000"), out Y);
scene.RegionInfo.RegionLocX = X * Constants.RegionSize;
scene.RegionInfo.RegionLocY = Y * Constants.RegionSize;
} else if (error.Error == "Region overlaps another region")
{
MainConsole.Instance.Error ("[RegisterRegionWithGrid]: Registration of region " +
scene.RegionInfo.RegionName +
" with the grid failed - The region location you specified is already in use. You must move your region.");
int X;
int Y;
int.TryParse (
MainConsole.Instance.Prompt ("New Region Location X",
(scene.RegionInfo.RegionLocX / Constants.RegionSize).ToString ()), out X);
int.TryParse (
MainConsole.Instance.Prompt ("New Region Location Y",
(scene.RegionInfo.RegionLocY / Constants.RegionSize).ToString ()), out Y);
scene.RegionInfo.RegionLocX = X * Constants.RegionSize;
scene.RegionInfo.RegionLocY = Y * Constants.RegionSize;
} else if (error.Error.Contains ("Can't move this region"))
{
MainConsole.Instance.Error ("[RegisterRegionWithGrid]: Registration of region " +
scene.RegionInfo.RegionName +
" with the grid failed - You can not move this region. Moving it back to its original position.");
//Opensim Grid Servers don't have this functionality.
try
{
string[] position = error.Error.Split (',');
scene.RegionInfo.RegionLocX = int.Parse (position [1]) * Constants.RegionSize;
scene.RegionInfo.RegionLocY = int.Parse (position [2]) * Constants.RegionSize;
} catch (Exception)
{
MainConsole.Instance.Error ("Unable to move the region back to its original position, is this an Opensim server? Please manually move the region back.");
throw;
}
} else if (error.Error == "Duplicate region name")
{
MainConsole.Instance.Error ("[RegisterRegionWithGrid]: Registration of region " +
scene.RegionInfo.RegionName +
" with the grid failed - The region name you specified is already in use. Please change the name.");
scene.RegionInfo.RegionName = MainConsole.Instance.Prompt ("New Region Name", "");
} else if (error.Error == "Region locked out")
{
MainConsole.Instance.Error ("[RegisterRegionWithGrid]: Registration of region " +
scene.RegionInfo.RegionName +
" with the grid the failed - The region you are attempting to join has been blocked from connecting. Please connect another region.");
MainConsole.Instance.Prompt ("Press enter when you are ready to exit");
Environment.Exit (0);
} else if (error.Error == "Could not reach grid service")
{
MainConsole.Instance.Error ("[RegisterRegionWithGrid]: Registration of region " +
scene.RegionInfo.RegionName +
" with the grid failed - The grid service can not be found! Please make sure that you can connect to the grid server and that the grid server is on.");
MainConsole.Instance.Error (
"You should also make sure you've provided the correct address and port of the grid service.");
string input =
MainConsole.Instance.Prompt (
"Press enter when you are ready to proceed, or type cancel to exit");
if (input == "cancel")
{
Environment.Exit (0);
}
} else if (error.Error == "Wrong Session ID")
{
MainConsole.Instance.Error ("[RegisterRegionWithGrid]: Registration of region " +
scene.RegionInfo.RegionName +
" with the grid failed - Wrong Session ID for this region!");
MainConsole.Instance.Error (
"This means that this region has failed to connect to the grid server and needs removed from it before it can connect again.");
MainConsole.Instance.Error (
"If you are running the WhiteCore.Server instance this region is connecting to, type \"grid clear region <RegionName>\" and then press enter on this console and it will work");
MainConsole.Instance.Error (
"If you are not running the WhiteCore.Server instance this region is connecting to, please contact your grid operator so that he can fix it");
string input =
MainConsole.Instance.Prompt (
"Press enter when you are ready to proceed, or type cancel to exit");
if (input == "cancel")
Environment.Exit (0);
} else if (error.Error == "Grid is not fully ready yet, please try again shortly")
{
MainConsole.Instance.Error ("[RegisterRegionWithGrid]: Registration of region " +
scene.RegionInfo.RegionName +
" with the grid failed - " + error.Error + ", retrying... ");
System.Threading.Thread.Sleep (3000); //Sleep for a bit and try again
} else
{
MainConsole.Instance.Error ("[RegisterRegionWithGrid]: Registration of region " +
scene.RegionInfo.RegionName +
" with the grid failed - " + error.Error + "!");
string input =
MainConsole.Instance.Prompt (
"Press enter when you are ready to proceed, or type cancel to exit");
if (input == "cancel")
Environment.Exit (0);
}
return RegisterRegionWithGrid (scene, true, continueTrying, password);
}
