Use delete_files from core when deleting a Realm.

Realm/Realm/Exceptions/RealmException.cs

@@ -145,6 +145,9 @@ internal static Exception Create(RealmExceptionCodes exceptionCode, string messa
 
                     return new SessionException(message, code);
 
+                case RealmExceptionCodes.RealmInUseException:
+                    return new RealmInUseException(message);
+
                 default:
                     return new Exception(message);
             }

Realm/Realm/Exceptions/RealmExceptionCodes.cs

@@ -44,6 +44,7 @@ internal enum RealmExceptionCodes : sbyte
         RealmClosed = 24,
         ObjectManagedByAnotherRealm = 25,
         KeyAlreadyExists = 26,
+        RealmInUseException = 27,
 
         RealmDotNetExceptionDuringMigration = 30,
 

Realm/Realm/Exceptions/RealmInUseException.cs

@@ -0,0 +1,31 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2021 Realm Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////
+
+namespace Realms.Exceptions
+{
+    /// <summary>
+    /// An exception thrown when an an operation is being performed on an open Realm
+    /// that can only performed on a closed Realm (e.g. deleting Realm files).
+    /// </summary>
+    public class RealmInUseException : RealmException
+    {
+        internal RealmInUseException(string message) : base(message)
+        {
+        }
+    }
+}

Realm/Realm/Handles/SharedRealmHandle.cs

@@ -94,6 +94,9 @@ public static extern IntPtr open_with_sync_async(Configuration configuration, Sy
             [DllImport(InteropConfig.DLL_NAME, EntryPoint = "shared_realm_close_realm", CallingConvention = CallingConvention.Cdecl)]
             public static extern void close_realm(SharedRealmHandle sharedRealm, out NativeException ex);
 
+            [DllImport(InteropConfig.DLL_NAME, EntryPoint = "shared_realm_delete_files", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+            public static extern void delete_files([MarshalAs(UnmanagedType.LPWStr)] string path, IntPtr path_len, out NativeException ex);
+
             [DllImport(InteropConfig.DLL_NAME, EntryPoint = "shared_realm_close_all_realms", CallingConvention = CallingConvention.Cdecl)]
             public static extern void close_all_realms(out NativeException ex);
 
@@ -263,6 +266,12 @@ public void CloseRealm()
             nativeException.ThrowIfNecessary();
         }
 
+        public static void DeleteFiles(string path)
+        {
+            NativeMethods.delete_files(path, (IntPtr)path.Length, out var nativeException);
+            nativeException.ThrowIfNecessary();
+        }
+
         public static void CloseAllRealms()
         {
             NativeMethods.close_all_realms(out var nativeException);

Realm/Realm/Realm.cs

@@ -169,32 +169,19 @@ public static bool Compact(RealmConfigurationBase config = null)
         }
 
         /// <summary>
-        /// Deletes all the files associated with a realm.
+        /// Deletes all files associated with a given Realm if the Realm exists and is not open.
         /// </summary>
+        /// <remarks>
+        /// The Realm file must not be open on other threads.<br/>
+        /// All but the .lock file will be deleted by this.
+        /// </remarks>
         /// <param name="configuration">A <see cref="RealmConfigurationBase"/> which supplies the realm path.</param>
+        /// <exception cref="RealmInUseException">Thrown if the Realm is still open.</exception>
         public static void DeleteRealm(RealmConfigurationBase configuration)
         {
             Argument.NotNull(configuration, nameof(configuration));
 
-            var fullpath = configuration.DatabasePath;
-            if (IsRealmOpen(fullpath))
-            {
-                throw new RealmPermissionDeniedException("Unable to delete Realm because it is still open.");
-            }
-
-            var filesToDelete = new[] { string.Empty, ".log_a", ".log_b", ".log", ".lock", ".note" }
-                .Select(ext => fullpath + ext)
-                .Where(File.Exists);
-
-            foreach (var file in filesToDelete)
-            {
-                File.Delete(file);
-            }
-
-            if (Directory.Exists($"{fullpath}.management"))
-            {
-                Directory.Delete($"{fullpath}.management", recursive: true);
-            }
+            SharedRealmHandle.DeleteFiles(configuration.DatabasePath);
         }
 
         private static bool IsRealmOpen(string path)

Tests/Realm.Tests/Database/InstanceTests.cs

@@ -76,6 +76,34 @@ public void DeleteRealmWorksIfClosed()
             Assert.That(File.Exists(config.DatabasePath), Is.False);
         }
 
+        [Test]
+        public void DeleteRealmWorksIfCalledMultipleTimes()
+        {
+            // Arrange
+            var config = RealmConfiguration.DefaultConfiguration;
+            var openRealm = GetRealm(config);
+
+            // Act
+            openRealm.Dispose();
+
+            // Assert
+            Assert.That(File.Exists(config.DatabasePath));
+            Assert.DoesNotThrow(() => Realm.DeleteRealm(config));
+            Assert.That(File.Exists(config.DatabasePath), Is.False);
+            Assert.DoesNotThrow(() => Realm.DeleteRealm(config));
+        }
+
+        [Test]
+        public void DeleteRealmWorksIfFolderDoesntExist()
+        {
+            var config = RealmConfiguration.DefaultConfiguration;
+            var dbFolder = Path.GetDirectoryName(config.DatabasePath);
+            var nonExistingRealm = Path.Combine(dbFolder, "idontexist", "my.realm");
+            var newConfig = new RealmConfiguration(nonExistingRealm);
+
+            Assert.DoesNotThrow(() => Realm.DeleteRealm(newConfig));
+        }
+
         [Test]
         public void GetUniqueInstancesDifferentThreads()
         {
@@ -141,7 +169,7 @@ public void DeleteRealmFailsIfOpenSameThread()
             using var openRealm = GetRealm();
 
             // Assert
-            Assert.Throws<RealmPermissionDeniedException>(() => Realm.DeleteRealm(RealmConfiguration.DefaultConfiguration));
+            Assert.Throws<RealmInUseException>(() => Realm.DeleteRealm(RealmConfiguration.DefaultConfiguration));
         }
 
         [Test]

Tests/Realm.Tests/RealmTest.cs

@@ -29,7 +29,7 @@ namespace Realms.Tests
     [Preserve(AllMembers = true)]
     public abstract class RealmTest
     {
-        private readonly List<Realm> _realms = new List<Realm>();
+        private readonly Queue<Realm> _realms = new Queue<Realm>();
         private Logger _originalLogger;
         private LogLevel _originalLogLevel;
 
@@ -69,7 +69,7 @@ protected virtual void CustomSetUp()
 
         protected void CleanupOnTearDown(Realm realm)
         {
-            _realms.Add(realm);
+            _realms.Enqueue(realm);
         }
 
         [TearDown]
@@ -100,15 +100,15 @@ protected virtual void CustomTearDown()
                 realm.Dispose();
             }
 
-            foreach (var realm in _realms)
+            _realms.DrainQueue(realm =>
             {
                 // TODO: this should be an assertion but fails on our migration tests due to https://github.com/realm/realm-core/issues/4605.
                 // Assert.That(DeleteRealmWithRetries(realm), Is.True, "Couldn't delete a Realm on teardown.");
                 DeleteRealmWithRetries(realm);
-            }
+            });
         }
 
