OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update svn properties.

0.6.1-post-fixes
Jeff Ames 2008-11-25 16:00:55 +00:00
parent fbf90b1ece
commit 518a8b9f2a
19 changed files with 5506 additions and 5506 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
OpenSim/Framework/Communications/IHyperlink.cs
View File

@ -1,42 +1,42 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Text; using System.Text;
using OpenSim.Framework; using OpenSim.Framework;
namespace OpenSim.Framework.Communications namespace OpenSim.Framework.Communications
{ {
public interface IHyperlink public interface IHyperlink
{ {
bool IsHyperlinkRegion(ulong handle); bool IsHyperlinkRegion(ulong handle);
RegionInfo GetHyperlinkRegion(ulong handle); RegionInfo GetHyperlinkRegion(ulong handle);
ulong FindRegionHandle(ulong handle); ulong FindRegionHandle(ulong handle);
} }
} }

160
OpenSim/Framework/ForeignUserProfileData.cs
View File

@ -1,80 +1,80 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System; using System;
using OpenSim.Framework; using OpenSim.Framework;
namespace OpenSim.Framework namespace OpenSim.Framework
{ {
public class ForeignUserProfileData : UserProfileData public class ForeignUserProfileData : UserProfileData
{ {
/// <summary> /// <summary>
/// The address of the users home sim, used for foreigners. /// The address of the users home sim, used for foreigners.
/// </summary> /// </summary>
private string _userUserServerURI = String.Empty; private string _userUserServerURI = String.Empty;
/// <summary> /// <summary>
/// The address of the users home sim, used for foreigners. /// The address of the users home sim, used for foreigners.
/// </summary> /// </summary>
private string _userHomeAddress = String.Empty; private string _userHomeAddress = String.Empty;
/// <summary> /// <summary>
/// The port of the users home sim, used for foreigners. /// The port of the users home sim, used for foreigners.
/// </summary> /// </summary>
private string _userHomePort = String.Empty; private string _userHomePort = String.Empty;
/// <summary> /// <summary>
/// The remoting port of the users home sim, used for foreigners. /// The remoting port of the users home sim, used for foreigners.
/// </summary> /// </summary>
private string _userHomeRemotingPort = String.Empty; private string _userHomeRemotingPort = String.Empty;
public string UserServerURI public string UserServerURI
{ {
get { return _userUserServerURI; } get { return _userUserServerURI; }
set { _userUserServerURI = value; } set { _userUserServerURI = value; }
} }
public string UserHomeAddress public string UserHomeAddress
{ {
get { return _userHomeAddress; } get { return _userHomeAddress; }
set { _userHomeAddress = value; } set { _userHomeAddress = value; }
} }
public string UserHomePort public string UserHomePort
{ {
get { return _userHomePort; } get { return _userHomePort; }
set { _userHomePort = value; } set { _userHomePort = value; }
} }
public string UserHomeRemotingPort public string UserHomeRemotingPort
{ {
get { return _userHomeRemotingPort; } get { return _userHomeRemotingPort; }
set { _userHomeRemotingPort = value; } set { _userHomeRemotingPort = value; }
} }
} }
} }

180
OpenSim/Framework/HGNetworkServersInfo.cs
View File

@ -1,90 +1,90 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Net; using System.Net;
using OpenSim.Framework; using OpenSim.Framework;
namespace OpenSim.Framework namespace OpenSim.Framework
{ {
public class HGNetworkServersInfo public class HGNetworkServersInfo
{ {
public readonly string LocalAssetServerURI, LocalInventoryServerURI, LocalUserServerURI; public readonly string LocalAssetServerURI, LocalInventoryServerURI, LocalUserServerURI;
private static HGNetworkServersInfo m_singleton; private static HGNetworkServersInfo m_singleton;
public static HGNetworkServersInfo Singleton public static HGNetworkServersInfo Singleton
{ {
get { return m_singleton; } get { return m_singleton; }
} }
public static void Init(string assetserver, string inventoryserver, string userserver) public static void Init(string assetserver, string inventoryserver, string userserver)
{ {
m_singleton = new HGNetworkServersInfo(assetserver, inventoryserver, userserver); m_singleton = new HGNetworkServersInfo(assetserver, inventoryserver, userserver);
} }
private HGNetworkServersInfo(string a, string i, string u) private HGNetworkServersInfo(string a, string i, string u)
{ {
LocalAssetServerURI = ServerURI(a); LocalAssetServerURI = ServerURI(a);
LocalInventoryServerURI = ServerURI(i); LocalInventoryServerURI = ServerURI(i);
LocalUserServerURI = ServerURI(u); LocalUserServerURI = ServerURI(u);
} }
public bool IsLocalUser(string userserver) public bool IsLocalUser(string userserver)
{ {
string userServerURI = ServerURI(userserver); string userServerURI = ServerURI(userserver);
bool ret = (((userServerURI == null) || (userServerURI == "") || (userServerURI == LocalUserServerURI))); bool ret = (((userServerURI == null) || (userServerURI == "") || (userServerURI == LocalUserServerURI)));
//Console.WriteLine("-------------> HGNetworkServersInfo.IsLocalUser? " + ret + "(userServer=" + userServerURI + "; localuserserver=" + LocalUserServerURI + ")"); //Console.WriteLine("-------------> HGNetworkServersInfo.IsLocalUser? " + ret + "(userServer=" + userServerURI + "; localuserserver=" + LocalUserServerURI + ")");
return ret; return ret;
} }
public static string ServerURI(string uri) public static string ServerURI(string uri)
{ {
IPAddress ipaddr1 = null; IPAddress ipaddr1 = null;
string port1 = ""; string port1 = "";
try try
{ {
ipaddr1 = Util.GetHostFromURL(uri); ipaddr1 = Util.GetHostFromURL(uri);
} }
catch { } catch { }
try try
{ {
port1 = uri.Split(new char[] { ':' })[2]; port1 = uri.Split(new char[] { ':' })[2];
} }
catch { } catch { }
// We tried our best to convert the domain names to IP addresses // We tried our best to convert the domain names to IP addresses
return (ipaddr1 != null) ? "http://" + ipaddr1.ToString() + ":" + port1 : uri; return (ipaddr1 != null) ? "http://" + ipaddr1.ToString() + ":" + port1 : uri;
} }
} }
} }

368
OpenSim/Region/Application/HGOpenSimNode.cs
View File

@ -1,184 +1,184 @@
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Net; using System.Net;
using System.Reflection; using System.Reflection;
using log4net; using log4net;
using Nini.Config; using Nini.Config;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Console; using OpenSim.Framework.Console;
using OpenSim.Framework.Servers; using OpenSim.Framework.Servers;
using OpenSim.Framework.Statistics; using OpenSim.Framework.Statistics;
using OpenSim.Region.ClientStack; using OpenSim.Region.ClientStack;
using OpenSim.Framework.Communications; using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Communications.Local; using OpenSim.Region.Communications.Local;
using OpenSim.Region.Communications.Hypergrid; using OpenSim.Region.Communications.Hypergrid;
using OpenSim.Region.Environment; using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces; using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Environment.Scenes.Hypergrid; using OpenSim.Region.Environment.Scenes.Hypergrid;
using Timer = System.Timers.Timer; using Timer = System.Timers.Timer;
namespace OpenSim namespace OpenSim
{ {
public class HGOpenSimNode : OpenSim public class HGOpenSimNode : OpenSim
{ {
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private IHyperlink HGServices = null; private IHyperlink HGServices = null;
public HGOpenSimNode(IConfigSource configSource) : base(configSource) public HGOpenSimNode(IConfigSource configSource) : base(configSource)
{ {
} }
/// <summary> /// <summary>
/// Performs initialisation of the scene, such as loading configuration from disk. /// Performs initialisation of the scene, such as loading configuration from disk.
/// </summary> /// </summary>
protected override void StartupSpecific() protected override void StartupSpecific()
{ {
m_log.Info("===================================================================="); m_log.Info("====================================================================");
m_log.Info("=================== STARTING HYPERGRID NODE ========================"); m_log.Info("=================== STARTING HYPERGRID NODE ========================");
m_log.Info("===================================================================="); m_log.Info("====================================================================");
base.StartupSpecific(); base.StartupSpecific();
} }
protected override void InitialiseStandaloneServices(LibraryRootFolder libraryRootFolder) protected override void InitialiseStandaloneServices(LibraryRootFolder libraryRootFolder)
{ {
// Standalone mode // Standalone mode
HGInventoryService inventoryService = new HGInventoryService(m_networkServersInfo.InventoryURL, null, false); HGInventoryService inventoryService = new HGInventoryService(m_networkServersInfo.InventoryURL, null, false);
inventoryService.AddPlugin(m_configSettings.StandaloneInventoryPlugin, m_configSettings.StandaloneInventorySource); inventoryService.AddPlugin(m_configSettings.StandaloneInventoryPlugin, m_configSettings.StandaloneInventorySource);
LocalUserServices userService = LocalUserServices userService =
new LocalUserServices(m_networkServersInfo, m_networkServersInfo.DefaultHomeLocX, new LocalUserServices(m_networkServersInfo, m_networkServersInfo.DefaultHomeLocX,
m_networkServersInfo.DefaultHomeLocY, inventoryService); m_networkServersInfo.DefaultHomeLocY, inventoryService);
userService.AddPlugin(m_configSettings.StandaloneUserPlugin, m_configSettings.StandaloneUserSource); userService.AddPlugin(m_configSettings.StandaloneUserPlugin, m_configSettings.StandaloneUserSource);
//LocalBackEndServices backendService = new LocalBackEndServices(); //LocalBackEndServices backendService = new LocalBackEndServices();
HGGridServicesStandalone gridService = new HGGridServicesStandalone(m_networkServersInfo, m_httpServer, m_assetCache, m_sceneManager); HGGridServicesStandalone gridService = new HGGridServicesStandalone(m_networkServersInfo, m_httpServer, m_assetCache, m_sceneManager);
LocalLoginService loginService = LocalLoginService loginService =
new LocalLoginService( new LocalLoginService(
userService, m_configSettings.StandaloneWelcomeMessage, inventoryService, gridService.LocalBackend, m_networkServersInfo, userService, m_configSettings.StandaloneWelcomeMessage, inventoryService, gridService.LocalBackend, m_networkServersInfo,
m_configSettings.StandaloneAuthenticate, libraryRootFolder); m_configSettings.StandaloneAuthenticate, libraryRootFolder);
m_commsManager = new HGCommunicationsStandalone(m_networkServersInfo, m_httpServer, m_assetCache, m_commsManager = new HGCommunicationsStandalone(m_networkServersInfo, m_httpServer, m_assetCache,
userService, userService, inventoryService, gridService, gridService, userService, libraryRootFolder, m_configSettings.DumpAssetsToFile); userService, userService, inventoryService, gridService, gridService, userService, libraryRootFolder, m_configSettings.DumpAssetsToFile);
inventoryService.UserProfileCache = m_commsManager.UserProfileCacheService; inventoryService.UserProfileCache = m_commsManager.UserProfileCacheService;
HGServices = gridService; HGServices = gridService;
// set up XMLRPC handler for client's initial login request message // set up XMLRPC handler for client's initial login request message
m_httpServer.AddXmlRPCHandler("login_to_simulator", loginService.XmlRpcLoginMethod); m_httpServer.AddXmlRPCHandler("login_to_simulator", loginService.XmlRpcLoginMethod);
// provides the web form login // provides the web form login
m_httpServer.AddHTTPHandler("login", loginService.ProcessHTMLLogin); m_httpServer.AddHTTPHandler("login", loginService.ProcessHTMLLogin);
// Provides the LLSD login // Provides the LLSD login
m_httpServer.SetDefaultLLSDHandler(loginService.LLSDLoginMethod); m_httpServer.SetDefaultLLSDHandler(loginService.LLSDLoginMethod);
// provide grid info // provide grid info
// m_gridInfoService = new GridInfoService(m_config.Source.Configs["Startup"].GetString("inifile", Path.Combine(Util.configDir(), "OpenSim.ini"))); // m_gridInfoService = new GridInfoService(m_config.Source.Configs["Startup"].GetString("inifile", Path.Combine(Util.configDir(), "OpenSim.ini")));
m_gridInfoService = new GridInfoService(m_config.Source); m_gridInfoService = new GridInfoService(m_config.Source);
m_httpServer.AddXmlRPCHandler("get_grid_info", m_gridInfoService.XmlRpcGridInfoMethod); m_httpServer.AddXmlRPCHandler("get_grid_info", m_gridInfoService.XmlRpcGridInfoMethod);
m_httpServer.AddStreamHandler(new RestStreamHandler("GET", "/get_grid_info", m_gridInfoService.RestGetGridInfoMethod)); m_httpServer.AddStreamHandler(new RestStreamHandler("GET", "/get_grid_info", m_gridInfoService.RestGetGridInfoMethod));
} }
protected override void InitialiseGridServices(LibraryRootFolder libraryRootFolder) protected override void InitialiseGridServices(LibraryRootFolder libraryRootFolder)
{ {
m_commsManager = new HGCommunicationsGridMode(m_networkServersInfo, m_httpServer, m_assetCache, m_sceneManager, libraryRootFolder); m_commsManager = new HGCommunicationsGridMode(m_networkServersInfo, m_httpServer, m_assetCache, m_sceneManager, libraryRootFolder);
HGServices = ((HGCommunicationsGridMode)m_commsManager).HGServices; HGServices = ((HGCommunicationsGridMode)m_commsManager).HGServices;
m_httpServer.AddStreamHandler(new SimStatusHandler()); m_httpServer.AddStreamHandler(new SimStatusHandler());
} }
protected override Scene CreateScene(RegionInfo regionInfo, StorageManager storageManager, protected override Scene CreateScene(RegionInfo regionInfo, StorageManager storageManager,
AgentCircuitManager circuitManager) AgentCircuitManager circuitManager)
{ {
HGSceneCommunicationService sceneGridService = new HGSceneCommunicationService(m_commsManager, HGServices); HGSceneCommunicationService sceneGridService = new HGSceneCommunicationService(m_commsManager, HGServices);
return return
new HGScene(regionInfo, circuitManager, m_commsManager, sceneGridService, m_assetCache, new HGScene(regionInfo, circuitManager, m_commsManager, sceneGridService, m_assetCache,
storageManager, m_httpServer, storageManager, m_httpServer,
m_moduleLoader, m_configSettings.DumpAssetsToFile, m_configSettings.PhysicalPrim, m_configSettings.See_into_region_from_neighbor, m_config.Source, m_moduleLoader, m_configSettings.DumpAssetsToFile, m_configSettings.PhysicalPrim, m_configSettings.See_into_region_from_neighbor, m_config.Source,
m_version); m_version);
} }
public override void RunCmd(string command, string[] cmdparams) public override void RunCmd(string command, string[] cmdparams)
{ {
if (command.Equals("link-region")) if (command.Equals("link-region"))
{ {
// link-region <Xloc> <Yloc> <HostName> <HttpPort> <LocalName> // link-region <Xloc> <Yloc> <HostName> <HttpPort> <LocalName>
if (cmdparams.Length < 4) if (cmdparams.Length < 4)
{ {
LinkRegionCmdUsage(); LinkRegionCmdUsage();
return; return;
} }
RegionInfo regInfo = new RegionInfo(); RegionInfo regInfo = new RegionInfo();
uint xloc, yloc; uint xloc, yloc;
uint externalPort; uint externalPort;
try try
{ {
xloc = Convert.ToUInt32(cmdparams[0]); xloc = Convert.ToUInt32(cmdparams[0]);
yloc = Convert.ToUInt32(cmdparams[1]); yloc = Convert.ToUInt32(cmdparams[1]);
externalPort = Convert.ToUInt32(cmdparams[3]); externalPort = Convert.ToUInt32(cmdparams[3]);
//internalPort = Convert.ToUInt32(cmdparams[4]); //internalPort = Convert.ToUInt32(cmdparams[4]);
//remotingPort = Convert.ToUInt32(cmdparams[5]); //remotingPort = Convert.ToUInt32(cmdparams[5]);
} }
catch (Exception e) catch (Exception e)
{ {
m_log.Warn("[HGrid] Wrong format for link-region command: " + e.Message); m_log.Warn("[HGrid] Wrong format for link-region command: " + e.Message);
LinkRegionCmdUsage(); LinkRegionCmdUsage();
return; return;
} }
regInfo.RegionLocX = xloc; regInfo.RegionLocX = xloc;
regInfo.RegionLocY = yloc; regInfo.RegionLocY = yloc;
regInfo.ExternalHostName = cmdparams[2]; regInfo.ExternalHostName = cmdparams[2];
regInfo.HttpPort = externalPort; regInfo.HttpPort = externalPort;
//regInfo.RemotingPort = remotingPort; //regInfo.RemotingPort = remotingPort;
try try
{ {
regInfo.InternalEndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), (int)0); regInfo.InternalEndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), (int)0);
} }
catch (Exception e) catch (Exception e)
{ {
m_log.Warn("[HGrid] Wrong format for link-region command: " + e.Message); m_log.Warn("[HGrid] Wrong format for link-region command: " + e.Message);
LinkRegionCmdUsage(); LinkRegionCmdUsage();
return; return;
} }
regInfo.RemotingAddress = regInfo.ExternalEndPoint.Address.ToString(); regInfo.RemotingAddress = regInfo.ExternalEndPoint.Address.ToString();
// Finally, link it // Finally, link it
try try
{ {
m_sceneManager.CurrentOrFirstScene.CommsManager.GridService.RegisterRegion(regInfo); m_sceneManager.CurrentOrFirstScene.CommsManager.GridService.RegisterRegion(regInfo);
} }
catch (Exception e) catch (Exception e)
{ {
m_log.Warn("[HGrid] Unable to link region: " + e.StackTrace); m_log.Warn("[HGrid] Unable to link region: " + e.StackTrace);
} }
if (cmdparams.Length >= 5) if (cmdparams.Length >= 5)
{ {
regInfo.RegionName = ""; regInfo.RegionName = "";
for (int i = 4; i < cmdparams.Length; i++) for (int i = 4; i < cmdparams.Length; i++)
regInfo.RegionName += cmdparams[i] + " "; regInfo.RegionName += cmdparams[i] + " ";
} }
} }
base.RunCmd(command, cmdparams); base.RunCmd(command, cmdparams);
} }
private void LinkRegionCmdUsage() private void LinkRegionCmdUsage()
{ {
Console.WriteLine("Usage: link-region <Xloc> <Yloc> <HostName> <HttpPort> [<LocalName>]"); Console.WriteLine("Usage: link-region <Xloc> <Yloc> <HostName> <HttpPort> [<LocalName>]");
} }
} }
} }

164
OpenSim/Region/Communications/Hypergrid/HGCommunicationsGridMode.cs
View File

