Merge branch 'master' of melanie@opensimulator.org:/var/git/opensim

11 files changed, 557 insertions, 103 deletions

diff --git a/OpenSim/Region/Application/OpenSimBase.cs b/OpenSim/Region/Application/OpenSimBase.cs
index e950613..6405811 100644
--- a/OpenSim/Region/Application/OpenSimBase.cs
+++ b/OpenSim/Region/Application/OpenSimBase.cs
@@ -793,66 +793,115 @@ namespace OpenSim
         }
         
         /// <summary>
-        /// Load the estate information for the provided RegionInfo object.
+        /// Create an estate with an initial region.
         /// </summary>
+        /// <remarks>
+        /// This method doesn't allow an estate to be created with the same name as existing estates.
+        /// </remarks>
         /// <param name="regInfo"></param>
-        public void PopulateRegionEstateInfo(RegionInfo regInfo)
+        /// <param name="existingName">A list of estate names that already exist.</param>
+        /// <returns>true if the estate was created, false otherwise</returns>
+        public bool CreateEstate(RegionInfo regInfo, List<string> existingNames)
         {
-            IEstateDataService estateDataService = EstateDataService;
+            // Create a new estate
+            regInfo.EstateSettings = EstateDataService.LoadEstateSettings(regInfo.RegionID, true);
+            string newName = MainConsole.Instance.CmdPrompt("New estate name", regInfo.EstateSettings.EstateName);
 
-            if (estateDataService != null)
+            if (existingNames.Contains(newName))
             {
-                regInfo.EstateSettings = estateDataService.LoadEstateSettings(regInfo.RegionID, false);
+                MainConsole.Instance.OutputFormat("An estate named {0} already exists.  Please try again.", newName);
+                return false;
             }
+            
+            regInfo.EstateSettings.EstateName = newName;
+            
+            // FIXME: Later on, the scene constructor will reload the estate settings no matter what.
+            // Therefore, we need to do an initial save here otherwise the new estate name will be reset
+            // back to the default.  The reloading of estate settings by scene could be eliminated if it
+            // knows that the passed in settings in RegionInfo are already valid.  Also, it might be 
+            // possible to eliminate some additional later saves made by callers of this method.
+            regInfo.EstateSettings.Save();   
+            
+            return true;
+        }
+        
+        /// <summary>
+        /// Load the estate information for the provided RegionInfo object.
+        /// </summary>
+        /// <param name="regInfo"></param>
+        public void PopulateRegionEstateInfo(RegionInfo regInfo)
+        {
+            if (EstateDataService != null)
+                regInfo.EstateSettings = EstateDataService.LoadEstateSettings(regInfo.RegionID, false);
 
             if (regInfo.EstateSettings.EstateID == 0) // No record at all
             {
-                MainConsole.Instance.Output("Your region is not part of an estate.");
+                MainConsole.Instance.OutputFormat("Region {0} is not part of an estate.", regInfo.RegionName);
+                
+                List<EstateSettings> estates = EstateDataService.LoadEstateSettingsAll();                
+                List<string> estateNames = new List<string>();
+                foreach (EstateSettings estate in estates)
+                    estateNames.Add(estate.EstateName);                
+                
                 while (true)
                 {
-                    string response = MainConsole.Instance.CmdPrompt("Do you wish to join an existing estate?", "no", new List<string>() { "yes", "no" });
-                    if (response == "no")
-                    {
-                        // Create a new estate
-                        regInfo.EstateSettings = estateDataService.LoadEstateSettings(regInfo.RegionID, true);
-
-                        regInfo.EstateSettings.EstateName = MainConsole.Instance.CmdPrompt("New estate name", regInfo.EstateSettings.EstateName);
+                    if (estates.Count == 0)
+                    {                        
+                        MainConsole.Instance.Output("No existing estates found.  You must create a new one.");
                         
-                        // FIXME: Later on, the scene constructor will reload the estate settings no matter what.
-                        // Therefore, we need to do an initial save here otherwise the new estate name will be reset
-                        // back to the default.  The reloading of estate settings by scene could be eliminated if it
-                        // knows that the passed in settings in RegionInfo are already valid.  Also, it might be 
-                        // possible to eliminate some additional later saves made by callers of this method.
-                        regInfo.EstateSettings.Save();
-                        break;
+                        if (CreateEstate(regInfo, estateNames))
+                            break;                        
+                        else
+                            continue;
                     }
                     else
                     {
-                        response = MainConsole.Instance.CmdPrompt("Estate name to join", "None");
-                        if (response == "None")
-                            continue;
-
-                        List<int> estateIDs = estateDataService.GetEstates(response);
-                        if (estateIDs.Count < 1)
+                        string response 
+                            = MainConsole.Instance.CmdPrompt(
+                                string.Format(
+                                    "Do you wish to join region {0} to an existing estate (yes/no)?", regInfo.RegionName), 
+                                    "no", 
+                                    new List<string>() { "yes", "no" });
+                        
+                        if (response == "no")
                         {
-                            MainConsole.Instance.Output("The name you have entered matches no known estate. Please try again");
-                            continue;
+                            if (CreateEstate(regInfo, estateNames))                            
+                                break;
+                            else
+                                continue;
+                        }
+                        else
+                        {                           
+                            response 
+                                = MainConsole.Instance.CmdPrompt(
+                                    string.Format(
+                                        "Name of estate to join.  Existing estate names are ({0})", string.Join(", ", estateNames.ToArray())), 
+                                    "None");
+                            
+                            if (response == "None")
+                                continue;
+    
+                            List<int> estateIDs = EstateDataService.GetEstates(response);
+                            if (estateIDs.Count < 1)
+                            {
+                                MainConsole.Instance.Output("The name you have entered matches no known estate. Please try again.");
+                                continue;
+                            }
+    
+                            int estateID = estateIDs[0];
+    
+                            regInfo.EstateSettings = EstateDataService.LoadEstateSettings(estateID);
+    
+                            if (EstateDataService.LinkRegion(regInfo.RegionID, estateID))
+                                break;
+    
+                            MainConsole.Instance.Output("Joining the estate failed. Please try again.");
                         }
-
-                        int estateID = estateIDs[0];
-
-                        regInfo.EstateSettings = estateDataService.LoadEstateSettings(estateID);
-
-                        if (estateDataService.LinkRegion(regInfo.RegionID, estateID))
-                            break;
-
-                        MainConsole.Instance.Output("Joining the estate failed. Please try again.");
                     }
                 }
             }
         }
     }
