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

OpenSim/Framework/Monitoring/Checks/Check.cs

@@ -0,0 +1,118 @@
+/*
+ * 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.Text;
+
+namespace OpenSim.Framework.Monitoring
+{
+    public class Check
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public static readonly char[] DisallowedShortNameCharacters = { '.' };
+
+        /// <summary>
+        /// Category of this stat (e.g. cache, scene, etc).
+        /// </summary>
+        public string Category { get; private set; }
+
+        /// <summary>
+        /// 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).
+        /// </summary>
+        /// <value>
+        /// The container.
+        /// </value>
+        public string Container { get; private set; }
+
+        /// <summary>
+        /// Action used to check whether alert should go off.
+        /// </summary>
+        /// <remarks>
+        /// Should return true if check passes.  False otherwise.
+        /// </remarks>
+        public Func<Check, bool> CheckFunc { get; private set; }
+
+        /// <summary>
+        /// Message from the last failure, if any.  If there is no message or no failure then will be null.
+        /// </summary>
+        /// <remarks>
+        /// Should be set by the CheckFunc when applicable.
+        /// </remarks>
+        public string LastFailureMessage { get; 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 Check(
+            string shortName,
+            string name,
+            string description,
+            string category,
+            string container,
+            Func<Check, bool> checkFunc,
+            StatVerbosity verbosity) 
+        {
+            if (ChecksManager.SubCommands.Contains(category))
+                throw new Exception(
+                    string.Format("Alert cannot be in category '{0}' since this is reserved for a subcommand", category));
+
+            foreach (char c in DisallowedShortNameCharacters)
+            {
+                if (shortName.IndexOf(c) != -1)
+                    throw new Exception(string.Format("Alert name {0} cannot contain character {1}", shortName, c));
+            }
+
+            ShortName = shortName;
+            Name = name;
+            Description = description;
+            Category = category;
+            Container = container;
+            CheckFunc = checkFunc;
+            Verbosity = verbosity;
+        }
+
+        public bool CheckIt()
+        {
+            return CheckFunc(this);
+        }
+
+        public virtual string ToConsoleString()
+        {
+            return string.Format(
+                "{0}.{1}.{2} - {3}", 
+                Category, 
+                Container, 
+                ShortName,
+                Description);
+        }
+    }
+}

OpenSim/Framework/Monitoring/ChecksManager.cs

@@ -0,0 +1,262 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using log4net;
+
+namespace OpenSim.Framework.Monitoring
+{
+    /// <summary>
+    /// Static class used to register/deregister checks on runtime conditions.
+    /// </summary>
+    public static class ChecksManager
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        // Subcommand used to list other stats.
+        public const string ListSubCommand = "list";
+
+        // All subcommands
+        public static HashSet<string> SubCommands = new HashSet<string> { ListSubCommand };
+
+        /// <summary>
+        /// Checks categorized by category/container/shortname
+        /// </summary>
+        /// <remarks>
+        /// Do not add or remove directly from this dictionary.
+        /// </remarks>
+        public static SortedDictionary<string, SortedDictionary<string, SortedDictionary<string, Check>>> RegisteredChecks
+            = new SortedDictionary<string, SortedDictionary<string, SortedDictionary<string, Check>>>();
+
+        public static void RegisterConsoleCommands(ICommandConsole console)
+        {
+            console.Commands.AddCommand(
+                "General",
+                false,
+                "show checks",
+                "show checks",
+                "Show checks configured for this server",
+                "If no argument is specified then info on all checks will be shown.\n"
+                    + "'list' argument will show check categories.\n"
+                    + "THIS FACILITY IS EXPERIMENTAL",
+                HandleShowchecksCommand);
+        }
+
+        public static void HandleShowchecksCommand(string module, string[] cmd)
+        {
+            ICommandConsole con = MainConsole.Instance;
+
+            if (cmd.Length > 2)
+            {
+                foreach (string name in cmd.Skip(2))
+                {
+                    string[] components = name.Split('.');
+
+                    string categoryName = components[0];
+//                    string containerName = components.Length > 1 ? components[1] : null;
+
+                    if (categoryName == ListSubCommand)
+                    {
+                        con.Output("check categories available are:");
+
+                        foreach (string category in RegisteredChecks.Keys)
+                            con.OutputFormat("  {0}", category);
+                    }
+//                    else
+//                    {
+//                        SortedDictionary<string, SortedDictionary<string, Check>> category;
+//                        if (!Registeredchecks.TryGetValue(categoryName, out category))
+//                        {
+//                            con.OutputFormat("No such category as {0}", categoryName);
+//                        }
+//                        else
+//                        {
+//                            if (String.IsNullOrEmpty(containerName))
+//                            {
+//                                OutputConfiguredToConsole(con, category);
+//                            }
+//                            else
+//                            {
+//                                SortedDictionary<string, Check> container;
+//                                if (category.TryGetValue(containerName, out container))
+//                                {
+//                                    OutputContainerChecksToConsole(con, container);
+//                                }
+//                                else
+//                                {
+//                                    con.OutputFormat("No such container {0} in category {1}", containerName, categoryName);
+//                                }
+//                            }
+//                        }
+//                    }
+                }
+            }
+            else
+            {
+                OutputAllChecksToConsole(con);
+            }
+        }
+
+        /// <summary>
+        /// Registers a statistic.
+        /// </summary>
+        /// <param name='stat'></param>
+        /// <returns></returns>
+        public static bool RegisterCheck(Check check)
+        {
+            SortedDictionary<string, SortedDictionary<string, Check>> category = null, newCategory;
+            SortedDictionary<string, Check> container = null, newContainer;
+
+            lock (RegisteredChecks)
+            {
+                // Check name is not unique across category/container/shortname key.
+                // XXX: For now just return false.  This is to avoid problems in regression tests where all tests
+                // in a class are run in the same instance of the VM.
+                if (TryGetCheckParents(check, out category, out container))
+                    return false;
+
+                // We take a copy-on-write approach here of replacing dictionaries when keys are added or removed.
+                // This means that we don't need to lock or copy them on iteration, which will be a much more
+                // common operation after startup.
+                if (container != null)
+                    newContainer = new SortedDictionary<string, Check>(container);
+                else
+                    newContainer = new SortedDictionary<string, Check>();
+
+                if (category != null)
+                    newCategory = new SortedDictionary<string, SortedDictionary<string, Check>>(category);
+                else
+                    newCategory = new SortedDictionary<string, SortedDictionary<string, Check>>();
+
+                newContainer[check.ShortName] = check;
+                newCategory[check.Container] = newContainer;
+                RegisteredChecks[check.Category] = newCategory;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Deregister an check
+        /// </summary>>
+        /// <param name='stat'></param>
+        /// <returns></returns>
+        public static bool DeregisterCheck(Check check)
+        {
+            SortedDictionary<string, SortedDictionary<string, Check>> category = null, newCategory;
+            SortedDictionary<string, Check> container = null, newContainer;
+
+            lock (RegisteredChecks)
+            {
+                if (!TryGetCheckParents(check, out category, out container))
+                    return false;
+
+                newContainer = new SortedDictionary<string, Check>(container);
+                newContainer.Remove(check.ShortName);
+
+                newCategory = new SortedDictionary<string, SortedDictionary<string, Check>>(category);
+                newCategory.Remove(check.Container);
+
+                newCategory[check.Container] = newContainer;
+                RegisteredChecks[check.Category] = newCategory;
+
+                return true;
+            }
+        }
+
+        public static bool TryGetCheckParents(
+            Check check,
+            out SortedDictionary<string, SortedDictionary<string, Check>> category,
+            out SortedDictionary<string, Check> container)
+        {
+            category = null;
+            container = null;
+
+            lock (RegisteredChecks)
+            {
+                if (RegisteredChecks.TryGetValue(check.Category, out category))
+                {
+                    if (category.TryGetValue(check.Container, out container))
+                    {
+                        if (container.ContainsKey(check.ShortName))
+                            return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        public static void CheckChecks()
+        {
+            lock (RegisteredChecks)
+            {
+                foreach (SortedDictionary<string, SortedDictionary<string, Check>> category in RegisteredChecks.Values)
+                {
+                    foreach (SortedDictionary<string, Check> container in category.Values)
+                    {
+                        foreach (Check check in container.Values)
+                        {
+                            if (!check.CheckIt())
+                                m_log.WarnFormat(
+                                    "[CHECKS MANAGER]: Check {0}.{1}.{2} failed with message {3}", check.Category, check.Container, check.ShortName, check.LastFailureMessage);
+                        }
+                    }
+                }
+            }
+        }
+
+        private static void OutputAllChecksToConsole(ICommandConsole con)
+        {
+            foreach (var category in RegisteredChecks.Values)
+            {
+                OutputCategoryChecksToConsole(con, category);
+            }
+        }
+
+        private static void OutputCategoryChecksToConsole(
+            ICommandConsole con, SortedDictionary<string, SortedDictionary<string, Check>> category)
+        {
+            foreach (var container in category.Values)
+            {
+                OutputContainerChecksToConsole(con, container);
+            }
+        }
+
+        private static void OutputContainerChecksToConsole(ICommandConsole con, SortedDictionary<string, Check> container)
+        {
+            foreach (Check check in container.Values)
+            {
+                con.Output(check.ToConsoleString());
+            }
+        }
+    }
+}

OpenSim/Framework/Monitoring/StatsManager.cs

@@ -35,9 +35,9 @@ using OpenMetaverse.StructuredData;
 namespace OpenSim.Framework.Monitoring
 {
     /// <summary>
-    /// Singleton used to provide access to statistics reporters
+    /// Static class used to register/deregister/fetch statistics
     /// </summary>
-    public class StatsManager
+    public static class StatsManager
     {
         // Subcommand used to list other stats.
         public const string AllSubCommand = "all";
@@ -257,7 +257,7 @@ namespace OpenSim.Framework.Monitoring
 //        }
 
         /// <summary>
-        /// Registers a statistic.
+        /// Register a statistic.
         /// </summary>
         /// <param name='stat'></param>
         /// <returns></returns>

OpenSim/Framework/Monitoring/Watchdog.cs

@@ -380,6 +380,7 @@ namespace OpenSim.Framework.Monitoring
             if (MemoryWatchdog.Enabled)
                 MemoryWatchdog.Update();
 
+            ChecksManager.CheckChecks();
             StatsManager.RecordStats();
 
             m_watchdogTimer.Start();

OpenSim/Framework/Servers/ServerBase.cs

@@ -272,6 +272,7 @@ namespace OpenSim.Framework.Servers
                 "shutdown",
                 "Quit the application", (mod, args) => Shutdown());
 
+            ChecksManager.RegisterConsoleCommands(m_console);
             StatsManager.RegisterConsoleCommands(m_console);
         }
 

OpenSim/Region/Application/Application.cs

@@ -103,26 +103,38 @@ namespace OpenSim
                 "[OPENSIM MAIN]: Environment variable MONO_THREADS_PER_CPU is {0}", monoThreadsPerCpu ?? "unset");
 
             // Verify the Threadpool allocates or uses enough worker and IO completion threads
-			// .NET 2.0 workerthreads default to 50 *  numcores
+			// .NET 2.0, workerthreads default to 50 *  numcores
-			// .NET 3.0 workerthreads defaults to 250 * numcores
+			// .NET 3.0, workerthreads defaults to 250 * numcores
-			// .NET 4.0 workerthreads are dynamic based on bitness and OS resources
+			// .NET 4.0, workerthreads are dynamic based on bitness and OS resources
-			// Max IO Completion threads are 1000 on all 3 CLRs.
+            // Max IO Completion threads are 1000 on all 3 CLRs
+            //
+            // Mono 2.10.9 to at least Mono 3.1, workerthreads default to 100 * numcores, iocp threads to 4 * numcores
 			int workerThreadsMin = 500;
 			int workerThreadsMax = 1000; // may need further adjustment to match other CLR
 			int iocpThreadsMin = 1000;
 			int iocpThreadsMax = 2000; // may need further adjustment to match other CLR
+
+            {
+                int currentMinWorkerThreads, currentMinIocpThreads;
+                System.Threading.ThreadPool.GetMinThreads(out currentMinWorkerThreads, out currentMinIocpThreads);
+                m_log.InfoFormat(
+                    "[OPENSIM MAIN]: Runtime gave us {0} min worker threads and {1} min IOCP threads", 
+                    currentMinWorkerThreads, currentMinIocpThreads);
+            }
+
             int workerThreads, iocpThreads;
             System.Threading.ThreadPool.GetMaxThreads(out workerThreads, out iocpThreads);
-            m_log.InfoFormat("[OPENSIM MAIN]: Runtime gave us {0} worker threads and {1} IOCP threads", workerThreads, iocpThreads);
+            m_log.InfoFormat("[OPENSIM MAIN]: Runtime gave us {0} max worker threads and {1} max IOCP threads", workerThreads, iocpThreads);
+
             if (workerThreads < workerThreadsMin)
             {
                 workerThreads = workerThreadsMin;
-                m_log.InfoFormat("[OPENSIM MAIN]: Bumping up to worker threads to {0}",workerThreads);
+                m_log.InfoFormat("[OPENSIM MAIN]: Bumping up to max worker threads to {0}",workerThreads);
             }
             if (workerThreads > workerThreadsMax)
             {
                 workerThreads = workerThreadsMax;
-                m_log.InfoFormat("[OPENSIM MAIN]: Limiting worker threads to {0}",workerThreads);
+                m_log.InfoFormat("[OPENSIM MAIN]: Limiting max worker threads to {0}",workerThreads);
             }
 
 			// Increase the number of IOCP threads available.
@@ -130,22 +142,24 @@ namespace OpenSim
 			if (iocpThreads < iocpThreadsMin)
             {
                 iocpThreads = iocpThreadsMin;
-                m_log.InfoFormat("[OPENSIM MAIN]: Bumping up IO completion threads to {0}",iocpThreads);
+                m_log.InfoFormat("[OPENSIM MAIN]: Bumping up max IO completion threads to {0}",iocpThreads);
             }
 			// Make sure we don't overallocate IOCP threads and thrash system resources
             if ( iocpThreads > iocpThreadsMax )
             {
                 iocpThreads = iocpThreadsMax;
-                m_log.InfoFormat("[OPENSIM MAIN]: Limiting IO completion threads to {0}",iocpThreads);
+                m_log.InfoFormat("[OPENSIM MAIN]: Limiting max IO completion threads to {0}",iocpThreads);
             }
 			// set the resulting worker and IO completion thread counts back to ThreadPool
             if ( System.Threading.ThreadPool.SetMaxThreads(workerThreads, iocpThreads) )
 			{
-	            m_log.InfoFormat("[OPENSIM MAIN]: Threadpool set to {0} worker threads and {1} IO completion threads", workerThreads, iocpThreads);
+	            m_log.InfoFormat(
+                    "[OPENSIM MAIN]: Threadpool set to {0} max worker threads and {1} max IO completion threads",
+                    workerThreads, iocpThreads);
 			}
 			else
 			{
-	            m_log.Info("[OPENSIM MAIN]: Threadpool reconfiguration failed, runtime defaults still in effect.");				
+	            m_log.Warn("[OPENSIM MAIN]: Threadpool reconfiguration failed, runtime defaults still in effect.");				
 			}
 
             // Check if the system is compatible with OpenSimulator.
@@ -153,17 +167,16 @@ namespace OpenSim
             string supported = String.Empty;
             if (Util.IsEnvironmentSupported(ref supported))
             {
-                m_log.Info("Environment is compatible.\n");
+                m_log.Info("[OPENSIM MAIN]: Environment is supported by OpenSimulator.");
             }
             else
             {
-                m_log.Warn("Environment is unsupported (" + supported + ")\n");
+                m_log.Warn("[OPENSIM MAIN]: Environment is not supported by OpenSimulator (" + supported + ")\n");
             }
 
             // Configure nIni aliases and localles
             Culture.SetCurrentCulture();
 
-
             // Validate that the user has the most basic configuration done
             // If not, offer to do the most basic configuration for them warning them along the way of the importance of 
             // reading these files.

OpenSim/Region/CoreModules/Scripting/ScriptModuleComms/ScriptModuleCommsModule.cs

@@ -163,7 +163,7 @@ namespace OpenSim.Region.CoreModules.Scripting.ScriptModuleComms
 
         public void RegisterScriptInvocation(object target, MethodInfo mi)
         {
-            m_log.DebugFormat("[MODULE COMMANDS] Register method {0} from type {1}", mi.Name, (target is Type) ? ((Type)target).Name : target.GetType().Name);
+//            m_log.DebugFormat("[MODULE COMMANDS] Register method {0} from type {1}", mi.Name, (target is Type) ? ((Type)target).Name : target.GetType().Name);
 
             Type delegateType;
             List<Type> typeArgs = mi.GetParameters()
@@ -323,7 +323,7 @@ namespace OpenSim.Region.CoreModules.Scripting.ScriptModuleComms
         /// </summary>
         public void RegisterConstant(string cname, object value)
         {
-            m_log.DebugFormat("[MODULE COMMANDS] register constant <{0}> with value {1}",cname,value.ToString());
+//            m_log.DebugFormat("[MODULE COMMANDS] register constant <{0}> with value {1}",cname,value.ToString());
             lock (m_constants)
             {
                 m_constants.Add(cname,value);

OpenSim/Services/Connectors/SimianGrid/SimianExternalCapsModule.cs

@@ -79,7 +79,11 @@ namespace OpenSim.Services.Connectors.SimianGrid
                     {
                         m_simianURL = m_config.GetString("SimianServiceURL");
                         if (String.IsNullOrEmpty(m_simianURL))
-                            m_log.ErrorFormat("[SimianGrid] service URL is not defined");
+                        {
+                            //m_log.DebugFormat("[SimianGrid] service URL is not defined");
+                            m_enabled = false;
+                            return;
+                        }
                     }
                 }
                 else

OpenSim/Services/Connectors/SimianGrid/SimianGrid.cs

@@ -74,11 +74,15 @@ namespace OpenSim.Services.Connectors.SimianGrid
                 {
                     m_simianURL = m_config.GetString("SimianServiceURL");
                     if (String.IsNullOrEmpty(m_simianURL))
-                        m_log.ErrorFormat("[SimianGrid] service URL is not defined");
+                    {
+                        // m_log.DebugFormat("[SimianGrid] service URL is not defined");
+                        m_enabled = false;
+                        return;
+                    }
                     
                     InitialiseSimCap();
                     SimulatorCapability = SimulatorCapability.Trim();
-                    m_log.WarnFormat("[SimianExternalCaps] using {0} as simulator capability",SimulatorCapability);
+                    m_log.InfoFormat("[SimianExternalCaps] using {0} as simulator capability",SimulatorCapability);
                 }
             }
             catch (Exception e)

OpenSim/Tests/Clients/Assets/AssetsClient.cs

@@ -68,8 +68,18 @@ namespace OpenSim.Tests.Clients.AssetsClient
             m_log.InfoFormat("[ASSET CLIENT]: Connecting to {0} max threads = {1} - {2}", serverURI, max1, max2);
             ThreadPool.GetMinThreads(out max1, out max2);
             m_log.InfoFormat("[ASSET CLIENT]: Connecting to {0} min threads = {1} - {2}", serverURI, max1, max2);
-            ThreadPool.SetMinThreads(1, 1);
+
-            ThreadPool.SetMaxThreads(10, 3);
+            if (!ThreadPool.SetMinThreads(1, 1))
+                m_log.WarnFormat("[ASSET CLIENT]: Failed to set min threads");
+
+            if (!ThreadPool.SetMaxThreads(10, 3))
+                m_log.WarnFormat("[ASSET CLIENT]: Failed to set max threads");
+
+            ThreadPool.GetMaxThreads(out max1, out max2);
+            m_log.InfoFormat("[ASSET CLIENT]: Post set max threads = {1} - {2}", serverURI, max1, max2);
+            ThreadPool.GetMinThreads(out max1, out max2);
+            m_log.InfoFormat("[ASSET CLIENT]: Post set min threads = {1} - {2}", serverURI, max1, max2);
+
             ServicePointManager.DefaultConnectionLimit = 12;
 
             AssetServicesConnector m_Connector = new AssetServicesConnector(serverURI);