public GridRegion GetRegionByURI(UUID scopeID, RegionURI uri)
{
GridRegion rinfo = m_LocalGridService.GetRegionByURI(scopeID, uri);
if (rinfo != null)
{
m_RegionInfoCache.Cache(scopeID, rinfo);
return(rinfo);
}
if (m_RemoteGridService == null || !uri.IsLocalGrid)
{
return(rinfo);
}
if (uri.HasRegionName)
{
rinfo = m_RemoteGridService.GetRegionByName(scopeID, uri.RegionName);
}
else
{
rinfo = m_RemoteGridService.GetDefaultRegions(UUID.Zero)[0];
if (rinfo == null)
{
m_log.Warn("[REMOTE GRID CONNECTOR] returned null default region");
}
else
{
m_log.WarnFormat("[REMOTE GRID CONNECTOR] returned default region {0}", rinfo.RegionName);
}
}
m_RegionInfoCache.Cache(scopeID, rinfo);
return(rinfo);
}
public GridRegion GetRegionByName(UUID scopeID, string name)
{
var nameURI = new RegionURI(name);
if (!nameURI.IsValid)
{
return(null);
}
return(GetRegionByURI(scopeID, nameURI));
}
public List <GridRegion> GetRegionsByURI(UUID scopeID, RegionURI uri, int maxNumber)
{
if (!uri.IsValid)
{
return(null);
}
List <GridRegion> rinfo = m_LocalGridService.GetRegionsByURI(scopeID, uri, maxNumber);
//m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Local GetRegionsByName {0} found {1} regions", name, rinfo.Count);
if (m_RemoteGridService == null || !uri.IsLocalGrid)
{
return(rinfo);
}
List <GridRegion> grinfo = null;
if (!uri.HasRegionName && (rinfo == null || rinfo.Count == 0))
{
List <GridRegion> grinfos = m_RemoteGridService.GetDefaultRegions(scopeID);
if (grinfos == null || grinfos.Count == 0)
{
m_log.Info("[REMOTE GRID CONNECTOR] returned no default regions");
}
else
{
m_log.InfoFormat("[REMOTE GRID CONNECTOR] returned default regions {0}, ...", grinfos[0].RegionName);
// only return first
grinfo = new List <GridRegion>()
{
grinfos[0]
};
}
}
else
{
grinfo = m_RemoteGridService.GetRegionsByName(scopeID, uri.RegionName, maxNumber);
}
if (grinfo != null)
{
//m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Remote GetRegionsByName {0} found {1} regions", name, grinfo.Count);
foreach (GridRegion r in grinfo)
{
m_RegionInfoCache.Cache(r);
if (rinfo.Find(delegate(GridRegion gr) { return(gr.RegionID == r.RegionID); }) == null)
{
rinfo.Add(r);
}
}
}
return(rinfo);
}
public List <GridRegion> GetRegionsByName(UUID scopeID, string name, int maxNumber)
{
// m_log.DebugFormat("[GRID SERVICE]: GetRegionsByName {0}", name);
var nameURI = new RegionURI(name);
if (!nameURI.IsValid)
{
return(new List <GridRegion>());
}
return(GetRegionsByURI(scopeID, nameURI, maxNumber));
}
public GridRegion GetRegionByName(UUID scopeID, string name)
{
bool inCache = false;
GridRegion rinfo = m_RegionInfoCache.Get(scopeID, name, out inCache);
if (inCache)
{
return(rinfo);
}
var ruri = new RegionURI(name, m_ThisGridInfo);
return(GetRegionByURI(scopeID, ruri));
}
public GridRegion LinkRegion(UUID scopeID, RegionURI rurl)
{
if (!rurl.IsValid)
{
return(null);
}
if (rurl.IsLocalGrid)
{
m_log.InfoFormat("[HYPERGRID LINKER]: Cannot hyperlink to regions on the same grid");
return(null);
}
int xloc = random.Next(0, short.MaxValue) << 8;
if (TryCreateLinkImpl(scopeID, xloc, 0, rurl, UUID.Zero, out GridRegion regInfo))
{
return(regInfo);
}
return(null);
}
public List <GridRegion> GetRegionsByURI(UUID scopeID, RegionURI uri, int maxNumber)
{
return(null);
}
public GridRegion GetRegionByURI(UUID scopeID, RegionURI uri)
{
return(null);
}
public List <GridRegion> GetRegionsByName(UUID scopeID, string name, int maxNumber)
{
var ruri = new RegionURI(name, m_ThisGridInfo);
return(GetRegionsByURI(scopeID, ruri, maxNumber));
}
public List <GridRegion> GetRegionsByURI(UUID scopeID, RegionURI nameURI, int maxNumber)
{
// m_log.DebugFormat("[GRID SERVICE]: GetRegionsByName {0}", name);
if (!nameURI.IsValid)
{
return(new List <GridRegion>());
}
bool localGrid;
if (nameURI.HasHost)
{
if (!nameURI.ResolveDNS())
{
return(new List <GridRegion>());
}
localGrid = m_HypergridLinker.IsLocalGrid(nameURI.HostUrl);
nameURI.IsLocalGrid = localGrid;
if (!nameURI.IsValid)
{
return(new List <GridRegion>());
}
}
else
{
localGrid = true;
}
int count = 0;
string mapname = nameURI.RegionHostPortSpaceName;
List <RegionData> rdatas = m_Database.Get("%" + Util.EscapeForLike(mapname) + "%", scopeID);
List <GridRegion> rinfos = new List <GridRegion>();
if (localGrid)
{
if (!nameURI.HasRegionName)
{
List <GridRegion> dinfos = GetDefaultRegions(scopeID);
if (dinfos != null && dinfos.Count > 0)
{
rinfos.Add(dinfos[0]);
}
}
else
{
string name = nameURI.RegionName;
if (rdatas != null && (rdatas.Count > 0))
{
//m_log.DebugFormat("[GRID SERVICE]: Found {0} regions", rdatas.Count);
foreach (RegionData rdata in rdatas)
{
if (name.Equals(rdata.RegionName, StringComparison.InvariantCultureIgnoreCase))
{
rinfos.Insert(0, RegionData2RegionInfo(rdata));
if (count == maxNumber)
{
rinfos.RemoveAt(count - 1);
}
}
else if (count++ < maxNumber)
{
rinfos.Add(RegionData2RegionInfo(rdata));
}
}
}
}
return(rinfos);
}
if (!m_AllowHypergridMapSearch)
{
return(rinfos);
}
if (rdatas != null && (rdatas.Count > 0))
{
bool haveMatch = false;
// m_log.DebugFormat("[GRID SERVICE]: Found {0} regions", rdatas.Count);
foreach (RegionData rdata in rdatas)
{
int indx = rdata.RegionName.IndexOf("://");
if (indx < 0)
{
continue;
}
string rname = rdata.RegionName.Substring(indx + 3);
if (mapname.Equals(rname, StringComparison.InvariantCultureIgnoreCase))
{
haveMatch = true;
rinfos.Insert(0, RegionData2RegionInfo(rdata));
if (count == maxNumber)
{
rinfos.RemoveAt(count - 1);
}
}
else if (count++ < maxNumber)
{
rinfos.Add(RegionData2RegionInfo(rdata));
}
}
if (haveMatch)
{
return(rinfos);
}
}
GridRegion r = m_HypergridLinker.LinkRegion(scopeID, nameURI);
if (r != null)
{
if (count == maxNumber)
{
rinfos.RemoveAt(count - 1);
}
rinfos.Add(r);
}
return(rinfos);
}
public GridRegion GetRegionByURI(UUID scopeID, RegionURI uri)
{
if (!uri.IsValid)
{
return(null);
}
bool localGrid = true;
if (uri.HasHost)
{
if (!uri.ResolveDNS())
{
return(null);
}
localGrid = m_HypergridLinker.IsLocalGrid(uri.HostUrl);
uri.IsLocalGrid = localGrid;
}
if (localGrid)
{
if (uri.HasRegionName)
{
RegionData rdata = m_Database.GetSpecific(uri.RegionName, scopeID);
if (rdata != null)
{
return(RegionData2RegionInfo(rdata));
}
}
else
{
List <GridRegion> defregs = GetDefaultRegions(scopeID);
if (defregs != null)
{
return(defregs[0]);
}
}
return(null);
}
if (!m_AllowHypergridMapSearch)
{
return(null);
}
string mapname = uri.RegionHostPortSpaceName;
List <RegionData> rdatas = m_Database.Get("%" + Util.EscapeForLike(mapname), scopeID);
if (rdatas != null && rdatas.Count > 0)
{
foreach (RegionData rdata in rdatas)
{
int indx = rdata.RegionName.IndexOf("://");
if (indx < 0)
{
continue;
}
string rname = rdata.RegionName.Substring(indx + 3);
if (mapname.Equals(rname, StringComparison.InvariantCultureIgnoreCase))
{
return(RegionData2RegionInfo(rdata));
}
}
}
GridRegion r = m_HypergridLinker.LinkRegion(scopeID, uri);
return(r);
}
private bool TryCreateLinkImpl(UUID scopeID, int xloc, int yloc, RegionURI rurl, UUID ownerID, out GridRegion regInfo)
{
m_log.InfoFormat("[HYPERGRID LINKER]: Link to {0} {1}, in <{2},{3}>",
rurl.HostUrl, rurl.RegionName, Util.WorldToRegionLoc((uint)xloc), Util.WorldToRegionLoc((uint)yloc));
// Check for free coordinates
GridRegion region = m_GridService.GetRegionByPosition(scopeID, xloc, yloc);
if (region != null)
{
m_log.WarnFormat("[HYPERGRID LINKER]: Coordinates <{0},{1}> are already occupied by region {2} with uuid {3}",
Util.WorldToRegionLoc((uint)xloc), Util.WorldToRegionLoc((uint)yloc),
region.RegionName, region.RegionID);
regInfo = null;
return(false);
}
regInfo = new GridRegion()
{
HttpPort = (uint)rurl.Port,
ExternalHostName = rurl.Host,
ServerURI = rurl.HostUrl,
RegionName = rurl.RegionName,
RegionLocX = xloc,
RegionLocY = yloc,
ScopeID = scopeID,
EstateOwner = ownerID,
InternalEndPoint = dummyIP
};
// Finally, link it
ulong handle = 0;
UUID regionID = UUID.Zero;
string externalName = string.Empty;
string imageURL = string.Empty;
int sizeX = (int)Constants.RegionSize;
int sizeY = (int)Constants.RegionSize;
if (!m_GatekeeperConnector.LinkRegion(regInfo, out regionID, out handle, out externalName, out imageURL, out string reason, out sizeX, out sizeY))
{
return(false);
}
if (regionID == UUID.Zero)
{
m_log.Warn("[HYPERGRID LINKER]: Unable to link region: " + reason);
return(false);
}
region = m_GridService.GetRegionByUUID(scopeID, regionID);
if (region != null)
{
m_log.DebugFormat("[HYPERGRID LINKER]: Region already exists in coordinates <{0},{1}>",
Util.WorldToRegionLoc((uint)region.RegionLocX), Util.WorldToRegionLoc((uint)region.RegionLocY));
regInfo = region;
return(true);
}
regInfo.RegionID = regionID;
regInfo.RegionSizeX = sizeX;
regInfo.RegionSizeY = sizeY;
if (externalName == string.Empty)
{
regInfo.RegionName = regInfo.ServerURI;
}
else
{
regInfo.RegionName = externalName;
}
m_log.DebugFormat("[HYPERGRID LINKER]: naming linked region {0}, handle {1}", regInfo.RegionName, handle.ToString());
// Get the map image
regInfo.TerrainImage = GetMapImage(regionID, imageURL);
// Store the origin's coordinates somewhere
regInfo.RegionSecret = handle.ToString();
AddHyperlinkRegion(regInfo, handle);
m_log.InfoFormat("[HYPERGRID LINKER]: Successfully linked to region {0} at <{1},{2}> with image {3}",
regInfo.RegionName, Util.WorldToRegionLoc((uint)regInfo.RegionLocX), Util.WorldToRegionLoc((uint)regInfo.RegionLocY), regInfo.TerrainImage);
return(true);
}