-
     
     public class OpenSimConfigSource
     {
diff --git a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
index 98ba8c3..d0727d9 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
@@ -72,6 +72,7 @@ namespace OpenSim.Region.CoreModules.World.Land
         protected Commander m_commander = new Commander("land");
         
         protected IUserManagement m_userManager;
+        protected IPrimCountModule m_primCountModule;
 
         // Minimum for parcels to work is 64m even if we don't actually use them.
         #pragma warning disable 0429
@@ -147,6 +148,7 @@ namespace OpenSim.Region.CoreModules.World.Land
         public void RegionLoaded(Scene scene)
         {
              m_userManager = m_scene.RequestModuleInterface<IUserManagement>();         
+             m_primCountModule = m_scene.RequestModuleInterface<IPrimCountModule>();
         }
 
         public void RemoveRegion(Scene scene)
@@ -306,10 +308,14 @@ namespace OpenSim.Region.CoreModules.World.Land
         /// <returns>The parcel created.</returns>
         protected ILandObject CreateDefaultParcel()
         {
-            ILandObject fullSimParcel = new LandObject(UUID.Zero, false, m_scene);
+//            m_log.DebugFormat(
+//                "[LAND MANAGEMENT MODULE]: Creating default parcel for region {0}", m_scene.RegionInfo.RegionName);
+            
+            ILandObject fullSimParcel = new LandObject(UUID.Zero, false, m_scene);                                                
             fullSimParcel.SetLandBitmap(fullSimParcel.GetSquareLandBitmap(0, 0, (int)Constants.RegionSize, (int)Constants.RegionSize));
             fullSimParcel.LandData.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
             fullSimParcel.LandData.ClaimDate = Util.UnixTimeSinceEpoch();
+            
             return AddLandObject(fullSimParcel);            
         }
 
@@ -579,7 +585,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             }
             else
             {
-                m_log.WarnFormat("[LAND]: Invalid local land ID {0}", landLocalID);
+                m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Invalid local land ID {0}", landLocalID);
             }
         }
 
@@ -590,6 +596,11 @@ namespace OpenSim.Region.CoreModules.World.Land
         public ILandObject AddLandObject(ILandObject land)
         {
             ILandObject new_land = land.Copy();
+            
+            // Only now can we add the prim counts to the land object - we rely on the global ID which is generated
+            // as a random UUID inside LandData initialization
+            if (m_primCountModule != null)
+                new_land.PrimCounts = m_primCountModule.GetPrimCounts(new_land.LandData.GlobalID);            
 
             lock (m_landList)
             {
@@ -630,7 +641,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                     {
                         if (m_landIDList[x, y] == local_id)
                         {
-                            m_log.WarnFormat("[LAND]: Not removing land object {0}; still being used at {1}, {2}",
+                            m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Not removing land object {0}; still being used at {1}, {2}",
                                              local_id, x, y);
                             return;
                             //throw new Exception("Could not remove land object. Still being used at " + x + ", " + y);
@@ -851,6 +862,10 @@ namespace OpenSim.Region.CoreModules.World.Land
 
         public void EventManagerOnParcelPrimCountUpdate()
         {
+//            m_log.DebugFormat(
+//                "[LAND MANAGEMENT MODULE]: Triggered EventManagerOnParcelPrimCountUpdate() for {0}", 
+//                m_scene.RegionInfo.RegionName);
+            
             ResetAllLandPrimCounts();
             EntityBase[] entities = m_scene.Entities.GetEntities();
             foreach (EntityBase obj in entities)
@@ -1198,7 +1213,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             }
             else
             {
-                m_log.WarnFormat("[PARCEL]: Invalid land object {0} passed for parcel object owner request", local_id);
+                m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Invalid land object {0} passed for parcel object owner request", local_id);
             }
         }
 
@@ -1361,7 +1376,7 @@ namespace OpenSim.Region.CoreModules.World.Land
         {
             ILandObject new_land = new LandObject(data.OwnerID, data.IsGroupOwned, m_scene);
             new_land.LandData = data.Copy();
-            new_land.SetLandBitmapFromByteArray();
+            new_land.SetLandBitmapFromByteArray();            
             AddLandObject(new_land);
         }
 
@@ -1426,7 +1441,7 @@ namespace OpenSim.Region.CoreModules.World.Land
         {
             IClientAPI client;
             if (! m_scene.TryGetClient(agentID, out client)) {
-                m_log.WarnFormat("[LAND] unable to retrieve IClientAPI for {0}", agentID.ToString());
+                m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Unable to retrieve IClientAPI for {0}", agentID);
                 return LLSDHelpers.SerialiseLLSDReply(new LLSDEmpty());
             }
 
@@ -1475,7 +1490,7 @@ namespace OpenSim.Region.CoreModules.World.Land
             }
             else
             {
-                m_log.WarnFormat("[LAND] unable to find parcelID {0}", parcelID);
+                m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Unable to find parcelID {0}", parcelID);
             }
             return LLSDHelpers.SerialiseLLSDReply(new LLSDEmpty());
         }
@@ -1533,17 +1548,17 @@ namespace OpenSim.Region.CoreModules.World.Land
             }
             catch (LLSD.LLSDParseException e)
             {
-                m_log.ErrorFormat("[LAND] Fetch error: {0}", e.Message);
-                m_log.ErrorFormat("[LAND] ... in request {0}", request);
+                m_log.ErrorFormat("[LAND MANAGEMENT MODULE]: Fetch error: {0}", e.Message);
+                m_log.ErrorFormat("[LAND MANAGEMENT MODULE]: ... in request {0}", request);
             }
-            catch(InvalidCastException)
+            catch (InvalidCastException)
             {
-                m_log.ErrorFormat("[LAND] Wrong type in request {0}", request);
+                m_log.ErrorFormat("[LAND MANAGEMENT MODULE]: Wrong type in request {0}", request);
             }
 
             LLSDRemoteParcelResponse response = new LLSDRemoteParcelResponse();
             response.parcel_id = parcelID;
-            m_log.DebugFormat("[LAND] got parcelID {0}", parcelID);
+            m_log.DebugFormat("[LAND MANAGEMENT MODULE]: Got parcelID {0}", parcelID);
 
             return LLSDHelpers.SerialiseLLSDReply(response);
         }
