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

* Apply http://opensimulator.org/mantis/view.php?id=2640 

* This is Diva's hypergrid patch, as perviously discussed on the opensim-dev mailing list
* Applied some minor prebuild.xml jiggling to resolve a dependency issue
* Thanks Diva!
0.6.1-post-fixes
Justin Clarke Casey 2008-11-25 15:19:00 +00:00
parent dbe64197ae
commit e187972377
20 changed files with 5557 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
OpenSim/Framework/Communications/IHyperlink.cs Normal file
View File

@ -0,0 +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);
}
}

80
OpenSim/Framework/ForeignUserProfileData.cs Normal file
View File

@ -0,0 +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; }
}
}
}

90
OpenSim/Framework/HGNetworkServersInfo.cs Normal file
View File

@ -0,0 +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;
}
}
}

10
OpenSim/Region/Application/Application.cs
View File

@ -76,11 +76,13 @@ namespace OpenSim
configSource.AddSwitch("Startup", "gridmode");
configSource.AddSwitch("Startup", "physics");
configSource.AddSwitch("Startup", "useexecutepath");
configSource.AddSwitch("Startup", "hypergrid");
configSource.AddConfig("StandAlone");
configSource.AddConfig("Network");
bool background = configSource.Configs["Startup"].GetBoolean("background", false);
bool hgrid = configSource.Configs["Startup"].GetBoolean("hypergrid", false);
if (background)
{
@ -89,13 +91,19 @@ namespace OpenSim
}
else
{
OpenSimBase sim = new OpenSim(configSource);
OpenSimBase sim = null;
if (hgrid)
sim = new HGOpenSimNode(configSource);
else
sim = new OpenSim(configSource);
sim.Startup();
while (true)
{
MainConsole.Instance.Prompt();
}
}
}

184
OpenSim/Region/Application/HGOpenSimNode.cs Normal file
View File

@ -0,0 +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>]");
}
}
}

82
OpenSim/Region/Communications/Hypergrid/HGCommunicationsGridMode.cs Normal file
View File

@ -0,0 +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;
}
}
}

59
OpenSim/Region/Communications/Hypergrid/HGCommunicationsStandalone.cs Normal file
View File

@ -0,0 +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;
}
}
}

1294
OpenSim/Region/Communications/Hypergrid/HGGridServices.cs Normal file
View File

File diff suppressed because it is too large Load Diff

285
OpenSim/Region/Communications/Hypergrid/HGGridServicesGridMode.cs Normal file
View File

@ -0,0 +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
}
}

928
OpenSim/Region/Communications/Hypergrid/HGGridServicesStandalone.cs Normal file
View File