-        private static bool DeleteRealmWithRetries(Realm realm)
+        protected static bool DeleteRealmWithRetries(Realm realm)
         {
             for (var i = 0; i < 100; i++)
             {

Tests/Realm.Tests/Sync/FunctionsTests.cs

@@ -28,7 +28,7 @@ namespace Realms.Tests.Sync
     [TestFixture, Preserve(AllMembers = true)]
     public class FunctionsTests : SyncTestBase
     {
-        private readonly List<string> _conventionsToRemove = new List<string>();
+        private readonly Queue<string> _conventionsToRemove = new Queue<string>();
 
         [Test]
         public void CallFunction_ReturnsResult()
@@ -490,12 +490,7 @@ protected override void CustomTearDown()
         {
             base.CustomTearDown();
 
-            foreach (var convention in _conventionsToRemove)
-            {
-                ConventionRegistry.Remove(convention);
-            }
-
-            _conventionsToRemove.Clear();
+            _conventionsToRemove.DrainQueue(ConventionRegistry.Remove);
         }
 
         private static void AssertDateTimeEquals(DateTime first, DateTime second)
@@ -518,7 +513,7 @@ private void AddCamelCaseConvention()
             pack.Add(new CamelCaseElementNameConvention());
             ConventionRegistry.Register(name, pack, _ => true);
 
-            _conventionsToRemove.Add(name);
+            _conventionsToRemove.Enqueue(name);
         }
 
         private class FunctionArgument

Tests/Realm.Tests/Sync/SyncTestBase.cs

@@ -27,8 +27,8 @@ namespace Realms.Tests.Sync
     [Preserve(AllMembers = true)]
     public abstract class SyncTestBase : RealmTest
     {
-        private readonly List<Session> _sessions = new List<Session>();
-        private readonly List<App> _apps = new List<App>();
+        private readonly Queue<Session> _sessions = new Queue<Session>();
+        private readonly Queue<App> _apps = new Queue<App>();
 
         private App _defaultApp;
 
@@ -45,7 +45,7 @@ protected App CreateApp(AppConfiguration config = null)
             config ??= SyncTestHelpers.GetAppConfig();
 
             var app = App.Create(config);
-            _apps.Add(app);
+            _apps.Enqueue(app);
 
             if (_defaultApp == null)
             {
@@ -57,24 +57,18 @@ protected App CreateApp(AppConfiguration config = null)
 
         protected override void CustomTearDown()
         {
-            foreach (var session in _sessions)
-            {
-                session?.CloseHandle();
-            }
+            _sessions.DrainQueue(session => session?.CloseHandle());
 
             base.CustomTearDown();
 
-            foreach (var app in _apps)
-            {
-                app.Handle.ResetForTesting();
-            }
+            _apps.DrainQueue(app => app.Handle.ResetForTesting());
 
             _defaultApp = null;
         }
 
         protected void CleanupOnTearDown(Session session)
         {
-            _sessions.Add(session);
+            _sessions.Enqueue(session);
         }
 
         protected Session GetSession(Realm realm)

Tests/Realm.Tests/Sync/SynchronizedInstanceTests.cs

@@ -320,6 +320,41 @@ public void EmbeddedObject_WhenAdditiveExplicit_ShouldThrow()
             Assert.Throws<RealmSchemaValidationException>(() => Realm.GetInstance(conf), $"Embedded object {nameof(EmbeddedLevel3)} is unreachable by any link path from top level objects");
         }
 
+        [Test]
+        public void DeleteRealmWorksIfCalledMultipleTimes()
+        {
+            var config = GetFakeConfig();
+            var openRealm = GetRealm(config);
+            openRealm.Dispose();
+            Assert.That(File.Exists(config.DatabasePath));
+
+            Assert.That(() => DeleteRealmWithRetries(openRealm), Is.True);
+            Assert.That(() => DeleteRealmWithRetries(openRealm), Is.True);
+        }
+
+        [Test]
+        public void DeleteRealm_afterSessionDisposed([Values(true, false)] bool singleTransaction)
+        {
+            SyncTestHelpers.RunBaasTestAsync(async () =>
+            {
+                var partition = Guid.NewGuid().ToString();
+
+                var config = await GetIntegrationConfigAsync(partition);
+                var asyncConfig = await GetIntegrationConfigAsync(partition);
+
+                using var realm = GetRealm(config);
+                AddDummyData(realm, singleTransaction);
+
+                await WaitForUploadAsync(realm);
+                realm.Dispose();
+
+                DeleteRealmWithRetries(realm);
+
+                using var asyncRealm = await GetRealmAsync(asyncConfig);
+                Assert.That(asyncRealm.All<ObjectIdPrimaryKeyWithValueObject>().Count(), Is.EqualTo(DummyDataSize / 2));
+            }, timeout: 120000);
+        }
+
         private const int DummyDataSize = 100;
 
         private static void AddDummyData(Realm realm, bool singleTransaction)

Tests/Realm.Tests/TestHelpers.cs

@@ -22,6 +22,7 @@
 #if NETCOREAPP || NETFRAMEWORK
 using System.Runtime.InteropServices;
 #endif
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using MongoDB.Bson;
 using Nito.AsyncEx;
@@ -377,6 +378,14 @@ public static string ByteArrayToTestDescription<T>(T arr)
             return $"<{byteArr[0]}>";
         }
 
+        public static void DrainQueue<T>(this Queue<T> queue, Action<T> action)
+        {
+            while (queue.Count > 0)
+            {
+                action(queue.Dequeue());
+            }
+        }
+
         public static IDisposable Subscribe<T>(this IObservable<T> observable, Action<T> onNext)
         {
             var observer = new FunctionObserver<T>(onNext);

wrappers/src/error_handling.cpp

@@ -149,6 +149,9 @@ namespace realm {
 
             return { RealmErrorType::AppUnknownError, e.message };
         }
+        catch (const DeleteOnOpenRealmException& e) {
+            return { RealmErrorType::RealmInUseException, e.what() };
+        }
         catch (const std::bad_alloc& e) {
             return { RealmErrorType::RealmOutOfMemory, e.what() };
         }

wrappers/src/realm_error_type.hpp

@@ -77,6 +77,8 @@ namespace realm {
         ObjectManagedByAnotherRealm = 25,
 
         KeyAlreadyExists = 26,
+
+        RealmInUseException = 27,
 
         RealmDotNetExceptionDuringMigration = 30,
 

wrappers/src/shared_realm_cs.cpp

@@ -284,6 +284,14 @@ REALM_EXPORT void shared_realm_close_realm(SharedRealm& realm, NativeException::
     });
 }
 
+REALM_EXPORT void shared_realm_delete_files(uint16_t* path_buf, size_t path_len, NativeException::Marshallable& ex)
+{
+    handle_errors(ex, [&]() {
+        Utf16StringAccessor path_string(path_buf, path_len);
+        Realm::delete_files(path_string);
+    });
+}
+
 REALM_EXPORT void shared_realm_close_all_realms(NativeException::Marshallable& ex)
 {
     s_can_call_managed = false;