Horizon – Diff between revs 3 and 5

Subversion Repositories:

?pathlinks?

Rev 3 – Rev 10 – Go to most recent revision – Details – Blame – Last modification – View Log

 using System.Drawing;
 using System.Drawing.Imaging;
 using System.Globalization;
 using System.IO;
 using System.IO.Compression;
+using System.Runtime.CompilerServices;
 using System.Security.Cryptography;
 using System.Threading;
 using System.Threading.Tasks;
 using Horizon.Snapshots;
 using Horizon.Utilities;
         #endregion
         #region Private Delegates, Events, Enums, Properties, Indexers and Fields
-        private readonly CancellationTokenSource _cancellationTokenSource;
         private readonly CancellationTokenSource _cancellationTokenSource;
-        private SemaphoreSlim _snapshotSemaphore;
+        private readonly SemaphoreSlim _databaseLock;
         #endregion
-        #region Constructors, Destructors and Finalizers
+        #region Constructors, Destructors and Finalizers
+        private SnapshotDatabase()
+        {
+            Directory.CreateDirectory(Constants.DatabaseDirectory);
-        public SnapshotDatabase()
+            _databaseLock = new SemaphoreSlim(1, 1);
+        }
+        public SnapshotDatabase(CancellationToken cancellationToken) : this()
+        {
             _cancellationTokenSource = new CancellationTokenSource();
-            _cancellationTokenSource = new CancellationTokenSource();
+            var localCancellationToken = _cancellationTokenSource.Token;
-            _cancellationToken = _cancellationTokenSource.Token;
+            var combinedCancellationTokenSource =
                 CancellationTokenSource.CreateLinkedTokenSource(localCancellationToken, cancellationToken);
+        }
         public void Dispose()
+        {
-            _cancellationTokenSource.Cancel();
-            _snapshotSemaphore?.Dispose();
-            _snapshotSemaphore = null;
+            _cancellationTokenSource.Cancel();
+        }
             var connectionString = new SQLiteConnectionStringBuilder
+            {
                 ConnectionString = DatabaseConnectionString
             };
+            await _databaseLock.WaitAsync(cancellationToken);
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+            try
-            {
-                await sqliteConnection.OpenAsync(cancellationToken);
+            {
-                using (var dbTransaction = sqliteConnection.BeginTransaction())
+                using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
                 {
-                    // Insert the file change.
+                    await sqliteConnection.OpenAsync(cancellationToken);
-                    using (var sqliteCommand =
-                           new SQLiteCommand(RemoveScreenshotFromHashSql, sqliteConnection, dbTransaction))
+                    using (var dbTransaction = sqliteConnection.BeginTransaction())
+                    {
-                    {
+                        // Insert the file change.
+                        using (var sqliteCommand =
-                        try
+                               new SQLiteCommand(RemoveScreenshotFromHashSql, sqliteConnection, dbTransaction))
+                        {
                             sqliteCommand.Parameters.AddRange(new[]
+                            {
                                 new SQLiteParameter("@hash", hash)
                             });
+                            sqliteCommand.Prepare();
-                            sqliteCommand.Prepare();
+                            try
+                            {
-                            await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
+                                await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
-                            dbTransaction.Commit();
+                                dbTransaction.Commit();
-                        }
+                            }
+                            catch
                         catch
                                 dbTransaction.Rollback();
                             dbTransaction.Rollback();
                                 throw;
+                            }
+                        }
+                    }
+                }
                             throw;
             finally
+            {
                 _databaseLock.Release();
+            }
+        }
         public async Task NormalizeTime(string hash, CancellationToken cancellationToken)
         {
             var connectionString = new SQLiteConnectionStringBuilder
             {
-                ConnectionString = DatabaseConnectionString
-            };
+                ConnectionString = DatabaseConnectionString
             };
-            using (var sqliteConnection =
+            await _databaseLock.WaitAsync(cancellationToken);
+            try
                    new SQLiteConnection(connectionString.ConnectionString))
+                using (var sqliteConnection =
+                       new SQLiteConnection(connectionString.ConnectionString))
-            {
+                {
-                await sqliteConnection.OpenAsync(cancellationToken);
+                    await sqliteConnection.OpenAsync(cancellationToken);
-                using (var readSQLiteCommand = new SQLiteCommand(RetrieveTimeFromHash, sqliteConnection))
+                    using (var readSQLiteCommand = new SQLiteCommand(RetrieveTimeFromHash, sqliteConnection))
-                {
-                    readSQLiteCommand.Parameters.AddRange(new[]
+                    {
-                        new SQLiteParameter("@hash", hash)
+                        readSQLiteCommand.Parameters.AddRange(new[]
                     });
+                            new SQLiteParameter("@hash", hash)
-                    readSQLiteCommand.Prepare();
+                        });
-                    using (var sqlDataReader = await readSQLiteCommand.ExecuteReaderAsync(cancellationToken))
-                    {
-                        using (var dbTransaction = sqliteConnection.BeginTransaction())
-                        {
-                            try
-                            {
-                                while (await sqlDataReader.ReadAsync(cancellationToken))
+                        readSQLiteCommand.Prepare();
-                                {
-                                    var time = (string)sqlDataReader["Time"];
+                        using (var sqlDataReader = await readSQLiteCommand.ExecuteReaderAsync(cancellationToken))
+                        {
+                            using (var dbTransaction = sqliteConnection.BeginTransaction())
+                            {
+                                try
-                                    // Skip if already ISO 8601
+                                {
-                                    if (DateTime.TryParseExact(time,
+                                    while (await sqlDataReader.ReadAsync(cancellationToken))
-                                            "yyyy-MM-ddTHH:mm:ss.fff",
+                                    {
-                                            CultureInfo.InvariantCulture,
-                                            DateTimeStyles.None, out _))
-                                    {
-                                        continue;
+                                        var time = (string)sqlDataReader["Time"];
-                                    if (!DateTime.TryParse(time, out var dateTime))
+                                        // Skip if already ISO 8601
-                                    {
+                                        if (DateTime.TryParseExact(time,
+                                                "yyyy-MM-ddTHH:mm:ss.fff",
+                                                CultureInfo.InvariantCulture,
+                                                DateTimeStyles.None, out _))
-                                        dateTime = DateTime.Now;
+                                        {
+                                            continue;
+                                        }
+                                        if (!DateTime.TryParse(time, out var dateTime))
+                                        {
+                                            dateTime = DateTime.Now;
+                                        }
-                                    }
+                                        using (var writeSQLiteCommand =
                                                new SQLiteCommand(UpdateTimeFromHash, sqliteConnection, dbTransaction))
-                                    using (var writeSQLiteCommand =
-                                           new SQLiteCommand(UpdateTimeFromHash, sqliteConnection, dbTransaction))
+                                        {
-                                    {
+                                            writeSQLiteCommand.Parameters.AddRange(new[]
-                                        writeSQLiteCommand.Parameters.AddRange(new[]
+                                            {
-                                        {
+                                                new SQLiteParameter("@time",
-                                            new SQLiteParameter("@time", dateTime.ToString("yyyy-MM-ddTHH:mm:ss.fff")),
+                                                    dateTime.ToString("yyyy-MM-ddTHH:mm:ss.fff")),
-                                            new SQLiteParameter("@hash", hash)
+                                                new SQLiteParameter("@hash", hash)
+                                            });
                                         });
                                             writeSQLiteCommand.Prepare();
                                         writeSQLiteCommand.Prepare();
                                             await writeSQLiteCommand.ExecuteNonQueryAsync(cancellationToken);
                                         await writeSQLiteCommand.ExecuteNonQueryAsync(cancellationToken);
+                                    }
+                                    dbTransaction.Commit();
+                                }
                                 catch
+                                {
                                     dbTransaction.Rollback();
                                 dbTransaction.Commit();
                                     throw;
                             catch
+                            }
-                                dbTransaction.Rollback();
+                        }
+                    }
+                }
-                                throw;
-                            }
-                        }
-                    }
+            }
             finally
-            }
-        }
+            {
+                _databaseLock.Release();
-        public async Task<long> CountSnapshots(CancellationToken cancellationToken)
+            }
+        }
+        public async Task<long> CountSnapshots(CancellationToken cancellationToken)
+        {
+            var connectionString = new SQLiteConnectionStringBuilder
-            var connectionString = new SQLiteConnectionStringBuilder
+            {
                 ConnectionString = DatabaseConnectionString
-                ConnectionString = DatabaseConnectionString
+            };
             };
+            await _databaseLock.WaitAsync(cancellationToken);
+            try
+            {
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                {
+                    await sqliteConnection.OpenAsync(cancellationToken);
                     // Insert the file change.
-                await sqliteConnection.OpenAsync(cancellationToken);
+                    using (var sqliteCommand = new SQLiteCommand(CountSnapshotsSql, sqliteConnection))
+                    {
-                // Insert the file change.
-                using (var sqliteCommand = new SQLiteCommand(CountSnapshotsSql, sqliteConnection))
                         long count = 0;
                     long count = 0;
                         sqliteCommand.Prepare();
+                        using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
+                        {
+                            while (await sqlDataReader.ReadAsync(cancellationToken))
                     sqliteCommand.Prepare();
+                                if (!(sqlDataReader[0] is long dbCount))
                     using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
                                     count = -1;
-                        while (await sqlDataReader.ReadAsync(cancellationToken))
+                                    break;
+                                }
                             if (!(sqlDataReader[0] is long dbCount))
-                            {
+                                count = dbCount;
-                                count = -1;
+                            }
                                 break;
-                            }
-                            count = dbCount;
+                            return count;
                         }
+                    }
-                        return count;
+                }
+            }
-                    }
+            finally
+            {
-            }
-        }
-        public async Task<IEnumerable<Snapshot>> LoadSnapshots(CancellationToken cancellationToken)
-        {
-            var connectionString = new SQLiteConnectionStringBuilder
-            {
-                ConnectionString = DatabaseConnectionString
-            };
+                _databaseLock.Release();
+            }
+        }
+        public async IAsyncEnumerable<Snapshot> LoadSnapshots([EnumeratorCancellation] CancellationToken cancellationToken)
             using (var sqliteConnection =
+            var connectionString = new SQLiteConnectionStringBuilder
+            {
+                ConnectionString = DatabaseConnectionString
-                   new SQLiteConnection(connectionString.ConnectionString))
+            };
-            {
+            await _databaseLock.WaitAsync(cancellationToken);
+            try
                 await sqliteConnection.OpenAsync(cancellationToken);
+                using (var sqliteConnection =
+                       new SQLiteConnection(connectionString.ConnectionString))
+                {
+                    await sqliteConnection.OpenAsync(cancellationToken);
-                // Insert the file change.
+                    // Insert the file change.
-                using (var sqliteCommand = new SQLiteCommand(RetrieveSnapshotsSql, sqliteConnection))
+                    using (var sqliteCommand = new SQLiteCommand(RetrieveSnapshotsSql, sqliteConnection))
-                {
+                    {
-                    sqliteCommand.Prepare();
+                        sqliteCommand.Prepare();
+                        using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
                     using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
-                    {
-                        var snapshots = new List<Snapshot>();
+                            //var snapshots = new List<Snapshot>();
+                            while (await sqlDataReader.ReadAsync(cancellationToken))
                         while (await sqlDataReader.ReadAsync(cancellationToken))
-                        {
-                            var name = (string)sqlDataReader["Name"];
-                            var path = (string)sqlDataReader["Path"];
+                                var name = (string)sqlDataReader["Name"];
-                            var time = (string)sqlDataReader["Time"];
+                                var path = (string)sqlDataReader["Path"];
-                            var hash = (string)sqlDataReader["Hash"];
+                                var time = (string)sqlDataReader["Time"];
+                                var hash = (string)sqlDataReader["Hash"];
+                                var color = Color.Empty;
                                 if (!(sqlDataReader["Color"] is DBNull))
                             var color = Color.Empty;
                                     var dbColor = Convert.ToInt32(sqlDataReader["Color"]);
-                            if (!(sqlDataReader["Color"] is DBNull))
-                            {
                                 var dbColor = Convert.ToInt32(sqlDataReader["Color"]);
                                     switch (dbColor)
                                 switch (dbColor)
                                         case 0:
-                                    case 0:
+                                            color = Color.Empty;
-                                        color = Color.Empty;
+                                            break;
-                                        break;
+                                        default:
-                                    default:
+                                            color = Color.FromArgb(dbColor);
-                                        color = Color.FromArgb(dbColor);
-                                        break;
+                                            break;
+                                    }
-                            }
+                                }
+                                yield return new Snapshot(name, path, time, hash, color);
+                            }
-                            snapshots.Add(new Snapshot(name, path, time, hash, color));
+                        }
+                    }
+                }
                         return snapshots;