@ -0,0 +1,928 @@
/**
* 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.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
using System.Security.Authentication;
using OpenSim.Framework;
using OpenSim.Framework.Communications;
using OpenSim.Framework.Communications.Cache;
using OpenSim.Framework.Servers;
using OpenSim.Region.Communications.Local;
using OpenSim.Region.Communications.OGS1;
using OpenSim.Region.Environment.Scenes;
using OpenMetaverse;
using Nwc.XmlRpc;
using log4net;
namespace OpenSim.Region.Communications.Hypergrid
{
public class HGGridServicesStandalone : HGGridServices
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
/// <summary>
/// Encapsulate local backend services for manipulation of local regions
/// </summary>
protected LocalBackEndServices m_localBackend = new LocalBackEndServices();
private Dictionary<ulong, int> m_deadRegionCache = new Dictionary<ulong, int>();
public LocalBackEndServices LocalBackend
{
get { return m_localBackend; }
}
public override string gdebugRegionName
{
get { return m_localBackend.gdebugRegionName; }
set { m_localBackend.gdebugRegionName = value; }
}
public override bool RegionLoginsEnabled
{
get { return m_localBackend.RegionLoginsEnabled; }
set { m_localBackend.RegionLoginsEnabled = value; }
}
public HGGridServicesStandalone(NetworkServersInfo servers_info, BaseHttpServer httpServe, AssetCache asscache, SceneManager sman)
: base(servers_info, httpServe, asscache, sman)
{
//Respond to Grid Services requests
httpServer.AddXmlRPCHandler("logoff_user", LogOffUser);
httpServer.AddXmlRPCHandler("check", PingCheckReply);
httpServer.AddXmlRPCHandler("land_data", LandData);
StartRemoting();
}
#region IGridServices interface
public override RegionCommsListener RegisterRegion(RegionInfo regionInfo)
{
if (!regionInfo.RegionID.Equals(UUID.Zero))
{
m_regionsOnInstance.Add(regionInfo);
return m_localBackend.RegisterRegion(regionInfo);
}
else
return base.RegisterRegion(regionInfo);
}
public override bool DeregisterRegion(RegionInfo regionInfo)
{
bool success = m_localBackend.DeregisterRegion(regionInfo);
if (!success)
success = base.DeregisterRegion(regionInfo);
return success;
}
public override List<SimpleRegionInfo> RequestNeighbours(uint x, uint y)
{
List<SimpleRegionInfo> neighbours = m_localBackend.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_localBackend.RequestNeighbourInfo(Region_UUID);
if (info == null)
info = base.RequestNeighbourInfo(Region_UUID);
return info;
}
public override RegionInfo RequestNeighbourInfo(ulong regionHandle)
{
RegionInfo info = m_localBackend.RequestNeighbourInfo(regionHandle);
//m_log.Info("[HGrid] Request neighbor info, local backend returned " + info);
if (info == null)
info = base.RequestNeighbourInfo(regionHandle);
return info;
}
public override RegionInfo RequestClosestRegion(string regionName)
{
RegionInfo info = m_localBackend.RequestClosestRegion(regionName);
if (info == null)
info = base.RequestClosestRegion(regionName);
return info;
}
public override List<MapBlockData> RequestNeighbourMapBlocks(int minX, int minY, int maxX, int maxY)
{
//m_log.Info("[HGrid] Request map blocks " + minX + "-" + minY + "-" + maxX + "-" + maxY);
List<MapBlockData> neighbours = m_localBackend.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_localBackend.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_localBackend.RequestNamedRegions(name, maxNumber);
List<RegionInfo> remotes = base.RequestNamedRegions(name, maxNumber);
infos.AddRange(remotes);
return infos;
}
#endregion
#region XML Request Handlers
/// <summary>
/// A ping / version check
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public virtual XmlRpcResponse PingCheckReply(XmlRpcRequest request)
{
XmlRpcResponse response = new XmlRpcResponse();
Hashtable respData = new Hashtable();
respData["online"] = "true";
m_localBackend.PingCheckReply(respData);
response.Value = respData;
return response;
}
// Grid Request Processing
/// <summary>
/// Ooops, our Agent must be dead if we're getting this request!
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public XmlRpcResponse LogOffUser(XmlRpcRequest request)
{
m_log.Debug("[HGrid]: LogOff User Called");
Hashtable requestData = (Hashtable)request.Params[0];
string message = (string)requestData["message"];
UUID agentID = UUID.Zero;
UUID RegionSecret = UUID.Zero;
UUID.TryParse((string)requestData["agent_id"], out agentID);
UUID.TryParse((string)requestData["region_secret"], out RegionSecret);
ulong regionHandle = Convert.ToUInt64((string)requestData["regionhandle"]);
m_localBackend.TriggerLogOffUser(regionHandle, agentID, RegionSecret, message);
return new XmlRpcResponse();
}
/// <summary>
/// Someone asked us about parcel-information
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public XmlRpcResponse LandData(XmlRpcRequest request)
{
Hashtable requestData = (Hashtable)request.Params[0];
ulong regionHandle = Convert.ToUInt64(requestData["region_handle"]);
uint x = Convert.ToUInt32(requestData["x"]);
uint y = Convert.ToUInt32(requestData["y"]);
m_log.DebugFormat("[HGrid]: Got XML reqeuest for land data at {0}, {1} in region {2}", x, y, regionHandle);
LandData landData = m_localBackend.RequestLandData(regionHandle, x, y);
Hashtable hash = new Hashtable();
if (landData != null)
{
// for now, only push out the data we need for answering a ParcelInfoReqeust
hash["AABBMax"] = landData.AABBMax.ToString();
hash["AABBMin"] = landData.AABBMin.ToString();
hash["Area"] = landData.Area.ToString();
hash["AuctionID"] = landData.AuctionID.ToString();
hash["Description"] = landData.Description;
hash["Flags"] = landData.Flags.ToString();
hash["GlobalID"] = landData.GlobalID.ToString();
hash["Name"] = landData.Name;
hash["OwnerID"] = landData.OwnerID.ToString();
hash["SalePrice"] = landData.SalePrice.ToString();
hash["SnapshotID"] = landData.SnapshotID.ToString();
hash["UserLocation"] = landData.UserLocation.ToString();
}
XmlRpcResponse response = new XmlRpcResponse();
response.Value = hash;
return response;
}
#endregion
#region Remoting
/// <summary>
/// Start listening for .net remoting calls from other regions.
/// </summary>
private void StartRemoting()
{
m_log.Info("[HGrid]: Start remoting...");
TcpChannel ch;
try
{
ch = new TcpChannel((int)NetworkServersInfo.RemotingListenerPort);
ChannelServices.RegisterChannel(ch, false); // Disabled security as Mono doesn't support this.
}
catch (Exception ex)
{
m_log.Error("[HGrid]: Exception while attempting to listen on TCP port " + (int)NetworkServersInfo.RemotingListenerPort + ".");
throw (ex);
}
WellKnownServiceTypeEntry wellType =
new WellKnownServiceTypeEntry(typeof(OGS1InterRegionRemoting), "InterRegions",
WellKnownObjectMode.Singleton);
RemotingConfiguration.RegisterWellKnownServiceType(wellType);
InterRegionSingleton.Instance.OnArrival += TriggerExpectAvatarCrossing;
InterRegionSingleton.Instance.OnChildAgent += IncomingChildAgent;
InterRegionSingleton.Instance.OnPrimGroupArrival += IncomingPrim;
InterRegionSingleton.Instance.OnPrimGroupNear += TriggerExpectPrimCrossing;
InterRegionSingleton.Instance.OnRegionUp += TriggerRegionUp;
InterRegionSingleton.Instance.OnChildAgentUpdate += TriggerChildAgentUpdate;
InterRegionSingleton.Instance.OnTellRegionToCloseChildConnection += TriggerTellRegionToCloseChildConnection;
}
#endregion
#region IInterRegionCommunications interface (Methods called by regions in this instance)
public override bool ChildAgentUpdate(ulong regionHandle, ChildAgentDataUpdate cAgentData)
{
int failures = 0;
lock (m_deadRegionCache)
{
if (m_deadRegionCache.ContainsKey(regionHandle))
{
failures = m_deadRegionCache[regionHandle];
}
}
if (failures <= 3)
{
RegionInfo regInfo = null;
try
{
if (m_localBackend.ChildAgentUpdate(regionHandle, cAgentData))
{
return true;
}
regInfo = RequestNeighbourInfo(regionHandle);
if (regInfo != null)
{
//don't want to be creating a new link to the remote instance every time like we are here
bool retValue = false;
OGS1InterRegionRemoting remObject = (OGS1InterRegionRemoting)Activator.GetObject(
typeof(OGS1InterRegionRemoting),
"tcp://" + regInfo.RemotingAddress +
":" + regInfo.RemotingPort +
"/InterRegions");
if (remObject != null)
{
retValue = remObject.ChildAgentUpdate(regionHandle, cAgentData);
}
else
{
m_log.Warn("[HGrid]: remoting object not found");
}
remObject = null;
return retValue;
}
NoteDeadRegion(regionHandle);
return false;
}
catch (RemotingException e)
{
NoteDeadRegion(regionHandle);
m_log.WarnFormat(
"[HGrid]: Remoting Error: Unable to connect to adjacent region: {0} {1},{2}",
regInfo.RegionName, regInfo.RegionLocX, regInfo.RegionLocY);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (SocketException e)
{
NoteDeadRegion(regionHandle);
m_log.WarnFormat(
"[HGrid]: Remoting Error: Unable to connect to adjacent region: {0} {1},{2}",
regInfo.RegionName, regInfo.RegionLocX, regInfo.RegionLocY);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (InvalidCredentialException e)
{
NoteDeadRegion(regionHandle);
m_log.WarnFormat(
"[HGrid]: Remoting Error: Unable to connect to adjacent region: {0} {1},{2}",
regInfo.RegionName, regInfo.RegionLocX, regInfo.RegionLocY);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (AuthenticationException e)
{
NoteDeadRegion(regionHandle);
m_log.WarnFormat(
"[HGrid]: Remoting Error: Unable to connect to adjacent region: {0} {1},{2}",
regInfo.RegionName, regInfo.RegionLocX, regInfo.RegionLocY);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (Exception e)
{
NoteDeadRegion(regionHandle);
m_log.WarnFormat("[HGrid]: Unable to connect to adjacent region: {0} {1},{2}",
regInfo.RegionName, regInfo.RegionLocX, regInfo.RegionLocY);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
}
else
{
//m_log.Info("[INTERREGION]: Skipped Sending Child Update to a region because it failed too many times:" + regionHandle.ToString());
return false;
}
}
/// <summary>
/// Inform a region that a child agent will be on the way from a client.
/// </summary>
/// <param name="regionHandle"></param>
/// <param name="agentData"></param>
/// <returns></returns>
public override bool InformRegionOfChildAgent(ulong regionHandle, AgentCircuitData agentData)
{
if (m_localBackend.InformRegionOfChildAgent(regionHandle, agentData))
{
return true;
}
return base.InformRegionOfChildAgent(regionHandle, agentData);
}
// UGLY!
public override bool RegionUp(SerializableRegionInfo region, ulong regionhandle)
{
if (m_localBackend.RegionUp(region, regionhandle))
return true;
return base.RegionUp(region, regionhandle);
}
/// <summary>
///
/// </summary>
/// <param name="regionHandle"></param>
/// <param name="agentData"></param>
/// <returns></returns>
public override bool InformRegionOfPrimCrossing(ulong regionHandle, UUID primID, string objData, int XMLMethod)
{
int failures = 0;
lock (m_deadRegionCache)
{
if (m_deadRegionCache.ContainsKey(regionHandle))
{
failures = m_deadRegionCache[regionHandle];
}
}
if (failures <= 1)
{
RegionInfo regInfo = null;
try
{
if (m_localBackend.InformRegionOfPrimCrossing(regionHandle, primID, objData, XMLMethod))
{
return true;
}
regInfo = RequestNeighbourInfo(regionHandle);
if (regInfo != null)
{
//don't want to be creating a new link to the remote instance every time like we are here
bool retValue = false;
OGS1InterRegionRemoting remObject = (OGS1InterRegionRemoting)Activator.GetObject(
typeof(OGS1InterRegionRemoting),
"tcp://" + regInfo.RemotingAddress +
":" + regInfo.RemotingPort +
"/InterRegions");
if (remObject != null)
{
retValue = remObject.InformRegionOfPrimCrossing(regionHandle, primID.Guid, objData, XMLMethod);
}
else
{
m_log.Warn("[HGrid]: Remoting object not found");
}
remObject = null;
return retValue;
}
NoteDeadRegion(regionHandle);
return false;
}
catch (RemotingException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Remoting Error: Unable to connect to adjacent region: " + regionHandle);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (SocketException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Remoting Error: Unable to connect to adjacent region: " + regionHandle);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (InvalidCredentialException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Invalid Credential Exception: Invalid Credentials : " + regionHandle);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (AuthenticationException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Authentication exception: Unable to connect to adjacent region: " + regionHandle);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (Exception e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Unknown exception: Unable to connect to adjacent region: " + regionHandle);
m_log.DebugFormat("[HGrid]: {0}", e);
return false;
}
}
else
{
return false;
}
}
/// <summary>
///
/// </summary>
/// <param name="regionHandle"></param>
/// <param name="agentID"></param>
/// <param name="position"></param>
/// <returns></returns>
public override bool ExpectAvatarCrossing(ulong regionHandle, UUID agentID, Vector3 position, bool isFlying)
{
RegionInfo[] regions = m_regionsOnInstance.ToArray();
bool banned = false;
bool localregion = false;
for (int i = 0; i < regions.Length; i++)
{
if (regions[i] != null)
{
if (regions[i].RegionHandle == regionHandle)
{
localregion = true;
if (regions[i].EstateSettings.IsBanned(agentID))
{
banned = true;
break;
}
}
}
}
if (banned)
return false;
if (localregion)
return m_localBackend.ExpectAvatarCrossing(regionHandle, agentID, position, isFlying);
return base.ExpectAvatarCrossing(regionHandle, agentID, position, isFlying);
}
public override bool ExpectPrimCrossing(ulong regionHandle, UUID agentID, Vector3 position, bool isPhysical)
{
RegionInfo regInfo = null;
try
{
if (m_localBackend.TriggerExpectPrimCrossing(regionHandle, agentID, position, isPhysical))
{
return true;
}
regInfo = RequestNeighbourInfo(regionHandle);
if (regInfo != null)
{
bool retValue = false;
OGS1InterRegionRemoting remObject = (OGS1InterRegionRemoting)Activator.GetObject(
typeof(OGS1InterRegionRemoting),
"tcp://" + regInfo.RemotingAddress +
":" + regInfo.RemotingPort +
"/InterRegions");
if (remObject != null)
{
retValue =
remObject.ExpectAvatarCrossing(regionHandle, agentID.Guid, new sLLVector3(position),
isPhysical);
}
else
{
m_log.Warn("[HGrid]: Remoting object not found");
}
remObject = null;
return retValue;
}
//TODO need to see if we know about where this region is and use .net remoting
// to inform it.
NoteDeadRegion(regionHandle);
return false;
}
catch (RemotingException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Remoting Error: Unable to connect to adjacent region: " + regionHandle);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (SocketException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Remoting Error: Unable to connect to adjacent region: " + regionHandle);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (InvalidCredentialException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Invalid Credential Exception: Invalid Credentials : " + regionHandle);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (AuthenticationException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Authentication exception: Unable to connect to adjacent region: " + regionHandle);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (Exception e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Unknown exception: Unable to connect to adjacent region: " + regionHandle);
m_log.DebugFormat("[HGrid]: {0}", e);
return false;
}
}
public override bool TellRegionToCloseChildConnection(ulong regionHandle, UUID agentID)
{
RegionInfo regInfo = null;
try
{
if (m_localBackend.TriggerTellRegionToCloseChildConnection(regionHandle, agentID))
{
return true;
}
regInfo = RequestNeighbourInfo(regionHandle);
if (regInfo != null)
{
// bool retValue = false;
OGS1InterRegionRemoting remObject = (OGS1InterRegionRemoting)Activator.GetObject(
typeof(OGS1InterRegionRemoting),
"tcp://" + regInfo.RemotingAddress +
":" + regInfo.RemotingPort +
"/InterRegions");
if (remObject != null)
{
// retValue =
remObject.TellRegionToCloseChildConnection(regionHandle, agentID.Guid);
}
else
{
m_log.Warn("[HGrid]: Remoting object not found");
}
remObject = null;
return true;
}
//TODO need to see if we know about where this region is and use .net remoting
// to inform it.
NoteDeadRegion(regionHandle);
return false;
}
catch (RemotingException)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Remoting Error: Unable to connect to adjacent region to tell it to close child agents: " + regInfo.RegionName +
" " + regInfo.RegionLocX + "," + regInfo.RegionLocY);
//m_log.Debug(e.ToString());
return false;
}
catch (SocketException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGridS]: Socket Error: Unable to connect to adjacent region using tcp://" +
regInfo.RemotingAddress +
":" + regInfo.RemotingPort +
"/InterRegions - @ " + regInfo.RegionLocX + "," + regInfo.RegionLocY +
" - Is this neighbor up?");
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (InvalidCredentialException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Invalid Credentials: Unable to connect to adjacent region using tcp://" +
regInfo.RemotingAddress +
":" + regInfo.RemotingPort +
"/InterRegions - @ " + regInfo.RegionLocX + "," + regInfo.RegionLocY);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (AuthenticationException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: Authentication exception: Unable to connect to adjacent region using tcp://" +
regInfo.RemotingAddress +
":" + regInfo.RemotingPort +
"/InterRegions - @ " + regInfo.RegionLocX + "," + regInfo.RegionLocY);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (WebException e)
{
NoteDeadRegion(regionHandle);
m_log.Warn("[HGrid]: WebException exception: Unable to connect to adjacent region using tcp://" +
regInfo.RemotingAddress +
":" + regInfo.RemotingPort +
"/InterRegions - @ " + regInfo.RegionLocX + "," + regInfo.RegionLocY);
m_log.DebugFormat("[HGrid]: {0} {1}", e.Source, e.Message);
return false;
}
catch (Exception e)
{
NoteDeadRegion(regionHandle);
// This line errors with a Null Reference Exception.. Why? @.@
//m_log.Warn("Unknown exception: Unable to connect to adjacent region using tcp://" + regInfo.RemotingAddress +
// ":" + regInfo.RemotingPort +
//"/InterRegions - @ " + regInfo.RegionLocX + "," + regInfo.RegionLocY + " - This is likely caused by an incompatibility in the protocol between this sim and that one");
m_log.DebugFormat("[HGrid]: {0}", e);
return false;
}
}
public override bool AcknowledgeAgentCrossed(ulong regionHandle, UUID agentId)
{
return m_localBackend.AcknowledgeAgentCrossed(regionHandle, agentId);
}
public override bool AcknowledgePrimCrossed(ulong regionHandle, UUID primId)
{
return m_localBackend.AcknowledgePrimCrossed(regionHandle, primId);
}
#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]: " + gdebugRegionName + ": Incoming HGrid Agent " + agentData.firstname + " " + agentData.lastname);
return m_localBackend.IncomingChildAgent(regionHandle, agentData);
}
public bool TriggerRegionUp(RegionUpData regionData, ulong regionhandle)
{
m_log.Info(
"[HGrid]: " +
m_localBackend._gdebugRegionName + "Incoming HGrid RegionUpReport: " + "(" + regionData.X +
"," + regionData.Y + "). Giving this region a fresh set of 'dead' tries");
RegionInfo nRegionInfo = new RegionInfo();
nRegionInfo.SetEndPoint("127.0.0.1", regionData.PORT);
nRegionInfo.ExternalHostName = regionData.IPADDR;
nRegionInfo.RegionLocX = regionData.X;
nRegionInfo.RegionLocY = regionData.Y;
lock (m_deadRegionCache)
{
if (m_deadRegionCache.ContainsKey(nRegionInfo.RegionHandle))
{
m_deadRegionCache.Remove(nRegionInfo.RegionHandle);
}
}
return m_localBackend.TriggerRegionUp(nRegionInfo, regionhandle);
}
public bool TriggerChildAgentUpdate(ulong regionHandle, ChildAgentDataUpdate cAgentData)
{
//m_log.Info("[INTER]: Incoming HGrid Child Agent Data Update");
return m_localBackend.TriggerChildAgentUpdate(regionHandle, cAgentData);
}
/// <summary>
///
/// </summary>
/// <param name="regionHandle"></param>
/// <param name="agentData"></param>
/// <returns></returns>
public bool IncomingPrim(ulong regionHandle, UUID primID, string objData, int XMLMethod)
{
m_localBackend.TriggerExpectPrim(regionHandle, primID, objData, XMLMethod);
return true;
}
/// <summary>
///
/// </summary>
/// <param name="regionHandle"></param>
/// <param name="agentID"></param>
/// <param name="position"></param>
/// <returns></returns>
public bool TriggerExpectAvatarCrossing(ulong regionHandle, UUID agentID, Vector3 position, bool isFlying)
{
return m_localBackend.TriggerExpectAvatarCrossing(regionHandle, agentID, position, isFlying);
}
public bool TriggerExpectPrimCrossing(ulong regionHandle, UUID agentID, Vector3 position, bool isPhysical)
{
return m_localBackend.TriggerExpectPrimCrossing(regionHandle, agentID, position, isPhysical);
}
public bool TriggerTellRegionToCloseChildConnection(ulong regionHandle, UUID agentID)
{
return m_localBackend.TriggerTellRegionToCloseChildConnection(regionHandle, agentID);
}
int timeOut = 10; //10 seconds
/// <summary>
/// Check that a region is available for TCP comms. This is necessary for .NET remoting between regions.
/// </summary>
/// <param name="address"></param>
/// <param name="port"></param>
/// <param name="retry"></param>
/// <returns></returns>
public bool CheckRegion(string address, uint port, bool retry)
{
bool available = false;
bool timed_out = true;
IPAddress ia;
IPAddress.TryParse(address, out ia);
IPEndPoint m_EndPoint = new IPEndPoint(ia, (int)port);
AsyncCallback callback = delegate(IAsyncResult iar)
{
Socket s = (Socket)iar.AsyncState;
try
{
s.EndConnect(iar);
available = true;
timed_out = false;
}
catch (Exception e)
{
m_log.DebugFormat(
"[HGrid]: Callback EndConnect exception: {0}:{1}", e.Message, e.StackTrace);
}
s.Close();
};
try
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IAsyncResult ar = socket.BeginConnect(m_EndPoint, callback, socket);
ar.AsyncWaitHandle.WaitOne(timeOut * 1000, false);
}
catch (Exception e)
{
m_log.DebugFormat(
"[HGrid]: CheckRegion Socket Setup exception: {0}:{1}", e.Message, e.StackTrace);
return false;
}
if (timed_out)
{
m_log.DebugFormat(
"[HGrid]: socket [{0}] timed out ({1}) waiting to obtain a connection.",
m_EndPoint, timeOut * 1000);
if (retry)
{
return CheckRegion(address, port, false);
}
}
return available;
}
public override bool CheckRegion(string address, uint port)
{
return CheckRegion(address, port, true);
}
public void NoteDeadRegion(ulong regionhandle)
{
lock (m_deadRegionCache)
{
if (m_deadRegionCache.ContainsKey(regionhandle))
{
m_deadRegionCache[regionhandle] = m_deadRegionCache[regionhandle] + 1;
}
else
{
m_deadRegionCache.Add(regionhandle, 1);
}
}
}
#endregion
}
}

451
OpenSim/Region/Communications/Hypergrid/HGInventoryService.cs Normal file
View File

@ -0,0 +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;
}
}
}

267
OpenSim/Region/Communications/Hypergrid/HGUserServices.cs Normal file
View File

@ -0,0 +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
}
}

199
OpenSim/Region/Environment/Modules/Hypergrid/HGStandaloneAssetService.cs Normal file
View File

@ -0,0 +1,199 @@
/**
* 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);
}
}
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;
}
}
}
}

315
OpenSim/Region/Environment/Modules/Hypergrid/HGStandaloneInventoryService.cs Normal file
View File

@ -0,0 +1,315 @@
/**
* 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);
}
}
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);
}
}
}

178
OpenSim/Region/Environment/Modules/Hypergrid/HGWorldMapModule.cs Normal file
View File

@ -0,0 +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);
}
}
}
}
}

377
OpenSim/Region/Environment/Scenes/Hypergrid/HGAssetMapper.cs Normal file
View File

@ -0,0 +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
}
}

152
OpenSim/Region/Environment/Scenes/Hypergrid/HGScene.Inventory.cs Normal file
View File

@ -0,0 +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
}
}

78
OpenSim/Region/Environment/Scenes/Hypergrid/HGScene.cs Normal file
View File

@ -0,0 +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));
}
}
}
}

263
OpenSim/Region/Environment/Scenes/Hypergrid/HGSceneCommunicationService.cs Normal file
View File

@ -0,0 +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);
}
}
}
}
}

409
prebuild.xml
View File

@ -815,6 +815,192 @@
</Files>
</Project>
<!-- OGS projects -->
<Project name="OpenSim.Grid.Communications.OGS1" path="OpenSim/Grid/Communications/OGS1" type="Library">
<Configuration name="Debug">
<Options>
<OutputPath>../../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../../bin/</ReferencePath>
<Reference name="System"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.Communications" />
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="XMLRPC.dll"/>
<Reference name="log4net.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Grid.GridServer" path="OpenSim/Grid/GridServer" type="Exe">
<Configuration name="Debug">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../bin/</ReferencePath>
<Reference name="System" localCopy="false"/>
<Reference name="System.Data" localCopy="false"/>
<Reference name="System.Xml" localCopy="false"/>
<Reference name="Mono.Addins.dll" />
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.Communications"/>
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenSim.Data"/>
<Reference name="OpenSim.Data.MySQL"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="OpenMetaverse.dll"/>
<Reference name="XMLRPC.dll"/>
<Reference name="log4net.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Grid.AssetServer" path="OpenSim/Grid/AssetServer" type="Exe">
<Configuration name="Debug">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../bin/</ReferencePath>
<Reference name="System" localCopy="false"/>
<Reference name="System.Data" localCopy="false"/>
<Reference name="System.Xml" localCopy="false"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.AssetLoader.Filesystem"/>
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenSim.Framework.Communications"/>
<Reference name="OpenSim.Framework.Statistics"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="log4net.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Grid.UserServer" path="OpenSim/Grid/UserServer" type="Exe">
<Configuration name="Debug">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../bin/</ReferencePath>
<Reference name="System" localCopy="false"/>
<Reference name="System.Data" localCopy="false"/>
<Reference name="System.Xml" localCopy="false"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Framework.Communications"/>
<Reference name="OpenSim.Data"/>
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenSim.Framework.Statistics"/>
<Reference name="OpenSim.Grid.Communications.OGS1"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="OpenMetaverse.StructuredData.dll"/>
<Reference name="XMLRPC.dll"/>
<Reference name="log4net.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Grid.InventoryServer" path="OpenSim/Grid/InventoryServer" type="Exe">
<Configuration name="Debug">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../bin/</ReferencePath>
<Reference name="System" localCopy="false"/>
<Reference name="System.Data" localCopy="false"/>
<Reference name="System.Xml" localCopy="false"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Framework.Communications"/>
<Reference name="OpenSim.Data"/>
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="log4net.dll"/>
<Reference name="XMLRPC.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Grid.MessagingServer" path="OpenSim/Grid/MessagingServer" type="Exe">
<Configuration name="Debug">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../bin/</ReferencePath>
<Reference name="System" localCopy="false"/>
<Reference name="System.Data" localCopy="false"/>
<Reference name="System.Xml" localCopy="false"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Framework.Communications"/>
<Reference name="OpenSim.Data"/>
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="OpenMetaverse.dll"/>
<Reference name="XMLRPC.dll"/>
<Reference name="log4net.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Region.Environment" path="OpenSim/Region/Environment" type="Library">
<Configuration name="Debug">
<Options>
@ -843,6 +1029,7 @@
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenSim.Framework.Statistics"/>
<Reference name="OpenSim.Region.Physics.Manager"/>
<Reference name="OpenSim.Grid.AssetServer"/>
<!-- For scripting in funny languages by default -->
<Reference name="Microsoft.JScript"/>
@ -917,6 +1104,42 @@
</Files>
</Project>
<Project name="OpenSim.Region.Communications.Hypergrid" path="OpenSim/Region/Communications/Hypergrid" type="Library">
<Configuration name="Debug">
<Options>
<OutputPath>../../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../../bin/</ReferencePath>
<Reference name="System"/>
<Reference name="System.Drawing"/>
<Reference name="System.Runtime.Remoting"/>
<Reference name="System.Xml"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.Communications" />
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenSim.Framework.Statistics"/>
<Reference name="OpenSim.Region.Communications.Local"/>
<Reference name="OpenSim.Region.Communications.OGS1"/>
<Reference name="OpenSim.Region.Environment"/>
<Reference name="OpenSim.Region.Interfaces"/>
<Reference name="OpenMetaverse.dll"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="XMLRPC.dll"/>
<Reference name="log4net.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Region.ClientStack" path="OpenSim/Region/ClientStack" type="Library">
<Configuration name="Debug">
<Options>
@ -1155,6 +1378,7 @@
<Reference name="OpenSim.Region.Communications.OGS1"/>
<Reference name="XMLRPC.dll"/>
<Reference name="OpenSim.Region.Communications.Local"/>
<Reference name="OpenSim.Region.Communications.Hypergrid"/>
<Reference name="Nini.dll" />
<Reference name="log4net.dll"/>
@ -2007,191 +2231,6 @@
</Files>
</Project>
<!-- OGS projects -->
<Project name="OpenSim.Grid.Communications.OGS1" path="OpenSim/Grid/Communications/OGS1" type="Library">
<Configuration name="Debug">
<Options>
<OutputPath>../../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../../bin/</ReferencePath>
<Reference name="System"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.Communications" />
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="XMLRPC.dll"/>
<Reference name="log4net.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Grid.GridServer" path="OpenSim/Grid/GridServer" type="Exe">
<Configuration name="Debug">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../bin/</ReferencePath>
<Reference name="System" localCopy="false"/>
<Reference name="System.Data" localCopy="false"/>
<Reference name="System.Xml" localCopy="false"/>
<Reference name="Mono.Addins.dll" />
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.Communications"/>
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenSim.Data"/>
<Reference name="OpenSim.Data.MySQL"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="OpenMetaverse.dll"/>
<Reference name="XMLRPC.dll"/>
<Reference name="log4net.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Grid.AssetServer" path="OpenSim/Grid/AssetServer" type="Exe">
<Configuration name="Debug">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../bin/</ReferencePath>
<Reference name="System" localCopy="false"/>
<Reference name="System.Data" localCopy="false"/>
<Reference name="System.Xml" localCopy="false"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.AssetLoader.Filesystem"/>
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenSim.Framework.Communications"/>
<Reference name="OpenSim.Framework.Statistics"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="log4net.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Grid.UserServer" path="OpenSim/Grid/UserServer" type="Exe">
<Configuration name="Debug">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../bin/</ReferencePath>
<Reference name="System" localCopy="false"/>
<Reference name="System.Data" localCopy="false"/>
<Reference name="System.Xml" localCopy="false"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Framework.Communications"/>
<Reference name="OpenSim.Data"/>
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenSim.Framework.Statistics"/>
<Reference name="OpenSim.Grid.Communications.OGS1"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="OpenMetaverse.StructuredData.dll"/>
<Reference name="XMLRPC.dll"/>
<Reference name="log4net.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Grid.InventoryServer" path="OpenSim/Grid/InventoryServer" type="Exe">
<Configuration name="Debug">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../bin/</ReferencePath>
<Reference name="System" localCopy="false"/>
<Reference name="System.Data" localCopy="false"/>
<Reference name="System.Xml" localCopy="false"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Framework.Communications"/>
<Reference name="OpenSim.Data"/>
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="log4net.dll"/>
<Reference name="XMLRPC.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Grid.MessagingServer" path="OpenSim/Grid/MessagingServer" type="Exe">
<Configuration name="Debug">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../bin/</ReferencePath>
<Reference name="System" localCopy="false"/>
<Reference name="System.Data" localCopy="false"/>
<Reference name="System.Xml" localCopy="false"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Framework.Communications"/>
<Reference name="OpenSim.Data"/>
<Reference name="OpenSim.Framework.Servers"/>
<Reference name="OpenMetaverseTypes.dll"/>
<Reference name="OpenMetaverse.dll"/>
<Reference name="XMLRPC.dll"/>
<Reference name="log4net.dll"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.ScriptEngine.Shared.Script" path="OpenSim/ScriptEngine/Shared.Script" type="Library">
<Configuration name="Debug">
<Options>