@@ -1564,7 +1579,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                         ExtendedLandData extLandData = new ExtendedLandData();
                         Util.ParseFakeParcelID(parcel, out extLandData.RegionHandle,
                                                out extLandData.X, out extLandData.Y);
-                        m_log.DebugFormat("[LAND] got parcelinfo request for regionHandle {0}, x/y {1}/{2}",
+                        m_log.DebugFormat("[LAND MANAGEMENT MODULE]: Got parcelinfo request for regionHandle {0}, x/y {1}/{2}",
                                           extLandData.RegionHandle, extLandData.X, extLandData.Y);
 
                         // for this region or for somewhere else?
@@ -1605,7 +1620,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                     info = m_scene.GridService.GetRegionByPosition(m_scene.RegionInfo.ScopeID, (int)x, (int)y);
                 }
                 // we need to transfer the fake parcelID, not the one in landData, so the viewer can match it to the landmark.
-                m_log.DebugFormat("[LAND] got parcelinfo for parcel {0} in region {1}; sending...",
+                m_log.DebugFormat("[LAND MANAGEMENT MODULE]: got parcelinfo for parcel {0} in region {1}; sending...",
                                   data.LandData.Name, data.RegionHandle);
                 // HACK for now
                 RegionInfo r = new RegionInfo();
@@ -1616,7 +1631,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                 remoteClient.SendParcelInfo(r, data.LandData, parcelID, data.X, data.Y);
             }
             else
-                m_log.Debug("[LAND] got no parcelinfo; not sending");
+                m_log.Debug("[LAND MANAGEMENT MODULE]: got no parcelinfo; not sending");
         }
 
         public void setParcelOtherCleanTime(IClientAPI remoteClient, int localID, int otherCleanTime)
diff --git a/OpenSim/Region/CoreModules/World/Land/LandObject.cs b/OpenSim/Region/CoreModules/World/Land/LandObject.cs
index 46c15ed..749bb3d 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandObject.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandObject.cs
@@ -51,7 +51,7 @@ namespace OpenSim.Region.CoreModules.World.Land
 
         private int m_lastSeqId = 0;
 
-        protected LandData m_landData = new LandData();
+        protected LandData m_landData = new LandData();        
         protected Scene m_scene;
         protected List<SceneObjectGroup> primsOverMe = new List<SceneObjectGroup>();
         protected Dictionary<uint, UUID> m_listTransactions = new Dictionary<uint, UUID>();
@@ -79,6 +79,8 @@ namespace OpenSim.Region.CoreModules.World.Land
 
             set { m_landData = value; }
         }