@ -1,82 +1,82 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System.Reflection; using System.Reflection;
using log4net; using log4net;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications; using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Communications.OGS1; using OpenSim.Region.Communications.OGS1;
using OpenSim.Framework.Servers; using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Scenes;
namespace OpenSim.Region.Communications.Hypergrid namespace OpenSim.Region.Communications.Hypergrid
{ {
public class HGCommunicationsGridMode : CommunicationsManager // CommunicationsOGS1 public class HGCommunicationsGridMode : CommunicationsManager // CommunicationsOGS1
{ {
private static readonly ILog m_log private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
IHyperlink m_osw = null; IHyperlink m_osw = null;
public IHyperlink HGServices public IHyperlink HGServices
{ {
get { return m_osw; } get { return m_osw; }
} }
public HGCommunicationsGridMode( public HGCommunicationsGridMode(
NetworkServersInfo serversInfo, BaseHttpServer httpServer, NetworkServersInfo serversInfo, BaseHttpServer httpServer,
AssetCache assetCache, SceneManager sman, LibraryRootFolder libraryRootFolder) AssetCache assetCache, SceneManager sman, LibraryRootFolder libraryRootFolder)
: base(serversInfo, httpServer, assetCache, false, libraryRootFolder) : base(serversInfo, httpServer, assetCache, false, libraryRootFolder)
{ {
// From constructor at CommunicationsOGS1 // From constructor at CommunicationsOGS1
HGGridServices gridInterComms = new HGGridServicesGridMode(serversInfo, httpServer, assetCache, sman, m_userProfileCacheService); HGGridServices gridInterComms = new HGGridServicesGridMode(serversInfo, httpServer, assetCache, sman, m_userProfileCacheService);
m_gridService = gridInterComms; m_gridService = gridInterComms;
m_interRegion = gridInterComms; m_interRegion = gridInterComms;
m_osw = gridInterComms; m_osw = gridInterComms;
// The HG InventoryService always uses secure handlers // The HG InventoryService always uses secure handlers
HGInventoryService invService = new HGInventoryService(serversInfo.InventoryURL, this.m_userProfileCacheService, true); HGInventoryService invService = new HGInventoryService(serversInfo.InventoryURL, this.m_userProfileCacheService, true);
AddSecureInventoryService(invService); AddSecureInventoryService(invService);
m_defaultInventoryHost = invService.Host; m_defaultInventoryHost = invService.Host;
if (SecureInventoryService != null) if (SecureInventoryService != null)
m_log.Info("[HG] SecureInventoryService."); m_log.Info("[HG] SecureInventoryService.");
else else
m_log.Info("[HG] Non-secureInventoryService."); m_log.Info("[HG] Non-secureInventoryService.");
HGUserServices userServices = new HGUserServices(this); HGUserServices userServices = new HGUserServices(this);
m_userService = userServices; m_userService = userServices;
m_messageService = userServices; m_messageService = userServices;
m_avatarService = (IAvatarService)m_userService; m_avatarService = (IAvatarService)m_userService;
} }
} }
} }

118
OpenSim/Region/Communications/Hypergrid/HGCommunicationsStandalone.cs
View File

@ -1,59 +1,59 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications; using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Communications.Local; using OpenSim.Region.Communications.Local;
using OpenSim.Framework.Servers; using OpenSim.Framework.Servers;
namespace OpenSim.Region.Communications.Hypergrid namespace OpenSim.Region.Communications.Hypergrid
{ {
public class HGCommunicationsStandalone : CommunicationsLocal public class HGCommunicationsStandalone : CommunicationsLocal
{ {
public HGCommunicationsStandalone( public HGCommunicationsStandalone(
NetworkServersInfo serversInfo, NetworkServersInfo serversInfo,
BaseHttpServer httpServer, BaseHttpServer httpServer,
AssetCache assetCache, AssetCache assetCache,
IUserService userService, IUserService userService,
IUserServiceAdmin userServiceAdmin, IUserServiceAdmin userServiceAdmin,
LocalInventoryService inventoryService, LocalInventoryService inventoryService,
IInterRegionCommunications interRegionService, IInterRegionCommunications interRegionService,
HGGridServices gridService, IMessagingService messageService, LibraryRootFolder libraryRootFolder, bool dumpAssetsToFile) HGGridServices gridService, IMessagingService messageService, LibraryRootFolder libraryRootFolder, bool dumpAssetsToFile)
: base(serversInfo, httpServer, assetCache, userService, userServiceAdmin, inventoryService, interRegionService, gridService, messageService, libraryRootFolder, dumpAssetsToFile) : base(serversInfo, httpServer, assetCache, userService, userServiceAdmin, inventoryService, interRegionService, gridService, messageService, libraryRootFolder, dumpAssetsToFile)
{ {
gridService.UserProfileCache = m_userProfileCacheService; gridService.UserProfileCache = m_userProfileCacheService;
m_assetCache = assetCache; m_assetCache = assetCache;
// Let's swap to always be secure access to inventory // Let's swap to always be secure access to inventory
AddSecureInventoryService((ISecureInventoryService)inventoryService); AddSecureInventoryService((ISecureInventoryService)inventoryService);
m_inventoryServices = null; m_inventoryServices = null;
} }
} }
} }

2588
OpenSim/Region/Communications/Hypergrid/HGGridServices.cs
View File

File diff suppressed because it is too large Load Diff

570
OpenSim/Region/Communications/Hypergrid/HGGridServicesGridMode.cs
View File

@ -1,285 +1,285 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Reflection; using System.Reflection;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications; using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers; using OpenSim.Framework.Servers;
using OpenSim.Region.Communications.OGS1; using OpenSim.Region.Communications.OGS1;
using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Scenes;
using OpenMetaverse; using OpenMetaverse;
using log4net; using log4net;
namespace OpenSim.Region.Communications.Hypergrid namespace OpenSim.Region.Communications.Hypergrid
{ {
public class HGGridServicesGridMode : HGGridServices public class HGGridServicesGridMode : HGGridServices
{ {
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
/// <summary> /// <summary>
/// Encapsulate remote backend services for manipulation of grid regions /// Encapsulate remote backend services for manipulation of grid regions
/// </summary> /// </summary>
private OGS1GridServices m_remoteBackend = null; private OGS1GridServices m_remoteBackend = null;
public OGS1GridServices RemoteBackend public OGS1GridServices RemoteBackend
{ {
get { return m_remoteBackend; } get { return m_remoteBackend; }
} }
public override string gdebugRegionName public override string gdebugRegionName
{ {
get { return m_remoteBackend.gdebugRegionName; } get { return m_remoteBackend.gdebugRegionName; }
set { m_remoteBackend.gdebugRegionName = value; } set { m_remoteBackend.gdebugRegionName = value; }
} }
public override bool RegionLoginsEnabled public override bool RegionLoginsEnabled
{ {
get { return m_remoteBackend.RegionLoginsEnabled; } get { return m_remoteBackend.RegionLoginsEnabled; }
set { m_remoteBackend.RegionLoginsEnabled = value; } set { m_remoteBackend.RegionLoginsEnabled = value; }
} }
public HGGridServicesGridMode(NetworkServersInfo servers_info, BaseHttpServer httpServe, public HGGridServicesGridMode(NetworkServersInfo servers_info, BaseHttpServer httpServe,
AssetCache asscache, SceneManager sman, UserProfileCacheService userv) AssetCache asscache, SceneManager sman, UserProfileCacheService userv)
: base(servers_info, httpServe, asscache, sman) : base(servers_info, httpServe, asscache, sman)
{ {
m_remoteBackend = new OGS1GridServices(servers_info, httpServe); m_remoteBackend = new OGS1GridServices(servers_info, httpServe);
// Let's deregister this, so we can handle it here first // Let's deregister this, so we can handle it here first
InterRegionSingleton.Instance.OnChildAgent -= m_remoteBackend.IncomingChildAgent; InterRegionSingleton.Instance.OnChildAgent -= m_remoteBackend.IncomingChildAgent;
InterRegionSingleton.Instance.OnChildAgent += IncomingChildAgent; InterRegionSingleton.Instance.OnChildAgent += IncomingChildAgent;
m_userProfileCache = userv; m_userProfileCache = userv;
} }
#region IGridServices interface #region IGridServices interface
public override RegionCommsListener RegisterRegion(RegionInfo regionInfo) public override RegionCommsListener RegisterRegion(RegionInfo regionInfo)
{ {
if (!regionInfo.RegionID.Equals(UUID.Zero)) if (!regionInfo.RegionID.Equals(UUID.Zero))
{ {
m_regionsOnInstance.Add(regionInfo); m_regionsOnInstance.Add(regionInfo);
return m_remoteBackend.RegisterRegion(regionInfo); return m_remoteBackend.RegisterRegion(regionInfo);
} }
else else
return base.RegisterRegion(regionInfo); return base.RegisterRegion(regionInfo);
} }
public override bool DeregisterRegion(RegionInfo regionInfo) public override bool DeregisterRegion(RegionInfo regionInfo)
{ {
bool success = m_remoteBackend.DeregisterRegion(regionInfo); bool success = m_remoteBackend.DeregisterRegion(regionInfo);
if (!success) if (!success)
success = base.DeregisterRegion(regionInfo); success = base.DeregisterRegion(regionInfo);
return success; return success;
} }
public override List<SimpleRegionInfo> RequestNeighbours(uint x, uint y) public override List<SimpleRegionInfo> RequestNeighbours(uint x, uint y)
{ {
List<SimpleRegionInfo> neighbours = m_remoteBackend.RequestNeighbours(x, y); List<SimpleRegionInfo> neighbours = m_remoteBackend.RequestNeighbours(x, y);
List<SimpleRegionInfo> remotes = base.RequestNeighbours(x, y); List<SimpleRegionInfo> remotes = base.RequestNeighbours(x, y);
neighbours.AddRange(remotes); neighbours.AddRange(remotes);
return neighbours; return neighbours;
} }
public override RegionInfo RequestNeighbourInfo(UUID Region_UUID) public override RegionInfo RequestNeighbourInfo(UUID Region_UUID)
{ {
RegionInfo info = m_remoteBackend.RequestNeighbourInfo(Region_UUID); RegionInfo info = m_remoteBackend.RequestNeighbourInfo(Region_UUID);
if (info == null) if (info == null)
info = base.RequestNeighbourInfo(Region_UUID); info = base.RequestNeighbourInfo(Region_UUID);
return info; return info;
} }
public override RegionInfo RequestNeighbourInfo(ulong regionHandle) public override RegionInfo RequestNeighbourInfo(ulong regionHandle)
{ {
RegionInfo info = m_remoteBackend.RequestNeighbourInfo(regionHandle); RegionInfo info = m_remoteBackend.RequestNeighbourInfo(regionHandle);
if (info == null) if (info == null)
info = base.RequestNeighbourInfo(regionHandle); info = base.RequestNeighbourInfo(regionHandle);
return info; return info;
} }
public override RegionInfo RequestClosestRegion(string regionName) public override RegionInfo RequestClosestRegion(string regionName)
{ {
RegionInfo info = m_remoteBackend.RequestClosestRegion(regionName); RegionInfo info = m_remoteBackend.RequestClosestRegion(regionName);
if (info == null) if (info == null)
info = base.RequestClosestRegion(regionName); info = base.RequestClosestRegion(regionName);
return info; return info;
} }
public override List<MapBlockData> RequestNeighbourMapBlocks(int minX, int minY, int maxX, int maxY) public override List<MapBlockData> RequestNeighbourMapBlocks(int minX, int minY, int maxX, int maxY)
{ {
List<MapBlockData> neighbours = m_remoteBackend.RequestNeighbourMapBlocks(minX, minY, maxX, maxY); List<MapBlockData> neighbours = m_remoteBackend.RequestNeighbourMapBlocks(minX, minY, maxX, maxY);
List<MapBlockData> remotes = base.RequestNeighbourMapBlocks(minX, minY, maxX, maxY); List<MapBlockData> remotes = base.RequestNeighbourMapBlocks(minX, minY, maxX, maxY);
neighbours.AddRange(remotes); neighbours.AddRange(remotes);
return neighbours; return neighbours;
} }
public override LandData RequestLandData(ulong regionHandle, uint x, uint y) public override LandData RequestLandData(ulong regionHandle, uint x, uint y)
{ {
LandData land = m_remoteBackend.RequestLandData(regionHandle, x, y); LandData land = m_remoteBackend.RequestLandData(regionHandle, x, y);
if (land == null) if (land == null)
land = base.RequestLandData(regionHandle, x, y); land = base.RequestLandData(regionHandle, x, y);
return land; return land;
} }
public override List<RegionInfo> RequestNamedRegions(string name, int maxNumber) public override List<RegionInfo> RequestNamedRegions(string name, int maxNumber)
{ {
List<RegionInfo> infos = m_remoteBackend.RequestNamedRegions(name, maxNumber); List<RegionInfo> infos = m_remoteBackend.RequestNamedRegions(name, maxNumber);
List<RegionInfo> remotes = base.RequestNamedRegions(name, maxNumber); List<RegionInfo> remotes = base.RequestNamedRegions(name, maxNumber);
infos.AddRange(remotes); infos.AddRange(remotes);
return infos; return infos;
} }
#endregion #endregion
#region IInterRegionCommunications interface #region IInterRegionCommunications interface
public override bool AcknowledgeAgentCrossed(ulong regionHandle, UUID agentId) public override bool AcknowledgeAgentCrossed(ulong regionHandle, UUID agentId)
{ {
return m_remoteBackend.AcknowledgeAgentCrossed(regionHandle, agentId); return m_remoteBackend.AcknowledgeAgentCrossed(regionHandle, agentId);
} }
public override bool AcknowledgePrimCrossed(ulong regionHandle, UUID primID) public override bool AcknowledgePrimCrossed(ulong regionHandle, UUID primID)
{ {
return m_remoteBackend.AcknowledgePrimCrossed(regionHandle, primID); return m_remoteBackend.AcknowledgePrimCrossed(regionHandle, primID);
} }
public override bool CheckRegion(string address, uint port) public override bool CheckRegion(string address, uint port)
{ {
return m_remoteBackend.CheckRegion(address, port); return m_remoteBackend.CheckRegion(address, port);
} }
public override bool ChildAgentUpdate(ulong regionHandle, ChildAgentDataUpdate cAgentData) public override bool ChildAgentUpdate(ulong regionHandle, ChildAgentDataUpdate cAgentData)
{ {
return m_remoteBackend.ChildAgentUpdate(regionHandle, cAgentData); return m_remoteBackend.ChildAgentUpdate(regionHandle, cAgentData);
} }
public override bool ExpectAvatarCrossing(ulong regionHandle, UUID agentID, Vector3 position, bool isFlying) public override bool ExpectAvatarCrossing(ulong regionHandle, UUID agentID, Vector3 position, bool isFlying)
{ {
if (base.ExpectAvatarCrossing(regionHandle, agentID, position, isFlying)) if (base.ExpectAvatarCrossing(regionHandle, agentID, position, isFlying))
return true; return true;
return m_remoteBackend.ExpectAvatarCrossing(regionHandle, agentID, position, isFlying); return m_remoteBackend.ExpectAvatarCrossing(regionHandle, agentID, position, isFlying);
} }
public override bool ExpectPrimCrossing(ulong regionHandle, UUID primID, Vector3 position, bool isFlying) public override bool ExpectPrimCrossing(ulong regionHandle, UUID primID, Vector3 position, bool isFlying)
{ {
return m_remoteBackend.ExpectPrimCrossing(regionHandle, primID, position, isFlying); return m_remoteBackend.ExpectPrimCrossing(regionHandle, primID, position, isFlying);
} }
public override bool InformRegionOfChildAgent(ulong regionHandle, AgentCircuitData agentData) public override bool InformRegionOfChildAgent(ulong regionHandle, AgentCircuitData agentData)
{ {
CachedUserInfo user = m_userProfileCache.GetUserDetails(agentData.AgentID); CachedUserInfo user = m_userProfileCache.GetUserDetails(agentData.AgentID);
if (IsLocalUser(user)) if (IsLocalUser(user))
{ {
Console.WriteLine("XXX Home User XXX"); Console.WriteLine("XXX Home User XXX");
if (IsHyperlinkRegion(regionHandle)) if (IsHyperlinkRegion(regionHandle))
{ {
Console.WriteLine("XXX Going Hyperlink XXX"); Console.WriteLine("XXX Going Hyperlink XXX");
return base.InformRegionOfChildAgent(regionHandle, agentData); return base.InformRegionOfChildAgent(regionHandle, agentData);
} }
else else
{ {
// non-hypergrid case // non-hypergrid case
Console.WriteLine("XXX Going local-grid region XXX"); Console.WriteLine("XXX Going local-grid region XXX");
return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData); return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData);
} }
} }
// Foregin users // Foregin users
Console.WriteLine("XXX Foreign User XXX"); Console.WriteLine("XXX Foreign User XXX");
if (IsLocalRegion(regionHandle)) // regions on the same instance if (IsLocalRegion(regionHandle)) // regions on the same instance
{ {
Console.WriteLine("XXX Going onInstance region XXX"); Console.WriteLine("XXX Going onInstance region XXX");
return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData); return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData);
} }
if (IsHyperlinkRegion(regionHandle)) // hyperlinked regions if (IsHyperlinkRegion(regionHandle)) // hyperlinked regions
{ {
Console.WriteLine("XXX Going Hyperlink XXX"); Console.WriteLine("XXX Going Hyperlink XXX");
return base.InformRegionOfChildAgent(regionHandle, agentData); return base.InformRegionOfChildAgent(regionHandle, agentData);
} }
else else
{ {
// foreign user going to a non-local region on the same grid // foreign user going to a non-local region on the same grid
// We need to inform that region about this user before // We need to inform that region about this user before
// proceeding to the normal backend process. // proceeding to the normal backend process.
Console.WriteLine("XXX Going local-grid region XXX"); Console.WriteLine("XXX Going local-grid region XXX");
RegionInfo regInfo = RequestNeighbourInfo(regionHandle); RegionInfo regInfo = RequestNeighbourInfo(regionHandle);
if (regInfo != null) if (regInfo != null)
InformRegionOfUser(regInfo, agentData); InformRegionOfUser(regInfo, agentData);
return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData); return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData);
} }
} }
public override bool InformRegionOfPrimCrossing(ulong regionHandle, UUID primID, string objData, int XMLMethod) public override bool InformRegionOfPrimCrossing(ulong regionHandle, UUID primID, string objData, int XMLMethod)
{ {
return m_remoteBackend.InformRegionOfPrimCrossing(regionHandle, primID, objData, XMLMethod); return m_remoteBackend.InformRegionOfPrimCrossing(regionHandle, primID, objData, XMLMethod);
} }
public override bool RegionUp(SerializableRegionInfo region, ulong regionhandle) public override bool RegionUp(SerializableRegionInfo region, ulong regionhandle)
{ {
if (m_remoteBackend.RegionUp(region, regionhandle)) if (m_remoteBackend.RegionUp(region, regionhandle))
return true; return true;
return base.RegionUp(region, regionhandle); return base.RegionUp(region, regionhandle);
} }
public override bool TellRegionToCloseChildConnection(ulong regionHandle, UUID agentID) public override bool TellRegionToCloseChildConnection(ulong regionHandle, UUID agentID)
{ {
return m_remoteBackend.TellRegionToCloseChildConnection(regionHandle, agentID); return m_remoteBackend.TellRegionToCloseChildConnection(regionHandle, agentID);
} }
#endregion #endregion
#region Methods triggered by calls from external instances #region Methods triggered by calls from external instances
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="regionHandle"></param> /// <param name="regionHandle"></param>
/// <param name="agentData"></param> /// <param name="agentData"></param>
/// <returns></returns> /// <returns></returns>
public bool IncomingChildAgent(ulong regionHandle, AgentCircuitData agentData) public bool IncomingChildAgent(ulong regionHandle, AgentCircuitData agentData)
{ {
HGIncomingChildAgent(regionHandle, agentData); HGIncomingChildAgent(regionHandle, agentData);
m_log.Info("[HGrid]: Incoming HGrid Agent " + agentData.firstname + " " + agentData.lastname); m_log.Info("[HGrid]: Incoming HGrid Agent " + agentData.firstname + " " + agentData.lastname);
return m_remoteBackend.IncomingChildAgent(regionHandle, agentData); return m_remoteBackend.IncomingChildAgent(regionHandle, agentData);
} }
#endregion #endregion
} }
} }

1856
OpenSim/Region/Communications/Hypergrid/HGGridServicesStandalone.cs
View File

File diff suppressed because it is too large Load Diff

902
OpenSim/Region/Communications/Hypergrid/HGInventoryService.cs
View File

