merge LocalGridServicesConnector and LemoteGridServicesConnector into just RegionGridServicesConnector, with more clear code path and less useless modules loading. runprebuild and note the need changes in config-include files

OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/LocalGridServiceConnector.cs

@@ -1,310 +0,0 @@
-/*
- * 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 OpenSimulator 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 log4net;
-using Mono.Addins;
-using Nini.Config;
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using OpenSim.Framework;
-using OpenSim.Framework.Console;
-using OpenSim.Server.Base;
-using OpenSim.Region.Framework.Interfaces;
-using OpenSim.Region.Framework.Scenes;
-using OpenSim.Services.Interfaces;
-using GridRegion = OpenSim.Services.Interfaces.GridRegion;
-using OpenMetaverse;
-
-namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
-{
-    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "LocalGridServicesConnector")]
-    public class LocalGridServicesConnector : ISharedRegionModule, IGridService
-    {
-        private static readonly ILog m_log =
-                LogManager.GetLogger(
-                MethodBase.GetCurrentMethod().DeclaringType);
-        private static string LogHeader = "[LOCAL GRID SERVICE CONNECTOR]";
-
-        private IGridService m_GridService;
-        private RegionInfoCache m_RegionInfoCache;
-        private HashSet<Scene> m_scenes = new HashSet<Scene>();
-
-        private bool m_Enabled;
-
-        public LocalGridServicesConnector()
-        {
-            m_log.DebugFormat("{0} LocalGridServicesConnector no parms.", LogHeader);
-        }
-
-        public LocalGridServicesConnector(IConfigSource source)
-        {
-            m_log.DebugFormat("{0} LocalGridServicesConnector instantiated directly.", LogHeader);
-            InitialiseService(source, null);
-        }
-
-        public LocalGridServicesConnector(IConfigSource source, RegionInfoCache regionInfoCache)
-        {
-            m_log.DebugFormat("{0} LocalGridServicesConnector instantiated directly with cache.", LogHeader);
-            InitialiseService(source, regionInfoCache);
-        }
-
-        #region ISharedRegionModule
-
-        public Type ReplaceableInterface
-        {
-            get { return null; }
-        }
-
-        public string Name
-        {
-            get { return "LocalGridServicesConnector"; }
-        }
-
-        public void Initialise(IConfigSource source)
-        {
-            IConfig moduleConfig = source.Configs["Modules"];
-            if (moduleConfig != null)
-            {
-                string name = moduleConfig.GetString("GridServices", "");
-                if (name == Name)
-                {
-                    if(InitialiseService(source, null))
-                        m_log.Info("[LOCAL GRID SERVICE CONNECTOR]: Local grid connector enabled");
-                }
-            }
-        }
-
-        private bool InitialiseService(IConfigSource source, RegionInfoCache ric)
-        {
-            if(ric == null && m_RegionInfoCache == null)
-                m_RegionInfoCache = new RegionInfoCache();
-            else
-                m_RegionInfoCache = ric;
-
-            IConfig config = source.Configs["GridService"];
-            if (config == null)
-            {
-                m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: GridService missing from OpenSim.ini");
-                return false;
-            }
-
-            string serviceDll = config.GetString("LocalServiceModule", String.Empty);
-
-            if (serviceDll == String.Empty)
-            {
-                m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: No LocalServiceModule named in section GridService");
-                return false;
-            }
-
-            Object[] args = new Object[] { source };
-            m_GridService = ServerUtils.LoadPlugin<IGridService>(serviceDll, args);
-
-            if (m_GridService == null)
-            {
-                m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: Can't load grid service");
-                return false;
-            }
-
-            m_Enabled = true;
-            return true;
-        }
-
-        public void PostInitialise()
-        {
-        }
-
-        public void Close()
-        {
-        }
-
-        public void AddRegion(Scene scene)
-        {
-            if (!m_Enabled)
-                return;
-
-            lock(m_scenes)
-            {
-                if(!m_scenes.Contains(scene))
-                    m_scenes.Add(scene);
-            }
-            scene.RegisterModuleInterface<IGridService>(this);
-
-            GridRegion r = new GridRegion(scene.RegionInfo);
-            m_RegionInfoCache.CacheLocal(r);
-
-            scene.EventManager.OnRegionUp += OnRegionUp;
-        }
-
-        public void RemoveRegion(Scene scene)
-        {
-            if (!m_Enabled)
-                return;
-
-            lock(m_scenes)
-            {
-                if(m_scenes.Contains(scene))
-                    m_scenes.Remove(scene);
-            }
-
-            m_RegionInfoCache.Remove(scene.RegionInfo.ScopeID, scene.RegionInfo.RegionHandle);
-            scene.EventManager.OnRegionUp -= OnRegionUp;
-        }
-
-        public void RegionLoaded(Scene scene)
-        {
-        }
-
-        #endregion
-
-        #region IGridService
-
-        private void OnRegionUp(GridRegion region)
-        {
-            // This shouldn't happen
-            if (region == null)
-                return;
-
-            m_RegionInfoCache.CacheNearNeighbour(region.ScopeID, region);
-        }
-
-        public string RegisterRegion(UUID scopeID, GridRegion regionInfo)
-        {
-            return m_GridService.RegisterRegion(scopeID, regionInfo);
-        }
-
-        public bool DeregisterRegion(UUID regionID)
-        {
-            return m_GridService.DeregisterRegion(regionID);
-        }
-
-        public List<GridRegion> GetNeighbours(UUID scopeID, UUID regionID)
-        {
-            return m_GridService.GetNeighbours(scopeID, regionID);
-        }
-
-        public GridRegion GetRegionByUUID(UUID scopeID, UUID regionID)
-        {
-            bool inCache = false;
-            GridRegion rinfo = m_RegionInfoCache.Get(scopeID, regionID, out inCache);
-            if (inCache)
-                return rinfo;
-
-            rinfo = m_GridService.GetRegionByUUID(scopeID, regionID);
-            if (rinfo != null)
-                m_RegionInfoCache.Cache(scopeID, rinfo);
-            return rinfo;
-        }
-
-        public GridRegion GetRegionByHandle(UUID scopeID, ulong regionhandle)
-        {
-            bool inCache = false;
-            GridRegion rinfo = m_RegionInfoCache.Get(scopeID, regionhandle, out inCache);
-            if (inCache)
-                return rinfo;
-
-            rinfo = m_GridService.GetRegionByHandle(scopeID, regionhandle);
-            if (rinfo != null)
-                m_RegionInfoCache.Cache(scopeID, rinfo);
-            return rinfo;
-        }
-
-        // Get a region given its base coordinates.
-        // NOTE: this is NOT 'get a region by some point in the region'. The coordinate MUST
-        //     be the base coordinate of the region.
-        public GridRegion GetRegionByPosition(UUID scopeID, int x, int y)
-        {
-
-            bool inCache = false;
-            GridRegion rinfo = m_RegionInfoCache.Get(scopeID, (uint)x, (uint)y, out inCache);
-            if (inCache)
-                return rinfo;
-
-            // Then try on this sim (may be a lookup in DB if this is using MySql).
-            rinfo = m_GridService.GetRegionByPosition(scopeID, x, y);
-            if(rinfo != null)
-                m_RegionInfoCache.Cache(scopeID, rinfo);
-            return rinfo;
-        }
-
-        public GridRegion GetRegionByName(UUID scopeID, string regionName)
-        {
-            bool inCache = false;
-            GridRegion rinfo = m_RegionInfoCache.Get(scopeID, regionName, out inCache);
-            if (inCache)
-                return rinfo;
-
-            rinfo =  m_GridService.GetRegionByName(scopeID, regionName);
-            if(rinfo != null)
-                m_RegionInfoCache.Cache(scopeID, rinfo);
-            return rinfo;
-        }
-
-        public List<GridRegion> GetRegionsByName(UUID scopeID, string name, int maxNumber)
-        {
-            return m_GridService.GetRegionsByName(scopeID, name, maxNumber);
-        }
-
-        public List<GridRegion> GetRegionRange(UUID scopeID, int xmin, int xmax, int ymin, int ymax)
-        {
-            return m_GridService.GetRegionRange(scopeID, xmin, xmax, ymin, ymax);
-        }
-
-        public List<GridRegion> GetDefaultRegions(UUID scopeID)
-        {
-            return m_GridService.GetDefaultRegions(scopeID);
-        }
-
-        public List<GridRegion> GetDefaultHypergridRegions(UUID scopeID)
-        {
-            return m_GridService.GetDefaultHypergridRegions(scopeID);
-        }
-
-        public List<GridRegion> GetFallbackRegions(UUID scopeID, int x, int y)
-        {
-            return m_GridService.GetFallbackRegions(scopeID, x, y);
-        }
-
-        public List<GridRegion> GetHyperlinks(UUID scopeID)
-        {
-            return m_GridService.GetHyperlinks(scopeID);
-        }
-
-        public int GetRegionFlags(UUID scopeID, UUID regionID)
-        {
-            return m_GridService.GetRegionFlags(scopeID, regionID);
-        }
-
-        public Dictionary<string, object> GetExtraFeatures()
-        {
-            return m_GridService.GetExtraFeatures();
-        }
-
-        #endregion
-
-    }
-}

OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RemoteGridServiceConnector.cs → OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RegionGridServiceConnector.cs

@@ -28,14 +28,12 @@
 using log4net;
 using Mono.Addins;
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
 using Nini.Config;
 using OpenMetaverse;
 
 using OpenSim.Framework;
-using OpenSim.Services.Connectors;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Server.Base;
@@ -44,30 +42,24 @@ using GridRegion = OpenSim.Services.Interfaces.GridRegion;
 
 namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 {
-    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "RemoteGridServicesConnector")]
-    public class RemoteGridServicesConnector : ISharedRegionModule, IGridService
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "RegionGridServicesConnector")]
+    public class RegionGridServicesConnector : ISharedRegionModule, IGridService
     {
-        private static readonly ILog m_log =
-                LogManager.GetLogger(
-                MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private bool m_Enabled = false;
         private GridInfo m_ThisGridInfo;
-        //private string m_ThisGatekeeperURI = string.Empty;
-        //private string m_ThisGatekeeperHost = string.Empty;
-        //private string m_ThisGatekeeperIP = string.Empty;
-        //private HashSet<string> m_ThisGateKeeperAlias = new HashSet<string>();
 
         private IGridService m_LocalGridService;
         private IGridService m_RemoteGridService;
 
         private RegionInfoCache m_RegionInfoCache;
 
-        public RemoteGridServicesConnector()
+        public RegionGridServicesConnector()
         {
         }
 
-        public RemoteGridServicesConnector(IConfigSource source)
+        public RegionGridServicesConnector(IConfigSource source)
         {
             InitialiseServices(source);
         }
@@ -81,7 +73,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 
         public string Name
         {
-            get { return "RemoteGridServicesConnector"; }
+            get { return "RegionGridServicesConnector"; }
         }
 
         public void Initialise(IConfigSource source)
@@ -89,13 +81,16 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             IConfig moduleConfig = source.Configs["Modules"];
             if (moduleConfig != null)
             {
-                string name = moduleConfig.GetString("GridServices", "");
+                string name = moduleConfig.GetString("GridServices", string.Empty);
                 if (name == Name)
                 {
                     if(InitialiseServices(source))
                     {
                         m_Enabled = true;
-                        m_log.Info("[REMOTE GRID CONNECTOR]: Remote grid enabled");
+                        if(m_RemoteGridService == null)
+                            m_log.Info("[REGION GRID CONNECTOR]: enabled in Standalone mode");
+                        else
+                            m_log.Info("[REGION GRID CONNECTOR]: enabled in Grid mode");
                     }
                 }
             }
@@ -106,37 +101,43 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             IConfig gridConfig = source.Configs["GridService"];
             if (gridConfig == null)
             {
-                m_log.Error("[REMOTE GRID CONNECTOR]: GridService missing from OpenSim.ini");
+                m_log.Error("[REGION GRID CONNECTOR]: GridService missing from OpenSim.ini");
                 return false;
             }
 
-            string networkConnector = gridConfig.GetString("NetworkConnector", string.Empty);
-            if (networkConnector == string.Empty)
+            string serviceDll = gridConfig.GetString("LocalServiceModule", string.Empty);
+            if (string.IsNullOrWhiteSpace(serviceDll))
             {
-                m_log.Error("[REMOTE GRID CONNECTOR]: Please specify a network connector under [GridService]");
+                m_log.Error("[REGION GRID CONNECTOR]: No LocalServiceModule named in section GridService");
                 return false;
             }
+            
+            object[] args = new object[] { source };
+            m_LocalGridService = ServerUtils.LoadPlugin<IGridService>(serviceDll, args);
 
-            Object[] args = new Object[] { source };
-            m_RemoteGridService = ServerUtils.LoadPlugin<IGridService>(networkConnector, args);
-
-            m_LocalGridService = new LocalGridServicesConnector(source, m_RegionInfoCache);
             if (m_LocalGridService == null)
             {
-                m_log.Error("[REMOTE GRID CONNECTOR]: failed to load local connector");
+                m_log.Error("[REGION GRID CONNECTOR]: failed to load LocalServiceModule");
                 return false;
             }
 
-            if(m_RegionInfoCache == null)
-                m_RegionInfoCache = new RegionInfoCache();
+            string networkConnector = gridConfig.GetString("NetworkConnector", string.Empty);
+            if (!string.IsNullOrWhiteSpace(networkConnector))
+            {
+                m_RemoteGridService = ServerUtils.LoadPlugin<IGridService>(networkConnector, args);
+                if (m_RemoteGridService == null)
+                {
+                    m_log.Error("[REGION GRID CONNECTOR]: failed to load NetworkConnector");
+                    return false;
+                }
+            }
 
+            m_RegionInfoCache = new RegionInfoCache();
             return true;
         }
 
         public void PostInitialise()
         {
-            if (m_Enabled)
-                ((ISharedRegionModule)m_LocalGridService).PostInitialise();
         }
 
         public void Close()
@@ -151,14 +152,21 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
                 scene.RegisterModuleInterface<IGridService>(this);
                 if(m_ThisGridInfo == null)
                     m_ThisGridInfo = scene.SceneGridInfo;
-                ((ISharedRegionModule)m_LocalGridService).AddRegion(scene);
+
+                GridRegion r = new GridRegion(scene.RegionInfo);
+                m_RegionInfoCache.CacheLocal(r);
+
+                scene.EventManager.OnRegionUp += OnRegionUp;
             }
         }
 
         public void RemoveRegion(Scene scene)
         {
             if (m_Enabled)
-                ((ISharedRegionModule)m_LocalGridService).RemoveRegion(scene);
+            {
+                m_RegionInfoCache.Remove(scene.RegionInfo.ScopeID, scene.RegionInfo.RegionHandle);
+                scene.EventManager.OnRegionUp -= OnRegionUp;
+            }
         }
 
         public void RegionLoaded(Scene scene)
@@ -167,13 +175,21 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 
         #endregion
 
+        private void OnRegionUp(GridRegion region)
+        {
+            // This shouldn't happen
+            if (region == null || !m_Enabled)
+                return;
+
+            m_RegionInfoCache.CacheNearNeighbour(region.ScopeID, region);
+        }
+
         #region IGridService
 
         public string RegisterRegion(UUID scopeID, GridRegion regionInfo)
         {
             string msg = m_LocalGridService.RegisterRegion(scopeID, regionInfo);
-
-            if (msg == String.Empty)
+            if (msg == string.Empty && m_RemoteGridService != null)
                 return m_RemoteGridService.RegisterRegion(scopeID, regionInfo);
 
             return msg;
@@ -181,7 +197,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 
         public bool DeregisterRegion(UUID regionID)
         {
-            if (m_LocalGridService.DeregisterRegion(regionID))
+            if (m_LocalGridService.DeregisterRegion(regionID) && m_RemoteGridService != null)
                 return m_RemoteGridService.DeregisterRegion(regionID);
 
             return false;
@@ -189,28 +205,51 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 
         public List<GridRegion> GetNeighbours(UUID scopeID, UUID regionID)
         {
+            if(m_RemoteGridService == null)
+                return m_LocalGridService.GetNeighbours(scopeID, regionID);
             return m_RemoteGridService.GetNeighbours(scopeID, regionID);
         }
 
         public GridRegion GetRegionByUUID(UUID scopeID, UUID regionID)
         {
-            GridRegion rinfo = m_LocalGridService.GetRegionByUUID(scopeID, regionID);
+            bool inCache = false;
+            GridRegion rinfo = m_RegionInfoCache.Get(scopeID, regionID, out inCache);
+            if (inCache)
+                return rinfo;
+
+            rinfo = m_LocalGridService.GetRegionByUUID(scopeID, regionID);
             if (rinfo != null)
+            {
+                m_RegionInfoCache.Cache(scopeID, rinfo);
                 return rinfo;
+            }
 
-            rinfo = m_RemoteGridService.GetRegionByUUID(scopeID, regionID);
-            m_RegionInfoCache.Cache(scopeID, rinfo);
+            if(m_RemoteGridService != null)
+            {
+                rinfo = m_RemoteGridService.GetRegionByUUID(scopeID, regionID);
+                m_RegionInfoCache.Cache(scopeID, rinfo);
+            }
             return rinfo;
         }
 
         public GridRegion GetRegionByHandle(UUID scopeID, ulong regionhandle)
         {
-            GridRegion rinfo = m_LocalGridService.GetRegionByHandle(scopeID, regionhandle);
-            if (rinfo != null)
+            bool inCache = false;
+            GridRegion rinfo = m_RegionInfoCache.Get(scopeID, regionhandle, out inCache);
+            if (inCache)
                 return rinfo;
 
-            rinfo = m_RemoteGridService.GetRegionByHandle(scopeID, regionhandle);
-            m_RegionInfoCache.Cache(scopeID, rinfo);
+            rinfo = m_LocalGridService.GetRegionByHandle(scopeID, regionhandle);
+            if (rinfo != null)
+            {
+                m_RegionInfoCache.Cache(scopeID, rinfo);
+                return rinfo;
+            }
+            if(m_RemoteGridService != null)
+            {
+                rinfo = m_RemoteGridService.GetRegionByHandle(scopeID, regionhandle);
+                m_RegionInfoCache.Cache(scopeID, rinfo);
+            }
             return rinfo;
         }
 
@@ -220,39 +259,58 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
         // The coordinates are world coords (meters), NOT region units.
         public GridRegion GetRegionByPosition(UUID scopeID, int x, int y)
         {
-            GridRegion rinfo = m_LocalGridService.GetRegionByPosition(scopeID, x, y);
+            bool inCache = false;
+            GridRegion rinfo = m_RegionInfoCache.Get(scopeID, (uint)x, (uint)y, out inCache);
+            if (inCache)
+                return rinfo;
+
+            rinfo = m_LocalGridService.GetRegionByPosition(scopeID, x, y);
             if (rinfo != null)
             {
-//                m_log.DebugFormat("[REMOTE GRID CONNECTOR]: GetRegionByPosition. Found region {0} on local. Pos=<{1},{2}>, RegionHandle={3}",
-//                    rinfo.RegionName, rinfo.RegionCoordX, rinfo.RegionCoordY, rinfo.RegionHandle);
+                // m_log.DebugFormat("[REMOTE GRID CONNECTOR]: GetRegionByPosition. Found region {0} on local. Pos=<{1},{2}>, RegionHandle={3}",
+                //    rinfo.RegionName, rinfo.RegionCoordX, rinfo.RegionCoordY, rinfo.RegionHandle);
+                m_RegionInfoCache.Cache(scopeID, rinfo);
                 return rinfo;
             }
 
-            rinfo = m_RemoteGridService.GetRegionByPosition(scopeID, x, y);
-
-            if (rinfo == null)
+            if(m_RemoteGridService != null)
             {
-//                uint regionX = Util.WorldToRegionLoc((uint)x);
-//                uint regionY = Util.WorldToRegionLoc((uint)y);
-//                m_log.WarnFormat("[REMOTE GRID CONNECTOR]: Requested region {0}-{1} not found", regionX, regionY);
-            }
-            else
-            {
-                m_RegionInfoCache.Cache(scopeID, rinfo);
+                rinfo = m_RemoteGridService.GetRegionByPosition(scopeID, x, y);
+                if (rinfo == null)
+                {
+    //                uint regionX = Util.WorldToRegionLoc((uint)x);
+    //                uint regionY = Util.WorldToRegionLoc((uint)y);
+    //                m_log.WarnFormat("[REMOTE GRID CONNECTOR]: Requested region {0}-{1} not found", regionX, regionY);
+                }
+                else
+                {
+                    m_RegionInfoCache.Cache(scopeID, rinfo);
 
-//                m_log.DebugFormat("[REMOTE GRID CONNECTOR]: GetRegionByPosition. Added region {0} to the cache. Pos=<{1},{2}>, RegionHandle={3}",
-//                    rinfo.RegionName, rinfo.RegionCoordX, rinfo.RegionCoordY, rinfo.RegionHandle);
+    //                m_log.DebugFormat("[REMOTE GRID CONNECTOR]: GetRegionByPosition. Added region {0} to the cache. Pos=<{1},{2}>, RegionHandle={3}",
+    //                    rinfo.RegionName, rinfo.RegionCoordX, rinfo.RegionCoordY, rinfo.RegionHandle);
+                }
             }
             return rinfo;
         }
 
         public GridRegion GetRegionByName(UUID scopeID, string name)
         {
-            GridRegion rinfo = m_LocalGridService.GetRegionByName(scopeID, name);
+            bool inCache = false;
+            GridRegion rinfo = m_RegionInfoCache.Get(scopeID, name, out inCache);
+            if (inCache)
+                return rinfo;
+
+            rinfo = m_LocalGridService.GetRegionByName(scopeID, name);
             if (rinfo != null)
+            {
+                m_RegionInfoCache.Cache(scopeID, rinfo);
                 return rinfo;
+            }
+
+            if(m_RemoteGridService == null)
+                return null;
 
-              // HG urls should not get here, strip them
+            // HG urls should not get here, strip them
             // side effect is that local regions with same name as HG may also be found
             // this mb good or bad
             string regionName = name;
@@ -268,7 +326,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
                     return rinfo; // not local grid
             }
 
-            if (String.IsNullOrEmpty(regionName))
+            if (string.IsNullOrEmpty(regionName))
             {
                 rinfo = m_RemoteGridService.GetDefaultRegions(UUID.Zero)[0];
                 if (rinfo == null)
@@ -287,6 +345,8 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             List<GridRegion> rinfo = m_LocalGridService.GetRegionsByName(scopeID, name, maxNumber);
             //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Local GetRegionsByName {0} found {1} regions", name, rinfo.Count);
 
+            if(m_RemoteGridService == null)
+                return rinfo;
             // HG urls should not get here, strip them
             // side effect is that local regions with same name as HG may also be found
             // this mb good or bad
@@ -304,7 +364,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             }
 
             List<GridRegion> grinfo = null;
-            if (String.IsNullOrEmpty(regionName))
+            if (string.IsNullOrEmpty(regionName))
             {
                 List<GridRegion> grinfos = m_RemoteGridService.GetDefaultRegions(scopeID);
                 if (grinfos == null || grinfos.Count == 0)
@@ -337,19 +397,21 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
         {
             List<GridRegion> rinfo = m_LocalGridService.GetRegionRange(scopeID, xmin, xmax, ymin, ymax);
             //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Local GetRegionRange {0} found {1} regions", name, rinfo.Count);
-            List<GridRegion> grinfo = m_RemoteGridService.GetRegionRange(scopeID, xmin, xmax, ymin, ymax);
-
-            if (grinfo != null)
+            if(m_RemoteGridService != null)
             {
-                //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Remote GetRegionRange {0} found {1} regions", name, grinfo.Count);
-                foreach (GridRegion r in grinfo)
+                List<GridRegion> grinfo = m_RemoteGridService.GetRegionRange(scopeID, xmin, xmax, ymin, ymax);
+
+                if (grinfo != null)
                 {
-                    m_RegionInfoCache.Cache(r);
-                    if (rinfo.Find(delegate(GridRegion gr) { return gr.RegionID == r.RegionID; }) == null)
-                        rinfo.Add(r);
+                    //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Remote GetRegionRange {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;
         }
 
@@ -357,19 +419,21 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
         {
             List<GridRegion> rinfo = m_LocalGridService.GetDefaultRegions(scopeID);
             //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Local GetDefaultRegions {0} found {1} regions", name, rinfo.Count);
-            List<GridRegion> grinfo = m_RemoteGridService.GetDefaultRegions(scopeID);
-
-            if (grinfo != null)
+            if(m_RemoteGridService != null)
             {
-                //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Remote GetDefaultRegions {0} found {1} regions", name, grinfo.Count);
-                foreach (GridRegion r in grinfo)
+                List<GridRegion> grinfo = m_RemoteGridService.GetDefaultRegions(scopeID);
+
+                if (grinfo != null)
                 {
-                    m_RegionInfoCache.Cache(r);
-                    if (rinfo.Find(delegate(GridRegion gr) { return gr.RegionID == r.RegionID; }) == null)
-                        rinfo.Add(r);
+                    //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Remote GetDefaultRegions {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;
         }
 
@@ -377,19 +441,21 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
         {
             List<GridRegion> rinfo = m_LocalGridService.GetDefaultHypergridRegions(scopeID);
             //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Local GetDefaultHypergridRegions {0} found {1} regions", name, rinfo.Count);
-            List<GridRegion> grinfo = m_RemoteGridService.GetDefaultHypergridRegions(scopeID);
-
-            if (grinfo != null)
+            if(m_RemoteGridService != null)
             {
-                //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Remote GetDefaultHypergridRegions {0} found {1} regions", name, grinfo.Count);
-                foreach (GridRegion r in grinfo)
+                List<GridRegion> grinfo = m_RemoteGridService.GetDefaultHypergridRegions(scopeID);
+
+                if (grinfo != null)
                 {
-                    m_RegionInfoCache.Cache(r);
-                    if (rinfo.Find(delegate(GridRegion gr) { return gr.RegionID == r.RegionID; }) == null)
-                        rinfo.Add(r);
+                    //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Remote GetDefaultHypergridRegions {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;
         }
 
@@ -397,19 +463,21 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
         {
             List<GridRegion> rinfo = m_LocalGridService.GetFallbackRegions(scopeID, x, y);
             //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Local GetFallbackRegions {0} found {1} regions", name, rinfo.Count);
-            List<GridRegion> grinfo = m_RemoteGridService.GetFallbackRegions(scopeID, x, y);
-
-            if (grinfo != null)
+            if(m_RemoteGridService != null)
             {
-                //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Remote GetFallbackRegions {0} found {1} regions", name, grinfo.Count);
-                foreach (GridRegion r in grinfo)
+                List<GridRegion> grinfo = m_RemoteGridService.GetFallbackRegions(scopeID, x, y);
+
+                if (grinfo != null)
                 {
-                    m_RegionInfoCache.Cache(r);
-                    if (rinfo.Find(delegate(GridRegion gr) { return gr.RegionID == r.RegionID; }) == null)
-                        rinfo.Add(r);
+                    //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Remote GetFallbackRegions {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;
         }
 
@@ -417,26 +485,28 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
         {
             List<GridRegion> rinfo = m_LocalGridService.GetHyperlinks(scopeID);
             //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Local GetHyperlinks {0} found {1} regions", name, rinfo.Count);
-            List<GridRegion> grinfo = m_RemoteGridService.GetHyperlinks(scopeID);
-
-            if (grinfo != null)
+            if(m_RemoteGridService != null)
             {
-                //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Remote GetHyperlinks {0} found {1} regions", name, grinfo.Count);
-                foreach (GridRegion r in grinfo)
+                List<GridRegion> grinfo = m_RemoteGridService.GetHyperlinks(scopeID);
+
+                if (grinfo != null)
                 {
-                    m_RegionInfoCache.Cache(r);
-                    if (rinfo.Find(delegate(GridRegion gr) { return gr.RegionID == r.RegionID; }) == null)
-                        rinfo.Add(r);
+                    //m_log.DebugFormat("[REMOTE GRID CONNECTOR]: Remote GetHyperlinks {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 int GetRegionFlags(UUID scopeID, UUID regionID)
         {
             int flags = m_LocalGridService.GetRegionFlags(scopeID, regionID);
-            if (flags == -1)
+            if (flags == -1 && m_RemoteGridService != null)
                 flags = m_RemoteGridService.GetRegionFlags(scopeID, regionID);
 
             return flags;
@@ -447,7 +517,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             Dictionary<string, object> extraFeatures;
             extraFeatures = m_LocalGridService.GetExtraFeatures();
 
-            if (extraFeatures.Count == 0)
+            if (extraFeatures.Count == 0 && m_RemoteGridService != null)
                 extraFeatures = m_RemoteGridService.GetExtraFeatures();
 
             return extraFeatures;

OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/Tests/GridConnectorsTests.cs

@@ -46,7 +46,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid.Tests
     [TestFixture]
     public class GridConnectorsTests : OpenSimTestCase
     {
-        LocalGridServicesConnector m_LocalConnector;
+        RegionGridServicesConnector m_LocalConnector;
 
         [SetUp]
         public override void SetUp()
@@ -56,7 +56,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid.Tests
             IConfigSource config = new IniConfigSource();
             config.AddConfig("Modules");
             config.AddConfig("GridService");
-            config.Configs["Modules"].Set("GridServices", "LocalGridServicesConnector");
+            config.Configs["Modules"].Set("GridServices", "RegionGridServicesConnector");
             config.Configs["GridService"].Set("LocalServiceModule", "OpenSim.Services.GridService.dll:GridService");
             config.Configs["GridService"].Set("StorageProvider", "OpenSim.Data.Null.dll");
             config.Configs["GridService"].Set("Region_Test_Region_1", "DefaultRegion");
@@ -64,7 +64,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid.Tests
             config.Configs["GridService"].Set("Region_Test_Region_3", "FallbackRegion");
             config.Configs["GridService"].Set("Region_Other_Region_4", "FallbackRegion");
 
-            m_LocalConnector = new LocalGridServicesConnector(config, null);
+            m_LocalConnector = new RegionGridServicesConnector(config);
         }
 
         /// <summary>

OpenSim/Region/Framework/Scenes/Tests/SharedRegionModuleTests.cs

@@ -66,12 +66,12 @@ namespace OpenSim.Region.Framework.Scenes.Tests
 
             // For grid servic
             configSource.AddConfig("GridService");
-            configSource.Configs["Modules"].Set("GridServices", "LocalGridServicesConnector");
+            configSource.Configs["Modules"].Set("GridServices", "RegionGridServicesConnector");
             configSource.Configs["GridService"].Set("StorageProvider", "OpenSim.Data.Null.dll:NullRegionData");
             configSource.Configs["GridService"].Set("LocalServiceModule", "OpenSim.Services.GridService.dll:GridService");
             configSource.Configs["GridService"].Set("ConnectionString", "!static");
 
-            LocalGridServicesConnector gridService = new LocalGridServicesConnector();
+            RegionGridServicesConnector gridService = new RegionGridServicesConnector();
 //
             OpenSim sim = new OpenSim(configSource);
 

OpenSim/Tests/Common/Helpers/SceneHelpers.cs

@@ -67,7 +67,7 @@ namespace OpenSim.Tests.Common
         private LocalAssetServicesConnector m_assetService;
         private LocalAuthenticationServicesConnector m_authenticationService;
         private LocalInventoryServicesConnector m_inventoryService;
-        private LocalGridServicesConnector m_gridService;
+        private RegionGridServicesConnector m_gridService;
         private LocalUserAccountServicesConnector m_userAccountService;
         private LocalPresenceServicesConnector m_presenceService;
 
@@ -266,17 +266,17 @@ namespace OpenSim.Tests.Common
             return inventoryService;
         }
 
-        private static LocalGridServicesConnector StartGridService()
+        private static RegionGridServicesConnector StartGridService()
         {
             IConfigSource config = new IniConfigSource();
             config.AddConfig("Modules");
             config.AddConfig("GridService");
-            config.Configs["Modules"].Set("GridServices", "LocalGridServicesConnector");
+            config.Configs["Modules"].Set("GridServices", "RegionGridServicesConnector");
             config.Configs["GridService"].Set("StorageProvider", "OpenSim.Data.Null.dll:NullRegionData");
             config.Configs["GridService"].Set("LocalServiceModule", "OpenSim.Services.GridService.dll:GridService");
             config.Configs["GridService"].Set("ConnectionString", "!static");
 
-            LocalGridServicesConnector gridService = new LocalGridServicesConnector();
+            RegionGridServicesConnector gridService = new RegionGridServicesConnector();
             gridService.Initialise(config);
 
             return gridService;

bin/config-include/Grid.ini

@@ -10,7 +10,7 @@
 [Modules]
     AssetServices           = "RegionAssetConnector"
     InventoryServices       = "RemoteXInventoryServicesConnector"
-    GridServices            = "RemoteGridServicesConnector"
+    GridServices            = "RegionGridServicesConnector"
     AvatarServices          = "RemoteAvatarServicesConnector"
     NeighbourServices       = "NeighbourServicesOutConnector"
     AuthenticationServices  = "RemoteAuthenticationServicesConnector"

bin/config-include/GridHypergrid.ini

@@ -13,7 +13,7 @@
 [Modules]
     AssetServices           = "RegionAssetConnector"
     InventoryServices       = "HGInventoryBroker"
-    GridServices            = "RemoteGridServicesConnector"
+    GridServices            = "RegionGridServicesConnector"
     AvatarServices          = "RemoteAvatarServicesConnector"
     NeighbourServices       = "NeighbourServicesOutConnector"
     AuthenticationServices  = "RemoteAuthenticationServicesConnector"
@@ -54,8 +54,6 @@
     LocalGridInventoryService = "OpenSim.Region.CoreModules.dll:RemoteXInventoryServicesConnector"
 
 [GridService]
-    ; RemoteGridServicesConnector instantiates a LocalGridServicesConnector,
-    ; which in turn uses this
     LocalServiceModule = "OpenSim.Services.GridService.dll:GridService"
     StorageProvider = "OpenSim.Data.Null.dll:NullRegionData"
 

bin/config-include/Standalone.ini

@@ -10,7 +10,7 @@
     NeighbourServices       = "NeighbourServicesOutConnector"
     AuthenticationServices  = "LocalAuthenticationServicesConnector"
     AuthorizationServices   = "LocalAuthorizationServicesConnector"
-    GridServices            = "LocalGridServicesConnector"
+    GridServices            = "RegionGridServicesConnector"
     PresenceServices        = "LocalPresenceServicesConnector"
     UserProfilesServices    = "LocalUserProfilesServicesConnector"
     UserAccountServices     = "LocalUserAccountServicesConnector"

bin/config-include/StandaloneHypergrid.ini

@@ -13,7 +13,7 @@
     NeighbourServices       = "NeighbourServicesOutConnector"
     AuthenticationServices  = "LocalAuthenticationServicesConnector"
     AuthorizationServices   = "LocalAuthorizationServicesConnector"
-    GridServices            = "LocalGridServicesConnector"
+    GridServices            = "RegionGridServicesConnector"
     PresenceServices        = "LocalPresenceServicesConnector"
     UserAccountServices     = "LocalUserAccountServicesConnector"
     AgentPreferencesServices= "LocalAgentPreferencesServicesConnector"
@@ -73,7 +73,6 @@
     LocalServiceModule = "OpenSim.Services.AuthenticationService.dll:PasswordAuthenticationService"
 
 [GridService]
-    ; LocalGridServicesConnector needs this
     LocalServiceModule = "OpenSim.Services.GridService.dll:GridService"
     Realm = "regions"
     StorageProvider = "OpenSim.Data.Null.dll"