Merge branch 'v8/dev' into v8/contrib

Author: nul800sebastiaan

src/SolutionInfo.cs

@@ -18,5 +18,5 @@
 [assembly: AssemblyVersion("8.0.0")]
 
 // these are FYI and changed automatically
-[assembly: AssemblyFileVersion("8.12.1")]
-[assembly: AssemblyInformationalVersion("8.12.1")]
+[assembly: AssemblyFileVersion("8.12.2")]
+[assembly: AssemblyInformationalVersion("8.12.2")]

src/Umbraco.Core/ConfigsExtensions.cs

@@ -1,10 +1,10 @@
 using System.IO;
 using Umbraco.Core.Cache;
-using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Configuration.Grid;
 using Umbraco.Core.Configuration.HealthChecks;
 using Umbraco.Core.Configuration.UmbracoSettings;
+using Umbraco.Core.Dashboards;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Manifest;
@@ -48,6 +48,8 @@ public static void AddCoreConfigs(this Configs configs)
                 configDir,
                 factory.GetInstance<ManifestParser>(),
                 factory.GetInstance<IRuntimeState>().Debug));
+
+            configs.Add<IContentDashboardSettings>(() => new ContentDashboardSettings());
         }
     }
 }

src/Umbraco.Core/Configuration/GlobalSettings.cs

@@ -395,7 +395,6 @@ public bool UseHttps
             }
         }
 
-
         /// <summary>
         /// An int value representing the time in milliseconds to lock the database for a write operation
         /// </summary>

src/Umbraco.Core/Constants-AppSettings.cs

@@ -110,6 +110,11 @@ public static class AppSettings
             /// </summary>
             public const string UseHttps = "Umbraco.Core.UseHttps";
 
+            /// <summary>
+            /// A true/false value indicating whether the content dashboard should be visible for all user groups.
+            /// </summary>
+            public const string AllowContentDashboardAccessToAllUsers = "Umbraco.Core.AllowContentDashboardAccessToAllUsers";
+
             /// <summary>
             /// TODO: FILL ME IN
             /// </summary>

src/Umbraco.Core/Dashboards/ContentDashboardSettings.cs

@@ -0,0 +1,24 @@
+using System.Configuration;
+
+namespace Umbraco.Core.Dashboards
+{
+    public class ContentDashboardSettings: IContentDashboardSettings
+    {
+
+        /// <summary>
+        /// Gets a value indicating whether the content dashboard should be available to all users.
+        /// </summary>
+        /// <value>
+        ///     <c>true</c> if the dashboard is visible for all user groups; otherwise, <c>false</c>
+        ///     and the default access rules for that dashboard will be in use.
+        /// </value>
+        public bool AllowContentDashboardAccessToAllUsers
+        {
+            get
+            {
+                bool.TryParse(ConfigurationManager.AppSettings[Constants.AppSettings.AllowContentDashboardAccessToAllUsers], out var value);
+                return value;
+            }
+        }
+    }
+}

src/Umbraco.Core/Dashboards/IContentDashboardSettings.cs

@@ -0,0 +1,14 @@
+namespace Umbraco.Core.Dashboards
+{
+    public interface IContentDashboardSettings
+    {
+        /// <summary>
+        /// Gets a value indicating whether the content dashboard should be available to all users.
+        /// </summary>
+        /// <value>
+        ///     <c>true</c> if the dashboard is visible for all user groups; otherwise, <c>false</c>
+        ///     and the default access rules for that dashboard will be in use.
+        /// </value>
+        bool AllowContentDashboardAccessToAllUsers { get; }
+    }
+}

src/Umbraco.Core/Runtime/MainDom.cs

@@ -179,7 +179,14 @@ private bool Acquire()
                 _listenTask = _mainDomLock.ListenAsync();
                 _listenCompleteTask = _listenTask.ContinueWith(t =>
                 {
-                    _logger.Debug<MainDom>("Listening task completed with {TaskStatus}", _listenTask.Status);
+                    if (_listenTask.Exception != null)
+                    {
+                        _logger.Warn<MainDom>("Listening task completed with {TaskStatus}, Exception: {Exception}", _listenTask.Status, _listenTask.Exception);
+                    }
+                    else
+                    {
+                        _logger.Debug<MainDom>("Listening task completed with {TaskStatus}", _listenTask.Status);
+                    }
 
                     OnSignal("signal");
                 }, TaskScheduler.Default); // Must explicitly specify this, see https://blog.stephencleary.com/2013/10/continuewith-is-dangerous-too.html

src/Umbraco.Core/Runtime/SqlMainDomLock.cs

@@ -86,7 +86,7 @@ public async Task<bool> AcquireLockAsync(int millisecondsTimeout)
                     // wait to get a write lock
                     _sqlServerSyntax.WriteLock(db, TimeSpan.FromMilliseconds(millisecondsTimeout), Constants.Locks.MainDom);
                 }
