Merge branch 'master' of /home/opensim/var/repo/opensim

Added "timer_Interval" to the OpenSimDefaults.ini, leaving the default value set to 1200, as the previous default setting. The value represents seconds. To change the default, copy the entry to OpenSim.ini and multiply the number of minutes for the interval by 60.

.gitignore

@@ -26,14 +26,9 @@
 bin/Debug/*.dll
 bin/*.dll.mdb
 bin/*.db
-bin/*.db-journal
 bin/addin-db-*
 bin/*.dll
 bin/OpenSim.vshost.exe.config
-bin/OpenSim.32BitLaunch.vshost.exe.config
-bin/OpenSim.32BitLaunch.log
-UpgradeLog.XML
-_UpgradeReport_Files/
 bin/ScriptEngines/*-*-*-*-*
 bin/ScriptEngines/*.dll
 bin/ScriptEngines/*/*.dll
@@ -46,8 +41,6 @@ bin/Physics*
 bin/Terrain*
 bin/Regions/*
 bin/UserAssets
-bin/assetcache
-bin/maptiles
 bin/estate_settings.xml
 bin/config-include/CenomeCache.ini
 bin/config-include/FlotsamCache.ini

.nant/local.include

@@ -135,25 +135,14 @@
   <delete dir="%temp%"/>
 </target>
 
-<target name="test-stress" depends="build, find-nunit">
+<target name="torture" depends="build, find-nunit">
   <setenv name="MONO_THREADS_PER_CPU" value="100" />
 
-  <exec program="${nunitcmd}" failonerror="true" resultproperty="testresult.opensim.tests.stress">
-    <arg value="./bin/OpenSim.Tests.Stress.dll" />
+  <exec program="${nunitcmd}" failonerror="true" resultproperty="testresult.opensim.tests.torture">
+    <arg value="./bin/OpenSim.Tests.Torture.dll" />
   </exec>
 
-  <fail message="Failures reported in stress tests." unless="${int::parse(testresult.opensim.tests.stress)==0}" /> 
-  <delete dir="%temp%"/>
-</target>
-
-<target name="test-perf" depends="build, find-nunit">
-  <setenv name="MONO_THREADS_PER_CPU" value="100" />
-
-  <exec program="${nunitcmd}" failonerror="true" resultproperty="testresult.opensim.tests.performance">
-    <arg value="./bin/OpenSim.Tests.Performance.dll" />
-  </exec>
-
-  <fail message="Failures reported in performance tests." unless="${int::parse(testresult.opensim.tests.performance)==0}" /> 
+  <fail message="Failures reported in unit tests." unless="${int::parse(testresult.opensim.tests.torture)==0}" /> 
   <delete dir="%temp%"/>
 </target>
 

CONTRIBUTORS.txt

@@ -91,8 +91,6 @@ what it is today.
 * Fly-Man
 * Flyte Xevious
 * Garmin Kawaguichi
-* Gryc Ueusp
-* Hiro Lecker
 * Imaze Rhiano
 * Intimidated
 * Jeremy Bongio (IBM)

OpenSim/ApplicationPlugins/LoadRegions/LoadRegionsPlugin.cs

@@ -125,7 +125,7 @@ namespace OpenSim.ApplicationPlugins.LoadRegions
                 bool changed = m_openSim.PopulateRegionEstateInfo(regionsToLoad[i]);
                 m_openSim.CreateRegion(regionsToLoad[i], true, out scene);
                 if (changed)
-		  regionsToLoad[i].EstateSettings.Save();
+		            regionsToLoad[i].EstateSettings.Save();
                 
                 if (scene != null)
                 {
@@ -136,7 +136,11 @@ namespace OpenSim.ApplicationPlugins.LoadRegions
                     }
                 }
             }
-
+            
+            //[TODO]: Temporary fix for an issue after the mono-addis upgrade
+            // PostInilise can fire before the region is loaded, so need to
+            // track down the cause of that
+            Thread.Sleep(300);
             m_openSim.ModuleLoader.PostInitialise();
             m_openSim.ModuleLoader.ClearCache();
         }

OpenSim/Capabilities/Handlers/WebFetchInventoryDescendents/WebFetchInvDescHandler.cs

@@ -301,8 +301,7 @@ namespace OpenSim.Capabilities.Handlers
                                         InventoryItemBase linkedItem
                                             = m_InventoryService.GetItem(new InventoryItemBase(link.AssetID));
 
-                                        if (linkedItem != null)
-                                            itemsToReturn.Insert(0, linkedItem);
+                                        itemsToReturn.Insert(0, linkedItem);
                                     }
                                 }
                             }
@@ -394,8 +393,12 @@ namespace OpenSim.Capabilities.Handlers
             llsdFolder.folder_id = invFolder.ID;
             llsdFolder.parent_id = invFolder.ParentID;
             llsdFolder.name = invFolder.Name;
-            llsdFolder.type = invFolder.Type;
-            llsdFolder.preferred_type = -1;
+
+            if (invFolder.Type == (short)AssetType.Unknown || !Enum.IsDefined(typeof(AssetType), (sbyte)invFolder.Type))
+                llsdFolder.type = "-1";
+            else
+                llsdFolder.type = Utils.AssetTypeToString((AssetType)invFolder.Type);
+            llsdFolder.preferred_type = "-1";
 
             return llsdFolder;
         }

OpenSim/Capabilities/LLSDInventoryFolder.cs

@@ -35,7 +35,7 @@ namespace OpenSim.Framework.Capabilities
         public UUID folder_id;
         public UUID parent_id;
         public string name;
-        public int type;
-        public int preferred_type;
+        public string type;
+        public string preferred_type;
     }
 }

OpenSim/Capabilities/LLSDStreamHandler.cs

@@ -66,7 +66,9 @@ namespace OpenSim.Framework.Capabilities
 
             TResponse response = m_method(llsdRequest);
 
-            return Util.UTF8NoBomEncoding.GetBytes(LLSDHelpers.SerialiseLLSDReply(response));
+            Encoding encoding = new UTF8Encoding(false);
+
+            return encoding.GetBytes(LLSDHelpers.SerialiseLLSDReply(response));
         }
     }
 }

OpenSim/ConsoleClient/Requester.cs

@@ -50,7 +50,7 @@ namespace OpenSim.ConsoleClient
 
             request.ContentType = "application/x-www-form-urlencoded";
 
-            byte[] buffer = Encoding.ASCII.GetBytes(data);
+            byte[] buffer = new System.Text.ASCIIEncoding().GetBytes(data);
             int length = (int) buffer.Length;
             request.ContentLength = length;
 

OpenSim/Data/IPresenceData.cs

@@ -49,6 +49,7 @@ namespace OpenSim.Data
         bool Store(PresenceData data);
 
         PresenceData Get(UUID sessionID);
+        PresenceData Verify(UUID s_sessionID);
         void LogoutRegionAgents(UUID regionID);
         bool ReportAgent(UUID sessionID, UUID regionID);
         PresenceData[] Get(string field, string data);

OpenSim/Data/IXInventoryData.cs

@@ -40,11 +40,6 @@ namespace OpenSim.Data
         public UUID folderID;
         public UUID agentID;
         public UUID parentFolderID;
-
-        public XInventoryFolder Clone()
-        {
-            return (XInventoryFolder)MemberwiseClone();
-        }
     }
 
     public class XInventoryItem
@@ -69,11 +64,6 @@ namespace OpenSim.Data
         public UUID avatarID;
         public UUID parentFolderID;
         public int inventoryGroupPermissions;
-
-        public XInventoryItem Clone()
-        {
-            return (XInventoryItem)MemberwiseClone();
-        }
     }
 
     public interface IXInventoryData

OpenSim/Data/MSSQL/MSSQLPresenceData.cs

@@ -61,6 +61,17 @@ namespace OpenSim.Data.MSSQL
             return ret[0];
         }
 
+        public PresenceData Verify(UUID s_sessionID)
+        {
+            PresenceData[] ret = Get("SecureSessionID",
+                    s_sessionID.ToString());
+
+            if (ret.Length == 0)
+                return null;
+
+            return ret[0];
+        }
+
         public void LogoutRegionAgents(UUID regionID)
         {
             using (SqlConnection conn = new SqlConnection(m_ConnectionString))

OpenSim/Data/MSSQL/MSSQLSimulationData.cs

@@ -2202,18 +2202,5 @@ VALUES
                 }
             }
         }
-
-        public void SaveExtra(UUID regionID, string name, string value)
-        {
-        }
-
-        public void RemoveExtra(UUID regionID, string name)
-        {
-        }
-
-        public Dictionary<string, string> GetExtra(UUID regionID)
-        {
-            return null;
-        }
     }
 }

OpenSim/Data/MySQL/MySQLPresenceData.cs

@@ -61,6 +61,17 @@ namespace OpenSim.Data.MySQL
             return ret[0];
         }
 
+        public PresenceData Verify(UUID s_sessionID)
+        {
+            PresenceData[] ret = Get("SecureSessionID",
+                    s_sessionID.ToString());
+
+            if (ret.Length == 0)
+                return null;
+
+            return ret[0];
+        }
+
         public void LogoutRegionAgents(UUID regionID)
         {
             using (MySqlCommand cmd = new MySqlCommand())
@@ -96,4 +107,4 @@ namespace OpenSim.Data.MySQL
             return true;
         }
     }
-}
+}

OpenSim/Data/MySQL/MySQLSimulationData.cs

@@ -719,99 +719,95 @@ namespace OpenSim.Data.MySQL
             RegionLightShareData nWP = new RegionLightShareData();
             nWP.OnSave += StoreRegionWindlightSettings;
 
-            lock (m_dbLock)
+            using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
             {
-                using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
+                dbcon.Open();
+
+                string command = "select * from `regionwindlight` where region_id = ?regionID";
+
+                using (MySqlCommand cmd = new MySqlCommand(command))
                 {
-                    dbcon.Open();
-    
-                    string command = "select * from `regionwindlight` where region_id = ?regionID";
-    
-                    using (MySqlCommand cmd = new MySqlCommand(command))
+                    cmd.Connection = dbcon;
+
+                    cmd.Parameters.AddWithValue("?regionID", regionUUID.ToString());
+
+                    IDataReader result = ExecuteReader(cmd);
+                    if (!result.Read())
                     {
-                        cmd.Connection = dbcon;
-    
-                        cmd.Parameters.AddWithValue("?regionID", regionUUID.ToString());
-    
-                        IDataReader result = ExecuteReader(cmd);
-                        if (!result.Read())
-                        {
-                            //No result, so store our default windlight profile and return it
-                            nWP.regionID = regionUUID;
-                            StoreRegionWindlightSettings(nWP);
-                            return nWP;
-                        }
-                        else
-                        {
-                            nWP.regionID = DBGuid.FromDB(result["region_id"]);
-                            nWP.waterColor.X = Convert.ToSingle(result["water_color_r"]);
-                            nWP.waterColor.Y = Convert.ToSingle(result["water_color_g"]);
-                            nWP.waterColor.Z = Convert.ToSingle(result["water_color_b"]);
-                            nWP.waterFogDensityExponent = Convert.ToSingle(result["water_fog_density_exponent"]);
-                            nWP.underwaterFogModifier = Convert.ToSingle(result["underwater_fog_modifier"]);
-                            nWP.reflectionWaveletScale.X = Convert.ToSingle(result["reflection_wavelet_scale_1"]);
-                            nWP.reflectionWaveletScale.Y = Convert.ToSingle(result["reflection_wavelet_scale_2"]);
-                            nWP.reflectionWaveletScale.Z = Convert.ToSingle(result["reflection_wavelet_scale_3"]);
-                            nWP.fresnelScale = Convert.ToSingle(result["fresnel_scale"]);
-                            nWP.fresnelOffset = Convert.ToSingle(result["fresnel_offset"]);
-                            nWP.refractScaleAbove = Convert.ToSingle(result["refract_scale_above"]);
-                            nWP.refractScaleBelow = Convert.ToSingle(result["refract_scale_below"]);
-                            nWP.blurMultiplier = Convert.ToSingle(result["blur_multiplier"]);
-                            nWP.bigWaveDirection.X = Convert.ToSingle(result["big_wave_direction_x"]);
-                            nWP.bigWaveDirection.Y = Convert.ToSingle(result["big_wave_direction_y"]);
-                            nWP.littleWaveDirection.X = Convert.ToSingle(result["little_wave_direction_x"]);
-                            nWP.littleWaveDirection.Y = Convert.ToSingle(result["little_wave_direction_y"]);
-                            UUID.TryParse(result["normal_map_texture"].ToString(), out nWP.normalMapTexture);
-                            nWP.horizon.X = Convert.ToSingle(result["horizon_r"]);
-                            nWP.horizon.Y = Convert.ToSingle(result["horizon_g"]);
-                            nWP.horizon.Z = Convert.ToSingle(result["horizon_b"]);
-                            nWP.horizon.W = Convert.ToSingle(result["horizon_i"]);
-                            nWP.hazeHorizon = Convert.ToSingle(result["haze_horizon"]);
-                            nWP.blueDensity.X = Convert.ToSingle(result["blue_density_r"]);
-                            nWP.blueDensity.Y = Convert.ToSingle(result["blue_density_g"]);
-                            nWP.blueDensity.Z = Convert.ToSingle(result["blue_density_b"]);
-                            nWP.blueDensity.W = Convert.ToSingle(result["blue_density_i"]);
-                            nWP.hazeDensity = Convert.ToSingle(result["haze_density"]);
-                            nWP.densityMultiplier = Convert.ToSingle(result["density_multiplier"]);
-                            nWP.distanceMultiplier = Convert.ToSingle(result["distance_multiplier"]);
-                            nWP.maxAltitude = Convert.ToUInt16(result["max_altitude"]);
-                            nWP.sunMoonColor.X = Convert.ToSingle(result["sun_moon_color_r"]);
-                            nWP.sunMoonColor.Y = Convert.ToSingle(result["sun_moon_color_g"]);
-                            nWP.sunMoonColor.Z = Convert.ToSingle(result["sun_moon_color_b"]);
-                            nWP.sunMoonColor.W = Convert.ToSingle(result["sun_moon_color_i"]);
-                            nWP.sunMoonPosition = Convert.ToSingle(result["sun_moon_position"]);
-                            nWP.ambient.X = Convert.ToSingle(result["ambient_r"]);
-                            nWP.ambient.Y = Convert.ToSingle(result["ambient_g"]);
-                            nWP.ambient.Z = Convert.ToSingle(result["ambient_b"]);
-                            nWP.ambient.W = Convert.ToSingle(result["ambient_i"]);
-                            nWP.eastAngle = Convert.ToSingle(result["east_angle"]);
-                            nWP.sunGlowFocus = Convert.ToSingle(result["sun_glow_focus"]);
-                            nWP.sunGlowSize = Convert.ToSingle(result["sun_glow_size"]);
-                            nWP.sceneGamma = Convert.ToSingle(result["scene_gamma"]);
-                            nWP.starBrightness = Convert.ToSingle(result["star_brightness"]);
-                            nWP.cloudColor.X = Convert.ToSingle(result["cloud_color_r"]);
-                            nWP.cloudColor.Y = Convert.ToSingle(result["cloud_color_g"]);
-                            nWP.cloudColor.Z = Convert.ToSingle(result["cloud_color_b"]);
-                            nWP.cloudColor.W = Convert.ToSingle(result["cloud_color_i"]);
-                            nWP.cloudXYDensity.X = Convert.ToSingle(result["cloud_x"]);
-                            nWP.cloudXYDensity.Y = Convert.ToSingle(result["cloud_y"]);
-                            nWP.cloudXYDensity.Z = Convert.ToSingle(result["cloud_density"]);
-                            nWP.cloudCoverage = Convert.ToSingle(result["cloud_coverage"]);
-                            nWP.cloudScale = Convert.ToSingle(result["cloud_scale"]);
-                            nWP.cloudDetailXYDensity.X = Convert.ToSingle(result["cloud_detail_x"]);
-                            nWP.cloudDetailXYDensity.Y = Convert.ToSingle(result["cloud_detail_y"]);
-                            nWP.cloudDetailXYDensity.Z = Convert.ToSingle(result["cloud_detail_density"]);
-                            nWP.cloudScrollX = Convert.ToSingle(result["cloud_scroll_x"]);
-                            nWP.cloudScrollXLock = Convert.ToBoolean(result["cloud_scroll_x_lock"]);
-                            nWP.cloudScrollY = Convert.ToSingle(result["cloud_scroll_y"]);
-                            nWP.cloudScrollYLock = Convert.ToBoolean(result["cloud_scroll_y_lock"]);
-                            nWP.drawClassicClouds = Convert.ToBoolean(result["draw_classic_clouds"]);
-                            nWP.valid = true;
-                        }
+                        //No result, so store our default windlight profile and return it
+                        nWP.regionID = regionUUID;
+                        StoreRegionWindlightSettings(nWP);
+                        return nWP;
+                    }
+                    else
+                    {
+                        nWP.regionID = DBGuid.FromDB(result["region_id"]);
+                        nWP.waterColor.X = Convert.ToSingle(result["water_color_r"]);
+                        nWP.waterColor.Y = Convert.ToSingle(result["water_color_g"]);
+                        nWP.waterColor.Z = Convert.ToSingle(result["water_color_b"]);
+                        nWP.waterFogDensityExponent = Convert.ToSingle(result["water_fog_density_exponent"]);
+                        nWP.underwaterFogModifier = Convert.ToSingle(result["underwater_fog_modifier"]);
+                        nWP.reflectionWaveletScale.X = Convert.ToSingle(result["reflection_wavelet_scale_1"]);
+                        nWP.reflectionWaveletScale.Y = Convert.ToSingle(result["reflection_wavelet_scale_2"]);
+                        nWP.reflectionWaveletScale.Z = Convert.ToSingle(result["reflection_wavelet_scale_3"]);
+                        nWP.fresnelScale = Convert.ToSingle(result["fresnel_scale"]);
+                        nWP.fresnelOffset = Convert.ToSingle(result["fresnel_offset"]);
+                        nWP.refractScaleAbove = Convert.ToSingle(result["refract_scale_above"]);
+                        nWP.refractScaleBelow = Convert.ToSingle(result["refract_scale_below"]);
+                        nWP.blurMultiplier = Convert.ToSingle(result["blur_multiplier"]);
+                        nWP.bigWaveDirection.X = Convert.ToSingle(result["big_wave_direction_x"]);
+                        nWP.bigWaveDirection.Y = Convert.ToSingle(result["big_wave_direction_y"]);
+                        nWP.littleWaveDirection.X = Convert.ToSingle(result["little_wave_direction_x"]);
+                        nWP.littleWaveDirection.Y = Convert.ToSingle(result["little_wave_direction_y"]);
+                        UUID.TryParse(result["normal_map_texture"].ToString(), out nWP.normalMapTexture);
+                        nWP.horizon.X = Convert.ToSingle(result["horizon_r"]);
+                        nWP.horizon.Y = Convert.ToSingle(result["horizon_g"]);
+                        nWP.horizon.Z = Convert.ToSingle(result["horizon_b"]);
+                        nWP.horizon.W = Convert.ToSingle(result["horizon_i"]);
+                        nWP.hazeHorizon = Convert.ToSingle(result["haze_horizon"]);
+                        nWP.blueDensity.X = Convert.ToSingle(result["blue_density_r"]);
+                        nWP.blueDensity.Y = Convert.ToSingle(result["blue_density_g"]);
+                        nWP.blueDensity.Z = Convert.ToSingle(result["blue_density_b"]);
+                        nWP.blueDensity.W = Convert.ToSingle(result["blue_density_i"]);
+                        nWP.hazeDensity = Convert.ToSingle(result["haze_density"]);
+                        nWP.densityMultiplier = Convert.ToSingle(result["density_multiplier"]);
+                        nWP.distanceMultiplier = Convert.ToSingle(result["distance_multiplier"]);
+                        nWP.maxAltitude = Convert.ToUInt16(result["max_altitude"]);
+                        nWP.sunMoonColor.X = Convert.ToSingle(result["sun_moon_color_r"]);
+                        nWP.sunMoonColor.Y = Convert.ToSingle(result["sun_moon_color_g"]);
+                        nWP.sunMoonColor.Z = Convert.ToSingle(result["sun_moon_color_b"]);
+                        nWP.sunMoonColor.W = Convert.ToSingle(result["sun_moon_color_i"]);
+                        nWP.sunMoonPosition = Convert.ToSingle(result["sun_moon_position"]);
+                        nWP.ambient.X = Convert.ToSingle(result["ambient_r"]);
+                        nWP.ambient.Y = Convert.ToSingle(result["ambient_g"]);
+                        nWP.ambient.Z = Convert.ToSingle(result["ambient_b"]);
+                        nWP.ambient.W = Convert.ToSingle(result["ambient_i"]);
+                        nWP.eastAngle = Convert.ToSingle(result["east_angle"]);
+                        nWP.sunGlowFocus = Convert.ToSingle(result["sun_glow_focus"]);
+                        nWP.sunGlowSize = Convert.ToSingle(result["sun_glow_size"]);
+                        nWP.sceneGamma = Convert.ToSingle(result["scene_gamma"]);
+                        nWP.starBrightness = Convert.ToSingle(result["star_brightness"]);
+                        nWP.cloudColor.X = Convert.ToSingle(result["cloud_color_r"]);
+                        nWP.cloudColor.Y = Convert.ToSingle(result["cloud_color_g"]);
+                        nWP.cloudColor.Z = Convert.ToSingle(result["cloud_color_b"]);
+                        nWP.cloudColor.W = Convert.ToSingle(result["cloud_color_i"]);
+                        nWP.cloudXYDensity.X = Convert.ToSingle(result["cloud_x"]);
+                        nWP.cloudXYDensity.Y = Convert.ToSingle(result["cloud_y"]);
+                        nWP.cloudXYDensity.Z = Convert.ToSingle(result["cloud_density"]);
+                        nWP.cloudCoverage = Convert.ToSingle(result["cloud_coverage"]);
+                        nWP.cloudScale = Convert.ToSingle(result["cloud_scale"]);
+                        nWP.cloudDetailXYDensity.X = Convert.ToSingle(result["cloud_detail_x"]);
+                        nWP.cloudDetailXYDensity.Y = Convert.ToSingle(result["cloud_detail_y"]);
+                        nWP.cloudDetailXYDensity.Z = Convert.ToSingle(result["cloud_detail_density"]);
+                        nWP.cloudScrollX = Convert.ToSingle(result["cloud_scroll_x"]);
+                        nWP.cloudScrollXLock = Convert.ToBoolean(result["cloud_scroll_x_lock"]);
+                        nWP.cloudScrollY = Convert.ToSingle(result["cloud_scroll_y"]);
+                        nWP.cloudScrollYLock = Convert.ToBoolean(result["cloud_scroll_y_lock"]);
+                        nWP.drawClassicClouds = Convert.ToBoolean(result["draw_classic_clouds"]);
+                        nWP.valid = true;
                     }
                 }
             }
-
             return nWP;
         }
 
@@ -857,124 +853,118 @@ namespace OpenSim.Data.MySQL
 
         public void StoreRegionWindlightSettings(RegionLightShareData wl)
         {
-            lock (m_dbLock)
+            using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
             {
-                using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
+                dbcon.Open();
+
+                using (MySqlCommand cmd = dbcon.CreateCommand())
                 {
-                    dbcon.Open();
-    
-                    using (MySqlCommand cmd = dbcon.CreateCommand())
-                    {
-                        cmd.CommandText = "REPLACE INTO `regionwindlight` (`region_id`, `water_color_r`, `water_color_g`, ";
-                        cmd.CommandText += "`water_color_b`, `water_fog_density_exponent`, `underwater_fog_modifier`, ";
-                        cmd.CommandText += "`reflection_wavelet_scale_1`, `reflection_wavelet_scale_2`, `reflection_wavelet_scale_3`, ";
-                        cmd.CommandText += "`fresnel_scale`, `fresnel_offset`, `refract_scale_above`, `refract_scale_below`, ";
-                        cmd.CommandText += "`blur_multiplier`, `big_wave_direction_x`, `big_wave_direction_y`, `little_wave_direction_x`, ";
-                        cmd.CommandText += "`little_wave_direction_y`, `normal_map_texture`, `horizon_r`, `horizon_g`, `horizon_b`, ";
-                        cmd.CommandText += "`horizon_i`, `haze_horizon`, `blue_density_r`, `blue_density_g`, `blue_density_b`, ";
-                        cmd.CommandText += "`blue_density_i`, `haze_density`, `density_multiplier`, `distance_multiplier`, `max_altitude`, ";
-                        cmd.CommandText += "`sun_moon_color_r`, `sun_moon_color_g`, `sun_moon_color_b`, `sun_moon_color_i`, `sun_moon_position`, ";
-                        cmd.CommandText += "`ambient_r`, `ambient_g`, `ambient_b`, `ambient_i`, `east_angle`, `sun_glow_focus`, `sun_glow_size`, ";
-                        cmd.CommandText += "`scene_gamma`, `star_brightness`, `cloud_color_r`, `cloud_color_g`, `cloud_color_b`, `cloud_color_i`, ";
-                        cmd.CommandText += "`cloud_x`, `cloud_y`, `cloud_density`, `cloud_coverage`, `cloud_scale`, `cloud_detail_x`, ";
-                        cmd.CommandText += "`cloud_detail_y`, `cloud_detail_density`, `cloud_scroll_x`, `cloud_scroll_x_lock`, `cloud_scroll_y`, ";
-                        cmd.CommandText += "`cloud_scroll_y_lock`, `draw_classic_clouds`) VALUES (?region_id, ?water_color_r, ";
-                        cmd.CommandText += "?water_color_g, ?water_color_b, ?water_fog_density_exponent, ?underwater_fog_modifier, ?reflection_wavelet_scale_1, ";
-                        cmd.CommandText += "?reflection_wavelet_scale_2, ?reflection_wavelet_scale_3, ?fresnel_scale, ?fresnel_offset, ?refract_scale_above, ";
-                        cmd.CommandText += "?refract_scale_below, ?blur_multiplier, ?big_wave_direction_x, ?big_wave_direction_y, ?little_wave_direction_x, ";
-                        cmd.CommandText += "?little_wave_direction_y, ?normal_map_texture, ?horizon_r, ?horizon_g, ?horizon_b, ?horizon_i, ?haze_horizon, ";
-                        cmd.CommandText += "?blue_density_r, ?blue_density_g, ?blue_density_b, ?blue_density_i, ?haze_density, ?density_multiplier, ";
-                        cmd.CommandText += "?distance_multiplier, ?max_altitude, ?sun_moon_color_r, ?sun_moon_color_g, ?sun_moon_color_b, ";
-                        cmd.CommandText += "?sun_moon_color_i, ?sun_moon_position, ?ambient_r, ?ambient_g, ?ambient_b, ?ambient_i, ?east_angle, ";
-                        cmd.CommandText += "?sun_glow_focus, ?sun_glow_size, ?scene_gamma, ?star_brightness, ?cloud_color_r, ?cloud_color_g, ";
-                        cmd.CommandText += "?cloud_color_b, ?cloud_color_i, ?cloud_x, ?cloud_y, ?cloud_density, ?cloud_coverage, ?cloud_scale, ";
-                        cmd.CommandText += "?cloud_detail_x, ?cloud_detail_y, ?cloud_detail_density, ?cloud_scroll_x, ?cloud_scroll_x_lock, ";
-                        cmd.CommandText += "?cloud_scroll_y, ?cloud_scroll_y_lock, ?draw_classic_clouds)";
-    
-                        cmd.Parameters.AddWithValue("region_id", wl.regionID);
-                        cmd.Parameters.AddWithValue("water_color_r", wl.waterColor.X);
-                        cmd.Parameters.AddWithValue("water_color_g", wl.waterColor.Y);
-                        cmd.Parameters.AddWithValue("water_color_b", wl.waterColor.Z);
-                        cmd.Parameters.AddWithValue("water_fog_density_exponent", wl.waterFogDensityExponent);
-                        cmd.Parameters.AddWithValue("underwater_fog_modifier", wl.underwaterFogModifier);
-                        cmd.Parameters.AddWithValue("reflection_wavelet_scale_1", wl.reflectionWaveletScale.X);
-                        cmd.Parameters.AddWithValue("reflection_wavelet_scale_2", wl.reflectionWaveletScale.Y);
-                        cmd.Parameters.AddWithValue("reflection_wavelet_scale_3", wl.reflectionWaveletScale.Z);
-                        cmd.Parameters.AddWithValue("fresnel_scale", wl.fresnelScale);
-                        cmd.Parameters.AddWithValue("fresnel_offset", wl.fresnelOffset);
-                        cmd.Parameters.AddWithValue("refract_scale_above", wl.refractScaleAbove);
-                        cmd.Parameters.AddWithValue("refract_scale_below", wl.refractScaleBelow);
-                        cmd.Parameters.AddWithValue("blur_multiplier", wl.blurMultiplier);
-                        cmd.Parameters.AddWithValue("big_wave_direction_x", wl.bigWaveDirection.X);
-                        cmd.Parameters.AddWithValue("big_wave_direction_y", wl.bigWaveDirection.Y);
-                        cmd.Parameters.AddWithValue("little_wave_direction_x", wl.littleWaveDirection.X);
-                        cmd.Parameters.AddWithValue("little_wave_direction_y", wl.littleWaveDirection.Y);
-                        cmd.Parameters.AddWithValue("normal_map_texture", wl.normalMapTexture);
-                        cmd.Parameters.AddWithValue("horizon_r", wl.horizon.X);
-                        cmd.Parameters.AddWithValue("horizon_g", wl.horizon.Y);
-                        cmd.Parameters.AddWithValue("horizon_b", wl.horizon.Z);
-                        cmd.Parameters.AddWithValue("horizon_i", wl.horizon.W);
-                        cmd.Parameters.AddWithValue("haze_horizon", wl.hazeHorizon);
-                        cmd.Parameters.AddWithValue("blue_density_r", wl.blueDensity.X);
-                        cmd.Parameters.AddWithValue("blue_density_g", wl.blueDensity.Y);
-                        cmd.Parameters.AddWithValue("blue_density_b", wl.blueDensity.Z);
-                        cmd.Parameters.AddWithValue("blue_density_i", wl.blueDensity.W);
-                        cmd.Parameters.AddWithValue("haze_density", wl.hazeDensity);
-                        cmd.Parameters.AddWithValue("density_multiplier", wl.densityMultiplier);
-                        cmd.Parameters.AddWithValue("distance_multiplier", wl.distanceMultiplier);
-                        cmd.Parameters.AddWithValue("max_altitude", wl.maxAltitude);
-                        cmd.Parameters.AddWithValue("sun_moon_color_r", wl.sunMoonColor.X);
-                        cmd.Parameters.AddWithValue("sun_moon_color_g", wl.sunMoonColor.Y);
-                        cmd.Parameters.AddWithValue("sun_moon_color_b", wl.sunMoonColor.Z);
-                        cmd.Parameters.AddWithValue("sun_moon_color_i", wl.sunMoonColor.W);
-                        cmd.Parameters.AddWithValue("sun_moon_position", wl.sunMoonPosition);
-                        cmd.Parameters.AddWithValue("ambient_r", wl.ambient.X);
-                        cmd.Parameters.AddWithValue("ambient_g", wl.ambient.Y);
-                        cmd.Parameters.AddWithValue("ambient_b", wl.ambient.Z);
-                        cmd.Parameters.AddWithValue("ambient_i", wl.ambient.W);
-                        cmd.Parameters.AddWithValue("east_angle", wl.eastAngle);
-                        cmd.Parameters.AddWithValue("sun_glow_focus", wl.sunGlowFocus);
-                        cmd.Parameters.AddWithValue("sun_glow_size", wl.sunGlowSize);
-                        cmd.Parameters.AddWithValue("scene_gamma", wl.sceneGamma);
-                        cmd.Parameters.AddWithValue("star_brightness", wl.starBrightness);
-                        cmd.Parameters.AddWithValue("cloud_color_r", wl.cloudColor.X);
-                        cmd.Parameters.AddWithValue("cloud_color_g", wl.cloudColor.Y);
-                        cmd.Parameters.AddWithValue("cloud_color_b", wl.cloudColor.Z);
-                        cmd.Parameters.AddWithValue("cloud_color_i", wl.cloudColor.W);
-                        cmd.Parameters.AddWithValue("cloud_x", wl.cloudXYDensity.X);
-                        cmd.Parameters.AddWithValue("cloud_y", wl.cloudXYDensity.Y);
-                        cmd.Parameters.AddWithValue("cloud_density", wl.cloudXYDensity.Z);
-                        cmd.Parameters.AddWithValue("cloud_coverage", wl.cloudCoverage);
-                        cmd.Parameters.AddWithValue("cloud_scale", wl.cloudScale);
-                        cmd.Parameters.AddWithValue("cloud_detail_x", wl.cloudDetailXYDensity.X);
-                        cmd.Parameters.AddWithValue("cloud_detail_y", wl.cloudDetailXYDensity.Y);
-                        cmd.Parameters.AddWithValue("cloud_detail_density", wl.cloudDetailXYDensity.Z);
-                        cmd.Parameters.AddWithValue("cloud_scroll_x", wl.cloudScrollX);
-                        cmd.Parameters.AddWithValue("cloud_scroll_x_lock", wl.cloudScrollXLock);
-                        cmd.Parameters.AddWithValue("cloud_scroll_y", wl.cloudScrollY);
-                        cmd.Parameters.AddWithValue("cloud_scroll_y_lock", wl.cloudScrollYLock);
-                        cmd.Parameters.AddWithValue("draw_classic_clouds", wl.drawClassicClouds);
-                        
-                        ExecuteNonQuery(cmd);
-                    }
+                    cmd.CommandText = "REPLACE INTO `regionwindlight` (`region_id`, `water_color_r`, `water_color_g`, ";
+                    cmd.CommandText += "`water_color_b`, `water_fog_density_exponent`, `underwater_fog_modifier`, ";
+                    cmd.CommandText += "`reflection_wavelet_scale_1`, `reflection_wavelet_scale_2`, `reflection_wavelet_scale_3`, ";
+                    cmd.CommandText += "`fresnel_scale`, `fresnel_offset`, `refract_scale_above`, `refract_scale_below`, ";
+                    cmd.CommandText += "`blur_multiplier`, `big_wave_direction_x`, `big_wave_direction_y`, `little_wave_direction_x`, ";
+                    cmd.CommandText += "`little_wave_direction_y`, `normal_map_texture`, `horizon_r`, `horizon_g`, `horizon_b`, ";
+                    cmd.CommandText += "`horizon_i`, `haze_horizon`, `blue_density_r`, `blue_density_g`, `blue_density_b`, ";
+                    cmd.CommandText += "`blue_density_i`, `haze_density`, `density_multiplier`, `distance_multiplier`, `max_altitude`, ";
+                    cmd.CommandText += "`sun_moon_color_r`, `sun_moon_color_g`, `sun_moon_color_b`, `sun_moon_color_i`, `sun_moon_position`, ";
+                    cmd.CommandText += "`ambient_r`, `ambient_g`, `ambient_b`, `ambient_i`, `east_angle`, `sun_glow_focus`, `sun_glow_size`, ";
+                    cmd.CommandText += "`scene_gamma`, `star_brightness`, `cloud_color_r`, `cloud_color_g`, `cloud_color_b`, `cloud_color_i`, ";
+                    cmd.CommandText += "`cloud_x`, `cloud_y`, `cloud_density`, `cloud_coverage`, `cloud_scale`, `cloud_detail_x`, ";
+                    cmd.CommandText += "`cloud_detail_y`, `cloud_detail_density`, `cloud_scroll_x`, `cloud_scroll_x_lock`, `cloud_scroll_y`, ";
+                    cmd.CommandText += "`cloud_scroll_y_lock`, `draw_classic_clouds`) VALUES (?region_id, ?water_color_r, ";
+                    cmd.CommandText += "?water_color_g, ?water_color_b, ?water_fog_density_exponent, ?underwater_fog_modifier, ?reflection_wavelet_scale_1, ";
+                    cmd.CommandText += "?reflection_wavelet_scale_2, ?reflection_wavelet_scale_3, ?fresnel_scale, ?fresnel_offset, ?refract_scale_above, ";
+                    cmd.CommandText += "?refract_scale_below, ?blur_multiplier, ?big_wave_direction_x, ?big_wave_direction_y, ?little_wave_direction_x, ";
+                    cmd.CommandText += "?little_wave_direction_y, ?normal_map_texture, ?horizon_r, ?horizon_g, ?horizon_b, ?horizon_i, ?haze_horizon, ";
+                    cmd.CommandText += "?blue_density_r, ?blue_density_g, ?blue_density_b, ?blue_density_i, ?haze_density, ?density_multiplier, ";
+                    cmd.CommandText += "?distance_multiplier, ?max_altitude, ?sun_moon_color_r, ?sun_moon_color_g, ?sun_moon_color_b, ";
+                    cmd.CommandText += "?sun_moon_color_i, ?sun_moon_position, ?ambient_r, ?ambient_g, ?ambient_b, ?ambient_i, ?east_angle, ";
+                    cmd.CommandText += "?sun_glow_focus, ?sun_glow_size, ?scene_gamma, ?star_brightness, ?cloud_color_r, ?cloud_color_g, ";
+                    cmd.CommandText += "?cloud_color_b, ?cloud_color_i, ?cloud_x, ?cloud_y, ?cloud_density, ?cloud_coverage, ?cloud_scale, ";
+                    cmd.CommandText += "?cloud_detail_x, ?cloud_detail_y, ?cloud_detail_density, ?cloud_scroll_x, ?cloud_scroll_x_lock, ";
+                    cmd.CommandText += "?cloud_scroll_y, ?cloud_scroll_y_lock, ?draw_classic_clouds)";
+
+                    cmd.Parameters.AddWithValue("region_id", wl.regionID);
+                    cmd.Parameters.AddWithValue("water_color_r", wl.waterColor.X);
+                    cmd.Parameters.AddWithValue("water_color_g", wl.waterColor.Y);
+                    cmd.Parameters.AddWithValue("water_color_b", wl.waterColor.Z);
+                    cmd.Parameters.AddWithValue("water_fog_density_exponent", wl.waterFogDensityExponent);
+                    cmd.Parameters.AddWithValue("underwater_fog_modifier", wl.underwaterFogModifier);
+                    cmd.Parameters.AddWithValue("reflection_wavelet_scale_1", wl.reflectionWaveletScale.X);
+                    cmd.Parameters.AddWithValue("reflection_wavelet_scale_2", wl.reflectionWaveletScale.Y);
+                    cmd.Parameters.AddWithValue("reflection_wavelet_scale_3", wl.reflectionWaveletScale.Z);
+                    cmd.Parameters.AddWithValue("fresnel_scale", wl.fresnelScale);
+                    cmd.Parameters.AddWithValue("fresnel_offset", wl.fresnelOffset);
+                    cmd.Parameters.AddWithValue("refract_scale_above", wl.refractScaleAbove);
+                    cmd.Parameters.AddWithValue("refract_scale_below", wl.refractScaleBelow);
+                    cmd.Parameters.AddWithValue("blur_multiplier", wl.blurMultiplier);
+                    cmd.Parameters.AddWithValue("big_wave_direction_x", wl.bigWaveDirection.X);
+                    cmd.Parameters.AddWithValue("big_wave_direction_y", wl.bigWaveDirection.Y);
+                    cmd.Parameters.AddWithValue("little_wave_direction_x", wl.littleWaveDirection.X);
+                    cmd.Parameters.AddWithValue("little_wave_direction_y", wl.littleWaveDirection.Y);
+                    cmd.Parameters.AddWithValue("normal_map_texture", wl.normalMapTexture);
+                    cmd.Parameters.AddWithValue("horizon_r", wl.horizon.X);
+                    cmd.Parameters.AddWithValue("horizon_g", wl.horizon.Y);
+                    cmd.Parameters.AddWithValue("horizon_b", wl.horizon.Z);
+                    cmd.Parameters.AddWithValue("horizon_i", wl.horizon.W);
+                    cmd.Parameters.AddWithValue("haze_horizon", wl.hazeHorizon);
+                    cmd.Parameters.AddWithValue("blue_density_r", wl.blueDensity.X);
+                    cmd.Parameters.AddWithValue("blue_density_g", wl.blueDensity.Y);
+                    cmd.Parameters.AddWithValue("blue_density_b", wl.blueDensity.Z);
+                    cmd.Parameters.AddWithValue("blue_density_i", wl.blueDensity.W);
+                    cmd.Parameters.AddWithValue("haze_density", wl.hazeDensity);
+                    cmd.Parameters.AddWithValue("density_multiplier", wl.densityMultiplier);
+                    cmd.Parameters.AddWithValue("distance_multiplier", wl.distanceMultiplier);
+                    cmd.Parameters.AddWithValue("max_altitude", wl.maxAltitude);
+                    cmd.Parameters.AddWithValue("sun_moon_color_r", wl.sunMoonColor.X);
+                    cmd.Parameters.AddWithValue("sun_moon_color_g", wl.sunMoonColor.Y);
+                    cmd.Parameters.AddWithValue("sun_moon_color_b", wl.sunMoonColor.Z);
+                    cmd.Parameters.AddWithValue("sun_moon_color_i", wl.sunMoonColor.W);
+                    cmd.Parameters.AddWithValue("sun_moon_position", wl.sunMoonPosition);
+                    cmd.Parameters.AddWithValue("ambient_r", wl.ambient.X);
+                    cmd.Parameters.AddWithValue("ambient_g", wl.ambient.Y);
+                    cmd.Parameters.AddWithValue("ambient_b", wl.ambient.Z);
+                    cmd.Parameters.AddWithValue("ambient_i", wl.ambient.W);
+                    cmd.Parameters.AddWithValue("east_angle", wl.eastAngle);
+                    cmd.Parameters.AddWithValue("sun_glow_focus", wl.sunGlowFocus);
+                    cmd.Parameters.AddWithValue("sun_glow_size", wl.sunGlowSize);
+                    cmd.Parameters.AddWithValue("scene_gamma", wl.sceneGamma);
+                    cmd.Parameters.AddWithValue("star_brightness", wl.starBrightness);
+                    cmd.Parameters.AddWithValue("cloud_color_r", wl.cloudColor.X);
+                    cmd.Parameters.AddWithValue("cloud_color_g", wl.cloudColor.Y);
+                    cmd.Parameters.AddWithValue("cloud_color_b", wl.cloudColor.Z);
+                    cmd.Parameters.AddWithValue("cloud_color_i", wl.cloudColor.W);
+                    cmd.Parameters.AddWithValue("cloud_x", wl.cloudXYDensity.X);
+                    cmd.Parameters.AddWithValue("cloud_y", wl.cloudXYDensity.Y);
+                    cmd.Parameters.AddWithValue("cloud_density", wl.cloudXYDensity.Z);
+                    cmd.Parameters.AddWithValue("cloud_coverage", wl.cloudCoverage);
+                    cmd.Parameters.AddWithValue("cloud_scale", wl.cloudScale);
+                    cmd.Parameters.AddWithValue("cloud_detail_x", wl.cloudDetailXYDensity.X);
+                    cmd.Parameters.AddWithValue("cloud_detail_y", wl.cloudDetailXYDensity.Y);
+                    cmd.Parameters.AddWithValue("cloud_detail_density", wl.cloudDetailXYDensity.Z);
+                    cmd.Parameters.AddWithValue("cloud_scroll_x", wl.cloudScrollX);
+                    cmd.Parameters.AddWithValue("cloud_scroll_x_lock", wl.cloudScrollXLock);
+                    cmd.Parameters.AddWithValue("cloud_scroll_y", wl.cloudScrollY);
+                    cmd.Parameters.AddWithValue("cloud_scroll_y_lock", wl.cloudScrollYLock);
+                    cmd.Parameters.AddWithValue("draw_classic_clouds", wl.drawClassicClouds);
+                    
+                    ExecuteNonQuery(cmd);
                 }
             }
         }
 
         public void RemoveRegionWindlightSettings(UUID regionID)
         {
-            lock (m_dbLock)
+            using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
             {
-                using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
+                dbcon.Open();
+
+                using (MySqlCommand cmd = dbcon.CreateCommand())
                 {
-                    dbcon.Open();
-    
-                    using (MySqlCommand cmd = dbcon.CreateCommand())
-                    {
-                        cmd.CommandText = "delete from `regionwindlight` where `region_id`=?regionID";
-                        cmd.Parameters.AddWithValue("?regionID", regionID.ToString());
-                        ExecuteNonQuery(cmd);
-                    }
+                    cmd.CommandText = "delete from `regionwindlight` where `region_id`=?regionID";
+                    cmd.Parameters.AddWithValue("?regionID", regionID.ToString());
+                    ExecuteNonQuery(cmd);
                 }
             }
         }
@@ -982,29 +972,26 @@ namespace OpenSim.Data.MySQL
         #region RegionEnvironmentSettings
         public string LoadRegionEnvironmentSettings(UUID regionUUID)
         {
-            lock (m_dbLock)
+            using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
             {
-                using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
+                dbcon.Open();
+
+                string command = "select * from `regionenvironment` where region_id = ?region_id";
+
+                using (MySqlCommand cmd = new MySqlCommand(command))
                 {
-                    dbcon.Open();
-    
-                    string command = "select * from `regionenvironment` where region_id = ?region_id";
-    
-                    using (MySqlCommand cmd = new MySqlCommand(command))
+                    cmd.Connection = dbcon;
+
+                    cmd.Parameters.AddWithValue("?region_id", regionUUID.ToString());
+
+                    IDataReader result = ExecuteReader(cmd);
+                    if (!result.Read())
                     {
-                        cmd.Connection = dbcon;
-    
-                        cmd.Parameters.AddWithValue("?region_id", regionUUID.ToString());
-    
-                        IDataReader result = ExecuteReader(cmd);
-                        if (!result.Read())
-                        {
-                            return String.Empty;
-                        }
-                        else
-                        {
-                            return Convert.ToString(result["llsd_settings"]);
-                        }
+                        return String.Empty;
+                    }
+                    else
+                    {
+                        return Convert.ToString(result["llsd_settings"]);
                     }
                 }
             }
@@ -1012,39 +999,33 @@ namespace OpenSim.Data.MySQL
 
         public void StoreRegionEnvironmentSettings(UUID regionUUID, string settings)
         {
-            lock (m_dbLock)
+            using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
             {
-                using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
+                dbcon.Open();
+
+                using (MySqlCommand cmd = dbcon.CreateCommand())
                 {
-                    dbcon.Open();
-    
-                    using (MySqlCommand cmd = dbcon.CreateCommand())
-                    {
-                        cmd.CommandText = "REPLACE INTO `regionenvironment` (`region_id`, `llsd_settings`) VALUES (?region_id, ?llsd_settings)";
-    
-                        cmd.Parameters.AddWithValue("region_id", regionUUID);
-                        cmd.Parameters.AddWithValue("llsd_settings", settings);
-    
-                        ExecuteNonQuery(cmd);
-                    }
+                    cmd.CommandText = "REPLACE INTO `regionenvironment` (`region_id`, `llsd_settings`) VALUES (?region_id, ?llsd_settings)";
+
+                    cmd.Parameters.AddWithValue("region_id", regionUUID);
+                    cmd.Parameters.AddWithValue("llsd_settings", settings);
+
+                    ExecuteNonQuery(cmd);
                 }
             }
         }
 
         public void RemoveRegionEnvironmentSettings(UUID regionUUID)
         {
-            lock (m_dbLock)
+            using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
             {
-                using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
+                dbcon.Open();
+
+                using (MySqlCommand cmd = dbcon.CreateCommand())
                 {
-                    dbcon.Open();
-    
-                    using (MySqlCommand cmd = dbcon.CreateCommand())
-                    {
-                        cmd.CommandText = "delete from `regionenvironment` where region_id = ?region_id";
-                        cmd.Parameters.AddWithValue("?region_id", regionUUID.ToString());
-                        ExecuteNonQuery(cmd);
-                    }
+                    cmd.CommandText = "delete from `regionenvironment` where region_id = ?region_id";
+                    cmd.Parameters.AddWithValue("?region_id", regionUUID.ToString());
+                    ExecuteNonQuery(cmd);
                 }
             }
         }
@@ -1985,74 +1966,5 @@ namespace OpenSim.Data.MySQL
                 }
             }
         }
-
-        public void SaveExtra(UUID regionID, string name, string val)
-        {
-            lock (m_dbLock)
-            {
-                using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
-                {
-                    dbcon.Open();
-
-                    using (MySqlCommand cmd = dbcon.CreateCommand())
-                    {
-                        cmd.CommandText = "replace into regionextra values (?RegionID, ?Name, ?value)";
-                        cmd.Parameters.AddWithValue("?RegionID", regionID.ToString());
-                        cmd.Parameters.AddWithValue("?Name", name);
-                        cmd.Parameters.AddWithValue("?value", val);
-
-                        cmd.ExecuteNonQuery();
-                    }
-                }
-            }
-        }
-
-        public void RemoveExtra(UUID regionID, string name)
-        {
-            lock (m_dbLock)
-            {
-                using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
-                {
-                    dbcon.Open();
-
-                    using (MySqlCommand cmd = dbcon.CreateCommand())
-                    {
-                        cmd.CommandText = "delete from regionextra where RegionID=?RegionID and Name=?Name";
-                        cmd.Parameters.AddWithValue("?RegionID", regionID.ToString());
-                        cmd.Parameters.AddWithValue("?Name", name);
-
-                        cmd.ExecuteNonQuery();
-                    }
-                }
-            }
-        }
-
-        public Dictionary<string, string> GetExtra(UUID regionID)
-        {
-            Dictionary<string, string> ret = new Dictionary<string, string>();
-
-            lock (m_dbLock)
-            {
-                using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
-                {
-                    dbcon.Open();
-
-                    using (MySqlCommand cmd = dbcon.CreateCommand())
-                    {
-                        cmd.CommandText = "select * from regionextra where RegionID=?RegionID";
-                        cmd.Parameters.AddWithValue("?RegionID", regionID.ToString());
-                        using (IDataReader r = cmd.ExecuteReader())
-                        {
-                            while (r.Read())
-                            {
-                                ret[r["Name"].ToString()] = r["value"].ToString();
-                            }
-                        }
-                    }
-                }
-            }
-
-            return ret;
-        }
     }
 }

OpenSim/Data/MySQL/Resources/RegionStore.migrations

@@ -895,10 +895,3 @@ CREATE TABLE `regionenvironment` (
 
 COMMIT;
 
-:VERSION 45
-
-BEGIN;
-
-CREATE TABLE `regionextra` (`RegionID` char(36) not null, `Name` varchar(32) not null, `value` text, primary key(`RegionID`, `Name`));
-
-COMMIT;

OpenSim/Data/Null/NullPresenceData.cs

@@ -79,6 +79,19 @@ namespace OpenSim.Data.Null
             return null;
         }
 
+        public PresenceData Verify(UUID s_sessionID)
+        {
+            if (Instance != this)
+                return Instance.Verify(s_sessionID);
+
+            if (m_presenceData.ContainsKey(s_sessionID))
+            {
+                return m_presenceData[s_sessionID];
+            }
+
+            return null;
+        }
+
         public void LogoutRegionAgents(UUID regionID)
         {
             if (Instance != this)

OpenSim/Data/Null/NullSimulationData.cs

@@ -151,18 +151,5 @@ namespace OpenSim.Data.Null
         public void Shutdown()
         {
         }
-
-        public void SaveExtra(UUID regionID, string name, string value)
-        {
-        }
-
-        public void RemoveExtra(UUID regionID, string name)
-        {
-        }
-
-        public Dictionary<string, string> GetExtra(UUID regionID)
-        {
-            return null;
-        }
     }
 }

OpenSim/Data/SQLite/SQLiteSimulationData.cs

@@ -2890,17 +2890,5 @@ namespace OpenSim.Data.SQLite
             }
         }
 
-        public void SaveExtra(UUID regionID, string name, string value)
-        {
-        }
-
-        public void RemoveExtra(UUID regionID, string name)
-        {
-        }
-
-        public Dictionary<string, string> GetExtra(UUID regionID)
-        {
-            return null;
-        }
     }
 }

OpenSim/Data/Tests/RegionTests.cs

@@ -1069,6 +1069,8 @@ namespace OpenSim.Data.Tests
             regionInfo.RegionLocX = 0;
             regionInfo.RegionLocY = 0;
 
+            Scene scene = new Scene(regionInfo);
+
             SceneObjectPart sop = new SceneObjectPart();
             sop.Name = name;
             sop.Description = name;
@@ -1079,7 +1081,7 @@ namespace OpenSim.Data.Tests
             sop.Shape = PrimitiveBaseShape.Default;
 
             SceneObjectGroup sog = new SceneObjectGroup(sop);
-//            sog.SetScene(scene);
+            sog.SetScene(scene);
 
             return sog;
         }

OpenSim/Framework/AgentCircuitData.cs

@@ -98,11 +98,6 @@ namespace OpenSim.Framework
         /// </summary>
         public string lastname;
 
-        /// <summary>
-        /// Agent's full name.
-        /// </summary>
-        public string Name { get { return string.Format("{0} {1}", firstname, lastname); } }
-
         /// <summary>
         /// Random Unique GUID for this session.  Client gets this at login and it's
         /// only supposed to be disclosed over secure channels

OpenSim/Framework/Cache.cs

@@ -199,14 +199,7 @@ namespace OpenSim.Framework
     //
     public class Cache
     {
-        /// <summary>
-        /// Must only be accessed under lock.
-        /// </summary>
         private List<CacheItemBase> m_Index = new List<CacheItemBase>();
-
-        /// <summary>
-        /// Must only be accessed under m_Index lock.
-        /// </summary>
         private Dictionary<string, CacheItemBase> m_Lookup =
             new Dictionary<string, CacheItemBase>();
 
@@ -327,19 +320,19 @@ namespace OpenSim.Framework
             {
                 if (m_Lookup.ContainsKey(index))
                     item = m_Lookup[index];
-
-                if (item == null)
-                {
-                    Expire(true);
-                    return null;
-                }
-    
-                item.hits++;
-                item.lastUsed = DateTime.Now;
-    
-                Expire(true);
             }
 
+            if (item == null)
+            {
+                Expire(true);
+                return null;
+            }
+
+            item.hits++;
+            item.lastUsed = DateTime.Now;
+
+            Expire(true);
+
             return item;
         }
 
@@ -392,10 +385,7 @@ namespace OpenSim.Framework
         //
         public Object Find(Predicate<CacheItemBase> d)
         {
-            CacheItemBase item;
-
-            lock (m_Index)
-                item = m_Index.Find(d);
+            CacheItemBase item = m_Index.Find(d);
 
             if (item == null)
                 return null;
@@ -429,12 +419,12 @@ namespace OpenSim.Framework
         public virtual void Store(string index, Object data, Type container,
                 Object[] parameters)
         {
+            Expire(false);
+
             CacheItemBase item;
 
             lock (m_Index)
             {
-                Expire(false);
-
                 if (m_Index.Contains(new CacheItemBase(index)))
                 {
                     if ((m_Flags & CacheFlags.AllowUpdate) != 0)
@@ -460,17 +450,9 @@ namespace OpenSim.Framework
                 m_Index.Add(item);
                 m_Lookup[index] = item;
             }
-
             item.Store(data);
         }
 
-        /// <summary>
-        /// Expire items as appropriate.
-        /// </summary>
-        /// <remarks>
-        /// Callers must lock m_Index.
-        /// </remarks>
-        /// <param name='getting'></param>
         protected virtual void Expire(bool getting)
         {
             if (getting && (m_Strategy == CacheStrategy.Aggressive))
@@ -493,10 +475,12 @@ namespace OpenSim.Framework
 
             switch (m_Strategy)
             {
-                case CacheStrategy.Aggressive:
-                    if (Count < Size)
-                        return;
+            case CacheStrategy.Aggressive:
+                if (Count < Size)
+                    return;
 
+                lock (m_Index)
+                {
                     m_Index.Sort(new SortLRU());
                     m_Index.Reverse();
 
@@ -506,7 +490,7 @@ namespace OpenSim.Framework
 
                     ExpireDelegate doExpire = OnExpire;
 
-                    if (doExpire != null)
+                if (doExpire != null)
                     {
                         List<CacheItemBase> candidates =
                                 m_Index.GetRange(target, Count - target);
@@ -529,34 +513,27 @@ namespace OpenSim.Framework
                         foreach (CacheItemBase item in m_Index)
                             m_Lookup[item.uuid] = item;
                     }
-
-                    break;
-
-                    default:
-                        break;
+                }
+                break;
+            default:
+                break;
             }
         }
 
         public void Invalidate(string uuid)
         {
-            lock (m_Index)
-            {
-                if (!m_Lookup.ContainsKey(uuid))
-                    return;
+            if (!m_Lookup.ContainsKey(uuid))
+                return;
 
-                CacheItemBase item = m_Lookup[uuid];
-                m_Lookup.Remove(uuid);
-                m_Index.Remove(item);
-            }
+            CacheItemBase item = m_Lookup[uuid];
+            m_Lookup.Remove(uuid);
+            m_Index.Remove(item);
         }
 
         public void Clear()
         {
-            lock (m_Index)
-            {
-                m_Index.Clear();
-                m_Lookup.Clear();
-            }
+            m_Index.Clear();
+            m_Lookup.Clear();
         }
     }
-}
+}

OpenSim/Framework/Console/CommandConsole.cs

@@ -678,8 +678,6 @@ namespace OpenSim.Framework.Console
     {
 //        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        public event OnOutputDelegate OnOutput;
-
         public ICommands Commands { get; private set; }
 
         public CommandConsole(string defaultPrompt) : base(defaultPrompt)
@@ -699,13 +697,6 @@ namespace OpenSim.Framework.Console
                 Output(s);
         }
 
-        protected void FireOnOutput(string text)
-        {
-            OnOutputDelegate onOutput = OnOutput;
-            if (onOutput != null)
-                onOutput(text);
-        }
-
         /// <summary>
         /// Display a command prompt on the console and wait for user input
         /// </summary>

OpenSim/Framework/Console/ConsoleDisplayTable.cs

@@ -79,16 +79,6 @@ namespace OpenSim.Framework.Console
             return sb.ToString();
         }
 
-        public void AddColumn(string name, int width)
-        {
-            Columns.Add(new ConsoleDisplayTableColumn(name, width));
-        }
-
-        public void AddRow(params string[] cells)
-        {
-            Rows.Add(new ConsoleDisplayTableRow(cells));
-        }
-
         public void AddToStringBuilder(StringBuilder sb)
         {
             string formatString = GetFormatString();
@@ -145,10 +135,5 @@ namespace OpenSim.Framework.Console
         {
             Cells = cells;
         }
-
-        public ConsoleDisplayTableRow(params string[] cells) : this()
-        {
-            Cells = new List<string>(cells);
-        }
     }
 }

OpenSim/Framework/Console/LocalConsole.cs

@@ -319,8 +319,6 @@ namespace OpenSim.Framework.Console
 
         public override void Output(string text, string level)
         {
-            FireOnOutput(text);
-
             lock (m_commandLine)
             {
                 if (m_cursorYPosition == -1)
@@ -511,4 +509,4 @@ namespace OpenSim.Framework.Console
             }
         }
     }
-}
+}

OpenSim/Framework/Console/MockConsole.cs

@@ -40,8 +40,6 @@ namespace OpenSim.Framework.Console
     /// </summary>
     public class MockConsole : ICommandConsole
     {
-        public event OnOutputDelegate OnOutput;
-
         private MockCommands m_commands = new MockCommands();
 
         public ICommands Commands { get { return m_commands; } }
@@ -78,4 +76,4 @@ namespace OpenSim.Framework.Console
         public string[] Resolve(string[] cmd) { return null; }
         public XmlElement GetXml(XmlDocument doc) { return null; }
     }
-}
+}

OpenSim/Framework/Console/RemoteConsole.cs

@@ -100,7 +100,6 @@ namespace OpenSim.Framework.Console
                 m_LineNumber++;
                 m_Scrollback.Add(String.Format("{0}", m_LineNumber)+":"+level+":"+text);
             }
-            FireOnOutput(text.Trim());
             System.Console.WriteLine(text.Trim());
         }
 

OpenSim/Framework/IClientAPI.cs

@@ -1033,21 +1033,7 @@ namespace OpenSim.Framework
 
         void InPacket(object NewPack);
         void ProcessInPacket(Packet NewPack);
-
-        /// <summary>
-        /// Close this client
-        /// </summary>
         void Close();
-
-        /// <summary>
-        /// Close this client
-        /// </summary>
-        /// <param name='force'>
-        /// If true, attempts the close without checking active status.  You do not want to try this except as a last
-        /// ditch attempt where Active == false but the ScenePresence still exists.
-        /// </param>
-        void Close(bool force);
-
         void Kick(string message);
         
         /// <summary>
@@ -1367,6 +1353,7 @@ namespace OpenSim.Framework
         void SendBlueBoxMessage(UUID FromAvatarID, String FromAvatarName, String Message);
 
         void SendLogoutPacket();
+        EndPoint GetClientEP();
 
         // WARNING WARNING WARNING
         //

OpenSim/Framework/ICommandConsole.cs

@@ -74,12 +74,8 @@ namespace OpenSim.Framework
         XmlElement GetXml(XmlDocument doc);
     }
 
-    public delegate void OnOutputDelegate(string message);
-
     public interface ICommandConsole : IConsole
     {
-        event OnOutputDelegate OnOutput;
-
         ICommands Commands { get; }
 
         /// <summary>
@@ -91,4 +87,4 @@ namespace OpenSim.Framework
 
         string ReadLine(string p, bool isCommand, bool e);
     }
-}
+}

OpenSim/Framework/IScene.cs

@@ -56,29 +56,11 @@ namespace OpenSim.Framework
 
     public interface IScene
     {
-        /// <summary>
-        /// The name of this scene.
-        /// </summary>
-        string Name { get; }
-
         RegionInfo RegionInfo { get; }
         RegionStatus RegionStatus { get; set; }
 
         IConfigSource Config { get; }
 
-        /// <summary>
-        /// Are logins enabled on this simulator?
-        /// </summary>
-        bool LoginsEnabled { get; set; }
-
-        /// <summary>
-        /// Is this region ready for use?
-        /// </summary>
-        /// <remarks>
-        /// This does not mean that logins are enabled, merely that they can be.
-        /// </remarks>
-        bool Ready { get; set; }
-
         float TimeDilation { get; }
 
         bool AllowScriptCrossings { get; }

OpenSim/Framework/InventoryFolderBase.cs

@@ -73,27 +73,33 @@ namespace OpenSim.Framework
         {
         }
 
-        public InventoryFolderBase(UUID id) : this()
+        public InventoryFolderBase(UUID id)
         {
             ID = id;
         }
 
-        public InventoryFolderBase(UUID id, UUID owner) : this(id)
+        public InventoryFolderBase(UUID id, UUID owner)
         {
+            ID = id;
             Owner = owner;
         }
 
-        public InventoryFolderBase(UUID id, string name, UUID owner, UUID parent) : this(id, owner)
+        public InventoryFolderBase(UUID id, string name, UUID owner, UUID parent)
         {
+            ID = id;
             Name = name;
+            Owner = owner;
             ParentID = parent;
         }
 
-        public InventoryFolderBase(
-            UUID id, string name, UUID owner, short type, UUID parent, ushort version) : this(id, name, owner, parent)
+        public InventoryFolderBase(UUID id, string name, UUID owner, short type, UUID parent, ushort version)
         {
+            ID = id;
+            Name = name;
+            Owner = owner;
             Type = type;
+            ParentID = parent;
             Version = version;
         }
     }
-}
+}

OpenSim/Framework/LocklessQueue.cs

@@ -99,13 +99,8 @@ namespace OpenSim.Framework
                     }
                     else
                     {
-                        item = oldHeadNext.Item;                       
+                        item = oldHeadNext.Item;
                         haveAdvancedHead = CAS(ref head, oldHead, oldHeadNext);
-                        if (haveAdvancedHead)
-                        {
-                            oldHeadNext.Item = default(T);
-                            oldHead.Next = null;
-                        }
                     }
                 }
             }
@@ -116,10 +111,6 @@ namespace OpenSim.Framework
 
         public void Clear()
         {
-            // ugly
-            T item;
-            while(count > 0)
-                Dequeue(out item);
             Init();
         }
 

OpenSim/Framework/MinHeap.cs

@@ -62,16 +62,13 @@ namespace OpenSim.Framework
             }
 
             internal void Clear()
-            {
-                if (this.handle != null)
-                    this.handle.Clear();
-                ClearRef();
-            }
-
-            internal void ClearRef()
             {
                 this.value = default(T);
-                this.handle = null;
+                if (this.handle != null)
+                {
+                    this.handle.Clear();
+                    this.handle = null;
+                }
             }
         }
 
@@ -288,7 +285,6 @@ namespace OpenSim.Framework
             if (--this.size > 0 && index != this.size)
             {
                 Set(this.items[this.size], index);
-                this.items[this.size].ClearRef();
                 if (!BubbleUp(index))
                     BubbleDown(index);
             }

OpenSim/Framework/Monitoring/MemoryWatchdog.cs

@@ -1,129 +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 System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Threading;
-using log4net;
-
-namespace OpenSim.Framework.Monitoring
-{
-    /// <summary>
-    /// Experimental watchdog for memory usage.
-    /// </summary>
-    public static class MemoryWatchdog
-    {
-//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-
-        /// <summary>
-        /// Is this watchdog active?
-        /// </summary>
-        public static bool Enabled
-        {
-            get { return m_enabled; }
-            set
-            {
-//                m_log.DebugFormat("[MEMORY WATCHDOG]: Setting MemoryWatchdog.Enabled to {0}", value);
-
-                if (value && !m_enabled)
-                    UpdateLastRecord(GC.GetTotalMemory(false), Util.EnvironmentTickCount());
-
-                m_enabled = value;
-            }
-        }
-        private static bool m_enabled;
-
-        /// <summary>
-        /// Average memory churn in bytes per millisecond.
-        /// </summary>
-        public static double AverageMemoryChurn
-        {
-            get { if (m_samples.Count > 0) return m_samples.Average(); else return 0; }
-        }
-
-        /// <summary>
-        /// Maximum number of statistical samples.
-        /// </summary>
-        /// <remarks>
-        /// At the moment this corresponds to 1 minute since the sampling rate is every 2.5 seconds as triggered from
-        /// the main Watchdog.
-        /// </remarks>
-        private static int m_maxSamples = 24;
-
-        /// <summary>
-        /// Time when the watchdog was last updated.
-        /// </summary>
-        private static int m_lastUpdateTick;
-
-        /// <summary>
-        /// Memory used at time of last watchdog update.
-        /// </summary>
-        private static long m_lastUpdateMemory;
-
-        /// <summary>
-        /// Memory churn rate per millisecond.
-        /// </summary>
-//        private static double m_churnRatePerMillisecond;
-
-        /// <summary>
-        /// Historical samples for calculating moving average.
-        /// </summary>
-        private static Queue<double> m_samples = new Queue<double>(m_maxSamples);
-
-        public static void Update()
-        {
-            int now = Util.EnvironmentTickCount();
-            long memoryNow = GC.GetTotalMemory(false);
-            long memoryDiff = memoryNow - m_lastUpdateMemory;
-
-            if (memoryDiff >= 0)
-            {
-                if (m_samples.Count >= m_maxSamples)
-                    m_samples.Dequeue();
-
-                double elapsed = Util.EnvironmentTickCountSubtract(now, m_lastUpdateTick);
-
-                // This should never happen since it's not useful for updates to occur with no time elapsed, but
-                // protect ourselves from a divide-by-zero just in case.
-                if (elapsed == 0)
-                    return;
-
-                m_samples.Enqueue(memoryDiff / (double)elapsed);
-            }
-
-            UpdateLastRecord(memoryNow, now);
-        }
-
-        private static void UpdateLastRecord(long memoryNow, int timeNow)
-        {
-            m_lastUpdateMemory = memoryNow;
-            m_lastUpdateTick = timeNow;
-        }
-    }
-}

OpenSim/Framework/RegionInfo.cs

@@ -120,9 +120,7 @@ namespace OpenSim.Framework
         public UUID lastMapUUID = UUID.Zero;
         public string lastMapRefresh = "0";
 
-        private float m_nonphysPrimMin = 0;
         private int m_nonphysPrimMax = 0;
-        private float m_physPrimMin = 0;
         private int m_physPrimMax = 0;
         private bool m_clampPrimSize = false;
         private int m_objectCapacity = 0;
@@ -287,21 +285,11 @@ namespace OpenSim.Framework
             set { m_windlight = value; }
         }
 
-        public float NonphysPrimMin
-        {
-            get { return m_nonphysPrimMin; }
-        }
-
         public int NonphysPrimMax
         {
             get { return m_nonphysPrimMax; }
         }
 
-        public float PhysPrimMin
-        {
-            get { return m_physPrimMin; }
-        }
-
         public int PhysPrimMax
         {
             get { return m_physPrimMax; }
@@ -492,16 +480,9 @@ namespace OpenSim.Framework
                 MainConsole.Instance.Output("=====================================\n");
 
                 if (name == String.Empty)
-                {
-                    while (name.Trim() == string.Empty)
-                    {
-                        name = MainConsole.Instance.CmdPrompt("New region name", name);
-                        if (name.Trim() == string.Empty)
-                        {
-                            MainConsole.Instance.Output("Cannot interactively create region with no name");
-                        }
-                    }
-                }
+                    name = MainConsole.Instance.CmdPrompt("New region name", name);
+                if (name == String.Empty)
+                    throw new Exception("Cannot interactively create region with no name");
 
                 source.AddConfig(name);
 
@@ -532,20 +513,15 @@ namespace OpenSim.Framework
             //
             allKeys.Remove("RegionUUID");
             string regionUUID = config.GetString("RegionUUID", string.Empty);
-            if (!UUID.TryParse(regionUUID.Trim(), out RegionID))
+            if (regionUUID == String.Empty)
             {
                 UUID newID = UUID.Random();
-                while (RegionID == UUID.Zero)
-                {
-                    regionUUID = MainConsole.Instance.CmdPrompt("RegionUUID", newID.ToString());
-                    if (!UUID.TryParse(regionUUID.Trim(), out RegionID))
-                    {
-                        MainConsole.Instance.Output("RegionUUID must be a valid UUID");
-                    }
-                }
+
+                regionUUID = MainConsole.Instance.CmdPrompt("RegionUUID", newID.ToString());
                 config.Set("RegionUUID", regionUUID);
             }
 
+            RegionID = new UUID(regionUUID);
             originRegionID = RegionID; // What IS this?! (Needed for RegionCombinerModule?)
 
             // Location
@@ -635,28 +611,16 @@ namespace OpenSim.Framework
             m_regionType = config.GetString("RegionType", String.Empty);
             allKeys.Remove("RegionType");
 
-            #region Prim stuff
-
-            m_nonphysPrimMin = config.GetFloat("NonphysicalPrimMin", 0);
-            allKeys.Remove("NonphysicalPrimMin");
-
+            // Prim stuff
+            //
             m_nonphysPrimMax = config.GetInt("NonphysicalPrimMax", 0);
             allKeys.Remove("NonphysicalPrimMax");
-
-            m_physPrimMin = config.GetFloat("PhysicalPrimMin", 0);
-            allKeys.Remove("PhysicalPrimMin");
-
             m_physPrimMax = config.GetInt("PhysicalPrimMax", 0);
             allKeys.Remove("PhysicalPrimMax");
-            
             m_clampPrimSize = config.GetBoolean("ClampPrimSize", false);
             allKeys.Remove("ClampPrimSize");
-            
             m_objectCapacity = config.GetInt("MaxPrims", 15000);
             allKeys.Remove("MaxPrims");
-            
-            #endregion
-
             m_agentCapacity = config.GetInt("MaxAgents", 100);
             allKeys.Remove("MaxAgents");
 
@@ -692,18 +656,10 @@ namespace OpenSim.Framework
 
             config.Set("ExternalHostName", m_externalHostName);
 
-            if (m_nonphysPrimMin != 0)
-                config.Set("NonphysicalPrimMax", m_nonphysPrimMin);
-
             if (m_nonphysPrimMax != 0)
                 config.Set("NonphysicalPrimMax", m_nonphysPrimMax);
-
-            if (m_physPrimMin != 0)
-                config.Set("PhysicalPrimMax", m_physPrimMin);
-            
             if (m_physPrimMax != 0)
                 config.Set("PhysicalPrimMax", m_physPrimMax);
-                        
             config.Set("ClampPrimSize", m_clampPrimSize.ToString());
 
             if (m_objectCapacity != 0)
@@ -786,15 +742,9 @@ namespace OpenSim.Framework
             configMember.addConfigurationOption("lastmap_refresh", ConfigurationOption.ConfigurationTypes.TYPE_STRING_NOT_EMPTY,
                                                 "Last Map Refresh", Util.UnixTimeSinceEpoch().ToString(), true);
 
-            configMember.addConfigurationOption("nonphysical_prim_min", ConfigurationOption.ConfigurationTypes.TYPE_FLOAT,
-                                                "Minimum size for nonphysical prims", m_nonphysPrimMin.ToString(), true);
-
             configMember.addConfigurationOption("nonphysical_prim_max", ConfigurationOption.ConfigurationTypes.TYPE_INT32,
                                                 "Maximum size for nonphysical prims", m_nonphysPrimMax.ToString(), true);
 
-            configMember.addConfigurationOption("physical_prim_min", ConfigurationOption.ConfigurationTypes.TYPE_FLOAT,
-                                                "Minimum size for nonphysical prims", m_physPrimMin.ToString(), true);
-
             configMember.addConfigurationOption("physical_prim_max", ConfigurationOption.ConfigurationTypes.TYPE_INT32,
                                                 "Maximum size for physical prims", m_physPrimMax.ToString(), true);
 

OpenSim/Framework/Serialization/External/LandDataSerializer.cs

@@ -42,7 +42,9 @@ namespace OpenSim.Framework.Serialization.External
     /// </summary>
     public class LandDataSerializer
     {
-//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected static UTF8Encoding m_utf8Encoding = new UTF8Encoding();
 
         private static Dictionary<string, Action<LandData, XmlTextReader>> m_ldProcessors
             = new Dictionary<string, Action<LandData, XmlTextReader>>();
@@ -93,8 +95,6 @@ namespace OpenSim.Framework.Serialization.External
                 "MediaURL",         (ld, xtr) => ld.MediaURL = xtr.ReadElementString("MediaURL"));
             m_ldProcessors.Add(
                 "MusicURL",         (ld, xtr) => ld.MusicURL = xtr.ReadElementString("MusicURL"));
-            m_ldProcessors.Add(
-                "OwnerID",          (ld, xtr) => ld.OwnerID  = UUID.Parse(xtr.ReadElementString("OwnerID")));
 
             m_ldProcessors.Add(
                 "ParcelAccessList", ProcessParcelAccessList);
@@ -163,7 +163,7 @@ namespace OpenSim.Framework.Serialization.External
         /// <exception cref="System.Xml.XmlException"></exception>
         public static LandData Deserialize(byte[] serializedLandData)
         {
-            return Deserialize(Encoding.UTF8.GetString(serializedLandData, 0, serializedLandData.Length));
+            return Deserialize(m_utf8Encoding.GetString(serializedLandData, 0, serializedLandData.Length));
         }
 
         /// <summary>
@@ -188,16 +188,7 @@ namespace OpenSim.Framework.Serialization.External
             return landData;
         }
 
-        /// <summary>
-        /// Serialize land data
-        /// </summary>
-        /// <param name='landData'></param>
-        /// <param name='options'>
-        /// Serialization options.
-        /// Can be null if there are no options.
-        /// "wipe-owners" will write UUID.Zero rather than the ownerID so that a later reload loads all parcels with the estate owner as the owner
-        /// </param>
-        public static string Serialize(LandData landData, Dictionary<string, object> options)
+        public static string Serialize(LandData landData)
         {
             StringWriter sw = new StringWriter();
             XmlTextWriter xtw = new XmlTextWriter(sw);
@@ -226,14 +217,7 @@ namespace OpenSim.Framework.Serialization.External
             xtw.WriteElementString("MediaID",        landData.MediaID.ToString());
             xtw.WriteElementString("MediaURL",       landData.MediaURL);
             xtw.WriteElementString("MusicURL",       landData.MusicURL);
-
-            UUID ownerIdToWrite;
-            if (options != null && options.ContainsKey("wipe-owners"))
-                ownerIdToWrite = UUID.Zero;                
-            else
-                ownerIdToWrite = landData.OwnerID;
-
-            xtw.WriteElementString("OwnerID",        ownerIdToWrite.ToString());
+            xtw.WriteElementString("OwnerID",        landData.OwnerID.ToString());
 
             xtw.WriteStartElement("ParcelAccessList");
             foreach (LandAccessEntry pal in landData.ParcelAccessList)

OpenSim/Framework/Serialization/External/OspResolver.cs

@@ -65,14 +65,9 @@ namespace OpenSim.Framework.Serialization
 
             UserAccount account = userService.GetUserAccount(UUID.Zero, userId);
             if (account != null)
-            {
                 return MakeOspa(account.FirstName, account.LastName);
-            }
 //            else
-//            {
 //                m_log.WarnFormat("[OSP RESOLVER]: No user account for {0}", userId);
-//                System.Console.WriteLine("[OSP RESOLVER]: No user account for {0}", userId);
-//            }
 
             return null;
         }
@@ -84,13 +79,10 @@ namespace OpenSim.Framework.Serialization
         /// <returns></returns>
         public static string MakeOspa(string firstName, string lastName)
         {
-            string ospa
-                = OSPA_PREFIX + OSPA_NAME_KEY + OSPA_PAIR_SEPARATOR + firstName + OSPA_NAME_VALUE_SEPARATOR + lastName;
-
-//            m_log.DebugFormat("[OSP RESOLVER]: Made OSPA {0} for {1} {2}", ospa, firstName, lastName);
-//            System.Console.WriteLine("[OSP RESOLVER]: Made OSPA {0} for {1} {2}", ospa, firstName, lastName);
+//            m_log.DebugFormat("[OSP RESOLVER]: Making OSPA for {0} {1}", firstName, lastName);
             
-            return ospa;
+            return 
+                OSPA_PREFIX + OSPA_NAME_KEY + OSPA_PAIR_SEPARATOR + firstName + OSPA_NAME_VALUE_SEPARATOR + lastName;
         }
         
         /// <summary>

OpenSim/Framework/Serialization/External/RegionSettingsSerializer.cs

@@ -40,6 +40,8 @@ namespace OpenSim.Framework.Serialization.External
     /// </summary>
     public class RegionSettingsSerializer
     {
+        protected static ASCIIEncoding m_asciiEncoding = new ASCIIEncoding();
+        
         /// <summary>
         /// Deserialize settings
         /// </summary>
@@ -48,7 +50,7 @@ namespace OpenSim.Framework.Serialization.External
         /// <exception cref="System.Xml.XmlException"></exception>
         public static RegionSettings Deserialize(byte[] serializedSettings)
         {
-            return Deserialize(Encoding.ASCII.GetString(serializedSettings, 0, serializedSettings.Length));
+            return Deserialize(m_asciiEncoding.GetString(serializedSettings, 0, serializedSettings.Length));
         }
         
         /// <summary>

OpenSim/Framework/Serialization/External/UserInventoryItemSerializer.cs

@@ -44,7 +44,7 @@ namespace OpenSim.Framework.Serialization.External
     /// </summary>
     public class UserInventoryItemSerializer
     {
-//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private static Dictionary<string, Action<InventoryItemBase, XmlTextReader>> m_InventoryItemXmlProcessors
             = new Dictionary<string, Action<InventoryItemBase, XmlTextReader>>();

OpenSim/Framework/Serialization/TarArchiveReader.cs

@@ -53,6 +53,8 @@ namespace OpenSim.Framework.Serialization
             TYPE_CONTIGUOUS_FILE = 8,
         }
 
+        protected static ASCIIEncoding m_asciiEncoding = new ASCIIEncoding();
+
         /// <summary>
         /// Binary reader for the underlying stream
         /// </summary>
@@ -118,13 +120,13 @@ namespace OpenSim.Framework.Serialization
             if (header[156] == (byte)'L')
             {
                 int longNameLength = ConvertOctalBytesToDecimal(header, 124, 11);
-                tarHeader.FilePath = Encoding.ASCII.GetString(ReadData(longNameLength));
+                tarHeader.FilePath = m_asciiEncoding.GetString(ReadData(longNameLength));
                 //m_log.DebugFormat("[TAR ARCHIVE READER]: Got long file name {0}", tarHeader.FilePath);
                 header = m_br.ReadBytes(512);
             }
             else
             {
-                tarHeader.FilePath = Encoding.ASCII.GetString(header, 0, 100);
+                tarHeader.FilePath = m_asciiEncoding.GetString(header, 0, 100);
                 tarHeader.FilePath = tarHeader.FilePath.Trim(m_nullCharArray);
                 //m_log.DebugFormat("[TAR ARCHIVE READER]: Got short file name {0}", tarHeader.FilePath);
             }
@@ -203,7 +205,7 @@ namespace OpenSim.Framework.Serialization
         {
             // Trim leading white space: ancient tars do that instead
             // of leading 0s :-( don't ask. really.
-            string oString = Encoding.ASCII.GetString(bytes, startIndex, count).TrimStart(m_spaceCharArray);
+            string oString = m_asciiEncoding.GetString(bytes, startIndex, count).TrimStart(m_spaceCharArray);
 
             int d = 0;
 

OpenSim/Framework/Serialization/TarArchiveWriter.cs

@@ -41,6 +41,9 @@ namespace OpenSim.Framework.Serialization
     {
 //        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
+        protected static ASCIIEncoding m_asciiEncoding = new ASCIIEncoding();
+        protected static UTF8Encoding m_utf8Encoding = new UTF8Encoding();
+
         /// <summary>
         /// Binary writer for the underlying stream
         /// </summary>
@@ -71,7 +74,7 @@ namespace OpenSim.Framework.Serialization
         /// <param name="data"></param>
         public void WriteFile(string filePath, string data)
         {
-            WriteFile(filePath, Util.UTF8NoBomEncoding.GetBytes(data));
+            WriteFile(filePath, m_utf8Encoding.GetBytes(data));
         }
 
         /// <summary>
@@ -82,7 +85,7 @@ namespace OpenSim.Framework.Serialization
         public void WriteFile(string filePath, byte[] data)
         {
             if (filePath.Length > 100)
-                WriteEntry("././@LongLink", Encoding.ASCII.GetBytes(filePath), 'L');
+                WriteEntry("././@LongLink", m_asciiEncoding.GetBytes(filePath), 'L');
 
             char fileType;
 
@@ -134,7 +137,7 @@ namespace OpenSim.Framework.Serialization
                 oString = "0" + oString;
             }
 
-            byte[] oBytes = Encoding.ASCII.GetBytes(oString);
+            byte[] oBytes = m_asciiEncoding.GetBytes(oString);
 
             return oBytes;
         }
@@ -153,20 +156,20 @@ namespace OpenSim.Framework.Serialization
             byte[] header = new byte[512];
 
             // file path field (100)
-            byte[] nameBytes = Encoding.ASCII.GetBytes(filePath);
+            byte[] nameBytes = m_asciiEncoding.GetBytes(filePath);
             int nameSize = (nameBytes.Length >= 100) ? 100 : nameBytes.Length;
             Array.Copy(nameBytes, header, nameSize);
 
             // file mode (8)
-            byte[] modeBytes = Encoding.ASCII.GetBytes("0000777");
+            byte[] modeBytes = m_asciiEncoding.GetBytes("0000777");
             Array.Copy(modeBytes, 0, header, 100, 7);
 
             // owner user id (8)
-            byte[] ownerIdBytes = Encoding.ASCII.GetBytes("0000764");
+            byte[] ownerIdBytes = m_asciiEncoding.GetBytes("0000764");
             Array.Copy(ownerIdBytes, 0, header, 108, 7);
 
             // group user id (8)
-            byte[] groupIdBytes = Encoding.ASCII.GetBytes("0000764");
+            byte[] groupIdBytes = m_asciiEncoding.GetBytes("0000764");
             Array.Copy(groupIdBytes, 0, header, 116, 7);
 
             // file size in bytes (12)
@@ -178,17 +181,17 @@ namespace OpenSim.Framework.Serialization
             Array.Copy(fileSizeBytes, 0, header, 124, 11);
 
             // last modification time (12)
-            byte[] lastModTimeBytes = Encoding.ASCII.GetBytes("11017037332");
+            byte[] lastModTimeBytes = m_asciiEncoding.GetBytes("11017037332");
             Array.Copy(lastModTimeBytes, 0, header, 136, 11);
 
             // entry type indicator (1)
-            header[156] = Encoding.ASCII.GetBytes(new char[] { fileType })[0];
+            header[156] = m_asciiEncoding.GetBytes(new char[] { fileType })[0];
 
-            Array.Copy(Encoding.ASCII.GetBytes("0000000"), 0, header, 329, 7);
-            Array.Copy(Encoding.ASCII.GetBytes("0000000"), 0, header, 337, 7);
+            Array.Copy(m_asciiEncoding.GetBytes("0000000"), 0, header, 329, 7);
+            Array.Copy(m_asciiEncoding.GetBytes("0000000"), 0, header, 337, 7);
 
             // check sum for header block (8) [calculated last]
-            Array.Copy(Encoding.ASCII.GetBytes("        "), 0, header, 148, 8);
+            Array.Copy(m_asciiEncoding.GetBytes("        "), 0, header, 148, 8);
 
             int checksum = 0;
             foreach (byte b in header)

OpenSim/Framework/Serialization/Tests/LandDataSerializerTests.cs

@@ -42,23 +42,22 @@ namespace OpenSim.Framework.Serialization.Tests
         private LandData land;
         private LandData landWithParcelAccessList;
 
-//        private static string preSerialized = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\n<LandData>\n  <Area>128</Area>\n  <AuctionID>0</AuctionID>\n  <AuthBuyerID>00000000-0000-0000-0000-000000000000</AuthBuyerID>\n  <Category>10</Category>\n  <ClaimDate>0</ClaimDate>\n  <ClaimPrice>0</ClaimPrice>\n  <GlobalID>54ff9641-dd40-4a2c-b1f1-47dd3af24e50</GlobalID>\n  <GroupID>d740204e-bbbf-44aa-949d-02c7d739f6a5</GroupID>\n  <IsGroupOwned>False</IsGroupOwned>\n  <Bitmap>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</Bitmap>\n  <Description>land data to test LandDataSerializer</Description>\n  <Flags>536870944</Flags>\n  <LandingType>2</LandingType>\n  <Name>LandDataSerializerTest Land</Name>\n  <Status>0</Status>\n  <LocalID>0</LocalID>\n  <MediaAutoScale>1</MediaAutoScale>\n  <MediaID>d4452578-2f25-4b97-a81b-819af559cfd7</MediaID>\n  <MediaURL>http://videos.opensimulator.org/bumblebee.mp4</MediaURL>\n  <MusicURL />\n  <OwnerID>1b8eedf9-6d15-448b-8015-24286f1756bf</OwnerID>\n  <ParcelAccessList />\n  <PassHours>0</PassHours>\n  <PassPrice>0</PassPrice>\n  <SalePrice>0</SalePrice>\n  <SnapshotID>00000000-0000-0000-0000-000000000000</SnapshotID>\n  <UserLocation>&lt;0, 0, 0&gt;</UserLocation>\n  <UserLookAt>&lt;0, 0, 0&gt;</UserLookAt>\n  <Dwell>0</Dwell>\n  <OtherCleanTime>0</OtherCleanTime>\n</LandData>";
-        private static string preSerializedWithParcelAccessList
-            = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\n<LandData>\n  <Area>128</Area>\n  <AuctionID>0</AuctionID>\n  <AuthBuyerID>00000000-0000-0000-0000-000000000000</AuthBuyerID>\n  <Category>10</Category>\n  <ClaimDate>0</ClaimDate>\n  <ClaimPrice>0</ClaimPrice>\n  <GlobalID>54ff9641-dd40-4a2c-b1f1-47dd3af24e50</GlobalID>\n  <GroupID>d740204e-bbbf-44aa-949d-02c7d739f6a5</GroupID>\n  <IsGroupOwned>False</IsGroupOwned>\n  <Bitmap>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</Bitmap>\n  <Description>land data to test LandDataSerializer</Description>\n  <Flags>536870944</Flags>\n  <LandingType>2</LandingType>\n  <Name>LandDataSerializerTest Land</Name>\n  <Status>0</Status>\n  <LocalID>0</LocalID>\n  <MediaAutoScale>1</MediaAutoScale>\n  <MediaID>d4452578-2f25-4b97-a81b-819af559cfd7</MediaID>\n  <MediaURL>http://videos.opensimulator.org/bumblebee.mp4</MediaURL>\n  <MusicURL />\n  <OwnerID>1b8eedf9-6d15-448b-8015-24286f1756bf</OwnerID>\n  <ParcelAccessList>\n    <ParcelAccessEntry>\n      <AgentID>62d65d45-c91a-4f77-862c-46557d978b6c</AgentID>\n      <Time>0</Time>\n      <AccessList>2</AccessList>\n    </ParcelAccessEntry>\n    <ParcelAccessEntry>\n      <AgentID>ec2a8d18-2378-4fe0-8b68-2a31b57c481e</AgentID>\n      <Time>0</Time>\n      <AccessList>1</AccessList>\n    </ParcelAccessEntry>\n  </ParcelAccessList>\n  <PassHours>0</PassHours>\n  <PassPrice>0</PassPrice>\n  <SalePrice>0</SalePrice>\n  <SnapshotID>00000000-0000-0000-0000-000000000000</SnapshotID>\n  <UserLocation>&lt;0, 0, 0&gt;</UserLocation>\n  <UserLookAt>&lt;0, 0, 0&gt;</UserLookAt>\n  <Dwell>0</Dwell>\n  <OtherCleanTime>0</OtherCleanTime>\n</LandData>";
+        private static string preSerialized = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\n<LandData>\n  <Area>128</Area>\n  <AuctionID>0</AuctionID>\n  <AuthBuyerID>00000000-0000-0000-0000-000000000000</AuthBuyerID>\n  <Category>10</Category>\n  <ClaimDate>0</ClaimDate>\n  <ClaimPrice>0</ClaimPrice>\n  <GlobalID>54ff9641-dd40-4a2c-b1f1-47dd3af24e50</GlobalID>\n  <GroupID>d740204e-bbbf-44aa-949d-02c7d739f6a5</GroupID>\n  <IsGroupOwned>False</IsGroupOwned>\n  <Bitmap>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</Bitmap>\n  <Description>land data to test LandDataSerializer</Description>\n  <Flags>536870944</Flags>\n  <LandingType>2</LandingType>\n  <Name>LandDataSerializerTest Land</Name>\n  <Status>0</Status>\n  <LocalID>0</LocalID>\n  <MediaAutoScale>1</MediaAutoScale>\n  <MediaID>d4452578-2f25-4b97-a81b-819af559cfd7</MediaID>\n  <MediaURL>http://videos.opensimulator.org/bumblebee.mp4</MediaURL>\n  <MusicURL />\n  <OwnerID>1b8eedf9-6d15-448b-8015-24286f1756bf</OwnerID>\n  <ParcelAccessList />\n  <PassHours>0</PassHours>\n  <PassPrice>0</PassPrice>\n  <SalePrice>0</SalePrice>\n  <SnapshotID>00000000-0000-0000-0000-000000000000</SnapshotID>\n  <UserLocation>&lt;0, 0, 0&gt;</UserLocation>\n  <UserLookAt>&lt;0, 0, 0&gt;</UserLookAt>\n  <Dwell>0</Dwell>\n  <OtherCleanTime>0</OtherCleanTime>\n</LandData>";
+        private static string preSerializedWithParcelAccessList = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\n<LandData>\n  <Area>128</Area>\n  <AuctionID>0</AuctionID>\n  <AuthBuyerID>00000000-0000-0000-0000-000000000000</AuthBuyerID>\n  <Category>10</Category>\n  <ClaimDate>0</ClaimDate>\n  <ClaimPrice>0</ClaimPrice>\n  <GlobalID>54ff9641-dd40-4a2c-b1f1-47dd3af24e50</GlobalID>\n  <GroupID>d740204e-bbbf-44aa-949d-02c7d739f6a5</GroupID>\n  <IsGroupOwned>False</IsGroupOwned>\n  <Bitmap>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</Bitmap>\n  <Description>land data to test LandDataSerializer</Description>\n  <Flags>536870944</Flags>\n  <LandingType>2</LandingType>\n  <Name>LandDataSerializerTest Land</Name>\n  <Status>0</Status>\n  <LocalID>0</LocalID>\n  <MediaAutoScale>1</MediaAutoScale>\n  <MediaID>d4452578-2f25-4b97-a81b-819af559cfd7</MediaID>\n  <MediaURL>http://videos.opensimulator.org/bumblebee.mp4</MediaURL>\n  <MusicURL />\n  <OwnerID>1b8eedf9-6d15-448b-8015-24286f1756bf</OwnerID>\n  <ParcelAccessList>\n    <ParcelAccessEntry>\n      <AgentID>62d65d45-c91a-4f77-862c-46557d978b6c</AgentID>\n      <Time>0</Time>\n      <AccessList>2</AccessList>\n    </ParcelAccessEntry>\n    <ParcelAccessEntry>\n      <AgentID>ec2a8d18-2378-4fe0-8b68-2a31b57c481e</AgentID>\n      <Time>0</Time>\n      <AccessList>1</AccessList>\n    </ParcelAccessEntry>\n  </ParcelAccessList>\n  <PassHours>0</PassHours>\n  <PassPrice>0</PassPrice>\n  <SalePrice>0</SalePrice>\n  <SnapshotID>00000000-0000-0000-0000-000000000000</SnapshotID>\n  <UserLocation>&lt;0, 0, 0&gt;</UserLocation>\n  <UserLookAt>&lt;0, 0, 0&gt;</UserLookAt>\n  <Dwell>0</Dwell>\n  <OtherCleanTime>0</OtherCleanTime>\n</LandData>";  
 
         [SetUp]
         public void setup()
         {
             // setup LandData object
             this.land = new LandData();
-            this.land.AABBMax = new Vector3(1, 2, 3);
-            this.land.AABBMin = new Vector3(129, 130, 131);
+            this.land.AABBMax = new Vector3(0, 0, 0);
+            this.land.AABBMin = new Vector3(128, 128, 128);
             this.land.Area = 128;
-            this.land.AuctionID = 4;
-            this.land.AuthBuyerID = new UUID("7176df0c-6c50-45db-8a37-5e78be56a0cd");
+            this.land.AuctionID = 0;
+            this.land.AuthBuyerID = new UUID();
             this.land.Category = ParcelCategory.Residential;
-            this.land.ClaimDate = 1;
-            this.land.ClaimPrice = 2;
+            this.land.ClaimDate = 0;
+            this.land.ClaimPrice = 0;
             this.land.GlobalID = new UUID("54ff9641-dd40-4a2c-b1f1-47dd3af24e50");
             this.land.GroupID = new UUID("d740204e-bbbf-44aa-949d-02c7d739f6a5");
             this.land.Description = "land data to test LandDataSerializer";
@@ -66,7 +65,7 @@ namespace OpenSim.Framework.Serialization.Tests
             this.land.LandingType = (byte)LandingType.Direct;
             this.land.Name = "LandDataSerializerTest Land";
             this.land.Status = ParcelStatus.Leased;
-            this.land.LocalID = 1;
+            this.land.LocalID = 0;
             this.land.MediaAutoScale = (byte)0x01;
             this.land.MediaID = new UUID("d4452578-2f25-4b97-a81b-819af559cfd7");
             this.land.MediaURL = "http://videos.opensimulator.org/bumblebee.mp4";
@@ -91,26 +90,26 @@ namespace OpenSim.Framework.Serialization.Tests
         /// <summary>
         /// Test the LandDataSerializer.Serialize() method
         /// </summary>
-//        [Test]
-//        public void LandDataSerializerSerializeTest()
-//        {
-//            TestHelpers.InMethod();
-//
-//            string serialized = LandDataSerializer.Serialize(this.land).Replace("\r\n", "\n");
-//            Assert.That(serialized.Length > 0, "Serialize(LandData) returned empty string");
-//
-//            // adding a simple boolean variable because resharper nUnit integration doesn't like this
-//            // XML data in the Assert.That statement.   Not sure why.
-//            bool result = (serialized == preSerialized);
-//            Assert.That(result, "result of Serialize LandData  does not match expected result");
-//
-//            string serializedWithParcelAccessList = LandDataSerializer.Serialize(this.landWithParcelAccessList).Replace("\r\n", "\n");
-//            Assert.That(serializedWithParcelAccessList.Length > 0,
-//                        "Serialize(LandData) returned empty string for LandData object with ParcelAccessList");
-//            result = (serializedWithParcelAccessList == preSerializedWithParcelAccessList);
-//            Assert.That(result,
-//                        "result of Serialize(LandData) does not match expected result (pre-serialized with parcel access list");
-//        }
+        [Test]
+        public void LandDataSerializerSerializeTest()
+        {
+            TestHelpers.InMethod();
+
+            string serialized = LandDataSerializer.Serialize(this.land).Replace("\r\n", "\n");
+            Assert.That(serialized.Length > 0, "Serialize(LandData) returned empty string");
+
+            // adding a simple boolean variable because resharper nUnit integration doesn't like this
+            // XML data in the Assert.That statement.   Not sure why.
+            bool result = (serialized == preSerialized);
+            Assert.That(result, "result of Serialize LandData  does not match expected result");
+
+            string serializedWithParcelAccessList = LandDataSerializer.Serialize(this.landWithParcelAccessList).Replace("\r\n", "\n");
+            Assert.That(serializedWithParcelAccessList.Length > 0,
+                        "Serialize(LandData) returned empty string for LandData object with ParcelAccessList");
+            result = (serializedWithParcelAccessList == preSerializedWithParcelAccessList);
+            Assert.That(result,
+                        "result of Serialize(LandData) does not match expected result (pre-serialized with parcel access list");
+        }
 
         /// <summary>
         /// Test the LandDataSerializer.Deserialize() method
@@ -121,28 +120,10 @@ namespace OpenSim.Framework.Serialization.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
 
-            LandData ld = LandDataSerializer.Deserialize(LandDataSerializer.Serialize(this.land, null));
-            Assert.That(ld, Is.Not.Null, "Deserialize(string) returned null");
-//            Assert.That(ld.AABBMax, Is.EqualTo(land.AABBMax));
-//            Assert.That(ld.AABBMin, Is.EqualTo(land.AABBMin));
-            Assert.That(ld.Area, Is.EqualTo(land.Area));
-            Assert.That(ld.AuctionID, Is.EqualTo(land.AuctionID));
-            Assert.That(ld.AuthBuyerID, Is.EqualTo(land.AuthBuyerID));
-            Assert.That(ld.Category, Is.EqualTo(land.Category));
-            Assert.That(ld.ClaimDate, Is.EqualTo(land.ClaimDate));
-            Assert.That(ld.ClaimPrice, Is.EqualTo(land.ClaimPrice));
-            Assert.That(ld.GlobalID, Is.EqualTo(land.GlobalID), "Reified LandData.GlobalID != original LandData.GlobalID");
-            Assert.That(ld.GroupID, Is.EqualTo(land.GroupID));
-            Assert.That(ld.Description, Is.EqualTo(land.Description));
-            Assert.That(ld.Flags, Is.EqualTo(land.Flags));
-            Assert.That(ld.LandingType, Is.EqualTo(land.LandingType));
-            Assert.That(ld.Name, Is.EqualTo(land.Name), "Reified LandData.Name != original LandData.Name");
-            Assert.That(ld.Status, Is.EqualTo(land.Status));
-            Assert.That(ld.LocalID, Is.EqualTo(land.LocalID));
-            Assert.That(ld.MediaAutoScale, Is.EqualTo(land.MediaAutoScale));
-            Assert.That(ld.MediaID, Is.EqualTo(land.MediaID));
-            Assert.That(ld.MediaURL, Is.EqualTo(land.MediaURL));
-            Assert.That(ld.OwnerID, Is.EqualTo(land.OwnerID));
+            LandData ld = LandDataSerializer.Deserialize(LandDataSerializerTest.preSerialized);
+            Assert.That(ld != null, "Deserialize(string) returned null");
+            Assert.That(ld.GlobalID == this.land.GlobalID, "Reified LandData.GlobalID != original LandData.GlobalID");
+            Assert.That(ld.Name == this.land.Name, "Reified LandData.Name != original LandData.Name");
         }
 
         [Test]

OpenSim/Framework/Servers/BaseOpenSimServer.cs

@@ -40,9 +40,9 @@ using log4net.Core;
 using log4net.Repository;
 using OpenSim.Framework;
 using OpenSim.Framework.Console;
-using OpenSim.Framework.Monitoring;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Framework.Statistics;
 using Timer=System.Timers.Timer;
 
 using OpenMetaverse;
@@ -320,9 +320,7 @@ namespace OpenSim.Framework.Servers
             
             TimeSpan timeTaken = DateTime.Now - m_startuptime;
             
-            m_log.InfoFormat(
-                "[STARTUP]: Non-script portion of startup took {0}m {1}s.  PLEASE WAIT FOR LOGINS TO BE ENABLED ON REGIONS ONCE SCRIPTS HAVE STARTED.",
-                timeTaken.Minutes, timeTaken.Seconds);
+            m_log.InfoFormat("[STARTUP]: Startup took {0}m {1}s", timeTaken.Minutes, timeTaken.Seconds);
         }
 
         /// <summary>
@@ -591,8 +589,8 @@ namespace OpenSim.Framework.Servers
             {
                 string pidstring = System.Diagnostics.Process.GetCurrentProcess().Id.ToString();
                 FileStream fs = File.Create(path);
-
-                Byte[] buf = Encoding.ASCII.GetBytes(pidstring);
+                System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
+                Byte[] buf = enc.GetBytes(pidstring);
                 fs.Write(buf, 0, buf.Length);
                 fs.Close();
                 m_pidFile = path;

OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs

@@ -45,7 +45,6 @@ using OpenMetaverse.StructuredData;
 using CoolHTTPListener = HttpServer.HttpListener;
 using HttpListener=System.Net.HttpListener;
 using LogPrio=HttpServer.LogPrio;
-using OpenSim.Framework.Monitoring;
 
 namespace OpenSim.Framework.Servers.HttpServer
 {
@@ -1558,9 +1557,6 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         private void StartHTTP()
         {
-            m_log.InfoFormat(
-                "[BASE HTTP SERVER]: Starting {0} server on port {1}", UseSSL ? "HTTPS" : "HTTP", Port);
-
             try
             {
                 //m_httpListener = new HttpListener();

OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs

@@ -28,7 +28,6 @@
 using System;
 using System.Collections;
 using OpenMetaverse;
-
 namespace OpenSim.Framework.Servers.HttpServer
 {
     public delegate void RequestMethod(UUID requestID, Hashtable request);
@@ -45,11 +44,7 @@ namespace OpenSim.Framework.Servers.HttpServer
         public NoEventsMethod NoEvents;
         public RequestMethod Request;
         public UUID Id;
-
-        public PollServiceEventArgs(
-            RequestMethod pRequest,
-            HasEventsMethod pHasEvents, GetEventsMethod pGetEvents, NoEventsMethod pNoEvents,
-            UUID pId)
+        public PollServiceEventArgs(RequestMethod pRequest, HasEventsMethod pHasEvents, GetEventsMethod pGetEvents, NoEventsMethod pNoEvents,UUID pId)
         {
             Request = pRequest;
             HasEvents = pHasEvents;
@@ -58,4 +53,4 @@ namespace OpenSim.Framework.Servers.HttpServer
             Id = pId;
         }
     }
-}
+}

OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs

@@ -31,6 +31,7 @@ using OpenMetaverse;
 
 namespace OpenSim.Framework.Servers.HttpServer
 {
+
     public class PollServiceHttpRequest
     {
         public readonly PollServiceEventArgs PollServiceArgs;
@@ -38,9 +39,7 @@ namespace OpenSim.Framework.Servers.HttpServer
         public readonly IHttpRequest Request;
         public readonly int RequestTime;
         public readonly UUID RequestID;
-
-        public PollServiceHttpRequest(
-            PollServiceEventArgs pPollServiceArgs, IHttpClientContext pHttpContext, IHttpRequest pRequest)
+        public PollServiceHttpRequest(PollServiceEventArgs pPollServiceArgs, IHttpClientContext pHttpContext, IHttpRequest pRequest)
         {
             PollServiceArgs = pPollServiceArgs;
             HttpContext = pHttpContext;
@@ -49,4 +48,4 @@ namespace OpenSim.Framework.Servers.HttpServer
             RequestID = UUID.Random();
         }
     }
-}
+}

OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs

@@ -32,7 +32,6 @@ using System.Reflection;
 using log4net;
 using HttpServer;
 using OpenSim.Framework;
-using OpenSim.Framework.Monitoring;
 
 namespace OpenSim.Framework.Servers.HttpServer
 {

OpenSim/Framework/Servers/HttpServer/PollServiceWorkerThread.cs

@@ -34,7 +34,6 @@ using HttpServer;
 using OpenMetaverse;
 using System.Reflection;
 using log4net;
-using OpenSim.Framework.Monitoring;
 
 namespace OpenSim.Framework.Servers.HttpServer
 {
@@ -130,7 +129,9 @@ namespace OpenSim.Framework.Servers.HttpServer
             OSHttpResponse response
                 = new OSHttpResponse(new HttpResponse(req.HttpContext, req.Request), req.HttpContext);
 
-            byte[] buffer = server.DoHTTPGruntWork(responsedata, response);
+            byte[] buffer
+                = server.DoHTTPGruntWork(
+                    responsedata, new OSHttpResponse(new HttpResponse(req.HttpContext, req.Request), req.HttpContext));
 
             response.SendChunked = false;
             response.ContentLength64 = buffer.Length;

OpenSim/Framework/Servers/MainServer.cs

@@ -30,15 +30,13 @@ using System.Collections.Generic;
 using System.Reflection;
 using System.Net;
 using log4net;
-using OpenSim.Framework;
-using OpenSim.Framework.Console;
 using OpenSim.Framework.Servers.HttpServer;
 
 namespace OpenSim.Framework.Servers
 {
     public class MainServer
     {
-//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private static BaseHttpServer instance = null;
         private static Dictionary<uint, BaseHttpServer> m_Servers = new Dictionary<uint, BaseHttpServer>();
@@ -89,57 +87,6 @@ namespace OpenSim.Framework.Servers
             }
         }
 
-        /// <summary>
-        /// Get all the registered servers.
-        /// </summary>
-        /// <remarks>
-        /// Returns a copy of the dictionary so this can be iterated through without locking.
-        /// </remarks>
-        /// <value></value>
-        public static Dictionary<uint, BaseHttpServer> Servers
-        {
-            get { return new Dictionary<uint, BaseHttpServer>(m_Servers); }
-        }
-
-
-        public static void RegisterHttpConsoleCommands(ICommandConsole console)
-        {
-            console.Commands.AddCommand(
-                "Debug", false, "debug http", "debug http [<level>]",
-                "Turn on inbound non-poll http request debugging.",
-                  "If level <= 0, then no extra logging is done.\n"
-                + "If level >= 1, then short warnings are logged when receiving bad input data.\n"
-                + "If level >= 2, then long warnings are logged when receiving bad input data.\n"
-                + "If level >= 3, then short notices about all incoming non-poll HTTP requests are logged.\n"
-                + "If no level is specified then the current level is returned.",
-                HandleDebugHttpCommand);
-        }
-
-        /// <summary>
-        /// Turn on some debugging values for OpenSim.
-        /// </summary>
-        /// <param name="args"></param>
-        private static void HandleDebugHttpCommand(string module, string[] args)
-        {
-            if (args.Length == 3)
-            {
-                int newDebug;
-                if (int.TryParse(args[2], out newDebug))
-                {
-                    MainServer.DebugLevel = newDebug;
-                    MainConsole.Instance.OutputFormat("Debug http level set to {0}", newDebug);
-                }
-            }
-            else if (args.Length == 2)
-            {
-                MainConsole.Instance.OutputFormat("Current debug http level is {0}", MainServer.DebugLevel);
-            }
-            else
-            {
-                MainConsole.Instance.Output("Usage: debug http 0..3");
-            }
-        }
-
         /// <summary>
         /// Register an already started HTTP server to the collection of known servers.
         /// </summary>
@@ -224,10 +171,11 @@ namespace OpenSim.Framework.Servers
                 if (ipaddr != null)
                     m_Servers[port].ListenIPAddress = ipaddr;
 
+                m_log.InfoFormat("[MAIN HTTP SERVER]: Starting main http server on port {0}", port);
                 m_Servers[port].Start();
-
-                return m_Servers[port];
             }
+
+            return m_Servers[port];
         }
     }
 }

OpenSim/Framework/Servers/VersionInfo.cs

@@ -29,7 +29,7 @@ namespace OpenSim
 {
     public class VersionInfo
     {
-        private const string VERSION_NUMBER = "0.7.5";
+        private const string VERSION_NUMBER = "0.7.4";
         private const Flavour VERSION_FLAVOUR = Flavour.Dev;
 
         public enum Flavour

OpenSim/Framework/Statistics/AssetStatsCollector.cs

@@ -28,7 +28,7 @@
 using System;
 using System.Timers;
 
-namespace OpenSim.Framework.Monitoring
+namespace OpenSim.Framework.Statistics
 {
     /// <summary>
     /// Asset service statistics collection

OpenSim/Framework/Statistics/BaseStatsCollector.cs

@@ -31,7 +31,8 @@ using System.Text;
 using OpenMetaverse;
 using OpenMetaverse.StructuredData;
 
-namespace OpenSim.Framework.Monitoring
+
+namespace OpenSim.Framework.Statistics
 {
     /// <summary>
     /// Statistics which all collectors are interested in reporting
@@ -43,18 +44,14 @@ namespace OpenSim.Framework.Monitoring
             StringBuilder sb = new StringBuilder(Environment.NewLine);
             sb.Append("MEMORY STATISTICS");
             sb.Append(Environment.NewLine);
-
-            sb.AppendFormat(
-                "Allocated to OpenSim objects: {0} MB\n",
-                Math.Round(GC.GetTotalMemory(false) / 1024.0 / 1024.0));
-
-            sb.AppendFormat(
-                "OpenSim object memory churn : {0} MB/s\n",
-                Math.Round((MemoryWatchdog.AverageMemoryChurn * 1000) / 1024.0 / 1024, 3));
-
-            sb.AppendFormat(
-                "Process memory              : {0} MB\n",
-                Math.Round(Process.GetCurrentProcess().WorkingSet64 / 1024.0 / 1024.0));
+            sb.Append(
+                string.Format(
+                    "Allocated to OpenSim objects: {0} MB\n",
+                    Math.Round(GC.GetTotalMemory(false) / 1024.0 / 1024.0)));
+            sb.Append(
+                string.Format(
+                    "Process memory              : {0} MB\n",
+                    Math.Round(Process.GetCurrentProcess().WorkingSet64 / 1024.0 / 1024.0)));
 
             return sb.ToString();
         }

OpenSim/Framework/Statistics/Interfaces/IPullStatsProvider.cs

@@ -25,7 +25,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-namespace OpenSim.Framework.Monitoring.Interfaces
+namespace OpenSim.Framework.Statistics.Interfaces
 {
     /// <summary>
     /// Implemented by objects which allow statistical information to be pulled from them.

OpenSim/Framework/Statistics/Interfaces/IStatsCollector.cs

@@ -25,7 +25,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-namespace OpenSim.Framework.Monitoring
+namespace OpenSim.Framework.Statistics
 {
     /// <summary>
     /// Implemented by classes which collect up non-viewer statistical information

OpenSim/Framework/Statistics/SimExtraStatsCollector.cs

@@ -28,11 +28,12 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using OpenMetaverse;
-using OpenMetaverse.StructuredData;
-using OpenSim.Framework.Monitoring.Interfaces;
 
-namespace OpenSim.Framework.Monitoring
+using OpenMetaverse;
+using OpenSim.Framework.Statistics.Interfaces;
+using OpenMetaverse.StructuredData;
+
+namespace OpenSim.Framework.Statistics
 {
     /// <summary>
     /// Collects sim statistics which aren't already being collected for the linden viewer's statistics pane

OpenSim/Framework/Statistics/StatsManager.cs

@@ -25,7 +25,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-namespace OpenSim.Framework.Monitoring
+namespace OpenSim.Framework.Statistics
 {
     /// <summary>
     /// Singleton used to provide access to statistics reporters

OpenSim/Framework/Statistics/UserStatsCollector.cs

@@ -27,7 +27,7 @@
 
 using System.Timers;
 
-namespace OpenSim.Framework.Monitoring
+namespace OpenSim.Framework.Statistics
 {
     /// <summary>
     /// Collects user service statistics

OpenSim/Framework/TaskInventoryItem.cs

@@ -73,9 +73,6 @@ namespace OpenSim.Framework
 
         private bool _ownerChanged = false;
 
-        // This used ONLY during copy. It can't be relied on at other times!
-        private bool _scriptRunning = true;
-
         public UUID AssetID {
             get {
                 return _assetID;
@@ -353,15 +350,6 @@ namespace OpenSim.Framework
             }
         }
 
-        public bool ScriptRunning {
-            get {
-                return _scriptRunning;
-            }
-            set {
-                _scriptRunning = value;
-            }
-        }
-
         // See ICloneable
 
         #region ICloneable Members

OpenSim/Framework/Util.cs

@@ -148,7 +148,6 @@ namespace OpenSim.Framework
         }
 
         public static Encoding UTF8 = Encoding.UTF8;
-        public static Encoding UTF8NoBomEncoding = new UTF8Encoding(false);
 
         /// <value>
         /// Well known UUID for the blank texture used in the Linden SL viewer version 1.20 (and hopefully onwards) 
@@ -850,12 +849,6 @@ namespace OpenSim.Framework
             return Math.Min(Math.Max(x, min), max);
         }
 
-        public static Vector3 Clip(Vector3 vec, float min, float max)
-        {
-            return new Vector3(Clip(vec.X, min, max), Clip(vec.Y, min, max),
-                Clip(vec.Z, min, max));
-        }
-
         /// <summary>
         /// Convert an UUID to a raw uuid string.  Right now this is a string without hyphens.
         /// </summary>
@@ -1243,7 +1236,8 @@ namespace OpenSim.Framework
 
         public static string Base64ToString(string str)
         {
-            Decoder utf8Decode = Encoding.UTF8.GetDecoder();
+            UTF8Encoding encoder = new UTF8Encoding();
+            Decoder utf8Decode = encoder.GetDecoder();
 
             byte[] todecode_byte = Convert.FromBase64String(str);
             int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);

OpenSim/Framework/Watchdog.cs

@@ -31,7 +31,7 @@ using System.Linq;
 using System.Threading;
 using log4net;
 
-namespace OpenSim.Framework.Monitoring
+namespace OpenSim.Framework
 {
     /// <summary>
     /// Manages launching threads and keeping watch over them for timeouts
@@ -41,8 +41,8 @@ namespace OpenSim.Framework.Monitoring
         /// <summary>Timer interval in milliseconds for the watchdog timer</summary>
         const double WATCHDOG_INTERVAL_MS = 2500.0d;
 
-        /// <summary>Default timeout in milliseconds before a thread is considered dead</summary>
-        public const int DEFAULT_WATCHDOG_TIMEOUT_MS = 5000;
+        /// <summary>Maximum timeout in milliseconds before a thread is considered dead</summary>
+        public const int WATCHDOG_TIMEOUT_MS = 5000;
 
         [System.Diagnostics.DebuggerDisplay("{Thread.Name}")]
         public class ThreadWatchdogInfo
@@ -89,17 +89,6 @@ namespace OpenSim.Framework.Monitoring
                 FirstTick = Environment.TickCount & Int32.MaxValue;
                 LastTick = FirstTick;
             }
-
-            public ThreadWatchdogInfo(ThreadWatchdogInfo previousTwi)
-            {
-                Thread = previousTwi.Thread;
-                FirstTick = previousTwi.FirstTick;
-                LastTick = previousTwi.LastTick;
-                Timeout = previousTwi.Timeout;
-                IsTimedOut = previousTwi.IsTimedOut;
-                AlarmIfTimeout = previousTwi.AlarmIfTimeout;
-                AlarmMethod = previousTwi.AlarmMethod;
-            }
         }
 
         /// <summary>
@@ -108,50 +97,17 @@ namespace OpenSim.Framework.Monitoring
         /// /summary>
         public static event Action<ThreadWatchdogInfo> OnWatchdogTimeout;
 
-        /// <summary>
-        /// Is this watchdog active?
-        /// </summary>
-        public static bool Enabled
-        {
-            get { return m_enabled; }
-            set
-            {
-//                m_log.DebugFormat("[MEMORY WATCHDOG]: Setting MemoryWatchdog.Enabled to {0}", value);
-
-                if (value == m_enabled)
-                    return;
-
-                m_enabled = value;
-
-                if (m_enabled)
-                {
-                    // Set now so we don't get alerted on the first run
-                    LastWatchdogThreadTick = Environment.TickCount & Int32.MaxValue;
-                }
-
-                m_watchdogTimer.Enabled = m_enabled;
-            }
-        }
-        private static bool m_enabled;
-
         private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
         private static Dictionary<int, ThreadWatchdogInfo> m_threads;
         private static System.Timers.Timer m_watchdogTimer;
 
-        /// <summary>
-        /// Last time the watchdog thread ran.
-        /// </summary>
-        /// <remarks>
-        /// Should run every WATCHDOG_INTERVAL_MS
-        /// </remarks>
-        public static int LastWatchdogThreadTick { get; private set; }
-
         static Watchdog()
         {
             m_threads = new Dictionary<int, ThreadWatchdogInfo>();
             m_watchdogTimer = new System.Timers.Timer(WATCHDOG_INTERVAL_MS);
             m_watchdogTimer.AutoReset = false;
             m_watchdogTimer.Elapsed += WatchdogTimerElapsed;
+            m_watchdogTimer.Start();
         }
 
         /// <summary>
@@ -166,7 +122,7 @@ namespace OpenSim.Framework.Monitoring
         public static Thread StartThread(
             ThreadStart start, string name, ThreadPriority priority, bool isBackground, bool alarmIfTimeout)
         {
-            return StartThread(start, name, priority, isBackground, alarmIfTimeout, null, DEFAULT_WATCHDOG_TIMEOUT_MS);
+            return StartThread(start, name, priority, isBackground, alarmIfTimeout, null, WATCHDOG_TIMEOUT_MS);
         }
 
         /// <summary>
@@ -308,16 +264,6 @@ namespace OpenSim.Framework.Monitoring
         /// <param name="e"></param>
         private static void WatchdogTimerElapsed(object sender, System.Timers.ElapsedEventArgs e)
         {
-            int now = Environment.TickCount & Int32.MaxValue;
-            int msElapsed = now - LastWatchdogThreadTick;
-
-            if (msElapsed > WATCHDOG_INTERVAL_MS * 2)
-                m_log.WarnFormat(
-                    "[WATCHDOG]: {0} ms since Watchdog last ran.  Interval should be approximately {1} ms",
-                    msElapsed, WATCHDOG_INTERVAL_MS);
-
-            LastWatchdogThreadTick = Environment.TickCount & Int32.MaxValue;
-
             Action<ThreadWatchdogInfo> callback = OnWatchdogTimeout;
 
             if (callback != null)
@@ -326,6 +272,8 @@ namespace OpenSim.Framework.Monitoring
 
                 lock (m_threads)
                 {
+                    int now = Environment.TickCount & Int32.MaxValue;
+
                     foreach (ThreadWatchdogInfo threadInfo in m_threads.Values)
                     {
                         if (threadInfo.Thread.ThreadState == ThreadState.Stopped)
@@ -346,9 +294,7 @@ namespace OpenSim.Framework.Monitoring
                                 if (callbackInfos == null)
                                     callbackInfos = new List<ThreadWatchdogInfo>();
 
-                                // Send a copy of the watchdog info to prevent race conditions where the watchdog
-                                // thread updates the monitoring info after an alarm has been sent out.
-                                callbackInfos.Add(new ThreadWatchdogInfo(threadInfo));
+                                callbackInfos.Add(threadInfo);
                             }
                         }
                     }
@@ -359,9 +305,6 @@ namespace OpenSim.Framework.Monitoring
                         callback(callbackInfo);
             }
 
-            if (MemoryWatchdog.Enabled)
-                MemoryWatchdog.Update();
-
             m_watchdogTimer.Start();
         }
     }

OpenSim/Region/Application/Application.cs

@@ -92,14 +92,9 @@ namespace OpenSim
                 m_log.Info("[OPENSIM MAIN]: configured log4net using default OpenSim.exe.config");
             }
 
-            m_log.InfoFormat(
+            m_log.DebugFormat(
                 "[OPENSIM MAIN]: System Locale is {0}", System.Threading.Thread.CurrentThread.CurrentCulture);
 
-            string monoThreadsPerCpu = System.Environment.GetEnvironmentVariable("MONO_THREADS_PER_CPU");
-
-            m_log.InfoFormat(
-                "[OPENSIM MAIN]: Environment variable MONO_THREADS_PER_CPU is {0}", monoThreadsPerCpu ?? "unset");
-
             // Increase the number of IOCP threads available. Mono defaults to a tragically low number
             int workerThreads, iocpThreads;
             System.Threading.ThreadPool.GetMaxThreads(out workerThreads, out iocpThreads);
@@ -114,6 +109,7 @@ namespace OpenSim
 
             // Check if the system is compatible with OpenSimulator.
             // Ensures that the minimum system requirements are met
+            m_log.Info("Performing compatibility checks... \n");
             string supported = String.Empty;
             if (Util.IsEnvironmentSupported(ref supported))
             {

OpenSim/Region/Application/OpenSim.cs

@@ -35,13 +35,12 @@ using System.Text;
 using System.Text.RegularExpressions;
 using System.Timers;
 using log4net;
-using NDesk.Options;
 using Nini.Config;
 using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Framework.Console;
 using OpenSim.Framework.Servers;
-using OpenSim.Framework.Monitoring;
+using OpenSim.Framework.Statistics;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 
@@ -201,9 +200,9 @@ namespace OpenSim
             PrintFileToConsole("startuplogo.txt");
 
             // For now, start at the 'root' level by default
-            if (SceneManager.Scenes.Count == 1) // If there is only one region, select it
+            if (m_sceneManager.Scenes.Count == 1) // If there is only one region, select it
                 ChangeSelectedRegion("region",
-                                     new string[] {"change", "region", SceneManager.Scenes[0].RegionInfo.RegionName});
+                                     new string[] {"change", "region", m_sceneManager.Scenes[0].RegionInfo.RegionName});
             else
                 ChangeSelectedRegion("region", new string[] {"change", "region", "root"});
 
@@ -232,14 +231,12 @@ namespace OpenSim
         /// </summary>
         private void RegisterConsoleCommands()
         {
-            MainServer.RegisterHttpConsoleCommands(m_console);
-
             m_console.Commands.AddCommand("Objects", false, "force update",
                                           "force update",
                                           "Force the update of all objects on clients",
                                           HandleForceUpdate);
 
-            m_console.Commands.AddCommand("Debug", false, "debug packet",
+            m_console.Commands.AddCommand("Comms", false, "debug packet",
                                           "debug packet <level> [<avatar-first-name> <avatar-last-name>]",
                                           "Turn on packet debugging",
                                             "If level >  255 then all incoming and outgoing packets are logged.\n"
@@ -251,9 +248,19 @@ namespace OpenSim
                                           + "If an avatar name is given then only packets from that avatar are logged",
                                           Debug);
 
-            m_console.Commands.AddCommand("Debug", false, "debug teleport", "debug teleport", "Toggle teleport route debugging", Debug);
+            m_console.Commands.AddCommand("Comms", false, "debug http",
+                                          "debug http [<level>]",
+                                          "Turn on inbound non-poll http request debugging for everything except the event queue (see debug eq).",
+                                            "If level <= 0, then no extra logging is done.\n"
+                                          + "If level >= 1, then short warnings are logged when receiving bad input data.\n"
+                                          + "If level >= 2, then long warnings are logged when receiving bad input data.\n"
+                                          + "If level >= 3, then short notices about all incoming non-poll HTTP requests are logged.\n"
+                                          + "If no level is specified then the current level is returned.",
+                                          Debug);
 
-            m_console.Commands.AddCommand("Debug", false, "debug scene",
+            m_console.Commands.AddCommand("Comms", false, "debug teleport", "debug teleport", "Toggle teleport route debugging", Debug);
+
+            m_console.Commands.AddCommand("Regions", false, "debug scene",
                                           "debug scene <scripting> <collisions> <physics>",
                                           "Turn on scene debugging", Debug);
 
@@ -295,13 +302,14 @@ namespace OpenSim
                                           "save oar [-h|--home=<url>] [--noassets] [--publish] [--perm=<permissions>] [<OAR path>]",
                                           "Save a region's data to an OAR archive.",
 //                                          "-v|--version=<N> generates scene objects as per older versions of the serialization (e.g. -v=0)" + Environment.NewLine
-                                          "-h|--home=<url> adds the url of the profile service to the saved user information.\n"
-                                          + "--noassets stops assets being saved to the OAR.\n"
-                                          + "--publish saves an OAR stripped of owner and last owner information.\n"
-                                          + "   on reload, the estate owner will be the owner of all objects\n"
-                                          + "   this is useful if you're making oars generally available that might be reloaded to the same grid from which you published\n"
-                                          + "--perm=<permissions> stops objects with insufficient permissions from being saved to the OAR.\n"
-                                          + "   <permissions> can contain one or more of these characters: \"C\" = Copy, \"T\" = Transfer\n"
+                                          "-h|--home=<url> adds the url of the profile service to the saved user information." + Environment.NewLine
+                                          + "--noassets stops assets being saved to the OAR." + Environment.NewLine
+                                          + "--publish saves an OAR stripped of owner and last owner information." + Environment.NewLine
+                                          + "   on reload, the estate owner will be the owner of all objects" + Environment.NewLine
+                                          + "   this is useful if you're making oars generally available that might be reloaded to the same grid from which you published" + Environment.NewLine
+                                          + "   this option is EXPERIMENTAL" + Environment.NewLine
+                                          + "--perm=<permissions> stops objects with insufficient permissions from being saved to the OAR." + Environment.NewLine
+                                          + "   <permissions> can contain one or more of these characters: \"C\" = Copy, \"T\" = Transfer" + Environment.NewLine
                                           + "The OAR path must be a filesystem path."
                                           + " If this is not given then the oar is saved to region.oar in the current directory.",
                                           SaveOar);
@@ -311,11 +319,8 @@ namespace OpenSim
                                           "Change the scale of a named prim", HandleEditScale);
 
             m_console.Commands.AddCommand("Users", false, "kick user",
-                                          "kick user <first> <last> [--force] [message]",
-                                          "Kick a user off the simulator",
-                                          "The --force option will kick the user without any checks to see whether it's already in the process of closing\n"
-                                          + "Only use this option if you are sure the avatar is inactive and a normal kick user operation does not removed them",
-                                          KickUserCommand);
+                                          "kick user <first> <last> [message]",
+                                          "Kick a user off the simulator", KickUserCommand);
 
             m_console.Commands.AddCommand("Users", false, "show users",
                                           "show users [full]",
@@ -412,6 +417,10 @@ namespace OpenSim
             m_console.Commands.AddCommand("General", false, "modules unload",
                                           "modules unload <name>",
                                           "Unload a module", HandleModules);
+
+            m_console.Commands.AddCommand("Objects", false, "kill uuid",
+                                          "kill uuid <UUID>",
+                                          "Kill an object by UUID", KillUUID);
         }
 
         public override void ShutdownSpecific()
@@ -420,7 +429,6 @@ namespace OpenSim
             {
                 RunCommandScript(m_shutdownCommandsFile);
             }
-            
             base.ShutdownSpecific();
         }
 
@@ -458,27 +466,21 @@ namespace OpenSim
         /// <param name="cmdparams">name of avatar to kick</param>
         private void KickUserCommand(string module, string[] cmdparams)
         {
-            bool force = false;
-            
-            OptionSet options = new OptionSet().Add("f|force", delegate (string v) { force = v != null; });
-
-            List<string> mainParams = options.Parse(cmdparams);
-
-            if (mainParams.Count < 4)
+            if (cmdparams.Length < 4)
                 return;
 
             string alert = null;
-            if (mainParams.Count > 4)
+            if (cmdparams.Length > 4)
                 alert = String.Format("\n{0}\n", String.Join(" ", cmdparams, 4, cmdparams.Length - 4));
 
-            IList agents = SceneManager.GetCurrentSceneAvatars();
+            IList agents = m_sceneManager.GetCurrentSceneAvatars();
 
             foreach (ScenePresence presence in agents)
             {
                 RegionInfo regionInfo = presence.Scene.RegionInfo;
 
-                if (presence.Firstname.ToLower().Contains(mainParams[2].ToLower()) &&
-                    presence.Lastname.ToLower().Contains(mainParams[3].ToLower()))
+                if (presence.Firstname.ToLower().Contains(cmdparams[2].ToLower()) &&
+                    presence.Lastname.ToLower().Contains(cmdparams[3].ToLower()))
                 {
                     MainConsole.Instance.Output(
                         String.Format(
@@ -491,7 +493,7 @@ namespace OpenSim
                     else
                         presence.ControllingClient.Kick("\nThe OpenSim manager kicked you out.\n");
 
-                    presence.Scene.IncomingCloseAgent(presence.UUID, force);
+                    presence.Scene.IncomingCloseAgent(presence.UUID);
                 }
             }
 
@@ -552,7 +554,7 @@ namespace OpenSim
         private void HandleForceUpdate(string module, string[] args)
         {
             MainConsole.Instance.Output("Updating all clients");
-            SceneManager.ForceCurrentSceneClientUpdate();
+            m_sceneManager.ForceCurrentSceneClientUpdate();
         }
 
         /// <summary>
@@ -564,7 +566,7 @@ namespace OpenSim
         {
             if (args.Length == 6)
             {
-                SceneManager.HandleEditCommandOnCurrentScene(args);
+                m_sceneManager.HandleEditCommandOnCurrentScene(args);
             }
             else
             {
@@ -775,7 +777,7 @@ namespace OpenSim
                     case "load":
                         if (cmdparams.Length > 1)
                         {
-                            foreach (Scene s in new ArrayList(SceneManager.Scenes))
+                            foreach (Scene s in new ArrayList(m_sceneManager.Scenes))
                             {
                                 MainConsole.Instance.Output(String.Format("Loading module: {0}", cmdparams[1]));
                                 m_moduleLoader.LoadRegionModules(cmdparams[1], s);
@@ -813,14 +815,14 @@ namespace OpenSim
 
                 case "backup":
                     MainConsole.Instance.Output("Triggering save of pending object updates to persistent store");
-                    SceneManager.BackupCurrentScene();
+                    m_sceneManager.BackupCurrentScene();
                     break;
 
                 case "remove-region":
                     string regRemoveName = CombineParams(cmdparams, 0);
 
                     Scene removeScene;
-                    if (SceneManager.TryGetScene(regRemoveName, out removeScene))
+                    if (m_sceneManager.TryGetScene(regRemoveName, out removeScene))
                         RemoveRegion(removeScene, false);
                     else
                         MainConsole.Instance.Output("No region with that name");
@@ -830,14 +832,14 @@ namespace OpenSim
                     string regDeleteName = CombineParams(cmdparams, 0);
 
                     Scene killScene;
-                    if (SceneManager.TryGetScene(regDeleteName, out killScene))
+                    if (m_sceneManager.TryGetScene(regDeleteName, out killScene))
                         RemoveRegion(killScene, true);
                     else
                         MainConsole.Instance.Output("no region with that name");
                     break;
 
                 case "restart":
-                    SceneManager.RestartCurrentScene();
+                    m_sceneManager.RestartCurrentScene();
                     break;
             }
         }
@@ -852,7 +854,7 @@ namespace OpenSim
             {
                 string newRegionName = CombineParams(cmdparams, 2);
 
-                if (!SceneManager.TrySetCurrentScene(newRegionName))
+                if (!m_sceneManager.TrySetCurrentScene(newRegionName))
                     MainConsole.Instance.Output(String.Format("Couldn't select region {0}", newRegionName));
             }
             else
@@ -860,7 +862,7 @@ namespace OpenSim
                 MainConsole.Instance.Output("Usage: change region <region name>");
             }
 
-            string regionName = (SceneManager.CurrentScene == null ? "root" : SceneManager.CurrentScene.RegionInfo.RegionName);
+            string regionName = (m_sceneManager.CurrentScene == null ? "root" : m_sceneManager.CurrentScene.RegionInfo.RegionName);
             MainConsole.Instance.Output(String.Format("Currently selected region is {0}", regionName));
 
 //            m_log.DebugFormat("Original prompt is {0}", m_consolePrompt);
@@ -878,7 +880,7 @@ namespace OpenSim
             });
 
             m_console.DefaultPrompt = prompt;
-            m_console.ConsoleScene = SceneManager.CurrentScene;
+            m_console.ConsoleScene = m_sceneManager.CurrentScene;
         }
 
         /// <summary>
@@ -902,7 +904,7 @@ namespace OpenSim
                         int newDebug;
                         if (int.TryParse(args[2], out newDebug))
                         {
-                            SceneManager.SetDebugPacketLevelOnCurrentScene(newDebug, name);
+                            m_sceneManager.SetDebugPacketLevelOnCurrentScene(newDebug, name);
                             // We provide user information elsewhere if any clients had their debug level set.
 //                            MainConsole.Instance.OutputFormat("Debug packet level set to {0}", newDebug);
                         }
@@ -914,10 +916,32 @@ namespace OpenSim
 
                     break;
 
+                case "http":
+                    if (args.Length == 3)
+                    {
+                        int newDebug;
+                        if (int.TryParse(args[2], out newDebug))
+                        {
+                            MainServer.DebugLevel = newDebug;
+                            MainConsole.Instance.OutputFormat("Debug http level set to {0}", newDebug);
+                            break;
+                        }
+                    }
+                    else if (args.Length == 2)
+                    {
+                        MainConsole.Instance.OutputFormat("Current debug http level is {0}", MainServer.DebugLevel);
+                    }
+                    else
+                    {
+                        MainConsole.Instance.Output("Usage: debug http 0..3");
+                    }
+
+                    break;
+
                 case "scene":
                     if (args.Length == 4)
                     {
-                        if (SceneManager.CurrentScene == null)
+                        if (m_sceneManager.CurrentScene == null)
                         {
                             MainConsole.Instance.Output("Please use 'change region <regioname>' first");
                         }
@@ -925,7 +949,7 @@ namespace OpenSim
                         {
                             string key = args[2];
                             string value = args[3];
-                            SceneManager.CurrentScene.SetSceneCoreDebug(
+                            m_sceneManager.CurrentScene.SetSceneCoreDebug(
                                 new Dictionary<string, string>() { { key, value } });
 
                             MainConsole.Instance.OutputFormat("Set debug scene {0} = {1}", key, value);
@@ -964,10 +988,10 @@ namespace OpenSim
                     IList agents;
                     if (showParams.Length > 1 && showParams[1] == "full")
                     {
-                        agents = SceneManager.GetCurrentScenePresences();
+                        agents = m_sceneManager.GetCurrentScenePresences();
                     } else
                     {
-                        agents = SceneManager.GetCurrentSceneAvatars();
+                        agents = m_sceneManager.GetCurrentSceneAvatars();
                     }
                 
                     MainConsole.Instance.Output(String.Format("\nAgents connected: {0}\n", agents.Count));
@@ -1006,11 +1030,44 @@ namespace OpenSim
                     break;
 
                 case "connections":
-                    HandleShowConnections();
+                    System.Text.StringBuilder connections = new System.Text.StringBuilder("Connections:\n");
+                    m_sceneManager.ForEachScene(
+                        delegate(Scene scene) {
+                        scene.ForEachClient(
+                                delegate(IClientAPI client) {
+                            connections.AppendFormat(
+                                "{0}: {1} ({2}) from {3} on circuit {4}\n",
+                                scene.RegionInfo.RegionName,
+                                client.Name,
+                                client.AgentId,
+                                client.RemoteEndPoint,
+                                client.CircuitCode
+                            );
+                        }
+                        );
+                    }
+                    );
+
+                    MainConsole.Instance.Output(connections.ToString());
                     break;
 
                 case "circuits":
-                    HandleShowCircuits();
+                    System.Text.StringBuilder acd = new System.Text.StringBuilder("Agent Circuits:\n");
+                    m_sceneManager.ForEachScene(
+                        delegate(Scene scene) {
+                        //this.HttpServer.
+                        acd.AppendFormat("{0}:\n", scene.RegionInfo.RegionName);
+                        foreach (AgentCircuitData aCircuit in scene.AuthenticateHandler.GetAgentCircuits().Values)
+                            acd.AppendFormat(
+                                "\t{0} {1} ({2})\n",
+                                aCircuit.firstname,
+                                aCircuit.lastname,
+                                (aCircuit.child ? "Child" : "Root")
+                            );
+                    }
+                    );
+
+                    MainConsole.Instance.Output(acd.ToString());
                     break;
 
                 case "http-handlers":
@@ -1047,7 +1104,7 @@ namespace OpenSim
                         MainConsole.Instance.Output("Shared Module: " + module.Name);
                     }
 
-                    SceneManager.ForEachScene(
+                    m_sceneManager.ForEachScene(
                         delegate(Scene scene) {
                         m_log.Error("The currently loaded modules in " + scene.RegionInfo.RegionName + " are:");
                         foreach (IRegionModule module in scene.Modules.Values)
@@ -1060,7 +1117,7 @@ namespace OpenSim
                     }
                     );
 
-                    SceneManager.ForEachScene(
+                    m_sceneManager.ForEachScene(
                         delegate(Scene scene) {
                         MainConsole.Instance.Output("Loaded new region modules in" + scene.RegionInfo.RegionName + " are:");
                         foreach (IRegionModuleBase module in scene.RegionModules.Values)
@@ -1076,7 +1133,7 @@ namespace OpenSim
                     break;
 
                 case "regions":
-                    SceneManager.ForEachScene(
+                    m_sceneManager.ForEachScene(
                         delegate(Scene scene)
                             {
                                 MainConsole.Instance.Output(String.Format(
@@ -1090,7 +1147,7 @@ namespace OpenSim
                     break;
 
                 case "ratings":
-                    SceneManager.ForEachScene(
+                    m_sceneManager.ForEachScene(
                     delegate(Scene scene)
                     {
                         string rating = "";
@@ -1115,53 +1172,6 @@ namespace OpenSim
             }
         }
 
-        private void HandleShowCircuits()
-        {
-            ConsoleDisplayTable cdt = new ConsoleDisplayTable();
-            cdt.AddColumn("Region", 20);
-            cdt.AddColumn("Avatar name", 24);
-            cdt.AddColumn("Type", 5);
-            cdt.AddColumn("Code", 10);
-            cdt.AddColumn("IP", 16);
-            cdt.AddColumn("Viewer Name", 24);
-
-            SceneManager.ForEachScene(
-                s =>
-                {
-                    foreach (AgentCircuitData aCircuit in s.AuthenticateHandler.GetAgentCircuits().Values)
-                        cdt.AddRow(
-                            s.Name,
-                            aCircuit.Name,
-                            aCircuit.child ? "child" : "root",
-                            aCircuit.circuitcode.ToString(),
-                            aCircuit.IPAddress.ToString(),
-                            aCircuit.Viewer);
-                });
-
-            MainConsole.Instance.Output(cdt.ToString());
-        }
-
-        private void HandleShowConnections()
-        {
-            ConsoleDisplayTable cdt = new ConsoleDisplayTable();
-            cdt.AddColumn("Region", 20);
-            cdt.AddColumn("Avatar name", 24);
-            cdt.AddColumn("Circuit code", 12);
-            cdt.AddColumn("Endpoint", 23);
-            cdt.AddColumn("Active?", 7);
-
-            SceneManager.ForEachScene(
-                s => s.ForEachClient(
-                    c => cdt.AddRow(
-                        s.Name,
-                        c.Name,
-                        c.CircuitCode.ToString(),
-                        c.RemoteEndPoint.ToString(),                
-                        c.IsActive.ToString())));
-
-            MainConsole.Instance.Output(cdt.ToString());
-        }
-
         /// <summary>
         /// Use XML2 format to serialize data to a file
         /// </summary>
@@ -1171,11 +1181,11 @@ namespace OpenSim
         {
             if (cmdparams.Length > 5)
             {
-                SceneManager.SaveNamedPrimsToXml2(cmdparams[3], cmdparams[4]);
+                m_sceneManager.SaveNamedPrimsToXml2(cmdparams[3], cmdparams[4]);
             }
             else
             {
-                SceneManager.SaveNamedPrimsToXml2("Primitive", DEFAULT_PRIM_BACKUP_FILENAME);
+                m_sceneManager.SaveNamedPrimsToXml2("Primitive", DEFAULT_PRIM_BACKUP_FILENAME);
             }
         }
 
@@ -1190,11 +1200,11 @@ namespace OpenSim
 
             if (cmdparams.Length > 0)
             {
-                SceneManager.SaveCurrentSceneToXml(cmdparams[2]);
+                m_sceneManager.SaveCurrentSceneToXml(cmdparams[2]);
             }
             else
             {
-                SceneManager.SaveCurrentSceneToXml(DEFAULT_PRIM_BACKUP_FILENAME);
+                m_sceneManager.SaveCurrentSceneToXml(DEFAULT_PRIM_BACKUP_FILENAME);
             }
         }
 
@@ -1231,13 +1241,13 @@ namespace OpenSim
                         MainConsole.Instance.Output(String.Format("loadOffsets <X,Y,Z> = <{0},{1},{2}>",loadOffset.X,loadOffset.Y,loadOffset.Z));
                     }
                 }
-                SceneManager.LoadCurrentSceneFromXml(cmdparams[2], generateNewIDS, loadOffset);
+                m_sceneManager.LoadCurrentSceneFromXml(cmdparams[2], generateNewIDS, loadOffset);
             }
             else
             {
                 try
                 {
-                    SceneManager.LoadCurrentSceneFromXml(DEFAULT_PRIM_BACKUP_FILENAME, false, loadOffset);
+                    m_sceneManager.LoadCurrentSceneFromXml(DEFAULT_PRIM_BACKUP_FILENAME, false, loadOffset);
                 }
                 catch (FileNotFoundException)
                 {
@@ -1254,11 +1264,11 @@ namespace OpenSim
         {
             if (cmdparams.Length > 2)
             {
-                SceneManager.SaveCurrentSceneToXml2(cmdparams[2]);
+                m_sceneManager.SaveCurrentSceneToXml2(cmdparams[2]);
             }
             else
             {
-                SceneManager.SaveCurrentSceneToXml2(DEFAULT_PRIM_BACKUP_FILENAME);
+                m_sceneManager.SaveCurrentSceneToXml2(DEFAULT_PRIM_BACKUP_FILENAME);
             }
         }
 
@@ -1273,7 +1283,7 @@ namespace OpenSim
             {
                 try
                 {
-                    SceneManager.LoadCurrentSceneFromXml2(cmdparams[2]);
+                    m_sceneManager.LoadCurrentSceneFromXml2(cmdparams[2]);
                 }
                 catch (FileNotFoundException)
                 {
@@ -1284,7 +1294,7 @@ namespace OpenSim
             {
                 try
                 {
-                    SceneManager.LoadCurrentSceneFromXml2(DEFAULT_PRIM_BACKUP_FILENAME);
+                    m_sceneManager.LoadCurrentSceneFromXml2(DEFAULT_PRIM_BACKUP_FILENAME);
                 }
                 catch (FileNotFoundException)
                 {
@@ -1301,7 +1311,7 @@ namespace OpenSim
         {
             try
             {
-                SceneManager.LoadArchiveToCurrentScene(cmdparams);
+                m_sceneManager.LoadArchiveToCurrentScene(cmdparams);
             }
             catch (Exception e)
             {
@@ -1315,7 +1325,7 @@ namespace OpenSim
         /// <param name="cmdparams"></param>
         protected void SaveOar(string module, string[] cmdparams)
         {
-            SceneManager.SaveCurrentSceneToArchive(cmdparams);
+            m_sceneManager.SaveCurrentSceneToArchive(cmdparams);
         }
 
         private static string CombineParams(string[] commandParams, int pos)
@@ -1329,6 +1339,58 @@ namespace OpenSim
             return result;
         }
 
+        /// <summary>
+        /// Kill an object given its UUID.
+        /// </summary>
+        /// <param name="cmdparams"></param>
+        protected void KillUUID(string module, string[] cmdparams)
+        {
+            if (cmdparams.Length > 2)
+            {
+                UUID id = UUID.Zero;
+                SceneObjectGroup grp = null;
+                Scene sc = null;
+
+                if (!UUID.TryParse(cmdparams[2], out id))
+                {
+                    MainConsole.Instance.Output("[KillUUID]: Error bad UUID format!");
+                    return;
+                }
+
+                m_sceneManager.ForEachScene(
+                    delegate(Scene scene)
+                    {
+                        SceneObjectPart part = scene.GetSceneObjectPart(id);
+                        if (part == null)
+                            return;
+
+                        grp = part.ParentGroup;
+                        sc = scene;
+                    });
+
+                if (grp == null)
+                {
+                    MainConsole.Instance.Output(String.Format("[KillUUID]: Given UUID {0} not found!", id));
+                }
+                else
+                {
+                    MainConsole.Instance.Output(String.Format("[KillUUID]: Found UUID {0} in scene {1}", id, sc.RegionInfo.RegionName));
+                    try
+                    {
+                        sc.DeleteSceneObject(grp, false);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("[KillUUID]: Error while removing objects from scene: " + e);
+                    }
+                }
+            }
+            else
+            {
+                MainConsole.Instance.Output("[KillUUID]: Usage: kill uuid <UUID>");
+            }
+        }
+
         #endregion
     }
 }

OpenSim/Region/Application/OpenSimBase.cs

@@ -40,7 +40,7 @@ using OpenSim.Framework.Communications;
 using OpenSim.Framework.Console;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
-using OpenSim.Framework.Monitoring;
+using OpenSim.Framework.Statistics;
 using OpenSim.Region.ClientStack;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.UserAccounts;
 using OpenSim.Region.Framework;
@@ -285,7 +285,7 @@ namespace OpenSim
 
         private void HandleCommanderCommand(string module, string[] cmd)
         {
-            SceneManager.SendCommandToPluginModules(cmd);
+            m_sceneManager.SendCommandToPluginModules(cmd);
         }
 
         private void HandleCommanderHelp(string module, string[] cmd)
@@ -303,15 +303,7 @@ namespace OpenSim
             // Called from base.StartUp()
 
             m_httpServerPort = m_networkServersInfo.HttpListenerPort;
-            SceneManager.OnRestartSim += handleRestartRegion;
-
-            // Only enable the watchdogs when all regions are ready.  Otherwise we get false positives when cpu is
-            // heavily used during initial startup.
-            //
-            // FIXME: It's also possible that region ready status should be flipped during an OAR load since this
-            // also makes heavy use of the CPU.
-            SceneManager.OnRegionsReadyStatusChange
-                += sm => { MemoryWatchdog.Enabled = sm.AllRegionsReady; Watchdog.Enabled = sm.AllRegionsReady; };
+            m_sceneManager.OnRestartSim += handleRestartRegion;
         }
 
         /// <summary>
@@ -420,7 +412,7 @@ namespace OpenSim
             // scripting engines.
             scene.CreateScriptInstances();
 
-            SceneManager.Add(scene);
+            m_sceneManager.Add(scene);
 
             if (m_autoCreateClientStack)
             {
@@ -440,6 +432,7 @@ namespace OpenSim
             mscene = scene;
 
             scene.Start();
+
             scene.StartScripts();
 
             return clientServer;
@@ -568,14 +561,14 @@ namespace OpenSim
         {
             // only need to check this if we are not at the
             // root level
-            if ((SceneManager.CurrentScene != null) &&
-                (SceneManager.CurrentScene.RegionInfo.RegionID == scene.RegionInfo.RegionID))
+            if ((m_sceneManager.CurrentScene != null) &&
+                (m_sceneManager.CurrentScene.RegionInfo.RegionID == scene.RegionInfo.RegionID))
             {
-                SceneManager.TrySetCurrentScene("..");
+                m_sceneManager.TrySetCurrentScene("..");
             }
 
             scene.DeleteAllSceneObjects();
-            SceneManager.CloseScene(scene);
+            m_sceneManager.CloseScene(scene);
             ShutdownClientServer(scene.RegionInfo);
             
             if (!cleanup)
@@ -617,7 +610,7 @@ namespace OpenSim
         public void RemoveRegion(string name, bool cleanUp)
         {
             Scene target;
-            if (SceneManager.TryGetScene(name, out target))
+            if (m_sceneManager.TryGetScene(name, out target))
                 RemoveRegion(target, cleanUp);
         }
 
@@ -630,13 +623,13 @@ namespace OpenSim
         {
             // only need to check this if we are not at the
             // root level
-            if ((SceneManager.CurrentScene != null) &&
-                (SceneManager.CurrentScene.RegionInfo.RegionID == scene.RegionInfo.RegionID))
+            if ((m_sceneManager.CurrentScene != null) &&
+                (m_sceneManager.CurrentScene.RegionInfo.RegionID == scene.RegionInfo.RegionID))
             {
-                SceneManager.TrySetCurrentScene("..");
+                m_sceneManager.TrySetCurrentScene("..");
             }
 
-            SceneManager.CloseScene(scene);
+            m_sceneManager.CloseScene(scene);
             ShutdownClientServer(scene.RegionInfo);
         }
         
@@ -648,7 +641,7 @@ namespace OpenSim
         public void CloseRegion(string name)
         {
             Scene target;
-            if (SceneManager.TryGetScene(name, out target))
+            if (m_sceneManager.TryGetScene(name, out target))
                 CloseRegion(target);
         }
         
@@ -705,7 +698,6 @@ namespace OpenSim
             scene.LoadWorldMap();
 
             scene.PhysicsScene = GetPhysicsScene(scene.RegionInfo.RegionName);
-            scene.PhysicsScene.RequestAssetMethod = scene.PhysicsRequestAsset;
             scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
             scene.PhysicsScene.SetWaterLevel((float) regionInfo.RegionSettings.WaterHeight);
 
@@ -905,7 +897,7 @@ namespace OpenSim
 
             try
             {
-                SceneManager.Close();
+                m_sceneManager.Close();
             }
             catch (Exception e)
             {
@@ -930,7 +922,7 @@ namespace OpenSim
         /// <param name="usernum">The first out parameter describing the number of all the avatars in the Region server</param>
         public void GetAvatarNumber(out int usernum)
         {
-            usernum = SceneManager.GetCurrentSceneAvatars().Count;
+            usernum = m_sceneManager.GetCurrentSceneAvatars().Count;
         }
 
         /// <summary>
@@ -939,7 +931,7 @@ namespace OpenSim
         /// <param name="regionnum">The first out parameter describing the number of regions</param>
         public void GetRegionNumber(out int regionnum)
         {
-            regionnum = SceneManager.Scenes.Count;
+            regionnum = m_sceneManager.Scenes.Count;
         }
         
         /// <summary>

OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs

@@ -123,14 +123,9 @@ namespace OpenSim.Region.ClientStack.Linden
                 IConfig sconfig = config.Configs["Startup"];
                 if (sconfig != null)
                 {
+                    m_persistBakedTextures = sconfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
                     m_levelUpload = sconfig.GetInt("LevelUpload", 0);
                 }
-
-                IConfig appearanceConfig = config.Configs["Appearance"];
-                if (appearanceConfig != null)
-                {
-                    m_persistBakedTextures = appearanceConfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
-                }
             }
 
             m_assetService = m_Scene.AssetService;

OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs

@@ -106,7 +106,7 @@ namespace OpenSim.Region.ClientStack.Linden
                 scene.EventManager.OnRegisterCaps += OnRegisterCaps;
 
                 MainConsole.Instance.Commands.AddCommand(
-                    "Debug",
+                    "Comms",
                     false,
                     "debug eq",
                     "debug eq [0|1|2]",

OpenSim/Region/ClientStack/Linden/Caps/EventQueue/Tests/EventQueueTests.cs

@@ -94,7 +94,7 @@ namespace OpenSim.Region.ClientStack.Linden.Tests
             UUID spId = TestHelpers.ParseTail(0x1);
 
             SceneHelpers.AddScenePresence(m_scene, spId);
-            m_scene.IncomingCloseAgent(spId, false);
+            m_scene.IncomingCloseAgent(spId);
 
             // TODO: Add more assertions for the other aspects of event queues
             Assert.That(MainServer.Instance.GetPollServiceHandlerKeys().Count, Is.EqualTo(0));

OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs

@@ -1,234 +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 System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Collections.Specialized;
-using System.Drawing;
-using System.Drawing.Imaging;
-using System.Reflection;
-using System.IO;
-using System.Web;
-using log4net;
-using Nini.Config;
-using Mono.Addins;
-using OpenMetaverse;
-using OpenMetaverse.StructuredData;
-using OpenMetaverse.Imaging;
-using OpenSim.Framework;
-using OpenSim.Framework.Console;
-using OpenSim.Framework.Servers;
-using OpenSim.Framework.Servers.HttpServer;
-using OpenSim.Region.Framework.Interfaces;
-using OpenSim.Region.Framework.Scenes;
-using OpenSim.Services.Interfaces;
-using Caps = OpenSim.Framework.Capabilities.Caps;
-using OpenSim.Capabilities.Handlers;
-
-namespace OpenSim.Region.ClientStack.Linden
-{
-
-    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "RegionConsoleModule")]
-    public class RegionConsoleModule : INonSharedRegionModule, IRegionConsole
-    {
-        private static readonly ILog m_log =
-            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        
-        private Scene m_scene;
-        private IEventQueue m_eventQueue;
-        private Commands m_commands = new Commands();
-        public ICommands Commands { get { return m_commands; } }
-
-        public void Initialise(IConfigSource source)
-        {
-            m_commands.AddCommand( "Help", false, "help", "help [<item>]", "Display help on a particular command or on a list of commands in a category", Help);
-        }
-
-        public void AddRegion(Scene s)
-        {
-            m_scene = s;
-            m_scene.RegisterModuleInterface<IRegionConsole>(this);
-        }
-
-        public void RemoveRegion(Scene s)
-        {
-            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
-            m_scene = null;
-        }
-
-        public void RegionLoaded(Scene s)
-        {
-            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
-            m_eventQueue = m_scene.RequestModuleInterface<IEventQueue>();
-        }
-
-        public void PostInitialise()
-        {
-        }
-
-        public void Close() { }
-
-        public string Name { get { return "RegionConsoleModule"; } }
-
-        public Type ReplaceableInterface
-        {
-            get { return null; }
-        }
-
-        public void RegisterCaps(UUID agentID, Caps caps)
-        {
-            if (!m_scene.RegionInfo.EstateSettings.IsEstateManagerOrOwner(agentID))
-                return;
-
-            UUID capID = UUID.Random();
-
-            m_log.DebugFormat("[REGION CONSOLE]: /CAPS/{0} in region {1}", capID, m_scene.RegionInfo.RegionName);
-            caps.RegisterHandler(
-                    "SimConsoleAsync",
-                    new ConsoleHandler("/CAPS/" + capID + "/", "SimConsoleAsync", agentID, this, m_scene));
-        }
-
-        public void SendConsoleOutput(UUID agentID, string message)
-        {
-            OSD osd = OSD.FromString(message);
-
-            m_eventQueue.Enqueue(EventQueueHelper.BuildEvent("SimConsoleResponse", osd), agentID);
-        }
-
-        public bool RunCommand(string command, UUID invokerID)
-        {
-            string[] parts = Parser.Parse(command);
-            Array.Resize(ref parts, parts.Length + 1);
-            parts[parts.Length - 1] = invokerID.ToString();
-
-            if (m_commands.Resolve(parts).Length == 0)
-                return false;
-
-            return true;
-        }
-
-        private void Help(string module, string[] cmd)
-        {
-            UUID agentID = new UUID(cmd[cmd.Length - 1]);
-            Array.Resize(ref cmd, cmd.Length - 1);
-
-            List<string> help = Commands.GetHelp(cmd);
-
-            string reply = String.Empty;
-
-            foreach (string s in help)
-            {
-                reply += s + "\n";
-            }
-
-            SendConsoleOutput(agentID, reply);
-        }
-        
-        public void AddCommand(string module, bool shared, string command, string help, string longhelp, CommandDelegate fn)
-        {
-            m_commands.AddCommand(module, shared, command, help, longhelp, fn);
-        }
-    }
-
-    public class ConsoleHandler : BaseStreamHandler
-    {
-        private static readonly ILog m_log =
-            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-
-        private RegionConsoleModule m_consoleModule;
-        private UUID m_agentID;
-        private bool m_isGod;
-        private Scene m_scene;
-        private bool m_consoleIsOn = false;
-
-        public ConsoleHandler(string path, string name, UUID agentID, RegionConsoleModule module, Scene scene)
-                :base("POST", path, name, agentID.ToString())
-        {
-            m_agentID = agentID;
-            m_consoleModule = module;
-            m_scene = scene;
-
-            m_isGod = m_scene.Permissions.IsGod(agentID);
-        }
-
-        public override byte[] Handle(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
-        {
-            StreamReader reader = new StreamReader(request);
-            string message = reader.ReadToEnd();
-
-            OSD osd = OSDParser.DeserializeLLSDXml(message);
-
-            string cmd = osd.AsString();
-            if (cmd == "set console on")
-            {
-                if (m_isGod)
-                {
-                    MainConsole.Instance.OnOutput += ConsoleSender;
-                    m_consoleIsOn = true;
-                    m_consoleModule.SendConsoleOutput(m_agentID, "Console is now on");
-                }
-                return new byte[0];
-            }
-            else if (cmd == "set console off")
-            {
-                MainConsole.Instance.OnOutput -= ConsoleSender;
-                m_consoleIsOn = false;
-                m_consoleModule.SendConsoleOutput(m_agentID, "Console is now off");
-                return new byte[0];
-            }
-
-            if (m_consoleIsOn == false && m_consoleModule.RunCommand(osd.AsString().Trim(), m_agentID))
-                return new byte[0];
-
-            if (m_isGod && m_consoleIsOn)
-            {
-                MainConsole.Instance.RunCommand(osd.AsString().Trim());
-            }
-            else
-            {
-                m_consoleModule.SendConsoleOutput(m_agentID, "Unknown command");
-            }
-
-            return new byte[0];
-        }
-
-        private void ConsoleSender(string text)
-        {
-            m_consoleModule.SendConsoleOutput(m_agentID, text);
-        }
-
-        private void OnMakeChildAgent(ScenePresence presence)
-        {
-            if (presence.UUID == m_agentID)
-            {
-                MainConsole.Instance.OnOutput -= ConsoleSender;
-                m_consoleIsOn = false;
-            }
-        }
-    }
-}

OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs

@@ -66,9 +66,9 @@ namespace OpenSim.Region.ClientStack.Linden
 
         public void Initialise(IConfigSource source)
         {
-            IConfig appearanceConfig = source.Configs["Appearance"];
-            if (appearanceConfig != null)
-                m_persistBakedTextures = appearanceConfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
+            IConfig sconfig = source.Configs["Startup"];
+            if (sconfig != null)
+                m_persistBakedTextures = sconfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
         }
 
         public void AddRegion(Scene s)

OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs

@@ -41,7 +41,7 @@ using OpenMetaverse.Messages.Linden;
 using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using OpenSim.Framework.Client;
-using OpenSim.Framework.Monitoring;
+using OpenSim.Framework.Statistics;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
@@ -59,7 +59,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
     /// Handles new client connections
     /// Constructor takes a single Packet and authenticates everything
     /// </summary>
-    public class LLClientView : IClientAPI, IClientCore, IClientIM, IClientChat, IClientInventory, IStatsCollector
+    public class LLClientView : IClientAPI, IClientCore, IClientIM, IClientChat, IClientInventory, IClientIPEndpoint, IStatsCollector
     {
         /// <value>
         /// Debug packet level.  See OpenSim.RegisterConsoleCommands() for more details.
@@ -347,6 +347,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         private int m_animationSequenceNumber = 1;
         private bool m_SendLogoutPacketWhenClosing = true;
         private AgentUpdateArgs lastarg;
+        private bool m_IsActive = true;
+        private bool m_IsLoggingOut = false;
 
         protected Dictionary<PacketType, PacketProcessor> m_packetHandlers = new Dictionary<PacketType, PacketProcessor>();
         protected Dictionary<string, GenericMessage> m_genericPacketHandlers = new Dictionary<string, GenericMessage>(); //PauPaw:Local Generic Message handlers
@@ -355,6 +357,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         protected string m_lastName;
         protected Thread m_clientThread;
         protected Vector3 m_startpos;
+        protected EndPoint m_userEndPoint;
         protected UUID m_activeGroupID;
         protected string m_activeGroupName = String.Empty;
         protected ulong m_activeGroupPowers;
@@ -410,19 +413,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public uint CircuitCode { get { return m_circuitCode; } }
         public int MoneyBalance { get { return m_moneyBalance; } }
         public int NextAnimationSequenceNumber { get { return m_animationSequenceNumber++; } }
-
-        /// <summary>
-        /// As well as it's function in IClientAPI, in LLClientView we are locking on this property in order to
-        /// prevent race conditions by different threads calling Close().
-        /// </summary>
-        public bool IsActive { get; set; }
-
-        /// <summary>
-        /// Used to synchronise threads when client is being closed.
-        /// </summary>
-        public Object CloseSyncLock { get; private set; }
-
-        public bool IsLoggingOut { get; set; }
+        public bool IsActive
+        {
+            get { return m_IsActive; }
+            set { m_IsActive = value; }
+        }
+        public bool IsLoggingOut
+        {
+            get { return m_IsLoggingOut; }
+            set { m_IsLoggingOut = value; }
+        }
 
         public bool DisableFacelights
         {
@@ -442,16 +442,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>
         /// Constructor
         /// </summary>
-        public LLClientView(Scene scene, LLUDPServer udpServer, LLUDPClient udpClient, AuthenticateResponse sessionInfo,
+        public LLClientView(EndPoint remoteEP, Scene scene, LLUDPServer udpServer, LLUDPClient udpClient, AuthenticateResponse sessionInfo,
             UUID agentId, UUID sessionId, uint circuitCode)
         {
 //            DebugPacketLevel = 1;
 
-            CloseSyncLock = new Object();
-
             RegisterInterface<IClientIM>(this);
             RegisterInterface<IClientInventory>(this);
             RegisterInterface<IClientChat>(this);
+            RegisterInterface<IClientIPEndpoint>(this);
 
             m_scene = scene;
             m_entityUpdates = new PriorityQueue(m_scene.Entities.Count);
@@ -468,6 +467,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             m_sessionId = sessionId;
             m_secureSessionId = sessionInfo.LoginInfo.SecureSession;
             m_circuitCode = circuitCode;
+            m_userEndPoint = remoteEP;
             m_firstName = sessionInfo.LoginInfo.First;
             m_lastName = sessionInfo.LoginInfo.Last;
             m_startpos = sessionInfo.LoginInfo.StartPos;
@@ -481,44 +481,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             m_prioritizer = new Prioritizer(m_scene);
 
             RegisterLocalPacketHandlers();
-
-            IsActive = true;
         }
 
         #region Client Methods
 
+        /// <summary>
+        /// Shut down the client view
+        /// </summary>
         public void Close()
         {
-            Close(false);
-        }
+            IsActive = false;
 
-        public void Close(bool force)
-        {
-            // We lock here to prevent race conditions between two threads calling close simultaneously (e.g.
-            // a simultaneous relog just as a client is being closed out due to no packet ack from the old connection.
-            lock (CloseSyncLock)
-            {
-                // We still perform a force close inside the sync lock since this is intended to attempt close where
-                // there is some unidentified connection problem, not where we have issues due to deadlock
-                if (!IsActive && !force)
-                    return;
-
-                IsActive = false;
-                CloseWithoutChecks();
-            }
-        }
-
-        /// <summary>
-        /// Closes down the client view without first checking whether it is active.
-        /// </summary>
-        /// <remarks>
-        /// This exists because LLUDPServer has to set IsActive = false in earlier synchronous code before calling
-        /// CloseWithoutIsActiveCheck asynchronously.
-        ///
-        /// Callers must lock ClosingSyncLock before calling.
-        /// </remarks>
-        public void CloseWithoutChecks()
-        {
             m_log.DebugFormat(
                 "[CLIENT]: Close has been called for {0} attached to scene {1}",
                 Name, m_scene.RegionInfo.RegionName);
@@ -3597,9 +3570,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void SendCoarseLocationUpdate(List<UUID> users, List<Vector3> CoarseLocations)
         {
-            // We don't need to update inactive clients.
-            if (!IsActive)
-                return;
+            if (!IsActive) return; // We don't need to update inactive clients.
 
             CoarseLocationUpdatePacket loc = (CoarseLocationUpdatePacket)PacketPool.Instance.GetPacket(PacketType.CoarseLocationUpdate);
             loc.Header.Reliable = false;
@@ -3837,15 +3808,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                 && part.ParentGroup.HasPrivateAttachmentPoint
                                 && part.ParentGroup.AttachedAvatar != AgentId)
                                 continue;
-
-                            // If the part has since been deleted, then drop the update.  In the case of attachments,
-                            // this is to avoid spurious updates to other viewers since post-processing of attachments
-                            // has to change the IsAttachment flag for various reasons (which will end up in a pass
-                            // of the test above).
-                            //
-                            // Actual deletions (kills) happen in another method.
-                            if (part.ParentGroup.IsDeleted)
-                                continue;
                         }
 
                         objectUpdateBlocks.Value.Add(updateBlock);
@@ -3853,20 +3815,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                     else if (!canUseImproved)
                     {
-                        SceneObjectPart part = (SceneObjectPart)update.Entity;
-                        ObjectUpdateCompressedPacket.ObjectDataBlock compressedBlock
-                            = CreateCompressedUpdateBlock(part, updateFlags);
-
-                        // If the part has since been deleted, then drop the update.  In the case of attachments,
-                        // this is to avoid spurious updates to other viewers since post-processing of attachments
-                        // has to change the IsAttachment flag for various reasons (which will end up in a pass
-                        // of the test above).
-                        //
-                        // Actual deletions (kills) happen in another method.
-                        if (part.ParentGroup.IsDeleted)
-                            continue;
-
-                        compressedUpdateBlocks.Value.Add(compressedBlock);
+                        compressedUpdateBlocks.Value.Add(CreateCompressedUpdateBlock((SceneObjectPart)update.Entity, updateFlags));
                         compressedUpdates.Value.Add(update);
                     }
                     else
@@ -3893,15 +3842,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                                     && part.ParentGroup.HasPrivateAttachmentPoint
                                     && part.ParentGroup.AttachedAvatar != AgentId)
                                     continue;
-
-                                // If the part has since been deleted, then drop the update.  In the case of attachments,
-                                // this is to avoid spurious updates to other viewers since post-processing of attachments
-                                // has to change the IsAttachment flag for various reasons (which will end up in a pass
-                                // of the test above).
-                                //
-                                // Actual deletions (kills) happen in another method.
-                                if (part.ParentGroup.IsDeleted)
-                                    continue;
                             }
 
                             terseUpdateBlocks.Value.Add(terseUpdateBlock);
@@ -4451,44 +4391,37 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 if (bl[i].BannedUserID == UUID.Zero)
                     continue;
                 BannedUsers.Add(bl[i].BannedUserID);
-
-                if (BannedUsers.Count >= 50 || (i == (bl.Length - 1) && BannedUsers.Count > 0))
-                {
-                    EstateOwnerMessagePacket packet = new EstateOwnerMessagePacket();
-                    packet.AgentData.TransactionID = UUID.Random();
-                    packet.AgentData.AgentID = AgentId;
-                    packet.AgentData.SessionID = SessionId;
-                    packet.MethodData.Invoice = invoice;
-                    packet.MethodData.Method = Utils.StringToBytes("setaccess");
-
-                    EstateOwnerMessagePacket.ParamListBlock[] returnblock = new EstateOwnerMessagePacket.ParamListBlock[6 + BannedUsers.Count];
-
-                    int j;
-                    for (j = 0; j < (6 + BannedUsers.Count); j++)
-                    {
-                        returnblock[j] = new EstateOwnerMessagePacket.ParamListBlock();
-                    }
-                    j = 0; 
-
-                    returnblock[j].Parameter = Utils.StringToBytes(estateID.ToString()); j++;
-                    returnblock[j].Parameter = Utils.StringToBytes(((int)Constants.EstateAccessCodex.EstateBans).ToString()); j++;
-                    returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
-                    returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
-                    returnblock[j].Parameter = Utils.StringToBytes(BannedUsers.Count.ToString()); j++;
-                    returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
-
-                    foreach (UUID banned in BannedUsers)
-                    {
-                        returnblock[j].Parameter = banned.GetBytes(); j++;
-                    }
-                    packet.ParamList = returnblock;
-                    packet.Header.Reliable = true;
-                    OutPacket(packet, ThrottleOutPacketType.Task);
-
-                    BannedUsers.Clear();
-                }
             }
 
+            EstateOwnerMessagePacket packet = new EstateOwnerMessagePacket();
+            packet.AgentData.TransactionID = UUID.Random();
+            packet.AgentData.AgentID = AgentId;
+            packet.AgentData.SessionID = SessionId;
+            packet.MethodData.Invoice = invoice;
+            packet.MethodData.Method = Utils.StringToBytes("setaccess");
+
+            EstateOwnerMessagePacket.ParamListBlock[] returnblock = new EstateOwnerMessagePacket.ParamListBlock[6 + BannedUsers.Count];
+
+            for (int i = 0; i < (6 + BannedUsers.Count); i++)
+            {
+                returnblock[i] = new EstateOwnerMessagePacket.ParamListBlock();
+            }
+            int j = 0;
+
+            returnblock[j].Parameter = Utils.StringToBytes(estateID.ToString()); j++;
+            returnblock[j].Parameter = Utils.StringToBytes(((int)Constants.EstateAccessCodex.EstateBans).ToString()); j++;
+            returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
+            returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
+            returnblock[j].Parameter = Utils.StringToBytes(BannedUsers.Count.ToString()); j++;
+            returnblock[j].Parameter = Utils.StringToBytes("0"); j++;
+
+            foreach (UUID banned in BannedUsers)
+            {
+                returnblock[j].Parameter = banned.GetBytes(); j++;
+            }
+            packet.ParamList = returnblock;
+            packet.Header.Reliable = false;
+            OutPacket(packet, ThrottleOutPacketType.Task);
         }
 
         public void SendRegionInfoToEstateMenu(RegionInfoForEstateMenuArgs args)
@@ -5203,7 +5136,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer);
             AddLocalPacketHandler(PacketType.AvatarPropertiesUpdate, HandlerAvatarPropertiesUpdate);
             AddLocalPacketHandler(PacketType.ScriptDialogReply, HandlerScriptDialogReply);
-            AddLocalPacketHandler(PacketType.ImprovedInstantMessage, HandlerImprovedInstantMessage);
+            AddLocalPacketHandler(PacketType.ImprovedInstantMessage, HandlerImprovedInstantMessage, false);
             AddLocalPacketHandler(PacketType.AcceptFriendship, HandlerAcceptFriendship);
             AddLocalPacketHandler(PacketType.DeclineFriendship, HandlerDeclineFriendship);
             AddLocalPacketHandler(PacketType.TerminateFriendship, HandlerTerminateFriendship);
@@ -5821,7 +5754,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 args.Channel = ch;
                 args.From = String.Empty;
                 args.Message = Utils.BytesToString(msg);
-                args.Type = ChatTypeEnum.Region; //Behaviour in SL is that the response can be heard from any distance
+                args.Type = ChatTypeEnum.Shout;
                 args.Position = new Vector3();
                 args.Scene = Scene;
                 args.Sender = this;
@@ -11869,6 +11802,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             ClientInfo info = m_udpClient.GetClientInfo();
 
+            info.userEP = m_userEndPoint;
             info.proxyEP = null;
             info.agentcircuit = RequestClientInfo();
 
@@ -11880,6 +11814,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             m_udpClient.SetClientInfo(info);
         }
 
+        public EndPoint GetClientEP()
+        {
+            return m_userEndPoint;
+        }
+
         #region Media Parcel Members
 
         public void SendParcelMediaCommand(uint flags, ParcelMediaCommandEnum command, float time)
@@ -12000,7 +11939,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             Kick(reason);
             Thread.Sleep(1000);
-            Disconnect();
+            Close();
         }
 
         public void Disconnect()
@@ -12149,6 +12088,24 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return numPackets;
         }
 
+        #region IClientIPEndpoint Members
+
+        public IPAddress EndPoint
+        {
+            get
+            {
+                if (m_userEndPoint is IPEndPoint)
+                {
+                    IPEndPoint ep = (IPEndPoint)m_userEndPoint;
+
+                    return ep.Address;
+                }
+                return null;
+            }
+        }
+
+        #endregion
+
         public void SendRebakeAvatarTextures(UUID textureID)
         {
             RebakeAvatarTexturesPacket pack =

OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs

@@ -278,8 +278,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public string GetStats()
         {
             return string.Format(
-                "{0,7} {1,7} {2,7} {3,9} {4,7} {5,7} {6,7} {7,7} {8,7} {9,8} {10,7} {11,7} {12,7}",
-                Util.EnvironmentTickCountSubtract(TickLastPacketReceived),
+                "{0,7} {1,7} {2,7} {3,9} {4,7} {5,7} {6,7} {7,7} {8,7} {9,8} {10,7} {11,7}",
                 PacketsReceived,                                 
                 PacketsSent,
                 PacketsResent,

OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs

@@ -37,7 +37,7 @@ using log4net;
 using Nini.Config;
 using OpenMetaverse.Packets;
 using OpenSim.Framework;
-using OpenSim.Framework.Monitoring;
+using OpenSim.Framework.Statistics;
 using OpenSim.Region.Framework.Scenes;
 using OpenMetaverse;
 
@@ -270,7 +270,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 false,
                 true,
                 GetWatchdogIncomingAlarmData,
-                Watchdog.DEFAULT_WATCHDOG_TIMEOUT_MS);
+                Watchdog.WATCHDOG_TIMEOUT_MS);
 
             Watchdog.StartThread(
                 OutgoingPacketHandler,
@@ -279,7 +279,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 false,
                 true,
                 GetWatchdogOutgoingAlarmData,
-                Watchdog.DEFAULT_WATCHDOG_TIMEOUT_MS);
+                Watchdog.WATCHDOG_TIMEOUT_MS);
 
             m_elapsedMSSinceLastStatReport = Environment.TickCount;
         }
@@ -986,8 +986,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 UseCircuitCodePacket uccp = (UseCircuitCodePacket)array[1];
 
                 m_log.DebugFormat(
-                    "[LLUDPSERVER]: Handling UseCircuitCode request for circuit {0} to {1} from IP {2}",
-                    uccp.CircuitCode.Code, m_scene.RegionInfo.RegionName, buffer.RemoteEndPoint);
+                    "[LLUDPSERVER]: Handling UseCircuitCode request for circuit {0} from {1}",
+                    uccp.CircuitCode.Code, buffer.RemoteEndPoint);
     
                 remoteEndPoint = (IPEndPoint)buffer.RemoteEndPoint;
     
@@ -1016,8 +1016,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 {
                     // Don't create clients for unauthorized requesters.
                     m_log.WarnFormat(
-                        "[LLUDPSERVER]: Ignoring connection request for {0} to {1} with unknown circuit code {2} from IP {3}",
-                        uccp.CircuitCode.ID, m_scene.RegionInfo.RegionName, uccp.CircuitCode.Code, remoteEndPoint);
+                        "[LLUDPSERVER]: Connection request for client {0} connecting with unnotified circuit code {1} from {2}",
+                        uccp.CircuitCode.ID, uccp.CircuitCode.Code, remoteEndPoint);
                 }
     
                 //            m_log.DebugFormat(
@@ -1103,7 +1103,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 {
                     LLUDPClient udpClient = new LLUDPClient(this, ThrottleRates, m_throttle, circuitCode, agentID, remoteEndPoint, m_defaultRTO, m_maxRTO);
 
-                    client = new LLClientView(m_scene, this, udpClient, sessionInfo, agentID, sessionID, circuitCode);
+                    client = new LLClientView(remoteEndPoint, m_scene, this, udpClient, sessionInfo, agentID, sessionID, circuitCode);
                     client.OnLogout += LogoutHandler;
 
                     ((LLClientView)client).DisableFacelights = m_disableFacelights;
@@ -1123,21 +1123,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// regular client pings.
         /// </remarks>
         /// <param name='client'></param>
-        private void DeactivateClientDueToTimeout(LLClientView client)
+        private void DeactivateClientDueToTimeout(IClientAPI client)
         {
-            lock (client.CloseSyncLock)
-            {
-                m_log.WarnFormat(
-                    "[LLUDPSERVER]: Ack timeout, disconnecting {0} agent for {1} in {2}",
-                    client.SceneAgent.IsChildAgent ? "child" : "root", client.Name, m_scene.RegionInfo.RegionName);
-    
-                StatsManager.SimExtraStats.AddAbnormalClientThreadTermination();
-    
-                if (!client.SceneAgent.IsChildAgent)
-                     client.Kick("Simulator logged you out due to connection timeout");
-    
-                client.CloseWithoutChecks();
-            }
+            // We must set IsActive synchronously so that we can stop the packet loop reinvoking this method, even
+            // though it's set later on by LLClientView.Close()
+            client.IsActive = false;
+
+            m_log.WarnFormat(
+                "[LLUDPSERVER]: Ack timeout, disconnecting {0} agent for {1} in {2}",
+                client.SceneAgent.IsChildAgent ? "child" : "root", client.Name, m_scene.RegionInfo.RegionName);
+
+            StatsManager.SimExtraStats.AddAbnormalClientThreadTermination();
+
+            if (!client.SceneAgent.IsChildAgent)
+                 client.Kick("Simulator logged you out due to connection timeout");
+
+            client.Close();
         }
 
         private void IncomingPacketHandler()

OpenSim/Region/ClientStack/Linden/UDP/Tests/MockScene.cs

@@ -44,8 +44,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
         }
         protected int m_objectNameCallsReceived;
         
-        public MockScene() : base(new RegionInfo(1000, 1000, null, null))
+        public MockScene()
         {
+            m_regInfo = new RegionInfo(1000, 1000, null, null);
             m_regStatus = RegionStatus.Up;
         }
         

OpenSim/Region/ClientStack/RegionApplicationBase.cs

@@ -53,8 +53,9 @@ namespace OpenSim.Region.ClientStack
         protected ISimulationDataService m_simulationDataService;
         protected IEstateDataService m_estateDataService;
         protected ClientStackManager m_clientStackManager;
+        protected SceneManager m_sceneManager = new SceneManager();
 
-        public SceneManager SceneManager { get; protected set; }
+        public SceneManager SceneManager { get { return m_sceneManager; } }
         public NetworkServersInfo NetServersInfo { get { return m_networkServersInfo; } }
         public ISimulationDataService SimulationDataService { get { return m_simulationDataService; } }
         public IEstateDataService EstateDataService { get { return m_estateDataService; } }
@@ -76,7 +77,6 @@ namespace OpenSim.Region.ClientStack
 
         protected override void StartupSpecific()
         {
-            SceneManager = new SceneManager();
             m_clientStackManager = CreateClientStackManager();
 
             Initialize();

OpenSim/Region/CoreModules/Asset/FlotsamAssetCache.cs

@@ -143,7 +143,7 @@ namespace Flotsam.RegionModules.AssetCache
                     IConfig assetConfig = source.Configs["AssetCache"];
                     if (assetConfig == null)
                     {
-                        m_log.Debug(
+                        m_log.Warn(
                            "[FLOTSAM ASSET CACHE]: AssetCache section missing from config (not copied config-include/FlotsamCache.ini.example?  Using defaults.");
                     }
                     else

OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs

@@ -28,8 +28,6 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using System.IO;
-using System.Xml;
 using log4net;
 using Mono.Addins;
 using Nini.Config;
@@ -102,56 +100,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
 
         #region IAttachmentsModule
 
-        public void CopyAttachments(IScenePresence sp, AgentData ad)
-        {
-            lock (sp.AttachmentsSyncLock)
-            {
-                // Attachment objects
-                List<SceneObjectGroup> attachments = sp.GetAttachments();
-                if (attachments.Count > 0)
-                {
-                    ad.AttachmentObjects = new List<ISceneObject>();
-                    ad.AttachmentObjectStates = new List<string>();
-    //                IScriptModule se = m_scene.RequestModuleInterface<IScriptModule>();
-                    sp.InTransitScriptStates.Clear();
-
-                    foreach (SceneObjectGroup sog in attachments)
-                    {
-                        // We need to make a copy and pass that copy
-                        // because of transfers withn the same sim
-                        ISceneObject clone = sog.CloneForNewScene();
-                        // Attachment module assumes that GroupPosition holds the offsets...!
-                        ((SceneObjectGroup)clone).RootPart.GroupPosition = sog.RootPart.AttachedPos;
-                        ((SceneObjectGroup)clone).IsAttachment = false;
-                        ad.AttachmentObjects.Add(clone);
-                        string state = sog.GetStateSnapshot();
-                        ad.AttachmentObjectStates.Add(state);
-                        sp.InTransitScriptStates.Add(state);
-                        // Let's remove the scripts of the original object here
-                        sog.RemoveScriptInstances(true);
-                    }
-                }
-            }
-        }
-
-        public void CopyAttachments(AgentData ad, IScenePresence sp)
-        {
-            if (ad.AttachmentObjects != null && ad.AttachmentObjects.Count > 0)
-            {
-                lock (sp.AttachmentsSyncLock)
-                    sp.ClearAttachments();
-
-                int i = 0;
-                foreach (ISceneObject so in ad.AttachmentObjects)
-                {
-                    ((SceneObjectGroup)so).LocalId = 0;
-                    ((SceneObjectGroup)so).RootPart.ClearUpdateSchedule();
-                    so.SetState(ad.AttachmentObjectStates[i++], m_scene);
-                    m_scene.IncomingCreateObject(Vector3.Zero, so);
-                }
-            }
-        }
-
         /// <summary>
         /// RezAttachments. This should only be called upon login on the first region.
         /// Attachment rezzings on crossings and TPs are done in a different way.
@@ -204,32 +152,30 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             }
         }
 
-        public void DeRezAttachments(IScenePresence sp)
+        public void SaveChangedAttachments(IScenePresence sp, bool saveAllScripted)
         {
+//            m_log.DebugFormat("[ATTACHMENTS MODULE]: Saving changed attachments for {0}", sp.Name);
+
             if (!Enabled)
                 return;
 
-//            m_log.DebugFormat("[ATTACHMENTS MODULE]: Saving changed attachments for {0}", sp.Name);
-
-            lock (sp.AttachmentsSyncLock)
+            foreach (SceneObjectGroup grp in sp.GetAttachments())
             {
-                foreach (SceneObjectGroup so in sp.GetAttachments())
-                {
-                    UpdateDetachedObject(sp, so);
-                }
-    
-                sp.ClearAttachments();
+                grp.IsAttachment = false;
+                grp.AbsolutePosition = grp.RootPart.AttachedPos;
+                UpdateKnownItem(sp, grp, saveAllScripted);
+                grp.IsAttachment = true;
             }
         }
 
         public void DeleteAttachmentsFromScene(IScenePresence sp, bool silent)
         {
-            if (!Enabled)
-                return;
-
 //            m_log.DebugFormat(
 //                "[ATTACHMENTS MODULE]: Deleting attachments from scene {0} for {1}, silent = {2}",
-//                m_scene.RegionInfo.RegionName, sp.Name, silent);            
+//                m_scene.RegionInfo.RegionName, sp.Name, silent);
+
+            if (!Enabled)
+                return;
 
             foreach (SceneObjectGroup sop in sp.GetAttachments())
             {
@@ -239,22 +185,13 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             sp.ClearAttachments();
         }
         
-        public bool AttachObject(IScenePresence sp, SceneObjectGroup group, uint attachmentPt, bool silent, bool temp)
+        public bool AttachObject(IScenePresence sp, SceneObjectGroup group, uint attachmentPt, bool silent)
         {
             lock (sp.AttachmentsSyncLock)
             {
 //                m_log.DebugFormat(
 //                    "[ATTACHMENTS MODULE]: Attaching object {0} {1} to {2} point {3} from ground (silent = {4})",
 //                    group.Name, group.LocalId, sp.Name, attachmentPt, silent);
-
-                if (group.GetSittingAvatarsCount() != 0)
-                {
-//                    m_log.WarnFormat(
-//                        "[ATTACHMENTS MODULE]: Ignoring request to attach {0} {1} to {2} on {3} since {4} avatars are still sitting on it",
-//                        group.Name, group.LocalId, sp.Name, attachmentPt, group.GetSittingAvatarsCount());
-    
-                    return false;
-                }
     
                 if (sp.GetAttachments(attachmentPt).Contains(group))
                 {
@@ -296,9 +233,33 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
     
                 group.AttachmentPoint = attachmentPt;
                 group.AbsolutePosition = attachPos;
-
+    
+                // We also don't want to do any of the inventory operations for an NPC.
                 if (sp.PresenceType != PresenceType.Npc)
-                    UpdateUserInventoryWithAttachment(sp, group, attachmentPt, temp);
+                {
+                    // Remove any previous attachments
+                    List<SceneObjectGroup> attachments = sp.GetAttachments(attachmentPt);
+    
+                    // At the moment we can only deal with a single attachment
+                    if (attachments.Count != 0)
+                    {
+                        UUID oldAttachmentItemID = attachments[0].FromItemID;
+        
+                        if (oldAttachmentItemID != UUID.Zero)
+                            DetachSingleAttachmentToInvInternal(sp, oldAttachmentItemID);
+                        else
+                            m_log.WarnFormat(
+                                "[ATTACHMENTS MODULE]: When detaching existing attachment {0} {1} at point {2} to make way for {3} {4} for {5}, couldn't find the associated item ID to adjust inventory attachment record!",
+                                attachments[0].Name, attachments[0].LocalId, attachmentPt, group.Name, group.LocalId, sp.Name);
+                    }
+    
+                    // Add the new attachment to inventory if we don't already have it.
+                    UUID newAttachmentItemID = group.FromItemID;
+                    if (newAttachmentItemID == UUID.Zero)
+                        newAttachmentItemID = AddSceneObjectAsNewAttachmentInInv(sp, group).ID;
+        
+                    ShowAttachInUserInventory(sp, attachmentPt, newAttachmentItemID, group);
+                }
     
                 AttachToAgent(sp, group, attachmentPt, attachPos, silent);
             }
@@ -306,35 +267,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             return true;
         }
 
-        private void UpdateUserInventoryWithAttachment(IScenePresence sp, SceneObjectGroup group, uint attachmentPt, bool temp)
-        {
-            // Remove any previous attachments
-            List<SceneObjectGroup> attachments = sp.GetAttachments(attachmentPt);
-
-            // At the moment we can only deal with a single attachment
-            if (attachments.Count != 0)
-            {
-                if (attachments[0].FromItemID != UUID.Zero)
-                    DetachSingleAttachmentToInvInternal(sp, attachments[0]);
-            // Error logging commented because UUID.Zero now means temp attachment
-//                else
-//                    m_log.WarnFormat(
-//                        "[ATTACHMENTS MODULE]: When detaching existing attachment {0} {1} at point {2} to make way for {3} {4} for {5}, couldn't find the associated item ID to adjust inventory attachment record!",
-//                        attachments[0].Name, attachments[0].LocalId, attachmentPt, group.Name, group.LocalId, sp.Name);
-            }
-
-            // Add the new attachment to inventory if we don't already have it.
-            if (!temp)
-            {
-                UUID newAttachmentItemID = group.FromItemID;
-                if (newAttachmentItemID == UUID.Zero)
-                    newAttachmentItemID = AddSceneObjectAsNewAttachmentInInv(sp, group).ID;
-
-                ShowAttachInUserInventory(sp, attachmentPt, newAttachmentItemID, group);
-            }
-        }
-
-        public SceneObjectGroup RezSingleAttachmentFromInventory(IScenePresence sp, UUID itemID, uint AttachmentPt)
+        public ISceneEntity RezSingleAttachmentFromInventory(IScenePresence sp, UUID itemID, uint AttachmentPt)
         {
             if (!Enabled)
                 return null;
@@ -373,7 +306,12 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                 return null;
             }
 
-            return RezSingleAttachmentFromInventoryInternal(sp, itemID, UUID.Zero, AttachmentPt);
+            SceneObjectGroup att = RezSingleAttachmentFromInventoryInternal(sp, itemID, UUID.Zero, AttachmentPt);
+
+            if (att == null)
+                DetachSingleAttachmentToInv(sp, itemID);
+
+            return att;
         }
 
         public void RezMultipleAttachmentsFromInventory(IScenePresence sp, List<KeyValuePair<UUID, uint>> rezlist)
@@ -410,10 +348,6 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
 
             UUID inventoryID = so.FromItemID;
 
-            // As per Linden spec, drop is disabled for temp attachs
-            if (inventoryID == UUID.Zero)
-                return;
-
 //            m_log.DebugFormat(
 //                "[ATTACHMENTS MODULE]: In DetachSingleAttachmentToGround(), object is {0} {1}, associated item is {2}",
 //                so.Name, so.LocalId, inventoryID);
@@ -424,9 +358,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                     so.PrimCount, sp.UUID, sp.AbsolutePosition))
                     return;
 
-                bool changed = false;
-                if (inventoryID != UUID.Zero)
-                    changed = sp.Appearance.DetachAttachment(inventoryID);
+                bool changed = sp.Appearance.DetachAttachment(inventoryID);
                 if (changed && m_scene.AvatarFactory != null)
                     m_scene.AvatarFactory.QueueAppearanceSave(sp.UUID);
 
@@ -456,27 +388,18 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             m_scene.EventManager.TriggerOnAttach(so.LocalId, so.UUID, UUID.Zero);
         }
 
-        public void DetachSingleAttachmentToInv(IScenePresence sp, SceneObjectGroup so)
+        public void DetachSingleAttachmentToInv(IScenePresence sp, UUID itemID)
         {
             lock (sp.AttachmentsSyncLock)
             {
                 // Save avatar attachment information
 //                m_log.Debug("[ATTACHMENTS MODULE]: Detaching from UserID: " + sp.UUID + ", ItemID: " + itemID);
 
-                if (so.AttachedAvatar != sp.UUID)
-                {
-                    m_log.WarnFormat(
-                        "[ATTACHMENTS MODULE]: Tried to detach object {0} from {1} {2} but attached avatar id was {3} in {4}",
-                        so.Name, sp.Name, sp.UUID, so.AttachedAvatar, m_scene.RegionInfo.RegionName);
-
-                    return;
-                }
-
-                bool changed = sp.Appearance.DetachAttachment(so.FromItemID);
+                bool changed = sp.Appearance.DetachAttachment(itemID);
                 if (changed && m_scene.AvatarFactory != null)
                     m_scene.AvatarFactory.QueueAppearanceSave(sp.UUID);
 
-                DetachSingleAttachmentToInvInternal(sp, so);
+                DetachSingleAttachmentToInvInternal(sp, itemID);
             }
         }
         
@@ -485,7 +408,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             if (!Enabled)
                 return;
 
+            // First we save the
+            // attachment point information, then we update the relative 
+            // positioning. Then we have to mark the object as NOT an
+            // attachment. This is necessary in order to correctly save
+            // and retrieve GroupPosition information for the attachment.
+            // Finally, we restore the object's attachment status.
+            uint attachmentPoint = sog.AttachmentPoint;
             sog.UpdateGroupPosition(pos);
+            sog.IsAttachment = false;
+            sog.AbsolutePosition = sog.RootPart.AttachedPos;
+            sog.AttachmentPoint = attachmentPoint;
             sog.HasGroupChanged = true;            
         }
 
@@ -528,16 +461,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
         /// </remarks>
         /// <param name="sp"></param>
         /// <param name="grp"></param>
-        /// <param name="saveAllScripted"></param>
-        private void UpdateKnownItem(IScenePresence sp, SceneObjectGroup grp, string scriptedState)
+        private void UpdateKnownItem(IScenePresence sp, SceneObjectGroup grp, bool saveAllScripted)
         {
-            if (grp.FromItemID == UUID.Zero)
-            {
-                // We can't save temp attachments
-                grp.HasGroupChanged = false;
-                return;
-            }
-
             // Saving attachments for NPCs messes them up for the real owner!
             INPCModule module = m_scene.RequestModuleInterface<INPCModule>();
             if (module != null)
@@ -546,13 +471,13 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                     return;
             }
 
-            if (grp.HasGroupChanged)
+            if (grp.HasGroupChanged || (saveAllScripted && grp.ContainsScripts()))
             {
 //                m_log.DebugFormat(
 //                    "[ATTACHMENTS MODULE]: Updating asset for attachment {0}, attachpoint {1}",
 //                    grp.UUID, grp.AttachmentPoint);
 
-                string sceneObjectXml = SceneObjectSerializer.ToOriginalXmlFormat(grp, scriptedState);
+                string sceneObjectXml = SceneObjectSerializer.ToOriginalXmlFormat(grp);
 
                 InventoryItemBase item = new InventoryItemBase(grp.FromItemID, sp.UUID);
                 item = m_scene.InventoryService.GetItem(item);
@@ -575,12 +500,10 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
 
                     m_scene.InventoryService.UpdateItem(item);
 
-                    // If the name of the object has been changed whilst attached then we want to update the inventory
-                    // item in the viewer.
+                    // this gets called when the agent logs off!
                     if (sp.ControllingClient != null)
                         sp.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
                 }
-
                 grp.HasGroupChanged = false; // Prevent it being saved over and over
             }
 //            else
@@ -678,12 +601,11 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             //                "[ATTACHMENTS MODULE]: Called AddSceneObjectAsAttachment for object {0} {1} for {2}",
             //                grp.Name, grp.LocalId, remoteClient.Name);
 
-            InventoryItemBase newItem
-                = m_invAccessModule.CopyToInventory(
-                    DeRezAction.TakeCopy,
-                    m_scene.InventoryService.GetFolderForType(sp.UUID, AssetType.Object).ID,
-                    new List<SceneObjectGroup> { grp },
-                    sp.ControllingClient, true)[0];
+            InventoryItemBase newItem =  m_invAccessModule.CopyToInventory(
+                DeRezAction.TakeCopy,
+                m_scene.InventoryService.GetFolderForType(sp.UUID, AssetType.Object).ID,
+                new List<SceneObjectGroup> { grp },
+                sp.ControllingClient, true)[0];
 
             // sets itemID so client can show item as 'attached' in inventory
             grp.FromItemID = newItem.ID;
@@ -691,68 +613,46 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             return newItem;
         }
 
-        private string GetObjectScriptStates(SceneObjectGroup grp)
-        {
-            using (StringWriter sw = new StringWriter())
-            {
-                using (XmlTextWriter writer = new XmlTextWriter(sw))
-                {
-                    grp.SaveScriptedState(writer);
-                }
-
-                return sw.ToString();
-            }
-        }
-
-        private void UpdateDetachedObject(IScenePresence sp, SceneObjectGroup so)
-        {
-            // Don't save attachments for HG visitors, it
-            // messes up their inventory. When a HG visitor logs
-            // out on a foreign grid, their attachments will be
-            // reloaded in the state they were in when they left
-            // the home grid. This is best anyway as the visited
-            // grid may use an incompatible script engine.
-            bool saveChanged
-                    = sp.PresenceType != PresenceType.Npc
-                    && (m_scene.UserManagementModule == null
-                    || m_scene.UserManagementModule.IsLocalGridUser(sp.UUID));
-
-            // Scripts MUST be snapshotted before the object is
-            // removed from the scene because doing otherwise will
-            // clobber the run flag
-            string scriptedState = GetObjectScriptStates(so);
-
-            // Remove the object from the scene so no more updates
-            // are sent. Doing this before the below changes will ensure
-            // updates can't cause "HUD artefacts"
-            m_scene.DeleteSceneObject(so, false, false);
-
-            // Prepare sog for storage
-            so.AttachedAvatar = UUID.Zero;
-            so.RootPart.SetParentLocalId(0);
-            so.IsAttachment = false;
-
-            if (saveChanged)
-            {
-                // We cannot use AbsolutePosition here because that would
-                // attempt to cross the prim as it is detached
-                so.ForEachPart(x => { x.GroupPosition = so.RootPart.AttachedPos; });
-
-                UpdateKnownItem(sp, so, scriptedState);
-            }
-
-            // Now, remove the scripts
-            so.RemoveScriptInstances(true);
-        }
-
-        private void DetachSingleAttachmentToInvInternal(IScenePresence sp, SceneObjectGroup so)
+        // What makes this method odd and unique is it tries to detach using an UUID....     Yay for standards.
+        // To LocalId or UUID, *THAT* is the question. How now Brown UUID??
+        private void DetachSingleAttachmentToInvInternal(IScenePresence sp, UUID itemID)
         {
             //            m_log.DebugFormat("[ATTACHMENTS MODULE]: Detaching item {0} to inventory for {1}", itemID, sp.Name);
 
-            m_scene.EventManager.TriggerOnAttach(so.LocalId, so.FromItemID, UUID.Zero);
-            sp.RemoveAttachment(so);
+            if (itemID == UUID.Zero) // If this happened, someone made a mistake....
+                return;
 
-            UpdateDetachedObject(sp, so);
+            // We can NOT use the dictionries here, as we are looking
+            // for an entity by the fromAssetID, which is NOT the prim UUID
+            EntityBase[] detachEntities = m_scene.GetEntities();
+            SceneObjectGroup group;
+
+            lock (sp.AttachmentsSyncLock)
+            {
+                foreach (EntityBase entity in detachEntities)
+                {
+                    if (entity is SceneObjectGroup)
+                    {
+                        group = (SceneObjectGroup)entity;
+                        if (group.FromItemID == itemID)
+                        {
+                            m_scene.EventManager.TriggerOnAttach(group.LocalId, itemID, UUID.Zero);
+                            sp.RemoveAttachment(group);
+
+                            // Prepare sog for storage
+                            group.AttachedAvatar = UUID.Zero;
+                            group.RootPart.SetParentLocalId(0);
+                            group.IsAttachment = false;
+                            group.AbsolutePosition = group.RootPart.AttachedPos;
+
+                            UpdateKnownItem(sp, group, true);
+                            m_scene.DeleteSceneObject(group, false);
+
+                            return;
+                        }
+                    }
+                }
+            }
         }
 
         private SceneObjectGroup RezSingleAttachmentFromInventoryInternal(
@@ -774,27 +674,22 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                         null, assetID, Vector3.Zero, Vector3.Zero, UUID.Zero, (byte)1, true,
                         false, false, sp.UUID, true);
 
+                //                m_log.DebugFormat(
+                //                    "[ATTACHMENTS MODULE]: Retrieved single object {0} for attachment to {1} on point {2}",
+                //                    objatt.Name, remoteClient.Name, AttachmentPt);
+
                 if (objatt != null)
                 {
-//                    m_log.DebugFormat(
-//                        "[ATTACHMENTS MODULE]: Rezzed single object {0} for attachment to {1} on point {2} in {3}",
-//                        objatt.Name, sp.Name, attachmentPt, m_scene.Name);
-
                     // HasGroupChanged is being set from within RezObject.  Ideally it would be set by the caller.
                     objatt.HasGroupChanged = false;
                     bool tainted = false;
                     if (attachmentPt != 0 && attachmentPt != objatt.AttachmentPoint)
                         tainted = true;
 
-                    // FIXME: Detect whether it's really likely for AttachObject to throw an exception in the normal
-                    // course of events.  If not, then it's probably not worth trying to recover the situation
-                    // since this is more likely to trigger further exceptions and confuse later debugging.  If
-                    // exceptions can be thrown in expected error conditions (not NREs) then make this consistent
-                    // since other normal error conditions will simply return false instead.
                     // This will throw if the attachment fails
                     try
                     {
-                        AttachObject(sp, objatt, attachmentPt, false, false);
+                        AttachObject(sp, objatt, attachmentPt, false);
                     }
                     catch (Exception e)
                     {
@@ -861,13 +756,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
             item = m_scene.InventoryService.GetItem(item);
             bool changed = sp.Appearance.SetAttachment((int)AttachmentPt, itemID, item.AssetID);
             if (changed && m_scene.AvatarFactory != null)
-            {
-//                m_log.DebugFormat(
-//                    "[ATTACHMENTS MODULE]: Queueing appearance save for {0}, attachment {1} point {2} in ShowAttachInUserInventory()",
-//                    sp.Name, att.Name, AttachmentPt);
-
                 m_scene.AvatarFactory.QueueAppearanceSave(sp.UUID);
-            }
         }
 
         #endregion
@@ -948,7 +837,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
                 AttachmentPt &= 0x7f;
 
                 // Calls attach with a Zero position
-                if (AttachObject(sp, part.ParentGroup, AttachmentPt, false, false))
+                if (AttachObject(sp, part.ParentGroup, AttachmentPt, false))
                 {
 //                    m_log.Debug(
 //                        "[ATTACHMENTS MODULE]: Saving avatar attachment. AgentID: " + remoteClient.AgentId
@@ -971,9 +860,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
 
             ScenePresence sp = m_scene.GetScenePresence(remoteClient.AgentId);
             SceneObjectGroup group = m_scene.GetGroupByPrim(objectLocalID);
-
-            if (sp != null && group != null && group.FromItemID != UUID.Zero)
-                DetachSingleAttachmentToInv(sp, group);
+            if (sp != null && group != null)
+                DetachSingleAttachmentToInv(sp, group.FromItemID);
         }
 
         private void Client_OnDetachAttachmentIntoInv(UUID itemID, IClientAPI remoteClient)
@@ -983,21 +871,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments
 
             ScenePresence sp = m_scene.GetScenePresence(remoteClient.AgentId);
             if (sp != null)
-            {
-                lock (sp.AttachmentsSyncLock)
-                {
-                    List<SceneObjectGroup> attachments = sp.GetAttachments();
-    
-                    foreach (SceneObjectGroup group in attachments)
-                    {
-                        if (group.FromItemID == itemID && group.FromItemID != UUID.Zero)
-                        {
-                            DetachSingleAttachmentToInv(sp, group);
-                            return;
-                        }
-                    }
-                }
-            }
+                DetachSingleAttachmentToInv(sp, itemID);
         }
 
         private void Client_OnObjectDrop(uint soLocalId, IClientAPI remoteClient)

OpenSim/Region/CoreModules/Avatar/Attachments/Tests/AttachmentsModuleTests.cs

@@ -31,7 +31,6 @@ using System.Reflection;
 using System.Text;
 using System.Threading;
 using System.Timers;
-using System.Xml;
 using Timer=System.Timers.Timer;
 using Nini.Config;
 using NUnit.Framework;
@@ -39,17 +38,11 @@ using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Framework.Communications;
 using OpenSim.Region.CoreModules.Avatar.Attachments;
-using OpenSim.Region.CoreModules.Framework;
-using OpenSim.Region.CoreModules.Framework.EntityTransfer;
 using OpenSim.Region.CoreModules.Framework.InventoryAccess;
-using OpenSim.Region.CoreModules.Scripting.WorldComm;
-using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
 using OpenSim.Region.CoreModules.World.Serialiser;
+using OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Interfaces;
-using OpenSim.Region.ScriptEngine.Interfaces;
-using OpenSim.Region.ScriptEngine.XEngine;
-using OpenSim.Services.Interfaces;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
 
@@ -59,10 +52,11 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
     /// Attachment tests
     /// </summary>
     [TestFixture]
-    public class AttachmentsModuleTests : OpenSimTestCase
+    public class AttachmentsModuleTests
     {
-        private AutoResetEvent m_chatEvent = new AutoResetEvent(false);
-        private OSChatMessage m_osChatMessageReceived;
+        private Scene scene;
+        private AttachmentsModule m_attMod;
+        private ScenePresence m_presence;
 
         [TestFixtureSetUp]
         public void FixtureInit()
@@ -71,6 +65,18 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             Util.FireAndForgetMethod = FireAndForgetMethod.None;
         }
 
+        [SetUp]
+        public void Init()
+        {
+            IConfigSource config = new IniConfigSource();
+            config.AddConfig("Modules");
+            config.Configs["Modules"].Set("InventoryAccessModule", "BasicInventoryAccessModule");
+
+            scene = new SceneHelpers().SetupScene();
+            m_attMod = new AttachmentsModule();
+            SceneHelpers.SetupSceneModules(scene, config, m_attMod, new BasicInventoryAccessModule());
+        }
+
         [TestFixtureTearDown]
         public void TearDown()
         {
@@ -79,100 +85,14 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             Util.FireAndForgetMethod = Util.DefaultFireAndForgetMethod;
         }
 
-        private void OnChatFromWorld(object sender, OSChatMessage oscm)
-        {
-//            Console.WriteLine("Got chat [{0}]", oscm.Message);
-
-            m_osChatMessageReceived = oscm;
-            m_chatEvent.Set();
-        }
-
-        private Scene CreateTestScene()
-        {
-            IConfigSource config = new IniConfigSource();
-            List<object> modules = new List<object>();
-
-            AddCommonConfig(config, modules);
-
-            Scene scene
-                = new SceneHelpers().SetupScene(
-                    "attachments-test-scene", TestHelpers.ParseTail(999), 1000, 1000, config);
-            SceneHelpers.SetupSceneModules(scene, config, modules.ToArray());
-
-            return scene;
-        }
-
-        private Scene CreateScriptingEnabledTestScene()
-        {
-            IConfigSource config = new IniConfigSource();
-            List<object> modules = new List<object>();
-
-            AddCommonConfig(config, modules);
-            AddScriptingConfig(config, modules);
-
-            Scene scene
-                = new SceneHelpers().SetupScene(
-                    "attachments-test-scene", TestHelpers.ParseTail(999), 1000, 1000, config);
-            SceneHelpers.SetupSceneModules(scene, config, modules.ToArray());
-
-            scene.StartScripts();
-
-            return scene;
-        }
-
-        private void AddCommonConfig(IConfigSource config, List<object> modules)
-        {
-            config.AddConfig("Modules");
-            config.Configs["Modules"].Set("InventoryAccessModule", "BasicInventoryAccessModule");
-
-            modules.Add(new AttachmentsModule());
-            modules.Add(new BasicInventoryAccessModule());
-        }
-
-        private void AddScriptingConfig(IConfigSource config, List<object> modules)
-        {
-            IConfig startupConfig = config.AddConfig("Startup");
-            startupConfig.Set("DefaultScriptEngine", "XEngine");
-
-            IConfig xEngineConfig = config.AddConfig("XEngine");
-            xEngineConfig.Set("Enabled", "true");
-            xEngineConfig.Set("StartDelay", "0");
-
-            // These tests will not run with AppDomainLoading = true, at least on mono.  For unknown reasons, the call
-            // to AssemblyResolver.OnAssemblyResolve fails.
-            xEngineConfig.Set("AppDomainLoading", "false");
-
-            modules.Add(new XEngine());
-
-            // Necessary to stop serialization complaining
-            // FIXME: Stop this being necessary if at all possible
-//            modules.Add(new WorldCommModule());
-        }
-
         /// <summary>
-        /// Creates an attachment item in the given user's inventory.  Does not attach.
+        /// Add the standard presence for a test.
         /// </summary>
-        /// <remarks>
-        /// A user with the given ID and an inventory must already exist.
-        /// </remarks>
-        /// <returns>
-        /// The attachment item.
-        /// </returns>
-        /// <param name='scene'></param>
-        /// <param name='userId'></param>
-        /// <param name='attName'></param>
-        /// <param name='rawItemId'></param>
-        /// <param name='rawAssetId'></param>
-        private InventoryItemBase CreateAttachmentItem(
-            Scene scene, UUID userId, string attName, int rawItemId, int rawAssetId)
+        private void AddPresence()
         {
-            return UserInventoryHelpers.CreateInventoryItem(
-                scene,
-                attName,
-                TestHelpers.ParseTail(rawItemId),
-                TestHelpers.ParseTail(rawAssetId),
-                userId,
-                InventoryType.Object);
+            UUID userId = TestHelpers.ParseTail(0x1);
+            UserAccountHelpers.CreateUserWithInventory(scene, userId);
+            m_presence = SceneHelpers.AddScenePresence(scene, userId);
         }
 
         [Test]
@@ -181,19 +101,16 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             TestHelpers.InMethod();
 //            TestHelpers.EnableLogging();
 
-            Scene scene = CreateTestScene();
-            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
-            ScenePresence sp = SceneHelpers.AddScenePresence(scene, ua1);
-
+            AddPresence();
             string attName = "att";
 
-            SceneObjectGroup so = SceneHelpers.AddSceneObject(scene, attName, sp.UUID);
+            SceneObjectGroup so = SceneHelpers.AddSceneObject(scene, attName, m_presence.UUID).ParentGroup;
 
-            scene.AttachmentsModule.AttachObject(sp, so, (uint)AttachmentPoint.Chest, false, false);
+            m_attMod.AttachObject(m_presence, so, (uint)AttachmentPoint.Chest, false);
 
             // Check status on scene presence
-            Assert.That(sp.HasAttachments(), Is.True);
-            List<SceneObjectGroup> attachments = sp.GetAttachments();
+            Assert.That(m_presence.HasAttachments(), Is.True);
+            List<SceneObjectGroup> attachments = m_presence.GetAttachments();
             Assert.That(attachments.Count, Is.EqualTo(1));
             SceneObjectGroup attSo = attachments[0];
             Assert.That(attSo.Name, Is.EqualTo(attName));
@@ -204,123 +121,51 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
 
             // Check item status
             Assert.That(
-                sp.Appearance.GetAttachpoint(attSo.FromItemID),
+                m_presence.Appearance.GetAttachpoint(attSo.FromItemID),
                 Is.EqualTo((int)AttachmentPoint.Chest));
 
             InventoryItemBase attachmentItem = scene.InventoryService.GetItem(new InventoryItemBase(attSo.FromItemID));
             Assert.That(attachmentItem, Is.Not.Null);
             Assert.That(attachmentItem.Name, Is.EqualTo(attName));
 
-            InventoryFolderBase targetFolder = scene.InventoryService.GetFolderForType(sp.UUID, AssetType.Object);
+            InventoryFolderBase targetFolder = scene.InventoryService.GetFolderForType(m_presence.UUID, AssetType.Object);
             Assert.That(attachmentItem.Folder, Is.EqualTo(targetFolder.ID));
 
-            Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
-
 //            TestHelpers.DisableLogging();
         }
 
-        /// <summary>
-        /// Test that we do not attempt to attach an in-world object that someone else is sitting on.
-        /// </summary>
         [Test]
-        public void TestAddSatOnAttachmentFromGround()
-        {
-            TestHelpers.InMethod();
-//            TestHelpers.EnableLogging();
-
-            Scene scene = CreateTestScene();
-            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
-            ScenePresence sp = SceneHelpers.AddScenePresence(scene, ua1);
-
-            string attName = "att";
-
-            SceneObjectGroup so = SceneHelpers.AddSceneObject(scene, attName, sp.UUID);
-
-            UserAccount ua2 = UserAccountHelpers.CreateUserWithInventory(scene, 0x2);
-            ScenePresence sp2 = SceneHelpers.AddScenePresence(scene, ua2);
-
-            // Put avatar within 10m of the prim so that sit doesn't fail.
-            sp2.AbsolutePosition = new Vector3(0, 0, 0);
-            sp2.HandleAgentRequestSit(sp2.ControllingClient, sp2.UUID, so.UUID, Vector3.Zero);
-
-            scene.AttachmentsModule.AttachObject(sp, so, (uint)AttachmentPoint.Chest, false, false);
-
-            Assert.That(sp.HasAttachments(), Is.False);
-            Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
-        }
-
-        [Test]
-        public void TestRezAttachmentFromInventory()
+        public void TestAddAttachmentFromInventory()
         {
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
 
-            Scene scene = CreateTestScene();
-            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
-            ScenePresence sp = SceneHelpers.AddScenePresence(scene, ua1.PrincipalID);
+            AddPresence();
 
-            InventoryItemBase attItem = CreateAttachmentItem(scene, ua1.PrincipalID, "att", 0x10, 0x20);
+            UUID attItemId = TestHelpers.ParseTail(0x2);
+            UUID attAssetId = TestHelpers.ParseTail(0x3);
+            string attName = "att";
 
-            scene.AttachmentsModule.RezSingleAttachmentFromInventory(
-                sp, attItem.ID, (uint)AttachmentPoint.Chest);
+            UserInventoryHelpers.CreateInventoryItem(
+                scene, attName, attItemId, attAssetId, m_presence.UUID, InventoryType.Object);
+
+            m_attMod.RezSingleAttachmentFromInventory(
+                m_presence, attItemId, (uint)AttachmentPoint.Chest);
 
             // Check scene presence status
-            Assert.That(sp.HasAttachments(), Is.True);
-            List<SceneObjectGroup> attachments = sp.GetAttachments();
+            Assert.That(m_presence.HasAttachments(), Is.True);
+            List<SceneObjectGroup> attachments = m_presence.GetAttachments();
             Assert.That(attachments.Count, Is.EqualTo(1));
             SceneObjectGroup attSo = attachments[0];
-            Assert.That(attSo.Name, Is.EqualTo(attItem.Name));
+            Assert.That(attSo.Name, Is.EqualTo(attName));
             Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.Chest));
             Assert.That(attSo.IsAttachment);
             Assert.That(attSo.UsesPhysics, Is.False);
             Assert.That(attSo.IsTemporary, Is.False);
 
             // Check appearance status
-            Assert.That(sp.Appearance.GetAttachments().Count, Is.EqualTo(1));
-            Assert.That(sp.Appearance.GetAttachpoint(attItem.ID), Is.EqualTo((int)AttachmentPoint.Chest));
-
-            Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
-        }
-
-        /// <summary>
-        /// Test specific conditions associated with rezzing a scripted attachment from inventory.
-        /// </summary>
-        [Test]
-        public void TestRezScriptedAttachmentFromInventory()
-        {
-            TestHelpers.InMethod();
-
-            Scene scene = CreateScriptingEnabledTestScene();
-            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
-            ScenePresence sp = SceneHelpers.AddScenePresence(scene, ua1);
-
-            SceneObjectGroup so = SceneHelpers.CreateSceneObject(1, sp.UUID, "att-name", 0x10);
-            TaskInventoryItem scriptItem
-                = TaskInventoryHelpers.AddScript(
-                    scene,
-                    so.RootPart,
-                    "scriptItem",
-                    "default { attach(key id) { if (id != NULL_KEY) { llSay(0, \"Hello World\"); } } }");
-
-            InventoryItemBase userItem = UserInventoryHelpers.AddInventoryItem(scene, so, 0x100, 0x1000);
-
-            // FIXME: Right now, we have to do a tricksy chat listen to make sure we know when the script is running.
-            // In the future, we need to be able to do this programatically more predicably.
-            scene.EventManager.OnChatFromWorld += OnChatFromWorld;
-
-            scene.AttachmentsModule.RezSingleAttachmentFromInventory(sp, userItem.ID, (uint)AttachmentPoint.Chest);
-
-            m_chatEvent.WaitOne(60000);
-
-            // TODO: Need to have a test that checks the script is actually started but this involves a lot more
-            // plumbing of the script engine and either pausing for events or more infrastructure to turn off various
-            // script engine delays/asychronicity that isn't helpful in an automated regression testing context.
-            SceneObjectGroup attSo = scene.GetSceneObjectGroup(so.Name);
-            Assert.That(attSo.ContainsScripts(), Is.True);
-
-            TaskInventoryItem reRezzedScriptItem = attSo.RootPart.Inventory.GetInventoryItem(scriptItem.Name);
-            IScriptModule xengine = scene.RequestModuleInterface<IScriptModule>();
-            Assert.That(xengine.GetScriptState(reRezzedScriptItem.ItemID), Is.True);
+            Assert.That(m_presence.Appearance.GetAttachments().Count, Is.EqualTo(1));
+            Assert.That(m_presence.Appearance.GetAttachpoint(attItemId), Is.EqualTo((int)AttachmentPoint.Chest));
         }
 
         [Test]
@@ -329,27 +174,29 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
 
-            Scene scene = CreateTestScene();
-            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
-            ScenePresence sp = SceneHelpers.AddScenePresence(scene, ua1.PrincipalID);
+            AddPresence();
 
-            InventoryItemBase attItem = CreateAttachmentItem(scene, ua1.PrincipalID, "att", 0x10, 0x20);
+            UUID attItemId = TestHelpers.ParseTail(0x2);
+            UUID attAssetId = TestHelpers.ParseTail(0x3);
+            string attName = "att";
 
-            ISceneEntity so
-                = scene.AttachmentsModule.RezSingleAttachmentFromInventory(
-                    sp, attItem.ID, (uint)AttachmentPoint.Chest);
-            scene.AttachmentsModule.DetachSingleAttachmentToGround(sp, so.LocalId);
+            UserInventoryHelpers.CreateInventoryItem(
+                scene, attName, attItemId, attAssetId, m_presence.UUID, InventoryType.Object);
+
+            ISceneEntity so = m_attMod.RezSingleAttachmentFromInventory(
+                m_presence, attItemId, (uint)AttachmentPoint.Chest);
+            m_attMod.DetachSingleAttachmentToGround(m_presence, so.LocalId);
 
             // Check scene presence status
-            Assert.That(sp.HasAttachments(), Is.False);
-            List<SceneObjectGroup> attachments = sp.GetAttachments();
+            Assert.That(m_presence.HasAttachments(), Is.False);
+            List<SceneObjectGroup> attachments = m_presence.GetAttachments();
             Assert.That(attachments.Count, Is.EqualTo(0));
 
             // Check appearance status
-            Assert.That(sp.Appearance.GetAttachments().Count, Is.EqualTo(0));
+            Assert.That(m_presence.Appearance.GetAttachments().Count, Is.EqualTo(0));
 
             // Check item status
-            Assert.That(scene.InventoryService.GetItem(new InventoryItemBase(attItem.ID)), Is.Null);
+            Assert.That(scene.InventoryService.GetItem(new InventoryItemBase(attItemId)), Is.Null);
 
             // Check object in scene
             Assert.That(scene.GetSceneObjectGroup("att"), Is.Not.Null);
@@ -359,86 +206,28 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
         public void TestDetachAttachmentToInventory()
         {
             TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
 
-            Scene scene = CreateTestScene();
-            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
-            ScenePresence sp = SceneHelpers.AddScenePresence(scene, ua1.PrincipalID);
+            AddPresence();
 
-            InventoryItemBase attItem = CreateAttachmentItem(scene, ua1.PrincipalID, "att", 0x10, 0x20);
+            UUID attItemId = TestHelpers.ParseTail(0x2);
+            UUID attAssetId = TestHelpers.ParseTail(0x3);
+            string attName = "att";
 
-            SceneObjectGroup so
-                = (SceneObjectGroup)scene.AttachmentsModule.RezSingleAttachmentFromInventory(
-                    sp, attItem.ID, (uint)AttachmentPoint.Chest);
-            scene.AttachmentsModule.DetachSingleAttachmentToInv(sp, so);
+            UserInventoryHelpers.CreateInventoryItem(
+                scene, attName, attItemId, attAssetId, m_presence.UUID, InventoryType.Object);
+
+            m_attMod.RezSingleAttachmentFromInventory(
+                m_presence, attItemId, (uint)AttachmentPoint.Chest);
+            m_attMod.DetachSingleAttachmentToInv(m_presence, attItemId);
 
             // Check status on scene presence
-            Assert.That(sp.HasAttachments(), Is.False);
-            List<SceneObjectGroup> attachments = sp.GetAttachments();
+            Assert.That(m_presence.HasAttachments(), Is.False);
+            List<SceneObjectGroup> attachments = m_presence.GetAttachments();
             Assert.That(attachments.Count, Is.EqualTo(0));
 
             // Check item status
-            Assert.That(sp.Appearance.GetAttachpoint(attItem.ID), Is.EqualTo(0));
-
-            Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(0));
-        }
-
-        /// <summary>
-        /// Test specific conditions associated with detaching a scripted attachment from inventory.
-        /// </summary>
-        [Test]
-        public void TestDetachScriptedAttachmentToInventory()
-        {
-            TestHelpers.InMethod();
-//            TestHelpers.EnableLogging();
-
-            Scene scene = CreateScriptingEnabledTestScene();
-            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
-            ScenePresence sp = SceneHelpers.AddScenePresence(scene, ua1);
-
-            SceneObjectGroup so = SceneHelpers.CreateSceneObject(1, sp.UUID, "att-name", 0x10);
-            TaskInventoryItem scriptTaskItem
-                = TaskInventoryHelpers.AddScript(
-                    scene,
-                    so.RootPart,
-                    "scriptItem",
-                    "default { attach(key id) { if (id != NULL_KEY) { llSay(0, \"Hello World\"); } } }");
-
-            InventoryItemBase userItem = UserInventoryHelpers.AddInventoryItem(scene, so, 0x100, 0x1000);
-
-            // FIXME: Right now, we have to do a tricksy chat listen to make sure we know when the script is running.
-            // In the future, we need to be able to do this programatically more predicably.
-            scene.EventManager.OnChatFromWorld += OnChatFromWorld;
-
-            SceneObjectGroup rezzedSo
-                = scene.AttachmentsModule.RezSingleAttachmentFromInventory(sp, userItem.ID, (uint)AttachmentPoint.Chest);
-
-            // Wait for chat to signal rezzed script has been started.
-            m_chatEvent.WaitOne(60000);
-
-            scene.AttachmentsModule.DetachSingleAttachmentToInv(sp, rezzedSo);
-
-            InventoryItemBase userItemUpdated = scene.InventoryService.GetItem(userItem);
-            AssetBase asset = scene.AssetService.Get(userItemUpdated.AssetID.ToString());
-
-            // TODO: It would probably be better here to check script state via the saving and retrieval of state
-            // information at a higher level, rather than having to inspect the serialization.
-            XmlDocument soXml = new XmlDocument();
-            soXml.LoadXml(Encoding.UTF8.GetString(asset.Data));
-
-            XmlNodeList scriptStateNodes = soXml.GetElementsByTagName("ScriptState");
-            Assert.That(scriptStateNodes.Count, Is.EqualTo(1));
-
-            // Re-rez the attachment to check script running state
-            SceneObjectGroup reRezzedSo = scene.AttachmentsModule.RezSingleAttachmentFromInventory(sp, userItem.ID, (uint)AttachmentPoint.Chest);
-
-            // Wait for chat to signal rezzed script has been started.
-            m_chatEvent.WaitOne(60000);
-
-            TaskInventoryItem reRezzedScriptItem = reRezzedSo.RootPart.Inventory.GetInventoryItem(scriptTaskItem.Name);
-            IScriptModule xengine = scene.RequestModuleInterface<IScriptModule>();
-            Assert.That(xengine.GetScriptState(reRezzedScriptItem.ItemID), Is.True);
-
-//            Console.WriteLine(soXml.OuterXml);
+            Assert.That(m_presence.Appearance.GetAttachpoint(attItemId), Is.EqualTo(0));
         }
 
         /// <summary>
@@ -450,18 +239,24 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
 
-            Scene scene = CreateTestScene();
-            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
-            InventoryItemBase attItem = CreateAttachmentItem(scene, ua1.PrincipalID, "att", 0x10, 0x20);
+            UUID userId = TestHelpers.ParseTail(0x1);
+            UUID attItemId = TestHelpers.ParseTail(0x2);
+            UUID attAssetId = TestHelpers.ParseTail(0x3);
+            string attName = "att";
 
-            AgentCircuitData acd = SceneHelpers.GenerateAgentData(ua1.PrincipalID);
+            UserAccountHelpers.CreateUserWithInventory(scene, userId);
+            InventoryItemBase attItem
+                = UserInventoryHelpers.CreateInventoryItem(
+                    scene, attName, attItemId, attAssetId, userId, InventoryType.Object);
+
+            AgentCircuitData acd = SceneHelpers.GenerateAgentData(userId);
             acd.Appearance = new AvatarAppearance();
             acd.Appearance.SetAttachment((int)AttachmentPoint.Chest, attItem.ID, attItem.AssetID);
             ScenePresence presence = SceneHelpers.AddScenePresence(scene, acd);
 
             SceneObjectGroup rezzedAtt = presence.GetAttachments()[0];
 
-            scene.IncomingCloseAgent(presence.UUID, false);
+            scene.IncomingCloseAgent(presence.UUID);
 
             // Check that we can't retrieve this attachment from the scene.
             Assert.That(scene.GetSceneObjectGroup(rezzedAtt.UUID), Is.Null);
@@ -473,11 +268,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             TestHelpers.InMethod();
 //            log4net.Config.XmlConfigurator.Configure();
 
-            Scene scene = CreateTestScene();
-            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
-            InventoryItemBase attItem = CreateAttachmentItem(scene, ua1.PrincipalID, "att", 0x10, 0x20);
+            UUID userId = TestHelpers.ParseTail(0x1);
+            UUID attItemId = TestHelpers.ParseTail(0x2);
+            UUID attAssetId = TestHelpers.ParseTail(0x3);
+            string attName = "att";
 
-            AgentCircuitData acd = SceneHelpers.GenerateAgentData(ua1.PrincipalID);
+            UserAccountHelpers.CreateUserWithInventory(scene, userId);
+            InventoryItemBase attItem
+                = UserInventoryHelpers.CreateInventoryItem(
+                    scene, attName, attItemId, attAssetId, userId, InventoryType.Object);
+
+            AgentCircuitData acd = SceneHelpers.GenerateAgentData(userId);
             acd.Appearance = new AvatarAppearance();
             acd.Appearance.SetAttachment((int)AttachmentPoint.Chest, attItem.ID, attItem.AssetID);
             ScenePresence presence = SceneHelpers.AddScenePresence(scene, acd);
@@ -487,7 +288,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
 
             Assert.That(attachments.Count, Is.EqualTo(1));
             SceneObjectGroup attSo = attachments[0];
-            Assert.That(attSo.Name, Is.EqualTo(attItem.Name));
+            Assert.That(attSo.Name, Is.EqualTo(attName));
             Assert.That(attSo.AttachmentPoint, Is.EqualTo((byte)AttachmentPoint.Chest));
             Assert.That(attSo.IsAttachment);
             Assert.That(attSo.UsesPhysics, Is.False);
@@ -497,125 +298,9 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
             List<AvatarAttachment> retreivedAttachments = presence.Appearance.GetAttachments();
             Assert.That(retreivedAttachments.Count, Is.EqualTo(1));
             Assert.That(retreivedAttachments[0].AttachPoint, Is.EqualTo((int)AttachmentPoint.Chest));
-            Assert.That(retreivedAttachments[0].ItemID, Is.EqualTo(attItem.ID));
-            Assert.That(retreivedAttachments[0].AssetID, Is.EqualTo(attItem.AssetID));
-            Assert.That(presence.Appearance.GetAttachpoint(attItem.ID), Is.EqualTo((int)AttachmentPoint.Chest));
-
-            Assert.That(scene.GetSceneObjectGroups().Count, Is.EqualTo(1));
-        }
-
-        [Test]
-        public void TestUpdateAttachmentPosition()
-        {
-            TestHelpers.InMethod();
-
-            Scene scene = CreateTestScene();
-            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(scene, 0x1);
-            InventoryItemBase attItem = CreateAttachmentItem(scene, ua1.PrincipalID, "att", 0x10, 0x20);
-
-            AgentCircuitData acd = SceneHelpers.GenerateAgentData(ua1.PrincipalID);
-            acd.Appearance = new AvatarAppearance();
-            acd.Appearance.SetAttachment((int)AttachmentPoint.Chest, attItem.ID, attItem.AssetID);
-            ScenePresence sp = SceneHelpers.AddScenePresence(scene, acd);
-
-            SceneObjectGroup attSo = sp.GetAttachments()[0];
-
-            Vector3 newPosition = new Vector3(1, 2, 4);
-
-            scene.SceneGraph.UpdatePrimGroupPosition(attSo.LocalId, newPosition, sp.ControllingClient);
-
-            Assert.That(attSo.AbsolutePosition, Is.EqualTo(sp.AbsolutePosition));
-            Assert.That(attSo.RootPart.AttachedPos, Is.EqualTo(newPosition));
-        }
-
-        [Test]
-        public void TestSameSimulatorNeighbouringRegionsTeleport()
-        {
-            TestHelpers.InMethod();
-//            TestHelpers.EnableLogging();
-
-            AttachmentsModule attModA = new AttachmentsModule();
-            AttachmentsModule attModB = new AttachmentsModule();
-            EntityTransferModule etmA = new EntityTransferModule();
-            EntityTransferModule etmB = new EntityTransferModule();
-            LocalSimulationConnectorModule lscm = new LocalSimulationConnectorModule();
-
-            IConfigSource config = new IniConfigSource();
-            IConfig modulesConfig = config.AddConfig("Modules");
-            modulesConfig.Set("EntityTransferModule", etmA.Name);
-            modulesConfig.Set("SimulationServices", lscm.Name);
-            IConfig entityTransferConfig = config.AddConfig("EntityTransfer");
-
-            // In order to run a single threaded regression test we do not want the entity transfer module waiting
-            // for a callback from the destination scene before removing its avatar data.
-            entityTransferConfig.Set("wait_for_callback", false);
-
-            modulesConfig.Set("InventoryAccessModule", "BasicInventoryAccessModule");
-
-            SceneHelpers sh = new SceneHelpers();
-            TestScene sceneA = sh.SetupScene("sceneA", TestHelpers.ParseTail(0x100), 1000, 1000);
-            TestScene sceneB = sh.SetupScene("sceneB", TestHelpers.ParseTail(0x200), 1001, 1000);
-
-            SceneHelpers.SetupSceneModules(new Scene[] { sceneA, sceneB }, config, lscm);
-            SceneHelpers.SetupSceneModules(
-                sceneA, config, new CapabilitiesModule(), etmA, attModA, new BasicInventoryAccessModule());
-            SceneHelpers.SetupSceneModules(
-                sceneB, config, new CapabilitiesModule(), etmB, attModB, new BasicInventoryAccessModule());
-
-            UserAccount ua1 = UserAccountHelpers.CreateUserWithInventory(sceneA, 0x1);
-            ScenePresence beforeTeleportSp = SceneHelpers.AddScenePresence(sceneA, ua1.PrincipalID, sh.SceneManager);
-            beforeTeleportSp.AbsolutePosition = new Vector3(30, 31, 32);
-
-            InventoryItemBase attItem = CreateAttachmentItem(sceneA, ua1.PrincipalID, "att", 0x10, 0x20);
-
-            sceneA.AttachmentsModule.RezSingleAttachmentFromInventory(
-                beforeTeleportSp, attItem.ID, (uint)AttachmentPoint.Chest);
-
-            Vector3 teleportPosition = new Vector3(10, 11, 12);
-            Vector3 teleportLookAt = new Vector3(20, 21, 22);
-
-            sceneA.RequestTeleportLocation(
-                beforeTeleportSp.ControllingClient,
-                sceneB.RegionInfo.RegionHandle,
-                teleportPosition,
-                teleportLookAt,
-                (uint)TeleportFlags.ViaLocation);
-
-            ((TestClient)beforeTeleportSp.ControllingClient).CompleteTeleportClientSide();
-
-            // Check attachments have made it into sceneB
-            ScenePresence afterTeleportSceneBSp = sceneB.GetScenePresence(ua1.PrincipalID);
-
-            // This is appearance data, as opposed to actually rezzed attachments
-            List<AvatarAttachment> sceneBAttachments = afterTeleportSceneBSp.Appearance.GetAttachments();
-            Assert.That(sceneBAttachments.Count, Is.EqualTo(1));
-            Assert.That(sceneBAttachments[0].AttachPoint, Is.EqualTo((int)AttachmentPoint.Chest));
-            Assert.That(sceneBAttachments[0].ItemID, Is.EqualTo(attItem.ID));
-            Assert.That(sceneBAttachments[0].AssetID, Is.EqualTo(attItem.AssetID));
-            Assert.That(afterTeleportSceneBSp.Appearance.GetAttachpoint(attItem.ID), Is.EqualTo((int)AttachmentPoint.Chest));
-
-            // This is the actual attachment
-            List<SceneObjectGroup> actualSceneBAttachments = afterTeleportSceneBSp.GetAttachments();
-            Assert.That(actualSceneBAttachments.Count, Is.EqualTo(1));
-            SceneObjectGroup actualSceneBAtt = actualSceneBAttachments[0];
-            Assert.That(actualSceneBAtt.Name, Is.EqualTo(attItem.Name));
-            Assert.That(actualSceneBAtt.AttachmentPoint, Is.EqualTo((uint)AttachmentPoint.Chest));
-
-            Assert.That(sceneB.GetSceneObjectGroups().Count, Is.EqualTo(1));
-
-            // Check attachments have been removed from sceneA
-            ScenePresence afterTeleportSceneASp = sceneA.GetScenePresence(ua1.PrincipalID);
-
-            // Since this is appearance data, it is still present on the child avatar!
-            List<AvatarAttachment> sceneAAttachments = afterTeleportSceneASp.Appearance.GetAttachments();
-            Assert.That(sceneAAttachments.Count, Is.EqualTo(1));
-            Assert.That(afterTeleportSceneASp.Appearance.GetAttachpoint(attItem.ID), Is.EqualTo((int)AttachmentPoint.Chest));
-
-            // This is the actual attachment, which should no longer exist
-            List<SceneObjectGroup> actualSceneAAttachments = afterTeleportSceneASp.GetAttachments();
-            Assert.That(actualSceneAAttachments.Count, Is.EqualTo(0));
-
-            Assert.That(sceneA.GetSceneObjectGroups().Count, Is.EqualTo(0));
+            Assert.That(retreivedAttachments[0].ItemID, Is.EqualTo(attItemId));
+            Assert.That(retreivedAttachments[0].AssetID, Is.EqualTo(attAssetId));
+            Assert.That(presence.Appearance.GetAttachpoint(attItemId), Is.EqualTo((int)AttachmentPoint.Chest));
         }
 
         // I'm commenting this test because scene setup NEEDS InventoryService to 
@@ -641,4 +326,4 @@ namespace OpenSim.Region.CoreModules.Avatar.Attachments.Tests
 //            Assert.That(presence.HasAttachments(), Is.True, "Presence has not received new objects");
 //        }
     }
-}
+}

OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs

@@ -66,11 +66,11 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             scene.RegisterModuleInterface<IAvatarFactoryModule>(this);
             scene.EventManager.OnNewClient += SubscribeToClientEvents;
 
-            IConfig appearanceConfig = config.Configs["Appearance"];
-            if (appearanceConfig != null)
+            IConfig sconfig = config.Configs["Startup"];
+            if (sconfig != null)
             {
-                m_savetime = Convert.ToInt32(appearanceConfig.GetString("DelayBeforeAppearanceSave",Convert.ToString(m_savetime)));
-                m_sendtime = Convert.ToInt32(appearanceConfig.GetString("DelayBeforeAppearanceSend",Convert.ToString(m_sendtime)));
+                m_savetime = Convert.ToInt32(sconfig.GetString("DelayBeforeAppearanceSave",Convert.ToString(m_savetime)));
+                m_sendtime = Convert.ToInt32(sconfig.GetString("DelayBeforeAppearanceSend",Convert.ToString(m_sendtime)));
                 // m_log.InfoFormat("[AVFACTORY] configured for {0} save and {1} send",m_savetime,m_sendtime);
             }
 
@@ -128,9 +128,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
         /// <param name="visualParam"></param>
         public void SetAppearance(IScenePresence sp, Primitive.TextureEntry textureEntry, byte[] visualParams)
         {
-//            m_log.DebugFormat(
-//                "[AVFACTORY]: start SetAppearance for {0}, te {1}, visualParams {2}",
-//                sp.Name, textureEntry, visualParams);
+            //            m_log.InfoFormat("[AVFACTORY]: start SetAppearance for {0}", client.AgentId);
 
             // TODO: This is probably not necessary any longer, just assume the
             // textureEntry set implies that the appearance transaction is complete

OpenSim/Region/CoreModules/Avatar/Commands/UserCommandsModule.cs

@@ -37,7 +37,7 @@ using Nini.Config;
 using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Framework.Console;
-using OpenSim.Framework.Monitoring;
+using OpenSim.Framework.Statistics;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 

OpenSim/Region/CoreModules/Avatar/Groups/GroupsModule.cs

@@ -96,7 +96,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Groups
 
             scene.EventManager.OnNewClient += OnNewClient;
             scene.EventManager.OnClientClosed += OnClientClosed;
-//            scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
+            scene.EventManager.OnIncomingInstantMessage += OnGridInstantMessage;
         }
 
         public void PostInitialise()
@@ -133,7 +133,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Groups
         private void OnNewClient(IClientAPI client)
         {
             // Subscribe to instant messages
-//            client.OnInstantMessage += OnInstantMessage;
+            client.OnInstantMessage += OnInstantMessage;
             client.OnAgentDataUpdateRequest += OnAgentDataUpdateRequest;
             client.OnUUIDGroupNameRequest += HandleUUIDGroupNameRequest;
             lock (m_ClientMap)
@@ -171,15 +171,15 @@ namespace OpenSim.Region.CoreModules.Avatar.Groups
                                              ActiveGroupTitle);
         }
 
-//        private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
-//        {
-//        }
+        private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
+        {
+        }
 
-//        private void OnGridInstantMessage(GridInstantMessage msg)
-//        {
-//            // Trigger the above event handler
-//            OnInstantMessage(null, msg);
-//        }
+        private void OnGridInstantMessage(GridInstantMessage msg)
+        {
+            // Trigger the above event handler
+            OnInstantMessage(null, msg);
+        }
 
         private void HandleUUIDGroupNameRequest(UUID id,IClientAPI remote_client)
         {

OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs

@@ -137,15 +137,13 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
             foreach (Scene scene in m_Scenes)
             {
 //                m_log.DebugFormat(
-//                    "[INSTANT MESSAGE]: Looking for root agent {0} in {1}",
+//                    "[INSTANT MESSAGE]: Looking for root agent {0} in {1}", 
 //                    toAgentID.ToString(), scene.RegionInfo.RegionName);
-
                 ScenePresence sp = scene.GetScenePresence(toAgentID);
                 if (sp != null && !sp.IsChildAgent)
                 {
                     // Local message
-                    m_log.DebugFormat("[INSTANT MESSAGE]: Delivering IM to root agent {0} {1}", sp.Name, toAgentID);
-
+//                    m_log.DebugFormat("[INSTANT MESSAGE]: Delivering IM to root agent {0} {1}", user.Name, toAgentID);
                     sp.ControllingClient.SendInstantMessage(im);
 
                     // Message sent
@@ -157,15 +155,13 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
             // try child avatar second
             foreach (Scene scene in m_Scenes)
             {
-                m_log.DebugFormat(
-                    "[INSTANT MESSAGE]: Looking for child of {0} in {1}", toAgentID, scene.RegionInfo.RegionName);
-
+//                m_log.DebugFormat(
+//                    "[INSTANT MESSAGE]: Looking for child of {0} in {1}", toAgentID, scene.RegionInfo.RegionName);
                 ScenePresence sp = scene.GetScenePresence(toAgentID);
                 if (sp != null)
                 {
                     // Local message
-                    m_log.DebugFormat("[INSTANT MESSAGE]: Delivering IM to child agent {0} {1}", sp.Name, toAgentID);
-
+//                    m_log.DebugFormat("[INSTANT MESSAGE]: Delivering IM to child agent {0} {1}", user.Name, toAgentID);
                     sp.ControllingClient.SendInstantMessage(im);
 
                     // Message sent
@@ -174,9 +170,10 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                 }
             }
 
-            m_log.DebugFormat("[INSTANT MESSAGE]: Delivering IM to {0} via XMLRPC", im.toAgentID);
-
+//            m_log.DebugFormat("[INSTANT MESSAGE]: Delivering IM to {0} via XMLRPC", im.toAgentID);
             SendGridInstantMessageViaXMLRPC(im, result);
+
+            return;
         }
 
         private void HandleUndeliveredMessage(GridInstantMessage im, MessageResultNotification result)

OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveTestCase.cs

@@ -48,7 +48,7 @@ using OpenSim.Tests.Common.Mock;
 namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
 {
     [TestFixture]
-    public class InventoryArchiveTestCase : OpenSimTestCase
+    public class InventoryArchiveTestCase
     {
         protected ManualResetEvent mre = new ManualResetEvent(false);
         
@@ -84,9 +84,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
         protected string m_coaItemName = "Coalesced Item";
         
         [SetUp]
-        public override void SetUp()
+        public virtual void SetUp()
         {
-            base.SetUp();
             m_iarStream = new MemoryStream(m_iarStreamBytes);
         }
         

OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiverTests.cs

@@ -350,38 +350,38 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests
             Assert.That(sog1.RootPart.CreatorID, Is.EqualTo(m_uaLL1.PrincipalID));            
         }
         
-//        /// <summary>
-//        /// Test loading a V0.1 OpenSim Inventory Archive (subject to change since there is no fixed format yet) where
-//        /// an account exists with the same name as the creator, though not the same id.
-//        /// </summary>
-//        [Test]
-//        public void TestLoadIarV0_1SameNameCreator()
-//        {
-//            TestHelpers.InMethod();
-//            TestHelpers.EnableLogging();
-//
-//            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaMT, "meowfood");
-//            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaLL2, "hampshire");
-//            
-//            m_archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "/", "meowfood", m_iarStream);            
-//            InventoryItemBase foundItem1
-//                = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, m_uaMT.PrincipalID, m_item1Name);
-//
-//            Assert.That(
-//                foundItem1.CreatorId, Is.EqualTo(m_uaLL2.PrincipalID.ToString()), 
-//                "Loaded item non-uuid creator doesn't match original");            
-//            Assert.That(
-//                foundItem1.CreatorIdAsUuid, Is.EqualTo(m_uaLL2.PrincipalID), 
-//                "Loaded item uuid creator doesn't match original");
-//            Assert.That(foundItem1.Owner, Is.EqualTo(m_uaMT.PrincipalID),
-//                "Loaded item owner doesn't match inventory reciever");
-//            
-//            AssetBase asset1 = m_scene.AssetService.Get(foundItem1.AssetID.ToString());            
-//            string xmlData = Utils.BytesToString(asset1.Data);
-//            SceneObjectGroup sog1 = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
-//            
-//            Assert.That(sog1.RootPart.CreatorID, Is.EqualTo(m_uaLL2.PrincipalID));
-//        }
+        /// <summary>
+        /// Test loading a V0.1 OpenSim Inventory Archive (subject to change since there is no fixed format yet) where
+        /// an account exists with the same name as the creator, though not the same id.
+        /// </summary>
+        [Test]
+        public void TestLoadIarV0_1SameNameCreator()
+        {
+            TestHelpers.InMethod();
+//            log4net.Config.XmlConfigurator.Configure();
+
+            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaMT, "meowfood");
+            UserAccountHelpers.CreateUserWithInventory(m_scene, m_uaLL2, "hampshire");
+            
+            m_archiverModule.DearchiveInventory(m_uaMT.FirstName, m_uaMT.LastName, "/", "meowfood", m_iarStream);            
+            InventoryItemBase foundItem1
+                = InventoryArchiveUtils.FindItemByPath(m_scene.InventoryService, m_uaMT.PrincipalID, m_item1Name);
+
+            Assert.That(
+                foundItem1.CreatorId, Is.EqualTo(m_uaLL2.PrincipalID.ToString()), 
+                "Loaded item non-uuid creator doesn't match original");            
+            Assert.That(
+                foundItem1.CreatorIdAsUuid, Is.EqualTo(m_uaLL2.PrincipalID), 
+                "Loaded item uuid creator doesn't match original");
+            Assert.That(foundItem1.Owner, Is.EqualTo(m_uaMT.PrincipalID),
+                "Loaded item owner doesn't match inventory reciever");
+            
+            AssetBase asset1 = m_scene.AssetService.Get(foundItem1.AssetID.ToString());            
+            string xmlData = Utils.BytesToString(asset1.Data);
+            SceneObjectGroup sog1 = SceneObjectSerializer.FromOriginalXmlFormat(xmlData);
+            
+            Assert.That(sog1.RootPart.CreatorID, Is.EqualTo(m_uaLL2.PrincipalID));
+        }
 
         /// <summary>
         /// Test loading a V0.1 OpenSim Inventory Archive (subject to change since there is no fixed format yet) where

OpenSim/Region/CoreModules/Avatar/Inventory/Transfer/InventoryTransferModule.cs

@@ -297,9 +297,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Transfer
                         });
                 }
             }
-            else if (
-                im.dialog == (byte)InstantMessageDialog.InventoryDeclined
-                || im.dialog == (byte)InstantMessageDialog.TaskInventoryDeclined)
+            else if (im.dialog == (byte) InstantMessageDialog.InventoryDeclined)
             {
                 // Here, the recipient is local and we can assume that the
                 // inventory is loaded. Courtesy of the above bulk update,

OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs

@@ -644,7 +644,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 // an agent cannot teleport back to this region if it has teleported away.
                 Thread.Sleep(2000);
 
-                sp.Scene.IncomingCloseAgent(sp.UUID, false);
+                sp.Scene.IncomingCloseAgent(sp.UUID);
             }
             else
             {
@@ -709,11 +709,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 agent.CallbackURI, region.RegionName);
         }
 
-        /// <summary>
-        /// Clean up operations once an agent has moved away through cross or teleport.
-        /// </summary>
-        /// <param name='sp'></param>
-        /// <param name='logout'></param>
         protected virtual void AgentHasMovedAway(ScenePresence sp, bool logout)
         {
             if (sp.Scene.AttachmentsModule != null)
@@ -1671,7 +1666,6 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
         #endregion
 
         #region Object Transfers
-
         /// <summary>
         /// Move the given scene object into a new region depending on which region its absolute position has moved
         /// into.
@@ -1973,43 +1967,35 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             return successYN;
         }
 
-        /// <summary>
-        /// Cross the attachments for an avatar into the destination region.
-        /// </summary>
-        /// <remarks>
-        /// This is only invoked for simulators released prior to April 2011.  Versions of OpenSimulator since then
-        /// transfer attachments in one go as part of the ChildAgentDataUpdate data passed in the update agent call.
-        /// </remarks>
-        /// <param name='destination'></param>
-        /// <param name='sp'></param>
-        /// <param name='silent'></param>
-        protected void CrossAttachmentsIntoNewRegion(GridRegion destination, ScenePresence sp, bool silent)
+        protected bool CrossAttachmentsIntoNewRegion(GridRegion destination, ScenePresence sp, bool silent)
         {
-            List<SceneObjectGroup> attachments = sp.GetAttachments();
+            List<SceneObjectGroup> m_attachments = sp.GetAttachments();
 
-//            m_log.DebugFormat(
-//                "[ENTITY TRANSFER MODULE]: Crossing {0} attachments into {1} for {2}",
-//                m_attachments.Count, destination.RegionName, sp.Name);
+            // Validate
+//            foreach (SceneObjectGroup gobj in m_attachments)
+//            {
+//                if (gobj == null || gobj.IsDeleted)
+//                    return false;
+//            }
 
-            foreach (SceneObjectGroup gobj in attachments)
+            foreach (SceneObjectGroup gobj in m_attachments)
             {
                 // If the prim group is null then something must have happened to it!
                 if (gobj != null && !gobj.IsDeleted)
                 {
-                    SceneObjectGroup clone = (SceneObjectGroup)gobj.CloneForNewScene();
-                    clone.RootPart.GroupPosition = gobj.RootPart.AttachedPos;
-                    clone.IsAttachment = false;
-
+                    // Set the parent localID to 0 so it transfers over properly.
+                    gobj.RootPart.SetParentLocalId(0);
+                    gobj.AbsolutePosition = gobj.RootPart.AttachedPos;
+                    gobj.IsAttachment = false;
                     //gobj.RootPart.LastOwnerID = gobj.GetFromAssetID();
-                    m_log.DebugFormat(
-                        "[ENTITY TRANSFER MODULE]: Sending attachment {0} to region {1}",
-                        clone.UUID, destination.RegionName);
-
-                    CrossPrimGroupIntoNewRegion(destination, Vector3.Zero, clone, silent);
+                    m_log.DebugFormat("[ENTITY TRANSFER MODULE]: Sending attachment {0} to region {1}", gobj.UUID, destination.RegionName);
+                    CrossPrimGroupIntoNewRegion(destination, Vector3.Zero, gobj, silent);
                 }
             }
 
             sp.ClearAttachments();
+
+            return true;
         }
 
         #endregion

OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs

@@ -204,9 +204,8 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
 
                     AssetBase asset = m_Scene.CreateAsset(name, description, assetType, data, remoteClient.AgentId);
                     m_Scene.AssetService.Store(asset);
-                    m_Scene.CreateNewInventoryItem(
-                        remoteClient, remoteClient.AgentId.ToString(), string.Empty, folderID,
-                        name, description, 0, callbackID, asset, invType, nextOwnerMask, creationDate);
+
+                    m_Scene.CreateNewInventoryItem(remoteClient, remoteClient.AgentId.ToString(), string.Empty, folderID, asset.Name, 0, callbackID, asset, invType, nextOwnerMask, creationDate);
                 }
                 else
                 {

OpenSim/Region/CoreModules/Framework/Statistics/Logging/BinaryLoggingModule.cs

@@ -39,7 +39,7 @@ using OpenSim.Region.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 
-namespace OpenSim.Region.CoreModules.Framework.Statistics.Logging
+namespace OpenSim.Region.CoreModules.Avatar.Attachments
 {
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "BinaryLoggingModule")]
     public class BinaryLoggingModule : INonSharedRegionModule

OpenSim/Region/CoreModules/Framework/Statistics/Logging/LogWriter.cs

@@ -1,161 +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 System;
-using System.IO;
-using System.Text;
-using log4net;
-
-namespace OpenSim.Region.CoreModules.Framework.Statistics.Logging
-{
-    /// <summary>
-    /// Class for writing a high performance, high volume log file.
-    /// Sometimes, to debug, one has a high volume logging to do and the regular
-    /// log file output is not appropriate.
-    /// Create a new instance with the parameters needed and
-    /// call Write() to output a line. Call Close() when finished.
-    /// If created with no parameters, it will not log anything.
-    /// </summary>
-    public class LogWriter : IDisposable
-    {
-        public bool Enabled { get; private set; }
-
-        private string m_logDirectory = ".";
-        private int m_logMaxFileTimeMin = 5;    // 5 minutes
-        public String LogFileHeader { get; set; }
-
-        private StreamWriter m_logFile = null;
-        private TimeSpan m_logFileLife;
-        private DateTime m_logFileEndTime;
-        private Object m_logFileWriteLock = new Object();
-
-        // set externally when debugging. If let 'null', this does not write any error messages.
-        public ILog ErrorLogger = null;
-        private string LogHeader = "[LOG WRITER]";
-
-        /// <summary>
-        /// Create a log writer that will not write anything. Good for when not enabled
-        /// but the write statements are still in the code.
-        /// </summary>
-        public LogWriter()
-        {
-            Enabled = false;
-            m_logFile = null;
-        }
-
-        /// <summary>
-        /// Create a log writer instance.
-        /// </summary>
-        /// <param name="dir">The directory to create the log file in. May be 'null' for default.</param>
-        /// <param name="headr">The characters that begin the log file name. May be 'null' for default.</param>
-        /// <param name="maxFileTime">Maximum age of a log file in minutes. If zero, will set default.</param>
-        public LogWriter(string dir, string headr, int maxFileTime)
-        {
-            m_logDirectory = dir == null ? "." : dir;
-
-            LogFileHeader = headr == null ? "log-" : headr;
-
-            m_logMaxFileTimeMin = maxFileTime;
-            if (m_logMaxFileTimeMin < 1)
-                m_logMaxFileTimeMin = 5;
-
-            m_logFileLife = new TimeSpan(0, m_logMaxFileTimeMin, 0);
-            m_logFileEndTime = DateTime.Now + m_logFileLife;
-
-            Enabled = true;
-        }
-
-        public void Dispose()
-        {
-            this.Close();
-        }
-
-        public void Close()
-        {
-            Enabled = false;
-            if (m_logFile != null)
-            {
-                m_logFile.Close();
-                m_logFile.Dispose();
-                m_logFile = null;
-            }
-        }
-
-        public void Write(string line, params object[] args)
-        {
-            if (!Enabled) return;
-            Write(String.Format(line, args));
-        }
-
-        public void Write(string line)
-        {
-            if (!Enabled) return;
-            try
-            {
-                lock (m_logFileWriteLock)
-                {
-                    DateTime now = DateTime.Now;
-                    if (m_logFile == null || now > m_logFileEndTime)
-                    {
-                        if (m_logFile != null)
-                        {
-                            m_logFile.Close();
-                            m_logFile.Dispose();
-                            m_logFile = null;
-                        }
-
-                        // First log file or time has expired, start writing to a new log file
-                        m_logFileEndTime = now + m_logFileLife;
-                        string path = (m_logDirectory.Length > 0 ? m_logDirectory
-                                    + System.IO.Path.DirectorySeparatorChar.ToString() : "")
-                                + String.Format("{0}{1}.log", LogFileHeader, now.ToString("yyyyMMddHHmmss"));
-                        m_logFile = new StreamWriter(File.Open(path, FileMode.Append, FileAccess.Write));
-                    }
-                    if (m_logFile != null)
-                    {
-                        StringBuilder buff = new StringBuilder(line.Length + 25);
-                        buff.Append(now.ToString("yyyyMMddHHmmssfff"));
-                        // buff.Append(now.ToString("yyyyMMddHHmmss"));
-                        buff.Append(",");
-                        buff.Append(line);
-                        buff.Append("\r\n");
-                        m_logFile.Write(buff.ToString());
-                    }
-                }
-            }
-            catch (Exception e)
-            {
-                if (ErrorLogger != null)
-                {
-                    ErrorLogger.ErrorFormat("{0}: FAILURE WRITING TO LOGFILE: {1}", LogHeader, e);
-                }
-                Enabled = false;
-            }
-            return;
-        }
-    }
-}

OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs

@@ -40,7 +40,6 @@ using OpenMetaverse;
 using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using OpenSim.Framework.Capabilities;
-using OpenSim.Framework.Monitoring;
 using OpenSim.Framework.Servers;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;

OpenSim/Region/CoreModules/Resources/CoreModulePlugin.addin.xml

@@ -79,6 +79,7 @@
         <RegionModule id="AuthenticationServiceInConnectorModule" type="OpenSim.Region.CoreModules.ServiceConnectorsIn.Authentication.AuthenticationServiceInConnectorModule" />
         <RegionModule id="AccessModule" type="OpenSim.Region.CoreModules.World.AccessModule" />    \
         <RegionModule id="MapImageModule" type="OpenSim.Region.CoreModules.World.LegacyMap.MapImageModule" />    \
+        <RegionModule id="Warp3DImageModule" type="OpenSim.Region.CoreModules.World.Warp3DMap.Warp3DImageModule" />    \
 
     </Extension>
 

OpenSim/Region/CoreModules/Scripting/DynamicTexture/DynamicTextureModule.cs

@@ -49,11 +49,6 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
         public const int DISP_EXPIRE = 1;
         public const int DISP_TEMP   = 2;
 
-        /// <summary>
-        /// If true then where possible dynamic textures are reused.
-        /// </summary>
-        public bool ReuseTextures { get; set; }
-
         private Dictionary<UUID, Scene> RegisteredScenes = new Dictionary<UUID, Scene>();
 
         private Dictionary<string, IDynamicTextureRender> RenderPlugins =
@@ -61,15 +56,6 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
 
         private Dictionary<UUID, DynamicTextureUpdater> Updaters = new Dictionary<UUID, DynamicTextureUpdater>();
 
-        /// <summary>
-        /// Record dynamic textures that we can reuse for a given data and parameter combination rather than
-        /// regenerate.
-        /// </summary>
-        /// <remarks>
-        /// Key is string.Format("{0}{1}", data
-        /// </remarks>
-        private Cache m_reuseableDynamicTextures;
-
         #region IDynamicTextureManager Members
 
         public void RegisterRender(string handleType, IDynamicTextureRender render)
@@ -85,8 +71,7 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
         /// </summary>
         /// <param name="id"></param>
         /// <param name="data"></param>
-        /// <param name="isReuseable">True if the data generated can be reused for subsequent identical requests</param>
-        public void ReturnData(UUID id, byte[] data, bool isReuseable)
+        public void ReturnData(UUID id, byte[] data)
         {
             DynamicTextureUpdater updater = null;
 
@@ -103,11 +88,7 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
                 if (RegisteredScenes.ContainsKey(updater.SimUUID))
                 {
                     Scene scene = RegisteredScenes[updater.SimUUID];
-                    UUID newTextureID = updater.DataReceived(data, scene);
-
-                    if (ReuseTextures && isReuseable && !updater.BlendWithOldTexture)
-                        m_reuseableDynamicTextures.Store(
-                            GenerateReusableTextureKey(updater.BodyData, updater.Params), newTextureID);
+                    updater.DataReceived(data, scene);
                 }
             }
 
@@ -186,61 +167,22 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
         public UUID AddDynamicTextureData(UUID simID, UUID primID, string contentType, string data,
                                           string extraParams, int updateTimer, bool SetBlending, int disp, byte AlphaValue, int face)
         {
-            if (!RenderPlugins.ContainsKey(contentType))
-                return UUID.Zero;
-
-            Scene scene;
-            RegisteredScenes.TryGetValue(simID, out scene);
-
-            if (scene == null)
-                return UUID.Zero;
-
-            SceneObjectPart part = scene.GetSceneObjectPart(primID);
-
-            if (part == null)
-                return UUID.Zero;
-
-            // If we want to reuse dynamic textures then we have to ignore any request from the caller to expire
-            // them.
-            if (ReuseTextures)
-                disp = disp & ~DISP_EXPIRE;
-
-            DynamicTextureUpdater updater = new DynamicTextureUpdater();
-            updater.SimUUID = simID;
-            updater.PrimID = primID;
-            updater.ContentType = contentType;
-            updater.BodyData = data;
-            updater.UpdateTimer = updateTimer;
-            updater.UpdaterID = UUID.Random();
-            updater.Params = extraParams;
-            updater.BlendWithOldTexture = SetBlending;
-            updater.FrontAlpha = AlphaValue;
-            updater.Face = face;
-            updater.Url = "Local image";
-            updater.Disp = disp;
-
-            object objReusableTextureUUID = null;
-
-            if (ReuseTextures && !updater.BlendWithOldTexture)
+            if (RenderPlugins.ContainsKey(contentType))
             {
-                string reuseableTextureKey = GenerateReusableTextureKey(data, extraParams);
-                objReusableTextureUUID = m_reuseableDynamicTextures.Get(reuseableTextureKey);
+                DynamicTextureUpdater updater = new DynamicTextureUpdater();
+                updater.SimUUID = simID;
+                updater.PrimID = primID;
+                updater.ContentType = contentType;
+                updater.BodyData = data;
+                updater.UpdateTimer = updateTimer;
+                updater.UpdaterID = UUID.Random();
+                updater.Params = extraParams;
+                updater.BlendWithOldTexture = SetBlending;
+                updater.FrontAlpha = AlphaValue;
+                updater.Face = face;
+                updater.Url = "Local image";
+                updater.Disp = disp;
 
-                if (objReusableTextureUUID != null)
-                {
-                    // If something else has removed this temporary asset from the cache, detect and invalidate
-                    // our cached uuid.
-                    if (scene.AssetService.GetMetadata(objReusableTextureUUID.ToString()) == null)
-                    {
-                        m_reuseableDynamicTextures.Invalidate(reuseableTextureKey);
-                        objReusableTextureUUID = null;
-                    }
-                }
-            }
-
-            // We cannot reuse a dynamic texture if the data is going to be blended with something already there.
-            if (objReusableTextureUUID == null)
-            {
                 lock (Updaters)
                 {
                     if (!Updaters.ContainsKey(updater.UpdaterID))
@@ -250,20 +192,10 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
                 }
 
                 RenderPlugins[contentType].AsyncConvertData(updater.UpdaterID, data, extraParams);
+                return updater.UpdaterID;
             }
-            else
-            {
-                // No need to add to updaters as the texture is always the same.  Not that this functionality
-                // apppears to be implemented anyway.
-                updater.UpdatePart(part, (UUID)objReusableTextureUUID);
-            }
-
-            return updater.UpdaterID;
-        }
-
-        private string GenerateReusableTextureKey(string data, string extraParams)
-        {
-            return string.Format("{0}{1}", data, extraParams);
+            
+            return UUID.Zero;
         }
 
         public void GetDrawStringSize(string contentType, string text, string fontName, int fontSize,
@@ -283,10 +215,6 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
 
         public void Initialise(Scene scene, IConfigSource config)
         {
-            IConfig texturesConfig = config.Configs["Textures"];
-            if (texturesConfig != null)
-                ReuseTextures = texturesConfig.GetBoolean("ReuseDynamicTextures", false);
-
             if (!RegisteredScenes.ContainsKey(scene.RegionInfo.RegionID))
             {
                 RegisteredScenes.Add(scene.RegionInfo.RegionID, scene);
@@ -296,11 +224,6 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
 
         public void PostInitialise()
         {
-            if (ReuseTextures)
-            {
-                m_reuseableDynamicTextures = new Cache(CacheMedium.Memory, CacheStrategy.Conservative);
-                m_reuseableDynamicTextures.DefaultTTL = new TimeSpan(24, 0, 0);
-            }
         }
 
         public void Close()
@@ -345,61 +268,10 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
                 BodyData = null;
             }
 
-            /// <summary>
-            /// Update the given part with the new texture.
-            /// </summary>
-            /// <returns>
-            /// The old texture UUID.
-            /// </returns>
-            public UUID UpdatePart(SceneObjectPart part, UUID textureID)
-            {
-                UUID oldID;
-
-                lock (part)
-                {
-                    // mostly keep the values from before
-                    Primitive.TextureEntry tmptex = part.Shape.Textures;
-
-                    // FIXME: Need to return the appropriate ID if only a single face is replaced.
-                    oldID = tmptex.DefaultTexture.TextureID;
-
-                    if (Face == ALL_SIDES)
-                    {
-                        oldID = tmptex.DefaultTexture.TextureID;
-                        tmptex.DefaultTexture.TextureID = textureID;
-                    }
-                    else
-                    {
-                        try
-                        {
-                            Primitive.TextureEntryFace texface = tmptex.CreateFace((uint)Face);
-                            texface.TextureID = textureID;
-                            tmptex.FaceTextures[Face] = texface;
-                        }
-                        catch (Exception)
-                        {
-                            tmptex.DefaultTexture.TextureID = textureID;
-                        }
-                    }
-
-                    // I'm pretty sure we always want to force this to true
-                    // I'm pretty sure noone whats to set fullbright true if it wasn't true before.
-                    // tmptex.DefaultTexture.Fullbright = true;
-
-                    part.UpdateTextureEntry(tmptex.GetBytes());
-                }
-
-                return oldID;
-            }
-
             /// <summary>
             /// Called once new texture data has been received for this updater.
             /// </summary>
-            /// <param name="data"></param>
-            /// <param name="scene"></param>
-            /// <param name="isReuseable">True if the data given is reuseable.</param>
-            /// <returns>The asset UUID given to the incoming data.</returns>
-            public UUID DataReceived(byte[] data, Scene scene)
+            public void DataReceived(byte[] data, Scene scene)
             {
                 SceneObjectPart part = scene.GetSceneObjectPart(PrimID);
 
@@ -409,8 +281,7 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
                         String.Format("DynamicTextureModule: Error preparing image using URL {0}", Url);
                     scene.SimChat(Utils.StringToBytes(msg), ChatTypeEnum.Say,
                                   0, part.ParentGroup.RootPart.AbsolutePosition, part.Name, part.UUID, false);
-                    
-                    return UUID.Zero;
+                    return;
                 }
 
                 byte[] assetData = null;
@@ -452,23 +323,52 @@ namespace OpenSim.Region.CoreModules.Scripting.DynamicTexture
                     cacheLayerDecode = null;
                 }
 
-                UUID oldID = UpdatePart(part, asset.FullID);
+                UUID oldID = UUID.Zero;
+
+                lock (part)
+                {
+                    // mostly keep the values from before
+                    Primitive.TextureEntry tmptex = part.Shape.Textures;
+
+                    // remove the old asset from the cache
+                    oldID = tmptex.DefaultTexture.TextureID;
+                    
+                    if (Face == ALL_SIDES)
+                    {
+                        tmptex.DefaultTexture.TextureID = asset.FullID;
+                    }
+                    else
+                    {
+                        try
+                        {
+                            Primitive.TextureEntryFace texface = tmptex.CreateFace((uint)Face);
+                            texface.TextureID = asset.FullID;
+                            tmptex.FaceTextures[Face] = texface;
+                        }
+                        catch (Exception)
+                        {
+                            tmptex.DefaultTexture.TextureID = asset.FullID;
+                        }
+                    }
+
+                    // I'm pretty sure we always want to force this to true
+                    // I'm pretty sure noone whats to set fullbright true if it wasn't true before.
+                    // tmptex.DefaultTexture.Fullbright = true;
+
+                    part.UpdateTextureEntry(tmptex.GetBytes());
+                }
 
                 if (oldID != UUID.Zero && ((Disp & DISP_EXPIRE) != 0))
                 {
-                    if (oldAsset == null)
-                        oldAsset = scene.AssetService.Get(oldID.ToString());
-
+                    if (oldAsset == null) oldAsset = scene.AssetService.Get(oldID.ToString());
                     if (oldAsset != null)
                     {
-                        if (oldAsset.Temporary)
+                        if (oldAsset.Temporary == true)
                         {
                             scene.AssetService.Delete(oldID.ToString());
                         }
                     }
                 }
-
-                return asset.FullID;
             }
 
             private byte[] BlendTextures(byte[] frontImage, byte[] backImage, bool setNewAlpha, byte newAlpha)

OpenSim/Region/CoreModules/Scripting/LSLHttp/UrlModule.cs

@@ -41,39 +41,13 @@ using OpenSim.Region.Framework.Scenes;
 
 namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
 {
-    /// <summary>
-    /// Data describing an external URL set up by a script.
-    /// </summary>
     public class UrlData
     {
-        /// <summary>
-        /// Scene object part hosting the script
-        /// </summary>
         public UUID hostID;
-
-        /// <summary>
-        /// The item ID of the script that requested the URL.
-        /// </summary>
         public UUID itemID;
-
-        /// <summary>
-        /// The script engine that runs the script.
-        /// </summary>
         public IScriptModule engine;
-
-        /// <summary>
-        /// The generated URL.
-        /// </summary>
         public string url;
-
-        /// <summary>
-        /// The random UUID component of the generated URL.
-        /// </summary>
         public UUID urlcode;
-
-        /// <summary>
-        /// The external requests currently being processed or awaiting retrieval for this URL.
-        /// </summary>
         public Dictionary<UUID, RequestData> requests;
     }
 
@@ -84,40 +58,25 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
         public string body;
         public int responseCode;
         public string responseBody;
-        public string responseType = "text/plain";
         //public ManualResetEvent ev;
         public bool requestDone;
         public int startTime;
         public string uri;
     }
 
-    /// <summary>
-    /// This module provides external URLs for in-world scripts.
-    /// </summary>
     public class UrlModule : ISharedRegionModule, IUrlModule
     {
         private static readonly ILog m_log =
                 LogManager.GetLogger(
                 MethodBase.GetCurrentMethod().DeclaringType);
 
-        /// <summary>
-        /// Indexs the URL request metadata (which script requested it, outstanding requests, etc.) by the request ID
-        /// randomly generated when a request is received for this URL.
-        /// </summary>
-        /// <remarks>
-        /// Manipulation or retrieval from this dictionary must be locked on m_UrlMap to preserve consistency with
-        /// m_UrlMap
-        /// </remarks>
-        private Dictionary<UUID, UrlData> m_RequestMap = new Dictionary<UUID, UrlData>();
+        private Dictionary<UUID, UrlData> m_RequestMap =
+                new Dictionary<UUID, UrlData>();
+
+        private Dictionary<string, UrlData> m_UrlMap =
+                new Dictionary<string, UrlData>();
 
-        /// <summary>
-        /// Indexs the URL request metadata (which script requested it, outstanding requests, etc.) by the full URL
-        /// </summary>
-        private Dictionary<string, UrlData> m_UrlMap = new Dictionary<string, UrlData>();
 
-        /// <summary>
-        /// Maximum number of external urls that can be set up by this module.
-        /// </summary>
         private int m_TotalUrls = 100;
 
         private uint https_port = 0;
@@ -144,14 +103,10 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
         {
             m_ExternalHostNameForLSL = config.Configs["Network"].GetString("ExternalHostNameForLSL", System.Environment.MachineName);
             bool ssl_enabled = config.Configs["Network"].GetBoolean("https_listener",false);
-
             if (ssl_enabled)
+            {
                 https_port = (uint) config.Configs["Network"].GetInt("https_port",0);
-
-            IConfig llFunctionsConfig = config.Configs["LL-Functions"];
-
-            if (llFunctionsConfig != null)
-                m_TotalUrls = llFunctionsConfig.GetInt("max_external_urls_per_simulator", m_TotalUrls);
+            }
         }
 
         public void PostInitialise()
@@ -262,6 +217,7 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
                 urlData.urlcode = urlcode;
                 urlData.requests = new Dictionary<UUID, RequestData>();
 
+                
                 m_UrlMap[url] = urlData;
                 
                 string uri = "/lslhttps/" + urlcode.ToString() + "/";
@@ -303,65 +259,41 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
             }
         }
         
-        public void HttpContentType(UUID request, string type)
-        {
-            lock (m_UrlMap)
-            {
-                if (m_RequestMap.ContainsKey(request))
-                {
-                    UrlData urlData = m_RequestMap[request];
-                    urlData.requests[request].responseType = type;
-                }
-                else
-                {
-                    m_log.Info("[HttpRequestHandler] There is no http-in request with id " + request.ToString());
-                }
-            }
-        }
-        
         public void HttpResponse(UUID request, int status, string body)
         {
-            lock (m_UrlMap)
+            if (m_RequestMap.ContainsKey(request))
             {
-                if (m_RequestMap.ContainsKey(request))
-                {
-                    UrlData urlData = m_RequestMap[request];
-                    urlData.requests[request].responseCode = status;
-                    urlData.requests[request].responseBody = body;
-                    //urlData.requests[request].ev.Set();
-                    urlData.requests[request].requestDone =true;
-                }
-                else
-                {
-                    m_log.Info("[HttpRequestHandler] There is no http-in request with id " + request.ToString());
-                }
+                UrlData urlData = m_RequestMap[request];
+                urlData.requests[request].responseCode = status;
+                urlData.requests[request].responseBody = body;
+                //urlData.requests[request].ev.Set();
+                urlData.requests[request].requestDone =true;
+            }
+            else
+            {
+                m_log.Info("[HttpRequestHandler] There is no http-in request with id " + request.ToString());
             }
         }
 
         public string GetHttpHeader(UUID requestId, string header)
         {
-            lock (m_UrlMap)
+            if (m_RequestMap.ContainsKey(requestId))
             {
-                if (m_RequestMap.ContainsKey(requestId))
-                {
-                    UrlData urlData = m_RequestMap[requestId];
-                    string value;
-                    if (urlData.requests[requestId].headers.TryGetValue(header, out value))
-                        return value;
-                }
-                else
-                {
-                    m_log.Warn("[HttpRequestHandler] There was no http-in request with id " + requestId);
-                }
+                UrlData urlData=m_RequestMap[requestId];
+                string value;
+                if (urlData.requests[requestId].headers.TryGetValue(header,out value))
+                    return value;
+            }
+            else
+            {
+                m_log.Warn("[HttpRequestHandler] There was no http-in request with id " + requestId);
             }
-
             return String.Empty;
         }
 
         public int GetFreeUrls()
         {
-            lock (m_UrlMap)
-                return m_TotalUrls - m_UrlMap.Count;
+            return m_TotalUrls - m_UrlMap.Count;
         }
 
         public void ScriptRemoved(UUID itemID)
@@ -400,7 +332,6 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
                     {
                         RemoveUrl(url.Value);
                         removeURLs.Add(url.Key);
-
                         foreach (UUID req in url.Value.requests.Keys)
                             m_RequestMap.Remove(req);
                     }
@@ -411,166 +342,145 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
             }
         }
 
+
         private void RemoveUrl(UrlData data)
         {
-            m_HttpServer.RemoveHTTPHandler("", "/lslhttp/" + data.urlcode.ToString() + "/");
+            m_HttpServer.RemoveHTTPHandler("", "/lslhttp/"+data.urlcode.ToString()+"/");
         }
 
         private Hashtable NoEvents(UUID requestID, UUID sessionID)
         {
             Hashtable response = new Hashtable();
-            UrlData urlData;
-
-            lock (m_UrlMap)
+            UrlData url;
+            lock (m_RequestMap)
             {
-                // We need to return a 404 here in case the request URL was removed at exactly the same time that a
-                // request was made.  In this case, the request thread can outrace llRemoveURL() and still be polling
-                // for the request ID.
                 if (!m_RequestMap.ContainsKey(requestID))
-                {
-                    response["int_response_code"] = 404;
-                    response["str_response_string"] = "";
-                    response["keepalive"] = false;
-                    response["reusecontext"] = false;
-
                     return response;
-                }
-
-                urlData = m_RequestMap[requestID];
-
-                if (System.Environment.TickCount - urlData.requests[requestID].startTime > 25000)
-                {
-                    response["int_response_code"] = 500;
-                    response["str_response_string"] = "Script timeout";
-                    response["content_type"] = "text/plain";
-                    response["keepalive"] = false;
-                    response["reusecontext"] = false;
-    
-                    //remove from map
-                    urlData.requests.Remove(requestID);
-                    m_RequestMap.Remove(requestID);
-
-                    return response;
-                }
+                url = m_RequestMap[requestID];
             }
 
+            if (System.Environment.TickCount - url.requests[requestID].startTime > 25000)
+            {
+                response["int_response_code"] = 500;
+                response["str_response_string"] = "Script timeout";
+                response["content_type"] = "text/plain";
+                response["keepalive"] = false;
+                response["reusecontext"] = false;
+
+                //remove from map
+                lock (url)
+                {
+                    url.requests.Remove(requestID);
+                    m_RequestMap.Remove(requestID);
+                }
+
+                return response;
+            }
+
+            
             return response;
         }
 
         private bool HasEvents(UUID requestID, UUID sessionID)
         {
-            lock (m_UrlMap)
+            UrlData url=null;
+            
+            lock (m_RequestMap)
             {
-                // We return true here because an external URL request that happened at the same time as an llRemoveURL()
-                // can still make it through to HttpRequestHandler().  That will return without setting up a request
-                // when it detects that the URL has been removed.  The poller, however, will continue to ask for
-                // events for that request, so here we will signal that there are events and in GetEvents we will
-                // return a 404.
                 if (!m_RequestMap.ContainsKey(requestID))
                 {
-                    return true;
+                    return false;
                 }
-
-                UrlData urlData = m_RequestMap[requestID];
-
-                if (!urlData.requests.ContainsKey(requestID))
+                url = m_RequestMap[requestID];
+                if (!url.requests.ContainsKey(requestID))
                 {
-                    return true;
+                    return false;
                 }
-
-                // Trigger return of timeout response.
-                if (System.Environment.TickCount - urlData.requests[requestID].startTime > 25000)
-                {
-                    return true;
-                }
-
-                return urlData.requests[requestID].requestDone;
             }
-        }
 
+            if (System.Environment.TickCount-url.requests[requestID].startTime>25000)
+            {
+                return true;
+            }
+
+            if (url.requests[requestID].requestDone)
+                return true;
+            else
+                return false;
+
+        }
         private Hashtable GetEvents(UUID requestID, UUID sessionID, string request)
         {
-            Hashtable response;
+             UrlData url = null;
+            RequestData requestData = null;
 
-            lock (m_UrlMap)
+            lock (m_RequestMap)
             {
-                UrlData url = null;
-                RequestData requestData = null;
-
                 if (!m_RequestMap.ContainsKey(requestID))
-                    return NoEvents(requestID, sessionID);
-
+                    return NoEvents(requestID,sessionID);
                 url = m_RequestMap[requestID];
                 requestData = url.requests[requestID];
+            }
 
-                if (!requestData.requestDone)
-                    return NoEvents(requestID, sessionID);
+            if (!requestData.requestDone)
+                return NoEvents(requestID,sessionID);
+            
+            Hashtable response = new Hashtable();
 
-                response = new Hashtable();
-
-                if (System.Environment.TickCount - requestData.startTime > 25000)
-                {
-                    response["int_response_code"] = 500;
-                    response["str_response_string"] = "Script timeout";
-                    response["content_type"] = "text/plain";
-                    response["keepalive"] = false;
-                    response["reusecontext"] = false;
-                    return response;
-                }
-
-                //put response
-                response["int_response_code"] = requestData.responseCode;
-                response["str_response_string"] = requestData.responseBody;
-                response["content_type"] = requestData.responseType;
-                // response["content_type"] = "text/plain";
+            if (System.Environment.TickCount - requestData.startTime > 25000)
+            {
+                response["int_response_code"] = 500;
+                response["str_response_string"] = "Script timeout";
+                response["content_type"] = "text/plain";
                 response["keepalive"] = false;
                 response["reusecontext"] = false;
-
-                //remove from map
+                return response;
+            }
+            //put response
+            response["int_response_code"] = requestData.responseCode;
+            response["str_response_string"] = requestData.responseBody;
+            response["content_type"] = "text/plain";
+            response["keepalive"] = false;
+            response["reusecontext"] = false;
+            
+            //remove from map
+            lock (url)
+            {
                 url.requests.Remove(requestID);
                 m_RequestMap.Remove(requestID);
             }
 
             return response;
         }
-
         public void HttpRequestHandler(UUID requestID, Hashtable request)
         {
-            string uri = request["uri"].ToString();
-            bool is_ssl = uri.Contains("lslhttps");
-
-            try
+            lock (request)
             {
-                Hashtable headers = (Hashtable)request["headers"];
+                string uri = request["uri"].ToString();
+                bool is_ssl = uri.Contains("lslhttps");
+
+                try
+                {
+                    Hashtable headers = (Hashtable)request["headers"];
 
 //                    string uri_full = "http://" + m_ExternalHostNameForLSL + ":" + m_HttpServer.Port.ToString() + uri;// "/lslhttp/" + urlcode.ToString() + "/";
 
-                int pos1 = uri.IndexOf("/");// /lslhttp
-                int pos2 = uri.IndexOf("/", pos1 + 1);// /lslhttp/
-                int pos3 = uri.IndexOf("/", pos2 + 1);// /lslhttp/<UUID>/
-                string uri_tmp = uri.Substring(0, pos3 + 1);
-                //HTTP server code doesn't provide us with QueryStrings
-                string pathInfo;
-                string queryString;
-                queryString = "";
+                    int pos1 = uri.IndexOf("/");// /lslhttp
+                    int pos2 = uri.IndexOf("/", pos1 + 1);// /lslhttp/
+                    int pos3 = uri.IndexOf("/", pos2 + 1);// /lslhttp/<UUID>/
+                    string uri_tmp = uri.Substring(0, pos3 + 1);
+                    //HTTP server code doesn't provide us with QueryStrings
+                    string pathInfo;
+                    string queryString;
+                    queryString = "";
 
-                pathInfo = uri.Substring(pos3);
+                    pathInfo = uri.Substring(pos3);
 
-                UrlData urlData = null;
-
-                lock (m_UrlMap)
-                {
-                    string url;
-
-                    if (is_ssl)
-                        url = "https://" + m_ExternalHostNameForLSL + ":" + m_HttpsServer.Port.ToString() + uri_tmp;
+                    UrlData url = null;
+                    if (!is_ssl)
+                        url = m_UrlMap["http://" + m_ExternalHostNameForLSL + ":" + m_HttpServer.Port.ToString() + uri_tmp];
                     else
-                        url = "http://" + m_ExternalHostNameForLSL + ":" + m_HttpServer.Port.ToString() + uri_tmp;
-
-                    // Avoid a race - the request URL may have been released via llRequestUrl() whilst this
-                    // request was being processed.
-                    if (!m_UrlMap.TryGetValue(url, out urlData))
-                        return;
+                        url = m_UrlMap["https://" + m_ExternalHostNameForLSL + ":" + m_HttpsServer.Port.ToString() + uri_tmp];
 
                     //for llGetHttpHeader support we need to store original URI here
                     //to make x-path-info / x-query-string / x-script-url / x-remote-ip headers 
@@ -590,7 +500,6 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
                         string value = (string)header.Value;
                         requestData.headers.Add(key, value);
                     }
-
                     foreach (DictionaryEntry de in request)
                     {
                         if (de.Key.ToString() == "querystringkeys")
@@ -604,10 +513,11 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
                                     queryString = queryString + key + "=" + val + "&";
                                 }
                             }
-
                             if (queryString.Length > 1)
                                 queryString = queryString.Substring(0, queryString.Length - 1);
+
                         }
+
                     }
 
                     //if this machine is behind DNAT/port forwarding, currently this is being
@@ -615,23 +525,34 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
                     requestData.headers["x-remote-ip"] = requestData.headers["remote_addr"];
                     requestData.headers["x-path-info"] = pathInfo;
                     requestData.headers["x-query-string"] = queryString;
-                    requestData.headers["x-script-url"] = urlData.url;
+                    requestData.headers["x-script-url"] = url.url;
+
+                    //requestData.ev = new ManualResetEvent(false);
+                    lock (url.requests)
+                    {
+                        url.requests.Add(requestID, requestData);
+                    }
+                    lock (m_RequestMap)
+                    {
+                        //add to request map
+                        m_RequestMap.Add(requestID, url);
+                    }
+
+                    url.engine.PostScriptEvent(url.itemID, "http_request", new Object[] { requestID.ToString(), request["http-method"].ToString(), request["body"].ToString() });
+
+                    //send initial response?
+//                    Hashtable response = new Hashtable();
+
+                    return;
 
-                    urlData.requests.Add(requestID, requestData);
-                    m_RequestMap.Add(requestID, urlData);
                 }
-
-                urlData.engine.PostScriptEvent(
-                    urlData.itemID,
-                    "http_request",
-                    new Object[] { requestID.ToString(), request["http-method"].ToString(), request["body"].ToString() });
-            }
-            catch (Exception we)
-            {
-                //Hashtable response = new Hashtable();
-                m_log.Warn("[HttpRequestHandler]: http-in request failed");
-                m_log.Warn(we.Message);
-                m_log.Warn(we.StackTrace);
+                catch (Exception we)
+                {
+                    //Hashtable response = new Hashtable();
+                    m_log.Warn("[HttpRequestHandler]: http-in request failed");
+                    m_log.Warn(we.Message);
+                    m_log.Warn(we.StackTrace);
+                }
             }
         }
 
@@ -640,4 +561,4 @@ namespace OpenSim.Region.CoreModules.Scripting.LSLHttp
             ScriptRemoved(itemID);
         }
     }
-}
+}

OpenSim/Region/CoreModules/Scripting/LoadImageURL/LoadImageURLModule.cs

@@ -67,18 +67,12 @@ namespace OpenSim.Region.CoreModules.Scripting.LoadImageURL
             return true;
         }
 
-//        public bool AlwaysIdenticalConversion(string bodyData, string extraParams)
-//        {
-//            // We don't support conversion of body data.
-//            return false;
-//        }
-
         public byte[] ConvertUrl(string url, string extraParams)
         {
             return null;
         }
 
-        public byte[] ConvertData(string bodyData, string extraParams)
+        public byte[] ConvertStream(Stream data, string extraParams)
         {
             return null;
         }
@@ -242,11 +236,9 @@ namespace OpenSim.Region.CoreModules.Scripting.LoadImageURL
                     stream.Close();
                 }
             }
-
             m_log.DebugFormat("[LOADIMAGEURLMODULE] Returning {0} bytes of image data for request {1}",
                                        imageJ2000.Length, state.RequestID);
-
-            m_textureManager.ReturnData(state.RequestID, imageJ2000, false);
+            m_textureManager.ReturnData(state.RequestID, imageJ2000);
         }
 
         #region Nested type: RequestState

OpenSim/Region/CoreModules/Scripting/VectorRender/Tests/VectorRenderModuleTests.cs

@@ -1,294 +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 System;
-using System.Collections.Generic;
-using System.IO;
-using System.Reflection;
-using System.Threading;
-using log4net.Config;
-using NUnit.Framework;
-using OpenMetaverse;
-using OpenMetaverse.Assets;
-using OpenSim.Framework;
-using OpenSim.Region.CoreModules.Scripting.DynamicTexture;
-using OpenSim.Region.CoreModules.Scripting.VectorRender;
-using OpenSim.Region.Framework.Scenes;
-using OpenSim.Region.Framework.Scenes.Serialization;
-using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
-
-namespace OpenSim.Region.CoreModules.Scripting.VectorRender.Tests
-{
-    [TestFixture]
-    public class VectorRenderModuleTests : OpenSimTestCase
-    {
-        Scene m_scene;
-        DynamicTextureModule m_dtm;
-        VectorRenderModule m_vrm;
-
-        private void SetupScene(bool reuseTextures)
-        {
-            m_scene = new SceneHelpers().SetupScene();
-
-            m_dtm = new DynamicTextureModule();
-            m_dtm.ReuseTextures = reuseTextures;
-
-            m_vrm = new VectorRenderModule();
-
-            SceneHelpers.SetupSceneModules(m_scene, m_dtm, m_vrm);
-        }
-
-        [Test]
-        public void TestDraw()
-        {
-            TestHelpers.InMethod();
-
-            SetupScene(false);
-            SceneObjectGroup so = SceneHelpers.AddSceneObject(m_scene);
-            UUID originalTextureID = so.RootPart.Shape.Textures.GetFace(0).TextureID;
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World;",
-                "",
-                0);
-
-            Assert.That(originalTextureID, Is.Not.EqualTo(so.RootPart.Shape.Textures.GetFace(0).TextureID));
-        }
-
-        [Test]
-        public void TestRepeatSameDraw()
-        {
-            TestHelpers.InMethod();
-
-            string dtText = "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World;";
-
-            SetupScene(false);
-            SceneObjectGroup so = SceneHelpers.AddSceneObject(m_scene);
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "",
-                0);
-
-            UUID firstDynamicTextureID = so.RootPart.Shape.Textures.GetFace(0).TextureID;
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "",
-                0);
-
-            Assert.That(firstDynamicTextureID, Is.Not.EqualTo(so.RootPart.Shape.Textures.GetFace(0).TextureID));
-        }
-
-        [Test]
-        public void TestRepeatSameDrawDifferentExtraParams()
-        {
-            TestHelpers.InMethod();
-
-            string dtText = "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World;";
-
-            SetupScene(false);
-            SceneObjectGroup so = SceneHelpers.AddSceneObject(m_scene);
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "",
-                0);
-
-            UUID firstDynamicTextureID = so.RootPart.Shape.Textures.GetFace(0).TextureID;
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "alpha:250",
-                0);
-
-            Assert.That(firstDynamicTextureID, Is.Not.EqualTo(so.RootPart.Shape.Textures.GetFace(0).TextureID));
-        }
-
-        [Test]
-        public void TestRepeatSameDrawContainingImage()
-        {
-            TestHelpers.InMethod();
-
-            string dtText
-                = "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World; Image http://localhost/shouldnotexist.png";
-
-            SetupScene(false);
-            SceneObjectGroup so = SceneHelpers.AddSceneObject(m_scene);
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "",
-                0);
-
-            UUID firstDynamicTextureID = so.RootPart.Shape.Textures.GetFace(0).TextureID;
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "",
-                0);
-
-            Assert.That(firstDynamicTextureID, Is.Not.EqualTo(so.RootPart.Shape.Textures.GetFace(0).TextureID));
-        }
-
-        [Test]
-        public void TestDrawReusingTexture()
-        {
-            TestHelpers.InMethod();
-
-            SetupScene(true);
-            SceneObjectGroup so = SceneHelpers.AddSceneObject(m_scene);
-            UUID originalTextureID = so.RootPart.Shape.Textures.GetFace(0).TextureID;
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World;",
-                "",
-                0);
-
-            Assert.That(originalTextureID, Is.Not.EqualTo(so.RootPart.Shape.Textures.GetFace(0).TextureID));
-        }
-
-        [Test]
-        public void TestRepeatSameDrawReusingTexture()
-        {
-            TestHelpers.InMethod();
-
-            string dtText = "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World;";
-
-            SetupScene(true);
-            SceneObjectGroup so = SceneHelpers.AddSceneObject(m_scene);
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "",
-                0);
-
-            UUID firstDynamicTextureID = so.RootPart.Shape.Textures.GetFace(0).TextureID;
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "",
-                0);
-
-            Assert.That(firstDynamicTextureID, Is.EqualTo(so.RootPart.Shape.Textures.GetFace(0).TextureID));
-        }
-
-        [Test]
-        public void TestRepeatSameDrawDifferentExtraParamsReusingTexture()
-        {
-            TestHelpers.InMethod();
-
-            string dtText = "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World;";
-
-            SetupScene(true);
-            SceneObjectGroup so = SceneHelpers.AddSceneObject(m_scene);
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "",
-                0);
-
-            UUID firstDynamicTextureID = so.RootPart.Shape.Textures.GetFace(0).TextureID;
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "alpha:250",
-                0);
-
-            Assert.That(firstDynamicTextureID, Is.Not.EqualTo(so.RootPart.Shape.Textures.GetFace(0).TextureID));
-        }
-
-        [Test]
-        public void TestRepeatSameDrawContainingImageReusingTexture()
-        {
-            TestHelpers.InMethod();
-
-            string dtText
-                = "PenColour BLACK; MoveTo 40,220; FontSize 32; Text Hello World; Image http://localhost/shouldnotexist.png";
-
-            SetupScene(true);
-            SceneObjectGroup so = SceneHelpers.AddSceneObject(m_scene);
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "",
-                0);
-
-            UUID firstDynamicTextureID = so.RootPart.Shape.Textures.GetFace(0).TextureID;
-
-            m_dtm.AddDynamicTextureData(
-                m_scene.RegionInfo.RegionID,
-                so.UUID,
-                m_vrm.GetContentType(),
-                dtText,
-                "",
-                0);
-
-            Assert.That(firstDynamicTextureID, Is.Not.EqualTo(so.RootPart.Shape.Textures.GetFace(0).TextureID));
-        }
-    }
-}

OpenSim/Region/CoreModules/Scripting/VectorRender/VectorRenderModule.cs

@@ -30,7 +30,6 @@ using System.Drawing;
 using System.Drawing.Imaging;
 using System.Globalization;
 using System.IO;
-using System.Linq;
 using System.Net;
 using Nini.Config;
 using OpenMetaverse;
@@ -48,6 +47,7 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
+        private string m_name = "VectorRenderModule";
         private Scene m_scene;
         private IDynamicTextureManager m_textureManager;
         private Graphics m_graph;
@@ -61,12 +61,12 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
 
         public string GetContentType()
         {
-            return "vector";
+            return ("vector");
         }
 
         public string GetName()
         {
-            return Name;
+            return m_name;
         }
 
         public bool SupportsAsynchronous()
@@ -74,26 +74,14 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
             return true;
         }
 
-//        public bool AlwaysIdenticalConversion(string bodyData, string extraParams)
-//        {
-//            string[] lines = GetLines(bodyData);
-//            return lines.Any((str, r) => str.StartsWith("Image"));
-//        }
-
         public byte[] ConvertUrl(string url, string extraParams)
         {
             return null;
         }
 
-        public byte[] ConvertData(string bodyData, string extraParams)
+        public byte[] ConvertStream(Stream data, string extraParams)
         {
-            bool reuseable;
-            return Draw(bodyData, extraParams, out reuseable);
-        }
-
-        private byte[] ConvertData(string bodyData, string extraParams, out bool reuseable)
-        {
-            return Draw(bodyData, extraParams, out reuseable);
+            return null;
         }
 
         public bool AsyncConvertUrl(UUID id, string url, string extraParams)
@@ -103,30 +91,23 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
 
         public bool AsyncConvertData(UUID id, string bodyData, string extraParams)
         {
-            // XXX: This isn't actually being done asynchronously!
-            bool reuseable;
-            byte[] data = ConvertData(bodyData, extraParams, out reuseable);
-
-            m_textureManager.ReturnData(id, data, reuseable);
-
+            Draw(bodyData, id, extraParams);
             return true;
         }
 
         public void GetDrawStringSize(string text, string fontName, int fontSize, 
                                       out double xSize, out double ySize)
         {
-            using (Font myFont = new Font(fontName, fontSize))
-            {
-                SizeF stringSize = new SizeF();
-                lock (m_graph)
-                {
-                    stringSize = m_graph.MeasureString(text, myFont);
-                    xSize = stringSize.Width;
-                    ySize = stringSize.Height;
-                }
+            Font myFont = new Font(fontName, fontSize);
+            SizeF stringSize = new SizeF();
+            lock (m_graph) {
+                stringSize = m_graph.MeasureString(text, myFont);
+                xSize = stringSize.Width;
+                ySize = stringSize.Height;
             }
         }
 
+
         #endregion
 
         #region IRegionModule Members
@@ -140,8 +121,6 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
 
             if (m_graph == null)
             {
-                // We won't dispose of these explicitly since this module is only removed when the entire simulator
-                // is shut down.
                 Bitmap bitmap = new Bitmap(1024, 1024, PixelFormat.Format32bppArgb);
                 m_graph = Graphics.FromImage(bitmap);
             }
@@ -169,7 +148,7 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
 
         public string Name
         {
-            get { return "VectorRenderModule"; }
+            get { return m_name; }
         }
 
         public bool IsSharedModule
@@ -179,7 +158,7 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
 
         #endregion
 
-        private byte[] Draw(string data, string extraParams, out bool reuseable)
+        private void Draw(string data, UUID id, string extraParams)
         {
             // We need to cater for old scripts that didnt use extraParams neatly, they use either an integer size which represents both width and height, or setalpha
             // we will now support multiple comma seperated params in the form  width:256,height:512,alpha:255
@@ -320,80 +299,53 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
                 }
             }
 
-            Bitmap bitmap = null;
-            Graphics graph = null;
+            Bitmap bitmap;
+            
+            if (alpha == 256)
+            {
+                bitmap = new Bitmap(width, height, PixelFormat.Format32bppRgb);
+            }
+            else
+            {
+                bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
+            }
+
+            Graphics graph = Graphics.FromImage(bitmap);
+
+            // this is really just to save people filling the 
+            // background color in their scripts, only do when fully opaque
+            if (alpha >= 255)
+            {
+                graph.FillRectangle(new SolidBrush(bgColor), 0, 0, width, height); 
+            }
+
+            for (int w = 0; w < bitmap.Width; w++)
+            {
+                if (alpha <= 255) 
+                {
+                    for (int h = 0; h < bitmap.Height; h++)
+                    {
+                        bitmap.SetPixel(w, h, Color.FromArgb(alpha, bitmap.GetPixel(w, h)));
+                    }
+                }
+            }
+
+            GDIDraw(data, graph, altDataDelim);
+
+            byte[] imageJ2000 = new byte[0];
 
             try
             {
-                // XXX: In testing, it appears that if multiple threads dispose of separate GDI+ objects simultaneously,
-                // the native malloc heap can become corrupted, possibly due to a double free().  This may be due to
-                // bugs in the underlying libcairo used by mono's libgdiplus.dll on Linux/OSX.  These problems were
-                // seen with both libcario 1.10.2-6.1ubuntu3 and 1.8.10-2ubuntu1.  They go away if disposal is perfomed
-                // under lock.
-                lock (this)
-                {
-                    if (alpha == 256)
-                        bitmap = new Bitmap(width, height, PixelFormat.Format32bppRgb);
-                    else
-                        bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
-    
-                    graph = Graphics.FromImage(bitmap);
-        
-                    // this is really just to save people filling the 
-                    // background color in their scripts, only do when fully opaque
-                    if (alpha >= 255)
-                    {
-                        using (SolidBrush bgFillBrush = new SolidBrush(bgColor))
-                        {
-                            graph.FillRectangle(bgFillBrush, 0, 0, width, height);
-                        }
-                    }
-        
-                    for (int w = 0; w < bitmap.Width; w++)
-                    {
-                        if (alpha <= 255) 
-                        {
-                            for (int h = 0; h < bitmap.Height; h++)
-                            {
-                                bitmap.SetPixel(w, h, Color.FromArgb(alpha, bitmap.GetPixel(w, h)));
-                            }
-                        }
-                    }
-        
-                    GDIDraw(data, graph, altDataDelim, out reuseable);
-                }
-    
-                byte[] imageJ2000 = new byte[0];
-    
-                try
-                {
-                    imageJ2000 = OpenJPEG.EncodeFromImage(bitmap, true);
-                }
-                catch (Exception e)
-                {
-                    m_log.ErrorFormat(
-                        "[VECTORRENDERMODULE]: OpenJpeg Encode Failed.  Exception {0}{1}",
-                        e.Message, e.StackTrace);
-                }
-
-                return imageJ2000;
+                imageJ2000 = OpenJPEG.EncodeFromImage(bitmap, true);
             }
-            finally
+            catch (Exception e)
             {
-                // XXX: In testing, it appears that if multiple threads dispose of separate GDI+ objects simultaneously,
-                // the native malloc heap can become corrupted, possibly due to a double free().  This may be due to
-                // bugs in the underlying libcairo used by mono's libgdiplus.dll on Linux/OSX.  These problems were
-                // seen with both libcario 1.10.2-6.1ubuntu3 and 1.8.10-2ubuntu1.  They go away if disposal is perfomed
-                // under lock.
-                lock (this)
-                {
-                    if (graph != null)
-                        graph.Dispose();
-    
-                    if (bitmap != null)
-                        bitmap.Dispose();
-                }
+                m_log.ErrorFormat(
+                    "[VECTORRENDERMODULE]: OpenJpeg Encode Failed.  Exception {0}{1}",
+                    e.Message, e.StackTrace);
             }
+
+            m_textureManager.ReturnData(id, imageJ2000);
         }
         
         private int parseIntParam(string strInt)
@@ -451,308 +403,241 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
         }
 */
 
-        /// <summary>
-        /// Split input data into discrete command lines.
-        /// </summary>
-        /// <returns></returns>
-        /// <param name='data'></param>
-        /// <param name='dataDelim'></param>
-        private string[] GetLines(string data, char dataDelim)
+        private void GDIDraw(string data, Graphics graph, char dataDelim)
         {
-            char[] lineDelimiter = { dataDelim };
-            return data.Split(lineDelimiter);
-        }
-
-        private void GDIDraw(string data, Graphics graph, char dataDelim, out bool reuseable)
-        {
-            reuseable = true;
             Point startPoint = new Point(0, 0);
             Point endPoint = new Point(0, 0);
-            Pen drawPen = null;
-            Font myFont = null;
-            SolidBrush myBrush = null;
+            Pen drawPen = new Pen(Color.Black, 7);
+            string fontName = m_fontName;
+            float fontSize = 14;
+            Font myFont = new Font(fontName, fontSize);
+            SolidBrush myBrush = new SolidBrush(Color.Black);
+            
+            char[] lineDelimiter = {dataDelim};
+            char[] partsDelimiter = {','};
+            string[] lines = data.Split(lineDelimiter);
 
-            try
+            foreach (string line in lines)
             {
-                drawPen = new Pen(Color.Black, 7);
-                string fontName = m_fontName;
-                float fontSize = 14;
-                myFont = new Font(fontName, fontSize);
-                myBrush = new SolidBrush(Color.Black);
-
-                char[] partsDelimiter = {','};
-
-                foreach (string line in GetLines(data, dataDelim))
+                string nextLine = line.Trim();
+                //replace with switch, or even better, do some proper parsing
+                if (nextLine.StartsWith("MoveTo"))
                 {
-                    string nextLine = line.Trim();
-                    //replace with switch, or even better, do some proper parsing
-                    if (nextLine.StartsWith("MoveTo"))
+                    float x = 0;
+                    float y = 0;
+                    GetParams(partsDelimiter, ref nextLine, 6, ref x, ref y);
+                    startPoint.X = (int) x;
+                    startPoint.Y = (int) y;
+                }
+                else if (nextLine.StartsWith("LineTo"))
+                {
+                    float x = 0;
+                    float y = 0;
+                    GetParams(partsDelimiter, ref nextLine, 6, ref x, ref y);
+                    endPoint.X = (int) x;
+                    endPoint.Y = (int) y;
+                    graph.DrawLine(drawPen, startPoint, endPoint);
+                    startPoint.X = endPoint.X;
+                    startPoint.Y = endPoint.Y;
+                }
+                else if (nextLine.StartsWith("Text"))
+                {
+                    nextLine = nextLine.Remove(0, 4);
+                    nextLine = nextLine.Trim();
+                    graph.DrawString(nextLine, myFont, myBrush, startPoint);
+                }
+                else if (nextLine.StartsWith("Image"))
+                {
+                    float x = 0;
+                    float y = 0;
+                    GetParams(partsDelimiter, ref nextLine, 5, ref x, ref y);
+                    endPoint.X = (int) x;
+                    endPoint.Y = (int) y;
+                    Image image = ImageHttpRequest(nextLine);
+                    if (image != null)
                     {
-                        float x = 0;
-                        float y = 0;
-                        GetParams(partsDelimiter, ref nextLine, 6, ref x, ref y);
-                        startPoint.X = (int) x;
-                        startPoint.Y = (int) y;
+                        graph.DrawImage(image, (float)startPoint.X, (float)startPoint.Y, x, y);
                     }
-                    else if (nextLine.StartsWith("LineTo"))
+                    else
                     {
-                        float x = 0;
-                        float y = 0;
-                        GetParams(partsDelimiter, ref nextLine, 6, ref x, ref y);
-                        endPoint.X = (int) x;
-                        endPoint.Y = (int) y;
-                        graph.DrawLine(drawPen, startPoint, endPoint);
-                        startPoint.X = endPoint.X;
-                        startPoint.Y = endPoint.Y;
-                    }
-                    else if (nextLine.StartsWith("Text"))
-                    {
-                        nextLine = nextLine.Remove(0, 4);
-                        nextLine = nextLine.Trim();
-                        graph.DrawString(nextLine, myFont, myBrush, startPoint);
-                    }
-                    else if (nextLine.StartsWith("Image"))
-                    {
-                        // We cannot reuse any generated texture involving fetching an image via HTTP since that image
-                        // can change.
-                        reuseable = false;
-
-                        float x = 0;
-                        float y = 0;
-                        GetParams(partsDelimiter, ref nextLine, 5, ref x, ref y);
-                        endPoint.X = (int) x;
-                        endPoint.Y = (int) y;
-
-                        using (Image image = ImageHttpRequest(nextLine))
-                        {
-                            if (image != null)
-                            {
-                                graph.DrawImage(image, (float)startPoint.X, (float)startPoint.Y, x, y);
-                            }
-                            else
-                            {
-                                using (Font errorFont = new Font(m_fontName,6))
-                                {
-                                    graph.DrawString("URL couldn't be resolved or is", errorFont,
-                                                     myBrush, startPoint);
-                                    graph.DrawString("not an image. Please check URL.", errorFont,
-                                                     myBrush, new Point(startPoint.X, 12 + startPoint.Y));
-                                }
-    
-                                graph.DrawRectangle(drawPen, startPoint.X, startPoint.Y, endPoint.X, endPoint.Y);
-                            }
-                        }
-
-                        startPoint.X += endPoint.X;
-                        startPoint.Y += endPoint.Y;
-                    }
-                    else if (nextLine.StartsWith("Rectangle"))
-                    {
-                        float x = 0;
-                        float y = 0;
-                        GetParams(partsDelimiter, ref nextLine, 9, ref x, ref y);
-                        endPoint.X = (int) x;
-                        endPoint.Y = (int) y;
+                        graph.DrawString("URL couldn't be resolved or is", new Font(m_fontName,6), 
+                                         myBrush, startPoint);
+                        graph.DrawString("not an image. Please check URL.", new Font(m_fontName, 6), 
+                                         myBrush, new Point(startPoint.X, 12 + startPoint.Y));
                         graph.DrawRectangle(drawPen, startPoint.X, startPoint.Y, endPoint.X, endPoint.Y);
-                        startPoint.X += endPoint.X;
-                        startPoint.Y += endPoint.Y;
                     }
-                    else if (nextLine.StartsWith("FillRectangle"))
-                    {
-                        float x = 0;
-                        float y = 0;
-                        GetParams(partsDelimiter, ref nextLine, 13, ref x, ref y);
-                        endPoint.X = (int) x;
-                        endPoint.Y = (int) y;
-                        graph.FillRectangle(myBrush, startPoint.X, startPoint.Y, endPoint.X, endPoint.Y);
-                        startPoint.X += endPoint.X;
-                        startPoint.Y += endPoint.Y;
-                    }
-                    else if (nextLine.StartsWith("FillPolygon"))
-                    {
-                        PointF[] points = null;
-                        GetParams(partsDelimiter, ref nextLine, 11, ref points);
-                        graph.FillPolygon(myBrush, points);
-                    }
-                    else if (nextLine.StartsWith("Polygon"))
-                    {
-                        PointF[] points = null;
-                        GetParams(partsDelimiter, ref nextLine, 7, ref points);
-                        graph.DrawPolygon(drawPen, points);
-                    }
-                    else if (nextLine.StartsWith("Ellipse"))
-                    {
-                        float x = 0;
-                        float y = 0;
-                        GetParams(partsDelimiter, ref nextLine, 7, ref x, ref y);
-                        endPoint.X = (int)x;
-                        endPoint.Y = (int)y;
-                        graph.DrawEllipse(drawPen, startPoint.X, startPoint.Y, endPoint.X, endPoint.Y);
-                        startPoint.X += endPoint.X;
-                        startPoint.Y += endPoint.Y;
-                    }
-                    else if (nextLine.StartsWith("FontSize"))
-                    {
-                        nextLine = nextLine.Remove(0, 8);
-                        nextLine = nextLine.Trim();
-                        fontSize = Convert.ToSingle(nextLine, CultureInfo.InvariantCulture);
+                    startPoint.X += endPoint.X;
+                    startPoint.Y += endPoint.Y;
+                }
+                else if (nextLine.StartsWith("Rectangle"))
+                {
+                    float x = 0;
+                    float y = 0;
+                    GetParams(partsDelimiter, ref nextLine, 9, ref x, ref y);
+                    endPoint.X = (int) x;
+                    endPoint.Y = (int) y;
+                    graph.DrawRectangle(drawPen, startPoint.X, startPoint.Y, endPoint.X, endPoint.Y);
+                    startPoint.X += endPoint.X;
+                    startPoint.Y += endPoint.Y;
+                }
+                else if (nextLine.StartsWith("FillRectangle"))
+                {
+                    float x = 0;
+                    float y = 0;
+                    GetParams(partsDelimiter, ref nextLine, 13, ref x, ref y);
+                    endPoint.X = (int) x;
+                    endPoint.Y = (int) y;
+                    graph.FillRectangle(myBrush, startPoint.X, startPoint.Y, endPoint.X, endPoint.Y);
+                    startPoint.X += endPoint.X;
+                    startPoint.Y += endPoint.Y;
+                }
+                else if (nextLine.StartsWith("FillPolygon"))
+                {
+                    PointF[] points = null;
+                    GetParams(partsDelimiter, ref nextLine, 11, ref points);
+                    graph.FillPolygon(myBrush, points);
+                }
+                else if (nextLine.StartsWith("Polygon"))
+                {
+                    PointF[] points = null;
+                    GetParams(partsDelimiter, ref nextLine, 7, ref points);
+                    graph.DrawPolygon(drawPen, points);
+                }
+                else if (nextLine.StartsWith("Ellipse"))
+                {
+                    float x = 0;
+                    float y = 0;
+                    GetParams(partsDelimiter, ref nextLine, 7, ref x, ref y);
+                    endPoint.X = (int)x;
+                    endPoint.Y = (int)y;
+                    graph.DrawEllipse(drawPen, startPoint.X, startPoint.Y, endPoint.X, endPoint.Y);
+                    startPoint.X += endPoint.X;
+                    startPoint.Y += endPoint.Y;
+                }
+                else if (nextLine.StartsWith("FontSize"))
+                {
+                    nextLine = nextLine.Remove(0, 8);
+                    nextLine = nextLine.Trim();
+                    fontSize = Convert.ToSingle(nextLine, CultureInfo.InvariantCulture);
+                    myFont = new Font(fontName, fontSize);
+                }
+                else if (nextLine.StartsWith("FontProp"))
+                {
+                    nextLine = nextLine.Remove(0, 8);
+                    nextLine = nextLine.Trim();
 
-                        myFont.Dispose();
-                        myFont = new Font(fontName, fontSize);
-                    }
-                    else if (nextLine.StartsWith("FontProp"))
+                    string[] fprops = nextLine.Split(partsDelimiter);
+                    foreach (string prop in fprops)
                     {
-                        nextLine = nextLine.Remove(0, 8);
-                        nextLine = nextLine.Trim();
-    
-                        string[] fprops = nextLine.Split(partsDelimiter);
-                        foreach (string prop in fprops)
-                        {
-    
-                            switch (prop)
-                            {
-                                case "B":
-                                    if (!(myFont.Bold))
-                                    {
-                                        Font newFont = new Font(myFont, myFont.Style | FontStyle.Bold);
-                                        myFont.Dispose();
-                                        myFont = newFont;
-                                    }
-                                    break;
-                                case "I":
-                                    if (!(myFont.Italic))
-                                    {
-                                        Font newFont = new Font(myFont, myFont.Style | FontStyle.Italic);
-                                        myFont.Dispose();
-                                        myFont = newFont;
-                                    }
-                                    break;
-                                case "U":
-                                    if (!(myFont.Underline))
-                                    {
-                                        Font newFont = new Font(myFont, myFont.Style | FontStyle.Underline);
-                                        myFont.Dispose();
-                                        myFont = newFont;
-                                    }
-                                    break;
-                                case "S":
-                                    if (!(myFont.Strikeout))
-                                    {
-                                        Font newFont = new Font(myFont, myFont.Style | FontStyle.Strikeout);
-                                        myFont.Dispose();
-                                        myFont = newFont;
-                                    }
-                                    break;
-                                case "R":
-                                    // We need to place this newFont inside its own context so that the .NET compiler
-                                    // doesn't complain about a redefinition of an existing newFont, even though there is none
-                                    // The mono compiler doesn't produce this error.
-                                    {
-                                        Font newFont = new Font(myFont, FontStyle.Regular);
-                                        myFont.Dispose();
-                                        myFont = newFont;
-                                    }
-                                    break;
-                            }
-                        }
-                    }
-                    else if (nextLine.StartsWith("FontName"))
-                    {
-                        nextLine = nextLine.Remove(0, 8);
-                        fontName = nextLine.Trim();
-                        myFont.Dispose();
-                        myFont = new Font(fontName, fontSize);
-                    }
-                    else if (nextLine.StartsWith("PenSize"))
-                    {
-                        nextLine = nextLine.Remove(0, 7);
-                        nextLine = nextLine.Trim();
-                        float size = Convert.ToSingle(nextLine, CultureInfo.InvariantCulture);
-                        drawPen.Width = size;
-                    }
-                    else if (nextLine.StartsWith("PenCap"))
-                    {
-                        bool start = true, end = true;
-                        nextLine = nextLine.Remove(0, 6);
-                        nextLine = nextLine.Trim();
-                        string[] cap = nextLine.Split(partsDelimiter);
-                        if (cap[0].ToLower() == "start")
-                            end = false;
-                        else if (cap[0].ToLower() == "end")
-                            start = false;
-                        else if (cap[0].ToLower() != "both")
-                            return;
-                        string type = cap[1].ToLower();
-                        
-                        if (end)
-                        {
-                            switch (type)
-                            {
-                                case "arrow":
-                                    drawPen.EndCap = System.Drawing.Drawing2D.LineCap.ArrowAnchor;
-                                    break;
-                                case "round":
-                                    drawPen.EndCap = System.Drawing.Drawing2D.LineCap.RoundAnchor;
-                                    break;
-                                case "diamond":
-                                    drawPen.EndCap = System.Drawing.Drawing2D.LineCap.DiamondAnchor;
-                                    break;
-                                case "flat":
-                                    drawPen.EndCap = System.Drawing.Drawing2D.LineCap.Flat;
-                                    break;
-                            }
-                        }
-                        if (start)
-                        {
-                            switch (type)
-                            {
-                                case "arrow":
-                                    drawPen.StartCap = System.Drawing.Drawing2D.LineCap.ArrowAnchor;
-                                    break;
-                                case "round":
-                                    drawPen.StartCap = System.Drawing.Drawing2D.LineCap.RoundAnchor;
-                                    break;
-                                case "diamond":
-                                    drawPen.StartCap = System.Drawing.Drawing2D.LineCap.DiamondAnchor;
-                                    break;
-                                case "flat":
-                                    drawPen.StartCap = System.Drawing.Drawing2D.LineCap.Flat;
-                                    break;
-                            }
-                        }
-                    }
-                    else if (nextLine.StartsWith("PenColour") || nextLine.StartsWith("PenColor"))
-                    {
-                        nextLine = nextLine.Remove(0, 9);
-                        nextLine = nextLine.Trim();
-                        int hex = 0;
-    
-                        Color newColor;
-                        if (Int32.TryParse(nextLine, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out hex))
-                        {
-                            newColor = Color.FromArgb(hex);
-                        }
-                        else
-                        {
-                            // this doesn't fail, it just returns black if nothing is found
-                            newColor = Color.FromName(nextLine);
-                        }
 
-                        myBrush.Color = newColor;
-                        drawPen.Color = newColor;
+                        switch (prop)
+                        {
+                            case "B":
+                                if (!(myFont.Bold))
+                                    myFont = new Font(myFont, myFont.Style | FontStyle.Bold);
+                                break;
+                            case "I":
+                                if (!(myFont.Italic))
+                                    myFont = new Font(myFont, myFont.Style | FontStyle.Italic);
+                                break;
+                            case "U":
+                                if (!(myFont.Underline))
+                                    myFont = new Font(myFont, myFont.Style | FontStyle.Underline);
+                                break;
+                            case "S":
+                                if (!(myFont.Strikeout))
+                                    myFont = new Font(myFont, myFont.Style | FontStyle.Strikeout);
+                                break;
+                            case "R":
+                                myFont = new Font(myFont, FontStyle.Regular);
+                                break;
+                        }
                     }
                 }
-            }
-            finally
-            {
-                if (drawPen != null)
-                    drawPen.Dispose();
+                else if (nextLine.StartsWith("FontName"))
+                {
+                    nextLine = nextLine.Remove(0, 8);
+                    fontName = nextLine.Trim();
+                    myFont = new Font(fontName, fontSize);
+                }
+                else if (nextLine.StartsWith("PenSize"))
+                {
+                    nextLine = nextLine.Remove(0, 7);
+                    nextLine = nextLine.Trim();
+                    float size = Convert.ToSingle(nextLine, CultureInfo.InvariantCulture);
+                    drawPen.Width = size;
+                }
+                else if (nextLine.StartsWith("PenCap"))
+                {
+                    bool start = true, end = true;
+                    nextLine = nextLine.Remove(0, 6);
+                    nextLine = nextLine.Trim();
+                    string[] cap = nextLine.Split(partsDelimiter);
+                    if (cap[0].ToLower() == "start")
+                        end = false;
+                    else if (cap[0].ToLower() == "end")
+                        start = false;
+                    else if (cap[0].ToLower() != "both")
+                        return;
+                    string type = cap[1].ToLower();
+                    
+                    if (end)
+                    {
+                        switch (type)
+                        {
+                            case "arrow":
+                                drawPen.EndCap = System.Drawing.Drawing2D.LineCap.ArrowAnchor;
+                                break;
+                            case "round":
+                                drawPen.EndCap = System.Drawing.Drawing2D.LineCap.RoundAnchor;
+                                break;
+                            case "diamond":
+                                drawPen.EndCap = System.Drawing.Drawing2D.LineCap.DiamondAnchor;
+                                break;
+                            case "flat":
+                                drawPen.EndCap = System.Drawing.Drawing2D.LineCap.Flat;
+                                break;
+                        }
+                    }
+                    if (start)
+                    {
+                        switch (type)
+                        {
+                            case "arrow":
+                                drawPen.StartCap = System.Drawing.Drawing2D.LineCap.ArrowAnchor;
+                                break;
+                            case "round":
+                                drawPen.StartCap = System.Drawing.Drawing2D.LineCap.RoundAnchor;
+                                break;
+                            case "diamond":
+                                drawPen.StartCap = System.Drawing.Drawing2D.LineCap.DiamondAnchor;
+                                break;
+                            case "flat":
+                                drawPen.StartCap = System.Drawing.Drawing2D.LineCap.Flat;
+                                break;
+                        }
+                    }
+                }
+                else if (nextLine.StartsWith("PenColour") || nextLine.StartsWith("PenColor"))
+                {
+                    nextLine = nextLine.Remove(0, 9);
+                    nextLine = nextLine.Trim();
+                    int hex = 0;
 
-                if (myFont != null)
-                    myFont.Dispose();
+                    Color newColor;
+                    if (Int32.TryParse(nextLine, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out hex))
+                    {
+                        newColor = Color.FromArgb(hex);
+                    }
+                    else
+                    {
+                        // this doesn't fail, it just returns black if nothing is found
+                        newColor = Color.FromName(nextLine);
+                    }
 
-                if (myBrush != null)
-                    myBrush.Dispose();
+                    myBrush.Color = newColor;
+                    drawPen.Color = newColor;
+                }
             }
         }
 
@@ -806,7 +691,7 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
         {
             try
             {
-                WebRequest request = HttpWebRequest.Create(url);
+            WebRequest request = HttpWebRequest.Create(url);
 //Ckrinke: Comment out for now as 'str' is unused. Bring it back into play later when it is used.
 //Ckrinke            Stream str = null;
                 HttpWebResponse response = (HttpWebResponse)(request).GetResponse();
@@ -817,8 +702,7 @@ namespace OpenSim.Region.CoreModules.Scripting.VectorRender
                 }
             }
             catch { }
-
             return null;
         }
     }
-}
+}

OpenSim/Region/CoreModules/ServiceConnectorsIn/Land/LandServiceInConnectorModule.cs

@@ -75,7 +75,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsIn.Land
             if (!m_Enabled)
                 return;
 
-//            m_log.Info("[LAND IN CONNECTOR]: Starting...");
+            m_log.Info("[LAND IN CONNECTOR]: Starting...");
         }
 
         public void Close()

OpenSim/Region/CoreModules/ServiceConnectorsIn/Neighbour/NeighbourServiceInConnectorModule.cs

@@ -74,7 +74,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsIn.Neighbour
             if (!m_Enabled)
                 return;
 
-//            m_log.Info("[NEIGHBOUR IN CONNECTOR]: Starting...");
+            m_log.Info("[NEIGHBOUR IN CONNECTOR]: Starting...");
         }
 
         public void Close()

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

@@ -41,7 +41,8 @@ using OpenMetaverse;
 
 namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 {
-    public class LocalGridServicesConnector : ISharedRegionModule, IGridService
+    public class LocalGridServicesConnector :
+            ISharedRegionModule, IGridService
     {
         private static readonly ILog m_log =
                 LogManager.GetLogger(
@@ -50,7 +51,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
         private IGridService m_GridService;
         private Dictionary<UUID, RegionCache> m_LocalCache = new Dictionary<UUID, RegionCache>();
 
-        private bool m_Enabled;
+        private bool m_Enabled = false;
 
         public LocalGridServicesConnector()
         {
@@ -58,7 +59,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 
         public LocalGridServicesConnector(IConfigSource source)
         {
-            m_log.Debug("[LOCAL GRID SERVICE CONNECTOR]: LocalGridServicesConnector instantiated directly.");
+            m_log.Debug("[LOCAL GRID CONNECTOR]: LocalGridServicesConnector instantiated");
             InitialiseService(source);
         }
 
@@ -83,7 +84,8 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
                 if (name == Name)
                 {
                     InitialiseService(source);
-                    m_log.Info("[LOCAL GRID SERVICE CONNECTOR]: Local grid connector enabled");
+                    m_Enabled = true;
+                    m_log.Info("[LOCAL GRID CONNECTOR]: Local grid connector enabled");
                 }
             }
         }
@@ -93,7 +95,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
             IConfig assetConfig = source.Configs["GridService"];
             if (assetConfig == null)
             {
-                m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: GridService missing from OpenSim.ini");
+                m_log.Error("[LOCAL GRID CONNECTOR]: GridService missing from OpenSim.ini");
                 return;
             }
 
@@ -102,7 +104,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 
             if (serviceDll == String.Empty)
             {
-                m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: No LocalServiceModule named in section GridService");
+                m_log.Error("[LOCAL GRID CONNECTOR]: No LocalServiceModule named in section GridService");
                 return;
             }
 
@@ -113,20 +115,16 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 
             if (m_GridService == null)
             {
-                m_log.Error("[LOCAL GRID SERVICE CONNECTOR]: Can't load grid service");
+                m_log.Error("[LOCAL GRID CONNECTOR]: Can't load grid service");
                 return;
             }
-
-            m_Enabled = true;
         }
 
         public void PostInitialise()
         {
-            // FIXME: We will still add this command even if we aren't enabled since RemoteGridServiceConnector
-            // will have instantiated us directly.
             MainConsole.Instance.Commands.AddCommand("Regions", false, "show neighbours",
                 "show neighbours",
-                "Shows the local regions' neighbours", HandleShowNeighboursCommand);
+                "Shows the local regions' neighbours", NeighboursCommand);
         }
 
         public void Close()
@@ -135,22 +133,17 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 
         public void AddRegion(Scene scene)
         {
-            if (!m_Enabled)
-                return;
-
-            scene.RegisterModuleInterface<IGridService>(this);
+            if (m_Enabled)
+                scene.RegisterModuleInterface<IGridService>(this);
 
             if (m_LocalCache.ContainsKey(scene.RegionInfo.RegionID))
-                m_log.ErrorFormat("[LOCAL GRID SERVICE CONNECTOR]: simulator seems to have more than one region with the same UUID. Please correct this!");
+                m_log.ErrorFormat("[LOCAL GRID CONNECTOR]: simulator seems to have more than one region with the same UUID. Please correct this!");
             else
                 m_LocalCache.Add(scene.RegionInfo.RegionID, new RegionCache(scene));
         }
 
         public void RemoveRegion(Scene scene)
         {
-            if (!m_Enabled)
-                return;
-
             m_LocalCache[scene.RegionInfo.RegionID].Clear();
             m_LocalCache.Remove(scene.RegionInfo.RegionID);
         }
@@ -239,7 +232,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
 
         #endregion
 
-        public void HandleShowNeighboursCommand(string module, string[] cmdparams)
+        public void NeighboursCommand(string module, string[] cmdparams)
         {
             System.Text.StringBuilder caps = new System.Text.StringBuilder();
 

OpenSim/Region/CoreModules/ServiceConnectorsOut/Inventory/RemoteXInventoryServiceConnector.cs

@@ -31,7 +31,7 @@ using System.Collections.Generic;
 using System.Reflection;
 using Nini.Config;
 using OpenSim.Framework;
-using OpenSim.Framework.Monitoring;
+using OpenSim.Framework.Statistics;
 using OpenSim.Services.Connectors;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;

OpenSim/Region/CoreModules/ServiceConnectorsOut/MapImage/MapImageServiceModule.cs

@@ -128,6 +128,11 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.MapImage
             m_enabled = true;
         }
 
+        ///<summary>
+        ///
+        ///</summary>
+
+
         ///<summary>
         ///
         ///</summary>
@@ -141,9 +146,10 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.MapImage
             lock (m_scenes)
                 m_scenes[scene.RegionInfo.RegionID] = scene;
 
-            scene.EventManager.OnRegionReadyStatusChange += s => { if (s.Ready) UploadMapTile(s); };
+            scene.EventManager.OnLoginsEnabled += OnLoginsEnabled; 
         }
 
+
         ///<summary>
         ///
         ///</summary>
@@ -157,7 +163,21 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.MapImage
         }
 
         #endregion ISharedRegionModule
-        
+
+        void OnLoginsEnabled(string regionName)
+        {
+            Scene scene = null;
+            foreach (Scene s in m_scenes.Values)
+                if (s.RegionInfo.RegionName == regionName)
+                {
+                    scene = s;
+                    break;
+                }
+            if (scene != null)
+                UploadMapTile(scene);
+        }
+
+
         ///<summary>
         ///
         ///</summary>

OpenSim/Region/CoreModules/ServiceConnectorsOut/Neighbour/LocalNeighbourServiceConnector.cs

@@ -125,13 +125,13 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Neighbour
             uint x, y;
             Utils.LongToUInts(regionHandle, out x, out y);
 
+            m_log.DebugFormat("[NEIGHBOUR CONNECTOR]: HelloNeighbour from region {0} to region at {1}-{2}",
+                thisRegion.RegionName, x / Constants.RegionSize, y / Constants.RegionSize);
+
             foreach (Scene s in m_Scenes)
             {
                 if (s.RegionInfo.RegionHandle == regionHandle)
                 {
-                    m_log.DebugFormat("[LOCAL NEIGHBOUR SERVICE CONNECTOR]: HelloNeighbour from region {0} to neighbour {1} at {2}-{3}",
-                        thisRegion.RegionName, s.Name, x / Constants.RegionSize, y / Constants.RegionSize);
-
                     //m_log.Debug("[NEIGHBOUR CONNECTOR]: Found region to SendHelloNeighbour");
                     return s.IncomingHelloNeighbour(thisRegion);
                 }

OpenSim/Region/CoreModules/ServiceConnectorsOut/Presence/LocalPresenceServiceConnector.cs

@@ -193,6 +193,11 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Presence
             return m_PresenceService.GetAgents(userIDs);
         }
 
+        public PresenceInfo VerifyAgent(UUID s_sessionID)
+        {
+            return m_PresenceService.VerifyAgent(s_sessionID);
+        }
+
         #endregion
 
     }