+        
+        public IPrimCounts PrimCounts { get; set; }
 
         public UUID RegionUUID
         {
diff --git a/OpenSim/Region/CoreModules/World/Land/PrimCountModule.cs b/OpenSim/Region/CoreModules/World/Land/PrimCountModule.cs
index 34ef67f..9fd347e 100644
--- a/OpenSim/Region/CoreModules/World/Land/PrimCountModule.cs
+++ b/OpenSim/Region/CoreModules/World/Land/PrimCountModule.cs
@@ -51,8 +51,8 @@ namespace OpenSim.Region.CoreModules.World.Land
 
     public class PrimCountModule : IPrimCountModule, INonSharedRegionModule
     {
-        private static readonly ILog m_log =
-            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private Scene m_Scene;
         private Dictionary<UUID, PrimCounts> m_PrimCounts =
@@ -64,10 +64,16 @@ namespace OpenSim.Region.CoreModules.World.Land
         private Dictionary<UUID, ParcelCounts> m_ParcelCounts =
                 new Dictionary<UUID, ParcelCounts>();
 
-        // For now, a simple simwide taint to get this up. Later parcel based
-        // taint to allow recounting a parcel if only ownership has changed
-        // without recounting the whole sim.
+
+        /// <value>
+        /// For now, a simple simwide taint to get this up. Later parcel based
+        /// taint to allow recounting a parcel if only ownership has changed
+        /// without recounting the whole sim.
+        /// 
+        /// We start out tainted so that the first get call resets the various prim counts.
+        /// <value>
         private bool m_Tainted = true;
+        
         private Object m_TaintLock = new Object();
 
         public Type ReplaceableInterface
@@ -82,9 +88,10 @@ namespace OpenSim.Region.CoreModules.World.Land
         public void AddRegion(Scene scene)
         {
             m_Scene = scene;
+            
+            m_Scene.RegisterModuleInterface<IPrimCountModule>(this);
 
-            m_Scene.EventManager.OnParcelPrimCountAdd +=
-                    OnParcelPrimCountAdd;
+            m_Scene.EventManager.OnObjectAddedToScene += OnParcelPrimCountAdd;            
             m_Scene.EventManager.OnObjectBeingRemovedFromScene +=
                     OnObjectBeingRemovedFromScene;
             m_Scene.EventManager.OnParcelPrimCountTainted +=
@@ -156,6 +163,8 @@ namespace OpenSim.Region.CoreModules.World.Land
         // NOTE: Call under Taint Lock
         private void AddObject(SceneObjectGroup obj)
         {
+//            m_log.DebugFormat("[PRIM COUNT MODULE]: Adding object {0} to prim count", obj.Name);
+            
             if (obj.IsAttachment)
                 return;
             if (((obj.RootPart.Flags & PrimFlags.TemporaryOnRez) != 0))
@@ -164,6 +173,10 @@ namespace OpenSim.Region.CoreModules.World.Land
             Vector3 pos = obj.AbsolutePosition;
             ILandObject landObject = m_Scene.LandChannel.GetLandObject(pos.X, pos.Y);
             LandData landData = landObject.LandData;
+            
+//            m_log.DebugFormat(
+//                "[PRIM COUNT MODULE]: Object {0} is owned by {1} over land owned by {2}", 
+//                obj.Name, obj.OwnerID, landData.OwnerID);
 
             ParcelCounts parcelCounts;
             if (m_ParcelCounts.TryGetValue(landData.GlobalID, out parcelCounts))
@@ -218,8 +231,16 @@ namespace OpenSim.Region.CoreModules.World.Land
             return primCounts;
         }
 
+        
+        /// <summary>
+        /// Get the number of prims on the parcel that are owned by the parcel owner.
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <returns></returns>
         public int GetOwnerCount(UUID parcelID)
         {
+//            m_log.DebugFormat("[PRIM COUNT MODULE]: GetOwnerCount for {0}", parcelID);
+            
             lock (m_TaintLock)
             {
                 if (m_Tainted)
@@ -232,6 +253,11 @@ namespace OpenSim.Region.CoreModules.World.Land
             return 0;
         }
 
+        /// <summary>
+        /// Get the number of prims on the parcel that have been set to the group that owns the parcel.
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <returns></returns>        
         public int GetGroupCount(UUID parcelID)
         {
             lock (m_TaintLock)
@@ -246,6 +272,11 @@ namespace OpenSim.Region.CoreModules.World.Land
             return 0;
         }
 
+        /// <summary>
+        /// Get the number of prims on the parcel that are not owned by the parcel owner or set to the parcel group.
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <returns></returns>                
         public int GetOthersCount(UUID parcelID)
         {
             lock (m_TaintLock)
@@ -260,6 +291,11 @@ namespace OpenSim.Region.CoreModules.World.Land
             return 0;
         }
 
+        /// <summary>
+        /// Get the number of prims that are in the entire simulator for the owner of this parcel.
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <returns></returns>              
         public int GetSimulatorCount(UUID parcelID)
         {
             lock (m_TaintLock)
@@ -278,6 +314,12 @@ namespace OpenSim.Region.CoreModules.World.Land
             return 0;
         }
 
+        /// <summary>
+        /// Get the number of prims that a particular user owns on this parcel.
+        /// </summary>
+        /// <param name="parcelID"></param>
+        /// <param name="userID"></param>
+        /// <returns></returns>          
         public int GetUserCount(UUID parcelID, UUID userID)
         {
             lock (m_TaintLock)
@@ -299,18 +341,21 @@ namespace OpenSim.Region.CoreModules.World.Land
         // NOTE: This method MUST be called while holding the taint lock!
         private void Recount()
         {
+//            m_log.DebugFormat("[PRIM COUNT MODULE]: Recounting prims on {0}", m_Scene.RegionInfo.RegionName);
+            
             m_OwnerMap.Clear();
             m_SimwideCounts.Clear();
             m_ParcelCounts.Clear();
 
             List<ILandObject> land = m_Scene.LandChannel.AllParcels();
-
+            
             foreach (ILandObject l in land)
             {
                 LandData landData = l.LandData;
 
                 m_OwnerMap[landData.GlobalID] = landData.OwnerID;
                 m_SimwideCounts[landData.OwnerID] = 0;
+//                m_log.DebugFormat("[PRIM COUNT MODULE]: Adding parcel count for {0}", landData.GlobalID);
                 m_ParcelCounts[landData.GlobalID] = new ParcelCounts();
             }
 
diff --git a/OpenSim/Region/CoreModules/World/Land/Tests/PrimCountModuleTests.cs b/OpenSim/Region/CoreModules/World/Land/Tests/PrimCountModuleTests.cs
new file mode 100644
index 0000000..c9d393f
--- /dev/null
+++ b/OpenSim/Region/CoreModules/World/Land/Tests/PrimCountModuleTests.cs
@@ -0,0 +1,131 @@
+/*
+ * 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 System;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenMetaverse.Assets;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+using OpenSim.Tests.Common.Mock;
+using OpenSim.Tests.Common.Setup;
+
+namespace OpenSim.Region.CoreModules.World.Land.Tests
+{
+    [TestFixture]
+    public class PrimCountModuleTests
+    {
+        protected UUID m_userId = new UUID("00000000-0000-0000-0000-100000000000");
+        protected UUID m_dummyUserId = new UUID("99999999-9999-9999-9999-999999999999");        
+        protected TestScene m_scene;
+        protected PrimCountModule m_pcm;
+        protected ILandObject m_lo;
+            
+        [SetUp]
+        public void SetUp()
+        {
+            m_pcm = new PrimCountModule();
+            LandManagementModule lmm = new LandManagementModule();
+            m_scene = SceneSetupHelpers.SetupScene();            
+            SceneSetupHelpers.SetupSceneModules(m_scene, lmm, m_pcm);             
+                        
+            ILandObject lo = new LandObject(m_userId, false, m_scene);
+            lo.SetLandBitmap(lo.GetSquareLandBitmap(0, 0, (int)Constants.RegionSize, (int)Constants.RegionSize));
+            m_lo = lmm.AddLandObject(lo);
+            //scene.loadAllLandObjectsFromStorage(scene.RegionInfo.originRegionID);            
+        } 
+        
+        /// <summary>
+        /// Test count after a parcel owner owned object is added.
+        /// </summary>
+        [Test]
+        public void TestAddOwnerObject()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();                                  
+                  
+            IPrimCounts pc = m_lo.PrimCounts;
+            
+            Assert.That(pc.Owner, Is.EqualTo(0));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(0));
+            Assert.That(pc.Users[m_dummyUserId], Is.EqualTo(0));
+            Assert.That(pc.Simulator, Is.EqualTo(0));
+            
+            SceneObjectGroup sog = SceneSetupHelpers.CreateSceneObject(3, m_userId, 0x01);             
+            m_scene.AddNewSceneObject(sog, false);
+            
+            Assert.That(pc.Owner, Is.EqualTo(3));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(3));
+            Assert.That(pc.Users[m_dummyUserId], Is.EqualTo(0));
+            Assert.That(pc.Simulator, Is.EqualTo(3));            
+            
+            // Add a second object and retest
+            SceneObjectGroup sog2 = SceneSetupHelpers.CreateSceneObject(2, m_userId, 0x10);             
+            m_scene.AddNewSceneObject(sog2, false);   
+            
+            Assert.That(pc.Owner, Is.EqualTo(5));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(5));
+            Assert.That(pc.Users[m_dummyUserId], Is.EqualTo(0));
+            Assert.That(pc.Simulator, Is.EqualTo(5));              
+        }
+        
+        /// <summary>
+        /// Test count after a parcel owner owned object is removed.
+        /// </summary>
+        [Test]
+        public void TestRemoveOwnerObject()
+        {
+            TestHelper.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+            
+            IPrimCounts pc = m_lo.PrimCounts;
+            
+            m_scene.AddNewSceneObject(SceneSetupHelpers.CreateSceneObject(1, m_userId, 0x1), false);
+            SceneObjectGroup sogToDelete = SceneSetupHelpers.CreateSceneObject(3, m_userId, 0x10);
+            m_scene.AddNewSceneObject(sogToDelete, false);            
+            m_scene.DeleteSceneObject(sogToDelete, false);
+            
+            Assert.That(pc.Owner, Is.EqualTo(1));
+            Assert.That(pc.Group, Is.EqualTo(0));
+            Assert.That(pc.Others, Is.EqualTo(0));
+            Assert.That(pc.Users[m_userId], Is.EqualTo(1));
+            Assert.That(pc.Users[m_dummyUserId], Is.EqualTo(0));
+            Assert.That(pc.Simulator, Is.EqualTo(1));            
+        }        
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/IEstateDataService.cs b/OpenSim/Region/Framework/Interfaces/IEstateDataService.cs
index 95c9659..38c10a6 100644
--- a/OpenSim/Region/Framework/Interfaces/IEstateDataService.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEstateDataService.cs
@@ -34,12 +34,68 @@ namespace OpenSim.Region.Framework.Interfaces
 {
     public interface IEstateDataService
     {
+        /// <summary>
+        /// Load estate settings for a region.
+        /// </summary>
+        /// <param name="regionID"></param>
+        /// <param name="create">If true, then an estate is created if one is not found.</param>
+        /// <returns></returns>        
         EstateSettings LoadEstateSettings(UUID regionID, bool create);
+        
+        /// <summary>
+        /// Load estate settings for an estate ID.
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns></returns>        
         EstateSettings LoadEstateSettings(int estateID);
+        
+        /// <summary>
+        /// Load/Get all estate settings.
+        /// </summary>
+        /// <returns>An empty list if no estates were found.</returns>
+        List<EstateSettings> LoadEstateSettingsAll();
+        
+        /// <summary>
+        /// Store estate settings.
+        /// </summary>
+        /// <remarks>
+        /// This is also called by EstateSettings.Save()</remarks>
+        /// <param name="es"></param>        
         void StoreEstateSettings(EstateSettings es);
+        
+        /// <summary>
+        /// Get estate IDs.
+        /// </summary>
+        /// <param name="search">Name of estate to search for.  This is the exact name, no parttern matching is done.</param>
+        /// <returns></returns>        
         List<int> GetEstates(string search);
+        
+        /// <summary>
+        /// Get the IDs of all estates.
+        /// </summary>
+        /// <returns>An empty list if no estates were found.</returns>
+        List<int> GetEstatesAll();
+            
+        /// <summary>
+        /// Link a region to an estate.
+        /// </summary>
+        /// <param name="regionID"></param>
+        /// <param name="estateID"></param>
+        /// <returns>true if the link succeeded, false otherwise</returns>        
         bool LinkRegion(UUID regionID, int estateID);
+        
+        /// <summary>
+        /// Get the UUIDs of all the regions in an estate.
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns></returns>        
         List<UUID> GetRegions(int estateID);
+        
+        /// <summary>
+        /// Delete an estate
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns>true if the delete succeeded, false otherwise</returns>        
         bool DeleteEstate(int estateID);
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/IEstateDataStore.cs b/OpenSim/Region/Framework/Interfaces/IEstateDataStore.cs
index 87c7a05..c82661d 100644
--- a/OpenSim/Region/Framework/Interfaces/IEstateDataStore.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEstateDataStore.cs
@@ -33,14 +33,74 @@ namespace OpenSim.Region.Framework.Interfaces
 {
     public interface IEstateDataStore
     {
+        /// <summary>
+        /// Initialise the data store.
+        /// </summary>
+        /// <param name="connectstring"></param>
         void Initialise(string connectstring);
 
+        /// <summary>
+        /// Load estate settings for a region.
+        /// </summary>
+        /// <param name="regionID"></param>
+        /// <param name="create">If true, then an estate is created if one is not found.</param>
+        /// <returns></returns>
         EstateSettings LoadEstateSettings(UUID regionID, bool create);
+        
+        /// <summary>
+        /// Load estate settings for an estate ID.
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns></returns>
         EstateSettings LoadEstateSettings(int estateID);
+        
+        /// <summary>
+        /// Load/Get all estate settings.
+        /// </summary>
+        /// <returns>An empty list if no estates were found.</returns>
+        List<EstateSettings> LoadEstateSettingsAll();
+        
+        /// <summary>
+        /// Store estate settings.
+        /// </summary>
+        /// <remarks>
+        /// This is also called by EstateSettings.Save()</remarks>
+        /// <param name="es"></param>
         void StoreEstateSettings(EstateSettings es);
+        
+        /// <summary>
+        /// Get estate IDs.
+        /// </summary>
+        /// <param name="search">Name of estate to search for.  This is the exact name, no parttern matching is done.</param>
+        /// <returns></returns>
         List<int> GetEstates(string search);
+        
+        /// <summary>
+        /// Get the IDs of all estates.
+        /// </summary>
+        /// <returns>An empty list if no estates were found.</returns>
+        List<int> GetEstatesAll();
+        
+        /// <summary>
+        /// Link a region to an estate.
+        /// </summary>
+        /// <param name="regionID"></param>
+        /// <param name="estateID"></param>
+        /// <returns>true if the link succeeded, false otherwise</returns>
         bool LinkRegion(UUID regionID, int estateID);
+        
+        /// <summary>
+        /// Get the UUIDs of all the regions in an estate.
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns></returns>
         List<UUID> GetRegions(int estateID);
+        
+        /// <summary>
+        /// Delete an estate
+        /// </summary>
+        /// <param name="estateID"></param>
+        /// <returns>true if the delete succeeded, false otherwise</returns>
         bool DeleteEstate(int estateID);
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/ILandObject.cs b/OpenSim/Region/Framework/Interfaces/ILandObject.cs
index eeb9d3a..9c0abde 100644
--- a/OpenSim/Region/Framework/Interfaces/ILandObject.cs
+++ b/OpenSim/Region/Framework/Interfaces/ILandObject.cs
@@ -46,6 +46,11 @@ namespace OpenSim.Region.Framework.Interfaces
         UUID RegionUUID { get; }
         
         /// <summary>
+        /// Prim counts for this land object.
+        /// </summary>
+        IPrimCounts PrimCounts { get; set; }
+        
+        /// <summary>
         /// The start point for the land object.  This is the western-most point as one scans land working from 
         /// north to south.
         /// </summary>
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index c321a15..fd62535 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -242,7 +242,15 @@ namespace OpenSim.Region.Framework.Scenes
         public delegate void GetScriptRunning(IClientAPI controllingClient, UUID objectID, UUID itemID);
 
         public event EstateToolsSunUpdate OnEstateToolsSunUpdate;
+        
+        /// <summary>
+        /// Triggered when an object is added to the scene.
+        /// </summary>
+        public event Action<SceneObjectGroup> OnObjectAddedToScene;
 
+        /// <summary>
+        /// Triggered when an object is removed from the scene.
+        /// </summary>
         public delegate void ObjectBeingRemovedFromScene(SceneObjectGroup obj);
         public event ObjectBeingRemovedFromScene OnObjectBeingRemovedFromScene;
 
@@ -345,6 +353,7 @@ namespace OpenSim.Region.Framework.Scenes
         public delegate void Attach(uint localID, UUID itemID, UUID avatarID);
         public event Attach OnAttach;
         
+        
         /// <summary>
         /// Called immediately after an object is loaded from storage.
         /// </summary>
@@ -800,6 +809,27 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public void TriggerObjectAddedToScene(SceneObjectGroup obj)
+        {
+            Action<SceneObjectGroup> handler = OnObjectAddedToScene;
+            if (handler != null)
+            {
+                foreach (Action<SceneObjectGroup> d in handler.GetInvocationList())
+                {
+                    try
+                    {
+                        d(obj);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerObjectAddedToScene failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        }        
+        
         public void TriggerObjectBeingRemovedFromScene(SceneObjectGroup obj)
         {
             ObjectBeingRemovedFromScene handlerObjectBeingRemovedFromScene = OnObjectBeingRemovedFromScene;
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 1a6a70b..d407a6f 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -1109,7 +1109,7 @@ namespace OpenSim.Region.Framework.Scenes
             //
             while (m_regInfo.EstateSettings.EstateOwner == UUID.Zero && MainConsole.Instance != null)
             {
-                MainConsole.Instance.Output("The current estate has no owner set.");
+                MainConsole.Instance.OutputFormat("Estate {0} has no owner set.", m_regInfo.EstateSettings.EstateName);
                 List<char> excluded = new List<char>(new char[1]{' '});
                 string first = MainConsole.Instance.CmdPrompt("Estate owner first name", "Test", excluded);
                 string last = MainConsole.Instance.CmdPrompt("Estate owner last name", "User", excluded);
@@ -1956,8 +1956,14 @@ namespace OpenSim.Region.Framework.Scenes
         /// If false, it is left to the caller to schedule the update
         /// </param>
         public bool AddNewSceneObject(SceneObjectGroup sceneObject, bool attachToBackup, bool sendClientUpdates)
-        {
-            return m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, sendClientUpdates);
+        {           
+            if (m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, sendClientUpdates))
+            {
+                EventManager.TriggerObjectAddedToScene(sceneObject);
+                return true;       
+            }
+            
+            return false;
         }
         
         /// <summary>
@@ -1974,7 +1980,13 @@ namespace OpenSim.Region.Framework.Scenes
         public bool AddNewSceneObject(
             SceneObjectGroup sceneObject, bool attachToBackup, Vector3 pos, Quaternion rot, Vector3 vel)
         {
-            return m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, pos, rot, vel);
+            if (m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, pos, rot, vel))
+            {            
+                EventManager.TriggerObjectAddedToScene(sceneObject);
+                return true;
+            }
+
+            return false;
         }
 
         /// <summary>
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index 734ba22..60855b2 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -88,9 +88,21 @@ namespace OpenSim.Region.Framework.Scenes
         protected internal object m_syncRoot = new object();
 
         protected internal PhysicsScene _PhyScene;
-
-        protected internal Dictionary<uint, SceneObjectGroup> SceneObjectGroupsByLocalID = new Dictionary<uint, SceneObjectGroup>();
+        
+        /// <summary>
+        /// Index the SceneObjectGroup for each part by the root part's UUID.
+        /// </summary>
         protected internal Dictionary<UUID, SceneObjectGroup> SceneObjectGroupsByFullID = new Dictionary<UUID, SceneObjectGroup>();
+        
+        /// <summary>
+        /// Index the SceneObjectGroup for each part by that part's UUID.
+        /// </summary>
+        protected internal Dictionary<UUID, SceneObjectGroup> SceneObjectGroupsByFullPartID = new Dictionary<UUID, SceneObjectGroup>();
+        
+        /// <summary>
+        /// Index the SceneObjectGroup for each part by that part's local ID.
+        /// </summary>
+        protected internal Dictionary<uint, SceneObjectGroup> SceneObjectGroupsByLocalPartID = new Dictionary<uint, SceneObjectGroup>();        
 
         private Object m_updateLock = new Object();
 
@@ -133,8 +145,10 @@ namespace OpenSim.Region.Framework.Scenes
 
             lock (SceneObjectGroupsByFullID)
                 SceneObjectGroupsByFullID.Clear();
-            lock (SceneObjectGroupsByLocalID)
-                SceneObjectGroupsByLocalID.Clear();
+            lock (SceneObjectGroupsByFullPartID)
+                SceneObjectGroupsByFullPartID.Clear();
+            lock (SceneObjectGroupsByLocalPartID)
+                SceneObjectGroupsByLocalPartID.Clear();
 
             Entities.Clear();
         }
@@ -349,6 +363,10 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (Entities.ContainsKey(sceneObject.UUID))
                 return false;
+            
+//            m_log.DebugFormat(
+//                "[SCENEGRAPH]: Adding scene object {0} {1}, with {2} parts on {3}", 
+//                sceneObject.Name, sceneObject.UUID, sceneObject.Parts.Length, m_parentScene.RegionInfo.RegionName);
 
             SceneObjectPart[] children = sceneObject.Parts;
 
@@ -385,17 +403,20 @@ namespace OpenSim.Region.Framework.Scenes
                 OnObjectCreate(sceneObject);
 
             lock (SceneObjectGroupsByFullID)
-            {
                 SceneObjectGroupsByFullID[sceneObject.UUID] = sceneObject;
+            
+            lock (SceneObjectGroupsByFullPartID)
+            {
+                SceneObjectGroupsByFullPartID[sceneObject.UUID] = sceneObject;
                 foreach (SceneObjectPart part in children)
-                    SceneObjectGroupsByFullID[part.UUID] = sceneObject;
+                    SceneObjectGroupsByFullPartID[part.UUID] = sceneObject;
             }
 
-            lock (SceneObjectGroupsByLocalID)
+            lock (SceneObjectGroupsByLocalPartID)
             {
-                SceneObjectGroupsByLocalID[sceneObject.LocalId] = sceneObject;
+                SceneObjectGroupsByLocalPartID[sceneObject.LocalId] = sceneObject;
                 foreach (SceneObjectPart part in children)
-                    SceneObjectGroupsByLocalID[part.LocalId] = sceneObject;
+                    SceneObjectGroupsByLocalPartID[part.LocalId] = sceneObject;
             }
 
             return true;
@@ -426,21 +447,24 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (OnObjectRemove != null)
                 OnObjectRemove(Entities[uuid]);
-
+            
             lock (SceneObjectGroupsByFullID)
+                SceneObjectGroupsByFullID.Remove(grp.UUID);
+
+            lock (SceneObjectGroupsByFullPartID)
             {
                 SceneObjectPart[] parts = grp.Parts;
                 for (int i = 0; i < parts.Length; i++)
-                    SceneObjectGroupsByFullID.Remove(parts[i].UUID);
-                SceneObjectGroupsByFullID.Remove(grp.RootPart.UUID);
+                    SceneObjectGroupsByFullPartID.Remove(parts[i].UUID);
+                SceneObjectGroupsByFullPartID.Remove(grp.RootPart.UUID);
             }
 
-            lock (SceneObjectGroupsByLocalID)
+            lock (SceneObjectGroupsByLocalPartID)
             {
                 SceneObjectPart[] parts = grp.Parts;
                 for (int i = 0; i < parts.Length; i++)
-                    SceneObjectGroupsByLocalID.Remove(parts[i].LocalId);
-                SceneObjectGroupsByLocalID.Remove(grp.RootPart.LocalId);
+                    SceneObjectGroupsByLocalPartID.Remove(parts[i].LocalId);
+                SceneObjectGroupsByLocalPartID.Remove(grp.RootPart.LocalId);
             }
 
             return Entities.Remove(uuid);
@@ -627,7 +651,7 @@ namespace OpenSim.Region.Framework.Scenes
             if (!Entities.Remove(agentID))
             {
                 m_log.WarnFormat(
-                    "[SCENE]: Tried to remove non-existent scene presence with agent ID {0} from scene Entities list",
+                    "[SCENEGRAPH]: Tried to remove non-existent scene presence with agent ID {0} from scene Entities list",
                     agentID);
             }
 
@@ -650,7 +674,7 @@ namespace OpenSim.Region.Framework.Scenes
                 }
                 else
                 {
-                    m_log.WarnFormat("[SCENE]: Tried to remove non-existent scene presence with agent ID {0} from scene ScenePresences list", agentID);
+                    m_log.WarnFormat("[SCENEGRAPH]: Tried to remove non-existent scene presence with agent ID {0} from scene ScenePresences list", agentID);
                 }
             }
         }
@@ -854,14 +878,14 @@ namespace OpenSim.Region.Framework.Scenes
 
             //m_log.DebugFormat("Entered GetGroupByPrim with localID {0}", localID);
             SceneObjectGroup sog;
-            lock (SceneObjectGroupsByLocalID)
-                SceneObjectGroupsByLocalID.TryGetValue(localID, out sog);
+            lock (SceneObjectGroupsByLocalPartID)
+                SceneObjectGroupsByLocalPartID.TryGetValue(localID, out sog);
 
             if (sog != null)
             {
                 if (sog.HasChildPrim(localID))
                     return sog;
-                SceneObjectGroupsByLocalID.Remove(localID);
+                SceneObjectGroupsByLocalPartID.Remove(localID);
             }
 
             EntityBase[] entityList = GetEntities();
@@ -873,8 +897,8 @@ namespace OpenSim.Region.Framework.Scenes
                     sog = (SceneObjectGroup)ent;
                     if (sog.HasChildPrim(localID))
                     {
-                        lock (SceneObjectGroupsByLocalID)
-                            SceneObjectGroupsByLocalID[localID] = sog;
+                        lock (SceneObjectGroupsByLocalPartID)
+                            SceneObjectGroupsByLocalPartID[localID] = sog;
                         return sog;
                     }
                 }
@@ -891,16 +915,16 @@ namespace OpenSim.Region.Framework.Scenes
         private SceneObjectGroup GetGroupByPrim(UUID fullID)
         {
             SceneObjectGroup sog;
-            lock (SceneObjectGroupsByFullID)
-                SceneObjectGroupsByFullID.TryGetValue(fullID, out sog);
+            lock (SceneObjectGroupsByFullPartID)
+                SceneObjectGroupsByFullPartID.TryGetValue(fullID, out sog);
 
             if (sog != null)
             {
                 if (sog.ContainsPart(fullID))
                     return sog;
 
-                lock (SceneObjectGroupsByFullID)
-                    SceneObjectGroupsByFullID.Remove(fullID);
+                lock (SceneObjectGroupsByFullPartID)
+                    SceneObjectGroupsByFullPartID.Remove(fullID);
             }
 
             EntityBase[] entityList = GetEntities();
@@ -911,8 +935,8 @@ namespace OpenSim.Region.Framework.Scenes
                     sog = (SceneObjectGroup)ent;
                     if (sog.HasChildPrim(fullID))
                     {
-                        lock (SceneObjectGroupsByFullID)
-                            SceneObjectGroupsByFullID[fullID] = sog;
+                        lock (SceneObjectGroupsByFullPartID)
+                            SceneObjectGroupsByFullPartID[fullID] = sog;
                         return sog;
                     }
                 }
@@ -1064,11 +1088,12 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Performs action on all scene object groups.
+        /// Performs action once on all scene object groups.
         /// </summary>
         /// <param name="action"></param>
         protected internal void ForEachSOG(Action<SceneObjectGroup> action)
         {
+            // FIXME: Need to lock here, really.
             List<SceneObjectGroup> objlist = new List<SceneObjectGroup>(SceneObjectGroupsByFullID.Values);
             foreach (SceneObjectGroup obj in objlist)
             {
@@ -1079,11 +1104,11 @@ namespace OpenSim.Region.Framework.Scenes
                 catch (Exception e)
                 {
                     // Catch it and move on. This includes situations where splist has inconsistent info
-                    m_log.WarnFormat("[SCENE]: Problem processing action in ForEachSOG: ", e.ToString());
+                    m_log.WarnFormat(
+                        "[SCENEGRAPH]: Problem processing action in ForEachSOG: {0} {1}", e.Message, e.StackTrace);
                 }
             }
         }
-
         
         /// <summary>
         /// Performs action on all scene presences. This can ultimately run the actions in parallel but
@@ -1103,8 +1128,8 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                     catch (Exception e)
                     {
-                        m_log.Info("[BUG] in " + m_parentScene.RegionInfo.RegionName + ": " + e.ToString());
-                        m_log.Info("[BUG] Stack Trace: " + e.StackTrace);
+                        m_log.Info("[SCENEGRAPH]: Error in " + m_parentScene.RegionInfo.RegionName + ": " + e.ToString());
+                        m_log.Info("[SCENEGRAPH]: Stack Trace: " + e.StackTrace);
                     }
                 });
             Parallel.ForEach<ScenePresence>(GetScenePresences(), protectedAction);
@@ -1119,7 +1144,7 @@ namespace OpenSim.Region.Framework.Scenes
                 }
                 catch (Exception e)
                 {
-                    m_log.Info("[BUG] in " + m_parentScene.RegionInfo.RegionName + ": " + e.ToString());
+                    m_log.Error("[SCENEGRAPH]: Error in " + m_parentScene.RegionInfo.RegionName + ": " + e.ToString());
                 }
             }
         }
@@ -1777,7 +1802,10 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="rot"></param>
         public SceneObjectGroup DuplicateObject(uint originalPrimID, Vector3 offset, uint flags, UUID AgentID, UUID GroupID, Quaternion rot)
         {
-            //m_log.DebugFormat("[SCENE]: Duplication of object {0} at offset {1} requested by agent {2}", originalPrim, offset, AgentID);
+//            m_log.DebugFormat(
+//                "[SCENE]: Duplication of object {0} at offset {1} requested by agent {2}", 
+//                originalPrimID, offset, AgentID);
+            
             SceneObjectGroup original = GetGroupByPrim(originalPrimID);
             if (original != null)
             {
@@ -1808,7 +1836,28 @@ namespace OpenSim.Region.Framework.Scenes
                         copy.RootPart.SalePrice = 10;
                     }
 
+                    // FIXME: This section needs to be refactored so that it just calls AddSceneObject()
                     Entities.Add(copy);
+                    
+                    lock (SceneObjectGroupsByFullID)
+                        SceneObjectGroupsByFullID[copy.UUID] = copy;
+                    
+                    SceneObjectPart[] children = copy.Parts;
+                    
+                    lock (SceneObjectGroupsByFullPartID)
+                    {
+                        SceneObjectGroupsByFullPartID[copy.UUID] = copy;
+                        foreach (SceneObjectPart part in children)
+                            SceneObjectGroupsByFullPartID[part.UUID] = copy;
+                    }
+        
+                    lock (SceneObjectGroupsByLocalPartID)
+                    {
+                        SceneObjectGroupsByLocalPartID[copy.LocalId] = copy;
+                        foreach (SceneObjectPart part in children)
+                            SceneObjectGroupsByLocalPartID[copy.LocalId] = copy;
+                    }   
+                    // PROBABLE END OF FIXME
 
                     // Since we copy from a source group that is in selected
                     // state, but the copy is shown deselected in the viewer,