-                    }
+            finally
-                }
-            }
-        }
+            {
+                _databaseLock.Release();
+            }
+        }
+        public async Task CreateSnapshot(string name, string path, Color color, CancellationToken cancellationToken)
-        public async Task CreateSnapshot(string name, string path, Color color, CancellationToken cancellationToken)
+        {
-        {
+            var connectionString = new SQLiteConnectionStringBuilder
-            await _snapshotSemaphore.WaitAsync(cancellationToken);
+            {
+                ConnectionString = DatabaseConnectionString
-            var connectionString = new SQLiteConnectionStringBuilder
+            };
-            {
-                ConnectionString = DatabaseConnectionString
+            await _databaseLock.WaitAsync(cancellationToken);
-            };
-            using (var sqliteConnection =
-                   new SQLiteConnection(connectionString.ConnectionString))
+            try
-            {
-                await sqliteConnection.OpenAsync(cancellationToken);
-                using (var dbTransaction = sqliteConnection.BeginTransaction())
-                {
-                    try
-                    {
-                        using (var md5 = MD5.Create())
-                        {
-                            using (var hashMemoryStream = new MemoryStream())
+            {
-                            {
+                using (var sqliteConnection =
-                                using (var fileStream =
-                                       await Miscellaneous.GetFileStream(path, FileMode.Open, FileAccess.Read,
+                       new SQLiteConnection(connectionString.ConnectionString))
+                {
+                    await sqliteConnection.OpenAsync(cancellationToken);
+                    using (var dbTransaction = sqliteConnection.BeginTransaction())
+                    {
+                        try
-                                           FileShare.Read,
+                        {
+                            using (var md5 = MD5.Create())
+                            {
+                                using (var hashMemoryStream = new MemoryStream())
+                                {
+                                    using (var fileStream =
-                                           cancellationToken))
+                                           await Miscellaneous.GetFileStream(path, FileMode.Open, FileAccess.Read,
+                                               FileShare.Read,
+                                               cancellationToken))
-                                {
+                                    {
-                                    fileStream.Position = 0L;
+                                        fileStream.Position = 0L;
-                                    await fileStream.CopyToAsync(hashMemoryStream);
+                                        await fileStream.CopyToAsync(hashMemoryStream);
-                                    hashMemoryStream.Position = 0L;
+                                        hashMemoryStream.Position = 0L;
-                                    var hash = md5.ComputeHash(hashMemoryStream);
+                                        var hash = md5.ComputeHash(hashMemoryStream);
-                                    var hashHex = BitConverter.ToString(hash).Replace("-", "")
+                                        var hashHex = BitConverter.ToString(hash).Replace("-", "")
-                                        .ToLowerInvariant();
+                                            .ToLowerInvariant();
-                                    using (var fileMemoryStream = new MemoryStream())
+                                        using (var fileMemoryStream = new MemoryStream())
-                                    {
+                                        {
-                                        using (var fileZipStream =
+                                            using (var fileZipStream =
-                                               new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
+                                                   new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
-                                        {
+                                            {
-                                            fileStream.Position = 0L;
+                                                fileStream.Position = 0L;
-                                            await fileStream.CopyToAsync(fileZipStream);
+                                                await fileStream.CopyToAsync(fileZipStream);
-                                            fileZipStream.Close();
+                                                fileZipStream.Close();
-                                            var time = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss.fff");
+                                                var time = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss.fff");
-                                            fileMemoryStream.Position = 0L;
+                                                fileMemoryStream.Position = 0L;
-                                            // Insert the file change.
+                                                // Insert the file change.
-                                            using (var sqliteCommand =
+                                                using (var sqliteCommand =
-                                                   new SQLiteCommand(SnapshotFileNoScreenshotSql, sqliteConnection,
+                                                       new SQLiteCommand(SnapshotFileNoScreenshotSql, sqliteConnection,
-                                                       dbTransaction))
+                                                           dbTransaction))
-                                            {
+                                                {
-                                                sqliteCommand.Parameters.AddRange(new[]
+                                                    sqliteCommand.Parameters.AddRange(new[]
-                                                {
+                                                    {
-                                                    new SQLiteParameter("@name", name),
+                                                        new SQLiteParameter("@name", name),
-                                                    new SQLiteParameter("@time", time),
+                                                        new SQLiteParameter("@time", time),
-                                                    new SQLiteParameter("@path", path),
+                                                        new SQLiteParameter("@path", path),
+                                                        new SQLiteParameter("@dataLength",
-                                                    new SQLiteParameter("@dataLength",
+                                                            fileMemoryStream.Length),
-                                                        fileMemoryStream.Length),
+                                                        new SQLiteParameter("@hash", hashHex)
-                                                    new SQLiteParameter("@hash", hashHex)
+                                                    });
-                                                });
+                                                    var numeric = color.ToArgb();
+                                                    switch (numeric)
-                                                var numeric = color.ToArgb();
+                                                    {
+                                                        case 0:
-                                                switch (numeric)
+                                                            sqliteCommand.Parameters.Add(
-                                                {
-                                                    case 0:
+                                                                new SQLiteParameter("@color", null));
-                                                        sqliteCommand.Parameters.Add(
+                                                            break;
-                                                            new SQLiteParameter("@color", null));
+                                                        default:
-                                                        break;
+                                                            sqliteCommand.Parameters.Add(
+                                                                new SQLiteParameter("@color", numeric));
-                                                    default:
+                                                            break;
                                                         sqliteCommand.Parameters.Add(
                                                             new SQLiteParameter("@color", numeric));
-                                                        break;
+                                                    sqliteCommand.Prepare();
-                                                sqliteCommand.Prepare();
+                                                    await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
+                                                }
-                                                await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
-                                            }
+                                                // Insert the data blobs.
+                                                using (var sqliteCommand =
+                                                       new SQLiteCommand(GetLastRowInsertSql, sqliteConnection,
+                                                           dbTransaction))
+                                                {
+                                                    sqliteCommand.Prepare();
+                                                    var rowId =
+                                                        (long)await sqliteCommand.ExecuteScalarAsync(cancellationToken);
+                                                    using (var sqliteBlob =
+                                                           SQLiteBlob.Create(sqliteConnection, "main", "Snapshots",
-                                            // Insert the data blobs.
+                                                               "Data",
-                                            using (var sqliteCommand =
+                                                               rowId,
-                                                   new SQLiteCommand(GetLastRowInsertSql, sqliteConnection,
-                                                       dbTransaction))
-                                            {
-                                                sqliteCommand.Prepare();
-                                                var rowId =
-                                                    (long)await sqliteCommand.ExecuteScalarAsync(cancellationToken);
-                                                using (var sqliteBlob =
-                                                       SQLiteBlob.Create(sqliteConnection, "main", "Snapshots", "Data",
+                                                               false))
-                                                           rowId,
+                                                    {
-                                                           false))
-                                                {
-                                                    var fileMemoryStreamData = fileMemoryStream.ToArray();
                                                         var fileMemoryStreamData = fileMemoryStream.ToArray();
                                                     sqliteBlob.Write(fileMemoryStreamData, fileMemoryStreamData.Length,
-);
+                                                        sqliteBlob.Write(fileMemoryStreamData,
+                                                            fileMemoryStreamData.Length,
+);
+                                                    }
+                                                }
                                                 dbTransaction.Commit();
-                                            dbTransaction.Commit();
+                                                SnapshotCreate?.Invoke(this,
-                                            SnapshotCreate?.Invoke(this,
-                                                new SnapshotCreateSuccessEventArgs(name, time, path, color,
+                                                    new SnapshotCreateSuccessEventArgs(name, time, path, color,
-                                                    hashHex));
+                                                        hashHex));
+                                            }
+                                        }
-                                }
+                                    }
-                            }
+                                }
+                            }
-                    }
+                        }
-                    catch (SQLiteException exception)
-                    {
+                        catch (SQLiteException exception)
                         dbTransaction.Rollback();
+                            dbTransaction.Rollback();
+                            if (exception.ResultCode != SQLiteErrorCode.Constraint)
                         if (exception.ResultCode != SQLiteErrorCode.Constraint)
-                        {
+                                SnapshotCreate?.Invoke(this,
-                            SnapshotCreate?.Invoke(this,
+                                    new SnapshotCreateFailureEventArgs(name, path, color, exception));
-                                new SnapshotCreateFailureEventArgs(name, path, color, exception));
+                            }
+                            throw;
-                        throw;
-                    }
-                    catch (Exception exception)
+                        }
+                        catch (Exception exception)
+                        {
+                            dbTransaction.Rollback();
+                            SnapshotCreate?.Invoke(this,
-                        dbTransaction.Rollback();
+                                new SnapshotCreateFailureEventArgs(name, path, color, exception));
-                        SnapshotCreate?.Invoke(this, new SnapshotCreateFailureEventArgs(name, path, color, exception));
+                            throw;
+                        }
-                        throw;
+                    }
-                    }
+                }
-                    finally
+            }
-                    {
-                        _snapshotSemaphore.Release();
-                    }
             finally
-            }
-        }
+            {
-        public async Task CreateSnapshot(string name, string path,
-                                         Bitmap shot, Color color, CancellationToken cancellationToken)
+                _databaseLock.Release();
+            }
-            await _snapshotSemaphore.WaitAsync(cancellationToken);
-            var connectionString = new SQLiteConnectionStringBuilder
+        }
-            {
-                ConnectionString = DatabaseConnectionString
-            };
+        public async Task CreateSnapshot(string name, string path,
+                                         Bitmap shot, Color color, CancellationToken cancellationToken)
+        {
+            var connectionString = new SQLiteConnectionStringBuilder
+            {
+                ConnectionString = DatabaseConnectionString
+            };
+            await _databaseLock.WaitAsync(cancellationToken);
-            using (var sqliteConnection =
-                   new SQLiteConnection(connectionString.ConnectionString))
+            try
-            {
-                await sqliteConnection.OpenAsync(cancellationToken);
-                using (var dbTransaction = sqliteConnection.BeginTransaction())
+            {
-                {
-                    try
-                    {
-                        using (var md5 = MD5.Create())
-                        {
-                            using (var hashMemoryStream = new MemoryStream())
-                            {
-                                using (var fileStream =
+                using (var sqliteConnection =
-                                       await Miscellaneous.GetFileStream(path, FileMode.Open, FileAccess.Read,
-                                           FileShare.Read,
-                                           cancellationToken))
-                                {
-                                    fileStream.Position = 0L;
+                       new SQLiteConnection(connectionString.ConnectionString))
+                {
+                    await sqliteConnection.OpenAsync(cancellationToken);
-                                    await fileStream.CopyToAsync(hashMemoryStream);
                     using (var dbTransaction = sqliteConnection.BeginTransaction())
+                    {
-                                    hashMemoryStream.Position = 0L;
+                        try
-                                    var hash = md5.ComputeHash(hashMemoryStream);
+                        {
-                                    var hashHex = BitConverter.ToString(hash).Replace("-", "")
+                            using (var md5 = MD5.Create())
-                                        .ToLowerInvariant();
+                            {
+                                using (var hashMemoryStream = new MemoryStream())
-                                    using (var fileMemoryStream = new MemoryStream())
+                                {
-                                    {
+                                    using (var fileStream =
-                                        using (var fileZipStream =
+                                           await Miscellaneous.GetFileStream(path, FileMode.Open, FileAccess.Read,
+                                               FileShare.Read,
-                                               new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
+                                               cancellationToken))
+                                    {
+                                        fileStream.Position = 0L;
+                                        await fileStream.CopyToAsync(hashMemoryStream);
+                                        hashMemoryStream.Position = 0L;
+                                        var hash = md5.ComputeHash(hashMemoryStream);
-                                        {
+                                        var hashHex = BitConverter.ToString(hash).Replace("-", "")
+                                            .ToLowerInvariant();
+                                        using (var fileMemoryStream = new MemoryStream())
+                                        {
+                                            using (var fileZipStream =
-                                            fileStream.Position = 0L;
+                                                   new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
-                                            await fileStream.CopyToAsync(fileZipStream);
-                                            fileZipStream.Close();
-                                            using (var bitmapMemoryStream = new MemoryStream())
+                                            {
-                                            {
-                                                using (var bitmapZipStream =
+                                                fileStream.Position = 0L;
-                                                       new GZipStream(bitmapMemoryStream, CompressionMode.Compress,
-                                                           true))
-                                                {
-                                                    shot.Save(bitmapZipStream, ImageFormat.Bmp);
+                                                await fileStream.CopyToAsync(fileZipStream);
-                                                    bitmapZipStream.Close();
+                                                fileZipStream.Close();
-                                                    var time = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss.fff");
-                                                    fileMemoryStream.Position = 0L;
-                                                    bitmapMemoryStream.Position = 0L;
+                                                using (var bitmapMemoryStream = new MemoryStream())
+                                                {
-                                                    // Insert the file change.
+                                                    using (var bitmapZipStream =
-                                                    using (var sqliteCommand =
+                                                           new GZipStream(bitmapMemoryStream, CompressionMode.Compress,
-                                                           new SQLiteCommand(SnapshotFileSql, sqliteConnection,
+                                                               true))
-                                                               dbTransaction))
+                                                    {
-                                                    {
-                                                        sqliteCommand.Parameters.AddRange(new[]
+                                                        shot.Save(bitmapZipStream, ImageFormat.Bmp);
-                                                        {
+                                                        bitmapZipStream.Close();
-                                                            new SQLiteParameter("@name", name),
+                                                        var time = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss.fff");
-                                                            new SQLiteParameter("@time", time),
-                                                            new SQLiteParameter("@path", path),
+                                                        fileMemoryStream.Position = 0L;
-                                                            new SQLiteParameter("@shotLength",
+                                                        bitmapMemoryStream.Position = 0L;
-                                                                bitmapMemoryStream.Length),
+                                                        // Insert the file change.
+                                                        using (var sqliteCommand =
+                                                               new SQLiteCommand(SnapshotFileSql, sqliteConnection,
+                                                                   dbTransaction))
+                                                        {
+                                                            sqliteCommand.Parameters.AddRange(new[]
+                                                            {
+                                                                new SQLiteParameter("@name", name),
+                                                                new SQLiteParameter("@time", time),
+                                                                new SQLiteParameter("@path", path),
+                                                                new SQLiteParameter("@shotLength",
+                                                                    bitmapMemoryStream.Length),
+                                                                new SQLiteParameter("@dataLength",
+                                                                    fileMemoryStream.Length),
+                                                                new SQLiteParameter("@hash", hashHex)
-                                                            new SQLiteParameter("@dataLength",
+                                                            });
-                                                                fileMemoryStream.Length),
-                                                            new SQLiteParameter("@hash", hashHex)
+                                                            var numeric = color.ToArgb();
+                                                            switch (numeric)
                                                         });
-                                                        var numeric = color.ToArgb();
+                                                                case 0:
-                                                        switch (numeric)
+                                                                    sqliteCommand.Parameters.Add(
-                                                        {
+                                                                        new SQLiteParameter("@color", null));
-                                                            case 0:
+                                                                    break;
+                                                                default:
-                                                                sqliteCommand.Parameters.Add(
+                                                                    sqliteCommand.Parameters.Add(
-                                                                    new SQLiteParameter("@color", null));
+                                                                        new SQLiteParameter("@color", numeric));
-                                                                break;
+                                                                    break;
                                                             default:
                                                                 sqliteCommand.Parameters.Add(
-                                                                    new SQLiteParameter("@color", numeric));
+                                                            sqliteCommand.Prepare();
                                                                 break;
+                                                            await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
                                                         }
+                                                        // Insert the data blobs.
+                                                        using (var sqliteCommand =
-                                                        sqliteCommand.Prepare();
+                                                               new SQLiteCommand(GetLastRowInsertSql, sqliteConnection,
+                                                                   dbTransaction))
+                                                        {
+                                                            sqliteCommand.Prepare();
+                                                            var rowId =
-                                                        await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
+                                                                (long)await sqliteCommand.ExecuteScalarAsync(
                                                                     cancellationToken);
+                                                            using (var sqliteBlob =
                                                                    SQLiteBlob.Create(sqliteConnection, "main",
-                                                    // Insert the data blobs.
+                                                                       "Snapshots",
-                                                    using (var sqliteCommand =
-                                                           new SQLiteCommand(GetLastRowInsertSql, sqliteConnection,
-                                                               dbTransaction))
-                                                    {
-                                                        sqliteCommand.Prepare();
-                                                        var rowId =
-                                                            (long)await sqliteCommand.ExecuteScalarAsync(
-                                                                cancellationToken);
+                                                                       "Data",
-                                                        using (var sqliteBlob =
+                                                                       rowId,
-                                                               SQLiteBlob.Create(sqliteConnection, "main", "Snapshots",
-                                                                   "Data",
-                                                                   rowId,
-                                                                   false))
+                                                                       false))
+                                                            {
-                                                            var fileMemoryStreamData = fileMemoryStream.ToArray();
+                                                                var fileMemoryStreamData = fileMemoryStream.ToArray();
+                                                                sqliteBlob.Write(fileMemoryStreamData,
+                                                                    fileMemoryStreamData.Length,
+);
+                                                            }
                                                             sqliteBlob.Write(fileMemoryStreamData,
-                                                                fileMemoryStreamData.Length,
+                                                            using (var sqliteBlob =
-);
+                                                                   SQLiteBlob.Create(sqliteConnection, "main",
                                                                        "Snapshots",
                                                                        "Shot",
-                                                        using (var sqliteBlob =
+                                                                       rowId,
-                                                               SQLiteBlob.Create(sqliteConnection, "main", "Snapshots",
+                                                                       false))
+                                                            {
-                                                                   "Shot",
+                                                                var bitmapMemoryStreamData =
-                                                                   rowId,
+                                                                    bitmapMemoryStream.ToArray();
-                                                                   false))
-                                                        {
-                                                            var bitmapMemoryStreamData = bitmapMemoryStream.ToArray();
                                                             sqliteBlob.Write(bitmapMemoryStreamData,
-                                                                bitmapMemoryStreamData.Length,
+                                                                sqliteBlob.Write(bitmapMemoryStreamData,
-);
-                                                        }
-                                                    }
-                                                    dbTransaction.Commit();
+                                                                    bitmapMemoryStreamData.Length,
+);
+                                                            }
                                                     SnapshotCreate?.Invoke(this,
-                                                        new SnapshotCreateSuccessEventArgs(name, time, path, color,
-                                                            hashHex));
+                                                        dbTransaction.Commit();
-                                                }
-                                            }
+                                                        SnapshotCreate?.Invoke(this,
-                                        }
-                                    }
-                                }
+                                                            new SnapshotCreateSuccessEventArgs(name, time, path, color,
-                            }
+                                                                hashHex));
+                                                    }
-                        }
+                                                }
+                                            }
-                    catch (SQLiteException exception)
+                                        }
-                    {
-                        dbTransaction.Rollback();
+                                    }
+                                }
+                            }
                         if (exception.ResultCode != SQLiteErrorCode.Constraint)
-                        {
+                        catch (SQLiteException exception)
+                        {
-                            SnapshotCreate?.Invoke(this,
+                            dbTransaction.Rollback();
+                            if (exception.ResultCode != SQLiteErrorCode.Constraint)
+                            {
+                                SnapshotCreate?.Invoke(this,
+                                    new SnapshotCreateFailureEventArgs(name, path, color, exception));
                                 new SnapshotCreateFailureEventArgs(name, path, color, exception));
+                            throw;
+                        }
+                        catch (Exception exception)
-                        }
+                        {
+                            dbTransaction.Rollback();
-                        throw;
+                            SnapshotCreate?.Invoke(this,
                                 new SnapshotCreateFailureEventArgs(name, path, color, exception));
                     catch (Exception exception)
                             throw;
                         dbTransaction.Rollback();
+                    }
+                }
+            }
+            finally
+            {
-                        SnapshotCreate?.Invoke(this, new SnapshotCreateFailureEventArgs(name, path, color, exception));
+                _databaseLock.Release();
+            }
                         throw;
-                    }
-                    finally
-                        _snapshotSemaphore.Release();
+        public async Task SaveFile(string path, string hash, CancellationToken cancellationToken)
+        {
             var connectionString = new SQLiteConnectionStringBuilder
-            }
+            {
+                ConnectionString = DatabaseConnectionString
             };
-        public async Task SaveFile(string path, string hash, CancellationToken cancellationToken)
-        {
-            var connectionString = new SQLiteConnectionStringBuilder
-            {
-                ConnectionString = DatabaseConnectionString
+            await _databaseLock.WaitAsync(cancellationToken);
+            try
+            {
+                using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
-            };
+                {
+                    await sqliteConnection.OpenAsync(cancellationToken);
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                    // Insert the file change.
                     using (var sqliteCommand =
+                           new SQLiteCommand(RetrieveDataPathFromHashSql, sqliteConnection))
+                    {
-                await sqliteConnection.OpenAsync(cancellationToken);
+                        sqliteCommand.Parameters.AddRange(new[]
+                        {
-                // Insert the file change.
+                            new SQLiteParameter("@hash", hash)
-                using (var sqliteCommand =
+                        });
-                       new SQLiteCommand(RetrieveDataPathFromHashSql, sqliteConnection))
-                {
                     sqliteCommand.Parameters.AddRange(new[]
+                        sqliteCommand.Prepare();
-                    {
+                        using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
-                        new SQLiteParameter("@hash", hash)
+                        {
-                    });
+                            while (await sqlDataReader.ReadAsync(cancellationToken))
+                            {
-                    sqliteCommand.Prepare();
+                                // Create directories if they do not exist.
+                                var dir = Path.GetDirectoryName(path);
-                    using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
-                    {
+                                if (dir != null && !Directory.Exists(dir))
-                        while (await sqlDataReader.ReadAsync(cancellationToken))
+                                {
-                        {
+                                    Directory.CreateDirectory(dir);
-                            // Create directories if they do not exist.
+                                }
-                            var dir = Path.GetDirectoryName(path);
+                                using (var readStream = sqlDataReader.GetStream(2))
-                            if (dir != null && !Directory.Exists(dir))
+                                {
-                            {
-                                Directory.CreateDirectory(dir);
-                            }
-                            using (var readStream = sqlDataReader.GetStream(2))
+                                    using (var fileStream =
+                                           await Miscellaneous.GetFileStream(path, FileMode.Create, FileAccess.Write,
-                            {
+                                               FileShare.Write,
-                                using (var fileStream =
+                                               cancellationToken))
                                        await Miscellaneous.GetFileStream(path, FileMode.Create, FileAccess.Write,
+                                        readStream.Position = 0L;
+                                        using (var zipStream = new GZipStream(readStream, CompressionMode.Decompress))
-                                           FileShare.Write,
+                                        {
+                                            await zipStream.CopyToAsync(fileStream);
                                            cancellationToken))
+                                    }
-                                    readStream.Position = 0L;
-                                    using (var zipStream = new GZipStream(readStream, CompressionMode.Decompress))
-                                    {
-                                        await zipStream.CopyToAsync(fileStream);
-                                    }
-                                }
+                                }
+                            }
-                    }
+                        }
+                    }
-            }
+                }
+            }
+            finally
+            {
+                _databaseLock.Release();
+            }
+        }
+        public async Task RevertFile(string name, string hash, CancellationToken cancellationToken, bool atomic = true)
-        public async Task RevertFile(string name, string hash, CancellationToken cancellationToken, bool atomic = true)
+        {
-        {
+            var connectionString = new SQLiteConnectionStringBuilder
-            await _snapshotSemaphore.WaitAsync(cancellationToken);
+            {
+                ConnectionString = DatabaseConnectionString
-            var connectionString = new SQLiteConnectionStringBuilder
+            };
-            {
-                ConnectionString = DatabaseConnectionString
+            await _databaseLock.WaitAsync(cancellationToken);
-            };
+            try
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
-            {
-                await sqliteConnection.OpenAsync(cancellationToken);
-                // Insert the file change.
                 using (var sqliteCommand =
-                       new SQLiteCommand(RetrieveDataPathFromHashSql, sqliteConnection))
+                using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
-                {
+                {
+                    await sqliteConnection.OpenAsync(cancellationToken);
-                    try
-                    {
+                    // Insert the file change.
-                        sqliteCommand.Parameters.AddRange(new[]
+                    using (var sqliteCommand =
+                           new SQLiteCommand(RetrieveDataPathFromHashSql, sqliteConnection))
+                    {
+                        try
+                        {
+                            sqliteCommand.Parameters.AddRange(new[]
-                        {
+                            {
+                                new SQLiteParameter("@hash", hash)
-                            new SQLiteParameter("@hash", hash)
+                            });
                         });
-                        sqliteCommand.Prepare();
+                            sqliteCommand.Prepare();
-                        using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
+                            using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
+                            {
                                 while (await sqlDataReader.ReadAsync(cancellationToken))
                             while (await sqlDataReader.ReadAsync(cancellationToken))
-                            {
-                                var path = (string)sqlDataReader["Path"];
+                                    var path = (string)sqlDataReader["Path"];
-                                // Create directories if they do not exist.
+                                    // Create directories if they do not exist.
-                                var dir = Path.GetDirectoryName(path);
+                                    var dir = Path.GetDirectoryName(path);
-                                if (dir != null && !Directory.Exists(dir))
-                                {
-                                    Directory.CreateDirectory(dir);
                                     if (dir != null && !Directory.Exists(dir))
+                                    {
-                                switch (atomic)
+                                        Directory.CreateDirectory(dir);
+                                    }
+                                    switch (atomic)
+                                    {
                                         case true:
-                                    case true:
+                                            // Atomic
-                                        // Atomic
+                                            var temp = Path.Combine(Path.GetDirectoryName(path),
-                                        var temp = Path.Combine(Path.GetDirectoryName(path),
+                                                $"{Path.GetFileName(path)}.temp");
                                             $"{Path.GetFileName(path)}.temp");
                                             using (var readStream = sqlDataReader.GetStream(2))
                                         using (var readStream = sqlDataReader.GetStream(2))
-                                        {
+                                                using (var fileStream = new FileStream(temp, FileMode.Create,
+                                                           FileAccess.Write,
-                                            using (var fileStream = new FileStream(temp, FileMode.Create,
+                                                           FileShare.None))
-                                                       FileAccess.Write,
-                                                       FileShare.None))
-                                            {
+                                                {
-                                                using (var zipStream =
+                                                    using (var zipStream =
-                                                       new GZipStream(readStream, CompressionMode.Decompress))
-                                                {
-                                                    zipStream.CopyTo(fileStream);
+                                                           new GZipStream(readStream, CompressionMode.Decompress))
+                                                    {
+                                                        zipStream.CopyTo(fileStream);
-                                                }
+                                                    }
+                                                }
-                                        }
+                                            }
+                                            try
-                                        try
+                                            {
+                                                File.Replace(temp, path, null, true);
-                                            File.Replace(temp, path, null, true);
+                                            }
+                                            catch
+                                            {
+                                                try
+                                                {
-                                        catch
+                                                    File.Delete(temp);
-                                        {
+                                                }
-                                            try
+                                                catch (Exception exception)
-                                            {
+                                                {
-                                                File.Delete(temp);
+                                                    // Suppress deletion errors of temporary file.
+                                                    Log.Warning(exception, "Could not delete temporary file.", temp);
+                                                }
-                                            catch (Exception exception)
-                                            {
-                                                // Suppress deletion errors of temporary file.
+                                                throw;
-                                                Log.Warning(exception, "Could not delete temporary file.", temp);
+                                            }
-                                            }
+                                            break;
-                                            throw;
+                                        default:
-                                        }
+                                            // Asynchronous
+                                            using (var readStream = sqlDataReader.GetStream(2))
+                                            {
-                                        break;
+                                                using (var fileStream =
-                                    default:
+                                                       await Miscellaneous.GetFileStream(path, FileMode.Create,
+                                                           FileAccess.Write,
+                                                           FileShare.Write,
+                                                           cancellationToken))
+                                                {
-                                        // Asynchronous
+                                                    readStream.Position = 0L;
                                         using (var readStream = sqlDataReader.GetStream(2))
                                                     using (var zipStream =
-                                            using (var fileStream =
+                                                           new GZipStream(readStream, CompressionMode.Decompress))
                                                    await Miscellaneous.GetFileStream(path, FileMode.Create,
-                                                       FileAccess.Write,
+                                                        await zipStream.CopyToAsync(fileStream);
                                                        FileShare.Write,
-                                                       cancellationToken))
-                                            {
+                                                }
+                                            }
                                                 readStream.Position = 0L;
-                                                using (var zipStream =
-                                                       new GZipStream(readStream, CompressionMode.Decompress))
                                             break;
-                                                    await zipStream.CopyToAsync(fileStream);
+                                    }
-                                                }
-                                            }
+                                    SnapshotRevert?.Invoke(this, new SnapshotRevertSuccessEventArgs(name));
+                                }
+                            }
+                        }
+                        catch
+                        {
-                                        break;
+                            SnapshotRevert?.Invoke(this, new SnapshotRevertFailureEventArgs(name));
                             throw;
                                 SnapshotRevert?.Invoke(this, new SnapshotRevertSuccessEventArgs(name));
+                    }
+                }
+            }
-                        }
+            finally
-                    }
+            {
-                    catch
+                _databaseLock.Release();
-                    {
+            }
-                        SnapshotRevert?.Invoke(this, new SnapshotRevertFailureEventArgs(name));
+        }
-                        throw;
+        public async Task RemoveFileFast(IEnumerable<string> hashes, CancellationToken cancellationToken)
+        {
             var connectionString = new SQLiteConnectionStringBuilder
                     finally
                 ConnectionString = DatabaseConnectionString
-                        _snapshotSemaphore.Release();
+            };
+            await _databaseLock.WaitAsync(cancellationToken);
+            try
+            {
                 using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                {
                     await sqliteConnection.OpenAsync(cancellationToken);
                     using (var dbTransaction = sqliteConnection.BeginTransaction())
         public async Task RemoveFileFast(IEnumerable<string> hashes, CancellationToken cancellationToken)
                         try
-            var connectionString = new SQLiteConnectionStringBuilder
-            {
-                ConnectionString = DatabaseConnectionString
+                        {
+                            var transactionCommands = new List<Task>();
-            };
+                            foreach (var hash in hashes)
+                            {
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                                // Insert the file change.
-            {
+                                using (var sqliteCommand =
-                await sqliteConnection.OpenAsync(cancellationToken);
+                                       new SQLiteCommand(RemoveSnapshotFromHashSql, sqliteConnection, dbTransaction))
+                                {
+                                    sqliteCommand.Parameters.AddRange(new[]
-                using (var dbTransaction = sqliteConnection.BeginTransaction())
+                                    {
+                                        new SQLiteParameter("@hash", hash)
                                     });
                     try
                                     sqliteCommand.Prepare();
                         var transactionCommands = new List<Task>();
                                     var command = sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
                         foreach (var hash in hashes)
                                     transactionCommands.Add(command);
+                                }
+                            }
-                            // Insert the file change.
-                            using (var sqliteCommand =
+                            await Task.WhenAll(transactionCommands);
-                                   new SQLiteCommand(RemoveSnapshotFromHashSql, sqliteConnection, dbTransaction))
-                            {
+                            dbTransaction.Commit();
-                                sqliteCommand.Parameters.AddRange(new[]
+                        }
-                                {
+                        catch
-                                    new SQLiteParameter("@hash", hash)
+                        {
+                            dbTransaction.Rollback();
                                 });
                             throw;
                                 sqliteCommand.Prepare();
+                    }
+                }
+            }
+            finally
+            {
-                                var command = sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
+                _databaseLock.Release();
+            }
                                 transactionCommands.Add(command);
         public async Task RemoveFile(string hash, CancellationToken cancellationToken)
+        {
-                        await Task.WhenAll(transactionCommands);
+            var connectionString = new SQLiteConnectionStringBuilder
+            {
+                ConnectionString = DatabaseConnectionString
-                        dbTransaction.Commit();
+            };
-                    }
-                    catch
-                    {
+            await _databaseLock.WaitAsync(cancellationToken);
-                        dbTransaction.Rollback();
+            try
+            {
-                        throw;
+                using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
-                    }
+                {
                     await sqliteConnection.OpenAsync(cancellationToken);
-            }
+                    using (var dbTransaction = sqliteConnection.BeginTransaction())
+                    {
                         // Insert the file change.
                         using (var sqliteCommand =
-        public async Task RemoveFile(string hash, CancellationToken cancellationToken)
+                               new SQLiteCommand(RemoveSnapshotFromHashSql, sqliteConnection, dbTransaction))
+                        {
-            var connectionString = new SQLiteConnectionStringBuilder
+                            sqliteCommand.Parameters.AddRange(new[]
+                            {
+                                new SQLiteParameter("@hash", hash)
+                            });
-                ConnectionString = DatabaseConnectionString
-            };
+                            sqliteCommand.Prepare();
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                            try
-            {
+                            {
-                await sqliteConnection.OpenAsync(cancellationToken);
+                                await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
+                                dbTransaction.Commit();
                 using (var dbTransaction = sqliteConnection.BeginTransaction())
                             catch
                     // Insert the file change.
-                    using (var sqliteCommand =
+                                dbTransaction.Rollback();
+                                throw;
+                            }
+                        }
                            new SQLiteCommand(RemoveSnapshotFromHashSql, sqliteConnection, dbTransaction))
+                }
                         try
             finally
                             sqliteCommand.Parameters.AddRange(new[]
                 _databaseLock.Release();
                                 new SQLiteParameter("@hash", hash)
-                            });
+        }
         public async Task UpdateColor(string hash, Color color, CancellationToken cancellationToken)
-                            sqliteCommand.Prepare();
-                            await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
+        {
-                            dbTransaction.Commit();
+            var connectionString = new SQLiteConnectionStringBuilder
-                        }
+            {
-                        catch
-                        {
-                            dbTransaction.Rollback();
-                            throw;
-                        }
-                    }
+                ConnectionString = DatabaseConnectionString
-                }
+            };
-        }
+            await _databaseLock.WaitAsync(cancellationToken);
-        public async Task UpdateColor(string hash, Color color, CancellationToken cancellationToken)
+            try
-        {
+            {
-            var connectionString = new SQLiteConnectionStringBuilder
-            {
-                ConnectionString = DatabaseConnectionString
-            };
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
-            {
-                await sqliteConnection.OpenAsync(cancellationToken);
+                {
+                    await sqliteConnection.OpenAsync(cancellationToken);
+                    using (var dbTransaction = sqliteConnection.BeginTransaction())
+                    {
+                        // Insert the file change.
-                using (var dbTransaction = sqliteConnection.BeginTransaction())
+                        using (var sqliteCommand =
-                {
-                    // Insert the file change.
-                    using (var sqliteCommand =
+                               new SQLiteCommand(UpdateColorFromHashSql, sqliteConnection, dbTransaction))
-                           new SQLiteCommand(UpdateColorFromHashSql, sqliteConnection, dbTransaction))
+                        {
-                        try
-                        {
-                            sqliteCommand.Parameters.AddRange(new[]
-                            {
-                                new SQLiteParameter("@hash", hash),
-                                new SQLiteParameter("@color", color.ToArgb())
-                            });
-                            sqliteCommand.Prepare();
-                            await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
-                            dbTransaction.Commit();
-                        }
-                        catch
-                        {
-                            dbTransaction.Rollback();
-                            throw;
-                        }
-                    }
-                }
-            }
-        }
-        public async Task RemoveColor(string hash, CancellationToken cancellationToken)
-        {
-            var connectionString = new SQLiteConnectionStringBuilder
-            {
-                ConnectionString = DatabaseConnectionString
-            };
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
-            {
+                            sqliteCommand.Parameters.AddRange(new[]
-                await sqliteConnection.OpenAsync(cancellationToken);
+                            {
-                using (var dbTransaction = sqliteConnection.BeginTransaction())
-                {
-                    // Insert the file change.
-                    using (var sqliteCommand =
-                           new SQLiteCommand(RemoveColorFromHashSql, sqliteConnection, dbTransaction))
                                 new SQLiteParameter("@hash", hash),
+                                new SQLiteParameter("@color", color.ToArgb())
-                        try
+                            });
-                        {
-                            sqliteCommand.Parameters.AddRange(new[]
-                            {
-                                new SQLiteParameter("@hash", hash)
-                            });
                             sqliteCommand.Prepare();
-                            sqliteCommand.Prepare();
-                            await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
+                            try
-                            dbTransaction.Commit();
-                        }
+                            {
-                        catch
-                        {
+                                await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
                             dbTransaction.Rollback();
                                 dbTransaction.Commit();
+                            }
+                            catch
                             throw;
-                        }
-                    }
+                                dbTransaction.Rollback();
                                 throw;
+                            }
+                        }
+                    }
+                }
+            }
+            finally
+            {
-        public async Task<SnapshotPreview> RetrievePreview(string hash, CancellationToken cancellationToken)
                 _databaseLock.Release();
             var connectionString = new SQLiteConnectionStringBuilder
+        }
                 ConnectionString = DatabaseConnectionString
-            };
+        public async Task RemoveColor(string hash, CancellationToken cancellationToken)
+        {
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+            var connectionString = new SQLiteConnectionStringBuilder
+            {
                 ConnectionString = DatabaseConnectionString
-                await sqliteConnection.OpenAsync(cancellationToken);
-                // Insert the file change.
-                using (var sqliteCommand = new SQLiteCommand(RetrievePreviewFromHashSql, sqliteConnection))
+            };
-                    sqliteCommand.Parameters.AddRange(new[]
+            await _databaseLock.WaitAsync(cancellationToken);
+            try
+            {
+                using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                {
+                    await sqliteConnection.OpenAsync(cancellationToken);
-                        new SQLiteParameter("@hash", hash)
+                    using (var dbTransaction = sqliteConnection.BeginTransaction())
-                    });
+                    {
+                        // Insert the file change.
-                    var note = string.Empty;
+                        using (var sqliteCommand =
-                    sqliteCommand.Prepare();
                                new SQLiteCommand(RemoveColorFromHashSql, sqliteConnection, dbTransaction))
-                    using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
+                        {
                             sqliteCommand.Parameters.AddRange(new[]
-                        while (await sqlDataReader.ReadAsync(cancellationToken))
+                            {
                                 new SQLiteParameter("@hash", hash)
+                            });
-                            if (!(sqlDataReader["Note"] is DBNull))
+                            sqliteCommand.Prepare();
-                            {
-                                note = (string)sqlDataReader["Note"];
+                            try
-                            }
+                            {
+                                await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
-                            Bitmap shot = null;
+                                dbTransaction.Commit();
-                            if (!(sqlDataReader["Shot"] is DBNull))
+                            }
-                            {
+                            catch
-                                var readStream = sqlDataReader.GetStream(2);
+                            {
+                                dbTransaction.Rollback();
-                                readStream.Position = 0L;
+                                throw;
+                            }
-                                using (var zipStream = new GZipStream(readStream, CompressionMode.Decompress))
-                                {
+                        }
+                    }
                                     using (var image = Image.FromStream(zipStream))
+            }
-                                        shot = new Bitmap(image);
+            finally
+            {
+                _databaseLock.Release();
+            }
+        }
         public async Task<SnapshotPreview> RetrievePreview(string hash, CancellationToken cancellationToken)
+        {
             var connectionString = new SQLiteConnectionStringBuilder
                             return new SnapshotPreview(hash, shot, note);
                 ConnectionString = DatabaseConnectionString
             };
-                        return null;
+            await _databaseLock.WaitAsync(cancellationToken);
             try
-                }
-            }
-        }
+            {
                 using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
-        /*
+                {
-        public MemoryStream RetrieveFileStream(string hash, CancellationToken cancellationToken)
+                    await sqliteConnection.OpenAsync(cancellationToken);
-        {
-            var connectionString = new SQLiteConnectionStringBuilder
+                    // Insert the file change.
+                    using (var sqliteCommand = new SQLiteCommand(RetrievePreviewFromHashSql, sqliteConnection))
-            {
+                    {
+                        sqliteCommand.Parameters.AddRange(new[]
                 ConnectionString = DatabaseConnectionString
-            };
+                            new SQLiteParameter("@hash", hash)
                         });
             using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
                         var note = string.Empty;
-                sqliteConnection.Open();
+                        sqliteCommand.Prepare();
+                        using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
+                        {
-                // Insert the file change.
+                            while (await sqlDataReader.ReadAsync(cancellationToken))
-                using (var sqliteCommand = new SQLiteCommand(RetrieveDataFromHashSql, sqliteConnection))
+                            {
-                {
+                                if (!(sqlDataReader["Note"] is DBNull))
-                    sqliteCommand.Parameters.AddRange(new[]
+                                {
-                    {
+                                    note = (string)sqlDataReader["Note"];
-                        new SQLiteParameter("@hash", hash)
+                                }
-                    });
+                                Bitmap shot = null;
-                    sqliteCommand.Prepare();
+                                if (!(sqlDataReader["Shot"] is DBNull))
+                                {
+                                    var readStream = sqlDataReader.GetStream(2);
+                                    readStream.Position = 0L;
+                                    using (var zipStream = new GZipStream(readStream, CompressionMode.Decompress))
                     using (var sqlDataReader = sqliteCommand.ExecuteReader())
                                         using (var image = Image.FromStream(zipStream))
+                                        {
-                        while (sqlDataReader.Read())
+                                            shot = new Bitmap(image);
+                                        }
                             using (var readStream = sqlDataReader.GetStream(1))
+                                }
+                                return new SnapshotPreview(hash, shot, note);
                                 using (var memoryStream = new MemoryStream())
-                                {
-                                    readStream.Position = 0L;
                             return null;
-                                    readStream.CopyTo(memoryStream);
+                        }
+                    }
-                                    memoryStream.Position = 0L;
+                }
+            }
+            finally
-                                    using (var zipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
+            {
+                _databaseLock.Release();
+            }
+        }
                                         var outputStream = new MemoryStream();
         public async Task<MemoryStream> RetrieveFileStream(string hash, CancellationToken cancellationToken)
                                         zipStream.CopyTo(outputStream);
             var connectionString = new SQLiteConnectionStringBuilder
                                         outputStream.Position = 0L;
+                ConnectionString = DatabaseConnectionString
+            };
-                                        return outputStream;
+            await _databaseLock.WaitAsync(cancellationToken);
-                                    }
+            try
-                                }
+            {
-                            }
+                using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
-                        }
+                {
+                    await sqliteConnection.OpenAsync(cancellationToken);
-                        return null;
-                    }
+                    // Insert the file change.
+                    using (var sqliteCommand = new SQLiteCommand(RetrieveDataFromHashSql, sqliteConnection))
+                    {
                         sqliteCommand.Parameters.AddRange(new[]
+                        {
-        */
+                            new SQLiteParameter("@hash", hash)
+                        });
+                        sqliteCommand.Prepare();
                         using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
         public async Task<MemoryStream> RetrieveFileStream(string hash, CancellationToken cancellationToken)
                             while (await sqlDataReader.ReadAsync(cancellationToken))
-            var connectionString = new SQLiteConnectionStringBuilder
+                            {
                                 using (var readStream = sqlDataReader.GetStream(1))
-                ConnectionString = DatabaseConnectionString
-            };
+                                {
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                                    using (var memoryStream = new MemoryStream())
+                                    {
+                                        readStream.Position = 0L;
-            {
+                                        await readStream.CopyToAsync(memoryStream);
                 await sqliteConnection.OpenAsync(cancellationToken);
-                // Insert the file change.
-                using (var sqliteCommand = new SQLiteCommand(RetrieveDataFromHashSql, sqliteConnection))
+                                        memoryStream.Position = 0L;
-                    sqliteCommand.Parameters.AddRange(new[]
+                                        using (var zipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
+                                        {
+                                            // Do not dispose the returned stream and leave it up to callers to dispose.
                                             var outputStream = new MemoryStream();
-                        new SQLiteParameter("@hash", hash)
-                    });
+                                            await zipStream.CopyToAsync(outputStream);
-                    sqliteCommand.Prepare();
+                                            outputStream.Position = 0L;
+                                            return outputStream;
+                                        }
-                    using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
+                                    }
-                    {
+                                }
-                        while (await sqlDataReader.ReadAsync(cancellationToken))
+                            }
-                        {
-                            using (var readStream = sqlDataReader.GetStream(1))
+                            return null;
-                            {
+                        }
-                                using (var memoryStream = new MemoryStream())
-                                {
-                                    readStream.Position = 0L;
+                    }
-                                    await readStream.CopyToAsync(memoryStream);
-                                    memoryStream.Position = 0L;
-                                    using (var zipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
-                                    {
-                                        // Do not dispose the returned stream and leave it up to callers to dispose.
-                                        var outputStream = new MemoryStream();
+                }
+            }
-                                        await zipStream.CopyToAsync(outputStream);
+            finally
+            {
+                _databaseLock.Release();
+            }
+        }
+        public async Task RelocateFile(string hash, string path, CancellationToken cancellationToken)
+        {
+            var connectionString = new SQLiteConnectionStringBuilder
+            {
+                ConnectionString = DatabaseConnectionString
-                                        outputStream.Position = 0L;
+            };
+            await _databaseLock.WaitAsync(cancellationToken);
+            try
-                                        return outputStream;
+            {
-                                    }
+                using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
-                                }
+                {
-                            }
+                    await sqliteConnection.OpenAsync(cancellationToken);
-                        }
+                    using (var dbTransaction = sqliteConnection.BeginTransaction())
-                        return null;
+                    {
-                    }
+                        // Insert the file change.
-                }
+                        using (var sqliteCommand =
-            }
-        }
                                new SQLiteCommand(RelocateFileFromHashSql, sqliteConnection, dbTransaction))
+                        {
+                            sqliteCommand.Parameters.AddRange(new[]
-        public async Task RelocateFile(string hash, string path, CancellationToken cancellationToken)
+                            {
-        {
+                                new SQLiteParameter("@hash", hash),
-            var connectionString = new SQLiteConnectionStringBuilder
+                                new SQLiteParameter("@path", path)
-            {
+                            });
-                ConnectionString = DatabaseConnectionString
-            };
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                            sqliteCommand.Prepare();
-            {
-                await sqliteConnection.OpenAsync(cancellationToken);
+                            try
-                using (var dbTransaction = sqliteConnection.BeginTransaction())
-                {
-                    // Insert the file change.
-                    using (var sqliteCommand =
+                            {
-                           new SQLiteCommand(RelocateFileFromHashSql, sqliteConnection, dbTransaction))
+                                await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
+                                dbTransaction.Commit();
+                            }
+                            catch
+                            {
+                                dbTransaction.Rollback();
+                                throw;
-                    {
+                            }
-                        try
+                        }
-                        {
+                    }
-                            sqliteCommand.Parameters.AddRange(new[]
+                }
-                            {
+            }
-                                new SQLiteParameter("@hash", hash),
+            finally
                                 new SQLiteParameter("@path", path)
-                            });
+                _databaseLock.Release();
+            }
-                            sqliteCommand.Prepare();
+        }
-                            await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
+        public async Task UpdateNote(string hash, string note, CancellationToken cancellationToken)
-                            dbTransaction.Commit();
+        {
+            var connectionString = new SQLiteConnectionStringBuilder
+            {
-                        catch
+                ConnectionString = DatabaseConnectionString
             };
                             dbTransaction.Rollback();
-                            throw;
+            await _databaseLock.WaitAsync(cancellationToken);
-                        }
+            try
-                    }
+            {
-                }
+                using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
-            }
+                {
+                    await sqliteConnection.OpenAsync(cancellationToken);
                     using (var dbTransaction = sqliteConnection.BeginTransaction())
         public async Task UpdateNote(string hash, string note, CancellationToken cancellationToken)
                         // Insert the file change.
+                        using (var sqliteCommand =
+                               new SQLiteCommand(UpdateNoteFromHashSql, sqliteConnection, dbTransaction))
+                        {
+                            sqliteCommand.Parameters.AddRange(new[]
             var connectionString = new SQLiteConnectionStringBuilder
                                 new SQLiteParameter("@hash", hash),
-                ConnectionString = DatabaseConnectionString
+                                new SQLiteParameter("@note", note)
-            };
+                            });
-            using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                            sqliteCommand.Prepare();
-                await sqliteConnection.OpenAsync(cancellationToken);
+                            try
+                            {
                                 await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
-                using (var dbTransaction = sqliteConnection.BeginTransaction())
-                {
-                    // Insert the file change.
-                    using (var sqliteCommand =
+                                dbTransaction.Commit();
-                           new SQLiteCommand(UpdateNoteFromHashSql, sqliteConnection, dbTransaction))
-                    {
+                                SnapshotNoteUpdate?.Invoke(this, new SnapshotNoteUpdateSuccessEventArgs(note));
-                        try
+                            }
                             catch
+                            {
-                            sqliteCommand.Parameters.AddRange(new[]
+                                dbTransaction.Rollback();
                                 SnapshotNoteUpdate?.Invoke(this, new SnapshotNoteUpdateFailureEventArgs());
                                 new SQLiteParameter("@hash", hash),
-                                new SQLiteParameter("@note", note)
+                                throw;
                             });
+                        }
                             sqliteCommand.Prepare();
+                }
+            }
+            finally
-                            await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
+            {
+                _databaseLock.Release();
-                            dbTransaction.Commit();
+            }
+        }
-                            SnapshotNoteUpdate?.Invoke(this, new SnapshotNoteUpdateSuccessEventArgs(note));
-                        }
+        public async Task<string> UpdateFile(string hash, byte[] data, CancellationToken cancellationToken)
-                        catch
+        {
+            var connectionString = new SQLiteConnectionStringBuilder
+            {
-                            dbTransaction.Rollback();
+                ConnectionString = DatabaseConnectionString
             };
                             SnapshotNoteUpdate?.Invoke(this, new SnapshotNoteUpdateFailureEventArgs());
+            await _databaseLock.WaitAsync(cancellationToken);
+            try
+            {
+                using (var dataMemoryStream = new MemoryStream(data))
+                {
-                            throw;
+                    using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                    {
-                    }
+                        await sqliteConnection.OpenAsync(cancellationToken);
                         using (var dbTransaction = sqliteConnection.BeginTransaction())
+                        {
                             try
         public async Task<string> UpdateFile(string hash, byte[] data, CancellationToken cancellationToken)
-        {
+                                using (var md5 = MD5.Create())
-            using (var dataMemoryStream = new MemoryStream(data))
+                                {
                                     using (var hashMemoryStream = new MemoryStream())
-                var connectionString = new SQLiteConnectionStringBuilder
-                {
-                    ConnectionString = DatabaseConnectionString
+                                    {
-                };
+                                        dataMemoryStream.Position = 0L;
                                         await dataMemoryStream.CopyToAsync(hashMemoryStream);
+                                        hashMemoryStream.Position = 0L;
+                                        var recomputedHash = md5.ComputeHash(hashMemoryStream);
+                                        var hashHex = BitConverter.ToString(recomputedHash).Replace("-", "")
+                                            .ToLowerInvariant();
-                using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
+                                        using (var fileMemoryStream = new MemoryStream())
+                                        {
-                    await sqliteConnection.OpenAsync(cancellationToken);
+                                            using (var fileZipStream =
+                                                   new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
+                                            {
+                                                dataMemoryStream.Position = 0L;
+                                                await dataMemoryStream.CopyToAsync(fileZipStream);
                                                 fileZipStream.Close();
-                    using (var dbTransaction = sqliteConnection.BeginTransaction())
                                                 fileMemoryStream.Position = 0L;
                         try
                                                 // Insert the file change.
-                            using (var md5 = MD5.Create())
+                                                using (var sqliteCommand =
                                                        new SQLiteCommand(UpdateFileSql, sqliteConnection,
-                                using (var hashMemoryStream = new MemoryStream())
+                                                           dbTransaction))
+                                                {
                                                     sqliteCommand.Parameters.AddRange(new[]
-                                    dataMemoryStream.Position = 0L;
-                                    await dataMemoryStream.CopyToAsync(hashMemoryStream);
+                                                    {
-                                    hashMemoryStream.Position = 0L;
+                                                        new SQLiteParameter("@dataLength", fileMemoryStream.Length),
-                                    var recomputedHash = md5.ComputeHash(hashMemoryStream);
+                                                        new SQLiteParameter("@recomputedHash", hashHex),
+                                                        new SQLiteParameter("@hash", hash)
-                                    var hashHex = BitConverter.ToString(recomputedHash).Replace("-", "")
+                                                    });
                                         .ToLowerInvariant();
+                                                    sqliteCommand.Prepare();
+                                                    await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
                                     using (var fileMemoryStream = new MemoryStream())
+                                                using (var sqliteCommand =
-                                    {
+                                                       new SQLiteCommand(GetRowFromHashSql, sqliteConnection,
-                                        using (var fileZipStream =
+                                                           dbTransaction))
-                                               new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
+                                                {
-                                        {
+                                                    sqliteCommand.Parameters.AddRange(new[]
-                                            dataMemoryStream.Position = 0L;
+                                                    {
-                                            await dataMemoryStream.CopyToAsync(fileZipStream);
+                                                        new SQLiteParameter("@hash", hashHex)
-                                            fileZipStream.Close();
+                                                    });
                                                     sqliteCommand.Prepare();
                                             fileMemoryStream.Position = 0L;
                                                     using (var sqlDataReader =
-                                            // Insert the file change.
+                                                           await sqliteCommand.ExecuteReaderAsync(cancellationToken))
+                                                    {
+                                                        while (await sqlDataReader.ReadAsync(cancellationToken))
+                                                        {
+                                                            if (sqlDataReader["id"] is long rowId)
                                             using (var sqliteCommand =
-                                                   new SQLiteCommand(UpdateFileSql, sqliteConnection, dbTransaction))
+                                                                using (var sqliteBlob = SQLiteBlob.Create(
                                                                            sqliteConnection,
-                                                sqliteCommand.Parameters.AddRange(new[]
+                                                                           "main",
                                                                            "Snapshots",