From 350cd58e5e52b88651035bcba19010807bff7870 Mon Sep 17 00:00:00 2001 From: "Justin Clark-Casey (justincc)" Date: Thu, 15 Nov 2012 04:01:30 +0000 Subject: [PATCH 1/8] refactor: move common inventory folder version update code to parent class in mysql, mssql and sqlite database plugins --- OpenSim/Data/MSSQL/MSSQLXInventoryData.cs | 47 ++++--------------- OpenSim/Data/MySQL/MySQLXInventoryData.cs | 51 ++++----------------- OpenSim/Data/SQLite/SQLiteXInventoryData.cs | 42 ++++------------- 3 files changed, 28 insertions(+), 112 deletions(-) diff --git a/OpenSim/Data/MSSQL/MSSQLXInventoryData.cs b/OpenSim/Data/MSSQL/MSSQLXInventoryData.cs index 97970af325..9164ffe4e3 100644 --- a/OpenSim/Data/MSSQL/MSSQLXInventoryData.cs +++ b/OpenSim/Data/MSSQL/MSSQLXInventoryData.cs @@ -122,7 +122,7 @@ namespace OpenSim.Data.MSSQL } } - public class MSSQLItemHandler : MSSQLGenericTableHandler + public class MSSQLItemHandler : MSSQLInventoryHandler { public MSSQLItemHandler(string c, string t, string m) : base(c, t, m) @@ -213,43 +213,9 @@ namespace OpenSim.Data.MSSQL return true; } - - private bool IncrementFolderVersion(UUID folderID) - { - return IncrementFolderVersion(folderID.ToString()); - } - - private bool IncrementFolderVersion(string folderID) - { -// m_log.DebugFormat("[MYSQL ITEM HANDLER]: Incrementing version on folder {0}", folderID); -// Util.PrintCallStack(); - - string sql = "update inventoryfolders set version=version+1 where folderID = ?folderID"; - - using (SqlConnection conn = new SqlConnection(m_ConnectionString)) - { - using (SqlCommand cmd = new SqlCommand(sql, conn)) - { - conn.Open(); - - cmd.Parameters.AddWithValue("@folderID", folderID); - - try - { - cmd.ExecuteNonQuery(); - } - catch (Exception) - { - return false; - } - } - } - - return true; - } } - public class MSSQLFolderHandler : MSSQLGenericTableHandler + public class MSSQLFolderHandler : MSSQLInventoryHandler { public MSSQLFolderHandler(string c, string t, string m) : base(c, t, m) @@ -296,13 +262,18 @@ namespace OpenSim.Data.MSSQL return true; } + } - private bool IncrementFolderVersion(UUID folderID) + public class MSSQLInventoryHandler : MSSQLGenericTableHandler where T: class, new() + { + public MSSQLInventoryHandler(string c, string t, string m) : base(c, t, m) {} + + protected bool IncrementFolderVersion(UUID folderID) { return IncrementFolderVersion(folderID.ToString()); } - private bool IncrementFolderVersion(string folderID) + protected bool IncrementFolderVersion(string folderID) { // m_log.DebugFormat("[MYSQL ITEM HANDLER]: Incrementing version on folder {0}", folderID); // Util.PrintCallStack(); diff --git a/OpenSim/Data/MySQL/MySQLXInventoryData.cs b/OpenSim/Data/MySQL/MySQLXInventoryData.cs index 7a3b5b4084..c74033eefc 100644 --- a/OpenSim/Data/MySQL/MySQLXInventoryData.cs +++ b/OpenSim/Data/MySQL/MySQLXInventoryData.cs @@ -122,7 +122,7 @@ namespace OpenSim.Data.MySQL } } - public class MySqlItemHandler : MySQLGenericTableHandler + public class MySqlItemHandler : MySqlInventoryHandler { // private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); @@ -241,47 +241,9 @@ namespace OpenSim.Data.MySQL return true; } - - private bool IncrementFolderVersion(UUID folderID) - { - return IncrementFolderVersion(folderID.ToString()); - } - - private bool IncrementFolderVersion(string folderID) - { -// m_log.DebugFormat("[MYSQL ITEM HANDLER]: Incrementing version on folder {0}", folderID); -// Util.PrintCallStack(); - - using (MySqlConnection dbcon = new MySqlConnection(m_connectionString)) - { - dbcon.Open(); - - using (MySqlCommand cmd = new MySqlCommand()) - { - cmd.Connection = dbcon; - - cmd.CommandText = String.Format("update inventoryfolders set version=version+1 where folderID = ?folderID"); - cmd.Parameters.AddWithValue("?folderID", folderID); - - try - { - cmd.ExecuteNonQuery(); - } - catch (Exception) - { - return false; - } - cmd.Dispose(); - } - - dbcon.Close(); - } - - return true; - } } - public class MySqlFolderHandler : MySQLGenericTableHandler + public class MySqlFolderHandler : MySqlInventoryHandler { // private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); @@ -326,13 +288,18 @@ namespace OpenSim.Data.MySQL return true; } + } - private bool IncrementFolderVersion(UUID folderID) + public class MySqlInventoryHandler : MySQLGenericTableHandler where T: class, new() + { + public MySqlInventoryHandler(string c, string t, string m) : base(c, t, m) {} + + protected bool IncrementFolderVersion(UUID folderID) { return IncrementFolderVersion(folderID.ToString()); } - private bool IncrementFolderVersion(string folderID) + protected bool IncrementFolderVersion(string folderID) { // m_log.DebugFormat("[MYSQL FOLDER HANDLER]: Incrementing version on folder {0}", folderID); // Util.PrintCallStack(); diff --git a/OpenSim/Data/SQLite/SQLiteXInventoryData.cs b/OpenSim/Data/SQLite/SQLiteXInventoryData.cs index 87eb31eb0f..2a0a8f6cc9 100644 --- a/OpenSim/Data/SQLite/SQLiteXInventoryData.cs +++ b/OpenSim/Data/SQLite/SQLiteXInventoryData.cs @@ -130,7 +130,7 @@ namespace OpenSim.Data.SQLite } } - public class SqliteItemHandler : SQLiteGenericTableHandler + public class SqliteItemHandler : SqliteInventoryHandler { public SqliteItemHandler(string c, string t, string m) : base(c, t, m) @@ -243,37 +243,9 @@ namespace OpenSim.Data.SQLite return perms; } - - private bool IncrementFolderVersion(UUID folderID) - { - return IncrementFolderVersion(folderID.ToString()); - } - - private bool IncrementFolderVersion(string folderID) - { -// m_log.DebugFormat("[MYSQL ITEM HANDLER]: Incrementing version on folder {0}", folderID); -// Util.PrintCallStack(); - - using (SqliteCommand cmd = new SqliteCommand()) - { - cmd.CommandText = "update inventoryfolders set version=version+1 where folderID = ?folderID"; - cmd.Parameters.Add(new SqliteParameter(":folderID", folderID)); - - try - { - cmd.ExecuteNonQuery(); - } - catch (Exception) - { - return false; - } - } - - return true; - } } - public class SqliteFolderHandler : SQLiteGenericTableHandler + public class SqliteFolderHandler : SqliteInventoryHandler { public SqliteFolderHandler(string c, string t, string m) : base(c, t, m) @@ -315,12 +287,18 @@ namespace OpenSim.Data.SQLite return true; } - private bool IncrementFolderVersion(UUID folderID) + } + + public class SqliteInventoryHandler : SQLiteGenericTableHandler where T: class, new() + { + public SqliteInventoryHandler(string c, string t, string m) : base(c, t, m) {} + + protected bool IncrementFolderVersion(UUID folderID) { return IncrementFolderVersion(folderID.ToString()); } - private bool IncrementFolderVersion(string folderID) + protected bool IncrementFolderVersion(string folderID) { // m_log.DebugFormat("[MYSQL ITEM HANDLER]: Incrementing version on folder {0}", folderID); // Util.PrintCallStack(); From df62d113abf5d9264caca7f2e554d061c260e522 Mon Sep 17 00:00:00 2001 From: Diva Canto Date: Wed, 14 Nov 2012 21:18:18 -0800 Subject: [PATCH 2/8] The last few AssemblyInfos. Finished! --- OpenSim/Server/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../AssetService/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../AvatarService/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Services/Base/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Connectors/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Friends/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../GridService/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Interfaces/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../LLLoginService/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Tools/Compiler/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Configger/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ .../Tools/pCampBot/Properties/AssemblyInfo.cs | 33 +++++++++++++++++++ 20 files changed, 660 insertions(+) create mode 100644 OpenSim/Server/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/AssetService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/AuthenticationService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/AuthorizationService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/AvatarService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/Base/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/Connectors/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/FreeswitchService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/Friends/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/GridService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/HypergridService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/Interfaces/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/InventoryService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/LLLoginService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/MapImageService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/PresenceService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Services/UserAccountService/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Tools/Compiler/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Tools/Configger/Properties/AssemblyInfo.cs create mode 100644 OpenSim/Tools/pCampBot/Properties/AssemblyInfo.cs diff --git a/OpenSim/Server/Properties/AssemblyInfo.cs b/OpenSim/Server/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..ebc10fbcf5 --- /dev/null +++ b/OpenSim/Server/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Robust")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("d347c5cb-baf8-4566-a221-35d948e1776f")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/AssetService/Properties/AssemblyInfo.cs b/OpenSim/Services/AssetService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..15094001f2 --- /dev/null +++ b/OpenSim/Services/AssetService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.AssetService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("fe57c0df-6101-4c23-ae1a-7b3e937843f9")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/AuthenticationService/Properties/AssemblyInfo.cs b/OpenSim/Services/AuthenticationService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..0eb2ba71eb --- /dev/null +++ b/OpenSim/Services/AuthenticationService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.AuthenticationService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("Copyright © 2012")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("74497b6f-8844-4ed4-8f0d-2caf7f42b760")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/AuthorizationService/Properties/AssemblyInfo.cs b/OpenSim/Services/AuthorizationService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..6d6b11e42b --- /dev/null +++ b/OpenSim/Services/AuthorizationService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.AuthorizationService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("822586bb-cf25-4a2a-ac3e-59edaf147be3")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/AvatarService/Properties/AssemblyInfo.cs b/OpenSim/Services/AvatarService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..0944149c5f --- /dev/null +++ b/OpenSim/Services/AvatarService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.AvatarService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("0c9462ad-a5f3-46d1-ae9e-d6901fa33aa4")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/Base/Properties/AssemblyInfo.cs b/OpenSim/Services/Base/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..306b699d4b --- /dev/null +++ b/OpenSim/Services/Base/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.Base")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("db9f6f73-3a56-497f-a465-4bea9cb86062")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/Connectors/Properties/AssemblyInfo.cs b/OpenSim/Services/Connectors/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..bfb681b4cd --- /dev/null +++ b/OpenSim/Services/Connectors/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.Connectors")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("3ab0a9a1-3f45-4c07-a892-3848df8c0173")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/FreeswitchService/Properties/AssemblyInfo.cs b/OpenSim/Services/FreeswitchService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..58c7283505 --- /dev/null +++ b/OpenSim/Services/FreeswitchService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.FreeswitchService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("af7d2401-cfd9-4ba5-8d6c-8af629984123")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/Friends/Properties/AssemblyInfo.cs b/OpenSim/Services/Friends/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..dddb091248 --- /dev/null +++ b/OpenSim/Services/Friends/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.FriendsService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("a265d071-e152-42cc-9674-3ddd053977f5")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/GridService/Properties/AssemblyInfo.cs b/OpenSim/Services/GridService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..5c0c8f4e85 --- /dev/null +++ b/OpenSim/Services/GridService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.GridService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("96526d7b-4943-4b8e-9f0f-5908af621090")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/HypergridService/Properties/AssemblyInfo.cs b/OpenSim/Services/HypergridService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..49f21769bd --- /dev/null +++ b/OpenSim/Services/HypergridService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.HypergridService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("8584f3c1-26dd-4d95-86f4-cd8f0110a18f")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/Interfaces/Properties/AssemblyInfo.cs b/OpenSim/Services/Interfaces/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..4723553dd1 --- /dev/null +++ b/OpenSim/Services/Interfaces/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.Interfaces")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("39091de1-1c4c-4ebe-bb01-31551ec1749d")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/InventoryService/Properties/AssemblyInfo.cs b/OpenSim/Services/InventoryService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..41ad9f84c4 --- /dev/null +++ b/OpenSim/Services/InventoryService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.InventoryService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("d96d6d8c-9769-47e7-88dc-dbeb8fe7105a")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/LLLoginService/Properties/AssemblyInfo.cs b/OpenSim/Services/LLLoginService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..62c6e0ff81 --- /dev/null +++ b/OpenSim/Services/LLLoginService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.LLLoginService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("cbeb8f23-3896-4076-97fd-f955b0af6a93")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/MapImageService/Properties/AssemblyInfo.cs b/OpenSim/Services/MapImageService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..23eb6644de --- /dev/null +++ b/OpenSim/Services/MapImageService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.MapImageService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("5e679df7-1d2a-401a-8966-b93677bb5839")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/PresenceService/Properties/AssemblyInfo.cs b/OpenSim/Services/PresenceService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..8c03dd7892 --- /dev/null +++ b/OpenSim/Services/PresenceService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.PresenceService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("a875a0bd-eab0-40a2-b5c4-3afddc3b4d2d")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Services/UserAccountService/Properties/AssemblyInfo.cs b/OpenSim/Services/UserAccountService/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..24e1d16750 --- /dev/null +++ b/OpenSim/Services/UserAccountService/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Services.UserAccountService")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("fdb4771d-9928-4db4-aeb5-90cac2976584")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Tools/Compiler/Properties/AssemblyInfo.cs b/OpenSim/Tools/Compiler/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..e1a1fda568 --- /dev/null +++ b/OpenSim/Tools/Compiler/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Tools.lslc")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("002864e7-b2a2-41d2-add8-82f653663160")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Tools/Configger/Properties/AssemblyInfo.cs b/OpenSim/Tools/Configger/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..62a2f2d8ec --- /dev/null +++ b/OpenSim/Tools/Configger/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OpenSim.Tools.Configger")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("67d7fdf2-554c-40f0-8f9d-f71373c20926")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/OpenSim/Tools/pCampBot/Properties/AssemblyInfo.cs b/OpenSim/Tools/pCampBot/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..20598f1b60 --- /dev/null +++ b/OpenSim/Tools/pCampBot/Properties/AssemblyInfo.cs @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("pCampBot")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("http://opensimulator.org")] +[assembly: AssemblyProduct("OpenSim")] +[assembly: AssemblyCopyright("OpenSimulator developers")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("84a69c60-76d3-4846-bd5b-0e1083774039")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("0.7.5.*")] +[assembly: AssemblyFileVersion("1.0.0.0")] From cd088757e96217defc9a2b0bf323747615c3255e Mon Sep 17 00:00:00 2001 From: "Justin Clark-Casey (justincc)" Date: Fri, 16 Nov 2012 04:36:22 +0000 Subject: [PATCH 3/8] Add a first draft mechanism for the IncomingPacketsProcessedStat to show the delta over time. The chief motivation for this is to be able to tell whether there's any impact on incoming packet processing from enabling extra packet pooling. --- OpenSim/Framework/Monitoring/StatsManager.cs | 139 +++++++++++++++++- OpenSim/Framework/Monitoring/Watchdog.cs | 4 +- .../ClientStack/Linden/UDP/LLUDPServer.cs | 1 + 3 files changed, 140 insertions(+), 4 deletions(-) diff --git a/OpenSim/Framework/Monitoring/StatsManager.cs b/OpenSim/Framework/Monitoring/StatsManager.cs index cebe905f18..eae750582d 100644 --- a/OpenSim/Framework/Monitoring/StatsManager.cs +++ b/OpenSim/Framework/Monitoring/StatsManager.cs @@ -27,6 +27,7 @@ using System; using System.Collections.Generic; +using System.Text; namespace OpenSim.Framework.Monitoring { @@ -246,6 +247,24 @@ namespace OpenSim.Framework.Monitoring return false; } + + public static void RecordStats() + { + lock (RegisteredStats) + { + foreach (Dictionary> category in RegisteredStats.Values) + { + foreach (Dictionary container in category.Values) + { + foreach (Stat stat in container.Values) + { + if (stat.MeasuresOfInterest != MeasuresOfInterest.None) + stat.RecordValue(); + } + } + } + } + } } /// @@ -261,6 +280,16 @@ namespace OpenSim.Framework.Monitoring Pull } + /// + /// Measures of interest for this stat. + /// + [Flags] + public enum MeasuresOfInterest + { + None, + AverageChangeOverTime + } + /// /// Verbosity of stat. /// @@ -295,6 +324,8 @@ namespace OpenSim.Framework.Monitoring public StatType StatType { get; private set; } + public MeasuresOfInterest MeasuresOfInterest { get; private set; } + /// /// Action used to update this stat when the value is requested if it's a pull type. /// @@ -327,6 +358,47 @@ namespace OpenSim.Framework.Monitoring private double m_value; + /// + /// Historical samples for calculating measures of interest average. + /// + /// + /// Will be null if no measures of interest require samples. + /// + private static Queue m_samples; + + /// + /// Maximum number of statistical samples. + /// + /// + /// At the moment this corresponds to 1 minute since the sampling rate is every 2.5 seconds as triggered from + /// the main Watchdog. + /// + private static int m_maxSamples = 24; + + public Stat( + string shortName, + string name, + string description, + string unitName, + string category, + string container, + StatType type, + Action pullAction, + StatVerbosity verbosity) + : this( + shortName, + name, + description, + unitName, + category, + container, + type, + MeasuresOfInterest.None, + pullAction, + verbosity) + { + } + /// /// Constructor /// @@ -341,6 +413,7 @@ namespace OpenSim.Framework.Monitoring /// Entity to which this stat relates. e.g. scene name if this is a per scene stat. /// Push or pull /// Pull stats need an action to update the stat on request. Push stats should set null here. + /// Measures of interest /// Verbosity of stat. Controls whether it will appear in short stat display or only full display. public Stat( string shortName, @@ -350,6 +423,7 @@ namespace OpenSim.Framework.Monitoring string category, string container, StatType type, + MeasuresOfInterest moi, Action pullAction, StatVerbosity verbosity) { @@ -370,13 +444,66 @@ namespace OpenSim.Framework.Monitoring else PullAction = pullAction; + MeasuresOfInterest = moi; + + if ((moi & MeasuresOfInterest.AverageChangeOverTime) == MeasuresOfInterest.AverageChangeOverTime) + m_samples = new Queue(m_maxSamples); + Verbosity = verbosity; } + /// + /// Record a value in the sample set. + /// + /// + /// Do not call this if MeasuresOfInterest.None + /// + public void RecordValue() + { + double newValue = Value; + + lock (m_samples) + { + if (m_samples.Count >= m_maxSamples) + m_samples.Dequeue(); + + m_samples.Enqueue(newValue); + } + } + public virtual string ToConsoleString() { - return string.Format( - "{0}.{1}.{2} : {3}{4}", Category, Container, ShortName, Value, UnitName); + StringBuilder sb = new StringBuilder(); + sb.AppendFormat("{0}.{1}.{2} : {3}{4}", Category, Container, ShortName, Value, UnitName); + + AppendMeasuresOfInterest(sb); + + return sb.ToString(); + } + + protected void AppendMeasuresOfInterest(StringBuilder sb) + { + if ((MeasuresOfInterest & MeasuresOfInterest.AverageChangeOverTime) + == MeasuresOfInterest.AverageChangeOverTime) + { + double totalChange = 0; + double? lastSample = null; + + lock (m_samples) + { + foreach (double s in m_samples) + { + if (lastSample != null) + totalChange += s - (double)lastSample; + + lastSample = s; + } + } + + int divisor = m_samples.Count <= 1 ? 1 : m_samples.Count - 1; + + sb.AppendFormat(", {0:0.##}{1}/s", totalChange / divisor / (Watchdog.WATCHDOG_INTERVAL_MS / 1000), UnitName); + } } } @@ -423,9 +550,15 @@ namespace OpenSim.Framework.Monitoring public override string ToConsoleString() { - return string.Format( + StringBuilder sb = new StringBuilder(); + + sb.AppendFormat( "{0}.{1}.{2} : {3:0.##}{4} ({5}/{6})", Category, Container, ShortName, Value, UnitName, Antecedent, Consequent); + + AppendMeasuresOfInterest(sb); + + return sb.ToString(); } } } \ No newline at end of file diff --git a/OpenSim/Framework/Monitoring/Watchdog.cs b/OpenSim/Framework/Monitoring/Watchdog.cs index a20326dbd8..3f992b1e3b 100644 --- a/OpenSim/Framework/Monitoring/Watchdog.cs +++ b/OpenSim/Framework/Monitoring/Watchdog.cs @@ -39,7 +39,7 @@ namespace OpenSim.Framework.Monitoring public static class Watchdog { /// Timer interval in milliseconds for the watchdog timer - const double WATCHDOG_INTERVAL_MS = 2500.0d; + public const double WATCHDOG_INTERVAL_MS = 2500.0d; /// Default timeout in milliseconds before a thread is considered dead public const int DEFAULT_WATCHDOG_TIMEOUT_MS = 5000; @@ -380,6 +380,8 @@ namespace OpenSim.Framework.Monitoring if (MemoryWatchdog.Enabled) MemoryWatchdog.Update(); + StatsManager.RecordStats(); + m_watchdogTimer.Start(); } } diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs index fcc69c0a4e..a7628d2ec3 100644 --- a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs +++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs @@ -80,6 +80,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP "clientstack", scene.Name, StatType.Pull, + MeasuresOfInterest.AverageChangeOverTime, stat => stat.Value = m_udpServer.IncomingPacketsProcessed, StatVerbosity.Debug)); } From 55f889cc66d78268c530c65a5fd111395cc26dc5 Mon Sep 17 00:00:00 2001 From: "Justin Clark-Casey (justincc)" Date: Fri, 16 Nov 2012 05:02:06 +0000 Subject: [PATCH 4/8] refactor: Move stat classes out of StatManager and into their own files for clarity. --- .../Monitoring/Stats/PercentageStat.cs | 88 ++++++ OpenSim/Framework/Monitoring/Stats/Stat.cs | 238 ++++++++++++++++ OpenSim/Framework/Monitoring/StatsManager.cs | 260 ------------------ 3 files changed, 326 insertions(+), 260 deletions(-) create mode 100644 OpenSim/Framework/Monitoring/Stats/PercentageStat.cs create mode 100644 OpenSim/Framework/Monitoring/Stats/Stat.cs diff --git a/OpenSim/Framework/Monitoring/Stats/PercentageStat.cs b/OpenSim/Framework/Monitoring/Stats/PercentageStat.cs new file mode 100644 index 0000000000..60bed55500 --- /dev/null +++ b/OpenSim/Framework/Monitoring/Stats/PercentageStat.cs @@ -0,0 +1,88 @@ +/* + * 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.Text; + +namespace OpenSim.Framework.Monitoring +{ + public class PercentageStat : Stat + { + public long Antecedent { get; set; } + public long Consequent { get; set; } + + public override double Value + { + get + { + // Asking for an update here means that the updater cannot access this value without infinite recursion. + // XXX: A slightly messy but simple solution may be to flick a flag so we can tell if this is being + // called by the pull action and just return the value. + if (StatType == StatType.Pull) + PullAction(this); + + long c = Consequent; + + // Avoid any chance of a multi-threaded divide-by-zero + if (c == 0) + return 0; + + return (double)Antecedent / c * 100; + } + + set + { + throw new InvalidOperationException("Cannot set value on a PercentageStat"); + } + } + + public PercentageStat( + string shortName, + string name, + string description, + string category, + string container, + StatType type, + Action pullAction, + StatVerbosity verbosity) + : base(shortName, name, description, "%", category, container, type, pullAction, verbosity) {} + + public override string ToConsoleString() + { + StringBuilder sb = new StringBuilder(); + + sb.AppendFormat( + "{0}.{1}.{2} : {3:0.##}{4} ({5}/{6})", + Category, Container, ShortName, Value, UnitName, Antecedent, Consequent); + + AppendMeasuresOfInterest(sb); + + return sb.ToString(); + } + } +} \ No newline at end of file diff --git a/OpenSim/Framework/Monitoring/Stats/Stat.cs b/OpenSim/Framework/Monitoring/Stats/Stat.cs new file mode 100644 index 0000000000..f91251b6ea --- /dev/null +++ b/OpenSim/Framework/Monitoring/Stats/Stat.cs @@ -0,0 +1,238 @@ +/* + * 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.Text; + +namespace OpenSim.Framework.Monitoring +{ + /// + /// Holds individual statistic details + /// + public class Stat + { + /// + /// Category of this stat (e.g. cache, scene, etc). + /// + public string Category { get; private set; } + + /// + /// Containing name for this stat. + /// FIXME: In the case of a scene, this is currently the scene name (though this leaves + /// us with a to-be-resolved problem of non-unique region names). + /// + /// + /// The container. + /// + public string Container { get; private set; } + + public StatType StatType { get; private set; } + + public MeasuresOfInterest MeasuresOfInterest { get; private set; } + + /// + /// Action used to update this stat when the value is requested if it's a pull type. + /// + public Action PullAction { get; private set; } + + public StatVerbosity Verbosity { get; private set; } + public string ShortName { get; private set; } + public string Name { get; private set; } + public string Description { get; private set; } + public virtual string UnitName { get; private set; } + + public virtual double Value + { + get + { + // Asking for an update here means that the updater cannot access this value without infinite recursion. + // XXX: A slightly messy but simple solution may be to flick a flag so we can tell if this is being + // called by the pull action and just return the value. + if (StatType == StatType.Pull) + PullAction(this); + + return m_value; + } + + set + { + m_value = value; + } + } + + private double m_value; + + /// + /// Historical samples for calculating measures of interest average. + /// + /// + /// Will be null if no measures of interest require samples. + /// + private static Queue m_samples; + + /// + /// Maximum number of statistical samples. + /// + /// + /// At the moment this corresponds to 1 minute since the sampling rate is every 2.5 seconds as triggered from + /// the main Watchdog. + /// + private static int m_maxSamples = 24; + + public Stat( + string shortName, + string name, + string description, + string unitName, + string category, + string container, + StatType type, + Action pullAction, + StatVerbosity verbosity) + : this( + shortName, + name, + description, + unitName, + category, + container, + type, + MeasuresOfInterest.None, + pullAction, + verbosity) + { + } + + /// + /// Constructor + /// + /// Short name for the stat. Must not contain spaces. e.g. "LongFrames" + /// Human readable name for the stat. e.g. "Long frames" + /// Description of stat + /// + /// Unit name for the stat. Should be preceeded by a space if the unit name isn't normally appeneded immediately to the value. + /// e.g. " frames" + /// + /// Category under which this stat should appear, e.g. "scene". Do not capitalize. + /// Entity to which this stat relates. e.g. scene name if this is a per scene stat. + /// Push or pull + /// Pull stats need an action to update the stat on request. Push stats should set null here. + /// Measures of interest + /// Verbosity of stat. Controls whether it will appear in short stat display or only full display. + public Stat( + string shortName, + string name, + string description, + string unitName, + string category, + string container, + StatType type, + MeasuresOfInterest moi, + Action pullAction, + StatVerbosity verbosity) + { + if (StatsManager.SubCommands.Contains(category)) + throw new Exception( + string.Format("Stat cannot be in category '{0}' since this is reserved for a subcommand", category)); + + ShortName = shortName; + Name = name; + Description = description; + UnitName = unitName; + Category = category; + Container = container; + StatType = type; + + if (StatType == StatType.Push && pullAction != null) + throw new Exception("A push stat cannot have a pull action"); + else + PullAction = pullAction; + + MeasuresOfInterest = moi; + + if ((moi & MeasuresOfInterest.AverageChangeOverTime) == MeasuresOfInterest.AverageChangeOverTime) + m_samples = new Queue(m_maxSamples); + + Verbosity = verbosity; + } + + /// + /// Record a value in the sample set. + /// + /// + /// Do not call this if MeasuresOfInterest.None + /// + public void RecordValue() + { + double newValue = Value; + + lock (m_samples) + { + if (m_samples.Count >= m_maxSamples) + m_samples.Dequeue(); + + m_samples.Enqueue(newValue); + } + } + + public virtual string ToConsoleString() + { + StringBuilder sb = new StringBuilder(); + sb.AppendFormat("{0}.{1}.{2} : {3}{4}", Category, Container, ShortName, Value, UnitName); + + AppendMeasuresOfInterest(sb); + + return sb.ToString(); + } + + protected void AppendMeasuresOfInterest(StringBuilder sb) + { + if ((MeasuresOfInterest & MeasuresOfInterest.AverageChangeOverTime) + == MeasuresOfInterest.AverageChangeOverTime) + { + double totalChange = 0; + double? lastSample = null; + + lock (m_samples) + { + foreach (double s in m_samples) + { + if (lastSample != null) + totalChange += s - (double)lastSample; + + lastSample = s; + } + } + + int divisor = m_samples.Count <= 1 ? 1 : m_samples.Count - 1; + + sb.AppendFormat(", {0:0.##}{1}/s", totalChange / divisor / (Watchdog.WATCHDOG_INTERVAL_MS / 1000), UnitName); + } + } + } +} \ No newline at end of file diff --git a/OpenSim/Framework/Monitoring/StatsManager.cs b/OpenSim/Framework/Monitoring/StatsManager.cs index eae750582d..0762b01c7d 100644 --- a/OpenSim/Framework/Monitoring/StatsManager.cs +++ b/OpenSim/Framework/Monitoring/StatsManager.cs @@ -301,264 +301,4 @@ namespace OpenSim.Framework.Monitoring Debug, Info } - - /// - /// Holds individual static details - /// - public class Stat - { - /// - /// Category of this stat (e.g. cache, scene, etc). - /// - public string Category { get; private set; } - - /// - /// Containing name for this stat. - /// FIXME: In the case of a scene, this is currently the scene name (though this leaves - /// us with a to-be-resolved problem of non-unique region names). - /// - /// - /// The container. - /// - public string Container { get; private set; } - - public StatType StatType { get; private set; } - - public MeasuresOfInterest MeasuresOfInterest { get; private set; } - - /// - /// Action used to update this stat when the value is requested if it's a pull type. - /// - public Action PullAction { get; private set; } - - public StatVerbosity Verbosity { get; private set; } - public string ShortName { get; private set; } - public string Name { get; private set; } - public string Description { get; private set; } - public virtual string UnitName { get; private set; } - - public virtual double Value - { - get - { - // Asking for an update here means that the updater cannot access this value without infinite recursion. - // XXX: A slightly messy but simple solution may be to flick a flag so we can tell if this is being - // called by the pull action and just return the value. - if (StatType == StatType.Pull) - PullAction(this); - - return m_value; - } - - set - { - m_value = value; - } - } - - private double m_value; - - /// - /// Historical samples for calculating measures of interest average. - /// - /// - /// Will be null if no measures of interest require samples. - /// - private static Queue m_samples; - - /// - /// Maximum number of statistical samples. - /// - /// - /// At the moment this corresponds to 1 minute since the sampling rate is every 2.5 seconds as triggered from - /// the main Watchdog. - /// - private static int m_maxSamples = 24; - - public Stat( - string shortName, - string name, - string description, - string unitName, - string category, - string container, - StatType type, - Action pullAction, - StatVerbosity verbosity) - : this( - shortName, - name, - description, - unitName, - category, - container, - type, - MeasuresOfInterest.None, - pullAction, - verbosity) - { - } - - /// - /// Constructor - /// - /// Short name for the stat. Must not contain spaces. e.g. "LongFrames" - /// Human readable name for the stat. e.g. "Long frames" - /// Description of stat - /// - /// Unit name for the stat. Should be preceeded by a space if the unit name isn't normally appeneded immediately to the value. - /// e.g. " frames" - /// - /// Category under which this stat should appear, e.g. "scene". Do not capitalize. - /// Entity to which this stat relates. e.g. scene name if this is a per scene stat. - /// Push or pull - /// Pull stats need an action to update the stat on request. Push stats should set null here. - /// Measures of interest - /// Verbosity of stat. Controls whether it will appear in short stat display or only full display. - public Stat( - string shortName, - string name, - string description, - string unitName, - string category, - string container, - StatType type, - MeasuresOfInterest moi, - Action pullAction, - StatVerbosity verbosity) - { - if (StatsManager.SubCommands.Contains(category)) - throw new Exception( - string.Format("Stat cannot be in category '{0}' since this is reserved for a subcommand", category)); - - ShortName = shortName; - Name = name; - Description = description; - UnitName = unitName; - Category = category; - Container = container; - StatType = type; - - if (StatType == StatType.Push && pullAction != null) - throw new Exception("A push stat cannot have a pull action"); - else - PullAction = pullAction; - - MeasuresOfInterest = moi; - - if ((moi & MeasuresOfInterest.AverageChangeOverTime) == MeasuresOfInterest.AverageChangeOverTime) - m_samples = new Queue(m_maxSamples); - - Verbosity = verbosity; - } - - /// - /// Record a value in the sample set. - /// - /// - /// Do not call this if MeasuresOfInterest.None - /// - public void RecordValue() - { - double newValue = Value; - - lock (m_samples) - { - if (m_samples.Count >= m_maxSamples) - m_samples.Dequeue(); - - m_samples.Enqueue(newValue); - } - } - - public virtual string ToConsoleString() - { - StringBuilder sb = new StringBuilder(); - sb.AppendFormat("{0}.{1}.{2} : {3}{4}", Category, Container, ShortName, Value, UnitName); - - AppendMeasuresOfInterest(sb); - - return sb.ToString(); - } - - protected void AppendMeasuresOfInterest(StringBuilder sb) - { - if ((MeasuresOfInterest & MeasuresOfInterest.AverageChangeOverTime) - == MeasuresOfInterest.AverageChangeOverTime) - { - double totalChange = 0; - double? lastSample = null; - - lock (m_samples) - { - foreach (double s in m_samples) - { - if (lastSample != null) - totalChange += s - (double)lastSample; - - lastSample = s; - } - } - - int divisor = m_samples.Count <= 1 ? 1 : m_samples.Count - 1; - - sb.AppendFormat(", {0:0.##}{1}/s", totalChange / divisor / (Watchdog.WATCHDOG_INTERVAL_MS / 1000), UnitName); - } - } - } - - public class PercentageStat : Stat - { - public long Antecedent { get; set; } - public long Consequent { get; set; } - - public override double Value - { - get - { - // Asking for an update here means that the updater cannot access this value without infinite recursion. - // XXX: A slightly messy but simple solution may be to flick a flag so we can tell if this is being - // called by the pull action and just return the value. - if (StatType == StatType.Pull) - PullAction(this); - - long c = Consequent; - - // Avoid any chance of a multi-threaded divide-by-zero - if (c == 0) - return 0; - - return (double)Antecedent / c * 100; - } - - set - { - throw new InvalidOperationException("Cannot set value on a PercentageStat"); - } - } - - public PercentageStat( - string shortName, - string name, - string description, - string category, - string container, - StatType type, - Action pullAction, - StatVerbosity verbosity) - : base(shortName, name, description, "%", category, container, type, pullAction, verbosity) {} - - public override string ToConsoleString() - { - StringBuilder sb = new StringBuilder(); - - sb.AppendFormat( - "{0}.{1}.{2} : {3:0.##}{4} ({5}/{6})", - Category, Container, ShortName, Value, UnitName, Antecedent, Consequent); - - AppendMeasuresOfInterest(sb); - - return sb.ToString(); - } - } } \ No newline at end of file From e25c51330a3d0009f4308bf45cf057e216c17ba9 Mon Sep 17 00:00:00 2001 From: "Justin Clark-Casey (justincc)" Date: Sat, 17 Nov 2012 00:12:25 +0000 Subject: [PATCH 5/8] Add basic XInventoryServicesTests.TestAddItem() regression test. --- .nant/local.include | 11 +++ .../Tests/XInventoryServiceTests.cs | 87 +++++++++++++++++++ prebuild.xml | 46 +++++++++- 3 files changed, 143 insertions(+), 1 deletion(-) create mode 100644 OpenSim/Services/InventoryService/Tests/XInventoryServiceTests.cs diff --git a/.nant/local.include b/.nant/local.include index 35f00589e8..9c9aa28a5c 100644 --- a/.nant/local.include +++ b/.nant/local.include @@ -132,6 +132,11 @@ + + + + + @@ -235,6 +240,11 @@ + + + + + @@ -245,6 +255,7 @@ + diff --git a/OpenSim/Services/InventoryService/Tests/XInventoryServiceTests.cs b/OpenSim/Services/InventoryService/Tests/XInventoryServiceTests.cs new file mode 100644 index 0000000000..d2356c5f83 --- /dev/null +++ b/OpenSim/Services/InventoryService/Tests/XInventoryServiceTests.cs @@ -0,0 +1,87 @@ +/* + * 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 Nini.Config; +using NUnit.Framework; +using OpenMetaverse; +using OpenSim.Framework; +using OpenSim.Server.Base; +using OpenSim.Services.Interfaces; +using OpenSim.Tests.Common; + +namespace OpenSim.Services.InventoryService.Tests +{ + /// + /// Tests for the XInventoryService + /// + /// + /// TODO: Fill out more tests. + /// + [TestFixture] + public class XInventoryServiceTests + { + /// + /// Tests add item operation. + /// + /// + /// TODO: Test all operations. + /// + [Test] + public void TestAddItem() + { + string creatorId = TestHelpers.ParseTail(0x1).ToString(); + UUID ownerId = TestHelpers.ParseTail(0x2); + UUID itemId = TestHelpers.ParseTail(0x10); + UUID assetId = TestHelpers.ParseTail(0x20); + string itemName = "item1"; + + IConfigSource config = new IniConfigSource(); + config.AddConfig("InventoryService"); + config.Configs["InventoryService"].Set("StorageProvider", "OpenSim.Tests.Common.dll"); + + IInventoryService xis + = ServerUtils.LoadPlugin( + "OpenSim.Services.InventoryService.dll:XInventoryService", new Object[] { config }); + + InventoryItemBase itemToStore + = new InventoryItemBase(itemId, ownerId) + { CreatorId = creatorId.ToString(), AssetID = assetId, Name = itemName }; + + xis.AddItem(itemToStore); + + InventoryItemBase itemRetrieved = new InventoryItemBase(itemId); + itemRetrieved = xis.GetItem(itemRetrieved); + + Assert.That(itemRetrieved, Is.Not.Null); + Assert.That(itemRetrieved.CreatorId, Is.EqualTo(creatorId)); + Assert.That(itemRetrieved.Owner, Is.EqualTo(ownerId)); + Assert.That(itemRetrieved.AssetID, Is.EqualTo(assetId)); + Assert.That(itemRetrieved.Name, Is.EqualTo(itemName)); + } + } +} \ No newline at end of file diff --git a/prebuild.xml b/prebuild.xml index aca0c49690..7694861777 100644 --- a/prebuild.xml +++ b/prebuild.xml @@ -1124,7 +1124,9 @@ - + + + @@ -2719,6 +2721,48 @@ + + + + ../../../../bin/ + + + + + ../../../../bin/ + + + + ../../../../bin/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 2aa58c58435e0071da185d32a3f3cb622f699de0 Mon Sep 17 00:00:00 2001 From: "Justin Clark-Casey (justincc)" Date: Sat, 17 Nov 2012 01:01:14 +0000 Subject: [PATCH 6/8] Do not allow invariants to change on calls to XInventoryService.UpdateItem() This is to help track down http://opensimulator.org/mantis/view.php?id=6359 where creator IDs on items and rezzed objects have been reported to sometimes change. This should never happen - a particular item should never change creators (if an item is given then a new item (with new id) is created). Invariants are inventory type, asset type, folder (changed only on MoveItems()), CreatorIdentification and Owner. If caller attempts to change an invariant, warning is logged but other properties are still changed. If you see this warning, reporting on Mantis 6359 would be very welcome with the exact operation being done at the time. --- .../Tests/XInventoryServiceTests.cs | 110 ++++++++++++++++-- .../InventoryService/XInventoryService.cs | 40 +++++++ 2 files changed, 140 insertions(+), 10 deletions(-) diff --git a/OpenSim/Services/InventoryService/Tests/XInventoryServiceTests.cs b/OpenSim/Services/InventoryService/Tests/XInventoryServiceTests.cs index d2356c5f83..9e3fa695af 100644 --- a/OpenSim/Services/InventoryService/Tests/XInventoryServiceTests.cs +++ b/OpenSim/Services/InventoryService/Tests/XInventoryServiceTests.cs @@ -43,8 +43,18 @@ namespace OpenSim.Services.InventoryService.Tests /// TODO: Fill out more tests. /// [TestFixture] - public class XInventoryServiceTests + public class XInventoryServiceTests : OpenSimTestCase { + private IInventoryService CreateXInventoryService() + { + IConfigSource config = new IniConfigSource(); + config.AddConfig("InventoryService"); + config.Configs["InventoryService"].Set("StorageProvider", "OpenSim.Tests.Common.dll"); + + return ServerUtils.LoadPlugin( + "OpenSim.Services.InventoryService.dll:XInventoryService", new Object[] { config }); + } + /// /// Tests add item operation. /// @@ -54,25 +64,31 @@ namespace OpenSim.Services.InventoryService.Tests [Test] public void TestAddItem() { + TestHelpers.InMethod(); + string creatorId = TestHelpers.ParseTail(0x1).ToString(); UUID ownerId = TestHelpers.ParseTail(0x2); UUID itemId = TestHelpers.ParseTail(0x10); UUID assetId = TestHelpers.ParseTail(0x20); + UUID folderId = TestHelpers.ParseTail(0x30); + int invType = (int)InventoryType.Animation; + int assetType = (int)AssetType.Animation; string itemName = "item1"; - IConfigSource config = new IniConfigSource(); - config.AddConfig("InventoryService"); - config.Configs["InventoryService"].Set("StorageProvider", "OpenSim.Tests.Common.dll"); - - IInventoryService xis - = ServerUtils.LoadPlugin( - "OpenSim.Services.InventoryService.dll:XInventoryService", new Object[] { config }); + IInventoryService xis = CreateXInventoryService(); InventoryItemBase itemToStore = new InventoryItemBase(itemId, ownerId) - { CreatorId = creatorId.ToString(), AssetID = assetId, Name = itemName }; + { + CreatorIdentification = creatorId.ToString(), + AssetID = assetId, + Name = itemName, + Folder = folderId, + InvType = invType, + AssetType = assetType + }; - xis.AddItem(itemToStore); + Assert.That(xis.AddItem(itemToStore), Is.True); InventoryItemBase itemRetrieved = new InventoryItemBase(itemId); itemRetrieved = xis.GetItem(itemRetrieved); @@ -81,7 +97,81 @@ namespace OpenSim.Services.InventoryService.Tests Assert.That(itemRetrieved.CreatorId, Is.EqualTo(creatorId)); Assert.That(itemRetrieved.Owner, Is.EqualTo(ownerId)); Assert.That(itemRetrieved.AssetID, Is.EqualTo(assetId)); + Assert.That(itemRetrieved.Folder, Is.EqualTo(folderId)); + Assert.That(itemRetrieved.InvType, Is.EqualTo(invType)); + Assert.That(itemRetrieved.AssetType, Is.EqualTo(assetType)); Assert.That(itemRetrieved.Name, Is.EqualTo(itemName)); } + + [Test] + public void TestUpdateItem() + { + TestHelpers.InMethod(); +// TestHelpers.EnableLogging(); + + string creatorId = TestHelpers.ParseTail(0x1).ToString(); + UUID ownerId = TestHelpers.ParseTail(0x2); + UUID itemId = TestHelpers.ParseTail(0x10); + UUID assetId = TestHelpers.ParseTail(0x20); + UUID folderId = TestHelpers.ParseTail(0x30); + int invType = (int)InventoryType.Animation; + int assetType = (int)AssetType.Animation; + string itemName = "item1"; + string itemName2 = "item2"; + + IInventoryService xis = CreateXInventoryService(); + + InventoryItemBase itemToStore + = new InventoryItemBase(itemId, ownerId) + { + CreatorIdentification = creatorId.ToString(), + AssetID = assetId, + Name = itemName, + Folder = folderId, + InvType = invType, + AssetType = assetType + }; + + Assert.That(xis.AddItem(itemToStore), Is.True); + + // Normal update + itemToStore.Name = itemName2; + + Assert.That(xis.UpdateItem(itemToStore), Is.True); + + InventoryItemBase itemRetrieved = new InventoryItemBase(itemId); + itemRetrieved = xis.GetItem(itemRetrieved); + + Assert.That(itemRetrieved, Is.Not.Null); + Assert.That(itemRetrieved.Name, Is.EqualTo(itemName2)); + + // Attempt to update properties that should never change + string creatorId2 = TestHelpers.ParseTail(0x7).ToString(); + UUID ownerId2 = TestHelpers.ParseTail(0x8); + UUID folderId2 = TestHelpers.ParseTail(0x70); + int invType2 = (int)InventoryType.CallingCard; + int assetType2 = (int)AssetType.CallingCard; + string itemName3 = "item3"; + + itemToStore.CreatorIdentification = creatorId2.ToString(); + itemToStore.Owner = ownerId2; + itemToStore.Folder = folderId2; + itemToStore.InvType = invType2; + itemToStore.AssetType = assetType2; + itemToStore.Name = itemName3; + + Assert.That(xis.UpdateItem(itemToStore), Is.True); + + itemRetrieved = xis.GetItem(itemRetrieved); + + Assert.That(itemRetrieved, Is.Not.Null); + Assert.That(itemRetrieved.CreatorId, Is.EqualTo(creatorId)); + Assert.That(itemRetrieved.Owner, Is.EqualTo(ownerId)); + Assert.That(itemRetrieved.AssetID, Is.EqualTo(assetId)); + Assert.That(itemRetrieved.Folder, Is.EqualTo(folderId)); + Assert.That(itemRetrieved.InvType, Is.EqualTo(invType)); + Assert.That(itemRetrieved.AssetType, Is.EqualTo(assetType)); + Assert.That(itemRetrieved.Name, Is.EqualTo(itemName3)); + } } } \ No newline at end of file diff --git a/OpenSim/Services/InventoryService/XInventoryService.cs b/OpenSim/Services/InventoryService/XInventoryService.cs index 9abc5e4f72..00faa440d5 100644 --- a/OpenSim/Services/InventoryService/XInventoryService.cs +++ b/OpenSim/Services/InventoryService/XInventoryService.cs @@ -476,6 +476,46 @@ namespace OpenSim.Services.InventoryService // m_log.InfoFormat( // "[XINVENTORY SERVICE]: Updating item {0} {1} in folder {2}", item.Name, item.ID, item.Folder); + InventoryItemBase retrievedItem = GetItem(item); + + if (retrievedItem == null) + { + m_log.WarnFormat( + "[XINVENTORY SERVICE]: Tried to update item {0} {1}, owner {2} but no existing item found.", + item.Name, item.ID, item.Owner); + + return false; + } + + // Do not allow invariants to change. Changes to folder ID occur in MoveItems() + if (retrievedItem.InvType != item.InvType + || retrievedItem.AssetType != item.AssetType + || retrievedItem.Folder != item.Folder + || retrievedItem.CreatorIdentification != item.CreatorIdentification + || retrievedItem.Owner != item.Owner) + { + m_log.WarnFormat( + "[XINVENTORY SERVICE]: Caller to UpdateItem() for {0} {1} tried to alter property(s) that should be invariant, (InvType, AssetType, Folder, CreatorIdentification, Owner), existing ({2}, {3}, {4}, {5}, {6}), update ({7}, {8}, {9}, {10}, {11})", + retrievedItem.Name, + retrievedItem.ID, + retrievedItem.InvType, + retrievedItem.AssetType, + retrievedItem.Folder, + retrievedItem.CreatorIdentification, + retrievedItem.Owner, + item.InvType, + item.AssetType, + item.Folder, + item.CreatorIdentification, + item.Owner); + + item.InvType = retrievedItem.InvType; + item.AssetType = retrievedItem.AssetType; + item.Folder = retrievedItem.Folder; + item.CreatorIdentification = retrievedItem.CreatorIdentification; + item.Owner = retrievedItem.Owner; + } + return m_Database.StoreItem(ConvertFromOpenSim(item)); } From 392e84e55402166f5b4ec708d3338efe70a94c2e Mon Sep 17 00:00:00 2001 From: "Justin Clark-Casey (justincc)" Date: Sat, 17 Nov 2012 01:23:29 +0000 Subject: [PATCH 7/8] Remove unnecessary ability to directly set InventoryItemBase.CreatorIdAsUuid This was necessary historically but hasn't been for many years. Can still get CreatorIdAsUuid, which is really just a UUID cached version of the string CreatorId --- .../RemoteController/RemoteAdminPlugin.cs | 4 ---- OpenSim/Framework/InventoryItemBase.cs | 22 +++++-------------- .../Archiver/InventoryArchiveReadRequest.cs | 5 ++--- .../Tests/InventoryArchiveTestCase.cs | 4 ++-- .../SimianInventoryServiceConnector.cs | 1 - 5 files changed, 9 insertions(+), 27 deletions(-) diff --git a/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs b/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs index 15fbdddb28..a75d10d417 100644 --- a/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs +++ b/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs @@ -2314,7 +2314,6 @@ namespace OpenSim.ApplicationPlugins.RemoteController destinationItem.Description = item.Description; destinationItem.InvType = item.InvType; destinationItem.CreatorId = item.CreatorId; - destinationItem.CreatorIdAsUuid = item.CreatorIdAsUuid; destinationItem.CreatorData = item.CreatorData; destinationItem.NextPermissions = item.NextPermissions; destinationItem.CurrentPermissions = item.CurrentPermissions; @@ -2369,7 +2368,6 @@ namespace OpenSim.ApplicationPlugins.RemoteController destinationItem.Description = item.Description; destinationItem.InvType = item.InvType; destinationItem.CreatorId = item.CreatorId; - destinationItem.CreatorIdAsUuid = item.CreatorIdAsUuid; destinationItem.CreatorData = item.CreatorData; destinationItem.NextPermissions = item.NextPermissions; destinationItem.CurrentPermissions = item.CurrentPermissions; @@ -2482,7 +2480,6 @@ namespace OpenSim.ApplicationPlugins.RemoteController destinationItem.Description = item.Description; destinationItem.InvType = item.InvType; destinationItem.CreatorId = item.CreatorId; - destinationItem.CreatorIdAsUuid = item.CreatorIdAsUuid; destinationItem.CreatorData = item.CreatorData; destinationItem.NextPermissions = item.NextPermissions; destinationItem.CurrentPermissions = item.CurrentPermissions; @@ -2788,7 +2785,6 @@ namespace OpenSim.ApplicationPlugins.RemoteController inventoryItem.Description = GetStringAttribute(item,"desc",""); inventoryItem.InvType = GetIntegerAttribute(item,"invtype",-1); inventoryItem.CreatorId = GetStringAttribute(item,"creatorid",""); - inventoryItem.CreatorIdAsUuid = (UUID)GetStringAttribute(item,"creatoruuid",""); inventoryItem.CreatorData = GetStringAttribute(item, "creatordata", ""); inventoryItem.NextPermissions = GetUnsignedAttribute(perms, "next", 0x7fffffff); inventoryItem.CurrentPermissions = GetUnsignedAttribute(perms,"current",0x7fffffff); diff --git a/OpenSim/Framework/InventoryItemBase.cs b/OpenSim/Framework/InventoryItemBase.cs index a663680a78..3d45e76698 100644 --- a/OpenSim/Framework/InventoryItemBase.cs +++ b/OpenSim/Framework/InventoryItemBase.cs @@ -87,16 +87,7 @@ namespace OpenSim.Framework protected string m_creatorId; /// - /// The UUID for the creator. This may be different from the canonical CreatorId. This property is used - /// for communication with the client over the Second Life protocol, since that protocol can only understand - /// UUIDs. As this is a basic framework class, this means that both the string creator id and the uuid - /// reference have to be settable separately - /// - /// Database plugins don't need to set this, it will be set by - /// upstream code (or set by the get accessor if left unset). - /// - /// XXX: An alternative to having a separate uuid property would be to hash the CreatorId appropriately - /// every time there was communication with a UUID-only client. This may be much more expensive. + /// The CreatorId expressed as a UUID.tely /// public UUID CreatorIdAsUuid { @@ -109,20 +100,18 @@ namespace OpenSim.Framework return m_creatorIdAsUuid; } - - set - { - m_creatorIdAsUuid = value; - } } protected UUID m_creatorIdAsUuid = UUID.Zero; - protected string m_creatorData = string.Empty; + /// + /// Extended creator information of the form ; + /// public string CreatorData // = ; { get { return m_creatorData; } set { m_creatorData = value; } } + protected string m_creatorData = string.Empty; /// /// Used by the DB layer to retrieve / store the entire user identification. @@ -162,7 +151,6 @@ namespace OpenSim.Framework name = parts[2]; m_creatorData += ';' + name; - } } } diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs index ee10d04ee1..50698031ad 100644 --- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs +++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiveReadRequest.cs @@ -411,18 +411,17 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver { // m_log.DebugFormat("[INVENTORY ARCHIVER]: Found creator {0} via OSPA resolution", ospResolvedId); - item.CreatorIdAsUuid = ospResolvedId; +// item.CreatorIdAsUuid = ospResolvedId; // Don't preserve the OSPA in the creator id (which actually gets persisted to the // database). Instead, replace with the UUID that we found. item.CreatorId = ospResolvedId.ToString(); - item.CreatorData = string.Empty; } else if (item.CreatorData == null || item.CreatorData == String.Empty) { item.CreatorId = m_userInfo.PrincipalID.ToString(); - item.CreatorIdAsUuid = new UUID(item.CreatorId); +// item.CreatorIdAsUuid = new UUID(item.CreatorId); } item.Owner = m_userInfo.PrincipalID; diff --git a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveTestCase.cs b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveTestCase.cs index 00727a45a6..db78da9ae6 100644 --- a/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveTestCase.cs +++ b/OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/Tests/InventoryArchiveTestCase.cs @@ -134,7 +134,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests item1.ID = UUID.Parse("00000000-0000-0000-0000-000000000020"); item1.AssetID = asset1.FullID; item1.GroupID = UUID.Random(); - item1.CreatorIdAsUuid = m_uaLL1.PrincipalID; + item1.CreatorId = m_uaLL1.PrincipalID.ToString(); item1.Owner = m_uaLL1.PrincipalID; item1.Folder = scene.InventoryService.GetRootFolder(m_uaLL1.PrincipalID).ID; scene.AddInventoryItem(item1); @@ -157,7 +157,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Inventory.Archiver.Tests coaItem.ID = UUID.Parse("00000000-0000-0000-0000-000000000180"); coaItem.AssetID = coaAsset.FullID; coaItem.GroupID = UUID.Random(); - coaItem.CreatorIdAsUuid = m_uaLL1.PrincipalID; + coaItem.CreatorId = m_uaLL1.PrincipalID.ToString(); coaItem.Owner = m_uaLL1.PrincipalID; coaItem.Folder = scene.InventoryService.GetRootFolder(m_uaLL1.PrincipalID).ID; scene.AddInventoryItem(coaItem); diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs index 4d7841b415..a3912758aa 100644 --- a/OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs +++ b/OpenSim/Services/Connectors/SimianGrid/SimianInventoryServiceConnector.cs @@ -781,7 +781,6 @@ namespace OpenSim.Services.Connectors.SimianGrid invItem.CreationDate = item["CreationDate"].AsInteger(); invItem.CreatorId = item["CreatorID"].AsString(); invItem.CreatorData = item["CreatorData"].AsString(); - invItem.CreatorIdAsUuid = item["CreatorID"].AsUUID(); invItem.Description = item["Description"].AsString(); invItem.Folder = item["ParentID"].AsUUID(); invItem.ID = item["ID"].AsUUID(); From 5b79bfc4dfb757fd06d847ecfcbaf97bc700f03b Mon Sep 17 00:00:00 2001 From: "Justin Clark-Casey (justincc)" Date: Sat, 17 Nov 2012 01:32:01 +0000 Subject: [PATCH 8/8] Remove old InventoryService, which has for a long time been replaced by XInventoryService. --- .../InventoryService/InventoryService.cs | 700 ------------------ .../InventoryService/InventoryServiceBase.cs | 82 -- 2 files changed, 782 deletions(-) delete mode 100644 OpenSim/Services/InventoryService/InventoryService.cs delete mode 100644 OpenSim/Services/InventoryService/InventoryServiceBase.cs diff --git a/OpenSim/Services/InventoryService/InventoryService.cs b/OpenSim/Services/InventoryService/InventoryService.cs deleted file mode 100644 index 73dd06ac3a..0000000000 --- a/OpenSim/Services/InventoryService/InventoryService.cs +++ /dev/null @@ -1,700 +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.Reflection; -using log4net; -using Nini.Config; -using OpenMetaverse; -using OpenSim.Data; -using OpenSim.Framework; -using OpenSim.Services.Interfaces; - -namespace OpenSim.Services.InventoryService -{ - /// - /// The Inventory service reference implementation - /// - public class InventoryService : InventoryServiceBase, IInventoryService - { - private static readonly ILog m_log - = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); - - public InventoryService(IConfigSource config) : base(config) - { - m_log.Debug("[INVENTORY SERVICE]: Initialized."); - } - - #region IInventoryServices methods - - public string Host - { - get { return "default"; } - } - - public List GetInventorySkeleton(UUID userId) - { - m_log.DebugFormat("[INVENTORY SERVICE]: Getting inventory skeleton for {0}", userId); - - InventoryFolderBase rootFolder = GetRootFolder(userId); - - // Agent has no inventory structure yet. - if (null == rootFolder) - { - m_log.DebugFormat("[INVENTORY SERVICE]: No root folder"); - return null; - } - - List userFolders = new List(); - - userFolders.Add(rootFolder); - - IList folders = m_Database.getFolderHierarchy(rootFolder.ID); - userFolders.AddRange(folders); - -// m_log.DebugFormat("[INVENTORY SERVICE]: Got folder {0} {1}", folder.name, folder.folderID); - - return userFolders; - } - - public virtual bool HasInventoryForUser(UUID userID) - { - return false; - } - - // See IInventoryServices - public virtual InventoryFolderBase GetRootFolder(UUID userID) - { - //m_log.DebugFormat("[INVENTORY SERVICE]: Getting root folder for {0}", userID); - - // Retrieve the first root folder we get from the DB. - InventoryFolderBase rootFolder = m_Database.getUserRootFolder(userID); - if (rootFolder != null) - return rootFolder; - - // Return nothing if the plugin was unable to supply a root folder - return null; - } - - // See IInventoryServices - public bool CreateUserInventory(UUID user) - { - InventoryFolderBase existingRootFolder; - try - { - existingRootFolder = GetRootFolder(user); - } - catch /*(Exception e)*/ - { - // Munch the exception, it has already been reported - // - return false; - } - - if (null != existingRootFolder) - { - m_log.WarnFormat( - "[INVENTORY SERVICE]: Did not create a new inventory for user {0} since they already have " - + "a root inventory folder with id {1}", - user, existingRootFolder.ID); - } - else - { - UsersInventory inven = new UsersInventory(); - inven.CreateNewInventorySet(user); - AddNewInventorySet(inven); - - return true; - } - - return false; - } - - // See IInventoryServices - - /// - /// Return a user's entire inventory synchronously - /// - /// - /// The user's inventory. If an inventory cannot be found then an empty collection is returned. - public InventoryCollection GetUserInventory(UUID userID) - { - m_log.InfoFormat("[INVENTORY SERVICE]: Processing request for inventory of {0}", userID); - - // Uncomment me to simulate a slow responding inventory server - //Thread.Sleep(16000); - - InventoryCollection invCollection = new InventoryCollection(); - - List allFolders = GetInventorySkeleton(userID); - - if (null == allFolders) - { - m_log.WarnFormat("[INVENTORY SERVICE]: No inventory found for user {0}", userID); - - return invCollection; - } - - List allItems = new List(); - - foreach (InventoryFolderBase folder in allFolders) - { - List items = GetFolderItems(userID, folder.ID); - - if (items != null) - { - allItems.InsertRange(0, items); - } - } - - invCollection.UserID = userID; - invCollection.Folders = allFolders; - invCollection.Items = allItems; - - // foreach (InventoryFolderBase folder in invCollection.Folders) - // { - // m_log.DebugFormat("[GRID INVENTORY SERVICE]: Sending back folder {0} {1}", folder.Name, folder.ID); - // } - // - // foreach (InventoryItemBase item in invCollection.Items) - // { - // m_log.DebugFormat("[GRID INVENTORY SERVICE]: Sending back item {0} {1}, folder {2}", item.Name, item.ID, item.Folder); - // } - - m_log.InfoFormat( - "[INVENTORY SERVICE]: Sending back inventory response to user {0} containing {1} folders and {2} items", - invCollection.UserID, invCollection.Folders.Count, invCollection.Items.Count); - - return invCollection; - } - - /// - /// Asynchronous inventory fetch. - /// - /// - /// - public void GetUserInventory(UUID userID, InventoryReceiptCallback callback) - { - m_log.InfoFormat("[INVENTORY SERVICE]: Requesting inventory for user {0}", userID); - - List folders = new List(); - List items = new List(); - - List skeletonFolders = GetInventorySkeleton(userID); - - if (skeletonFolders != null) - { - InventoryFolderImpl rootFolder = null; - - // Need to retrieve the root folder on the first pass - foreach (InventoryFolderBase folder in skeletonFolders) - { - if (folder.ParentID == UUID.Zero) - { - rootFolder = new InventoryFolderImpl(folder); - folders.Add(rootFolder); - items.AddRange(GetFolderItems(userID, rootFolder.ID)); - break; // Only 1 root folder per user - } - } - - if (rootFolder != null) - { - foreach (InventoryFolderBase folder in skeletonFolders) - { - if (folder.ID != rootFolder.ID) - { - folders.Add(new InventoryFolderImpl(folder)); - items.AddRange(GetFolderItems(userID, folder.ID)); - } - } - } - - m_log.InfoFormat( - "[INVENTORY SERVICE]: Received inventory response for user {0} containing {1} folders and {2} items", - userID, folders.Count, items.Count); - } - else - { - m_log.WarnFormat("[INVENTORY SERVICE]: User {0} inventory not available", userID); - } - - Util.FireAndForget(delegate { callback(folders, items); }); - } - - public InventoryCollection GetFolderContent(UUID userID, UUID folderID) - { - // Uncomment me to simulate a slow responding inventory server - //Thread.Sleep(16000); - - InventoryCollection invCollection = new InventoryCollection(); - - List items = GetFolderItems(userID, folderID); - List folders = RequestSubFolders(folderID); - - invCollection.UserID = userID; - invCollection.Folders = folders; - invCollection.Items = items; - - m_log.DebugFormat("[INVENTORY SERVICE]: Found {0} items and {1} folders in folder {2}", items.Count, folders.Count, folderID); - - return invCollection; - } - - public InventoryFolderBase GetFolderForType(UUID userID, AssetType type) - { -// m_log.DebugFormat("[INVENTORY SERVICE]: Looking for folder type {0} for user {1}", type, userID); - - InventoryFolderBase root = m_Database.getUserRootFolder(userID); - if (root != null) - { - List folders = RequestSubFolders(root.ID); - - foreach (InventoryFolderBase folder in folders) - { - if (folder.Type == (short)type) - { -// m_log.DebugFormat( -// "[INVENTORY SERVICE]: Found folder {0} type {1}", folder.Name, (AssetType)folder.Type); - - return folder; - } - } - } - - // we didn't find any folder of that type. Return the root folder - // hopefully the root folder is not null. If it is, too bad - return root; - } - - public Dictionary GetSystemFolders(UUID userID) - { - InventoryFolderBase root = GetRootFolder(userID); - if (root != null) - { - InventoryCollection content = GetFolderContent(userID, root.ID); - if (content != null) - { - Dictionary folders = new Dictionary(); - foreach (InventoryFolderBase folder in content.Folders) - { - if ((folder.Type != (short)AssetType.Folder) && (folder.Type != (short)AssetType.Unknown)) - folders[(AssetType)folder.Type] = folder; - } - m_log.DebugFormat("[INVENTORY SERVICE]: Got {0} system folders for {1}", folders.Count, userID); - return folders; - } - } - m_log.WarnFormat("[INVENTORY SERVICE]: System folders for {0} not found", userID); - return new Dictionary(); - } - - public List GetActiveGestures(UUID userId) - { - List activeGestures = new List(); - activeGestures.AddRange(m_Database.fetchActiveGestures(userId)); - - return activeGestures; - } - - #endregion - - #region Methods used by GridInventoryService - - public List RequestSubFolders(UUID parentFolderID) - { - List inventoryList = new List(); - - inventoryList.AddRange(m_Database.getInventoryFolders(parentFolderID)); - - return inventoryList; - } - - public List GetFolderItems(UUID userID, UUID folderID) - { - List itemsList = new List(); - - itemsList.AddRange(m_Database.getInventoryInFolder(folderID)); - -// m_log.DebugFormat( -// "[INVENTORY SERVICE]: Found {0} items in folder {1} for {2}", itemsList.Count, folderID, userID); - - return itemsList; - } - - #endregion - - // See IInventoryServices - public virtual bool AddFolder(InventoryFolderBase folder) - { - m_log.DebugFormat( - "[INVENTORY SERVICE]: Adding folder {0} {1} to folder {2}", folder.Name, folder.ID, folder.ParentID); - - m_Database.addInventoryFolder(folder); - - // FIXME: Should return false on failure - return true; - } - - // See IInventoryServices - public virtual bool UpdateFolder(InventoryFolderBase folder) - { - m_log.DebugFormat( - "[INVENTORY SERVICE]: Updating folder {0} {1} to folder {2}", folder.Name, folder.ID, folder.ParentID); - - m_Database.updateInventoryFolder(folder); - - // FIXME: Should return false on failure - return true; - } - - // See IInventoryServices - public virtual bool MoveFolder(InventoryFolderBase folder) - { - m_log.DebugFormat( - "[INVENTORY SERVICE]: Moving folder {0} {1} to folder {2}", folder.Name, folder.ID, folder.ParentID); - - m_Database.moveInventoryFolder(folder); - - // FIXME: Should return false on failure - return true; - } - - // See IInventoryServices - public virtual bool AddItem(InventoryItemBase item) - { -// m_log.DebugFormat( -// "[INVENTORY SERVICE]: Adding item {0} {1} to folder {2} for {3}", -// item.Name, item.ID, item.Folder, item.Owner); - - m_Database.addInventoryItem(item); - - // FIXME: Should return false on failure - return true; - } - - // See IInventoryServices - public virtual bool UpdateItem(InventoryItemBase item) - { - m_log.InfoFormat( - "[INVENTORY SERVICE]: Updating item {0} {1} in folder {2}", item.Name, item.ID, item.Folder); - - m_Database.updateInventoryItem(item); - - // FIXME: Should return false on failure - return true; - } - - public virtual bool MoveItems(UUID ownerID, List items) - { - m_log.InfoFormat( - "[INVENTORY SERVICE]: Moving {0} items from user {1}", items.Count, ownerID); - - InventoryItemBase itm = null; - foreach (InventoryItemBase item in items) - { - itm = GetInventoryItem(item.ID); - itm.Folder = item.Folder; - if ((item.Name != null) && !item.Name.Equals(string.Empty)) - itm.Name = item.Name; - m_Database.updateInventoryItem(itm); - } - - return true; - } - - // See IInventoryServices - public virtual bool DeleteItems(UUID owner, List itemIDs) - { - m_log.InfoFormat( - "[INVENTORY SERVICE]: Deleting {0} items from user {1}", itemIDs.Count, owner); - - // uhh..... - foreach (UUID uuid in itemIDs) - m_Database.deleteInventoryItem(uuid); - - // FIXME: Should return false on failure - return true; - } - - public virtual InventoryItemBase GetItem(InventoryItemBase item) - { - InventoryItemBase result = m_Database.getInventoryItem(item.ID); - if (result != null) - return result; - m_log.DebugFormat("[INVENTORY SERVICE]: GetItem failed to find item {0}", item.ID); - return null; - } - - public virtual InventoryFolderBase GetFolder(InventoryFolderBase folder) - { - InventoryFolderBase result = m_Database.getInventoryFolder(folder.ID); - if (result != null) - return result; - - m_log.DebugFormat("[INVENTORY SERVICE]: GetFolder failed to find folder {0}", folder.ID); - return null; - } - - public virtual bool DeleteFolders(UUID ownerID, List folderIDs) - { - m_log.InfoFormat("[INVENTORY SERVICE]: Deleting {0} folders from user {1}", folderIDs.Count, ownerID); - foreach (UUID id in folderIDs) - { - InventoryFolderBase folder = new InventoryFolderBase(id, ownerID); - PurgeFolder(folder); - m_Database.deleteInventoryFolder(id); - } - return true; - } - - /// - /// Purge a folder of all items items and subfolders. - /// - /// FIXME: Really nasty in a sense, because we have to query the database to get information we may - /// already know... Needs heavy refactoring. - /// - /// - public virtual bool PurgeFolder(InventoryFolderBase folder) - { - m_log.DebugFormat( - "[INVENTORY SERVICE]: Purging folder {0} {1} of its contents", folder.Name, folder.ID); - - List subFolders = RequestSubFolders(folder.ID); - - foreach (InventoryFolderBase subFolder in subFolders) - { -// m_log.DebugFormat("[INVENTORY SERVICE]: Deleting folder {0} {1}", subFolder.Name, subFolder.ID); - - m_Database.deleteInventoryFolder(subFolder.ID); - } - - List items = GetFolderItems(folder.Owner, folder.ID); - - List uuids = new List(); - foreach (InventoryItemBase item in items) - { - uuids.Add(item.ID); - } - DeleteItems(folder.Owner, uuids); - - // FIXME: Should return false on failure - return true; - } - - private void AddNewInventorySet(UsersInventory inventory) - { - foreach (InventoryFolderBase folder in inventory.Folders.Values) - { - AddFolder(folder); - } - } - - public InventoryItemBase GetInventoryItem(UUID itemID) - { - InventoryItemBase item = m_Database.getInventoryItem(itemID); - if (item != null) - return item; - - return null; - } - - public int GetAssetPermissions(UUID userID, UUID assetID) - { - InventoryFolderBase parent = GetRootFolder(userID); - return FindAssetPerms(parent, assetID); - } - - private int FindAssetPerms(InventoryFolderBase folder, UUID assetID) - { - InventoryCollection contents = GetFolderContent(folder.Owner, folder.ID); - - int perms = 0; - foreach (InventoryItemBase item in contents.Items) - { - if (item.AssetID == assetID) - perms = (int)item.CurrentPermissions | perms; - } - - foreach (InventoryFolderBase subfolder in contents.Folders) - perms = perms | FindAssetPerms(subfolder, assetID); - - return perms; - } - - /// - /// Used to create a new user inventory. - /// - private class UsersInventory - { - public Dictionary Folders = new Dictionary(); - public Dictionary Items = new Dictionary(); - - public virtual void CreateNewInventorySet(UUID user) - { - InventoryFolderBase folder = new InventoryFolderBase(); - - folder.ParentID = UUID.Zero; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "My Inventory"; - folder.Type = (short)AssetType.Folder; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - UUID rootFolder = folder.ID; - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Animations"; - folder.Type = (short)AssetType.Animation; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Body Parts"; - folder.Type = (short)AssetType.Bodypart; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Calling Cards"; - folder.Type = (short)AssetType.CallingCard; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Clothing"; - folder.Type = (short)AssetType.Clothing; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Gestures"; - folder.Type = (short)AssetType.Gesture; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Landmarks"; - folder.Type = (short)AssetType.Landmark; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Lost And Found"; - folder.Type = (short)AssetType.LostAndFoundFolder; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Notecards"; - folder.Type = (short)AssetType.Notecard; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Objects"; - folder.Type = (short)AssetType.Object; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Photo Album"; - folder.Type = (short)AssetType.SnapshotFolder; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Scripts"; - folder.Type = (short)AssetType.LSLText; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Sounds"; - folder.Type = (short)AssetType.Sound; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Textures"; - folder.Type = (short)AssetType.Texture; - folder.Version = 1; - Folders.Add(folder.ID, folder); - - folder = new InventoryFolderBase(); - folder.ParentID = rootFolder; - folder.Owner = user; - folder.ID = UUID.Random(); - folder.Name = "Trash"; - folder.Type = (short)AssetType.TrashFolder; - folder.Version = 1; - Folders.Add(folder.ID, folder); - } - } - } -} diff --git a/OpenSim/Services/InventoryService/InventoryServiceBase.cs b/OpenSim/Services/InventoryService/InventoryServiceBase.cs deleted file mode 100644 index 456e4557db..0000000000 --- a/OpenSim/Services/InventoryService/InventoryServiceBase.cs +++ /dev/null @@ -1,82 +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.Reflection; -using Nini.Config; -using OpenSim.Framework; -using OpenSim.Data; -using OpenSim.Services.Interfaces; -using OpenSim.Services.Base; - -namespace OpenSim.Services.InventoryService -{ - public class InventoryServiceBase : ServiceBase - { - protected IInventoryDataPlugin m_Database = null; - - public InventoryServiceBase(IConfigSource config) : base(config) - { - string dllName = String.Empty; - string connString = String.Empty; - - // - // Try reading the [DatabaseService] section first, if it exists - // - IConfig dbConfig = config.Configs["DatabaseService"]; - if (dbConfig != null) - { - dllName = dbConfig.GetString("StorageProvider", String.Empty); - connString = dbConfig.GetString("ConnectionString", String.Empty); - } - - // - // Try reading the more specific [InventoryService] section, if it exists - // - IConfig inventoryConfig = config.Configs["InventoryService"]; - if (inventoryConfig != null) - { - dllName = inventoryConfig.GetString("StorageProvider", dllName); - connString = inventoryConfig.GetString("ConnectionString", connString); - } - - // - // We tried, but this doesn't exist. We can't proceed. - // - if (dllName.Equals(String.Empty)) - throw new Exception("No InventoryService configuration"); - - m_Database = LoadPlugin(dllName); - if (m_Database == null) - throw new Exception("Could not find a storage interface in the given module"); - - m_Database.Initialise(connString); - } - - } -}