-                catch(SqlException ex)
+                catch (SqlException ex)
                 {
                     if (IsLockTimeoutException(ex))
                     {
@@ -126,7 +126,7 @@ public async Task<bool> AcquireLockAsync(int millisecondsTimeout)
             }
 
 
-            return await WaitForExistingAsync(tempId, millisecondsTimeout);
+            return await WaitForExistingAsync(tempId, millisecondsTimeout).ConfigureAwait(false);
         }
 
         public Task ListenAsync()
@@ -139,13 +139,15 @@ public Task ListenAsync()
 
             // Create a long running task (dedicated thread)
             // to poll to check if we are still the MainDom registered in the DB
-            return Task.Factory.StartNew(
-                ListeningLoop,
-                _cancellationTokenSource.Token,
-                TaskCreationOptions.LongRunning,
-                // Must explicitly specify this, see https://blog.stephencleary.com/2013/10/continuewith-is-dangerous-too.html
-                TaskScheduler.Default);
-
+            using (ExecutionContext.SuppressFlow())
+            {
+                return Task.Factory.StartNew(
+                    ListeningLoop,
+                    _cancellationTokenSource.Token,
+                    TaskCreationOptions.LongRunning,
+                    // Must explicitly specify this, see https://blog.stephencleary.com/2013/10/continuewith-is-dangerous-too.html
+                    TaskScheduler.Default);
+            }
         }
 
         /// <summary>
@@ -227,11 +229,29 @@ private void ListeningLoop()
                     }
                     finally
                     {
-                        db?.CompleteTransaction();
-                        db?.Dispose();
+                        // Even if any of the above fail like BeginTransaction, or even a query after the
+                        // Transaction is started, the calls below will not throw. I've tried all sorts of
+                        // combinations to see if I can make this throw but I can't. In any case, we'll be
+                        // extra safe and try/catch/log
+                        try
+                        {
+                            db?.CompleteTransaction();
+                        }
+                        catch (Exception ex)
+                        {
+                            _logger.Error<SqlMainDomLock>(ex, "Unexpected error completing transaction.");
+                        }
+
+                        try
+                        {
+                            db?.Dispose();
+                        }
+                        catch (Exception ex)
+                        {
+                            _logger.Error<SqlMainDomLock>(ex, "Unexpected error completing disposing.");
+                        }
                     }
                 }
-
             }
         }
 
@@ -245,37 +265,40 @@ private Task<bool> WaitForExistingAsync(string tempId, int millisecondsTimeout)
         {
             var updatedTempId = tempId + UpdatedSuffix;
 
-            return Task.Run(() =>
+            using (ExecutionContext.SuppressFlow())
             {
-                try
+                return Task.Run(() =>
                 {
-                    using var db = _dbFactory.CreateDatabase();
-
-                    var watch = new Stopwatch();
-                    watch.Start();
-                    while (true)
+                    try
                     {
-                        // poll very often, we need to take over as fast as we can
-                        // local testing shows the actual query to be executed from client/server is approx 300ms but would change depending on environment/IO
-                        Thread.Sleep(1000);
-
-                        var acquired = TryAcquire(db, tempId, updatedTempId);
-                        if (acquired.HasValue)
-                            return acquired.Value;
+                        using var db = _dbFactory.CreateDatabase();
 
-                        if (watch.ElapsedMilliseconds >= millisecondsTimeout)
+                        var watch = new Stopwatch();
+                        watch.Start();
+                        while (true)
                         {
-                            return AcquireWhenMaxWaitTimeElapsed(db);
+                            // poll very often, we need to take over as fast as we can
+                            // local testing shows the actual query to be executed from client/server is approx 300ms but would change depending on environment/IO
+                            Thread.Sleep(1000);
+
+                            var acquired = TryAcquire(db, tempId, updatedTempId);
+                            if (acquired.HasValue)
+                                return acquired.Value;
+
+                            if (watch.ElapsedMilliseconds >= millisecondsTimeout)
+                            {
+                                return AcquireWhenMaxWaitTimeElapsed(db);
+                            }
                         }
                     }
-                }
-                catch (Exception ex)
-                {
-                    _logger.Error<SqlMainDomLock>(ex, "An error occurred trying to acquire and waiting for existing SqlMainDomLock to shutdown");
-                    return false;
-                }
+                    catch (Exception ex)
+                    {
+                        _logger.Error<SqlMainDomLock>(ex, "An error occurred trying to acquire and waiting for existing SqlMainDomLock to shutdown");
+                        return false;
+                    }
 
-            }, _cancellationTokenSource.Token);
+                }, _cancellationTokenSource.Token);
+            }
         }
 
         private bool? TryAcquire(IUmbracoDatabase db, string tempId, string updatedTempId)