@ -1,451 +1,451 @@
/* /*
* Copyright (c) Contributors, http://opensimulator.org/ * Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright * * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright * * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the * notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution. * documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the * * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products * names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission. * derived from this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Net; using System.Net;
using System.Reflection; using System.Reflection;
using OpenMetaverse; using OpenMetaverse;
using log4net; using log4net;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications; using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers; using OpenSim.Framework.Servers;
using OpenSim.Framework.Statistics; using OpenSim.Framework.Statistics;
using OpenSim.Region.Communications.Local; using OpenSim.Region.Communications.Local;
namespace OpenSim.Region.Communications.Hypergrid namespace OpenSim.Region.Communications.Hypergrid
{ {
public class HGInventoryService : LocalInventoryService, ISecureInventoryService public class HGInventoryService : LocalInventoryService, ISecureInventoryService
{ {
private static readonly ILog m_log private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private string _inventoryServerUrl; private string _inventoryServerUrl;
//private Uri m_Uri; //private Uri m_Uri;
private UserProfileCacheService m_userProfileCache; private UserProfileCacheService m_userProfileCache;
private bool m_gridmode = false; private bool m_gridmode = false;
private Dictionary<UUID, InventoryReceiptCallback> m_RequestingInventory private Dictionary<UUID, InventoryReceiptCallback> m_RequestingInventory
= new Dictionary<UUID, InventoryReceiptCallback>(); = new Dictionary<UUID, InventoryReceiptCallback>();
public UserProfileCacheService UserProfileCache public UserProfileCacheService UserProfileCache
{ {
set { m_userProfileCache = value; } set { m_userProfileCache = value; }
} }
public HGInventoryService(string inventoryServerUrl, UserProfileCacheService userProfileCacheService, bool gridmode) public HGInventoryService(string inventoryServerUrl, UserProfileCacheService userProfileCacheService, bool gridmode)
{ {
_inventoryServerUrl = HGNetworkServersInfo.ServerURI(inventoryServerUrl); _inventoryServerUrl = HGNetworkServersInfo.ServerURI(inventoryServerUrl);
//m_Uri = new Uri(_inventoryServerUrl); //m_Uri = new Uri(_inventoryServerUrl);
m_userProfileCache = userProfileCacheService; m_userProfileCache = userProfileCacheService;
m_gridmode = gridmode; m_gridmode = gridmode;
} }
#region ISecureInventoryService Members #region ISecureInventoryService Members
public void RequestInventoryForUser(UUID userID, UUID session_id, InventoryReceiptCallback callback) public void RequestInventoryForUser(UUID userID, UUID session_id, InventoryReceiptCallback callback)
{ {
if (IsLocalStandaloneUser(userID)) if (IsLocalStandaloneUser(userID))
{ {
base.RequestInventoryForUser(userID, callback); base.RequestInventoryForUser(userID, callback);
return; return;
} }
// grid/hypergrid mode // grid/hypergrid mode
if (!m_RequestingInventory.ContainsKey(userID)) if (!m_RequestingInventory.ContainsKey(userID))
{ {
m_RequestingInventory.Add(userID, callback); m_RequestingInventory.Add(userID, callback);
try try
{ {
string invServer = GetUserInventoryURI(userID); string invServer = GetUserInventoryURI(userID);
m_log.InfoFormat( m_log.InfoFormat(
"[HGrid INVENTORY SERVICE]: Requesting inventory from {0}/GetInventory/ for user {1} ({2})", "[HGrid INVENTORY SERVICE]: Requesting inventory from {0}/GetInventory/ for user {1} ({2})",
/*_inventoryServerUrl*/ invServer, userID, userID.Guid); /*_inventoryServerUrl*/ invServer, userID, userID.Guid);
RestSessionObjectPosterResponse<Guid, InventoryCollection> requester RestSessionObjectPosterResponse<Guid, InventoryCollection> requester
= new RestSessionObjectPosterResponse<Guid, InventoryCollection>(); = new RestSessionObjectPosterResponse<Guid, InventoryCollection>();
requester.ResponseCallback = InventoryResponse; requester.ResponseCallback = InventoryResponse;
requester.BeginPostObject(invServer + "/GetInventory/", userID.Guid, session_id.ToString(), userID.ToString()); requester.BeginPostObject(invServer + "/GetInventory/", userID.Guid, session_id.ToString(), userID.ToString());
//Test(userID.Guid); //Test(userID.Guid);
//RestObjectPosterResponse<InventoryCollection> requester //RestObjectPosterResponse<InventoryCollection> requester
// = new RestObjectPosterResponse<InventoryCollection>(); // = new RestObjectPosterResponse<InventoryCollection>();
//requester.ResponseCallback = InventoryResponse; //requester.ResponseCallback = InventoryResponse;
//requester.BeginPostObject<Guid>(/*_inventoryServerUrl*/ invServer + "/GetInventory/", userID.Guid); //requester.BeginPostObject<Guid>(/*_inventoryServerUrl*/ invServer + "/GetInventory/", userID.Guid);
//RestClient cli = new RestClient(invServer + "/GetInventory/" + userID.Guid); //RestClient cli = new RestClient(invServer + "/GetInventory/" + userID.Guid);
//Stream reply = cli.Request(); //Stream reply = cli.Request();
} }
catch (WebException e) catch (WebException e)
{ {
if (StatsManager.SimExtraStats != null) if (StatsManager.SimExtraStats != null)
StatsManager.SimExtraStats.AddInventoryServiceRetrievalFailure(); StatsManager.SimExtraStats.AddInventoryServiceRetrievalFailure();
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Request inventory operation failed, {0} {1}", m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Request inventory operation failed, {0} {1}",
e.Source, e.Message); e.Source, e.Message);
} }
} }
else else
{ {
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: RequestInventoryForUser() - could not find user profile for {0}", userID); m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: RequestInventoryForUser() - could not find user profile for {0}", userID);
} }
} }
/// <summary> /// <summary>
/// Add a new folder to the user's inventory /// Add a new folder to the user's inventory
/// </summary> /// </summary>
/// <param name="folder"></param> /// <param name="folder"></param>
/// <returns>true if the folder was successfully added</returns> /// <returns>true if the folder was successfully added</returns>
public bool AddFolder(InventoryFolderBase folder, UUID session_id) public bool AddFolder(InventoryFolderBase folder, UUID session_id)
{ {
if (IsLocalStandaloneUser(folder.Owner)) if (IsLocalStandaloneUser(folder.Owner))
{ {
return base.AddFolder(folder); return base.AddFolder(folder);
} }
try try
{ {
string invServ = GetUserInventoryURI(folder.Owner); string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject( return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/NewFolder/", folder, session_id.ToString(), folder.Owner.ToString()); "POST", invServ + "/NewFolder/", folder, session_id.ToString(), folder.Owner.ToString());
} }
catch (WebException e) catch (WebException e)
{ {
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Add new inventory folder operation failed, {0} {1}", m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Add new inventory folder operation failed, {0} {1}",
e.Source, e.Message); e.Source, e.Message);
} }
return false; return false;
} }
/// <summary> /// <summary>
/// Update a folder in the user's inventory /// Update a folder in the user's inventory
/// </summary> /// </summary>
/// <param name="folder"></param> /// <param name="folder"></param>
/// <returns>true if the folder was successfully updated</returns> /// <returns>true if the folder was successfully updated</returns>
public bool UpdateFolder(InventoryFolderBase folder, UUID session_id) public bool UpdateFolder(InventoryFolderBase folder, UUID session_id)
{ {
if (IsLocalStandaloneUser(folder.Owner)) if (IsLocalStandaloneUser(folder.Owner))
{ {
return base.UpdateFolder(folder); return base.UpdateFolder(folder);
} }
try try
{ {
string invServ = GetUserInventoryURI(folder.Owner); string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject( return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/UpdateFolder/", folder, session_id.ToString(), folder.Owner.ToString()); "POST", invServ + "/UpdateFolder/", folder, session_id.ToString(), folder.Owner.ToString());
} }
catch (WebException e) catch (WebException e)
{ {
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Update inventory folder operation failed, {0} {1}", m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Update inventory folder operation failed, {0} {1}",
e.Source, e.Message); e.Source, e.Message);
} }
return false; return false;
} }
/// <summary> /// <summary>
/// Move an inventory folder to a new location /// Move an inventory folder to a new location
/// </summary> /// </summary>
/// <param name="folder">A folder containing the details of the new location</param> /// <param name="folder">A folder containing the details of the new location</param>
/// <returns>true if the folder was successfully moved</returns> /// <returns>true if the folder was successfully moved</returns>
public bool MoveFolder(InventoryFolderBase folder, UUID session_id) public bool MoveFolder(InventoryFolderBase folder, UUID session_id)
{ {
if (IsLocalStandaloneUser(folder.Owner)) if (IsLocalStandaloneUser(folder.Owner))
{ {
return base.MoveFolder(folder); return base.MoveFolder(folder);
} }
try try
{ {
string invServ = GetUserInventoryURI(folder.Owner); string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject( return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/MoveFolder/", folder, session_id.ToString(), folder.Owner.ToString()); "POST", invServ + "/MoveFolder/", folder, session_id.ToString(), folder.Owner.ToString());
} }
catch (WebException e) catch (WebException e)
{ {
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Move inventory folder operation failed, {0} {1}", m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Move inventory folder operation failed, {0} {1}",
e.Source, e.Message); e.Source, e.Message);
} }
return false; return false;
} }
/// <summary> /// <summary>
/// Purge an inventory folder of all its items and subfolders. /// Purge an inventory folder of all its items and subfolders.
/// </summary> /// </summary>
/// <param name="folder"></param> /// <param name="folder"></param>
/// <returns>true if the folder was successfully purged</returns> /// <returns>true if the folder was successfully purged</returns>
public bool PurgeFolder(InventoryFolderBase folder, UUID session_id) public bool PurgeFolder(InventoryFolderBase folder, UUID session_id)
{ {
if (IsLocalStandaloneUser(folder.Owner)) if (IsLocalStandaloneUser(folder.Owner))
{ {
return base.PurgeFolder(folder); return base.PurgeFolder(folder);
} }
try try
{ {
string invServ = GetUserInventoryURI(folder.Owner); string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject( return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/PurgeFolder/", folder, session_id.ToString(), folder.Owner.ToString()); "POST", invServ + "/PurgeFolder/", folder, session_id.ToString(), folder.Owner.ToString());
} }
catch (WebException e) catch (WebException e)
{ {
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Move inventory folder operation failed, {0} {1}", m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Move inventory folder operation failed, {0} {1}",
e.Source, e.Message); e.Source, e.Message);
} }
return false; return false;
} }
/// <summary> /// <summary>
/// Add a new item to the user's inventory /// Add a new item to the user's inventory
/// </summary> /// </summary>
/// <param name="item"></param> /// <param name="item"></param>
/// <returns>true if the item was successfully added</returns> /// <returns>true if the item was successfully added</returns>
public bool AddItem(InventoryItemBase item, UUID session_id) public bool AddItem(InventoryItemBase item, UUID session_id)
{ {
if (IsLocalStandaloneUser(item.Owner)) if (IsLocalStandaloneUser(item.Owner))
{ {
return base.AddItem(item); return base.AddItem(item);
} }
try try
{ {
string invServ = GetUserInventoryURI(item.Owner); string invServ = GetUserInventoryURI(item.Owner);
return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject( return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject(
"POST", invServ + "/NewItem/", item, session_id.ToString(), item.Owner.ToString()); "POST", invServ + "/NewItem/", item, session_id.ToString(), item.Owner.ToString());
} }
catch (WebException e) catch (WebException e)
{ {
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Add new inventory item operation failed, {0} {1}", m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Add new inventory item operation failed, {0} {1}",
e.Source, e.Message); e.Source, e.Message);
} }
return false; return false;
} }
/// <summary> /// <summary>
/// Update an item in the user's inventory /// Update an item in the user's inventory
/// </summary> /// </summary>
/// <param name="item"></param> /// <param name="item"></param>
/// <returns>true if the item was successfully updated</returns> /// <returns>true if the item was successfully updated</returns>
public bool UpdateItem(InventoryItemBase item, UUID session_id) public bool UpdateItem(InventoryItemBase item, UUID session_id)
{ {
if (IsLocalStandaloneUser(item.Owner)) if (IsLocalStandaloneUser(item.Owner))
{ {
return base.UpdateItem(item); return base.UpdateItem(item);
} }
try try
{ {
string invServ = GetUserInventoryURI(item.Owner); string invServ = GetUserInventoryURI(item.Owner);
return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject( return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject(
"POST", invServ + "/NewItem/", item, session_id.ToString(), item.Owner.ToString()); "POST", invServ + "/NewItem/", item, session_id.ToString(), item.Owner.ToString());
} }
catch (WebException e) catch (WebException e)
{ {
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Update new inventory item operation failed, {0} {1}", m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Update new inventory item operation failed, {0} {1}",
e.Source, e.Message); e.Source, e.Message);
} }
return false; return false;
} }
/// <summary> /// <summary>
/// Delete an item from the user's inventory /// Delete an item from the user's inventory
/// </summary> /// </summary>
/// <param name="item"></param> /// <param name="item"></param>
/// <returns>true if the item was successfully deleted</returns> /// <returns>true if the item was successfully deleted</returns>
public bool DeleteItem(InventoryItemBase item, UUID session_id) public bool DeleteItem(InventoryItemBase item, UUID session_id)
{ {
if (IsLocalStandaloneUser(item.Owner)) if (IsLocalStandaloneUser(item.Owner))
{ {
return base.DeleteItem(item); return base.DeleteItem(item);
} }
try try
{ {
string invServ = GetUserInventoryURI(item.Owner); string invServ = GetUserInventoryURI(item.Owner);
return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject( return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject(
"POST", invServ + "/DeleteItem/", item, session_id.ToString(), item.Owner.ToString()); "POST", invServ + "/DeleteItem/", item, session_id.ToString(), item.Owner.ToString());
} }
catch (WebException e) catch (WebException e)
{ {
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Delete inventory item operation failed, {0} {1}", m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Delete inventory item operation failed, {0} {1}",
e.Source, e.Message); e.Source, e.Message);
} }
return false; return false;
} }
#endregion #endregion
#region Methods common to ISecureInventoryService and IInventoryService #region Methods common to ISecureInventoryService and IInventoryService
/// <summary> /// <summary>
/// Does the given user have an inventory structure? /// Does the given user have an inventory structure?
/// </summary> /// </summary>
/// <param name="userID"></param> /// <param name="userID"></param>
/// <returns></returns> /// <returns></returns>
public override bool HasInventoryForUser(UUID userID) public override bool HasInventoryForUser(UUID userID)
{ {
if (IsLocalStandaloneUser(userID)) if (IsLocalStandaloneUser(userID))
{ {
return base.HasInventoryForUser(userID); return base.HasInventoryForUser(userID);
} }
return false; return false;
} }
/// <summary> /// <summary>
/// Retrieve the root inventory folder for the given user. /// Retrieve the root inventory folder for the given user.
/// </summary> /// </summary>
/// <param name="userID"></param> /// <param name="userID"></param>
/// <returns>null if no root folder was found</returns> /// <returns>null if no root folder was found</returns>
public override InventoryFolderBase RequestRootFolder(UUID userID) public override InventoryFolderBase RequestRootFolder(UUID userID)
{ {
if (IsLocalStandaloneUser(userID)) if (IsLocalStandaloneUser(userID))
{ {
return base.RequestRootFolder(userID); return base.RequestRootFolder(userID);
} }
return null; return null;
} }
#endregion #endregion
/// <summary> /// <summary>
/// Callback used by the inventory server GetInventory request /// Callback used by the inventory server GetInventory request
/// </summary> /// </summary>
/// <param name="userID"></param> /// <param name="userID"></param>
private void InventoryResponse(InventoryCollection response) private void InventoryResponse(InventoryCollection response)
{ {
UUID userID = response.UserID; UUID userID = response.UserID;
if (m_RequestingInventory.ContainsKey(userID)) if (m_RequestingInventory.ContainsKey(userID))
{ {
m_log.InfoFormat("[HGrid INVENTORY SERVICE]: " + m_log.InfoFormat("[HGrid INVENTORY SERVICE]: " +
"Received inventory response for user {0} containing {1} folders and {2} items", "Received inventory response for user {0} containing {1} folders and {2} items",
userID, response.Folders.Count, response.Items.Count); userID, response.Folders.Count, response.Items.Count);
InventoryFolderImpl rootFolder = null; InventoryFolderImpl rootFolder = null;
InventoryReceiptCallback callback = m_RequestingInventory[userID]; InventoryReceiptCallback callback = m_RequestingInventory[userID];
ICollection<InventoryFolderImpl> folders = new List<InventoryFolderImpl>(); ICollection<InventoryFolderImpl> folders = new List<InventoryFolderImpl>();
ICollection<InventoryItemBase> items = new List<InventoryItemBase>(); ICollection<InventoryItemBase> items = new List<InventoryItemBase>();
foreach (InventoryFolderBase folder in response.Folders) foreach (InventoryFolderBase folder in response.Folders)
{ {
if (folder.ParentID == UUID.Zero) if (folder.ParentID == UUID.Zero)
{ {
rootFolder = new InventoryFolderImpl(folder); rootFolder = new InventoryFolderImpl(folder);
folders.Add(rootFolder); folders.Add(rootFolder);
break; break;
} }
} }
if (rootFolder != null) if (rootFolder != null)
{ {
foreach (InventoryFolderBase folder in response.Folders) foreach (InventoryFolderBase folder in response.Folders)
{ {
if (folder.ID != rootFolder.ID) if (folder.ID != rootFolder.ID)
{ {
folders.Add(new InventoryFolderImpl(folder)); folders.Add(new InventoryFolderImpl(folder));
} }
} }
foreach (InventoryItemBase item in response.Items) foreach (InventoryItemBase item in response.Items)
{ {
items.Add(item); items.Add(item);
} }
} }
else else
{ {
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Did not get back an inventory containing a root folder for user {0}", userID); m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Did not get back an inventory containing a root folder for user {0}", userID);
} }
callback(folders, items); callback(folders, items);
m_RequestingInventory.Remove(userID); m_RequestingInventory.Remove(userID);
} }
else else
{ {
m_log.WarnFormat( m_log.WarnFormat(
"[HGrid INVENTORY SERVICE]: " + "[HGrid INVENTORY SERVICE]: " +
"Received inventory response for {0} for which we do not have a record of requesting!", "Received inventory response for {0} for which we do not have a record of requesting!",
userID); userID);
} }
} }
private bool IsLocalStandaloneUser(UUID userID) private bool IsLocalStandaloneUser(UUID userID)
{ {
CachedUserInfo uinfo = m_userProfileCache.GetUserDetails(userID); CachedUserInfo uinfo = m_userProfileCache.GetUserDetails(userID);
if (uinfo == null) if (uinfo == null)
return true; return true;
string userInventoryServerURI = HGNetworkServersInfo.ServerURI(uinfo.UserProfile.UserInventoryURI); string userInventoryServerURI = HGNetworkServersInfo.ServerURI(uinfo.UserProfile.UserInventoryURI);
if ((!m_gridmode) && ((userInventoryServerURI == _inventoryServerUrl)) || (userInventoryServerURI == "")) if ((!m_gridmode) && ((userInventoryServerURI == _inventoryServerUrl)) || (userInventoryServerURI == ""))
{ {
return true; return true;
} }
return false; return false;
} }
private string GetUserInventoryURI(UUID userID) private string GetUserInventoryURI(UUID userID)
{ {
string invURI = _inventoryServerUrl; string invURI = _inventoryServerUrl;
CachedUserInfo uinfo = m_userProfileCache.GetUserDetails(userID); CachedUserInfo uinfo = m_userProfileCache.GetUserDetails(userID);
if ((uinfo == null) || (uinfo.UserProfile == null)) if ((uinfo == null) || (uinfo.UserProfile == null))
return invURI; return invURI;
string userInventoryServerURI = HGNetworkServersInfo.ServerURI(uinfo.UserProfile.UserInventoryURI); string userInventoryServerURI = HGNetworkServersInfo.ServerURI(uinfo.UserProfile.UserInventoryURI);
if ((userInventoryServerURI != null) && if ((userInventoryServerURI != null) &&
(userInventoryServerURI != "")) (userInventoryServerURI != ""))
invURI = userInventoryServerURI; invURI = userInventoryServerURI;
return invURI; return invURI;
} }
} }
} }

