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.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Text;
using OpenSim.Framework;
namespace OpenSim.Framework.Communications
{
public interface IHyperlink
{
bool IsHyperlinkRegion(ulong handle);
RegionInfo GetHyperlinkRegion(ulong handle);
ulong FindRegionHandle(ulong handle);
}
}
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Text;
using OpenSim.Framework;
namespace OpenSim.Framework.Communications
{
public interface IHyperlink
{
bool IsHyperlinkRegion(ulong handle);
RegionInfo GetHyperlinkRegion(ulong handle);
ulong FindRegionHandle(ulong handle);
}
}

160
OpenSim/Framework/ForeignUserProfileData.cs
View File

@ -1,80 +1,80 @@
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using OpenSim.Framework;
namespace OpenSim.Framework
{
public class ForeignUserProfileData : UserProfileData
{
/// <summary>
/// The address of the users home sim, used for foreigners.
/// </summary>
private string _userUserServerURI = String.Empty;
/// <summary>
/// The address of the users home sim, used for foreigners.
/// </summary>
private string _userHomeAddress = String.Empty;
/// <summary>
/// The port of the users home sim, used for foreigners.
/// </summary>
private string _userHomePort = String.Empty;
/// <summary>
/// The remoting port of the users home sim, used for foreigners.
/// </summary>
private string _userHomeRemotingPort = String.Empty;
public string UserServerURI
{
get { return _userUserServerURI; }
set { _userUserServerURI = value; }
}
public string UserHomeAddress
{
get { return _userHomeAddress; }
set { _userHomeAddress = value; }
}
public string UserHomePort
{
get { return _userHomePort; }
set { _userHomePort = value; }
}
public string UserHomeRemotingPort
{
get { return _userHomeRemotingPort; }
set { _userHomeRemotingPort = value; }
}
}
}
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using OpenSim.Framework;
namespace OpenSim.Framework
{
public class ForeignUserProfileData : UserProfileData
{
/// <summary>
/// The address of the users home sim, used for foreigners.
/// </summary>
private string _userUserServerURI = String.Empty;
/// <summary>
/// The address of the users home sim, used for foreigners.
/// </summary>
private string _userHomeAddress = String.Empty;
/// <summary>
/// The port of the users home sim, used for foreigners.
/// </summary>
private string _userHomePort = String.Empty;
/// <summary>
/// The remoting port of the users home sim, used for foreigners.
/// </summary>
private string _userHomeRemotingPort = String.Empty;
public string UserServerURI
{
get { return _userUserServerURI; }
set { _userUserServerURI = value; }
}
public string UserHomeAddress
{
get { return _userHomeAddress; }
set { _userHomeAddress = value; }
}
public string UserHomePort
{
get { return _userHomePort; }
set { _userHomePort = value; }
}
public string UserHomeRemotingPort
{
get { return _userHomeRemotingPort; }
set { _userHomeRemotingPort = value; }
}
}
}

180
OpenSim/Framework/HGNetworkServersInfo.cs
View File

@ -1,90 +1,90 @@
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Net;
using OpenSim.Framework;
namespace OpenSim.Framework
{
public class HGNetworkServersInfo
{
public readonly string LocalAssetServerURI, LocalInventoryServerURI, LocalUserServerURI;
private static HGNetworkServersInfo m_singleton;
public static HGNetworkServersInfo Singleton
{
get { return m_singleton; }
}
public static void Init(string assetserver, string inventoryserver, string userserver)
{
m_singleton = new HGNetworkServersInfo(assetserver, inventoryserver, userserver);
}
private HGNetworkServersInfo(string a, string i, string u)
{
LocalAssetServerURI = ServerURI(a);
LocalInventoryServerURI = ServerURI(i);
LocalUserServerURI = ServerURI(u);
}
public bool IsLocalUser(string userserver)
{
string userServerURI = ServerURI(userserver);
bool ret = (((userServerURI == null) || (userServerURI == "") || (userServerURI == LocalUserServerURI)));
//Console.WriteLine("-------------> HGNetworkServersInfo.IsLocalUser? " + ret + "(userServer=" + userServerURI + "; localuserserver=" + LocalUserServerURI + ")");
return ret;
}
public static string ServerURI(string uri)
{
IPAddress ipaddr1 = null;
string port1 = "";
try
{
ipaddr1 = Util.GetHostFromURL(uri);
}
catch { }
try
{
port1 = uri.Split(new char[] { ':' })[2];
}
catch { }
// We tried our best to convert the domain names to IP addresses
return (ipaddr1 != null) ? "http://" + ipaddr1.ToString() + ":" + port1 : uri;
}
}
}
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Net;
using OpenSim.Framework;
namespace OpenSim.Framework
{
public class HGNetworkServersInfo
{
public readonly string LocalAssetServerURI, LocalInventoryServerURI, LocalUserServerURI;
private static HGNetworkServersInfo m_singleton;
public static HGNetworkServersInfo Singleton
{
get { return m_singleton; }
}
public static void Init(string assetserver, string inventoryserver, string userserver)
{
m_singleton = new HGNetworkServersInfo(assetserver, inventoryserver, userserver);
}
private HGNetworkServersInfo(string a, string i, string u)
{
LocalAssetServerURI = ServerURI(a);
LocalInventoryServerURI = ServerURI(i);
LocalUserServerURI = ServerURI(u);
}
public bool IsLocalUser(string userserver)
{
string userServerURI = ServerURI(userserver);
bool ret = (((userServerURI == null) || (userServerURI == "") || (userServerURI == LocalUserServerURI)));
//Console.WriteLine("-------------> HGNetworkServersInfo.IsLocalUser? " + ret + "(userServer=" + userServerURI + "; localuserserver=" + LocalUserServerURI + ")");
return ret;
}
public static string ServerURI(string uri)
{
IPAddress ipaddr1 = null;
string port1 = "";
try
{
ipaddr1 = Util.GetHostFromURL(uri);
}
catch { }
try
{
port1 = uri.Split(new char[] { ':' })[2];
}
catch { }
// We tried our best to convert the domain names to IP addresses
return (ipaddr1 != null) ? "http://" + ipaddr1.ToString() + ":" + port1 : uri;
}
}
}

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