534
OpenSim/Region/Communications/Hypergrid/HGUserServices.cs
View File

@ -1,267 +1,267 @@
/* /*
* Copyright (c) Contributors, http://opensimulator.org/ * Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright * * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright * * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the * notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution. * documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the * * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products * names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission. * derived from this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.Net; using System.Net;
using System.Reflection; using System.Reflection;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
using OpenMetaverse; using OpenMetaverse;
using log4net; using log4net;
using Nwc.XmlRpc; using Nwc.XmlRpc;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications; using OpenSim.Framework.Communications;
using OpenSim.Region.Communications.OGS1; using OpenSim.Region.Communications.OGS1;
namespace OpenSim.Region.Communications.Hypergrid namespace OpenSim.Region.Communications.Hypergrid
{ {
/// <summary> /// <summary>
/// For the time being, this class is just an identity wrapper around OGS1UserServices, /// For the time being, this class is just an identity wrapper around OGS1UserServices,
/// so it always fails for foreign users. /// so it always fails for foreign users.
/// Later it needs to talk with the foreign users' user servers. /// Later it needs to talk with the foreign users' user servers.
/// </summary> /// </summary>
public class HGUserServices : IUserService, IAvatarService, IMessagingService public class HGUserServices : IUserService, IAvatarService, IMessagingService
{ {
//private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
//private HGCommunicationsGridMode m_parent; //private HGCommunicationsGridMode m_parent;
private OGS1UserServices m_remoteUserServices; private OGS1UserServices m_remoteUserServices;
public HGUserServices(HGCommunicationsGridMode parent) public HGUserServices(HGCommunicationsGridMode parent)
{ {
//m_parent = parent; //m_parent = parent;
m_remoteUserServices = new OGS1UserServices(parent); m_remoteUserServices = new OGS1UserServices(parent);
} }
public UserProfileData ConvertXMLRPCDataToUserProfile(Hashtable data) public UserProfileData ConvertXMLRPCDataToUserProfile(Hashtable data)
{ {
return m_remoteUserServices.ConvertXMLRPCDataToUserProfile(data); return m_remoteUserServices.ConvertXMLRPCDataToUserProfile(data);
} }
/// <summary> /// <summary>
/// Get a user agent from the user server /// Get a user agent from the user server
/// </summary> /// </summary>
/// <param name="avatarID"></param> /// <param name="avatarID"></param>
/// <returns>null if the request fails</returns> /// <returns>null if the request fails</returns>
public UserAgentData GetAgentByUUID(UUID userId) public UserAgentData GetAgentByUUID(UUID userId)
{ {
return m_remoteUserServices.GetAgentByUUID(userId); return m_remoteUserServices.GetAgentByUUID(userId);
} }
public AvatarAppearance ConvertXMLRPCDataToAvatarAppearance(Hashtable data) public AvatarAppearance ConvertXMLRPCDataToAvatarAppearance(Hashtable data)
{ {
return m_remoteUserServices.ConvertXMLRPCDataToAvatarAppearance(data); return m_remoteUserServices.ConvertXMLRPCDataToAvatarAppearance(data);
} }
public List<AvatarPickerAvatar> ConvertXMLRPCDataToAvatarPickerList(UUID queryID, Hashtable data) public List<AvatarPickerAvatar> ConvertXMLRPCDataToAvatarPickerList(UUID queryID, Hashtable data)
{ {
return m_remoteUserServices.ConvertXMLRPCDataToAvatarPickerList(queryID, data); return m_remoteUserServices.ConvertXMLRPCDataToAvatarPickerList(queryID, data);
} }
public List<FriendListItem> ConvertXMLRPCDataToFriendListItemList(Hashtable data) public List<FriendListItem> ConvertXMLRPCDataToFriendListItemList(Hashtable data)
{ {
return m_remoteUserServices.ConvertXMLRPCDataToFriendListItemList(data); return m_remoteUserServices.ConvertXMLRPCDataToFriendListItemList(data);
} }
/// <summary> /// <summary>
/// Logs off a user on the user server /// Logs off a user on the user server
/// </summary> /// </summary>
/// <param name="UserID">UUID of the user</param> /// <param name="UserID">UUID of the user</param>
/// <param name="regionID">UUID of the Region</param> /// <param name="regionID">UUID of the Region</param>
/// <param name="regionhandle">regionhandle</param> /// <param name="regionhandle">regionhandle</param>
/// <param name="position">final position</param> /// <param name="position">final position</param>
/// <param name="lookat">final lookat</param> /// <param name="lookat">final lookat</param>
public void LogOffUser(UUID userid, UUID regionid, ulong regionhandle, Vector3 position, Vector3 lookat) public void LogOffUser(UUID userid, UUID regionid, ulong regionhandle, Vector3 position, Vector3 lookat)
{ {
m_remoteUserServices.LogOffUser(userid, regionid, regionhandle, position, lookat); m_remoteUserServices.LogOffUser(userid, regionid, regionhandle, position, lookat);
} }
/// <summary> /// <summary>
/// Logs off a user on the user server (deprecated as of 2008-08-27) /// Logs off a user on the user server (deprecated as of 2008-08-27)
/// </summary> /// </summary>
/// <param name="UserID">UUID of the user</param> /// <param name="UserID">UUID of the user</param>
/// <param name="regionID">UUID of the Region</param> /// <param name="regionID">UUID of the Region</param>
/// <param name="regionhandle">regionhandle</param> /// <param name="regionhandle">regionhandle</param>
/// <param name="posx">final position x</param> /// <param name="posx">final position x</param>
/// <param name="posy">final position y</param> /// <param name="posy">final position y</param>
/// <param name="posz">final position z</param> /// <param name="posz">final position z</param>
public void LogOffUser(UUID userid, UUID regionid, ulong regionhandle, float posx, float posy, float posz) public void LogOffUser(UUID userid, UUID regionid, ulong regionhandle, float posx, float posy, float posz)
{ {
m_remoteUserServices.LogOffUser(userid, regionid, regionhandle, posx, posy, posz); m_remoteUserServices.LogOffUser(userid, regionid, regionhandle, posx, posy, posz);
} }
public UserProfileData GetUserProfile(string firstName, string lastName) public UserProfileData GetUserProfile(string firstName, string lastName)
{ {
return GetUserProfile(firstName + " " + lastName); return GetUserProfile(firstName + " " + lastName);
} }
public void UpdateUserCurrentRegion(UUID avatarid, UUID regionuuid, ulong regionhandle) public void UpdateUserCurrentRegion(UUID avatarid, UUID regionuuid, ulong regionhandle)
{ {
m_remoteUserServices.UpdateUserCurrentRegion(avatarid, regionuuid, regionhandle); m_remoteUserServices.UpdateUserCurrentRegion(avatarid, regionuuid, regionhandle);
} }
public List<AvatarPickerAvatar> GenerateAgentPickerRequestResponse(UUID queryID, string query) public List<AvatarPickerAvatar> GenerateAgentPickerRequestResponse(UUID queryID, string query)
{ {
return m_remoteUserServices.GenerateAgentPickerRequestResponse(queryID, query); return m_remoteUserServices.GenerateAgentPickerRequestResponse(queryID, query);
} }
/// <summary> /// <summary>
/// Get a user profile from the user server /// Get a user profile from the user server
/// </summary> /// </summary>
/// <param name="avatarID"></param> /// <param name="avatarID"></param>
/// <returns>null if the request fails</returns> /// <returns>null if the request fails</returns>
public UserProfileData GetUserProfile(string name) public UserProfileData GetUserProfile(string name)
{ {
return m_remoteUserServices.GetUserProfile(name); return m_remoteUserServices.GetUserProfile(name);
} }
/// <summary> /// <summary>
/// Get a user profile from the user server /// Get a user profile from the user server
/// </summary> /// </summary>
/// <param name="avatarID"></param> /// <param name="avatarID"></param>
/// <returns>null if the request fails</returns> /// <returns>null if the request fails</returns>
public UserProfileData GetUserProfile(UUID avatarID) public UserProfileData GetUserProfile(UUID avatarID)
{ {
return m_remoteUserServices.GetUserProfile(avatarID); return m_remoteUserServices.GetUserProfile(avatarID);
} }
public void ClearUserAgent(UUID avatarID) public void ClearUserAgent(UUID avatarID)
{ {
m_remoteUserServices.ClearUserAgent(avatarID); m_remoteUserServices.ClearUserAgent(avatarID);
} }
/// <summary> /// <summary>
/// Retrieve the user information for the given master uuid. /// Retrieve the user information for the given master uuid.
/// </summary> /// </summary>
/// <param name="uuid"></param> /// <param name="uuid"></param>
/// <returns></returns> /// <returns></returns>
public UserProfileData SetupMasterUser(string firstName, string lastName) public UserProfileData SetupMasterUser(string firstName, string lastName)
{ {
return m_remoteUserServices.SetupMasterUser(firstName, lastName); return m_remoteUserServices.SetupMasterUser(firstName, lastName);
} }
/// <summary> /// <summary>
/// Retrieve the user information for the given master uuid. /// Retrieve the user information for the given master uuid.
/// </summary> /// </summary>
/// <param name="uuid"></param> /// <param name="uuid"></param>
/// <returns></returns> /// <returns></returns>
public UserProfileData SetupMasterUser(string firstName, string lastName, string password) public UserProfileData SetupMasterUser(string firstName, string lastName, string password)
{ {
return m_remoteUserServices.SetupMasterUser(firstName, lastName, password); return m_remoteUserServices.SetupMasterUser(firstName, lastName, password);
} }
/// <summary> /// <summary>
/// Retrieve the user information for the given master uuid. /// Retrieve the user information for the given master uuid.
/// </summary> /// </summary>
/// <param name="uuid"></param> /// <param name="uuid"></param>
/// <returns></returns> /// <returns></returns>
public UserProfileData SetupMasterUser(UUID uuid) public UserProfileData SetupMasterUser(UUID uuid)
{ {
return m_remoteUserServices.SetupMasterUser(uuid); return m_remoteUserServices.SetupMasterUser(uuid);
} }
public UUID AddUserProfile(string firstName, string lastName, string pass, uint regX, uint regY) public UUID AddUserProfile(string firstName, string lastName, string pass, uint regX, uint regY)
{ {
return m_remoteUserServices.AddUserProfile(firstName, lastName, pass, regX, regY); return m_remoteUserServices.AddUserProfile(firstName, lastName, pass, regX, regY);
} }
public bool ResetUserPassword(string firstName, string lastName, string newPassword) public bool ResetUserPassword(string firstName, string lastName, string newPassword)
{ {
return m_remoteUserServices.ResetUserPassword(firstName, lastName, newPassword); return m_remoteUserServices.ResetUserPassword(firstName, lastName, newPassword);
} }
public bool UpdateUserProfile(UserProfileData userProfile) public bool UpdateUserProfile(UserProfileData userProfile)
{ {
return m_remoteUserServices.UpdateUserProfile(userProfile); return m_remoteUserServices.UpdateUserProfile(userProfile);
} }
#region IUserServices Friend Methods #region IUserServices Friend Methods
/// <summary> /// <summary>
/// Adds a new friend to the database for XUser /// Adds a new friend to the database for XUser
/// </summary> /// </summary>
/// <param name="friendlistowner">The agent that who's friends list is being added to</param> /// <param name="friendlistowner">The agent that who's friends list is being added to</param>
/// <param name="friend">The agent that being added to the friends list of the friends list owner</param> /// <param name="friend">The agent that being added to the friends list of the friends list owner</param>
/// <param name="perms">A uint bit vector for set perms that the friend being added has; 0 = none, 1=This friend can see when they sign on, 2 = map, 4 edit objects </param> /// <param name="perms">A uint bit vector for set perms that the friend being added has; 0 = none, 1=This friend can see when they sign on, 2 = map, 4 edit objects </param>
public void AddNewUserFriend(UUID friendlistowner, UUID friend, uint perms) public void AddNewUserFriend(UUID friendlistowner, UUID friend, uint perms)
{ {
m_remoteUserServices.AddNewUserFriend(friendlistowner, friend, perms); m_remoteUserServices.AddNewUserFriend(friendlistowner, friend, perms);
} }
/// <summary> /// <summary>
/// Delete friend on friendlistowner's friendlist. /// Delete friend on friendlistowner's friendlist.
/// </summary> /// </summary>
/// <param name="friendlistowner">The agent that who's friends list is being updated</param> /// <param name="friendlistowner">The agent that who's friends list is being updated</param>
/// <param name="friend">The Ex-friend agent</param> /// <param name="friend">The Ex-friend agent</param>
public void RemoveUserFriend(UUID friendlistowner, UUID friend) public void RemoveUserFriend(UUID friendlistowner, UUID friend)
{ {
m_remoteUserServices.RemoveUserFriend(friend, friend); m_remoteUserServices.RemoveUserFriend(friend, friend);
} }
/// <summary> /// <summary>
/// Update permissions for friend on friendlistowner's friendlist. /// Update permissions for friend on friendlistowner's friendlist.
/// </summary> /// </summary>
/// <param name="friendlistowner">The agent that who's friends list is being updated</param> /// <param name="friendlistowner">The agent that who's friends list is being updated</param>
/// <param name="friend">The agent that is getting or loosing permissions</param> /// <param name="friend">The agent that is getting or loosing permissions</param>
/// <param name="perms">A uint bit vector for set perms that the friend being added has; 0 = none, 1=This friend can see when they sign on, 2 = map, 4 edit objects </param> /// <param name="perms">A uint bit vector for set perms that the friend being added has; 0 = none, 1=This friend can see when they sign on, 2 = map, 4 edit objects </param>
public void UpdateUserFriendPerms(UUID friendlistowner, UUID friend, uint perms) public void UpdateUserFriendPerms(UUID friendlistowner, UUID friend, uint perms)
{ {
m_remoteUserServices.UpdateUserFriendPerms(friendlistowner, friend, perms); m_remoteUserServices.UpdateUserFriendPerms(friendlistowner, friend, perms);
} }
/// <summary> /// <summary>
/// Returns a list of FriendsListItems that describe the friends and permissions in the friend relationship for UUID friendslistowner /// Returns a list of FriendsListItems that describe the friends and permissions in the friend relationship for UUID friendslistowner
/// </summary> /// </summary>
/// <param name="friendlistowner">The agent that we're retreiving the friends Data.</param> /// <param name="friendlistowner">The agent that we're retreiving the friends Data.</param>
public List<FriendListItem> GetUserFriendList(UUID friendlistowner) public List<FriendListItem> GetUserFriendList(UUID friendlistowner)
{ {
return m_remoteUserServices.GetUserFriendList(friendlistowner); return m_remoteUserServices.GetUserFriendList(friendlistowner);
} }
#endregion #endregion
/// Appearance /// Appearance
public AvatarAppearance GetUserAppearance(UUID user) public AvatarAppearance GetUserAppearance(UUID user)
{ {
return m_remoteUserServices.GetUserAppearance(user); return m_remoteUserServices.GetUserAppearance(user);
} }
public void UpdateUserAppearance(UUID user, AvatarAppearance appearance) public void UpdateUserAppearance(UUID user, AvatarAppearance appearance)
{ {
m_remoteUserServices.UpdateUserAppearance(user, appearance); m_remoteUserServices.UpdateUserAppearance(user, appearance);
} }
#region IMessagingService #region IMessagingService
public Dictionary<UUID, FriendRegionInfo> GetFriendRegionInfos(List<UUID> uuids) public Dictionary<UUID, FriendRegionInfo> GetFriendRegionInfos(List<UUID> uuids)
{ {
return m_remoteUserServices.GetFriendRegionInfos(uuids); return m_remoteUserServices.GetFriendRegionInfos(uuids);
} }
#endregion #endregion
} }
} }

398
OpenSim/Region/Environment/Modules/Hypergrid/HGStandaloneAssetService.cs
View File

@ -1,200 +1,200 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Net; using System.Net;
using System.Reflection; using System.Reflection;
using log4net; using log4net;
using Nini.Config; using Nini.Config;
using OpenMetaverse; using OpenMetaverse;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications; using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers; using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Interfaces; using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Scenes;
using OpenSim.Grid.AssetServer; using OpenSim.Grid.AssetServer;
namespace OpenSim.Region.Environment.Modules.Hypergrid namespace OpenSim.Region.Environment.Modules.Hypergrid
{ {
public class HGStandaloneAssetService : IRegionModule public class HGStandaloneAssetService : IRegionModule
{ {
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private static bool initialized = false; private static bool initialized = false;
private static bool enabled = false; private static bool enabled = false;
Scene m_scene; Scene m_scene;
//AssetService m_assetService; //AssetService m_assetService;
#region IRegionModule interface #region IRegionModule interface
public void Initialise(Scene scene, IConfigSource config) public void Initialise(Scene scene, IConfigSource config)
{ {
if (!initialized) if (!initialized)
{ {
initialized = true; initialized = true;
m_scene = scene; m_scene = scene;
// This module is only on for standalones in hypergrid mode // This module is only on for standalones in hypergrid mode
enabled = !config.Configs["Startup"].GetBoolean("gridmode", true) && config.Configs["Startup"].GetBoolean("hypergrid", false); enabled = !config.Configs["Startup"].GetBoolean("gridmode", true) && config.Configs["Startup"].GetBoolean("hypergrid", false);
} }
} }
public void PostInitialise() public void PostInitialise()
{ {
if (enabled) if (enabled)
{ {
m_log.Info("[HGStandaloneAssetService]: Starting..."); m_log.Info("[HGStandaloneAssetService]: Starting...");
//m_assetService = new AssetService(m_scene); //m_assetService = new AssetService(m_scene);
new AssetService(m_scene); new AssetService(m_scene);
} }
} }
public void Close() public void Close()
{ {
} }
public string Name public string Name
{ {
get { return "HGStandaloneAssetService"; } get { return "HGStandaloneAssetService"; }
} }
public bool IsSharedModule public bool IsSharedModule
{ {
get { return true; } get { return true; }
} }
#endregion #endregion
} }
public class AssetService public class AssetService
{ {
private IUserService m_userService; private IUserService m_userService;
private bool m_doLookup = false; private bool m_doLookup = false;
public bool DoLookup public bool DoLookup
{ {
get { return m_doLookup; } get { return m_doLookup; }
set { m_doLookup = value; } set { m_doLookup = value; }
} }
private static readonly ILog m_log private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
public AssetService(Scene m_scene) public AssetService(Scene m_scene)
{ {
AddHttpHandlers(m_scene); AddHttpHandlers(m_scene);
m_userService = m_scene.CommsManager.UserService; m_userService = m_scene.CommsManager.UserService;
} }
protected void AddHttpHandlers(Scene m_scene) protected void AddHttpHandlers(Scene m_scene)
{ {
IAssetProviderPlugin m_assetProvider = ((AssetServerBase)m_scene.AssetCache.AssetServer).AssetProviderPlugin; IAssetProviderPlugin m_assetProvider = ((AssetServerBase)m_scene.AssetCache.AssetServer).AssetProviderPlugin;
m_scene.AddStreamHandler(new GetAssetStreamHandler(m_assetProvider)); m_scene.AddStreamHandler(new GetAssetStreamHandler(m_assetProvider));
m_scene.AddStreamHandler(new PostAssetStreamHandler(m_assetProvider)); m_scene.AddStreamHandler(new PostAssetStreamHandler(m_assetProvider));
} }
///// <summary> ///// <summary>
///// Check that the source of an inventory request is one that we trust. ///// Check that the source of an inventory request is one that we trust.
///// </summary> ///// </summary>
///// <param name="peer"></param> ///// <param name="peer"></param>
///// <returns></returns> ///// <returns></returns>
//public bool CheckTrustSource(IPEndPoint peer) //public bool CheckTrustSource(IPEndPoint peer)
//{ //{
// if (m_doLookup) // if (m_doLookup)
// { // {
// m_log.InfoFormat("[GRID AGENT INVENTORY]: Checking trusted source {0}", peer); // m_log.InfoFormat("[GRID AGENT INVENTORY]: Checking trusted source {0}", peer);
// UriBuilder ub = new UriBuilder(m_userserver_url); // UriBuilder ub = new UriBuilder(m_userserver_url);
// IPAddress[] uaddrs = Dns.GetHostAddresses(ub.Host); // IPAddress[] uaddrs = Dns.GetHostAddresses(ub.Host);
// foreach (IPAddress uaddr in uaddrs) // foreach (IPAddress uaddr in uaddrs)
// { // {
// if (uaddr.Equals(peer.Address)) // if (uaddr.Equals(peer.Address))
// { // {
// return true; // return true;
// } // }
// } // }
// m_log.WarnFormat( // m_log.WarnFormat(
// "[GRID AGENT INVENTORY]: Rejecting request since source {0} was not in the list of trusted sources", // "[GRID AGENT INVENTORY]: Rejecting request since source {0} was not in the list of trusted sources",
// peer); // peer);
// return false; // return false;
// } // }
// else // else
// { // {
// return true; // return true;
// } // }
//} //}
/// <summary> /// <summary>
/// Check that the source of an inventory request for a particular agent is a current session belonging to /// Check that the source of an inventory request for a particular agent is a current session belonging to
/// that agent. /// that agent.
/// </summary> /// </summary>
/// <param name="session_id"></param> /// <param name="session_id"></param>
/// <param name="avatar_id"></param> /// <param name="avatar_id"></param>
/// <returns></returns> /// <returns></returns>
public bool CheckAuthSession(string session_id, string avatar_id) public bool CheckAuthSession(string session_id, string avatar_id)
{ {
if (m_doLookup) if (m_doLookup)
{ {
m_log.InfoFormat("[HGStandaloneInvService]: checking authed session {0} {1}", session_id, avatar_id); m_log.InfoFormat("[HGStandaloneInvService]: checking authed session {0} {1}", session_id, avatar_id);
UUID userID = UUID.Zero; UUID userID = UUID.Zero;
UUID sessionID = UUID.Zero; UUID sessionID = UUID.Zero;
UUID.TryParse(avatar_id, out userID); UUID.TryParse(avatar_id, out userID);
UUID.TryParse(session_id, out sessionID); UUID.TryParse(session_id, out sessionID);
if (userID.Equals(UUID.Zero) || sessionID.Equals(UUID.Zero)) if (userID.Equals(UUID.Zero) || sessionID.Equals(UUID.Zero))
{ {
m_log.Info("[HGStandaloneInvService]: Invalid user or session id " + avatar_id + "; " + session_id); m_log.Info("[HGStandaloneInvService]: Invalid user or session id " + avatar_id + "; " + session_id);
return false; return false;
} }
UserProfileData userProfile = m_userService.GetUserProfile(userID); UserProfileData userProfile = m_userService.GetUserProfile(userID);
if (userProfile != null && userProfile.CurrentAgent != null && if (userProfile != null && userProfile.CurrentAgent != null &&
userProfile.CurrentAgent.SessionID == sessionID) userProfile.CurrentAgent.SessionID == sessionID)
{ {
m_log.Info("[HGStandaloneInvService]: user is logged in and session is valid. Authorizing access."); m_log.Info("[HGStandaloneInvService]: user is logged in and session is valid. Authorizing access.");
return true; return true;
} }
m_log.Warn("[HGStandaloneInvService]: unknown user or session_id, request rejected"); m_log.Warn("[HGStandaloneInvService]: unknown user or session_id, request rejected");
return false; return false;
} }
else else
{ {
return true; return true;
} }
} }
} }
} }

630
OpenSim/Region/Environment/Modules/Hypergrid/HGStandaloneInventoryService.cs
View File

@ -1,316 +1,316 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Net; using System.Net;
using System.Reflection; using System.Reflection;
using log4net; using log4net;
using Nini.Config; using Nini.Config;
using OpenMetaverse; using OpenMetaverse;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications; using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers; using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Interfaces; using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Scenes;
namespace OpenSim.Region.Environment.Modules.Hypergrid namespace OpenSim.Region.Environment.Modules.Hypergrid
{ {
public class HGStandaloneInventoryService : IRegionModule public class HGStandaloneInventoryService : IRegionModule
{ {
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private static bool initialized = false; private static bool initialized = false;
private static bool enabled = false; private static bool enabled = false;
Scene m_scene; Scene m_scene;
//InventoryService m_inventoryService; //InventoryService m_inventoryService;
#region IRegionModule interface #region IRegionModule interface
public void Initialise(Scene scene, IConfigSource config) public void Initialise(Scene scene, IConfigSource config)
{ {
if (!initialized) if (!initialized)
{ {
initialized = true; initialized = true;
m_scene = scene; m_scene = scene;
// This module is only on for standalones // This module is only on for standalones
enabled = !config.Configs["Startup"].GetBoolean("gridmode", true) && config.Configs["Startup"].GetBoolean("hypergrid", false); enabled = !config.Configs["Startup"].GetBoolean("gridmode", true) && config.Configs["Startup"].GetBoolean("hypergrid", false);
} }
} }
public void PostInitialise() public void PostInitialise()
{ {
if (enabled) if (enabled)
{ {
m_log.Info("[HGStandaloneInvService]: Starting..."); m_log.Info("[HGStandaloneInvService]: Starting...");
//m_inventoryService = new InventoryService(m_scene); //m_inventoryService = new InventoryService(m_scene);
new InventoryService(m_scene); new InventoryService(m_scene);
} }
} }
public void Close() public void Close()
{ {
} }
public string Name public string Name
{ {
get { return "HGStandaloneInventoryService"; } get { return "HGStandaloneInventoryService"; }
} }
public bool IsSharedModule public bool IsSharedModule
{ {
get { return true; } get { return true; }
} }
#endregion #endregion
} }
public class InventoryService public class InventoryService
{ {
private InventoryServiceBase m_inventoryService; private InventoryServiceBase m_inventoryService;
private IUserService m_userService; private IUserService m_userService;
private bool m_doLookup = false; private bool m_doLookup = false;
public bool DoLookup public bool DoLookup
{ {
get { return m_doLookup; } get { return m_doLookup; }
set { m_doLookup = value; } set { m_doLookup = value; }
} }
private static readonly ILog m_log private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
public InventoryService(Scene m_scene) public InventoryService(Scene m_scene)
{ {
m_inventoryService = (InventoryServiceBase)m_scene.CommsManager.SecureInventoryService; m_inventoryService = (InventoryServiceBase)m_scene.CommsManager.SecureInventoryService;
m_userService = m_scene.CommsManager.UserService; m_userService = m_scene.CommsManager.UserService;
AddHttpHandlers(m_scene); AddHttpHandlers(m_scene);
} }
protected void AddHttpHandlers(Scene m_scene) protected void AddHttpHandlers(Scene m_scene)
{ {
m_scene.AddStreamHandler( m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<Guid, InventoryCollection>( new RestDeserialiseSecureHandler<Guid, InventoryCollection>(
"POST", "/GetInventory/", GetUserInventory, CheckAuthSession)); "POST", "/GetInventory/", GetUserInventory, CheckAuthSession));
m_scene.AddStreamHandler( m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>( new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/NewFolder/", m_inventoryService.AddFolder, CheckAuthSession)); "POST", "/NewFolder/", m_inventoryService.AddFolder, CheckAuthSession));
m_scene.AddStreamHandler( m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>( new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/UpdateFolder/", m_inventoryService.UpdateFolder, CheckAuthSession)); "POST", "/UpdateFolder/", m_inventoryService.UpdateFolder, CheckAuthSession));
m_scene.AddStreamHandler( m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>( new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/MoveFolder/", m_inventoryService.MoveFolder, CheckAuthSession)); "POST", "/MoveFolder/", m_inventoryService.MoveFolder, CheckAuthSession));
m_scene.AddStreamHandler( m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>( new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/PurgeFolder/", m_inventoryService.PurgeFolder, CheckAuthSession)); "POST", "/PurgeFolder/", m_inventoryService.PurgeFolder, CheckAuthSession));
m_scene.AddStreamHandler( m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryItemBase, bool>( new RestDeserialiseSecureHandler<InventoryItemBase, bool>(
"POST", "/NewItem/", m_inventoryService.AddItem, CheckAuthSession)); "POST", "/NewItem/", m_inventoryService.AddItem, CheckAuthSession));
m_scene.AddStreamHandler( m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryItemBase, bool>( new RestDeserialiseSecureHandler<InventoryItemBase, bool>(
"POST", "/DeleteItem/", m_inventoryService.DeleteItem, CheckAuthSession)); "POST", "/DeleteItem/", m_inventoryService.DeleteItem, CheckAuthSession));
//// WARNING: Root folders no longer just delivers the root and immediate child folders (e.g //// WARNING: Root folders no longer just delivers the root and immediate child folders (e.g
//// system folders such as Objects, Textures), but it now returns the entire inventory skeleton. //// system folders such as Objects, Textures), but it now returns the entire inventory skeleton.
//// It would have been better to rename this request, but complexities in the BaseHttpServer //// It would have been better to rename this request, but complexities in the BaseHttpServer
//// (e.g. any http request not found is automatically treated as an xmlrpc request) make it easier //// (e.g. any http request not found is automatically treated as an xmlrpc request) make it easier
//// to do this for now. //// to do this for now.
//m_scene.AddStreamHandler( //m_scene.AddStreamHandler(
// new RestDeserialiseTrustedHandler<Guid, List<InventoryFolderBase>> // new RestDeserialiseTrustedHandler<Guid, List<InventoryFolderBase>>
// ("POST", "/RootFolders/", GetInventorySkeleton, CheckTrustSource)); // ("POST", "/RootFolders/", GetInventorySkeleton, CheckTrustSource));
//// for persistent active gestures //// for persistent active gestures
//m_scene.AddStreamHandler( //m_scene.AddStreamHandler(
// new RestDeserialiseTrustedHandler<Guid, List<InventoryItemBase>> // new RestDeserialiseTrustedHandler<Guid, List<InventoryItemBase>>
// ("POST", "/ActiveGestures/", GetActiveGestures, CheckTrustSource)); // ("POST", "/ActiveGestures/", GetActiveGestures, CheckTrustSource));
} }
///// <summary> ///// <summary>
///// Check that the source of an inventory request is one that we trust. ///// Check that the source of an inventory request is one that we trust.
///// </summary> ///// </summary>
///// <param name="peer"></param> ///// <param name="peer"></param>
///// <returns></returns> ///// <returns></returns>
//public bool CheckTrustSource(IPEndPoint peer) //public bool CheckTrustSource(IPEndPoint peer)
//{ //{
// if (m_doLookup) // if (m_doLookup)
// { // {
// m_log.InfoFormat("[GRID AGENT INVENTORY]: Checking trusted source {0}", peer); // m_log.InfoFormat("[GRID AGENT INVENTORY]: Checking trusted source {0}", peer);
// UriBuilder ub = new UriBuilder(m_userserver_url); // UriBuilder ub = new UriBuilder(m_userserver_url);
// IPAddress[] uaddrs = Dns.GetHostAddresses(ub.Host); // IPAddress[] uaddrs = Dns.GetHostAddresses(ub.Host);
// foreach (IPAddress uaddr in uaddrs) // foreach (IPAddress uaddr in uaddrs)
// { // {
// if (uaddr.Equals(peer.Address)) // if (uaddr.Equals(peer.Address))
// { // {
// return true; // return true;
// } // }
// } // }
// m_log.WarnFormat( // m_log.WarnFormat(
// "[GRID AGENT INVENTORY]: Rejecting request since source {0} was not in the list of trusted sources", // "[GRID AGENT INVENTORY]: Rejecting request since source {0} was not in the list of trusted sources",
// peer); // peer);
// return false; // return false;
// } // }
// else // else
// { // {
// return true; // return true;
// } // }
//} //}
/// <summary> /// <summary>
/// Check that the source of an inventory request for a particular agent is a current session belonging to /// Check that the source of an inventory request for a particular agent is a current session belonging to
/// that agent. /// that agent.
/// </summary> /// </summary>
/// <param name="session_id"></param> /// <param name="session_id"></param>
/// <param name="avatar_id"></param> /// <param name="avatar_id"></param>
/// <returns></returns> /// <returns></returns>
public bool CheckAuthSession(string session_id, string avatar_id) public bool CheckAuthSession(string session_id, string avatar_id)
{ {
if (m_doLookup) if (m_doLookup)
{ {
m_log.InfoFormat("[HGStandaloneInvService]: checking authed session {0} {1}", session_id, avatar_id); m_log.InfoFormat("[HGStandaloneInvService]: checking authed session {0} {1}", session_id, avatar_id);
UUID userID = UUID.Zero; UUID userID = UUID.Zero;
UUID sessionID = UUID.Zero; UUID sessionID = UUID.Zero;
UUID.TryParse(avatar_id, out userID); UUID.TryParse(avatar_id, out userID);
UUID.TryParse(session_id, out sessionID); UUID.TryParse(session_id, out sessionID);
if (userID.Equals(UUID.Zero) || sessionID.Equals(UUID.Zero)) if (userID.Equals(UUID.Zero) || sessionID.Equals(UUID.Zero))
{ {
m_log.Info("[HGStandaloneInvService]: Invalid user or session id " + avatar_id + "; " + session_id); m_log.Info("[HGStandaloneInvService]: Invalid user or session id " + avatar_id + "; " + session_id);
return false; return false;
} }
UserProfileData userProfile = m_userService.GetUserProfile(userID); UserProfileData userProfile = m_userService.GetUserProfile(userID);
if (userProfile != null && userProfile.CurrentAgent != null && if (userProfile != null && userProfile.CurrentAgent != null &&
userProfile.CurrentAgent.SessionID == sessionID) userProfile.CurrentAgent.SessionID == sessionID)
{ {
m_log.Info("[HGStandaloneInvService]: user is logged in and session is valid. Authorizing access."); m_log.Info("[HGStandaloneInvService]: user is logged in and session is valid. Authorizing access.");
return true; return true;
} }
m_log.Warn("[HGStandaloneInvService]: unknown user or session_id, request rejected"); m_log.Warn("[HGStandaloneInvService]: unknown user or session_id, request rejected");
return false; return false;
} }
else else
{ {
return true; return true;
} }
} }
/// <summary> /// <summary>
/// Return a user's entire inventory /// Return a user's entire inventory
/// </summary> /// </summary>
/// <param name="rawUserID"></param> /// <param name="rawUserID"></param>
/// <returns>The user's inventory. If an inventory cannot be found then an empty collection is returned.</returns> /// <returns>The user's inventory. If an inventory cannot be found then an empty collection is returned.</returns>
public InventoryCollection GetUserInventory(Guid rawUserID) public InventoryCollection GetUserInventory(Guid rawUserID)
{ {
UUID userID = new UUID(rawUserID); UUID userID = new UUID(rawUserID);
m_log.Info("[HGStandaloneInvService]: Processing request for inventory of " + userID); m_log.Info("[HGStandaloneInvService]: Processing request for inventory of " + userID);
// Uncomment me to simulate a slow responding inventory server // Uncomment me to simulate a slow responding inventory server
//Thread.Sleep(16000); //Thread.Sleep(16000);
InventoryCollection invCollection = new InventoryCollection(); InventoryCollection invCollection = new InventoryCollection();
List<InventoryFolderBase> allFolders = ((InventoryServiceBase)m_inventoryService).GetInventorySkeleton(userID); List<InventoryFolderBase> allFolders = ((InventoryServiceBase)m_inventoryService).GetInventorySkeleton(userID);
if (null == allFolders) if (null == allFolders)
{ {
m_log.WarnFormat("[HGStandaloneInvService]: No inventory found for user {0}", rawUserID); m_log.WarnFormat("[HGStandaloneInvService]: No inventory found for user {0}", rawUserID);
return invCollection; return invCollection;
} }
List<InventoryItemBase> allItems = new List<InventoryItemBase>(); List<InventoryItemBase> allItems = new List<InventoryItemBase>();
foreach (InventoryFolderBase folder in allFolders) foreach (InventoryFolderBase folder in allFolders)
{ {
List<InventoryItemBase> items = ((InventoryServiceBase)m_inventoryService).RequestFolderItems(folder.ID); List<InventoryItemBase> items = ((InventoryServiceBase)m_inventoryService).RequestFolderItems(folder.ID);
if (items != null) if (items != null)
{ {
allItems.InsertRange(0, items); allItems.InsertRange(0, items);
} }
} }
invCollection.UserID = userID; invCollection.UserID = userID;
invCollection.Folders = allFolders; invCollection.Folders = allFolders;
invCollection.Items = allItems; invCollection.Items = allItems;
// foreach (InventoryFolderBase folder in invCollection.Folders) // foreach (InventoryFolderBase folder in invCollection.Folders)
// { // {
// m_log.DebugFormat("[GRID AGENT INVENTORY]: Sending back folder {0} {1}", folder.Name, folder.ID); // m_log.DebugFormat("[GRID AGENT INVENTORY]: Sending back folder {0} {1}", folder.Name, folder.ID);
// } // }
// //
// foreach (InventoryItemBase item in invCollection.Items) // foreach (InventoryItemBase item in invCollection.Items)
// { // {
// m_log.DebugFormat("[GRID AGENT INVENTORY]: Sending back item {0} {1}, folder {2}", item.Name, item.ID, item.Folder); // m_log.DebugFormat("[GRID AGENT INVENTORY]: Sending back item {0} {1}, folder {2}", item.Name, item.ID, item.Folder);
// } // }
m_log.InfoFormat( m_log.InfoFormat(
"[HGStandaloneInvService]: Sending back inventory response to user {0} containing {1} folders and {2} items", "[HGStandaloneInvService]: Sending back inventory response to user {0} containing {1} folders and {2} items",
invCollection.UserID, invCollection.Folders.Count, invCollection.Items.Count); invCollection.UserID, invCollection.Folders.Count, invCollection.Items.Count);
return invCollection; return invCollection;
} }
/// <summary> /// <summary>
/// Guid to UUID wrapper for same name IInventoryServices method /// Guid to UUID wrapper for same name IInventoryServices method
/// </summary> /// </summary>
/// <param name="rawUserID"></param> /// <param name="rawUserID"></param>
/// <returns></returns> /// <returns></returns>
public List<InventoryFolderBase> GetInventorySkeleton(Guid rawUserID) public List<InventoryFolderBase> GetInventorySkeleton(Guid rawUserID)
{ {
UUID userID = new UUID(rawUserID); UUID userID = new UUID(rawUserID);
return ((InventoryServiceBase)m_inventoryService).GetInventorySkeleton(userID); return ((InventoryServiceBase)m_inventoryService).GetInventorySkeleton(userID);
} }
public List<InventoryItemBase> GetActiveGestures(Guid rawUserID) public List<InventoryItemBase> GetActiveGestures(Guid rawUserID)
{ {
UUID userID = new UUID(rawUserID); UUID userID = new UUID(rawUserID);
m_log.InfoFormat("[HGStandaloneInvService]: fetching active gestures for user {0}", userID); m_log.InfoFormat("[HGStandaloneInvService]: fetching active gestures for user {0}", userID);
return ((InventoryServiceBase)m_inventoryService).GetActiveGestures(userID); return ((InventoryServiceBase)m_inventoryService).GetActiveGestures(userID);
} }
} }
} }

356
OpenSim/Region/Environment/Modules/Hypergrid/HGWorldMapModule.cs
View File

@ -1,178 +1,178 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.Drawing; using System.Drawing;
using System.Drawing.Imaging; using System.Drawing.Imaging;
using System.IO; using System.IO;
using System.Net; using System.Net;
using System.Reflection; using System.Reflection;
using System.Threading; using System.Threading;
using OpenMetaverse; using OpenMetaverse;
using OpenMetaverse.Imaging; using OpenMetaverse.Imaging;
using OpenMetaverse.StructuredData; using OpenMetaverse.StructuredData;
using log4net; using log4net;
using Nini.Config; using Nini.Config;
using Nwc.XmlRpc; using Nwc.XmlRpc;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Communications.Capabilities; using OpenSim.Framework.Communications.Capabilities;
using OpenSim.Framework.Servers; using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Interfaces; using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Modules.World.WorldMap; using OpenSim.Region.Environment.Modules.World.WorldMap;
using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Environment.Types; using OpenSim.Region.Environment.Types;
using Caps = OpenSim.Framework.Communications.Capabilities.Caps; using Caps = OpenSim.Framework.Communications.Capabilities.Caps;
using OSD = OpenMetaverse.StructuredData.OSD; using OSD = OpenMetaverse.StructuredData.OSD;
using OSDMap = OpenMetaverse.StructuredData.OSDMap; using OSDMap = OpenMetaverse.StructuredData.OSDMap;
using OSDArray = OpenMetaverse.StructuredData.OSDArray; using OSDArray = OpenMetaverse.StructuredData.OSDArray;
namespace OpenSim.Region.Environment.Modules.Hypergrid namespace OpenSim.Region.Environment.Modules.Hypergrid
{ {
public class HGWorldMapModule : WorldMapModule, IRegionModule public class HGWorldMapModule : WorldMapModule, IRegionModule
{ {
private static readonly ILog m_log = private static readonly ILog m_log =
LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
#region IRegionModule Members #region IRegionModule Members
public override void Initialise(Scene scene, IConfigSource config) public override void Initialise(Scene scene, IConfigSource config)
{ {
IConfig startupConfig = config.Configs["Startup"]; IConfig startupConfig = config.Configs["Startup"];
if (startupConfig.GetString("WorldMapModule", "WorldMap") == "HGWorldMap") if (startupConfig.GetString("WorldMapModule", "WorldMap") == "HGWorldMap")
m_Enabled = true; m_Enabled = true;
if (!m_Enabled) if (!m_Enabled)
return; return;
m_log.Info("[HGMap] Initializing..."); m_log.Info("[HGMap] Initializing...");
m_scene = scene; m_scene = scene;
} }
public override string Name public override string Name
{ {
get { return "HGWorldMap"; } get { return "HGWorldMap"; }
} }
#endregion #endregion
/// <summary> /// <summary>
/// Requests map blocks in area of minX, maxX, minY, MaxY in world cordinates /// Requests map blocks in area of minX, maxX, minY, MaxY in world cordinates
/// </summary> /// </summary>
/// <param name="minX"></param> /// <param name="minX"></param>
/// <param name="minY"></param> /// <param name="minY"></param>
/// <param name="maxX"></param> /// <param name="maxX"></param>
/// <param name="maxY"></param> /// <param name="maxY"></param>
public override void RequestMapBlocks(IClientAPI remoteClient, int minX, int minY, int maxX, int maxY, uint flag) public override void RequestMapBlocks(IClientAPI remoteClient, int minX, int minY, int maxX, int maxY, uint flag)
{ {
// //
// WARNING!!! COPY & PASTE FROM SUPERCLASS // WARNING!!! COPY & PASTE FROM SUPERCLASS
// The only difference is at the very end // The only difference is at the very end
// //
m_log.Info("[HGMap]: Request map blocks " + minX + "-" + maxX + " " + minY + "-" + maxY); m_log.Info("[HGMap]: Request map blocks " + minX + "-" + maxX + " " + minY + "-" + maxY);
//m_scene.ForEachScenePresence(delegate (ScenePresence sp) { //m_scene.ForEachScenePresence(delegate (ScenePresence sp) {
// if (!sp.IsChildAgent && sp.UUID == remoteClient.AgentId) // if (!sp.IsChildAgent && sp.UUID == remoteClient.AgentId)
// { // {
// Console.WriteLine("XXX Root agent"); // Console.WriteLine("XXX Root agent");
// DoRequestMapBlocks(remoteClient, minX, minY, maxX, maxY, flag); // DoRequestMapBlocks(remoteClient, minX, minY, maxX, maxY, flag);
// } // }
//}; //};
List<MapBlockData> mapBlocks; List<MapBlockData> mapBlocks;
if ((flag & 0x10000) != 0) // user clicked on the map a tile that isn't visible if ((flag & 0x10000) != 0) // user clicked on the map a tile that isn't visible
{ {
List<MapBlockData> response = new List<MapBlockData>(); List<MapBlockData> response = new List<MapBlockData>();
// this should return one mapblock at most. But make sure: Look whether the one we requested is in there // this should return one mapblock at most. But make sure: Look whether the one we requested is in there
mapBlocks = m_scene.SceneGridService.RequestNeighbourMapBlocks(minX, minY, maxX, maxY); mapBlocks = m_scene.SceneGridService.RequestNeighbourMapBlocks(minX, minY, maxX, maxY);
if (mapBlocks != null) if (mapBlocks != null)
{ {
foreach (MapBlockData block in mapBlocks) foreach (MapBlockData block in mapBlocks)
{ {
if (block.X == minX && block.Y == minY) if (block.X == minX && block.Y == minY)
{ {
// found it => add it to response // found it => add it to response
response.Add(block); response.Add(block);
break; break;
} }
} }
} }
response = mapBlocks; response = mapBlocks;
if (response.Count == 0) if (response.Count == 0)
{ {
// response still empty => couldn't find the map-tile the user clicked on => tell the client // response still empty => couldn't find the map-tile the user clicked on => tell the client
MapBlockData block = new MapBlockData(); MapBlockData block = new MapBlockData();
block.X = (ushort)minX; block.X = (ushort)minX;
block.Y = (ushort)minY; block.Y = (ushort)minY;
block.Access = 254; // == not there block.Access = 254; // == not there
response.Add(block); response.Add(block);
} }
remoteClient.SendMapBlock(response, 0); remoteClient.SendMapBlock(response, 0);
} }
else else
{ {
// normal mapblock request. Use the provided values // normal mapblock request. Use the provided values
mapBlocks = m_scene.SceneGridService.RequestNeighbourMapBlocks(minX - 4, minY - 4, maxX + 4, maxY + 4); mapBlocks = m_scene.SceneGridService.RequestNeighbourMapBlocks(minX - 4, minY - 4, maxX + 4, maxY + 4);
// Different from super // Different from super
FillInMap(mapBlocks, minX, minY, maxX, maxY); FillInMap(mapBlocks, minX, minY, maxX, maxY);
// //
remoteClient.SendMapBlock(mapBlocks, flag); remoteClient.SendMapBlock(mapBlocks, flag);
} }
} }
private void FillInMap(List<MapBlockData> mapBlocks, int minX, int minY, int maxX, int maxY) private void FillInMap(List<MapBlockData> mapBlocks, int minX, int minY, int maxX, int maxY)
{ {
for (int x = minX; x <= maxX; x++) for (int x = minX; x <= maxX; x++)
for (int y = minY; y <= maxY; y++) for (int y = minY; y <= maxY; y++)
{ {
MapBlockData mblock = mapBlocks.Find(delegate(MapBlockData mb) { return ((mb.X == x) && (mb.Y == y)); }); MapBlockData mblock = mapBlocks.Find(delegate(MapBlockData mb) { return ((mb.X == x) && (mb.Y == y)); });
if (mblock == null) if (mblock == null)
{ {
mblock = new MapBlockData(); mblock = new MapBlockData();
mblock.X = (ushort)x; mblock.X = (ushort)x;
mblock.Y = (ushort)y; mblock.Y = (ushort)y;
mblock.Name = ""; mblock.Name = "";
mblock.Access = 254; // not here??? mblock.Access = 254; // not here???
mblock.MapImageId = UUID.Zero; mblock.MapImageId = UUID.Zero;
mapBlocks.Add(mblock); mapBlocks.Add(mblock);
} }
} }
} }
} }
} }

364
OpenSim/Region/Environment/Scenes/EntityManager.cs
View File

@ -1,182 +1,182 @@
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using OpenMetaverse; using OpenMetaverse;
namespace OpenSim.Region.Environment.Scenes namespace OpenSim.Region.Environment.Scenes
{ {
public class EntityManager : IEnumerable<EntityBase> public class EntityManager : IEnumerable<EntityBase>
{ {
private readonly Dictionary<UUID,EntityBase> m_eb_uuid = new Dictionary<UUID, EntityBase>(); private readonly Dictionary<UUID,EntityBase> m_eb_uuid = new Dictionary<UUID, EntityBase>();
private readonly Dictionary<uint, EntityBase> m_eb_localID = new Dictionary<uint, EntityBase>(); private readonly Dictionary<uint, EntityBase> m_eb_localID = new Dictionary<uint, EntityBase>();
private readonly Object m_lock = new Object(); private readonly Object m_lock = new Object();
[Obsolete("Use Add() instead.")] [Obsolete("Use Add() instead.")]
public void Add(UUID id, EntityBase eb) public void Add(UUID id, EntityBase eb)
{ {
Add(eb); Add(eb);
} }
public void Add(EntityBase entity) public void Add(EntityBase entity)
{ {
lock(m_lock) lock(m_lock)
{ {
m_eb_uuid.Add(entity.UUID, entity); m_eb_uuid.Add(entity.UUID, entity);
m_eb_localID.Add(entity.LocalId, entity); m_eb_localID.Add(entity.LocalId, entity);
} }
} }
public void InsertOrReplace(EntityBase entity) public void InsertOrReplace(EntityBase entity)
{ {
lock(m_lock) lock(m_lock)
{ {
m_eb_uuid[entity.UUID] = entity; m_eb_uuid[entity.UUID] = entity;
m_eb_localID[entity.LocalId] = entity; m_eb_localID[entity.LocalId] = entity;
} }
} }
public void Clear() public void Clear()
{ {
lock (m_lock) lock (m_lock)
{ {
m_eb_uuid.Clear(); m_eb_uuid.Clear();
m_eb_localID.Clear(); m_eb_localID.Clear();
} }
} }
public int Count public int Count
{ {
get get
{ {
lock (m_lock) lock (m_lock)
{ {
return m_eb_uuid.Count; return m_eb_uuid.Count;
} }
} }
} }
public bool ContainsKey(UUID id) public bool ContainsKey(UUID id)
{ {
lock(m_lock) lock(m_lock)
{ {
return m_eb_uuid.ContainsKey(id); return m_eb_uuid.ContainsKey(id);
} }
} }
public bool ContainsKey(uint localID) public bool ContainsKey(uint localID)
{ {
lock (m_lock) lock (m_lock)
{ {
return m_eb_localID.ContainsKey(localID); return m_eb_localID.ContainsKey(localID);
} }
} }
public bool Remove(uint localID) public bool Remove(uint localID)
{ {
lock(m_lock) lock(m_lock)
{ {
bool a = m_eb_uuid.Remove(m_eb_localID[localID].UUID); bool a = m_eb_uuid.Remove(m_eb_localID[localID].UUID);
bool b = m_eb_localID.Remove(localID); bool b = m_eb_localID.Remove(localID);
return a && b; return a && b;
} }
} }
public bool Remove(UUID id) public bool Remove(UUID id)
{ {
lock(m_lock) lock(m_lock)
{ {
bool a = m_eb_localID.Remove(m_eb_uuid[id].LocalId); bool a = m_eb_localID.Remove(m_eb_uuid[id].LocalId);
bool b = m_eb_uuid.Remove(id); bool b = m_eb_uuid.Remove(id);
return a && b; return a && b;
} }
} }
public List<EntityBase> GetAllByType<T>() public List<EntityBase> GetAllByType<T>()
{ {
List<EntityBase> tmp = new List<EntityBase>(); List<EntityBase> tmp = new List<EntityBase>();
lock(m_lock) lock(m_lock)
{ {
foreach (KeyValuePair<UUID, EntityBase> pair in m_eb_uuid) foreach (KeyValuePair<UUID, EntityBase> pair in m_eb_uuid)
{ {
if(pair.Value is T) if(pair.Value is T)
{ {
tmp.Add(pair.Value); tmp.Add(pair.Value);
} }
} }
} }
return tmp; return tmp;
} }
public List<EntityBase> GetEntities() public List<EntityBase> GetEntities()
{ {
lock (m_lock) lock (m_lock)
{ {
return new List<EntityBase>(m_eb_uuid.Values); return new List<EntityBase>(m_eb_uuid.Values);
} }
} }
public EntityBase this[UUID id] public EntityBase this[UUID id]
{ {
get get
{ {
lock (m_lock) lock (m_lock)
{ {
return m_eb_uuid[id]; return m_eb_uuid[id];
} }
} }
set set
{ {
InsertOrReplace(value); InsertOrReplace(value);
} }
} }
public EntityBase this[uint localID] public EntityBase this[uint localID]
{ {
get get
{ {
lock (m_lock) lock (m_lock)
{ {
return m_eb_localID[localID]; return m_eb_localID[localID];
} }
} }
set set
{ {
InsertOrReplace(value); InsertOrReplace(value);
} }
} }
public bool TryGetValue(UUID key, out EntityBase obj) public bool TryGetValue(UUID key, out EntityBase obj)
{ {
lock(m_lock) lock(m_lock)
{ {
return m_eb_uuid.TryGetValue(key, out obj); return m_eb_uuid.TryGetValue(key, out obj);
} }
} }
public bool TryGetValue(uint key, out EntityBase obj) public bool TryGetValue(uint key, out EntityBase obj)
{ {
lock (m_lock) lock (m_lock)
{ {
return m_eb_localID.TryGetValue(key, out obj); return m_eb_localID.TryGetValue(key, out obj);
} }
} }
/// <summary> /// <summary>
/// This could be optimised to work on the list 'live' rather than making a safe copy and iterating that. /// This could be optimised to work on the list 'live' rather than making a safe copy and iterating that.
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
public IEnumerator<EntityBase> GetEnumerator() public IEnumerator<EntityBase> GetEnumerator()
{ {
return GetEntities().GetEnumerator(); return GetEntities().GetEnumerator();
} }
IEnumerator IEnumerable.GetEnumerator() IEnumerator IEnumerable.GetEnumerator()
{ {
return GetEnumerator(); return GetEnumerator();
} }
} }
} }

754
OpenSim/Region/Environment/Scenes/Hypergrid/HGAssetMapper.cs
View File

@ -1,377 +1,377 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.Reflection; using System.Reflection;
using System.Threading; using System.Threading;
using log4net; using log4net;
using Nini.Config; using Nini.Config;
using OpenMetaverse; using OpenMetaverse;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications; using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers; using OpenSim.Framework.Servers;
using OpenSim.Region.Environment; using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Scenes;
//using HyperGrid.Framework; //using HyperGrid.Framework;
//using OpenSim.Region.Communications.Hypergrid; //using OpenSim.Region.Communications.Hypergrid;
namespace OpenSim.Region.Environment.Scenes.Hypergrid namespace OpenSim.Region.Environment.Scenes.Hypergrid
{ {
public class HGAssetMapper public class HGAssetMapper
{ {
#region Fields #region Fields
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
// This maps between asset server URLs and asset server clients // This maps between asset server URLs and asset server clients
private Dictionary<string, GridAssetClient> m_assetServers = new Dictionary<string, GridAssetClient>(); private Dictionary<string, GridAssetClient> m_assetServers = new Dictionary<string, GridAssetClient>();
// This maps between asset UUIDs and asset servers // This maps between asset UUIDs and asset servers
private Dictionary<UUID, GridAssetClient> m_assetMap = new Dictionary<UUID, GridAssetClient>(); private Dictionary<UUID, GridAssetClient> m_assetMap = new Dictionary<UUID, GridAssetClient>();
private Scene m_scene; private Scene m_scene;
#endregion #endregion
#region Constructor #region Constructor
public HGAssetMapper(Scene scene) public HGAssetMapper(Scene scene)
{ {
m_scene = scene; m_scene = scene;
} }
#endregion #endregion
#region Internal functions #region Internal functions
private string UserAssetURL(UUID userID) private string UserAssetURL(UUID userID)
{ {
CachedUserInfo uinfo = m_scene.CommsManager.UserProfileCacheService.GetUserDetails(userID); CachedUserInfo uinfo = m_scene.CommsManager.UserProfileCacheService.GetUserDetails(userID);
if (uinfo != null) if (uinfo != null)
return (uinfo.UserProfile.UserAssetURI == "") ? null : uinfo.UserProfile.UserAssetURI; return (uinfo.UserProfile.UserAssetURI == "") ? null : uinfo.UserProfile.UserAssetURI;
return null; return null;
} }
private bool IsHomeUser(UUID userID) private bool IsHomeUser(UUID userID)
{ {
CachedUserInfo uinfo = m_scene.CommsManager.UserProfileCacheService.GetUserDetails(userID); CachedUserInfo uinfo = m_scene.CommsManager.UserProfileCacheService.GetUserDetails(userID);
if (uinfo != null) if (uinfo != null)
{ {
//if ((uinfo.UserProfile.UserAssetURI == null) || (uinfo.UserProfile.UserAssetURI == "") || //if ((uinfo.UserProfile.UserAssetURI == null) || (uinfo.UserProfile.UserAssetURI == "") ||
// uinfo.UserProfile.UserAssetURI.Equals(m_scene.CommsManager.NetworkServersInfo.AssetURL)) // uinfo.UserProfile.UserAssetURI.Equals(m_scene.CommsManager.NetworkServersInfo.AssetURL))
if (HGNetworkServersInfo.Singleton.IsLocalUser(uinfo.UserProfile.UserAssetURI)) if (HGNetworkServersInfo.Singleton.IsLocalUser(uinfo.UserProfile.UserAssetURI))
{ {
m_log.Debug("[HGScene]: Home user " + uinfo.UserProfile.FirstName + " " + uinfo.UserProfile.SurName); m_log.Debug("[HGScene]: Home user " + uinfo.UserProfile.FirstName + " " + uinfo.UserProfile.SurName);
return true; return true;
} }
} }
m_log.Debug("[HGScene]: Foreign user " + uinfo.UserProfile.FirstName + " " + uinfo.UserProfile.SurName); m_log.Debug("[HGScene]: Foreign user " + uinfo.UserProfile.FirstName + " " + uinfo.UserProfile.SurName);
return false; return false;
} }
private bool IsInAssetMap(UUID uuid) private bool IsInAssetMap(UUID uuid)
{ {
return m_assetMap.ContainsKey(uuid); return m_assetMap.ContainsKey(uuid);
} }
private bool FetchAsset(GridAssetClient asscli, UUID assetID, bool isTexture) private bool FetchAsset(GridAssetClient asscli, UUID assetID, bool isTexture)
{ {
// I'm not going over 3 seconds since this will be blocking processing of all the other inbound // I'm not going over 3 seconds since this will be blocking processing of all the other inbound
// packets from the client. // packets from the client.
int pollPeriod = 200; int pollPeriod = 200;
int maxPolls = 15; int maxPolls = 15;
AssetBase asset; AssetBase asset;
// Maybe it came late, and it's already here. Check first. // Maybe it came late, and it's already here. Check first.
if (m_scene.CommsManager.AssetCache.TryGetCachedAsset(assetID, out asset)) if (m_scene.CommsManager.AssetCache.TryGetCachedAsset(assetID, out asset))
{ {
m_log.Debug("[HGScene]: Asset already in asset cache. " + assetID); m_log.Debug("[HGScene]: Asset already in asset cache. " + assetID);
return true; return true;
} }
asscli.RequestAsset(assetID, isTexture); asscli.RequestAsset(assetID, isTexture);
do do
{ {
Thread.Sleep(pollPeriod); Thread.Sleep(pollPeriod);
if (m_scene.CommsManager.AssetCache.TryGetCachedAsset(assetID, out asset) && (asset != null)) if (m_scene.CommsManager.AssetCache.TryGetCachedAsset(assetID, out asset) && (asset != null))
{ {
m_log.Debug("[HGScene]: Asset made it to asset cache. " + asset.Name + " " + assetID); m_log.Debug("[HGScene]: Asset made it to asset cache. " + asset.Name + " " + assetID);
// I think I need to store it in the asset DB too. // I think I need to store it in the asset DB too.
// For now, let me just do it for textures and scripts // For now, let me just do it for textures and scripts
if (((AssetType)asset.Type == AssetType.Texture) || if (((AssetType)asset.Type == AssetType.Texture) ||
((AssetType)asset.Type == AssetType.LSLBytecode) || ((AssetType)asset.Type == AssetType.LSLBytecode) ||
((AssetType)asset.Type == AssetType.LSLText)) ((AssetType)asset.Type == AssetType.LSLText))
{ {
AssetBase asset1 = new AssetBase(); AssetBase asset1 = new AssetBase();
Copy(asset, asset1); Copy(asset, asset1);
m_scene.AssetCache.AssetServer.StoreAsset(asset1); m_scene.AssetCache.AssetServer.StoreAsset(asset1);
} }
return true; return true;
} }
} while (--maxPolls > 0); } while (--maxPolls > 0);
m_log.WarnFormat("[HGScene]: {0} {1} was not received before the retrieval timeout was reached", m_log.WarnFormat("[HGScene]: {0} {1} was not received before the retrieval timeout was reached",
isTexture ? "texture" : "asset", assetID.ToString()); isTexture ? "texture" : "asset", assetID.ToString());
return false; return false;
} }
private bool PostAsset(GridAssetClient asscli, UUID assetID) private bool PostAsset(GridAssetClient asscli, UUID assetID)
{ {
AssetBase asset1; AssetBase asset1;
m_scene.CommsManager.AssetCache.TryGetCachedAsset(assetID, out asset1); m_scene.CommsManager.AssetCache.TryGetCachedAsset(assetID, out asset1);
if (asset1 != null) if (asset1 != null)
{ {
// See long comment in AssetCache.AddAsset // See long comment in AssetCache.AddAsset
if (!asset1.Temporary || asset1.Local) if (!asset1.Temporary || asset1.Local)
{ {
// The asset cache returns instances of subclasses of AssetBase: // The asset cache returns instances of subclasses of AssetBase:
// TextureImage or AssetInfo. So in passing them to the remote // TextureImage or AssetInfo. So in passing them to the remote
// server we first need to convert this to instances of AssetBase, // server we first need to convert this to instances of AssetBase,
// which is the serializable class for assets. // which is the serializable class for assets.
AssetBase asset = new AssetBase(); AssetBase asset = new AssetBase();
Copy(asset1, asset); Copy(asset1, asset);
asscli.StoreAsset(asset); asscli.StoreAsset(asset);
} }
return true; return true;
} }
else else
m_log.Warn("[HGScene]: Tried to post asset to remote server, but asset not in local cache."); m_log.Warn("[HGScene]: Tried to post asset to remote server, but asset not in local cache.");
return false; return false;
} }
private void Copy(AssetBase from, AssetBase to) private void Copy(AssetBase from, AssetBase to)
{ {
to.Data = from.Data; to.Data = from.Data;
to.Description = from.Description; to.Description = from.Description;
to.FullID = from.FullID; to.FullID = from.FullID;
to.ID = from.ID; to.ID = from.ID;
to.Local = from.Local; to.Local = from.Local;
to.Name = from.Name; to.Name = from.Name;
to.Temporary = from.Temporary; to.Temporary = from.Temporary;
to.Type = from.Type; to.Type = from.Type;
} }
private void _guardedAdd(Dictionary<UUID, bool> lst, UUID obj, bool val) private void _guardedAdd(Dictionary<UUID, bool> lst, UUID obj, bool val)
{ {
if (!lst.ContainsKey(obj)) if (!lst.ContainsKey(obj))
lst.Add(obj, val); lst.Add(obj, val);
} }
private void SniffTextureUUIDs(Dictionary<UUID, bool> uuids, SceneObjectGroup sog) private void SniffTextureUUIDs(Dictionary<UUID, bool> uuids, SceneObjectGroup sog)
{ {
try try
{ {
_guardedAdd(uuids, sog.RootPart.Shape.Textures.DefaultTexture.TextureID, true); _guardedAdd(uuids, sog.RootPart.Shape.Textures.DefaultTexture.TextureID, true);
} }
catch (Exception) { } catch (Exception) { }
foreach (Primitive.TextureEntryFace tface in sog.RootPart.Shape.Textures.FaceTextures) foreach (Primitive.TextureEntryFace tface in sog.RootPart.Shape.Textures.FaceTextures)
{ {
try try
{ {
_guardedAdd(uuids, tface.TextureID, true); _guardedAdd(uuids, tface.TextureID, true);
} }
catch (Exception) { } catch (Exception) { }
} }
foreach (SceneObjectPart sop in sog.Children.Values) foreach (SceneObjectPart sop in sog.Children.Values)
{ {
try try
{ {
_guardedAdd(uuids, sop.Shape.Textures.DefaultTexture.TextureID, true); _guardedAdd(uuids, sop.Shape.Textures.DefaultTexture.TextureID, true);
} }
catch (Exception) { } catch (Exception) { }
foreach (Primitive.TextureEntryFace tface in sop.Shape.Textures.FaceTextures) foreach (Primitive.TextureEntryFace tface in sop.Shape.Textures.FaceTextures)
{ {
try try
{ {
_guardedAdd(uuids, tface.TextureID, true); _guardedAdd(uuids, tface.TextureID, true);
} }
catch (Exception) { } catch (Exception) { }
} }
} }
} }
private void SniffTaskInventoryUUIDs(Dictionary<UUID, bool> uuids, SceneObjectGroup sog) private void SniffTaskInventoryUUIDs(Dictionary<UUID, bool> uuids, SceneObjectGroup sog)
{ {
TaskInventoryDictionary tinv = sog.RootPart.TaskInventory; TaskInventoryDictionary tinv = sog.RootPart.TaskInventory;
foreach (TaskInventoryItem titem in tinv.Values) foreach (TaskInventoryItem titem in tinv.Values)
{ {
uuids.Add(titem.AssetID, (InventoryType)titem.Type == InventoryType.Texture); uuids.Add(titem.AssetID, (InventoryType)titem.Type == InventoryType.Texture);
} }
} }
private Dictionary<UUID, bool> SniffUUIDs(AssetBase asset) private Dictionary<UUID, bool> SniffUUIDs(AssetBase asset)
{ {
Dictionary<UUID, bool> uuids = new Dictionary<UUID, bool>(); Dictionary<UUID, bool> uuids = new Dictionary<UUID, bool>();
if ((asset != null) && ((AssetType)asset.Type == AssetType.Object)) if ((asset != null) && ((AssetType)asset.Type == AssetType.Object))
{ {
string ass_str = Utils.BytesToString(asset.Data); string ass_str = Utils.BytesToString(asset.Data);
SceneObjectGroup sog = new SceneObjectGroup(ass_str, true); SceneObjectGroup sog = new SceneObjectGroup(ass_str, true);
SniffTextureUUIDs(uuids, sog); SniffTextureUUIDs(uuids, sog);
// We need to sniff further... // We need to sniff further...
SniffTaskInventoryUUIDs(uuids, sog); SniffTaskInventoryUUIDs(uuids, sog);
} }
return uuids; return uuids;
} }
private Dictionary<UUID, bool> SniffUUIDs(UUID assetID) private Dictionary<UUID, bool> SniffUUIDs(UUID assetID)
{ {
//Dictionary<UUID, bool> uuids = new Dictionary<UUID, bool>(); //Dictionary<UUID, bool> uuids = new Dictionary<UUID, bool>();
AssetBase asset; AssetBase asset;
m_scene.CommsManager.AssetCache.TryGetCachedAsset(assetID, out asset); m_scene.CommsManager.AssetCache.TryGetCachedAsset(assetID, out asset);
return SniffUUIDs(asset); return SniffUUIDs(asset);
} }
private void Dump(Dictionary<UUID, bool> lst) private void Dump(Dictionary<UUID, bool> lst)
{ {
m_log.Debug("XXX -------- UUID DUMP ------- XXX"); m_log.Debug("XXX -------- UUID DUMP ------- XXX");
foreach (KeyValuePair<UUID, bool> kvp in lst) foreach (KeyValuePair<UUID, bool> kvp in lst)
m_log.Debug(" >> " + kvp.Key + " (texture? " + kvp.Value + ")"); m_log.Debug(" >> " + kvp.Key + " (texture? " + kvp.Value + ")");
m_log.Debug("XXX -------- UUID DUMP ------- XXX"); m_log.Debug("XXX -------- UUID DUMP ------- XXX");
} }
#endregion #endregion
#region Public interface #region Public interface
public void Get(UUID itemID, UUID ownerID) public void Get(UUID itemID, UUID ownerID)
{ {
if (!IsInAssetMap(itemID) && !IsHomeUser(ownerID)) if (!IsInAssetMap(itemID) && !IsHomeUser(ownerID))
{ {
// Get the item from the remote asset server onto the local AssetCache // Get the item from the remote asset server onto the local AssetCache
// and place an entry in m_assetMap // and place an entry in m_assetMap
GridAssetClient asscli = null; GridAssetClient asscli = null;
string userAssetURL = UserAssetURL(ownerID); string userAssetURL = UserAssetURL(ownerID);
if (userAssetURL != null) if (userAssetURL != null)
{ {
m_assetServers.TryGetValue(userAssetURL, out asscli); m_assetServers.TryGetValue(userAssetURL, out asscli);
if (asscli == null) if (asscli == null)
{ {
m_log.Debug("[HGScene]: Starting new GridAssetClient for " + userAssetURL); m_log.Debug("[HGScene]: Starting new GridAssetClient for " + userAssetURL);
asscli = new GridAssetClient(userAssetURL); asscli = new GridAssetClient(userAssetURL);
asscli.SetReceiver(m_scene.CommsManager.AssetCache); // Straight to the asset cache! asscli.SetReceiver(m_scene.CommsManager.AssetCache); // Straight to the asset cache!
m_assetServers.Add(userAssetURL, asscli); m_assetServers.Add(userAssetURL, asscli);
} }
m_log.Debug("[HGScene]: Fetching object " + itemID + " to asset server " + userAssetURL); m_log.Debug("[HGScene]: Fetching object " + itemID + " to asset server " + userAssetURL);
bool success = FetchAsset(asscli, itemID, false); // asscli.RequestAsset(item.ItemID, false); bool success = FetchAsset(asscli, itemID, false); // asscli.RequestAsset(item.ItemID, false);
// OK, now fetch the inside. // OK, now fetch the inside.
Dictionary<UUID, bool> ids = SniffUUIDs(itemID); Dictionary<UUID, bool> ids = SniffUUIDs(itemID);
Dump(ids); Dump(ids);
foreach (KeyValuePair<UUID, bool> kvp in ids) foreach (KeyValuePair<UUID, bool> kvp in ids)
FetchAsset(asscli, kvp.Key, kvp.Value); FetchAsset(asscli, kvp.Key, kvp.Value);
if (success) if (success)
{ {
m_log.Debug("[HGScene]: Successfully fetched item from remote asset server " + userAssetURL); m_log.Debug("[HGScene]: Successfully fetched item from remote asset server " + userAssetURL);
m_assetMap.Add(itemID, asscli); m_assetMap.Add(itemID, asscli);
} }
else else
m_log.Warn("[HGScene]: Could not fetch asset from remote asset server " + userAssetURL); m_log.Warn("[HGScene]: Could not fetch asset from remote asset server " + userAssetURL);
} }
else else
m_log.Warn("[HGScene]: Unable to locate foreign user's asset server"); m_log.Warn("[HGScene]: Unable to locate foreign user's asset server");
} }
} }
public void Post(UUID itemID, UUID ownerID) public void Post(UUID itemID, UUID ownerID)
{ {
if (!IsHomeUser(ownerID)) if (!IsHomeUser(ownerID))
{ {
// Post the item from the local AssetCache ontp the remote asset server // Post the item from the local AssetCache ontp the remote asset server
// and place an entry in m_assetMap // and place an entry in m_assetMap
GridAssetClient asscli = null; GridAssetClient asscli = null;
string userAssetURL = UserAssetURL(ownerID); string userAssetURL = UserAssetURL(ownerID);
if (userAssetURL != null) if (userAssetURL != null)
{ {
m_assetServers.TryGetValue(userAssetURL, out asscli); m_assetServers.TryGetValue(userAssetURL, out asscli);
if (asscli == null) if (asscli == null)
{ {
m_log.Debug("[HGScene]: Starting new GridAssetClient for " + userAssetURL); m_log.Debug("[HGScene]: Starting new GridAssetClient for " + userAssetURL);
asscli = new GridAssetClient(userAssetURL); asscli = new GridAssetClient(userAssetURL);
asscli.SetReceiver(m_scene.CommsManager.AssetCache); // Straight to the asset cache! asscli.SetReceiver(m_scene.CommsManager.AssetCache); // Straight to the asset cache!
m_assetServers.Add(userAssetURL, asscli); m_assetServers.Add(userAssetURL, asscli);
} }
m_log.Debug("[HGScene]: Posting object " + itemID + " to asset server " + userAssetURL); m_log.Debug("[HGScene]: Posting object " + itemID + " to asset server " + userAssetURL);
bool success = PostAsset(asscli, itemID); bool success = PostAsset(asscli, itemID);
// Now the inside // Now the inside
Dictionary<UUID, bool> ids = SniffUUIDs(itemID); Dictionary<UUID, bool> ids = SniffUUIDs(itemID);
Dump(ids); Dump(ids);
foreach (KeyValuePair<UUID, bool> kvp in ids) foreach (KeyValuePair<UUID, bool> kvp in ids)
PostAsset(asscli, kvp.Key); PostAsset(asscli, kvp.Key);
if (success) if (success)
{ {
m_log.Debug("[HGScene]: Successfully posted item to remote asset server " + userAssetURL); m_log.Debug("[HGScene]: Successfully posted item to remote asset server " + userAssetURL);
m_assetMap.Add(itemID, asscli); m_assetMap.Add(itemID, asscli);
} }
else else
m_log.Warn("[HGScene]: Could not post asset to remote asset server " + userAssetURL); m_log.Warn("[HGScene]: Could not post asset to remote asset server " + userAssetURL);
//if (!m_assetMap.ContainsKey(itemID)) //if (!m_assetMap.ContainsKey(itemID))
// m_assetMap.Add(itemID, asscli); // m_assetMap.Add(itemID, asscli);
} }
else else
m_log.Warn("[HGScene]: Unable to locate foreign user's asset server"); m_log.Warn("[HGScene]: Unable to locate foreign user's asset server");
} }
} }
#endregion #endregion
} }
} }

304
OpenSim/Region/Environment/Scenes/Hypergrid/HGScene.Inventory.cs
View File

@ -1,152 +1,152 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.Reflection; using System.Reflection;
using System.Threading; using System.Threading;
using log4net; using log4net;
using Nini.Config; using Nini.Config;
using OpenMetaverse; using OpenMetaverse;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications; using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers; using OpenSim.Framework.Servers;
using OpenSim.Region.Environment; using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Scenes;
namespace OpenSim.Region.Environment.Scenes.Hypergrid namespace OpenSim.Region.Environment.Scenes.Hypergrid
{ {
public partial class HGScene : Scene public partial class HGScene : Scene
{ {
#region Fields #region Fields
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private HGAssetMapper m_assMapper; private HGAssetMapper m_assMapper;
#endregion #endregion
#region Constructors #region Constructors
public HGScene(RegionInfo regInfo, AgentCircuitManager authen, public HGScene(RegionInfo regInfo, AgentCircuitManager authen,
CommunicationsManager commsMan, SceneCommunicationService sceneGridService, CommunicationsManager commsMan, SceneCommunicationService sceneGridService,
AssetCache assetCach, StorageManager storeManager, BaseHttpServer httpServer, AssetCache assetCach, StorageManager storeManager, BaseHttpServer httpServer,
ModuleLoader moduleLoader, bool dumpAssetsToFile, bool physicalPrim, ModuleLoader moduleLoader, bool dumpAssetsToFile, bool physicalPrim,
bool SeeIntoRegionFromNeighbor, IConfigSource config, string simulatorVersion) bool SeeIntoRegionFromNeighbor, IConfigSource config, string simulatorVersion)
: base(regInfo, authen, commsMan, sceneGridService, assetCach, storeManager, httpServer, moduleLoader, : base(regInfo, authen, commsMan, sceneGridService, assetCach, storeManager, httpServer, moduleLoader,
dumpAssetsToFile, physicalPrim, SeeIntoRegionFromNeighbor, config, simulatorVersion) dumpAssetsToFile, physicalPrim, SeeIntoRegionFromNeighbor, config, simulatorVersion)
{ {
m_log.Info("[HGScene]: Starting HGScene."); m_log.Info("[HGScene]: Starting HGScene.");
m_assMapper = new HGAssetMapper(this); m_assMapper = new HGAssetMapper(this);
EventManager.OnNewInventoryItemUploadComplete += UploadInventoryItem; EventManager.OnNewInventoryItemUploadComplete += UploadInventoryItem;
} }
#endregion #endregion
#region Event handlers #region Event handlers
public void UploadInventoryItem(UUID avatarID, UUID assetID, string name, int userlevel) public void UploadInventoryItem(UUID avatarID, UUID assetID, string name, int userlevel)
{ {
CachedUserInfo userInfo = CommsManager.UserProfileCacheService.GetUserDetails(avatarID); CachedUserInfo userInfo = CommsManager.UserProfileCacheService.GetUserDetails(avatarID);
if (userInfo != null) if (userInfo != null)
{ {
m_assMapper.Post(assetID, avatarID); m_assMapper.Post(assetID, avatarID);
} }
} }
#endregion #endregion
#region Overrides of Scene.Inventory methods #region Overrides of Scene.Inventory methods
/// ///
/// CapsUpdateInventoryItemAsset /// CapsUpdateInventoryItemAsset
/// ///
public override UUID CapsUpdateInventoryItemAsset(IClientAPI remoteClient, UUID itemID, byte[] data) public override UUID CapsUpdateInventoryItemAsset(IClientAPI remoteClient, UUID itemID, byte[] data)
{ {
UUID newAssetID = base.CapsUpdateInventoryItemAsset(remoteClient, itemID, data); UUID newAssetID = base.CapsUpdateInventoryItemAsset(remoteClient, itemID, data);
UploadInventoryItem(remoteClient.AgentId, newAssetID, "", 0); UploadInventoryItem(remoteClient.AgentId, newAssetID, "", 0);
return newAssetID; return newAssetID;
} }
/// ///
/// DeleteToInventory /// DeleteToInventory
/// ///
public override UUID DeleteToInventory(int destination, UUID folderID, SceneObjectGroup objectGroup, IClientAPI remoteClient) public override UUID DeleteToInventory(int destination, UUID folderID, SceneObjectGroup objectGroup, IClientAPI remoteClient)
{ {
UUID assetID = base.DeleteToInventory(destination, folderID, objectGroup, remoteClient); UUID assetID = base.DeleteToInventory(destination, folderID, objectGroup, remoteClient);
if (!assetID.Equals(UUID.Zero)) if (!assetID.Equals(UUID.Zero))
{ {
UploadInventoryItem(remoteClient.AgentId, assetID, "", 0); UploadInventoryItem(remoteClient.AgentId, assetID, "", 0);
} }
else else
m_log.Debug("[HGScene]: Scene.Inventory did not create asset"); m_log.Debug("[HGScene]: Scene.Inventory did not create asset");
return assetID; return assetID;
} }
/// ///
/// RezObject /// RezObject
/// ///
public override SceneObjectGroup RezObject(IClientAPI remoteClient, UUID itemID, Vector3 RayEnd, Vector3 RayStart, public override SceneObjectGroup RezObject(IClientAPI remoteClient, UUID itemID, Vector3 RayEnd, Vector3 RayStart,
UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection, UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
bool RezSelected, bool RemoveItem, UUID fromTaskID, bool attachment) bool RezSelected, bool RemoveItem, UUID fromTaskID, bool attachment)
{ {
CachedUserInfo userInfo = CommsManager.UserProfileCacheService.GetUserDetails(remoteClient.AgentId); CachedUserInfo userInfo = CommsManager.UserProfileCacheService.GetUserDetails(remoteClient.AgentId);
if (userInfo != null) if (userInfo != null)
{ {
if (userInfo.RootFolder != null) if (userInfo.RootFolder != null)
{ {
InventoryItemBase item = userInfo.RootFolder.FindItem(itemID); InventoryItemBase item = userInfo.RootFolder.FindItem(itemID);
if (item != null) if (item != null)
{ {
m_assMapper.Get(item.AssetID, remoteClient.AgentId); m_assMapper.Get(item.AssetID, remoteClient.AgentId);
} }
} }
} }
// OK, we're done fetching. Pass it up to the default RezObject // OK, we're done fetching. Pass it up to the default RezObject
return base.RezObject(remoteClient, itemID, RayEnd, RayStart, RayTargetID, BypassRayCast, RayEndIsIntersection, return base.RezObject(remoteClient, itemID, RayEnd, RayStart, RayTargetID, BypassRayCast, RayEndIsIntersection,
RezSelected, RemoveItem, fromTaskID, attachment); RezSelected, RemoveItem, fromTaskID, attachment);
} }
#endregion #endregion
} }
} }

156
OpenSim/Region/Environment/Scenes/Hypergrid/HGScene.cs
View File

@ -1,78 +1,78 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using OpenMetaverse; using OpenMetaverse;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Environment; using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Scenes;
using TPFlags = OpenSim.Framework.Constants.TeleportFlags; using TPFlags = OpenSim.Framework.Constants.TeleportFlags;
namespace OpenSim.Region.Environment.Scenes.Hypergrid namespace OpenSim.Region.Environment.Scenes.Hypergrid
{ {
public partial class HGScene : Scene public partial class HGScene : Scene
{ {
/// <summary> /// <summary>
/// Teleport an avatar to their home region /// Teleport an avatar to their home region
/// </summary> /// </summary>
/// <param name="agentId"></param> /// <param name="agentId"></param>
/// <param name="client"></param> /// <param name="client"></param>
public override void TeleportClientHome(UUID agentId, IClientAPI client) public override void TeleportClientHome(UUID agentId, IClientAPI client)
{ {
m_log.Debug("[HGScene]: TeleportClientHome " + client.FirstName + " " + client.LastName); m_log.Debug("[HGScene]: TeleportClientHome " + client.FirstName + " " + client.LastName);
CachedUserInfo uinfo = CommsManager.UserProfileCacheService.GetUserDetails(agentId); CachedUserInfo uinfo = CommsManager.UserProfileCacheService.GetUserDetails(agentId);
UserProfileData UserProfile = uinfo.UserProfile; UserProfileData UserProfile = uinfo.UserProfile;
if (UserProfile != null) if (UserProfile != null)
{ {
RegionInfo regionInfo = CommsManager.GridService.RequestNeighbourInfo(UserProfile.HomeRegion); RegionInfo regionInfo = CommsManager.GridService.RequestNeighbourInfo(UserProfile.HomeRegion);
//if (regionInfo != null) //if (regionInfo != null)
//{ //{
// UserProfile.HomeRegionID = regionInfo.RegionID; // UserProfile.HomeRegionID = regionInfo.RegionID;
// //CommsManager.UserService.UpdateUserProfile(UserProfile); // //CommsManager.UserService.UpdateUserProfile(UserProfile);
//} //}
if (regionInfo == null) if (regionInfo == null)
{ {
// can't find the Home region: Tell viewer and abort // can't find the Home region: Tell viewer and abort
client.SendTeleportFailed("Your home-region could not be found."); client.SendTeleportFailed("Your home-region could not be found.");
return; return;
} }
RequestTeleportLocation( RequestTeleportLocation(
client, regionInfo.RegionHandle, UserProfile.HomeLocation, UserProfile.HomeLookAt, client, regionInfo.RegionHandle, UserProfile.HomeLocation, UserProfile.HomeLookAt,
(uint)(TPFlags.SetLastToTarget | TPFlags.ViaHome)); (uint)(TPFlags.SetLastToTarget | TPFlags.ViaHome));
} }
} }
} }
} }

526
OpenSim/Region/Environment/Scenes/Hypergrid/HGSceneCommunicationService.cs
View File

@ -1,263 +1,263 @@
/** /**
* Copyright (c) 2008, Contributors. All rights reserved. * Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
* *
* * Redistributions of source code must retain the above copyright notice, * * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice, * * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual * * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from * Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission. * this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE. * OF THE POSSIBILITY OF SUCH DAMAGE.
* *
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Reflection; using System.Reflection;
using System.Threading; using System.Threading;
using OpenMetaverse; using OpenMetaverse;
using log4net; using log4net;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Communications; using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache; using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Environment; using OpenSim.Region.Environment;
using OpenSim.Region.Interfaces; using OpenSim.Region.Interfaces;
using OSD = OpenMetaverse.StructuredData.OSD; using OSD = OpenMetaverse.StructuredData.OSD;
namespace OpenSim.Region.Environment.Scenes.Hypergrid namespace OpenSim.Region.Environment.Scenes.Hypergrid
{ {
public class HGSceneCommunicationService : SceneCommunicationService public class HGSceneCommunicationService : SceneCommunicationService
{ {
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private IHyperlink m_hg; private IHyperlink m_hg;
public HGSceneCommunicationService(CommunicationsManager commsMan, IHyperlink hg) : base(commsMan) public HGSceneCommunicationService(CommunicationsManager commsMan, IHyperlink hg) : base(commsMan)
{ {
m_hg = hg; m_hg = hg;
} }
/// <summary> /// <summary>
/// Try to teleport an agent to a new region. /// Try to teleport an agent to a new region.
/// </summary> /// </summary>
/// <param name="remoteClient"></param> /// <param name="remoteClient"></param>
/// <param name="RegionHandle"></param> /// <param name="RegionHandle"></param>
/// <param name="position"></param> /// <param name="position"></param>
/// <param name="lookAt"></param> /// <param name="lookAt"></param>
/// <param name="flags"></param> /// <param name="flags"></param>
public override void RequestTeleportToLocation(ScenePresence avatar, ulong regionHandle, Vector3 position, public override void RequestTeleportToLocation(ScenePresence avatar, ulong regionHandle, Vector3 position,
Vector3 lookAt, uint teleportFlags) Vector3 lookAt, uint teleportFlags)
{ {
if (!avatar.Scene.Permissions.CanTeleport(avatar.UUID)) if (!avatar.Scene.Permissions.CanTeleport(avatar.UUID))
return; return;
bool destRegionUp = false; bool destRegionUp = false;
IEventQueue eq = avatar.Scene.RequestModuleInterface<IEventQueue>(); IEventQueue eq = avatar.Scene.RequestModuleInterface<IEventQueue>();
if (regionHandle == m_regionInfo.RegionHandle) if (regionHandle == m_regionInfo.RegionHandle)
{ {
// Teleport within the same region // Teleport within the same region
if (position.X < 0 || position.X > Constants.RegionSize || position.Y < 0 || position.Y > Constants.RegionSize || position.Z < 0) if (position.X < 0 || position.X > Constants.RegionSize || position.Y < 0 || position.Y > Constants.RegionSize || position.Z < 0)
{ {
Vector3 emergencyPos = new Vector3(128, 128, 128); Vector3 emergencyPos = new Vector3(128, 128, 128);
m_log.WarnFormat( m_log.WarnFormat(
"[HGSceneCommService]: RequestTeleportToLocation() was given an illegal position of {0} for avatar {1}, {2}. Substituting {3}", "[HGSceneCommService]: RequestTeleportToLocation() was given an illegal position of {0} for avatar {1}, {2}. Substituting {3}",
position, avatar.Name, avatar.UUID, emergencyPos); position, avatar.Name, avatar.UUID, emergencyPos);
position = emergencyPos; position = emergencyPos;
} }
// TODO: Get proper AVG Height // TODO: Get proper AVG Height
float localAVHeight = 1.56f; float localAVHeight = 1.56f;
float posZLimit = (float)avatar.Scene.GetLandHeight((int)position.X, (int)position.Y); float posZLimit = (float)avatar.Scene.GetLandHeight((int)position.X, (int)position.Y);
float newPosZ = posZLimit + localAVHeight; float newPosZ = posZLimit + localAVHeight;
if (posZLimit >= (position.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ))) if (posZLimit >= (position.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ)))
{ {
position.Z = newPosZ; position.Z = newPosZ;
} }
// Only send this if the event queue is null // Only send this if the event queue is null
if (eq == null) if (eq == null)
avatar.ControllingClient.SendTeleportLocationStart(); avatar.ControllingClient.SendTeleportLocationStart();
avatar.ControllingClient.SendLocalTeleport(position, lookAt, teleportFlags); avatar.ControllingClient.SendLocalTeleport(position, lookAt, teleportFlags);
avatar.Teleport(position); avatar.Teleport(position);
} }
else else
{ {
RegionInfo reg = RequestNeighbouringRegionInfo(regionHandle); RegionInfo reg = RequestNeighbouringRegionInfo(regionHandle);
if (reg != null) if (reg != null)
{ {
/// ///
/// Hypergrid mod start /// Hypergrid mod start
/// ///
/// ///
bool isHyperLink = m_hg.IsHyperlinkRegion(reg.RegionHandle); bool isHyperLink = m_hg.IsHyperlinkRegion(reg.RegionHandle);
bool isHomeUser = true; bool isHomeUser = true;
ulong realHandle = regionHandle; ulong realHandle = regionHandle;
CachedUserInfo uinfo = m_commsProvider.UserProfileCacheService.GetUserDetails(avatar.UUID); CachedUserInfo uinfo = m_commsProvider.UserProfileCacheService.GetUserDetails(avatar.UUID);
if (uinfo != null) if (uinfo != null)
{ {
isHomeUser = HGNetworkServersInfo.Singleton.IsLocalUser(uinfo.UserProfile.UserAssetURI); isHomeUser = HGNetworkServersInfo.Singleton.IsLocalUser(uinfo.UserProfile.UserAssetURI);
realHandle = m_hg.FindRegionHandle(regionHandle); realHandle = m_hg.FindRegionHandle(regionHandle);
Console.WriteLine("XXX ---- home user? " + isHomeUser + " --- hyperlink? " + isHyperLink + " --- real handle: " + realHandle.ToString()); Console.WriteLine("XXX ---- home user? " + isHomeUser + " --- hyperlink? " + isHyperLink + " --- real handle: " + realHandle.ToString());
} }
/// ///
/// Hypergrid mod stop /// Hypergrid mod stop
/// ///
/// ///
if (eq == null) if (eq == null)
avatar.ControllingClient.SendTeleportLocationStart(); avatar.ControllingClient.SendTeleportLocationStart();
AgentCircuitData agent = avatar.ControllingClient.RequestClientInfo(); AgentCircuitData agent = avatar.ControllingClient.RequestClientInfo();
agent.BaseFolder = UUID.Zero; agent.BaseFolder = UUID.Zero;
agent.InventoryFolder = UUID.Zero; agent.InventoryFolder = UUID.Zero;
agent.startpos = position; agent.startpos = position;
agent.child = true; agent.child = true;
if (reg.RemotingAddress != "" && reg.RemotingPort != 0) if (reg.RemotingAddress != "" && reg.RemotingPort != 0)
{ {
// region is remote. see if it is up // region is remote. see if it is up
destRegionUp = m_commsProvider.InterRegion.CheckRegion(reg.RemotingAddress, reg.RemotingPort); destRegionUp = m_commsProvider.InterRegion.CheckRegion(reg.RemotingAddress, reg.RemotingPort);
} }
else else
{ {
// assume local regions are always up // assume local regions are always up
destRegionUp = true; destRegionUp = true;
} }
if (destRegionUp) if (destRegionUp)
{ {
// Fixing a bug where teleporting while sitting results in the avatar ending up removed from // Fixing a bug where teleporting while sitting results in the avatar ending up removed from
// both regions // both regions
if (avatar.ParentID != (uint)0) if (avatar.ParentID != (uint)0)
avatar.StandUp(); avatar.StandUp();
if (!avatar.ValidateAttachments()) if (!avatar.ValidateAttachments())
{ {
avatar.ControllingClient.SendTeleportFailed("Inconsistent attachment state"); avatar.ControllingClient.SendTeleportFailed("Inconsistent attachment state");
return; return;
} }
// the avatar.Close below will clear the child region list. We need this below for (possibly) // the avatar.Close below will clear the child region list. We need this below for (possibly)
// closing the child agents, so save it here (we need a copy as it is Clear()-ed). // closing the child agents, so save it here (we need a copy as it is Clear()-ed).
List<ulong> childRegions = new List<ulong>(avatar.GetKnownRegionList()); List<ulong> childRegions = new List<ulong>(avatar.GetKnownRegionList());
// Compared to ScenePresence.CrossToNewRegion(), there's no obvious code to handle a teleport // Compared to ScenePresence.CrossToNewRegion(), there's no obvious code to handle a teleport
// failure at this point (unlike a border crossing failure). So perhaps this can never fail // failure at this point (unlike a border crossing failure). So perhaps this can never fail
// once we reach here... // once we reach here...
avatar.Scene.RemoveCapsHandler(avatar.UUID); avatar.Scene.RemoveCapsHandler(avatar.UUID);
agent.child = false; agent.child = false;
m_commsProvider.InterRegion.InformRegionOfChildAgent(reg.RegionHandle, agent); m_commsProvider.InterRegion.InformRegionOfChildAgent(reg.RegionHandle, agent);
m_commsProvider.InterRegion.ExpectAvatarCrossing(reg.RegionHandle, avatar.ControllingClient.AgentId, m_commsProvider.InterRegion.ExpectAvatarCrossing(reg.RegionHandle, avatar.ControllingClient.AgentId,
position, false); position, false);
Thread.Sleep(2000); Thread.Sleep(2000);
AgentCircuitData circuitdata = avatar.ControllingClient.RequestClientInfo(); AgentCircuitData circuitdata = avatar.ControllingClient.RequestClientInfo();
// TODO Should construct this behind a method // TODO Should construct this behind a method
string capsPath = string capsPath =
"http://" + reg.ExternalHostName + ":" + reg.HttpPort "http://" + reg.ExternalHostName + ":" + reg.HttpPort
+ "/CAPS/" + circuitdata.CapsPath + "0000/"; + "/CAPS/" + circuitdata.CapsPath + "0000/";
m_log.DebugFormat( m_log.DebugFormat(
"[CAPS]: Sending new CAPS seed url {0} to client {1}", capsPath, avatar.UUID); "[CAPS]: Sending new CAPS seed url {0} to client {1}", capsPath, avatar.UUID);
/// ///
/// Hypergrid mod: realHandle instead of reg.RegionHandle /// Hypergrid mod: realHandle instead of reg.RegionHandle
/// ///
/// ///
if (eq != null) if (eq != null)
{ {
OSD Item = EventQueueHelper.TeleportFinishEvent(realHandle, 13, reg.ExternalEndPoint, OSD Item = EventQueueHelper.TeleportFinishEvent(realHandle, 13, reg.ExternalEndPoint,
4, teleportFlags, capsPath, avatar.UUID); 4, teleportFlags, capsPath, avatar.UUID);
eq.Enqueue(Item, avatar.UUID); eq.Enqueue(Item, avatar.UUID);
} }
else else
{ {
avatar.ControllingClient.SendRegionTeleport(realHandle, 13, reg.ExternalEndPoint, 4, avatar.ControllingClient.SendRegionTeleport(realHandle, 13, reg.ExternalEndPoint, 4,
teleportFlags, capsPath); teleportFlags, capsPath);
} }
/// ///
/// Hypergrid mod stop /// Hypergrid mod stop
/// ///
avatar.MakeChildAgent(); avatar.MakeChildAgent();
Thread.Sleep(7000); Thread.Sleep(7000);
avatar.CrossAttachmentsIntoNewRegion(reg.RegionHandle, true); avatar.CrossAttachmentsIntoNewRegion(reg.RegionHandle, true);
if (KiPrimitive != null) if (KiPrimitive != null)
{ {
KiPrimitive(avatar.LocalId); KiPrimitive(avatar.LocalId);
} }
avatar.Close(); avatar.Close();
uint newRegionX = (uint)(reg.RegionHandle >> 40); uint newRegionX = (uint)(reg.RegionHandle >> 40);
uint newRegionY = (((uint)(reg.RegionHandle)) >> 8); uint newRegionY = (((uint)(reg.RegionHandle)) >> 8);
uint oldRegionX = (uint)(m_regionInfo.RegionHandle >> 40); uint oldRegionX = (uint)(m_regionInfo.RegionHandle >> 40);
uint oldRegionY = (((uint)(m_regionInfo.RegionHandle)) >> 8); uint oldRegionY = (((uint)(m_regionInfo.RegionHandle)) >> 8);
/// ///
/// Hypergrid mod: extra check for isHyperLink /// Hypergrid mod: extra check for isHyperLink
/// ///
if ((Util.fast_distance2d((int)(newRegionX - oldRegionX), (int)(newRegionY - oldRegionY)) > 3) || isHyperLink) if ((Util.fast_distance2d((int)(newRegionX - oldRegionX), (int)(newRegionY - oldRegionY)) > 3) || isHyperLink)
{ {
//SendCloseChildAgentConnections(avatar.UUID, avatar.GetKnownRegionList()); //SendCloseChildAgentConnections(avatar.UUID, avatar.GetKnownRegionList());
SendCloseChildAgentConnections(avatar.UUID, childRegions); SendCloseChildAgentConnections(avatar.UUID, childRegions);
CloseConnection(avatar.UUID); CloseConnection(avatar.UUID);
} }
// if (teleport success) // seems to be always success here // if (teleport success) // seems to be always success here
// the user may change their profile information in other region, // the user may change their profile information in other region,
// so the userinfo in UserProfileCache is not reliable any more, delete it // so the userinfo in UserProfileCache is not reliable any more, delete it
if (avatar.Scene.NeedSceneCacheClear(avatar.UUID)) if (avatar.Scene.NeedSceneCacheClear(avatar.UUID))
m_commsProvider.UserProfileCacheService.RemoveUser(avatar.UUID); m_commsProvider.UserProfileCacheService.RemoveUser(avatar.UUID);
m_log.InfoFormat("[HGSceneCommService]: User {0} is going to another region, profile cache removed", avatar.UUID); m_log.InfoFormat("[HGSceneCommService]: User {0} is going to another region, profile cache removed", avatar.UUID);
} }
else else
{ {
avatar.ControllingClient.SendTeleportFailed("Remote Region appears to be down"); avatar.ControllingClient.SendTeleportFailed("Remote Region appears to be down");
} }
} }
else else
{ {
// TP to a place that doesn't exist (anymore) // TP to a place that doesn't exist (anymore)
// Inform the viewer about that // Inform the viewer about that
avatar.ControllingClient.SendTeleportFailed("The region you tried to teleport to doesn't exist anymore"); avatar.ControllingClient.SendTeleportFailed("The region you tried to teleport to doesn't exist anymore");
// and set the map-tile to '(Offline)' // and set the map-tile to '(Offline)'
uint regX, regY; uint regX, regY;
Utils.LongToUInts(regionHandle, out regX, out regY); Utils.LongToUInts(regionHandle, out regX, out regY);
MapBlockData block = new MapBlockData(); MapBlockData block = new MapBlockData();
block.X = (ushort)(regX / Constants.RegionSize); block.X = (ushort)(regX / Constants.RegionSize);
block.Y = (ushort)(regY / Constants.RegionSize); block.Y = (ushort)(regY / Constants.RegionSize);
block.Access = 254; // == not there block.Access = 254; // == not there
List<MapBlockData> blocks = new List<MapBlockData>(); List<MapBlockData> blocks = new List<MapBlockData>();
blocks.Add(block); blocks.Add(block);
avatar.ControllingClient.SendMapBlock(blocks, 0); avatar.ControllingClient.SendMapBlock(blocks, 0);
} }
} }
} }
} }
} }