@ -1,184 +1,184 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenSim.Framework;
using OpenSim.Framework.Console;
using OpenSim.Framework.Servers;
using OpenSim.Framework.Statistics;
using OpenSim.Region.ClientStack;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Communications.Local;
using OpenSim.Region.Communications.Hypergrid;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Environment.Scenes.Hypergrid;
using Timer = System.Timers.Timer;
namespace OpenSim
{
public class HGOpenSimNode : OpenSim
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private IHyperlink HGServices = null;
public HGOpenSimNode(IConfigSource configSource) : base(configSource)
{
}
/// <summary>
/// Performs initialisation of the scene, such as loading configuration from disk.
/// </summary>
protected override void StartupSpecific()
{
m_log.Info("====================================================================");
m_log.Info("=================== STARTING HYPERGRID NODE ========================");
m_log.Info("====================================================================");
base.StartupSpecific();
}
protected override void InitialiseStandaloneServices(LibraryRootFolder libraryRootFolder)
{
// Standalone mode
HGInventoryService inventoryService = new HGInventoryService(m_networkServersInfo.InventoryURL, null, false);
inventoryService.AddPlugin(m_configSettings.StandaloneInventoryPlugin, m_configSettings.StandaloneInventorySource);
LocalUserServices userService =
new LocalUserServices(m_networkServersInfo, m_networkServersInfo.DefaultHomeLocX,
m_networkServersInfo.DefaultHomeLocY, inventoryService);
userService.AddPlugin(m_configSettings.StandaloneUserPlugin, m_configSettings.StandaloneUserSource);
//LocalBackEndServices backendService = new LocalBackEndServices();
HGGridServicesStandalone gridService = new HGGridServicesStandalone(m_networkServersInfo, m_httpServer, m_assetCache, m_sceneManager);
LocalLoginService loginService =
new LocalLoginService(
userService, m_configSettings.StandaloneWelcomeMessage, inventoryService, gridService.LocalBackend, m_networkServersInfo,
m_configSettings.StandaloneAuthenticate, libraryRootFolder);
m_commsManager = new HGCommunicationsStandalone(m_networkServersInfo, m_httpServer, m_assetCache,
userService, userService, inventoryService, gridService, gridService, userService, libraryRootFolder, m_configSettings.DumpAssetsToFile);
inventoryService.UserProfileCache = m_commsManager.UserProfileCacheService;
HGServices = gridService;
// set up XMLRPC handler for client's initial login request message
m_httpServer.AddXmlRPCHandler("login_to_simulator", loginService.XmlRpcLoginMethod);
// provides the web form login
m_httpServer.AddHTTPHandler("login", loginService.ProcessHTMLLogin);
// Provides the LLSD login
m_httpServer.SetDefaultLLSDHandler(loginService.LLSDLoginMethod);
// 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);
m_httpServer.AddXmlRPCHandler("get_grid_info", m_gridInfoService.XmlRpcGridInfoMethod);
m_httpServer.AddStreamHandler(new RestStreamHandler("GET", "/get_grid_info", m_gridInfoService.RestGetGridInfoMethod));
}
protected override void InitialiseGridServices(LibraryRootFolder libraryRootFolder)
{
m_commsManager = new HGCommunicationsGridMode(m_networkServersInfo, m_httpServer, m_assetCache, m_sceneManager, libraryRootFolder);
HGServices = ((HGCommunicationsGridMode)m_commsManager).HGServices;
m_httpServer.AddStreamHandler(new SimStatusHandler());
}
protected override Scene CreateScene(RegionInfo regionInfo, StorageManager storageManager,
AgentCircuitManager circuitManager)
{
HGSceneCommunicationService sceneGridService = new HGSceneCommunicationService(m_commsManager, HGServices);
return
new HGScene(regionInfo, circuitManager, m_commsManager, sceneGridService, m_assetCache,
storageManager, m_httpServer,
m_moduleLoader, m_configSettings.DumpAssetsToFile, m_configSettings.PhysicalPrim, m_configSettings.See_into_region_from_neighbor, m_config.Source,
m_version);
}
public override void RunCmd(string command, string[] cmdparams)
{
if (command.Equals("link-region"))
{
// link-region <Xloc> <Yloc> <HostName> <HttpPort> <LocalName>
if (cmdparams.Length < 4)
{
LinkRegionCmdUsage();
return;
}
RegionInfo regInfo = new RegionInfo();
uint xloc, yloc;
uint externalPort;
try
{
xloc = Convert.ToUInt32(cmdparams[0]);
yloc = Convert.ToUInt32(cmdparams[1]);
externalPort = Convert.ToUInt32(cmdparams[3]);
//internalPort = Convert.ToUInt32(cmdparams[4]);
//remotingPort = Convert.ToUInt32(cmdparams[5]);
}
catch (Exception e)
{
m_log.Warn("[HGrid] Wrong format for link-region command: " + e.Message);
LinkRegionCmdUsage();
return;
}
regInfo.RegionLocX = xloc;
regInfo.RegionLocY = yloc;
regInfo.ExternalHostName = cmdparams[2];
regInfo.HttpPort = externalPort;
//regInfo.RemotingPort = remotingPort;
try
{
regInfo.InternalEndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), (int)0);
}
catch (Exception e)
{
m_log.Warn("[HGrid] Wrong format for link-region command: " + e.Message);
LinkRegionCmdUsage();
return;
}
regInfo.RemotingAddress = regInfo.ExternalEndPoint.Address.ToString();
// Finally, link it
try
{
m_sceneManager.CurrentOrFirstScene.CommsManager.GridService.RegisterRegion(regInfo);
}
catch (Exception e)
{
m_log.Warn("[HGrid] Unable to link region: " + e.StackTrace);
}
if (cmdparams.Length >= 5)
{
regInfo.RegionName = "";
for (int i = 4; i < cmdparams.Length; i++)
regInfo.RegionName += cmdparams[i] + " ";
}
}
base.RunCmd(command, cmdparams);
}
private void LinkRegionCmdUsage()
{
Console.WriteLine("Usage: link-region <Xloc> <Yloc> <HostName> <HttpPort> [<LocalName>]");
}
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenSim.Framework;
using OpenSim.Framework.Console;
using OpenSim.Framework.Servers;
using OpenSim.Framework.Statistics;
using OpenSim.Region.ClientStack;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Communications.Local;
using OpenSim.Region.Communications.Hypergrid;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Environment.Scenes.Hypergrid;
using Timer = System.Timers.Timer;
namespace OpenSim
{
public class HGOpenSimNode : OpenSim
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private IHyperlink HGServices = null;
public HGOpenSimNode(IConfigSource configSource) : base(configSource)
{
}
/// <summary>
/// Performs initialisation of the scene, such as loading configuration from disk.
/// </summary>
protected override void StartupSpecific()
{
m_log.Info("====================================================================");
m_log.Info("=================== STARTING HYPERGRID NODE ========================");
m_log.Info("====================================================================");
base.StartupSpecific();
}
protected override void InitialiseStandaloneServices(LibraryRootFolder libraryRootFolder)
{
// Standalone mode
HGInventoryService inventoryService = new HGInventoryService(m_networkServersInfo.InventoryURL, null, false);
inventoryService.AddPlugin(m_configSettings.StandaloneInventoryPlugin, m_configSettings.StandaloneInventorySource);
LocalUserServices userService =
new LocalUserServices(m_networkServersInfo, m_networkServersInfo.DefaultHomeLocX,
m_networkServersInfo.DefaultHomeLocY, inventoryService);
userService.AddPlugin(m_configSettings.StandaloneUserPlugin, m_configSettings.StandaloneUserSource);
//LocalBackEndServices backendService = new LocalBackEndServices();
HGGridServicesStandalone gridService = new HGGridServicesStandalone(m_networkServersInfo, m_httpServer, m_assetCache, m_sceneManager);
LocalLoginService loginService =
new LocalLoginService(
userService, m_configSettings.StandaloneWelcomeMessage, inventoryService, gridService.LocalBackend, m_networkServersInfo,
m_configSettings.StandaloneAuthenticate, libraryRootFolder);
m_commsManager = new HGCommunicationsStandalone(m_networkServersInfo, m_httpServer, m_assetCache,
userService, userService, inventoryService, gridService, gridService, userService, libraryRootFolder, m_configSettings.DumpAssetsToFile);
inventoryService.UserProfileCache = m_commsManager.UserProfileCacheService;
HGServices = gridService;
// set up XMLRPC handler for client's initial login request message
m_httpServer.AddXmlRPCHandler("login_to_simulator", loginService.XmlRpcLoginMethod);
// provides the web form login
m_httpServer.AddHTTPHandler("login", loginService.ProcessHTMLLogin);
// Provides the LLSD login
m_httpServer.SetDefaultLLSDHandler(loginService.LLSDLoginMethod);
// 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);
m_httpServer.AddXmlRPCHandler("get_grid_info", m_gridInfoService.XmlRpcGridInfoMethod);
m_httpServer.AddStreamHandler(new RestStreamHandler("GET", "/get_grid_info", m_gridInfoService.RestGetGridInfoMethod));
}
protected override void InitialiseGridServices(LibraryRootFolder libraryRootFolder)
{
m_commsManager = new HGCommunicationsGridMode(m_networkServersInfo, m_httpServer, m_assetCache, m_sceneManager, libraryRootFolder);
HGServices = ((HGCommunicationsGridMode)m_commsManager).HGServices;
m_httpServer.AddStreamHandler(new SimStatusHandler());
}
protected override Scene CreateScene(RegionInfo regionInfo, StorageManager storageManager,
AgentCircuitManager circuitManager)
{
HGSceneCommunicationService sceneGridService = new HGSceneCommunicationService(m_commsManager, HGServices);
return
new HGScene(regionInfo, circuitManager, m_commsManager, sceneGridService, m_assetCache,
storageManager, m_httpServer,
m_moduleLoader, m_configSettings.DumpAssetsToFile, m_configSettings.PhysicalPrim, m_configSettings.See_into_region_from_neighbor, m_config.Source,
m_version);
}
public override void RunCmd(string command, string[] cmdparams)
{
if (command.Equals("link-region"))
{
// link-region <Xloc> <Yloc> <HostName> <HttpPort> <LocalName>
if (cmdparams.Length < 4)
{
LinkRegionCmdUsage();
return;
}
RegionInfo regInfo = new RegionInfo();
uint xloc, yloc;
uint externalPort;
try
{
xloc = Convert.ToUInt32(cmdparams[0]);
yloc = Convert.ToUInt32(cmdparams[1]);
externalPort = Convert.ToUInt32(cmdparams[3]);
//internalPort = Convert.ToUInt32(cmdparams[4]);
//remotingPort = Convert.ToUInt32(cmdparams[5]);
}
catch (Exception e)
{
m_log.Warn("[HGrid] Wrong format for link-region command: " + e.Message);
LinkRegionCmdUsage();
return;
}
regInfo.RegionLocX = xloc;
regInfo.RegionLocY = yloc;
regInfo.ExternalHostName = cmdparams[2];
regInfo.HttpPort = externalPort;
//regInfo.RemotingPort = remotingPort;
try
{
regInfo.InternalEndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), (int)0);
}
catch (Exception e)
{
m_log.Warn("[HGrid] Wrong format for link-region command: " + e.Message);
LinkRegionCmdUsage();
return;
}
regInfo.RemotingAddress = regInfo.ExternalEndPoint.Address.ToString();
// Finally, link it
try
{
m_sceneManager.CurrentOrFirstScene.CommsManager.GridService.RegisterRegion(regInfo);
}
catch (Exception e)
{
m_log.Warn("[HGrid] Unable to link region: " + e.StackTrace);
}
if (cmdparams.Length >= 5)
{
regInfo.RegionName = "";
for (int i = 4; i < cmdparams.Length; i++)
regInfo.RegionName += cmdparams[i] + " ";
}
}
base.RunCmd(command, cmdparams);
}
private void LinkRegionCmdUsage()
{
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.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System.Reflection;
using log4net;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Communications.OGS1;
using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Scenes;
namespace OpenSim.Region.Communications.Hypergrid
{
public class HGCommunicationsGridMode : CommunicationsManager // CommunicationsOGS1
{
private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
IHyperlink m_osw = null;
public IHyperlink HGServices
{
get { return m_osw; }
}
public HGCommunicationsGridMode(
NetworkServersInfo serversInfo, BaseHttpServer httpServer,
AssetCache assetCache, SceneManager sman, LibraryRootFolder libraryRootFolder)
: base(serversInfo, httpServer, assetCache, false, libraryRootFolder)
{
// From constructor at CommunicationsOGS1
HGGridServices gridInterComms = new HGGridServicesGridMode(serversInfo, httpServer, assetCache, sman, m_userProfileCacheService);
m_gridService = gridInterComms;
m_interRegion = gridInterComms;
m_osw = gridInterComms;
// The HG InventoryService always uses secure handlers
HGInventoryService invService = new HGInventoryService(serversInfo.InventoryURL, this.m_userProfileCacheService, true);
AddSecureInventoryService(invService);
m_defaultInventoryHost = invService.Host;
if (SecureInventoryService != null)
m_log.Info("[HG] SecureInventoryService.");
else
m_log.Info("[HG] Non-secureInventoryService.");
HGUserServices userServices = new HGUserServices(this);
m_userService = userServices;
m_messageService = userServices;
m_avatarService = (IAvatarService)m_userService;
}
}
}
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System.Reflection;
using log4net;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Communications.OGS1;
using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Scenes;
namespace OpenSim.Region.Communications.Hypergrid
{
public class HGCommunicationsGridMode : CommunicationsManager // CommunicationsOGS1
{
private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
IHyperlink m_osw = null;
public IHyperlink HGServices
{
get { return m_osw; }
}
public HGCommunicationsGridMode(
NetworkServersInfo serversInfo, BaseHttpServer httpServer,
AssetCache assetCache, SceneManager sman, LibraryRootFolder libraryRootFolder)
: base(serversInfo, httpServer, assetCache, false, libraryRootFolder)
{
// From constructor at CommunicationsOGS1
HGGridServices gridInterComms = new HGGridServicesGridMode(serversInfo, httpServer, assetCache, sman, m_userProfileCacheService);
m_gridService = gridInterComms;
m_interRegion = gridInterComms;
m_osw = gridInterComms;
// The HG InventoryService always uses secure handlers
HGInventoryService invService = new HGInventoryService(serversInfo.InventoryURL, this.m_userProfileCacheService, true);
AddSecureInventoryService(invService);
m_defaultInventoryHost = invService.Host;
if (SecureInventoryService != null)
m_log.Info("[HG] SecureInventoryService.");
else
m_log.Info("[HG] Non-secureInventoryService.");
HGUserServices userServices = new HGUserServices(this);
m_userService = userServices;
m_messageService = userServices;
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.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Communications.Local;
using OpenSim.Framework.Servers;
namespace OpenSim.Region.Communications.Hypergrid
{
public class HGCommunicationsStandalone : CommunicationsLocal
{
public HGCommunicationsStandalone(
NetworkServersInfo serversInfo,
BaseHttpServer httpServer,
AssetCache assetCache,
IUserService userService,
IUserServiceAdmin userServiceAdmin,
LocalInventoryService inventoryService,
IInterRegionCommunications interRegionService,
HGGridServices gridService, IMessagingService messageService, LibraryRootFolder libraryRootFolder, bool dumpAssetsToFile)
: base(serversInfo, httpServer, assetCache, userService, userServiceAdmin, inventoryService, interRegionService, gridService, messageService, libraryRootFolder, dumpAssetsToFile)
{
gridService.UserProfileCache = m_userProfileCacheService;
m_assetCache = assetCache;
// Let's swap to always be secure access to inventory
AddSecureInventoryService((ISecureInventoryService)inventoryService);
m_inventoryServices = null;
}
}
}
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Communications.Local;
using OpenSim.Framework.Servers;
namespace OpenSim.Region.Communications.Hypergrid
{
public class HGCommunicationsStandalone : CommunicationsLocal
{
public HGCommunicationsStandalone(
NetworkServersInfo serversInfo,
BaseHttpServer httpServer,
AssetCache assetCache,
IUserService userService,
IUserServiceAdmin userServiceAdmin,
LocalInventoryService inventoryService,
IInterRegionCommunications interRegionService,
HGGridServices gridService, IMessagingService messageService, LibraryRootFolder libraryRootFolder, bool dumpAssetsToFile)
: base(serversInfo, httpServer, assetCache, userService, userServiceAdmin, inventoryService, interRegionService, gridService, messageService, libraryRootFolder, dumpAssetsToFile)
{
gridService.UserProfileCache = m_userProfileCacheService;
m_assetCache = assetCache;
// Let's swap to always be secure access to inventory
AddSecureInventoryService((ISecureInventoryService)inventoryService);
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.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Reflection;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers;
using OpenSim.Region.Communications.OGS1;
using OpenSim.Region.Environment.Scenes;
using OpenMetaverse;
using log4net;
namespace OpenSim.Region.Communications.Hypergrid
{
public class HGGridServicesGridMode : HGGridServices
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
/// <summary>
/// Encapsulate remote backend services for manipulation of grid regions
/// </summary>
private OGS1GridServices m_remoteBackend = null;
public OGS1GridServices RemoteBackend
{
get { return m_remoteBackend; }
}
public override string gdebugRegionName
{
get { return m_remoteBackend.gdebugRegionName; }
set { m_remoteBackend.gdebugRegionName = value; }
}
public override bool RegionLoginsEnabled
{
get { return m_remoteBackend.RegionLoginsEnabled; }
set { m_remoteBackend.RegionLoginsEnabled = value; }
}
public HGGridServicesGridMode(NetworkServersInfo servers_info, BaseHttpServer httpServe,
AssetCache asscache, SceneManager sman, UserProfileCacheService userv)
: base(servers_info, httpServe, asscache, sman)
{
m_remoteBackend = new OGS1GridServices(servers_info, httpServe);
// Let's deregister this, so we can handle it here first
InterRegionSingleton.Instance.OnChildAgent -= m_remoteBackend.IncomingChildAgent;
InterRegionSingleton.Instance.OnChildAgent += IncomingChildAgent;
m_userProfileCache = userv;
}
#region IGridServices interface
public override RegionCommsListener RegisterRegion(RegionInfo regionInfo)
{
if (!regionInfo.RegionID.Equals(UUID.Zero))
{
m_regionsOnInstance.Add(regionInfo);
return m_remoteBackend.RegisterRegion(regionInfo);
}
else
return base.RegisterRegion(regionInfo);
}
public override bool DeregisterRegion(RegionInfo regionInfo)
{
bool success = m_remoteBackend.DeregisterRegion(regionInfo);
if (!success)
success = base.DeregisterRegion(regionInfo);
return success;
}
public override List<SimpleRegionInfo> RequestNeighbours(uint x, uint y)
{
List<SimpleRegionInfo> neighbours = m_remoteBackend.RequestNeighbours(x, y);
List<SimpleRegionInfo> remotes = base.RequestNeighbours(x, y);
neighbours.AddRange(remotes);
return neighbours;
}
public override RegionInfo RequestNeighbourInfo(UUID Region_UUID)
{
RegionInfo info = m_remoteBackend.RequestNeighbourInfo(Region_UUID);
if (info == null)
info = base.RequestNeighbourInfo(Region_UUID);
return info;
}
public override RegionInfo RequestNeighbourInfo(ulong regionHandle)
{
RegionInfo info = m_remoteBackend.RequestNeighbourInfo(regionHandle);
if (info == null)
info = base.RequestNeighbourInfo(regionHandle);
return info;
}
public override RegionInfo RequestClosestRegion(string regionName)
{
RegionInfo info = m_remoteBackend.RequestClosestRegion(regionName);
if (info == null)
info = base.RequestClosestRegion(regionName);
return info;
}
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> remotes = base.RequestNeighbourMapBlocks(minX, minY, maxX, maxY);
neighbours.AddRange(remotes);
return neighbours;
}
public override LandData RequestLandData(ulong regionHandle, uint x, uint y)
{
LandData land = m_remoteBackend.RequestLandData(regionHandle, x, y);
if (land == null)
land = base.RequestLandData(regionHandle, x, y);
return land;
}
public override List<RegionInfo> RequestNamedRegions(string name, int maxNumber)
{
List<RegionInfo> infos = m_remoteBackend.RequestNamedRegions(name, maxNumber);
List<RegionInfo> remotes = base.RequestNamedRegions(name, maxNumber);
infos.AddRange(remotes);
return infos;
}
#endregion
#region IInterRegionCommunications interface
public override bool AcknowledgeAgentCrossed(ulong regionHandle, UUID agentId)
{
return m_remoteBackend.AcknowledgeAgentCrossed(regionHandle, agentId);
}
public override bool AcknowledgePrimCrossed(ulong regionHandle, UUID primID)
{
return m_remoteBackend.AcknowledgePrimCrossed(regionHandle, primID);
}
public override bool CheckRegion(string address, uint port)
{
return m_remoteBackend.CheckRegion(address, port);
}
public override bool ChildAgentUpdate(ulong regionHandle, ChildAgentDataUpdate cAgentData)
{
return m_remoteBackend.ChildAgentUpdate(regionHandle, cAgentData);
}
public override bool ExpectAvatarCrossing(ulong regionHandle, UUID agentID, Vector3 position, bool isFlying)
{
if (base.ExpectAvatarCrossing(regionHandle, agentID, position, isFlying))
return true;
return m_remoteBackend.ExpectAvatarCrossing(regionHandle, agentID, position, isFlying);
}
public override bool ExpectPrimCrossing(ulong regionHandle, UUID primID, Vector3 position, bool isFlying)
{
return m_remoteBackend.ExpectPrimCrossing(regionHandle, primID, position, isFlying);
}
public override bool InformRegionOfChildAgent(ulong regionHandle, AgentCircuitData agentData)
{
CachedUserInfo user = m_userProfileCache.GetUserDetails(agentData.AgentID);
if (IsLocalUser(user))
{
Console.WriteLine("XXX Home User XXX");
if (IsHyperlinkRegion(regionHandle))
{
Console.WriteLine("XXX Going Hyperlink XXX");
return base.InformRegionOfChildAgent(regionHandle, agentData);
}
else
{
// non-hypergrid case
Console.WriteLine("XXX Going local-grid region XXX");
return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData);
}
}
// Foregin users
Console.WriteLine("XXX Foreign User XXX");
if (IsLocalRegion(regionHandle)) // regions on the same instance
{
Console.WriteLine("XXX Going onInstance region XXX");
return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData);
}
if (IsHyperlinkRegion(regionHandle)) // hyperlinked regions
{
Console.WriteLine("XXX Going Hyperlink XXX");
return base.InformRegionOfChildAgent(regionHandle, agentData);
}
else
{
// foreign user going to a non-local region on the same grid
// We need to inform that region about this user before
// proceeding to the normal backend process.
Console.WriteLine("XXX Going local-grid region XXX");
RegionInfo regInfo = RequestNeighbourInfo(regionHandle);
if (regInfo != null)
InformRegionOfUser(regInfo, agentData);
return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData);
}
}
public override bool InformRegionOfPrimCrossing(ulong regionHandle, UUID primID, string objData, int XMLMethod)
{
return m_remoteBackend.InformRegionOfPrimCrossing(regionHandle, primID, objData, XMLMethod);
}
public override bool RegionUp(SerializableRegionInfo region, ulong regionhandle)
{
if (m_remoteBackend.RegionUp(region, regionhandle))
return true;
return base.RegionUp(region, regionhandle);
}
public override bool TellRegionToCloseChildConnection(ulong regionHandle, UUID agentID)
{
return m_remoteBackend.TellRegionToCloseChildConnection(regionHandle, agentID);
}
#endregion
#region Methods triggered by calls from external instances
/// <summary>
///
/// </summary>
/// <param name="regionHandle"></param>
/// <param name="agentData"></param>
/// <returns></returns>
public bool IncomingChildAgent(ulong regionHandle, AgentCircuitData agentData)
{
HGIncomingChildAgent(regionHandle, agentData);
m_log.Info("[HGrid]: Incoming HGrid Agent " + agentData.firstname + " " + agentData.lastname);
return m_remoteBackend.IncomingChildAgent(regionHandle, agentData);
}
#endregion
}
}
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Reflection;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers;
using OpenSim.Region.Communications.OGS1;
using OpenSim.Region.Environment.Scenes;
using OpenMetaverse;
using log4net;
namespace OpenSim.Region.Communications.Hypergrid
{
public class HGGridServicesGridMode : HGGridServices
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
/// <summary>
/// Encapsulate remote backend services for manipulation of grid regions
/// </summary>
private OGS1GridServices m_remoteBackend = null;
public OGS1GridServices RemoteBackend
{
get { return m_remoteBackend; }
}
public override string gdebugRegionName
{
get { return m_remoteBackend.gdebugRegionName; }
set { m_remoteBackend.gdebugRegionName = value; }
}
public override bool RegionLoginsEnabled
{
get { return m_remoteBackend.RegionLoginsEnabled; }
set { m_remoteBackend.RegionLoginsEnabled = value; }
}
public HGGridServicesGridMode(NetworkServersInfo servers_info, BaseHttpServer httpServe,
AssetCache asscache, SceneManager sman, UserProfileCacheService userv)
: base(servers_info, httpServe, asscache, sman)
{
m_remoteBackend = new OGS1GridServices(servers_info, httpServe);
// Let's deregister this, so we can handle it here first
InterRegionSingleton.Instance.OnChildAgent -= m_remoteBackend.IncomingChildAgent;
InterRegionSingleton.Instance.OnChildAgent += IncomingChildAgent;
m_userProfileCache = userv;
}
#region IGridServices interface
public override RegionCommsListener RegisterRegion(RegionInfo regionInfo)
{
if (!regionInfo.RegionID.Equals(UUID.Zero))
{
m_regionsOnInstance.Add(regionInfo);
return m_remoteBackend.RegisterRegion(regionInfo);
}
else
return base.RegisterRegion(regionInfo);
}
public override bool DeregisterRegion(RegionInfo regionInfo)
{
bool success = m_remoteBackend.DeregisterRegion(regionInfo);
if (!success)
success = base.DeregisterRegion(regionInfo);
return success;
}
public override List<SimpleRegionInfo> RequestNeighbours(uint x, uint y)
{
List<SimpleRegionInfo> neighbours = m_remoteBackend.RequestNeighbours(x, y);
List<SimpleRegionInfo> remotes = base.RequestNeighbours(x, y);
neighbours.AddRange(remotes);
return neighbours;
}
public override RegionInfo RequestNeighbourInfo(UUID Region_UUID)
{
RegionInfo info = m_remoteBackend.RequestNeighbourInfo(Region_UUID);
if (info == null)
info = base.RequestNeighbourInfo(Region_UUID);
return info;
}
public override RegionInfo RequestNeighbourInfo(ulong regionHandle)
{
RegionInfo info = m_remoteBackend.RequestNeighbourInfo(regionHandle);
if (info == null)
info = base.RequestNeighbourInfo(regionHandle);
return info;
}
public override RegionInfo RequestClosestRegion(string regionName)
{
RegionInfo info = m_remoteBackend.RequestClosestRegion(regionName);
if (info == null)
info = base.RequestClosestRegion(regionName);
return info;
}
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> remotes = base.RequestNeighbourMapBlocks(minX, minY, maxX, maxY);
neighbours.AddRange(remotes);
return neighbours;
}
public override LandData RequestLandData(ulong regionHandle, uint x, uint y)
{
LandData land = m_remoteBackend.RequestLandData(regionHandle, x, y);
if (land == null)
land = base.RequestLandData(regionHandle, x, y);
return land;
}
public override List<RegionInfo> RequestNamedRegions(string name, int maxNumber)
{
List<RegionInfo> infos = m_remoteBackend.RequestNamedRegions(name, maxNumber);
List<RegionInfo> remotes = base.RequestNamedRegions(name, maxNumber);
infos.AddRange(remotes);
return infos;
}
#endregion
#region IInterRegionCommunications interface
public override bool AcknowledgeAgentCrossed(ulong regionHandle, UUID agentId)
{
return m_remoteBackend.AcknowledgeAgentCrossed(regionHandle, agentId);
}
public override bool AcknowledgePrimCrossed(ulong regionHandle, UUID primID)
{
return m_remoteBackend.AcknowledgePrimCrossed(regionHandle, primID);
}
public override bool CheckRegion(string address, uint port)
{
return m_remoteBackend.CheckRegion(address, port);
}
public override bool ChildAgentUpdate(ulong regionHandle, ChildAgentDataUpdate cAgentData)
{
return m_remoteBackend.ChildAgentUpdate(regionHandle, cAgentData);
}
public override bool ExpectAvatarCrossing(ulong regionHandle, UUID agentID, Vector3 position, bool isFlying)
{
if (base.ExpectAvatarCrossing(regionHandle, agentID, position, isFlying))
return true;
return m_remoteBackend.ExpectAvatarCrossing(regionHandle, agentID, position, isFlying);
}
public override bool ExpectPrimCrossing(ulong regionHandle, UUID primID, Vector3 position, bool isFlying)
{
return m_remoteBackend.ExpectPrimCrossing(regionHandle, primID, position, isFlying);
}
public override bool InformRegionOfChildAgent(ulong regionHandle, AgentCircuitData agentData)
{
CachedUserInfo user = m_userProfileCache.GetUserDetails(agentData.AgentID);
if (IsLocalUser(user))
{
Console.WriteLine("XXX Home User XXX");
if (IsHyperlinkRegion(regionHandle))
{
Console.WriteLine("XXX Going Hyperlink XXX");
return base.InformRegionOfChildAgent(regionHandle, agentData);
}
else
{
// non-hypergrid case
Console.WriteLine("XXX Going local-grid region XXX");
return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData);
}
}
// Foregin users
Console.WriteLine("XXX Foreign User XXX");
if (IsLocalRegion(regionHandle)) // regions on the same instance
{
Console.WriteLine("XXX Going onInstance region XXX");
return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData);
}
if (IsHyperlinkRegion(regionHandle)) // hyperlinked regions
{
Console.WriteLine("XXX Going Hyperlink XXX");
return base.InformRegionOfChildAgent(regionHandle, agentData);
}
else
{
// foreign user going to a non-local region on the same grid
// We need to inform that region about this user before
// proceeding to the normal backend process.
Console.WriteLine("XXX Going local-grid region XXX");
RegionInfo regInfo = RequestNeighbourInfo(regionHandle);
if (regInfo != null)
InformRegionOfUser(regInfo, agentData);
return m_remoteBackend.InformRegionOfChildAgent(regionHandle, agentData);
}
}
public override bool InformRegionOfPrimCrossing(ulong regionHandle, UUID primID, string objData, int XMLMethod)
{
return m_remoteBackend.InformRegionOfPrimCrossing(regionHandle, primID, objData, XMLMethod);
}
public override bool RegionUp(SerializableRegionInfo region, ulong regionhandle)
{
if (m_remoteBackend.RegionUp(region, regionhandle))
return true;
return base.RegionUp(region, regionhandle);
}
public override bool TellRegionToCloseChildConnection(ulong regionHandle, UUID agentID)
{
return m_remoteBackend.TellRegionToCloseChildConnection(regionHandle, agentID);
}
#endregion
#region Methods triggered by calls from external instances
/// <summary>
///
/// </summary>
/// <param name="regionHandle"></param>
/// <param name="agentData"></param>
/// <returns></returns>
public bool IncomingChildAgent(ulong regionHandle, AgentCircuitData agentData)
{
HGIncomingChildAgent(regionHandle, agentData);
m_log.Info("[HGrid]: Incoming HGrid Agent " + agentData.firstname + " " + agentData.lastname);
return m_remoteBackend.IncomingChildAgent(regionHandle, agentData);
}
#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/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND 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 THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 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 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 OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Reflection;
using OpenMetaverse;
using log4net;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers;
using OpenSim.Framework.Statistics;
using OpenSim.Region.Communications.Local;
namespace OpenSim.Region.Communications.Hypergrid
{
public class HGInventoryService : LocalInventoryService, ISecureInventoryService
{
private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private string _inventoryServerUrl;
//private Uri m_Uri;
private UserProfileCacheService m_userProfileCache;
private bool m_gridmode = false;
private Dictionary<UUID, InventoryReceiptCallback> m_RequestingInventory
= new Dictionary<UUID, InventoryReceiptCallback>();
public UserProfileCacheService UserProfileCache
{
set { m_userProfileCache = value; }
}
public HGInventoryService(string inventoryServerUrl, UserProfileCacheService userProfileCacheService, bool gridmode)
{
_inventoryServerUrl = HGNetworkServersInfo.ServerURI(inventoryServerUrl);
//m_Uri = new Uri(_inventoryServerUrl);
m_userProfileCache = userProfileCacheService;
m_gridmode = gridmode;
}
#region ISecureInventoryService Members
public void RequestInventoryForUser(UUID userID, UUID session_id, InventoryReceiptCallback callback)
{
if (IsLocalStandaloneUser(userID))
{
base.RequestInventoryForUser(userID, callback);
return;
}
// grid/hypergrid mode
if (!m_RequestingInventory.ContainsKey(userID))
{
m_RequestingInventory.Add(userID, callback);
try
{
string invServer = GetUserInventoryURI(userID);
m_log.InfoFormat(
"[HGrid INVENTORY SERVICE]: Requesting inventory from {0}/GetInventory/ for user {1} ({2})",
/*_inventoryServerUrl*/ invServer, userID, userID.Guid);
RestSessionObjectPosterResponse<Guid, InventoryCollection> requester
= new RestSessionObjectPosterResponse<Guid, InventoryCollection>();
requester.ResponseCallback = InventoryResponse;
requester.BeginPostObject(invServer + "/GetInventory/", userID.Guid, session_id.ToString(), userID.ToString());
//Test(userID.Guid);
//RestObjectPosterResponse<InventoryCollection> requester
// = new RestObjectPosterResponse<InventoryCollection>();
//requester.ResponseCallback = InventoryResponse;
//requester.BeginPostObject<Guid>(/*_inventoryServerUrl*/ invServer + "/GetInventory/", userID.Guid);
//RestClient cli = new RestClient(invServer + "/GetInventory/" + userID.Guid);
//Stream reply = cli.Request();
}
catch (WebException e)
{
if (StatsManager.SimExtraStats != null)
StatsManager.SimExtraStats.AddInventoryServiceRetrievalFailure();
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Request inventory operation failed, {0} {1}",
e.Source, e.Message);
}
}
else
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: RequestInventoryForUser() - could not find user profile for {0}", userID);
}
}
/// <summary>
/// Add a new folder to the user's inventory
/// </summary>
/// <param name="folder"></param>
/// <returns>true if the folder was successfully added</returns>
public bool AddFolder(InventoryFolderBase folder, UUID session_id)
{
if (IsLocalStandaloneUser(folder.Owner))
{
return base.AddFolder(folder);
}
try
{
string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/NewFolder/", folder, session_id.ToString(), folder.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Add new inventory folder operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Update a folder in the user's inventory
/// </summary>
/// <param name="folder"></param>
/// <returns>true if the folder was successfully updated</returns>
public bool UpdateFolder(InventoryFolderBase folder, UUID session_id)
{
if (IsLocalStandaloneUser(folder.Owner))
{
return base.UpdateFolder(folder);
}
try
{
string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/UpdateFolder/", folder, session_id.ToString(), folder.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Update inventory folder operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Move an inventory folder to a new location
/// </summary>
/// <param name="folder">A folder containing the details of the new location</param>
/// <returns>true if the folder was successfully moved</returns>
public bool MoveFolder(InventoryFolderBase folder, UUID session_id)
{
if (IsLocalStandaloneUser(folder.Owner))
{
return base.MoveFolder(folder);
}
try
{
string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/MoveFolder/", folder, session_id.ToString(), folder.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Move inventory folder operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Purge an inventory folder of all its items and subfolders.
/// </summary>
/// <param name="folder"></param>
/// <returns>true if the folder was successfully purged</returns>
public bool PurgeFolder(InventoryFolderBase folder, UUID session_id)
{
if (IsLocalStandaloneUser(folder.Owner))
{
return base.PurgeFolder(folder);
}
try
{
string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/PurgeFolder/", folder, session_id.ToString(), folder.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Move inventory folder operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Add a new item to the user's inventory
/// </summary>
/// <param name="item"></param>
/// <returns>true if the item was successfully added</returns>
public bool AddItem(InventoryItemBase item, UUID session_id)
{
if (IsLocalStandaloneUser(item.Owner))
{
return base.AddItem(item);
}
try
{
string invServ = GetUserInventoryURI(item.Owner);
return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject(
"POST", invServ + "/NewItem/", item, session_id.ToString(), item.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Add new inventory item operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Update an item in the user's inventory
/// </summary>
/// <param name="item"></param>
/// <returns>true if the item was successfully updated</returns>
public bool UpdateItem(InventoryItemBase item, UUID session_id)
{
if (IsLocalStandaloneUser(item.Owner))
{
return base.UpdateItem(item);
}
try
{
string invServ = GetUserInventoryURI(item.Owner);
return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject(
"POST", invServ + "/NewItem/", item, session_id.ToString(), item.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Update new inventory item operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Delete an item from the user's inventory
/// </summary>
/// <param name="item"></param>
/// <returns>true if the item was successfully deleted</returns>
public bool DeleteItem(InventoryItemBase item, UUID session_id)
{
if (IsLocalStandaloneUser(item.Owner))
{
return base.DeleteItem(item);
}
try
{
string invServ = GetUserInventoryURI(item.Owner);
return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject(
"POST", invServ + "/DeleteItem/", item, session_id.ToString(), item.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Delete inventory item operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
#endregion
#region Methods common to ISecureInventoryService and IInventoryService
/// <summary>
/// Does the given user have an inventory structure?
/// </summary>
/// <param name="userID"></param>
/// <returns></returns>
public override bool HasInventoryForUser(UUID userID)
{
if (IsLocalStandaloneUser(userID))
{
return base.HasInventoryForUser(userID);
}
return false;
}
/// <summary>
/// Retrieve the root inventory folder for the given user.
/// </summary>
/// <param name="userID"></param>
/// <returns>null if no root folder was found</returns>
public override InventoryFolderBase RequestRootFolder(UUID userID)
{
if (IsLocalStandaloneUser(userID))
{
return base.RequestRootFolder(userID);
}
return null;
}
#endregion
/// <summary>
/// Callback used by the inventory server GetInventory request
/// </summary>
/// <param name="userID"></param>
private void InventoryResponse(InventoryCollection response)
{
UUID userID = response.UserID;
if (m_RequestingInventory.ContainsKey(userID))
{
m_log.InfoFormat("[HGrid INVENTORY SERVICE]: " +
"Received inventory response for user {0} containing {1} folders and {2} items",
userID, response.Folders.Count, response.Items.Count);
InventoryFolderImpl rootFolder = null;
InventoryReceiptCallback callback = m_RequestingInventory[userID];
ICollection<InventoryFolderImpl> folders = new List<InventoryFolderImpl>();
ICollection<InventoryItemBase> items = new List<InventoryItemBase>();
foreach (InventoryFolderBase folder in response.Folders)
{
if (folder.ParentID == UUID.Zero)
{
rootFolder = new InventoryFolderImpl(folder);
folders.Add(rootFolder);
break;
}
}
if (rootFolder != null)
{
foreach (InventoryFolderBase folder in response.Folders)
{
if (folder.ID != rootFolder.ID)
{
folders.Add(new InventoryFolderImpl(folder));
}
}
foreach (InventoryItemBase item in response.Items)
{
items.Add(item);
}
}
else
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Did not get back an inventory containing a root folder for user {0}", userID);
}
callback(folders, items);
m_RequestingInventory.Remove(userID);
}
else
{
m_log.WarnFormat(
"[HGrid INVENTORY SERVICE]: " +
"Received inventory response for {0} for which we do not have a record of requesting!",
userID);
}
}
private bool IsLocalStandaloneUser(UUID userID)
{
CachedUserInfo uinfo = m_userProfileCache.GetUserDetails(userID);
if (uinfo == null)
return true;
string userInventoryServerURI = HGNetworkServersInfo.ServerURI(uinfo.UserProfile.UserInventoryURI);
if ((!m_gridmode) && ((userInventoryServerURI == _inventoryServerUrl)) || (userInventoryServerURI == ""))
{
return true;
}
return false;
}
private string GetUserInventoryURI(UUID userID)
{
string invURI = _inventoryServerUrl;
CachedUserInfo uinfo = m_userProfileCache.GetUserDetails(userID);
if ((uinfo == null) || (uinfo.UserProfile == null))
return invURI;
string userInventoryServerURI = HGNetworkServersInfo.ServerURI(uinfo.UserProfile.UserInventoryURI);
if ((userInventoryServerURI != null) &&
(userInventoryServerURI != ""))
invURI = userInventoryServerURI;
return invURI;
}
}
}
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND 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 THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 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 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 OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Reflection;
using OpenMetaverse;
using log4net;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers;
using OpenSim.Framework.Statistics;
using OpenSim.Region.Communications.Local;
namespace OpenSim.Region.Communications.Hypergrid
{
public class HGInventoryService : LocalInventoryService, ISecureInventoryService
{
private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private string _inventoryServerUrl;
//private Uri m_Uri;
private UserProfileCacheService m_userProfileCache;
private bool m_gridmode = false;
private Dictionary<UUID, InventoryReceiptCallback> m_RequestingInventory
= new Dictionary<UUID, InventoryReceiptCallback>();
public UserProfileCacheService UserProfileCache
{
set { m_userProfileCache = value; }
}
public HGInventoryService(string inventoryServerUrl, UserProfileCacheService userProfileCacheService, bool gridmode)
{
_inventoryServerUrl = HGNetworkServersInfo.ServerURI(inventoryServerUrl);
//m_Uri = new Uri(_inventoryServerUrl);
m_userProfileCache = userProfileCacheService;
m_gridmode = gridmode;
}
#region ISecureInventoryService Members
public void RequestInventoryForUser(UUID userID, UUID session_id, InventoryReceiptCallback callback)
{
if (IsLocalStandaloneUser(userID))
{
base.RequestInventoryForUser(userID, callback);
return;
}
// grid/hypergrid mode
if (!m_RequestingInventory.ContainsKey(userID))
{
m_RequestingInventory.Add(userID, callback);
try
{
string invServer = GetUserInventoryURI(userID);
m_log.InfoFormat(
"[HGrid INVENTORY SERVICE]: Requesting inventory from {0}/GetInventory/ for user {1} ({2})",
/*_inventoryServerUrl*/ invServer, userID, userID.Guid);
RestSessionObjectPosterResponse<Guid, InventoryCollection> requester
= new RestSessionObjectPosterResponse<Guid, InventoryCollection>();
requester.ResponseCallback = InventoryResponse;
requester.BeginPostObject(invServer + "/GetInventory/", userID.Guid, session_id.ToString(), userID.ToString());
//Test(userID.Guid);
//RestObjectPosterResponse<InventoryCollection> requester
// = new RestObjectPosterResponse<InventoryCollection>();
//requester.ResponseCallback = InventoryResponse;
//requester.BeginPostObject<Guid>(/*_inventoryServerUrl*/ invServer + "/GetInventory/", userID.Guid);
//RestClient cli = new RestClient(invServer + "/GetInventory/" + userID.Guid);
//Stream reply = cli.Request();
}
catch (WebException e)
{
if (StatsManager.SimExtraStats != null)
StatsManager.SimExtraStats.AddInventoryServiceRetrievalFailure();
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Request inventory operation failed, {0} {1}",
e.Source, e.Message);
}
}
else
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: RequestInventoryForUser() - could not find user profile for {0}", userID);
}
}
/// <summary>
/// Add a new folder to the user's inventory
/// </summary>
/// <param name="folder"></param>
/// <returns>true if the folder was successfully added</returns>
public bool AddFolder(InventoryFolderBase folder, UUID session_id)
{
if (IsLocalStandaloneUser(folder.Owner))
{
return base.AddFolder(folder);
}
try
{
string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/NewFolder/", folder, session_id.ToString(), folder.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Add new inventory folder operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Update a folder in the user's inventory
/// </summary>
/// <param name="folder"></param>
/// <returns>true if the folder was successfully updated</returns>
public bool UpdateFolder(InventoryFolderBase folder, UUID session_id)
{
if (IsLocalStandaloneUser(folder.Owner))
{
return base.UpdateFolder(folder);
}
try
{
string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/UpdateFolder/", folder, session_id.ToString(), folder.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Update inventory folder operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Move an inventory folder to a new location
/// </summary>
/// <param name="folder">A folder containing the details of the new location</param>
/// <returns>true if the folder was successfully moved</returns>
public bool MoveFolder(InventoryFolderBase folder, UUID session_id)
{
if (IsLocalStandaloneUser(folder.Owner))
{
return base.MoveFolder(folder);
}
try
{
string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/MoveFolder/", folder, session_id.ToString(), folder.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Move inventory folder operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Purge an inventory folder of all its items and subfolders.
/// </summary>
/// <param name="folder"></param>
/// <returns>true if the folder was successfully purged</returns>
public bool PurgeFolder(InventoryFolderBase folder, UUID session_id)
{
if (IsLocalStandaloneUser(folder.Owner))
{
return base.PurgeFolder(folder);
}
try
{
string invServ = GetUserInventoryURI(folder.Owner);
return SynchronousRestSessionObjectPoster<InventoryFolderBase, bool>.BeginPostObject(
"POST", invServ + "/PurgeFolder/", folder, session_id.ToString(), folder.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Move inventory folder operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Add a new item to the user's inventory
/// </summary>
/// <param name="item"></param>
/// <returns>true if the item was successfully added</returns>
public bool AddItem(InventoryItemBase item, UUID session_id)
{
if (IsLocalStandaloneUser(item.Owner))
{
return base.AddItem(item);
}
try
{
string invServ = GetUserInventoryURI(item.Owner);
return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject(
"POST", invServ + "/NewItem/", item, session_id.ToString(), item.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Add new inventory item operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Update an item in the user's inventory
/// </summary>
/// <param name="item"></param>
/// <returns>true if the item was successfully updated</returns>
public bool UpdateItem(InventoryItemBase item, UUID session_id)
{
if (IsLocalStandaloneUser(item.Owner))
{
return base.UpdateItem(item);
}
try
{
string invServ = GetUserInventoryURI(item.Owner);
return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject(
"POST", invServ + "/NewItem/", item, session_id.ToString(), item.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Update new inventory item operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
/// <summary>
/// Delete an item from the user's inventory
/// </summary>
/// <param name="item"></param>
/// <returns>true if the item was successfully deleted</returns>
public bool DeleteItem(InventoryItemBase item, UUID session_id)
{
if (IsLocalStandaloneUser(item.Owner))
{
return base.DeleteItem(item);
}
try
{
string invServ = GetUserInventoryURI(item.Owner);
return SynchronousRestSessionObjectPoster<InventoryItemBase, bool>.BeginPostObject(
"POST", invServ + "/DeleteItem/", item, session_id.ToString(), item.Owner.ToString());
}
catch (WebException e)
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Delete inventory item operation failed, {0} {1}",
e.Source, e.Message);
}
return false;
}
#endregion
#region Methods common to ISecureInventoryService and IInventoryService
/// <summary>
/// Does the given user have an inventory structure?
/// </summary>
/// <param name="userID"></param>
/// <returns></returns>
public override bool HasInventoryForUser(UUID userID)
{
if (IsLocalStandaloneUser(userID))
{
return base.HasInventoryForUser(userID);
}
return false;
}
/// <summary>
/// Retrieve the root inventory folder for the given user.
/// </summary>
/// <param name="userID"></param>
/// <returns>null if no root folder was found</returns>
public override InventoryFolderBase RequestRootFolder(UUID userID)
{
if (IsLocalStandaloneUser(userID))
{
return base.RequestRootFolder(userID);
}
return null;
}
#endregion
/// <summary>
/// Callback used by the inventory server GetInventory request
/// </summary>
/// <param name="userID"></param>
private void InventoryResponse(InventoryCollection response)
{
UUID userID = response.UserID;
if (m_RequestingInventory.ContainsKey(userID))
{
m_log.InfoFormat("[HGrid INVENTORY SERVICE]: " +
"Received inventory response for user {0} containing {1} folders and {2} items",
userID, response.Folders.Count, response.Items.Count);
InventoryFolderImpl rootFolder = null;
InventoryReceiptCallback callback = m_RequestingInventory[userID];
ICollection<InventoryFolderImpl> folders = new List<InventoryFolderImpl>();
ICollection<InventoryItemBase> items = new List<InventoryItemBase>();
foreach (InventoryFolderBase folder in response.Folders)
{
if (folder.ParentID == UUID.Zero)
{
rootFolder = new InventoryFolderImpl(folder);
folders.Add(rootFolder);
break;
}
}
if (rootFolder != null)
{
foreach (InventoryFolderBase folder in response.Folders)
{
if (folder.ID != rootFolder.ID)
{
folders.Add(new InventoryFolderImpl(folder));
}
}
foreach (InventoryItemBase item in response.Items)
{
items.Add(item);
}
}
else
{
m_log.ErrorFormat("[HGrid INVENTORY SERVICE]: Did not get back an inventory containing a root folder for user {0}", userID);
}
callback(folders, items);
m_RequestingInventory.Remove(userID);
}
else
{
m_log.WarnFormat(
"[HGrid INVENTORY SERVICE]: " +
"Received inventory response for {0} for which we do not have a record of requesting!",
userID);
}
}
private bool IsLocalStandaloneUser(UUID userID)
{
CachedUserInfo uinfo = m_userProfileCache.GetUserDetails(userID);
if (uinfo == null)
return true;
string userInventoryServerURI = HGNetworkServersInfo.ServerURI(uinfo.UserProfile.UserInventoryURI);
if ((!m_gridmode) && ((userInventoryServerURI == _inventoryServerUrl)) || (userInventoryServerURI == ""))
{
return true;
}
return false;
}
private string GetUserInventoryURI(UUID userID)
{
string invURI = _inventoryServerUrl;
CachedUserInfo uinfo = m_userProfileCache.GetUserDetails(userID);
if ((uinfo == null) || (uinfo.UserProfile == null))
return invURI;
string userInventoryServerURI = HGNetworkServersInfo.ServerURI(uinfo.UserProfile.UserInventoryURI);
if ((userInventoryServerURI != null) &&
(userInventoryServerURI != ""))
invURI = userInventoryServerURI;
return invURI;
}
}
}

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

@ -1,267 +1,267 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND 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 THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 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 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 OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Reflection;
using System.Text.RegularExpressions;
using OpenMetaverse;
using log4net;
using Nwc.XmlRpc;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Region.Communications.OGS1;
namespace OpenSim.Region.Communications.Hypergrid
{
/// <summary>
/// For the time being, this class is just an identity wrapper around OGS1UserServices,
/// so it always fails for foreign users.
/// Later it needs to talk with the foreign users' user servers.
/// </summary>
public class HGUserServices : IUserService, IAvatarService, IMessagingService
{
//private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
//private HGCommunicationsGridMode m_parent;
private OGS1UserServices m_remoteUserServices;
public HGUserServices(HGCommunicationsGridMode parent)
{
//m_parent = parent;
m_remoteUserServices = new OGS1UserServices(parent);
}
public UserProfileData ConvertXMLRPCDataToUserProfile(Hashtable data)
{
return m_remoteUserServices.ConvertXMLRPCDataToUserProfile(data);
}
/// <summary>
/// Get a user agent from the user server
/// </summary>
/// <param name="avatarID"></param>
/// <returns>null if the request fails</returns>
public UserAgentData GetAgentByUUID(UUID userId)
{
return m_remoteUserServices.GetAgentByUUID(userId);
}
public AvatarAppearance ConvertXMLRPCDataToAvatarAppearance(Hashtable data)
{
return m_remoteUserServices.ConvertXMLRPCDataToAvatarAppearance(data);
}
public List<AvatarPickerAvatar> ConvertXMLRPCDataToAvatarPickerList(UUID queryID, Hashtable data)
{
return m_remoteUserServices.ConvertXMLRPCDataToAvatarPickerList(queryID, data);
}
public List<FriendListItem> ConvertXMLRPCDataToFriendListItemList(Hashtable data)
{
return m_remoteUserServices.ConvertXMLRPCDataToFriendListItemList(data);
}
/// <summary>
/// Logs off a user on the user server
/// </summary>
/// <param name="UserID">UUID of the user</param>
/// <param name="regionID">UUID of the Region</param>
/// <param name="regionhandle">regionhandle</param>
/// <param name="position">final position</param>
/// <param name="lookat">final lookat</param>
public void LogOffUser(UUID userid, UUID regionid, ulong regionhandle, Vector3 position, Vector3 lookat)
{
m_remoteUserServices.LogOffUser(userid, regionid, regionhandle, position, lookat);
}
/// <summary>
/// Logs off a user on the user server (deprecated as of 2008-08-27)
/// </summary>
/// <param name="UserID">UUID of the user</param>
/// <param name="regionID">UUID of the Region</param>
/// <param name="regionhandle">regionhandle</param>
/// <param name="posx">final position x</param>
/// <param name="posy">final position y</param>
/// <param name="posz">final position z</param>
public void LogOffUser(UUID userid, UUID regionid, ulong regionhandle, float posx, float posy, float posz)
{
m_remoteUserServices.LogOffUser(userid, regionid, regionhandle, posx, posy, posz);
}
public UserProfileData GetUserProfile(string firstName, string lastName)
{
return GetUserProfile(firstName + " " + lastName);
}
public void UpdateUserCurrentRegion(UUID avatarid, UUID regionuuid, ulong regionhandle)
{
m_remoteUserServices.UpdateUserCurrentRegion(avatarid, regionuuid, regionhandle);
}
public List<AvatarPickerAvatar> GenerateAgentPickerRequestResponse(UUID queryID, string query)
{
return m_remoteUserServices.GenerateAgentPickerRequestResponse(queryID, query);
}
/// <summary>
/// Get a user profile from the user server
/// </summary>
/// <param name="avatarID"></param>
/// <returns>null if the request fails</returns>
public UserProfileData GetUserProfile(string name)
{
return m_remoteUserServices.GetUserProfile(name);
}
/// <summary>
/// Get a user profile from the user server
/// </summary>
/// <param name="avatarID"></param>
/// <returns>null if the request fails</returns>
public UserProfileData GetUserProfile(UUID avatarID)
{
return m_remoteUserServices.GetUserProfile(avatarID);
}
public void ClearUserAgent(UUID avatarID)
{
m_remoteUserServices.ClearUserAgent(avatarID);
}
/// <summary>
/// Retrieve the user information for the given master uuid.
/// </summary>
/// <param name="uuid"></param>
/// <returns></returns>
public UserProfileData SetupMasterUser(string firstName, string lastName)
{
return m_remoteUserServices.SetupMasterUser(firstName, lastName);
}
/// <summary>
/// Retrieve the user information for the given master uuid.
/// </summary>
/// <param name="uuid"></param>
/// <returns></returns>
public UserProfileData SetupMasterUser(string firstName, string lastName, string password)
{
return m_remoteUserServices.SetupMasterUser(firstName, lastName, password);
}
/// <summary>
/// Retrieve the user information for the given master uuid.
/// </summary>
/// <param name="uuid"></param>
/// <returns></returns>
public UserProfileData SetupMasterUser(UUID uuid)
{
return m_remoteUserServices.SetupMasterUser(uuid);
}
public UUID AddUserProfile(string firstName, string lastName, string pass, uint regX, uint regY)
{
return m_remoteUserServices.AddUserProfile(firstName, lastName, pass, regX, regY);
}
public bool ResetUserPassword(string firstName, string lastName, string newPassword)
{
return m_remoteUserServices.ResetUserPassword(firstName, lastName, newPassword);
}
public bool UpdateUserProfile(UserProfileData userProfile)
{
return m_remoteUserServices.UpdateUserProfile(userProfile);
}
#region IUserServices Friend Methods
/// <summary>
/// Adds a new friend to the database for XUser
/// </summary>
/// <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="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)
{
m_remoteUserServices.AddNewUserFriend(friendlistowner, friend, perms);
}
/// <summary>
/// Delete friend on friendlistowner's friendlist.
/// </summary>
/// <param name="friendlistowner">The agent that who's friends list is being updated</param>
/// <param name="friend">The Ex-friend agent</param>
public void RemoveUserFriend(UUID friendlistowner, UUID friend)
{
m_remoteUserServices.RemoveUserFriend(friend, friend);
}
/// <summary>
/// Update permissions for friend on friendlistowner's friendlist.
/// </summary>
/// <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="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)
{
m_remoteUserServices.UpdateUserFriendPerms(friendlistowner, friend, perms);
}
/// <summary>
/// Returns a list of FriendsListItems that describe the friends and permissions in the friend relationship for UUID friendslistowner
/// </summary>
/// <param name="friendlistowner">The agent that we're retreiving the friends Data.</param>
public List<FriendListItem> GetUserFriendList(UUID friendlistowner)
{
return m_remoteUserServices.GetUserFriendList(friendlistowner);
}
#endregion
/// Appearance
public AvatarAppearance GetUserAppearance(UUID user)
{
return m_remoteUserServices.GetUserAppearance(user);
}
public void UpdateUserAppearance(UUID user, AvatarAppearance appearance)
{
m_remoteUserServices.UpdateUserAppearance(user, appearance);
}
#region IMessagingService
public Dictionary<UUID, FriendRegionInfo> GetFriendRegionInfos(List<UUID> uuids)
{
return m_remoteUserServices.GetFriendRegionInfos(uuids);
}
#endregion
}
}
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND 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 THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 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 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 OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Reflection;
using System.Text.RegularExpressions;
using OpenMetaverse;
using log4net;
using Nwc.XmlRpc;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Region.Communications.OGS1;
namespace OpenSim.Region.Communications.Hypergrid
{
/// <summary>
/// For the time being, this class is just an identity wrapper around OGS1UserServices,
/// so it always fails for foreign users.
/// Later it needs to talk with the foreign users' user servers.
/// </summary>
public class HGUserServices : IUserService, IAvatarService, IMessagingService
{
//private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
//private HGCommunicationsGridMode m_parent;
private OGS1UserServices m_remoteUserServices;
public HGUserServices(HGCommunicationsGridMode parent)
{
//m_parent = parent;
m_remoteUserServices = new OGS1UserServices(parent);
}
public UserProfileData ConvertXMLRPCDataToUserProfile(Hashtable data)
{
return m_remoteUserServices.ConvertXMLRPCDataToUserProfile(data);
}
/// <summary>
/// Get a user agent from the user server
/// </summary>
/// <param name="avatarID"></param>
/// <returns>null if the request fails</returns>
public UserAgentData GetAgentByUUID(UUID userId)
{
return m_remoteUserServices.GetAgentByUUID(userId);
}
public AvatarAppearance ConvertXMLRPCDataToAvatarAppearance(Hashtable data)
{
return m_remoteUserServices.ConvertXMLRPCDataToAvatarAppearance(data);
}
public List<AvatarPickerAvatar> ConvertXMLRPCDataToAvatarPickerList(UUID queryID, Hashtable data)
{
return m_remoteUserServices.ConvertXMLRPCDataToAvatarPickerList(queryID, data);
}
public List<FriendListItem> ConvertXMLRPCDataToFriendListItemList(Hashtable data)
{
return m_remoteUserServices.ConvertXMLRPCDataToFriendListItemList(data);
}
/// <summary>
/// Logs off a user on the user server
/// </summary>
/// <param name="UserID">UUID of the user</param>
/// <param name="regionID">UUID of the Region</param>
/// <param name="regionhandle">regionhandle</param>
/// <param name="position">final position</param>
/// <param name="lookat">final lookat</param>
public void LogOffUser(UUID userid, UUID regionid, ulong regionhandle, Vector3 position, Vector3 lookat)
{
m_remoteUserServices.LogOffUser(userid, regionid, regionhandle, position, lookat);
}
/// <summary>
/// Logs off a user on the user server (deprecated as of 2008-08-27)
/// </summary>
/// <param name="UserID">UUID of the user</param>
/// <param name="regionID">UUID of the Region</param>
/// <param name="regionhandle">regionhandle</param>
/// <param name="posx">final position x</param>
/// <param name="posy">final position y</param>
/// <param name="posz">final position z</param>
public void LogOffUser(UUID userid, UUID regionid, ulong regionhandle, float posx, float posy, float posz)
{
m_remoteUserServices.LogOffUser(userid, regionid, regionhandle, posx, posy, posz);
}
public UserProfileData GetUserProfile(string firstName, string lastName)
{
return GetUserProfile(firstName + " " + lastName);
}
public void UpdateUserCurrentRegion(UUID avatarid, UUID regionuuid, ulong regionhandle)
{
m_remoteUserServices.UpdateUserCurrentRegion(avatarid, regionuuid, regionhandle);
}
public List<AvatarPickerAvatar> GenerateAgentPickerRequestResponse(UUID queryID, string query)
{
return m_remoteUserServices.GenerateAgentPickerRequestResponse(queryID, query);
}
/// <summary>
/// Get a user profile from the user server
/// </summary>
/// <param name="avatarID"></param>
/// <returns>null if the request fails</returns>
public UserProfileData GetUserProfile(string name)
{
return m_remoteUserServices.GetUserProfile(name);
}
/// <summary>
/// Get a user profile from the user server
/// </summary>
/// <param name="avatarID"></param>
/// <returns>null if the request fails</returns>
public UserProfileData GetUserProfile(UUID avatarID)
{
return m_remoteUserServices.GetUserProfile(avatarID);
}
public void ClearUserAgent(UUID avatarID)
{
m_remoteUserServices.ClearUserAgent(avatarID);
}
/// <summary>
/// Retrieve the user information for the given master uuid.
/// </summary>
/// <param name="uuid"></param>
/// <returns></returns>
public UserProfileData SetupMasterUser(string firstName, string lastName)
{
return m_remoteUserServices.SetupMasterUser(firstName, lastName);
}
/// <summary>
/// Retrieve the user information for the given master uuid.
/// </summary>
/// <param name="uuid"></param>
/// <returns></returns>
public UserProfileData SetupMasterUser(string firstName, string lastName, string password)
{
return m_remoteUserServices.SetupMasterUser(firstName, lastName, password);
}
/// <summary>
/// Retrieve the user information for the given master uuid.
/// </summary>
/// <param name="uuid"></param>
/// <returns></returns>
public UserProfileData SetupMasterUser(UUID uuid)
{
return m_remoteUserServices.SetupMasterUser(uuid);
}
public UUID AddUserProfile(string firstName, string lastName, string pass, uint regX, uint regY)
{
return m_remoteUserServices.AddUserProfile(firstName, lastName, pass, regX, regY);
}
public bool ResetUserPassword(string firstName, string lastName, string newPassword)
{
return m_remoteUserServices.ResetUserPassword(firstName, lastName, newPassword);
}
public bool UpdateUserProfile(UserProfileData userProfile)
{
return m_remoteUserServices.UpdateUserProfile(userProfile);
}
#region IUserServices Friend Methods
/// <summary>
/// Adds a new friend to the database for XUser
/// </summary>
/// <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="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)
{
m_remoteUserServices.AddNewUserFriend(friendlistowner, friend, perms);
}
/// <summary>
/// Delete friend on friendlistowner's friendlist.
/// </summary>
/// <param name="friendlistowner">The agent that who's friends list is being updated</param>
/// <param name="friend">The Ex-friend agent</param>
public void RemoveUserFriend(UUID friendlistowner, UUID friend)
{
m_remoteUserServices.RemoveUserFriend(friend, friend);
}
/// <summary>
/// Update permissions for friend on friendlistowner's friendlist.
/// </summary>
/// <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="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)
{
m_remoteUserServices.UpdateUserFriendPerms(friendlistowner, friend, perms);
}
/// <summary>
/// Returns a list of FriendsListItems that describe the friends and permissions in the friend relationship for UUID friendslistowner
/// </summary>
/// <param name="friendlistowner">The agent that we're retreiving the friends Data.</param>
public List<FriendListItem> GetUserFriendList(UUID friendlistowner)
{
return m_remoteUserServices.GetUserFriendList(friendlistowner);
}
#endregion
/// Appearance
public AvatarAppearance GetUserAppearance(UUID user)
{
return m_remoteUserServices.GetUserAppearance(user);
}
public void UpdateUserAppearance(UUID user, AvatarAppearance appearance)
{
m_remoteUserServices.UpdateUserAppearance(user, appearance);
}
#region IMessagingService
public Dictionary<UUID, FriendRegionInfo> GetFriendRegionInfos(List<UUID> uuids)
{
return m_remoteUserServices.GetFriendRegionInfos(uuids);
}
#endregion
}
}

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

@ -1,200 +1,200 @@
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Grid.AssetServer;
namespace OpenSim.Region.Environment.Modules.Hypergrid
{
public class HGStandaloneAssetService : IRegionModule
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private static bool initialized = false;
private static bool enabled = false;
Scene m_scene;
//AssetService m_assetService;
#region IRegionModule interface
public void Initialise(Scene scene, IConfigSource config)
{
if (!initialized)
{
initialized = true;
m_scene = scene;
// This module is only on for standalones in hypergrid mode
enabled = !config.Configs["Startup"].GetBoolean("gridmode", true) && config.Configs["Startup"].GetBoolean("hypergrid", false);
}
}
public void PostInitialise()
{
if (enabled)
{
m_log.Info("[HGStandaloneAssetService]: Starting...");
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Grid.AssetServer;
namespace OpenSim.Region.Environment.Modules.Hypergrid
{
public class HGStandaloneAssetService : IRegionModule
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private static bool initialized = false;
private static bool enabled = false;
Scene m_scene;
//AssetService m_assetService;
#region IRegionModule interface
public void Initialise(Scene scene, IConfigSource config)
{
if (!initialized)
{
initialized = true;
m_scene = scene;
// This module is only on for standalones in hypergrid mode
enabled = !config.Configs["Startup"].GetBoolean("gridmode", true) && config.Configs["Startup"].GetBoolean("hypergrid", false);
}
}
public void PostInitialise()
{
if (enabled)
{
m_log.Info("[HGStandaloneAssetService]: Starting...");
//m_assetService = new AssetService(m_scene);
new AssetService(m_scene);
}
}
public void Close()
{
}
public string Name
{
get { return "HGStandaloneAssetService"; }
}
public bool IsSharedModule
{
get { return true; }
}
#endregion
}
public class AssetService
{
private IUserService m_userService;
private bool m_doLookup = false;
public bool DoLookup
{
get { return m_doLookup; }
set { m_doLookup = value; }
}
private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
public AssetService(Scene m_scene)
{
AddHttpHandlers(m_scene);
m_userService = m_scene.CommsManager.UserService;
}
protected void AddHttpHandlers(Scene m_scene)
{
IAssetProviderPlugin m_assetProvider = ((AssetServerBase)m_scene.AssetCache.AssetServer).AssetProviderPlugin;
m_scene.AddStreamHandler(new GetAssetStreamHandler(m_assetProvider));
m_scene.AddStreamHandler(new PostAssetStreamHandler(m_assetProvider));
}
///// <summary>
///// Check that the source of an inventory request is one that we trust.
///// </summary>
///// <param name="peer"></param>
///// <returns></returns>
//public bool CheckTrustSource(IPEndPoint peer)
//{
// if (m_doLookup)
// {
// m_log.InfoFormat("[GRID AGENT INVENTORY]: Checking trusted source {0}", peer);
// UriBuilder ub = new UriBuilder(m_userserver_url);
// IPAddress[] uaddrs = Dns.GetHostAddresses(ub.Host);
// foreach (IPAddress uaddr in uaddrs)
// {
// if (uaddr.Equals(peer.Address))
// {
// return true;
// }
// }
// m_log.WarnFormat(
// "[GRID AGENT INVENTORY]: Rejecting request since source {0} was not in the list of trusted sources",
// peer);
// return false;
// }
// else
// {
// return true;
// }
//}
/// <summary>
/// Check that the source of an inventory request for a particular agent is a current session belonging to
/// that agent.
/// </summary>
/// <param name="session_id"></param>
/// <param name="avatar_id"></param>
/// <returns></returns>
public bool CheckAuthSession(string session_id, string avatar_id)
{
if (m_doLookup)
{
m_log.InfoFormat("[HGStandaloneInvService]: checking authed session {0} {1}", session_id, avatar_id);
UUID userID = UUID.Zero;
UUID sessionID = UUID.Zero;
UUID.TryParse(avatar_id, out userID);
UUID.TryParse(session_id, out sessionID);
if (userID.Equals(UUID.Zero) || sessionID.Equals(UUID.Zero))
{
m_log.Info("[HGStandaloneInvService]: Invalid user or session id " + avatar_id + "; " + session_id);
return false;
}
UserProfileData userProfile = m_userService.GetUserProfile(userID);
if (userProfile != null && userProfile.CurrentAgent != null &&
userProfile.CurrentAgent.SessionID == sessionID)
{
m_log.Info("[HGStandaloneInvService]: user is logged in and session is valid. Authorizing access.");
return true;
}
m_log.Warn("[HGStandaloneInvService]: unknown user or session_id, request rejected");
return false;
}
else
{
return true;
}
}
}
}
new AssetService(m_scene);
}
}
public void Close()
{
}
public string Name
{
get { return "HGStandaloneAssetService"; }
}
public bool IsSharedModule
{
get { return true; }
}
#endregion
}
public class AssetService
{
private IUserService m_userService;
private bool m_doLookup = false;
public bool DoLookup
{
get { return m_doLookup; }
set { m_doLookup = value; }
}
private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
public AssetService(Scene m_scene)
{
AddHttpHandlers(m_scene);
m_userService = m_scene.CommsManager.UserService;
}
protected void AddHttpHandlers(Scene m_scene)
{
IAssetProviderPlugin m_assetProvider = ((AssetServerBase)m_scene.AssetCache.AssetServer).AssetProviderPlugin;
m_scene.AddStreamHandler(new GetAssetStreamHandler(m_assetProvider));
m_scene.AddStreamHandler(new PostAssetStreamHandler(m_assetProvider));
}
///// <summary>
///// Check that the source of an inventory request is one that we trust.
///// </summary>
///// <param name="peer"></param>
///// <returns></returns>
//public bool CheckTrustSource(IPEndPoint peer)
//{
// if (m_doLookup)
// {
// m_log.InfoFormat("[GRID AGENT INVENTORY]: Checking trusted source {0}", peer);
// UriBuilder ub = new UriBuilder(m_userserver_url);
// IPAddress[] uaddrs = Dns.GetHostAddresses(ub.Host);
// foreach (IPAddress uaddr in uaddrs)
// {
// if (uaddr.Equals(peer.Address))
// {
// return true;
// }
// }
// m_log.WarnFormat(
// "[GRID AGENT INVENTORY]: Rejecting request since source {0} was not in the list of trusted sources",
// peer);
// return false;
// }
// else
// {
// return true;
// }
//}
/// <summary>
/// Check that the source of an inventory request for a particular agent is a current session belonging to
/// that agent.
/// </summary>
/// <param name="session_id"></param>
/// <param name="avatar_id"></param>
/// <returns></returns>
public bool CheckAuthSession(string session_id, string avatar_id)
{
if (m_doLookup)
{
m_log.InfoFormat("[HGStandaloneInvService]: checking authed session {0} {1}", session_id, avatar_id);
UUID userID = UUID.Zero;
UUID sessionID = UUID.Zero;
UUID.TryParse(avatar_id, out userID);
UUID.TryParse(session_id, out sessionID);
if (userID.Equals(UUID.Zero) || sessionID.Equals(UUID.Zero))
{
m_log.Info("[HGStandaloneInvService]: Invalid user or session id " + avatar_id + "; " + session_id);
return false;
}
UserProfileData userProfile = m_userService.GetUserProfile(userID);
if (userProfile != null && userProfile.CurrentAgent != null &&
userProfile.CurrentAgent.SessionID == sessionID)
{
m_log.Info("[HGStandaloneInvService]: user is logged in and session is valid. Authorizing access.");
return true;
}
m_log.Warn("[HGStandaloneInvService]: unknown user or session_id, request rejected");
return false;
}
else
{
return true;
}
}
}
}

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

@ -1,316 +1,316 @@
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
namespace OpenSim.Region.Environment.Modules.Hypergrid
{
public class HGStandaloneInventoryService : IRegionModule
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private static bool initialized = false;
private static bool enabled = false;
Scene m_scene;
//InventoryService m_inventoryService;
#region IRegionModule interface
public void Initialise(Scene scene, IConfigSource config)
{
if (!initialized)
{
initialized = true;
m_scene = scene;
// This module is only on for standalones
enabled = !config.Configs["Startup"].GetBoolean("gridmode", true) && config.Configs["Startup"].GetBoolean("hypergrid", false);
}
}
public void PostInitialise()
{
if (enabled)
{
m_log.Info("[HGStandaloneInvService]: Starting...");
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
namespace OpenSim.Region.Environment.Modules.Hypergrid
{
public class HGStandaloneInventoryService : IRegionModule
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private static bool initialized = false;
private static bool enabled = false;
Scene m_scene;
//InventoryService m_inventoryService;
#region IRegionModule interface
public void Initialise(Scene scene, IConfigSource config)
{
if (!initialized)
{
initialized = true;
m_scene = scene;
// This module is only on for standalones
enabled = !config.Configs["Startup"].GetBoolean("gridmode", true) && config.Configs["Startup"].GetBoolean("hypergrid", false);
}
}
public void PostInitialise()
{
if (enabled)
{
m_log.Info("[HGStandaloneInvService]: Starting...");
//m_inventoryService = new InventoryService(m_scene);
new InventoryService(m_scene);
}
}
public void Close()
{
}
public string Name
{
get { return "HGStandaloneInventoryService"; }
}
public bool IsSharedModule
{
get { return true; }
}
#endregion
}
public class InventoryService
{
private InventoryServiceBase m_inventoryService;
private IUserService m_userService;
private bool m_doLookup = false;
public bool DoLookup
{
get { return m_doLookup; }
set { m_doLookup = value; }
}
private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
public InventoryService(Scene m_scene)
{
m_inventoryService = (InventoryServiceBase)m_scene.CommsManager.SecureInventoryService;
m_userService = m_scene.CommsManager.UserService;
AddHttpHandlers(m_scene);
}
protected void AddHttpHandlers(Scene m_scene)
{
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<Guid, InventoryCollection>(
"POST", "/GetInventory/", GetUserInventory, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/NewFolder/", m_inventoryService.AddFolder, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/UpdateFolder/", m_inventoryService.UpdateFolder, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/MoveFolder/", m_inventoryService.MoveFolder, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/PurgeFolder/", m_inventoryService.PurgeFolder, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryItemBase, bool>(
"POST", "/NewItem/", m_inventoryService.AddItem, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryItemBase, bool>(
"POST", "/DeleteItem/", m_inventoryService.DeleteItem, CheckAuthSession));
//// 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.
//// 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
//// to do this for now.
//m_scene.AddStreamHandler(
// new RestDeserialiseTrustedHandler<Guid, List<InventoryFolderBase>>
// ("POST", "/RootFolders/", GetInventorySkeleton, CheckTrustSource));
//// for persistent active gestures
//m_scene.AddStreamHandler(
// new RestDeserialiseTrustedHandler<Guid, List<InventoryItemBase>>
// ("POST", "/ActiveGestures/", GetActiveGestures, CheckTrustSource));
}
///// <summary>
///// Check that the source of an inventory request is one that we trust.
///// </summary>
///// <param name="peer"></param>
///// <returns></returns>
//public bool CheckTrustSource(IPEndPoint peer)
//{
// if (m_doLookup)
// {
// m_log.InfoFormat("[GRID AGENT INVENTORY]: Checking trusted source {0}", peer);
// UriBuilder ub = new UriBuilder(m_userserver_url);
// IPAddress[] uaddrs = Dns.GetHostAddresses(ub.Host);
// foreach (IPAddress uaddr in uaddrs)
// {
// if (uaddr.Equals(peer.Address))
// {
// return true;
// }
// }
// m_log.WarnFormat(
// "[GRID AGENT INVENTORY]: Rejecting request since source {0} was not in the list of trusted sources",
// peer);
// return false;
// }
// else
// {
// return true;
// }
//}
/// <summary>
/// Check that the source of an inventory request for a particular agent is a current session belonging to
/// that agent.
/// </summary>
/// <param name="session_id"></param>
/// <param name="avatar_id"></param>
/// <returns></returns>
public bool CheckAuthSession(string session_id, string avatar_id)
{
if (m_doLookup)
{
m_log.InfoFormat("[HGStandaloneInvService]: checking authed session {0} {1}", session_id, avatar_id);
UUID userID = UUID.Zero;
UUID sessionID = UUID.Zero;
UUID.TryParse(avatar_id, out userID);
UUID.TryParse(session_id, out sessionID);
if (userID.Equals(UUID.Zero) || sessionID.Equals(UUID.Zero))
{
m_log.Info("[HGStandaloneInvService]: Invalid user or session id " + avatar_id + "; " + session_id);
return false;
}
UserProfileData userProfile = m_userService.GetUserProfile(userID);
if (userProfile != null && userProfile.CurrentAgent != null &&
userProfile.CurrentAgent.SessionID == sessionID)
{
m_log.Info("[HGStandaloneInvService]: user is logged in and session is valid. Authorizing access.");
return true;
}
m_log.Warn("[HGStandaloneInvService]: unknown user or session_id, request rejected");
return false;
}
else
{
return true;
}
}
/// <summary>
/// Return a user's entire inventory
/// </summary>
/// <param name="rawUserID"></param>
/// <returns>The user's inventory. If an inventory cannot be found then an empty collection is returned.</returns>
public InventoryCollection GetUserInventory(Guid rawUserID)
{
UUID userID = new UUID(rawUserID);
m_log.Info("[HGStandaloneInvService]: Processing request for inventory of " + userID);
// Uncomment me to simulate a slow responding inventory server
//Thread.Sleep(16000);
InventoryCollection invCollection = new InventoryCollection();
List<InventoryFolderBase> allFolders = ((InventoryServiceBase)m_inventoryService).GetInventorySkeleton(userID);
if (null == allFolders)
{
m_log.WarnFormat("[HGStandaloneInvService]: No inventory found for user {0}", rawUserID);
return invCollection;
}
List<InventoryItemBase> allItems = new List<InventoryItemBase>();
foreach (InventoryFolderBase folder in allFolders)
{
List<InventoryItemBase> items = ((InventoryServiceBase)m_inventoryService).RequestFolderItems(folder.ID);
if (items != null)
{
allItems.InsertRange(0, items);
}
}
invCollection.UserID = userID;
invCollection.Folders = allFolders;
invCollection.Items = allItems;
// foreach (InventoryFolderBase folder in invCollection.Folders)
// {
// m_log.DebugFormat("[GRID AGENT INVENTORY]: Sending back folder {0} {1}", folder.Name, folder.ID);
// }
//
// 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.InfoFormat(
"[HGStandaloneInvService]: Sending back inventory response to user {0} containing {1} folders and {2} items",
invCollection.UserID, invCollection.Folders.Count, invCollection.Items.Count);
return invCollection;
}
/// <summary>
/// Guid to UUID wrapper for same name IInventoryServices method
/// </summary>
/// <param name="rawUserID"></param>
/// <returns></returns>
public List<InventoryFolderBase> GetInventorySkeleton(Guid rawUserID)
{
UUID userID = new UUID(rawUserID);
return ((InventoryServiceBase)m_inventoryService).GetInventorySkeleton(userID);
}
public List<InventoryItemBase> GetActiveGestures(Guid rawUserID)
{
UUID userID = new UUID(rawUserID);
m_log.InfoFormat("[HGStandaloneInvService]: fetching active gestures for user {0}", userID);
return ((InventoryServiceBase)m_inventoryService).GetActiveGestures(userID);
}
}
}
new InventoryService(m_scene);
}
}
public void Close()
{
}
public string Name
{
get { return "HGStandaloneInventoryService"; }
}
public bool IsSharedModule
{
get { return true; }
}
#endregion
}
public class InventoryService
{
private InventoryServiceBase m_inventoryService;
private IUserService m_userService;
private bool m_doLookup = false;
public bool DoLookup
{
get { return m_doLookup; }
set { m_doLookup = value; }
}
private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
public InventoryService(Scene m_scene)
{
m_inventoryService = (InventoryServiceBase)m_scene.CommsManager.SecureInventoryService;
m_userService = m_scene.CommsManager.UserService;
AddHttpHandlers(m_scene);
}
protected void AddHttpHandlers(Scene m_scene)
{
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<Guid, InventoryCollection>(
"POST", "/GetInventory/", GetUserInventory, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/NewFolder/", m_inventoryService.AddFolder, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/UpdateFolder/", m_inventoryService.UpdateFolder, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/MoveFolder/", m_inventoryService.MoveFolder, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/PurgeFolder/", m_inventoryService.PurgeFolder, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryItemBase, bool>(
"POST", "/NewItem/", m_inventoryService.AddItem, CheckAuthSession));
m_scene.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryItemBase, bool>(
"POST", "/DeleteItem/", m_inventoryService.DeleteItem, CheckAuthSession));
//// 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.
//// 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
//// to do this for now.
//m_scene.AddStreamHandler(
// new RestDeserialiseTrustedHandler<Guid, List<InventoryFolderBase>>
// ("POST", "/RootFolders/", GetInventorySkeleton, CheckTrustSource));
//// for persistent active gestures
//m_scene.AddStreamHandler(
// new RestDeserialiseTrustedHandler<Guid, List<InventoryItemBase>>
// ("POST", "/ActiveGestures/", GetActiveGestures, CheckTrustSource));
}
///// <summary>
///// Check that the source of an inventory request is one that we trust.
///// </summary>
///// <param name="peer"></param>
///// <returns></returns>
//public bool CheckTrustSource(IPEndPoint peer)
//{
// if (m_doLookup)
// {
// m_log.InfoFormat("[GRID AGENT INVENTORY]: Checking trusted source {0}", peer);
// UriBuilder ub = new UriBuilder(m_userserver_url);
// IPAddress[] uaddrs = Dns.GetHostAddresses(ub.Host);
// foreach (IPAddress uaddr in uaddrs)
// {
// if (uaddr.Equals(peer.Address))
// {
// return true;
// }
// }
// m_log.WarnFormat(
// "[GRID AGENT INVENTORY]: Rejecting request since source {0} was not in the list of trusted sources",
// peer);
// return false;
// }
// else
// {
// return true;
// }
//}
/// <summary>
/// Check that the source of an inventory request for a particular agent is a current session belonging to
/// that agent.
/// </summary>
/// <param name="session_id"></param>
/// <param name="avatar_id"></param>
/// <returns></returns>
public bool CheckAuthSession(string session_id, string avatar_id)
{
if (m_doLookup)
{
m_log.InfoFormat("[HGStandaloneInvService]: checking authed session {0} {1}", session_id, avatar_id);
UUID userID = UUID.Zero;
UUID sessionID = UUID.Zero;
UUID.TryParse(avatar_id, out userID);
UUID.TryParse(session_id, out sessionID);
if (userID.Equals(UUID.Zero) || sessionID.Equals(UUID.Zero))
{
m_log.Info("[HGStandaloneInvService]: Invalid user or session id " + avatar_id + "; " + session_id);
return false;
}
UserProfileData userProfile = m_userService.GetUserProfile(userID);
if (userProfile != null && userProfile.CurrentAgent != null &&
userProfile.CurrentAgent.SessionID == sessionID)
{
m_log.Info("[HGStandaloneInvService]: user is logged in and session is valid. Authorizing access.");
return true;
}
m_log.Warn("[HGStandaloneInvService]: unknown user or session_id, request rejected");
return false;
}
else
{
return true;
}
}
/// <summary>
/// Return a user's entire inventory
/// </summary>
/// <param name="rawUserID"></param>
/// <returns>The user's inventory. If an inventory cannot be found then an empty collection is returned.</returns>
public InventoryCollection GetUserInventory(Guid rawUserID)
{
UUID userID = new UUID(rawUserID);
m_log.Info("[HGStandaloneInvService]: Processing request for inventory of " + userID);
// Uncomment me to simulate a slow responding inventory server
//Thread.Sleep(16000);
InventoryCollection invCollection = new InventoryCollection();
List<InventoryFolderBase> allFolders = ((InventoryServiceBase)m_inventoryService).GetInventorySkeleton(userID);
if (null == allFolders)
{
m_log.WarnFormat("[HGStandaloneInvService]: No inventory found for user {0}", rawUserID);
return invCollection;
}
List<InventoryItemBase> allItems = new List<InventoryItemBase>();
foreach (InventoryFolderBase folder in allFolders)
{
List<InventoryItemBase> items = ((InventoryServiceBase)m_inventoryService).RequestFolderItems(folder.ID);
if (items != null)
{
allItems.InsertRange(0, items);
}
}
invCollection.UserID = userID;
invCollection.Folders = allFolders;
invCollection.Items = allItems;
// foreach (InventoryFolderBase folder in invCollection.Folders)
// {
// m_log.DebugFormat("[GRID AGENT INVENTORY]: Sending back folder {0} {1}", folder.Name, folder.ID);
// }
//
// 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.InfoFormat(
"[HGStandaloneInvService]: Sending back inventory response to user {0} containing {1} folders and {2} items",
invCollection.UserID, invCollection.Folders.Count, invCollection.Items.Count);
return invCollection;
}
/// <summary>
/// Guid to UUID wrapper for same name IInventoryServices method
/// </summary>
/// <param name="rawUserID"></param>
/// <returns></returns>
public List<InventoryFolderBase> GetInventorySkeleton(Guid rawUserID)
{
UUID userID = new UUID(rawUserID);
return ((InventoryServiceBase)m_inventoryService).GetInventorySkeleton(userID);
}
public List<InventoryItemBase> GetActiveGestures(Guid rawUserID)
{
UUID userID = new UUID(rawUserID);
m_log.InfoFormat("[HGStandaloneInvService]: fetching active gestures for user {0}", 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.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Net;
using System.Reflection;
using System.Threading;
using OpenMetaverse;
using OpenMetaverse.Imaging;
using OpenMetaverse.StructuredData;
using log4net;
using Nini.Config;
using Nwc.XmlRpc;
using OpenSim.Framework;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Communications.Capabilities;
using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Modules.World.WorldMap;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Environment.Types;
using Caps = OpenSim.Framework.Communications.Capabilities.Caps;
using OSD = OpenMetaverse.StructuredData.OSD;
using OSDMap = OpenMetaverse.StructuredData.OSDMap;
using OSDArray = OpenMetaverse.StructuredData.OSDArray;
namespace OpenSim.Region.Environment.Modules.Hypergrid
{
public class HGWorldMapModule : WorldMapModule, IRegionModule
{
private static readonly ILog m_log =
LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
#region IRegionModule Members
public override void Initialise(Scene scene, IConfigSource config)
{
IConfig startupConfig = config.Configs["Startup"];
if (startupConfig.GetString("WorldMapModule", "WorldMap") == "HGWorldMap")
m_Enabled = true;
if (!m_Enabled)
return;
m_log.Info("[HGMap] Initializing...");
m_scene = scene;
}
public override string Name
{
get { return "HGWorldMap"; }
}
#endregion
/// <summary>
/// Requests map blocks in area of minX, maxX, minY, MaxY in world cordinates
/// </summary>
/// <param name="minX"></param>
/// <param name="minY"></param>
/// <param name="maxX"></param>
/// <param name="maxY"></param>
public override void RequestMapBlocks(IClientAPI remoteClient, int minX, int minY, int maxX, int maxY, uint flag)
{
//
// WARNING!!! COPY & PASTE FROM SUPERCLASS
// The only difference is at the very end
//
m_log.Info("[HGMap]: Request map blocks " + minX + "-" + maxX + " " + minY + "-" + maxY);
//m_scene.ForEachScenePresence(delegate (ScenePresence sp) {
// if (!sp.IsChildAgent && sp.UUID == remoteClient.AgentId)
// {
// Console.WriteLine("XXX Root agent");
// DoRequestMapBlocks(remoteClient, minX, minY, maxX, maxY, flag);
// }
//};
List<MapBlockData> mapBlocks;
if ((flag & 0x10000) != 0) // user clicked on the map a tile that isn't visible
{
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
mapBlocks = m_scene.SceneGridService.RequestNeighbourMapBlocks(minX, minY, maxX, maxY);
if (mapBlocks != null)
{
foreach (MapBlockData block in mapBlocks)
{
if (block.X == minX && block.Y == minY)
{
// found it => add it to response
response.Add(block);
break;
}
}
}
response = mapBlocks;
if (response.Count == 0)
{
// response still empty => couldn't find the map-tile the user clicked on => tell the client
MapBlockData block = new MapBlockData();
block.X = (ushort)minX;
block.Y = (ushort)minY;
block.Access = 254; // == not there
response.Add(block);
}
remoteClient.SendMapBlock(response, 0);
}
else
{
// normal mapblock request. Use the provided values
mapBlocks = m_scene.SceneGridService.RequestNeighbourMapBlocks(minX - 4, minY - 4, maxX + 4, maxY + 4);
// Different from super
FillInMap(mapBlocks, minX, minY, maxX, maxY);
//
remoteClient.SendMapBlock(mapBlocks, flag);
}
}
private void FillInMap(List<MapBlockData> mapBlocks, int minX, int minY, int maxX, int maxY)
{
for (int x = minX; x <= maxX; x++)
for (int y = minY; y <= maxY; y++)
{
MapBlockData mblock = mapBlocks.Find(delegate(MapBlockData mb) { return ((mb.X == x) && (mb.Y == y)); });
if (mblock == null)
{
mblock = new MapBlockData();
mblock.X = (ushort)x;
mblock.Y = (ushort)y;
mblock.Name = "";
mblock.Access = 254; // not here???
mblock.MapImageId = UUID.Zero;
mapBlocks.Add(mblock);
}
}
}
}
}
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Net;
using System.Reflection;
using System.Threading;
using OpenMetaverse;
using OpenMetaverse.Imaging;
using OpenMetaverse.StructuredData;
using log4net;
using Nini.Config;
using Nwc.XmlRpc;
using OpenSim.Framework;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Communications.Capabilities;
using OpenSim.Framework.Servers;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Modules.World.WorldMap;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Environment.Types;
using Caps = OpenSim.Framework.Communications.Capabilities.Caps;
using OSD = OpenMetaverse.StructuredData.OSD;
using OSDMap = OpenMetaverse.StructuredData.OSDMap;
using OSDArray = OpenMetaverse.StructuredData.OSDArray;
namespace OpenSim.Region.Environment.Modules.Hypergrid
{
public class HGWorldMapModule : WorldMapModule, IRegionModule
{
private static readonly ILog m_log =
LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
#region IRegionModule Members
public override void Initialise(Scene scene, IConfigSource config)
{
IConfig startupConfig = config.Configs["Startup"];
if (startupConfig.GetString("WorldMapModule", "WorldMap") == "HGWorldMap")
m_Enabled = true;
if (!m_Enabled)
return;
m_log.Info("[HGMap] Initializing...");
m_scene = scene;
}
public override string Name
{
get { return "HGWorldMap"; }
}
#endregion
/// <summary>
/// Requests map blocks in area of minX, maxX, minY, MaxY in world cordinates
/// </summary>
/// <param name="minX"></param>
/// <param name="minY"></param>
/// <param name="maxX"></param>
/// <param name="maxY"></param>
public override void RequestMapBlocks(IClientAPI remoteClient, int minX, int minY, int maxX, int maxY, uint flag)
{
//
// WARNING!!! COPY & PASTE FROM SUPERCLASS
// The only difference is at the very end
//
m_log.Info("[HGMap]: Request map blocks " + minX + "-" + maxX + " " + minY + "-" + maxY);
//m_scene.ForEachScenePresence(delegate (ScenePresence sp) {
// if (!sp.IsChildAgent && sp.UUID == remoteClient.AgentId)
// {
// Console.WriteLine("XXX Root agent");
// DoRequestMapBlocks(remoteClient, minX, minY, maxX, maxY, flag);
// }
//};
List<MapBlockData> mapBlocks;
if ((flag & 0x10000) != 0) // user clicked on the map a tile that isn't visible
{
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
mapBlocks = m_scene.SceneGridService.RequestNeighbourMapBlocks(minX, minY, maxX, maxY);
if (mapBlocks != null)
{
foreach (MapBlockData block in mapBlocks)
{
if (block.X == minX && block.Y == minY)
{
// found it => add it to response
response.Add(block);
break;
}
}
}
response = mapBlocks;
if (response.Count == 0)
{
// response still empty => couldn't find the map-tile the user clicked on => tell the client
MapBlockData block = new MapBlockData();
block.X = (ushort)minX;
block.Y = (ushort)minY;
block.Access = 254; // == not there
response.Add(block);
}
remoteClient.SendMapBlock(response, 0);
}
else
{
// normal mapblock request. Use the provided values
mapBlocks = m_scene.SceneGridService.RequestNeighbourMapBlocks(minX - 4, minY - 4, maxX + 4, maxY + 4);
// Different from super
FillInMap(mapBlocks, minX, minY, maxX, maxY);
//
remoteClient.SendMapBlock(mapBlocks, flag);
}
}
private void FillInMap(List<MapBlockData> mapBlocks, int minX, int minY, int maxX, int maxY)
{
for (int x = minX; x <= maxX; x++)
for (int y = minY; y <= maxY; y++)
{
MapBlockData mblock = mapBlocks.Find(delegate(MapBlockData mb) { return ((mb.X == x) && (mb.Y == y)); });
if (mblock == null)
{
mblock = new MapBlockData();
mblock.X = (ushort)x;
mblock.Y = (ushort)y;
mblock.Name = "";
mblock.Access = 254; // not here???
mblock.MapImageId = UUID.Zero;
mapBlocks.Add(mblock);
}
}
}
}
}

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

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

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

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

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

@ -1,152 +1,152 @@
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Threading;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Scenes;
namespace OpenSim.Region.Environment.Scenes.Hypergrid
{
public partial class HGScene : Scene
{
#region Fields
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private HGAssetMapper m_assMapper;
#endregion
#region Constructors
public HGScene(RegionInfo regInfo, AgentCircuitManager authen,
CommunicationsManager commsMan, SceneCommunicationService sceneGridService,
AssetCache assetCach, StorageManager storeManager, BaseHttpServer httpServer,
ModuleLoader moduleLoader, bool dumpAssetsToFile, bool physicalPrim,
bool SeeIntoRegionFromNeighbor, IConfigSource config, string simulatorVersion)
: base(regInfo, authen, commsMan, sceneGridService, assetCach, storeManager, httpServer, moduleLoader,
dumpAssetsToFile, physicalPrim, SeeIntoRegionFromNeighbor, config, simulatorVersion)
{
m_log.Info("[HGScene]: Starting HGScene.");
m_assMapper = new HGAssetMapper(this);
EventManager.OnNewInventoryItemUploadComplete += UploadInventoryItem;
}
#endregion
#region Event handlers
public void UploadInventoryItem(UUID avatarID, UUID assetID, string name, int userlevel)
{
CachedUserInfo userInfo = CommsManager.UserProfileCacheService.GetUserDetails(avatarID);
if (userInfo != null)
{
m_assMapper.Post(assetID, avatarID);
}
}
#endregion
#region Overrides of Scene.Inventory methods
///
/// CapsUpdateInventoryItemAsset
///
public override UUID CapsUpdateInventoryItemAsset(IClientAPI remoteClient, UUID itemID, byte[] data)
{
UUID newAssetID = base.CapsUpdateInventoryItemAsset(remoteClient, itemID, data);
UploadInventoryItem(remoteClient.AgentId, newAssetID, "", 0);
return newAssetID;
}
///
/// DeleteToInventory
///
public override UUID DeleteToInventory(int destination, UUID folderID, SceneObjectGroup objectGroup, IClientAPI remoteClient)
{
UUID assetID = base.DeleteToInventory(destination, folderID, objectGroup, remoteClient);
if (!assetID.Equals(UUID.Zero))
{
UploadInventoryItem(remoteClient.AgentId, assetID, "", 0);
}
else
m_log.Debug("[HGScene]: Scene.Inventory did not create asset");
return assetID;
}
///
/// RezObject
///
public override SceneObjectGroup RezObject(IClientAPI remoteClient, UUID itemID, Vector3 RayEnd, Vector3 RayStart,
UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
bool RezSelected, bool RemoveItem, UUID fromTaskID, bool attachment)
{
CachedUserInfo userInfo = CommsManager.UserProfileCacheService.GetUserDetails(remoteClient.AgentId);
if (userInfo != null)
{
if (userInfo.RootFolder != null)
{
InventoryItemBase item = userInfo.RootFolder.FindItem(itemID);
if (item != null)
{
m_assMapper.Get(item.AssetID, remoteClient.AgentId);
}
}
}
// OK, we're done fetching. Pass it up to the default RezObject
return base.RezObject(remoteClient, itemID, RayEnd, RayStart, RayTargetID, BypassRayCast, RayEndIsIntersection,
RezSelected, RemoveItem, fromTaskID, attachment);
}
#endregion
}
}
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Threading;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Scenes;
namespace OpenSim.Region.Environment.Scenes.Hypergrid
{
public partial class HGScene : Scene
{
#region Fields
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private HGAssetMapper m_assMapper;
#endregion
#region Constructors
public HGScene(RegionInfo regInfo, AgentCircuitManager authen,
CommunicationsManager commsMan, SceneCommunicationService sceneGridService,
AssetCache assetCach, StorageManager storeManager, BaseHttpServer httpServer,
ModuleLoader moduleLoader, bool dumpAssetsToFile, bool physicalPrim,
bool SeeIntoRegionFromNeighbor, IConfigSource config, string simulatorVersion)
: base(regInfo, authen, commsMan, sceneGridService, assetCach, storeManager, httpServer, moduleLoader,
dumpAssetsToFile, physicalPrim, SeeIntoRegionFromNeighbor, config, simulatorVersion)
{
m_log.Info("[HGScene]: Starting HGScene.");
m_assMapper = new HGAssetMapper(this);
EventManager.OnNewInventoryItemUploadComplete += UploadInventoryItem;
}
#endregion
#region Event handlers
public void UploadInventoryItem(UUID avatarID, UUID assetID, string name, int userlevel)
{
CachedUserInfo userInfo = CommsManager.UserProfileCacheService.GetUserDetails(avatarID);
if (userInfo != null)
{
m_assMapper.Post(assetID, avatarID);
}
}
#endregion
#region Overrides of Scene.Inventory methods
///
/// CapsUpdateInventoryItemAsset
///
public override UUID CapsUpdateInventoryItemAsset(IClientAPI remoteClient, UUID itemID, byte[] data)
{
UUID newAssetID = base.CapsUpdateInventoryItemAsset(remoteClient, itemID, data);
UploadInventoryItem(remoteClient.AgentId, newAssetID, "", 0);
return newAssetID;
}
///
/// DeleteToInventory
///
public override UUID DeleteToInventory(int destination, UUID folderID, SceneObjectGroup objectGroup, IClientAPI remoteClient)
{
UUID assetID = base.DeleteToInventory(destination, folderID, objectGroup, remoteClient);
if (!assetID.Equals(UUID.Zero))
{
UploadInventoryItem(remoteClient.AgentId, assetID, "", 0);
}
else
m_log.Debug("[HGScene]: Scene.Inventory did not create asset");
return assetID;
}
///
/// RezObject
///
public override SceneObjectGroup RezObject(IClientAPI remoteClient, UUID itemID, Vector3 RayEnd, Vector3 RayStart,
UUID RayTargetID, byte BypassRayCast, bool RayEndIsIntersection,
bool RezSelected, bool RemoveItem, UUID fromTaskID, bool attachment)
{
CachedUserInfo userInfo = CommsManager.UserProfileCacheService.GetUserDetails(remoteClient.AgentId);
if (userInfo != null)
{
if (userInfo.RootFolder != null)
{
InventoryItemBase item = userInfo.RootFolder.FindItem(itemID);
if (item != null)
{
m_assMapper.Get(item.AssetID, remoteClient.AgentId);
}
}
}
// OK, we're done fetching. Pass it up to the default RezObject
return base.RezObject(remoteClient, itemID, RayEnd, RayStart, RayTargetID, BypassRayCast, RayEndIsIntersection,
RezSelected, RemoveItem, fromTaskID, attachment);
}
#endregion
}
}

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

@ -1,78 +1,78 @@
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Scenes;
using TPFlags = OpenSim.Framework.Constants.TeleportFlags;
namespace OpenSim.Region.Environment.Scenes.Hypergrid
{
public partial class HGScene : Scene
{
/// <summary>
/// Teleport an avatar to their home region
/// </summary>
/// <param name="agentId"></param>
/// <param name="client"></param>
public override void TeleportClientHome(UUID agentId, IClientAPI client)
{
m_log.Debug("[HGScene]: TeleportClientHome " + client.FirstName + " " + client.LastName);
CachedUserInfo uinfo = CommsManager.UserProfileCacheService.GetUserDetails(agentId);
UserProfileData UserProfile = uinfo.UserProfile;
if (UserProfile != null)
{
RegionInfo regionInfo = CommsManager.GridService.RequestNeighbourInfo(UserProfile.HomeRegion);
//if (regionInfo != null)
//{
// UserProfile.HomeRegionID = regionInfo.RegionID;
// //CommsManager.UserService.UpdateUserProfile(UserProfile);
//}
if (regionInfo == null)
{
// can't find the Home region: Tell viewer and abort
client.SendTeleportFailed("Your home-region could not be found.");
return;
}
RequestTeleportLocation(
client, regionInfo.RegionHandle, UserProfile.HomeLocation, UserProfile.HomeLookAt,
(uint)(TPFlags.SetLastToTarget | TPFlags.ViaHome));
}
}
}
}
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Scenes;
using TPFlags = OpenSim.Framework.Constants.TeleportFlags;
namespace OpenSim.Region.Environment.Scenes.Hypergrid
{
public partial class HGScene : Scene
{
/// <summary>
/// Teleport an avatar to their home region
/// </summary>
/// <param name="agentId"></param>
/// <param name="client"></param>
public override void TeleportClientHome(UUID agentId, IClientAPI client)
{
m_log.Debug("[HGScene]: TeleportClientHome " + client.FirstName + " " + client.LastName);
CachedUserInfo uinfo = CommsManager.UserProfileCacheService.GetUserDetails(agentId);
UserProfileData UserProfile = uinfo.UserProfile;
if (UserProfile != null)
{
RegionInfo regionInfo = CommsManager.GridService.RequestNeighbourInfo(UserProfile.HomeRegion);
//if (regionInfo != null)
//{
// UserProfile.HomeRegionID = regionInfo.RegionID;
// //CommsManager.UserService.UpdateUserProfile(UserProfile);
//}
if (regionInfo == null)
{
// can't find the Home region: Tell viewer and abort
client.SendTeleportFailed("Your home-region could not be found.");
return;
}
RequestTeleportLocation(
client, regionInfo.RegionHandle, UserProfile.HomeLocation, UserProfile.HomeLookAt,
(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.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading;
using OpenMetaverse;
using log4net;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Environment;
using OpenSim.Region.Interfaces;
using OSD = OpenMetaverse.StructuredData.OSD;
namespace OpenSim.Region.Environment.Scenes.Hypergrid
{
public class HGSceneCommunicationService : SceneCommunicationService
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private IHyperlink m_hg;
public HGSceneCommunicationService(CommunicationsManager commsMan, IHyperlink hg) : base(commsMan)
{
m_hg = hg;
}
/// <summary>
/// Try to teleport an agent to a new region.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="RegionHandle"></param>
/// <param name="position"></param>
/// <param name="lookAt"></param>
/// <param name="flags"></param>
public override void RequestTeleportToLocation(ScenePresence avatar, ulong regionHandle, Vector3 position,
Vector3 lookAt, uint teleportFlags)
{
if (!avatar.Scene.Permissions.CanTeleport(avatar.UUID))
return;
bool destRegionUp = false;
IEventQueue eq = avatar.Scene.RequestModuleInterface<IEventQueue>();
if (regionHandle == m_regionInfo.RegionHandle)
{
// Teleport within the same region
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);
m_log.WarnFormat(
"[HGSceneCommService]: RequestTeleportToLocation() was given an illegal position of {0} for avatar {1}, {2}. Substituting {3}",
position, avatar.Name, avatar.UUID, emergencyPos);
position = emergencyPos;
}
// TODO: Get proper AVG Height
float localAVHeight = 1.56f;
float posZLimit = (float)avatar.Scene.GetLandHeight((int)position.X, (int)position.Y);
float newPosZ = posZLimit + localAVHeight;
if (posZLimit >= (position.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ)))
{
position.Z = newPosZ;
}
// Only send this if the event queue is null
if (eq == null)
avatar.ControllingClient.SendTeleportLocationStart();
avatar.ControllingClient.SendLocalTeleport(position, lookAt, teleportFlags);
avatar.Teleport(position);
}
else
{
RegionInfo reg = RequestNeighbouringRegionInfo(regionHandle);
if (reg != null)
{
///
/// Hypergrid mod start
///
///
bool isHyperLink = m_hg.IsHyperlinkRegion(reg.RegionHandle);
bool isHomeUser = true;
ulong realHandle = regionHandle;
CachedUserInfo uinfo = m_commsProvider.UserProfileCacheService.GetUserDetails(avatar.UUID);
if (uinfo != null)
{
isHomeUser = HGNetworkServersInfo.Singleton.IsLocalUser(uinfo.UserProfile.UserAssetURI);
realHandle = m_hg.FindRegionHandle(regionHandle);
Console.WriteLine("XXX ---- home user? " + isHomeUser + " --- hyperlink? " + isHyperLink + " --- real handle: " + realHandle.ToString());
}
///
/// Hypergrid mod stop
///
///
if (eq == null)
avatar.ControllingClient.SendTeleportLocationStart();
AgentCircuitData agent = avatar.ControllingClient.RequestClientInfo();
agent.BaseFolder = UUID.Zero;
agent.InventoryFolder = UUID.Zero;
agent.startpos = position;
agent.child = true;
if (reg.RemotingAddress != "" && reg.RemotingPort != 0)
{
// region is remote. see if it is up
destRegionUp = m_commsProvider.InterRegion.CheckRegion(reg.RemotingAddress, reg.RemotingPort);
}
else
{
// assume local regions are always up
destRegionUp = true;
}
if (destRegionUp)
{
// Fixing a bug where teleporting while sitting results in the avatar ending up removed from
// both regions
if (avatar.ParentID != (uint)0)
avatar.StandUp();
if (!avatar.ValidateAttachments())
{
avatar.ControllingClient.SendTeleportFailed("Inconsistent attachment state");
return;
}
// 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).
List<ulong> childRegions = new List<ulong>(avatar.GetKnownRegionList());
// 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
// once we reach here...
avatar.Scene.RemoveCapsHandler(avatar.UUID);
agent.child = false;
m_commsProvider.InterRegion.InformRegionOfChildAgent(reg.RegionHandle, agent);
m_commsProvider.InterRegion.ExpectAvatarCrossing(reg.RegionHandle, avatar.ControllingClient.AgentId,
position, false);
Thread.Sleep(2000);
AgentCircuitData circuitdata = avatar.ControllingClient.RequestClientInfo();
// TODO Should construct this behind a method
string capsPath =
"http://" + reg.ExternalHostName + ":" + reg.HttpPort
+ "/CAPS/" + circuitdata.CapsPath + "0000/";
m_log.DebugFormat(
"[CAPS]: Sending new CAPS seed url {0} to client {1}", capsPath, avatar.UUID);
///
/// Hypergrid mod: realHandle instead of reg.RegionHandle
///
///
if (eq != null)
{
OSD Item = EventQueueHelper.TeleportFinishEvent(realHandle, 13, reg.ExternalEndPoint,
4, teleportFlags, capsPath, avatar.UUID);
eq.Enqueue(Item, avatar.UUID);
}
else
{
avatar.ControllingClient.SendRegionTeleport(realHandle, 13, reg.ExternalEndPoint, 4,
teleportFlags, capsPath);
}
///
/// Hypergrid mod stop
///
avatar.MakeChildAgent();
Thread.Sleep(7000);
avatar.CrossAttachmentsIntoNewRegion(reg.RegionHandle, true);
if (KiPrimitive != null)
{
KiPrimitive(avatar.LocalId);
}
avatar.Close();
uint newRegionX = (uint)(reg.RegionHandle >> 40);
uint newRegionY = (((uint)(reg.RegionHandle)) >> 8);
uint oldRegionX = (uint)(m_regionInfo.RegionHandle >> 40);
uint oldRegionY = (((uint)(m_regionInfo.RegionHandle)) >> 8);
///
/// Hypergrid mod: extra check for isHyperLink
///
if ((Util.fast_distance2d((int)(newRegionX - oldRegionX), (int)(newRegionY - oldRegionY)) > 3) || isHyperLink)
{
//SendCloseChildAgentConnections(avatar.UUID, avatar.GetKnownRegionList());
SendCloseChildAgentConnections(avatar.UUID, childRegions);
CloseConnection(avatar.UUID);
}
// if (teleport success) // seems to be always success here
// the user may change their profile information in other region,
// so the userinfo in UserProfileCache is not reliable any more, delete it
if (avatar.Scene.NeedSceneCacheClear(avatar.UUID))
m_commsProvider.UserProfileCacheService.RemoveUser(avatar.UUID);
m_log.InfoFormat("[HGSceneCommService]: User {0} is going to another region, profile cache removed", avatar.UUID);
}
else
{
avatar.ControllingClient.SendTeleportFailed("Remote Region appears to be down");
}
}
else
{
// TP to a place that doesn't exist (anymore)
// Inform the viewer about that
avatar.ControllingClient.SendTeleportFailed("The region you tried to teleport to doesn't exist anymore");
// and set the map-tile to '(Offline)'
uint regX, regY;
Utils.LongToUInts(regionHandle, out regX, out regY);
MapBlockData block = new MapBlockData();
block.X = (ushort)(regX / Constants.RegionSize);
block.Y = (ushort)(regY / Constants.RegionSize);
block.Access = 254; // == not there
List<MapBlockData> blocks = new List<MapBlockData>();
blocks.Add(block);
avatar.ControllingClient.SendMapBlock(blocks, 0);
}
}
}
}
}
/**
* Copyright (c) 2008, Contributors. All rights reserved.
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the Organizations nor the names of Individual
* Contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* 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
* 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,
* 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
* 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
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading;
using OpenMetaverse;
using log4net;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Region.Environment.Scenes;
using OpenSim.Region.Environment;
using OpenSim.Region.Interfaces;
using OSD = OpenMetaverse.StructuredData.OSD;
namespace OpenSim.Region.Environment.Scenes.Hypergrid
{
public class HGSceneCommunicationService : SceneCommunicationService
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private IHyperlink m_hg;
public HGSceneCommunicationService(CommunicationsManager commsMan, IHyperlink hg) : base(commsMan)
{
m_hg = hg;
}
/// <summary>
/// Try to teleport an agent to a new region.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="RegionHandle"></param>
/// <param name="position"></param>
/// <param name="lookAt"></param>
/// <param name="flags"></param>
public override void RequestTeleportToLocation(ScenePresence avatar, ulong regionHandle, Vector3 position,
Vector3 lookAt, uint teleportFlags)
{
if (!avatar.Scene.Permissions.CanTeleport(avatar.UUID))
return;
bool destRegionUp = false;
IEventQueue eq = avatar.Scene.RequestModuleInterface<IEventQueue>();
if (regionHandle == m_regionInfo.RegionHandle)
{
// Teleport within the same region
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);
m_log.WarnFormat(
"[HGSceneCommService]: RequestTeleportToLocation() was given an illegal position of {0} for avatar {1}, {2}. Substituting {3}",
position, avatar.Name, avatar.UUID, emergencyPos);
position = emergencyPos;
}
// TODO: Get proper AVG Height
float localAVHeight = 1.56f;
float posZLimit = (float)avatar.Scene.GetLandHeight((int)position.X, (int)position.Y);
float newPosZ = posZLimit + localAVHeight;
if (posZLimit >= (position.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ)))
{
position.Z = newPosZ;
}
// Only send this if the event queue is null
if (eq == null)
avatar.ControllingClient.SendTeleportLocationStart();
avatar.ControllingClient.SendLocalTeleport(position, lookAt, teleportFlags);
avatar.Teleport(position);
}
else
{
RegionInfo reg = RequestNeighbouringRegionInfo(regionHandle);
if (reg != null)
{
///
/// Hypergrid mod start
///
///
bool isHyperLink = m_hg.IsHyperlinkRegion(reg.RegionHandle);
bool isHomeUser = true;
ulong realHandle = regionHandle;
CachedUserInfo uinfo = m_commsProvider.UserProfileCacheService.GetUserDetails(avatar.UUID);
if (uinfo != null)
{
isHomeUser = HGNetworkServersInfo.Singleton.IsLocalUser(uinfo.UserProfile.UserAssetURI);
realHandle = m_hg.FindRegionHandle(regionHandle);
Console.WriteLine("XXX ---- home user? " + isHomeUser + " --- hyperlink? " + isHyperLink + " --- real handle: " + realHandle.ToString());
}
///
/// Hypergrid mod stop
///
///
if (eq == null)
avatar.ControllingClient.SendTeleportLocationStart();
AgentCircuitData agent = avatar.ControllingClient.RequestClientInfo();
agent.BaseFolder = UUID.Zero;
agent.InventoryFolder = UUID.Zero;
agent.startpos = position;
agent.child = true;
if (reg.RemotingAddress != "" && reg.RemotingPort != 0)
{
// region is remote. see if it is up
destRegionUp = m_commsProvider.InterRegion.CheckRegion(reg.RemotingAddress, reg.RemotingPort);
}
else
{
// assume local regions are always up
destRegionUp = true;
}
if (destRegionUp)
{
// Fixing a bug where teleporting while sitting results in the avatar ending up removed from
// both regions
if (avatar.ParentID != (uint)0)
avatar.StandUp();
if (!avatar.ValidateAttachments())
{
avatar.ControllingClient.SendTeleportFailed("Inconsistent attachment state");
return;
}
// 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).
List<ulong> childRegions = new List<ulong>(avatar.GetKnownRegionList());
// 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
// once we reach here...
avatar.Scene.RemoveCapsHandler(avatar.UUID);
agent.child = false;
m_commsProvider.InterRegion.InformRegionOfChildAgent(reg.RegionHandle, agent);
m_commsProvider.InterRegion.ExpectAvatarCrossing(reg.RegionHandle, avatar.ControllingClient.AgentId,
position, false);
Thread.Sleep(2000);
AgentCircuitData circuitdata = avatar.ControllingClient.RequestClientInfo();
// TODO Should construct this behind a method
string capsPath =
"http://" + reg.ExternalHostName + ":" + reg.HttpPort
+ "/CAPS/" + circuitdata.CapsPath + "0000/";
m_log.DebugFormat(
"[CAPS]: Sending new CAPS seed url {0} to client {1}", capsPath, avatar.UUID);
///
/// Hypergrid mod: realHandle instead of reg.RegionHandle
///
///
if (eq != null)
{
OSD Item = EventQueueHelper.TeleportFinishEvent(realHandle, 13, reg.ExternalEndPoint,
4, teleportFlags, capsPath, avatar.UUID);
eq.Enqueue(Item, avatar.UUID);
}
else
{
avatar.ControllingClient.SendRegionTeleport(realHandle, 13, reg.ExternalEndPoint, 4,
teleportFlags, capsPath);
}
///
/// Hypergrid mod stop
///
avatar.MakeChildAgent();
Thread.Sleep(7000);
avatar.CrossAttachmentsIntoNewRegion(reg.RegionHandle, true);
if (KiPrimitive != null)
{
KiPrimitive(avatar.LocalId);
}
avatar.Close();
uint newRegionX = (uint)(reg.RegionHandle >> 40);
uint newRegionY = (((uint)(reg.RegionHandle)) >> 8);
uint oldRegionX = (uint)(m_regionInfo.RegionHandle >> 40);
uint oldRegionY = (((uint)(m_regionInfo.RegionHandle)) >> 8);
///
/// Hypergrid mod: extra check for isHyperLink
///
if ((Util.fast_distance2d((int)(newRegionX - oldRegionX), (int)(newRegionY - oldRegionY)) > 3) || isHyperLink)
{
//SendCloseChildAgentConnections(avatar.UUID, avatar.GetKnownRegionList());
SendCloseChildAgentConnections(avatar.UUID, childRegions);
CloseConnection(avatar.UUID);
}
// if (teleport success) // seems to be always success here
// the user may change their profile information in other region,
// so the userinfo in UserProfileCache is not reliable any more, delete it
if (avatar.Scene.NeedSceneCacheClear(avatar.UUID))
m_commsProvider.UserProfileCacheService.RemoveUser(avatar.UUID);
m_log.InfoFormat("[HGSceneCommService]: User {0} is going to another region, profile cache removed", avatar.UUID);
}
else
{
avatar.ControllingClient.SendTeleportFailed("Remote Region appears to be down");
}
}
else
{
// TP to a place that doesn't exist (anymore)
// Inform the viewer about that
avatar.ControllingClient.SendTeleportFailed("The region you tried to teleport to doesn't exist anymore");
// and set the map-tile to '(Offline)'
uint regX, regY;
Utils.LongToUInts(regionHandle, out regX, out regY);
MapBlockData block = new MapBlockData();
block.X = (ushort)(regX / Constants.RegionSize);
block.Y = (ushort)(regY / Constants.RegionSize);
block.Access = 254; // == not there
List<MapBlockData> blocks = new List<MapBlockData>();
blocks.Add(block);
avatar.ControllingClient.SendMapBlock(blocks, 0);
}
}
}
}
}