Horizon

Subversion Repositories:
Compare Path: Rev
With Path: Rev
?path1? @ 4  →  ?path2? @ 5
/Horizon/Database/SnapshotDatabase.cs
@@ -6,6 +6,7 @@
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;
@@ -96,22 +97,29 @@
#region Private Delegates, Events, Enums, Properties, Indexers and Fields
 
private readonly CancellationTokenSource _cancellationTokenSource;
private readonly SemaphoreSlim _databaseLock;
 
private SemaphoreSlim _snapshotSemaphore;
 
#endregion
 
#region Constructors, Destructors and Finalizers
 
public SnapshotDatabase()
private SnapshotDatabase()
{
Directory.CreateDirectory(Constants.DatabaseDirectory);
 
_databaseLock = new SemaphoreSlim(1, 1);
}
 
public SnapshotDatabase(CancellationToken cancellationToken) : this()
{
_cancellationTokenSource = new CancellationTokenSource();
_cancellationToken = _cancellationTokenSource.Token;
var localCancellationToken = _cancellationTokenSource.Token;
var combinedCancellationTokenSource =
CancellationTokenSource.CreateLinkedTokenSource(localCancellationToken, cancellationToken);
_cancellationToken = combinedCancellationTokenSource.Token;
 
_snapshotSemaphore = new SemaphoreSlim(1, 1);
 
Directory.CreateDirectory(Constants.DatabaseDirectory);
 
CreateDatabase(_cancellationToken).ContinueWith(async createDatabaseTask =>
{
try
@@ -137,9 +145,6 @@
public void Dispose()
{
_cancellationTokenSource.Cancel();
 
_snapshotSemaphore?.Dispose();
_snapshotSemaphore = null;
}
 
#endregion
@@ -153,17 +158,18 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RemoveScreenshotFromHashSql, sqliteConnection, dbTransaction))
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RemoveScreenshotFromHashSql, sqliteConnection, dbTransaction))
{
sqliteCommand.Parameters.AddRange(new[]
{
@@ -172,19 +178,26 @@
 
sqliteCommand.Prepare();
 
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
try
{
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
 
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
 
throw;
throw;
}
}
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task NormalizeTime(string hash, CancellationToken cancellationToken)
@@ -194,71 +207,80 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection =
new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection =
new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var readSQLiteCommand = new SQLiteCommand(RetrieveTimeFromHash, sqliteConnection))
{
readSQLiteCommand.Parameters.AddRange(new[]
using (var readSQLiteCommand = new SQLiteCommand(RetrieveTimeFromHash, sqliteConnection))
{
new SQLiteParameter("@hash", hash)
});
readSQLiteCommand.Parameters.AddRange(new[]
{
new SQLiteParameter("@hash", hash)
});
 
readSQLiteCommand.Prepare();
readSQLiteCommand.Prepare();
 
using (var sqlDataReader = await readSQLiteCommand.ExecuteReaderAsync(cancellationToken))
{
using (var dbTransaction = sqliteConnection.BeginTransaction())
using (var sqlDataReader = await readSQLiteCommand.ExecuteReaderAsync(cancellationToken))
{
try
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
while (await sqlDataReader.ReadAsync(cancellationToken))
try
{
var time = (string)sqlDataReader["Time"];
 
// Skip if already ISO 8601
if (DateTime.TryParseExact(time,
"yyyy-MM-ddTHH:mm:ss.fff",
CultureInfo.InvariantCulture,
DateTimeStyles.None, out _))
while (await sqlDataReader.ReadAsync(cancellationToken))
{
continue;
}
var time = (string)sqlDataReader["Time"];
 
if (!DateTime.TryParse(time, out var dateTime))
{
dateTime = DateTime.Now;
}
// Skip if already ISO 8601
if (DateTime.TryParseExact(time,
"yyyy-MM-ddTHH:mm:ss.fff",
CultureInfo.InvariantCulture,
DateTimeStyles.None, out _))
{
continue;
}
 
using (var writeSQLiteCommand =
new SQLiteCommand(UpdateTimeFromHash, sqliteConnection, dbTransaction))
{
writeSQLiteCommand.Parameters.AddRange(new[]
if (!DateTime.TryParse(time, out var dateTime))
{
new SQLiteParameter("@time", dateTime.ToString("yyyy-MM-ddTHH:mm:ss.fff")),
new SQLiteParameter("@hash", hash)
});
dateTime = DateTime.Now;
}
 
writeSQLiteCommand.Prepare();
using (var writeSQLiteCommand =
new SQLiteCommand(UpdateTimeFromHash, sqliteConnection, dbTransaction))
{
writeSQLiteCommand.Parameters.AddRange(new[]
{
new SQLiteParameter("@time",
dateTime.ToString("yyyy-MM-ddTHH:mm:ss.fff")),
new SQLiteParameter("@hash", hash)
});
 
await writeSQLiteCommand.ExecuteNonQueryAsync(cancellationToken);
writeSQLiteCommand.Prepare();
 
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)
@@ -268,37 +290,45 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
 
// Insert the file change.
using (var sqliteCommand = new SQLiteCommand(CountSnapshotsSql, sqliteConnection))
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
long count = 0;
await sqliteConnection.OpenAsync(cancellationToken);
 
sqliteCommand.Prepare();
// Insert the file change.
using (var sqliteCommand = new SQLiteCommand(CountSnapshotsSql, sqliteConnection))
{
long count = 0;
 
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
while (await sqlDataReader.ReadAsync(cancellationToken))
sqliteCommand.Prepare();
 
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
if (!(sqlDataReader[0] is long dbCount))
while (await sqlDataReader.ReadAsync(cancellationToken))
{
count = -1;
break;
if (!(sqlDataReader[0] is long dbCount))
{
count = -1;
break;
}
 
count = dbCount;
}
 
count = dbCount;
return count;
}
 
return count;
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task<IEnumerable<Snapshot>> LoadSnapshots(CancellationToken cancellationToken)
public async IAsyncEnumerable<Snapshot> LoadSnapshots([EnumeratorCancellation] CancellationToken cancellationToken)
{
var connectionString = new SQLiteConnectionStringBuilder
{
@@ -305,331 +335,347 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection =
new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
 
// Insert the file change.
using (var sqliteCommand = new SQLiteCommand(RetrieveSnapshotsSql, sqliteConnection))
using (var sqliteConnection =
new SQLiteConnection(connectionString.ConnectionString))
{
sqliteCommand.Prepare();
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
// Insert the file change.
using (var sqliteCommand = new SQLiteCommand(RetrieveSnapshotsSql, sqliteConnection))
{
var snapshots = new List<Snapshot>();
while (await sqlDataReader.ReadAsync(cancellationToken))
sqliteCommand.Prepare();
 
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
var name = (string)sqlDataReader["Name"];
var path = (string)sqlDataReader["Path"];
var time = (string)sqlDataReader["Time"];
var hash = (string)sqlDataReader["Hash"];
//var snapshots = new List<Snapshot>();
while (await sqlDataReader.ReadAsync(cancellationToken))
{
var name = (string)sqlDataReader["Name"];
var path = (string)sqlDataReader["Path"];
var time = (string)sqlDataReader["Time"];
var hash = (string)sqlDataReader["Hash"];
 
var color = Color.Empty;
var color = Color.Empty;
 
if (!(sqlDataReader["Color"] is DBNull))
{
var dbColor = Convert.ToInt32(sqlDataReader["Color"]);
if (!(sqlDataReader["Color"] is DBNull))
{
var dbColor = Convert.ToInt32(sqlDataReader["Color"]);
 
switch (dbColor)
{
case 0:
color = Color.Empty;
break;
default:
color = Color.FromArgb(dbColor);
break;
switch (dbColor)
{
case 0:
color = Color.Empty;
break;
default:
color = Color.FromArgb(dbColor);
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)
{
await _snapshotSemaphore.WaitAsync(cancellationToken);
 
var connectionString = new SQLiteConnectionStringBuilder
{
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection =
new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection =
new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
using (var md5 = MD5.Create())
try
{
using (var hashMemoryStream = new MemoryStream())
using (var md5 = MD5.Create())
{
using (var fileStream =
await Miscellaneous.GetFileStream(path, FileMode.Open, FileAccess.Read,
FileShare.Read,
cancellationToken))
using (var hashMemoryStream = new MemoryStream())
{
fileStream.Position = 0L;
await fileStream.CopyToAsync(hashMemoryStream);
using (var fileStream =
await Miscellaneous.GetFileStream(path, FileMode.Open, FileAccess.Read,
FileShare.Read,
cancellationToken))
{
fileStream.Position = 0L;
await fileStream.CopyToAsync(hashMemoryStream);
 
hashMemoryStream.Position = 0L;
var hash = md5.ComputeHash(hashMemoryStream);
var hashHex = BitConverter.ToString(hash).Replace("-", "")
.ToLowerInvariant();
hashMemoryStream.Position = 0L;
var hash = md5.ComputeHash(hashMemoryStream);
var hashHex = BitConverter.ToString(hash).Replace("-", "")
.ToLowerInvariant();
 
using (var fileMemoryStream = new MemoryStream())
{
using (var fileZipStream =
new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
using (var fileMemoryStream = new MemoryStream())
{
fileStream.Position = 0L;
await fileStream.CopyToAsync(fileZipStream);
fileZipStream.Close();
using (var fileZipStream =
new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
{
fileStream.Position = 0L;
await fileStream.CopyToAsync(fileZipStream);
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.
using (var sqliteCommand =
new SQLiteCommand(SnapshotFileNoScreenshotSql, sqliteConnection,
dbTransaction))
{
sqliteCommand.Parameters.AddRange(new[]
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(SnapshotFileNoScreenshotSql, sqliteConnection,
dbTransaction))
{
new SQLiteParameter("@name", name),
new SQLiteParameter("@time", time),
new SQLiteParameter("@path", path),
new SQLiteParameter("@dataLength",
fileMemoryStream.Length),
new SQLiteParameter("@hash", hashHex)
});
sqliteCommand.Parameters.AddRange(new[]
{
new SQLiteParameter("@name", name),
new SQLiteParameter("@time", time),
new SQLiteParameter("@path", path),
new SQLiteParameter("@dataLength",
fileMemoryStream.Length),
new SQLiteParameter("@hash", hashHex)
});
 
var numeric = color.ToArgb();
switch (numeric)
{
case 0:
sqliteCommand.Parameters.Add(
new SQLiteParameter("@color", null));
break;
default:
sqliteCommand.Parameters.Add(
new SQLiteParameter("@color", numeric));
break;
}
var numeric = color.ToArgb();
switch (numeric)
{
case 0:
sqliteCommand.Parameters.Add(
new SQLiteParameter("@color", null));
break;
default:
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();
// Insert the data blobs.
using (var sqliteCommand =
new SQLiteCommand(GetLastRowInsertSql, sqliteConnection,
dbTransaction))
{
sqliteCommand.Prepare();
 
var rowId =
(long)await sqliteCommand.ExecuteScalarAsync(cancellationToken);
var rowId =
(long)await sqliteCommand.ExecuteScalarAsync(cancellationToken);
 
using (var sqliteBlob =
SQLiteBlob.Create(sqliteConnection, "main", "Snapshots", "Data",
rowId,
false))
{
var fileMemoryStreamData = fileMemoryStream.ToArray();
using (var sqliteBlob =
SQLiteBlob.Create(sqliteConnection, "main", "Snapshots",
"Data",
rowId,
false))
{
var fileMemoryStreamData = fileMemoryStream.ToArray();
 
sqliteBlob.Write(fileMemoryStreamData, fileMemoryStreamData.Length,
0);
sqliteBlob.Write(fileMemoryStreamData,
fileMemoryStreamData.Length,
0);
}
}
}
 
dbTransaction.Commit();
dbTransaction.Commit();
 
SnapshotCreate?.Invoke(this,
new SnapshotCreateSuccessEventArgs(name, time, path, color,
hashHex));
SnapshotCreate?.Invoke(this,
new SnapshotCreateSuccessEventArgs(name, time, path, color,
hashHex));
}
}
}
}
}
}
}
catch (SQLiteException exception)
{
dbTransaction.Rollback();
catch (SQLiteException exception)
{
dbTransaction.Rollback();
 
if (exception.ResultCode != SQLiteErrorCode.Constraint)
if (exception.ResultCode != SQLiteErrorCode.Constraint)
{
SnapshotCreate?.Invoke(this,
new SnapshotCreateFailureEventArgs(name, path, color, exception));
}
 
throw;
}
catch (Exception exception)
{
dbTransaction.Rollback();
 
SnapshotCreate?.Invoke(this,
new SnapshotCreateFailureEventArgs(name, path, color, exception));
 
throw;
}
 
throw;
}
catch (Exception exception)
{
dbTransaction.Rollback();
 
SnapshotCreate?.Invoke(this, new SnapshotCreateFailureEventArgs(name, path, color, exception));
 
throw;
}
finally
{
_snapshotSemaphore.Release();
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task CreateSnapshot(string name, string path,
Bitmap shot, Color color, CancellationToken cancellationToken)
{
await _snapshotSemaphore.WaitAsync(cancellationToken);
 
var connectionString = new SQLiteConnectionStringBuilder
{
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection =
new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection =
new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
using (var md5 = MD5.Create())
try
{
using (var hashMemoryStream = new MemoryStream())
using (var md5 = MD5.Create())
{
using (var fileStream =
await Miscellaneous.GetFileStream(path, FileMode.Open, FileAccess.Read,
FileShare.Read,
cancellationToken))
using (var hashMemoryStream = new MemoryStream())
{
fileStream.Position = 0L;
await fileStream.CopyToAsync(hashMemoryStream);
using (var fileStream =
await Miscellaneous.GetFileStream(path, FileMode.Open, FileAccess.Read,
FileShare.Read,
cancellationToken))
{
fileStream.Position = 0L;
await fileStream.CopyToAsync(hashMemoryStream);
 
hashMemoryStream.Position = 0L;
var hash = md5.ComputeHash(hashMemoryStream);
var hashHex = BitConverter.ToString(hash).Replace("-", "")
.ToLowerInvariant();
hashMemoryStream.Position = 0L;
var hash = md5.ComputeHash(hashMemoryStream);
var hashHex = BitConverter.ToString(hash).Replace("-", "")
.ToLowerInvariant();
 
using (var fileMemoryStream = new MemoryStream())
{
using (var fileZipStream =
new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
using (var fileMemoryStream = new MemoryStream())
{
fileStream.Position = 0L;
await fileStream.CopyToAsync(fileZipStream);
fileZipStream.Close();
using (var fileZipStream =
new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
{
fileStream.Position = 0L;
await fileStream.CopyToAsync(fileZipStream);
fileZipStream.Close();
 
using (var bitmapMemoryStream = new MemoryStream())
{
using (var bitmapZipStream =
new GZipStream(bitmapMemoryStream, CompressionMode.Compress,
true))
using (var bitmapMemoryStream = new MemoryStream())
{
shot.Save(bitmapZipStream, ImageFormat.Bmp);
bitmapZipStream.Close();
using (var bitmapZipStream =
new GZipStream(bitmapMemoryStream, CompressionMode.Compress,
true))
{
shot.Save(bitmapZipStream, ImageFormat.Bmp);
bitmapZipStream.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;
bitmapMemoryStream.Position = 0L;
fileMemoryStream.Position = 0L;
bitmapMemoryStream.Position = 0L;
 
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(SnapshotFileSql, sqliteConnection,
dbTransaction))
{
sqliteCommand.Parameters.AddRange(new[]
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(SnapshotFileSql, sqliteConnection,
dbTransaction))
{
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)
});
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)
});
 
var numeric = color.ToArgb();
switch (numeric)
{
case 0:
sqliteCommand.Parameters.Add(
new SQLiteParameter("@color", null));
break;
default:
sqliteCommand.Parameters.Add(
new SQLiteParameter("@color", numeric));
break;
var numeric = color.ToArgb();
switch (numeric)
{
case 0:
sqliteCommand.Parameters.Add(
new SQLiteParameter("@color", null));
break;
default:
sqliteCommand.Parameters.Add(
new SQLiteParameter("@color", numeric));
break;
}
 
sqliteCommand.Prepare();
 
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
}
 
sqliteCommand.Prepare();
// Insert the data blobs.
using (var sqliteCommand =
new SQLiteCommand(GetLastRowInsertSql, sqliteConnection,
dbTransaction))
{
sqliteCommand.Prepare();
 
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
}
var rowId =
(long)await sqliteCommand.ExecuteScalarAsync(
cancellationToken);
 
// Insert the data blobs.
using (var sqliteCommand =
new SQLiteCommand(GetLastRowInsertSql, sqliteConnection,
dbTransaction))
{
sqliteCommand.Prepare();
using (var sqliteBlob =
SQLiteBlob.Create(sqliteConnection, "main",
"Snapshots",
"Data",
rowId,
false))
{
var fileMemoryStreamData = fileMemoryStream.ToArray();
 
var rowId =
(long)await sqliteCommand.ExecuteScalarAsync(
cancellationToken);
sqliteBlob.Write(fileMemoryStreamData,
fileMemoryStreamData.Length,
0);
}
 
using (var sqliteBlob =
SQLiteBlob.Create(sqliteConnection, "main", "Snapshots",
"Data",
rowId,
false))
{
var fileMemoryStreamData = fileMemoryStream.ToArray();
using (var sqliteBlob =
SQLiteBlob.Create(sqliteConnection, "main",
"Snapshots",
"Shot",
rowId,
false))
{
var bitmapMemoryStreamData =
bitmapMemoryStream.ToArray();
 
sqliteBlob.Write(fileMemoryStreamData,
fileMemoryStreamData.Length,
0);
sqliteBlob.Write(bitmapMemoryStreamData,
bitmapMemoryStreamData.Length,
0);
}
}
 
using (var sqliteBlob =
SQLiteBlob.Create(sqliteConnection, "main", "Snapshots",
"Shot",
rowId,
false))
{
var bitmapMemoryStreamData = bitmapMemoryStream.ToArray();
dbTransaction.Commit();
 
sqliteBlob.Write(bitmapMemoryStreamData,
bitmapMemoryStreamData.Length,
0);
}
SnapshotCreate?.Invoke(this,
new SnapshotCreateSuccessEventArgs(name, time, path, color,
hashHex));
}
 
dbTransaction.Commit();
 
SnapshotCreate?.Invoke(this,
new SnapshotCreateSuccessEventArgs(name, time, path, color,
hashHex));
}
}
}
@@ -637,33 +683,34 @@
}
}
}
}
catch (SQLiteException exception)
{
dbTransaction.Rollback();
catch (SQLiteException exception)
{
dbTransaction.Rollback();
 
if (exception.ResultCode != SQLiteErrorCode.Constraint)
if (exception.ResultCode != SQLiteErrorCode.Constraint)
{
SnapshotCreate?.Invoke(this,
new SnapshotCreateFailureEventArgs(name, path, color, exception));
}
 
throw;
}
catch (Exception exception)
{
dbTransaction.Rollback();
 
SnapshotCreate?.Invoke(this,
new SnapshotCreateFailureEventArgs(name, path, color, exception));
 
throw;
}
 
throw;
}
catch (Exception exception)
{
dbTransaction.Rollback();
 
SnapshotCreate?.Invoke(this, new SnapshotCreateFailureEventArgs(name, path, color, exception));
 
throw;
}
finally
{
_snapshotSemaphore.Release();
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task SaveFile(string path, string hash, CancellationToken cancellationToken)
@@ -673,45 +720,49 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = 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.
using (var sqliteCommand =
new SQLiteCommand(RetrieveDataPathFromHashSql, sqliteConnection))
{
sqliteCommand.Parameters.AddRange(new[]
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RetrieveDataPathFromHashSql, sqliteConnection))
{
new SQLiteParameter("@hash", hash)
});
sqliteCommand.Parameters.AddRange(new[]
{
new SQLiteParameter("@hash", hash)
});
 
sqliteCommand.Prepare();
sqliteCommand.Prepare();
 
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
while (await sqlDataReader.ReadAsync(cancellationToken))
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
// Create directories if they do not exist.
var dir = Path.GetDirectoryName(path);
 
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))
{
using (var fileStream =
await Miscellaneous.GetFileStream(path, FileMode.Create, FileAccess.Write,
FileShare.Write,
cancellationToken))
if (dir != null && !Directory.Exists(dir))
{
readStream.Position = 0L;
Directory.CreateDirectory(dir);
}
 
using (var zipStream = new GZipStream(readStream, CompressionMode.Decompress))
using (var readStream = sqlDataReader.GetStream(2))
{
using (var fileStream =
await Miscellaneous.GetFileStream(path, FileMode.Create, FileAccess.Write,
FileShare.Write,
cancellationToken))
{
await zipStream.CopyToAsync(fileStream);
readStream.Position = 0L;
 
using (var zipStream = new GZipStream(readStream, CompressionMode.Decompress))
{
await zipStream.CopyToAsync(fileStream);
}
}
}
}
@@ -719,129 +770,135 @@
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task RevertFile(string name, string hash, CancellationToken cancellationToken, bool atomic = true)
{
await _snapshotSemaphore.WaitAsync(cancellationToken);
 
var connectionString = new SQLiteConnectionStringBuilder
{
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = 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.
using (var sqliteCommand =
new SQLiteCommand(RetrieveDataPathFromHashSql, sqliteConnection))
{
try
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RetrieveDataPathFromHashSql, sqliteConnection))
{
sqliteCommand.Parameters.AddRange(new[]
try
{
new SQLiteParameter("@hash", hash)
});
sqliteCommand.Parameters.AddRange(new[]
{
new SQLiteParameter("@hash", hash)
});
 
sqliteCommand.Prepare();
sqliteCommand.Prepare();
 
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
while (await sqlDataReader.ReadAsync(cancellationToken))
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
var path = (string)sqlDataReader["Path"];
while (await sqlDataReader.ReadAsync(cancellationToken))
{
var path = (string)sqlDataReader["Path"];
 
// Create directories if they do not exist.
var dir = Path.GetDirectoryName(path);
// Create directories if they do not exist.
var dir = Path.GetDirectoryName(path);
 
if (dir != null && !Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
if (dir != null && !Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
 
switch (atomic)
{
case true:
// Atomic
var temp = Path.Combine(Path.GetDirectoryName(path),
$"{Path.GetFileName(path)}.temp");
switch (atomic)
{
case true:
// Atomic
var temp = Path.Combine(Path.GetDirectoryName(path),
$"{Path.GetFileName(path)}.temp");
 
using (var readStream = sqlDataReader.GetStream(2))
{
using (var fileStream = new FileStream(temp, FileMode.Create,
FileAccess.Write,
FileShare.None))
using (var readStream = sqlDataReader.GetStream(2))
{
using (var zipStream =
new GZipStream(readStream, CompressionMode.Decompress))
using (var fileStream = new FileStream(temp, FileMode.Create,
FileAccess.Write,
FileShare.None))
{
zipStream.CopyTo(fileStream);
using (var zipStream =
new GZipStream(readStream, CompressionMode.Decompress))
{
zipStream.CopyTo(fileStream);
}
}
}
}
 
try
{
File.Replace(temp, path, null, true);
}
catch
{
try
{
File.Delete(temp);
File.Replace(temp, path, null, true);
}
catch (Exception exception)
catch
{
// Suppress deletion errors of temporary file.
Log.Warning(exception, "Could not delete temporary file.", temp);
try
{
File.Delete(temp);
}
catch (Exception exception)
{
// Suppress deletion errors of temporary file.
Log.Warning(exception, "Could not delete temporary file.", temp);
}
 
throw;
}
 
throw;
}
 
break;
default:
// Asynchronous
using (var readStream = sqlDataReader.GetStream(2))
{
using (var fileStream =
await Miscellaneous.GetFileStream(path, FileMode.Create,
FileAccess.Write,
FileShare.Write,
cancellationToken))
break;
default:
// Asynchronous
using (var readStream = sqlDataReader.GetStream(2))
{
readStream.Position = 0L;
using (var fileStream =
await Miscellaneous.GetFileStream(path, FileMode.Create,
FileAccess.Write,
FileShare.Write,
cancellationToken))
{
readStream.Position = 0L;
 
using (var zipStream =
new GZipStream(readStream, CompressionMode.Decompress))
{
await zipStream.CopyToAsync(fileStream);
using (var zipStream =
new GZipStream(readStream, CompressionMode.Decompress))
{
await zipStream.CopyToAsync(fileStream);
}
}
}
}
 
 
break;
break;
}
 
SnapshotRevert?.Invoke(this, new SnapshotRevertSuccessEventArgs(name));
}
 
SnapshotRevert?.Invoke(this, new SnapshotRevertSuccessEventArgs(name));
}
}
}
catch
{
SnapshotRevert?.Invoke(this, new SnapshotRevertFailureEventArgs(name));
catch
{
SnapshotRevert?.Invoke(this, new SnapshotRevertFailureEventArgs(name));
 
throw;
throw;
}
}
finally
{
_snapshotSemaphore.Release();
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task RemoveFileFast(IEnumerable<string> hashes, CancellationToken cancellationToken)
@@ -851,47 +908,55 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
var transactionCommands = new List<Task>();
try
{
var transactionCommands = new List<Task>();
 
foreach (var hash in hashes)
{
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RemoveSnapshotFromHashSql, sqliteConnection, dbTransaction))
foreach (var hash in hashes)
{
sqliteCommand.Parameters.AddRange(new[]
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RemoveSnapshotFromHashSql, sqliteConnection, dbTransaction))
{
new SQLiteParameter("@hash", hash)
});
sqliteCommand.Parameters.AddRange(new[]
{
new SQLiteParameter("@hash", hash)
});
 
sqliteCommand.Prepare();
sqliteCommand.Prepare();
 
var command = sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
var command = sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
 
transactionCommands.Add(command);
transactionCommands.Add(command);
}
}
}
 
await Task.WhenAll(transactionCommands);
await Task.WhenAll(transactionCommands);
 
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
 
throw;
throw;
}
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task RemoveFile(string hash, CancellationToken cancellationToken)
@@ -900,18 +965,18 @@
{
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RemoveSnapshotFromHashSql, sqliteConnection, dbTransaction))
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RemoveSnapshotFromHashSql, sqliteConnection, dbTransaction))
{
sqliteCommand.Parameters.AddRange(new[]
{
@@ -920,19 +985,26 @@
 
sqliteCommand.Prepare();
 
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
try
{
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
 
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
 
throw;
throw;
}
}
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task UpdateColor(string hash, Color color, CancellationToken cancellationToken)
@@ -942,17 +1014,19 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
 
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(UpdateColorFromHashSql, sqliteConnection, dbTransaction))
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(UpdateColorFromHashSql, sqliteConnection, dbTransaction))
{
sqliteCommand.Parameters.AddRange(new[]
{
@@ -962,19 +1036,26 @@
 
sqliteCommand.Prepare();
 
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
try
{
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
 
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
 
throw;
throw;
}
}
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task RemoveColor(string hash, CancellationToken cancellationToken)
@@ -984,17 +1065,18 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RemoveColorFromHashSql, sqliteConnection, dbTransaction))
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RemoveColorFromHashSql, sqliteConnection, dbTransaction))
{
sqliteCommand.Parameters.AddRange(new[]
{
@@ -1003,19 +1085,26 @@
 
sqliteCommand.Prepare();
 
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
try
{
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
 
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
 
throw;
throw;
}
}
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task<SnapshotPreview> RetrievePreview(string hash, CancellationToken cancellationToken)
@@ -1025,118 +1114,64 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = 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.
using (var sqliteCommand = new SQLiteCommand(RetrievePreviewFromHashSql, sqliteConnection))
{
sqliteCommand.Parameters.AddRange(new[]
// Insert the file change.
using (var sqliteCommand = new SQLiteCommand(RetrievePreviewFromHashSql, sqliteConnection))
{
new SQLiteParameter("@hash", hash)
});
sqliteCommand.Parameters.AddRange(new[]
{
new SQLiteParameter("@hash", hash)
});
 
var note = string.Empty;
var note = string.Empty;
 
sqliteCommand.Prepare();
sqliteCommand.Prepare();
 
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
while (await sqlDataReader.ReadAsync(cancellationToken))
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
if (!(sqlDataReader["Note"] is DBNull))
while (await sqlDataReader.ReadAsync(cancellationToken))
{
note = (string)sqlDataReader["Note"];
}
 
Bitmap shot = null;
 
if (!(sqlDataReader["Shot"] is DBNull))
{
var readStream = sqlDataReader.GetStream(2);
 
readStream.Position = 0L;
 
using (var zipStream = new GZipStream(readStream, CompressionMode.Decompress))
if (!(sqlDataReader["Note"] is DBNull))
{
using (var image = Image.FromStream(zipStream))
{
shot = new Bitmap(image);
}
note = (string)sqlDataReader["Note"];
}
}
 
return new SnapshotPreview(hash, shot, note);
}
Bitmap shot = null;
 
return null;
}
}
}
}
 
/*
public MemoryStream RetrieveFileStream(string hash, CancellationToken cancellationToken)
{
var connectionString = new SQLiteConnectionStringBuilder
{
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
 
sqliteConnection.Open();
 
// Insert the file change.
using (var sqliteCommand = new SQLiteCommand(RetrieveDataFromHashSql, sqliteConnection))
{
sqliteCommand.Parameters.AddRange(new[]
{
new SQLiteParameter("@hash", hash)
});
 
sqliteCommand.Prepare();
 
using (var sqlDataReader = sqliteCommand.ExecuteReader())
{
 
while (sqlDataReader.Read())
{
using (var readStream = sqlDataReader.GetStream(1))
{
 
using (var memoryStream = new MemoryStream())
if (!(sqlDataReader["Shot"] is DBNull))
{
var readStream = sqlDataReader.GetStream(2);
 
readStream.Position = 0L;
 
readStream.CopyTo(memoryStream);
 
memoryStream.Position = 0L;
 
using (var zipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
using (var zipStream = new GZipStream(readStream, CompressionMode.Decompress))
{
 
var outputStream = new MemoryStream();
 
zipStream.CopyTo(outputStream);
 
outputStream.Position = 0L;
 
return outputStream;
using (var image = Image.FromStream(zipStream))
{
shot = new Bitmap(image);
}
}
}
 
return new SnapshotPreview(hash, shot, note);
}
 
return null;
}
 
return null;
}
}
}
finally
{
_databaseLock.Release();
}
}
*/
 
public async Task<MemoryStream> RetrieveFileStream(string hash, CancellationToken cancellationToken)
{
@@ -1145,53 +1180,61 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = 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.
using (var sqliteCommand = new SQLiteCommand(RetrieveDataFromHashSql, sqliteConnection))
{
sqliteCommand.Parameters.AddRange(new[]
// Insert the file change.
using (var sqliteCommand = new SQLiteCommand(RetrieveDataFromHashSql, sqliteConnection))
{
new SQLiteParameter("@hash", hash)
});
sqliteCommand.Parameters.AddRange(new[]
{
new SQLiteParameter("@hash", hash)
});
 
sqliteCommand.Prepare();
sqliteCommand.Prepare();
 
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
while (await sqlDataReader.ReadAsync(cancellationToken))
using (var sqlDataReader = await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
using (var readStream = sqlDataReader.GetStream(1))
while (await sqlDataReader.ReadAsync(cancellationToken))
{
using (var memoryStream = new MemoryStream())
using (var readStream = sqlDataReader.GetStream(1))
{
readStream.Position = 0L;
using (var memoryStream = new MemoryStream())
{
readStream.Position = 0L;
 
await readStream.CopyToAsync(memoryStream);
await readStream.CopyToAsync(memoryStream);
 
memoryStream.Position = 0L;
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();
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);
await zipStream.CopyToAsync(outputStream);
 
outputStream.Position = 0L;
outputStream.Position = 0L;
 
return outputStream;
return outputStream;
}
}
}
}
 
return null;
}
 
return null;
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task RelocateFile(string hash, string path, CancellationToken cancellationToken)
@@ -1201,17 +1244,18 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RelocateFileFromHashSql, sqliteConnection, dbTransaction))
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(RelocateFileFromHashSql, sqliteConnection, dbTransaction))
{
sqliteCommand.Parameters.AddRange(new[]
{
@@ -1221,19 +1265,27 @@
 
sqliteCommand.Prepare();
 
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
try
{
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
 
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
 
throw;
throw;
}
}
}
}
}
 
finally
{
_databaseLock.Release();
}
}
 
public async Task UpdateNote(string hash, string note, CancellationToken cancellationToken)
@@ -1243,17 +1295,18 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(UpdateNoteFromHashSql, sqliteConnection, dbTransaction))
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(UpdateNoteFromHashSql, sqliteConnection, dbTransaction))
{
sqliteCommand.Parameters.AddRange(new[]
{
@@ -1263,137 +1316,155 @@
 
sqliteCommand.Prepare();
 
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
try
{
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
 
dbTransaction.Commit();
dbTransaction.Commit();
 
SnapshotNoteUpdate?.Invoke(this, new SnapshotNoteUpdateSuccessEventArgs(note));
}
catch
{
dbTransaction.Rollback();
SnapshotNoteUpdate?.Invoke(this, new SnapshotNoteUpdateSuccessEventArgs(note));
}
catch
{
dbTransaction.Rollback();
 
SnapshotNoteUpdate?.Invoke(this, new SnapshotNoteUpdateFailureEventArgs());
SnapshotNoteUpdate?.Invoke(this, new SnapshotNoteUpdateFailureEventArgs());
 
throw;
throw;
}
}
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task<string> UpdateFile(string hash, byte[] data, CancellationToken cancellationToken)
{
using (var dataMemoryStream = new MemoryStream(data))
var connectionString = new SQLiteConnectionStringBuilder
{
var connectionString = new SQLiteConnectionStringBuilder
{
ConnectionString = DatabaseConnectionString
};
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
using (var dataMemoryStream = new MemoryStream(data))
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
using (var md5 = MD5.Create())
try
{
using (var hashMemoryStream = new MemoryStream())
using (var md5 = MD5.Create())
{
dataMemoryStream.Position = 0L;
await dataMemoryStream.CopyToAsync(hashMemoryStream);
using (var hashMemoryStream = new MemoryStream())
{
dataMemoryStream.Position = 0L;
await dataMemoryStream.CopyToAsync(hashMemoryStream);
 
hashMemoryStream.Position = 0L;
var recomputedHash = md5.ComputeHash(hashMemoryStream);
var hashHex = BitConverter.ToString(recomputedHash).Replace("-", "")
.ToLowerInvariant();
hashMemoryStream.Position = 0L;
var recomputedHash = md5.ComputeHash(hashMemoryStream);
var hashHex = BitConverter.ToString(recomputedHash).Replace("-", "")
.ToLowerInvariant();
 
using (var fileMemoryStream = new MemoryStream())
{
using (var fileZipStream =
new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
using (var fileMemoryStream = new MemoryStream())
{
dataMemoryStream.Position = 0L;
await dataMemoryStream.CopyToAsync(fileZipStream);
fileZipStream.Close();
using (var fileZipStream =
new GZipStream(fileMemoryStream, CompressionMode.Compress, true))
{
dataMemoryStream.Position = 0L;
await dataMemoryStream.CopyToAsync(fileZipStream);
fileZipStream.Close();
 
fileMemoryStream.Position = 0L;
fileMemoryStream.Position = 0L;
 
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(UpdateFileSql, sqliteConnection, dbTransaction))
{
sqliteCommand.Parameters.AddRange(new[]
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(UpdateFileSql, sqliteConnection,
dbTransaction))
{
new SQLiteParameter("@dataLength", fileMemoryStream.Length),
new SQLiteParameter("@recomputedHash", hashHex),
new SQLiteParameter("@hash", hash)
});
sqliteCommand.Parameters.AddRange(new[]
{
new SQLiteParameter("@dataLength", fileMemoryStream.Length),
new SQLiteParameter("@recomputedHash", hashHex),
new SQLiteParameter("@hash", hash)
});
 
sqliteCommand.Prepare();
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
}
sqliteCommand.Prepare();
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
}
 
using (var sqliteCommand =
new SQLiteCommand(GetRowFromHashSql, sqliteConnection,
dbTransaction))
{
sqliteCommand.Parameters.AddRange(new[]
using (var sqliteCommand =
new SQLiteCommand(GetRowFromHashSql, sqliteConnection,
dbTransaction))
{
new SQLiteParameter("@hash", hashHex)
});
sqliteCommand.Parameters.AddRange(new[]
{
new SQLiteParameter("@hash", hashHex)
});
 
sqliteCommand.Prepare();
sqliteCommand.Prepare();
 
using (var sqlDataReader =
await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
while (await sqlDataReader.ReadAsync(cancellationToken))
using (var sqlDataReader =
await sqliteCommand.ExecuteReaderAsync(cancellationToken))
{
if (sqlDataReader["id"] is long rowId)
while (await sqlDataReader.ReadAsync(cancellationToken))
{
using (var sqliteBlob = SQLiteBlob.Create(sqliteConnection,
"main",
"Snapshots",
"Data",
rowId, false))
if (sqlDataReader["id"] is long rowId)
{
var fileMemoryStreamData = fileMemoryStream.ToArray();
using (var sqliteBlob = SQLiteBlob.Create(
sqliteConnection,
"main",
"Snapshots",
"Data",
rowId, false))
{
var fileMemoryStreamData =
fileMemoryStream.ToArray();
 
sqliteBlob.Write(fileMemoryStreamData,
fileMemoryStreamData.Length,
0);
sqliteBlob.Write(fileMemoryStreamData,
fileMemoryStreamData.Length,
0);
}
}
}
}
}
}
 
dbTransaction.Commit();
dbTransaction.Commit();
 
SnapshotDataUpdate?.Invoke(this,
new SnapshotDataUpdateSuccessEventArgs(hash, hashHex));
SnapshotDataUpdate?.Invoke(this,
new SnapshotDataUpdateSuccessEventArgs(hash, hashHex));
 
return hashHex;
return hashHex;
}
}
}
}
}
}
catch
{
dbTransaction.Rollback();
catch
{
dbTransaction.Rollback();
 
SnapshotDataUpdate?.Invoke(this, new SnapshotDataUpdateFailureEventArgs(hash));
SnapshotDataUpdate?.Invoke(this, new SnapshotDataUpdateFailureEventArgs(hash));
 
throw;
throw;
}
}
}
}
}
finally
{
_databaseLock.Release();
}
}
 
public async Task UpdateHash(string from, string to, CancellationToken cancellationToken)
@@ -1403,17 +1474,18 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(UpdateHashFromHashSql, sqliteConnection, dbTransaction))
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
// Insert the file change.
using (var sqliteCommand =
new SQLiteCommand(UpdateHashFromHashSql, sqliteConnection, dbTransaction))
{
sqliteCommand.Parameters.AddRange(new[]
{
@@ -1423,19 +1495,26 @@
 
sqliteCommand.Prepare();
 
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
try
{
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
 
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
 
throw;
throw;
}
}
}
}
}
finally
{
_databaseLock.Release();
}
}
 
#endregion
@@ -1442,7 +1521,7 @@
 
#region Private Methods
 
private static async Task SetAutoVacuum(CancellationToken cancellationToken)
private async Task SetAutoVacuum(CancellationToken cancellationToken)
{
var connectionString = new SQLiteConnectionStringBuilder
{
@@ -1449,20 +1528,28 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection =
new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection =
new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
// Set auto vacuum.
using (var sqliteCommand = new SQLiteCommand(SetAutoVacuumSql, sqliteConnection))
{
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
// Set auto vacuum.
using (var sqliteCommand = new SQLiteCommand(SetAutoVacuumSql, sqliteConnection))
{
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
}
}
}
finally
{
_databaseLock.Release();
}
}
 
private static async Task CreateDatabase(CancellationToken cancellationToken)
private async Task CreateDatabase(CancellationToken cancellationToken)
{
var connectionString = new SQLiteConnectionStringBuilder
{
@@ -1469,30 +1556,38 @@
ConnectionString = DatabaseConnectionString
};
 
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
await _databaseLock.WaitAsync(cancellationToken);
try
{
await sqliteConnection.OpenAsync(cancellationToken);
using (var sqliteConnection = new SQLiteConnection(connectionString.ConnectionString))
{
await sqliteConnection.OpenAsync(cancellationToken);
 
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
// Create the table if it does not exist.
using (var sqliteCommand = new SQLiteCommand(CreateTableSql, sqliteConnection, dbTransaction))
using (var dbTransaction = sqliteConnection.BeginTransaction())
{
try
// Create the table if it does not exist.
using (var sqliteCommand = new SQLiteCommand(CreateTableSql, sqliteConnection, dbTransaction))
{
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
try
{
await sqliteCommand.ExecuteNonQueryAsync(cancellationToken);
 
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
dbTransaction.Commit();
}
catch
{
dbTransaction.Rollback();
 
throw;
throw;
}
}
}
}
}
finally
{
_databaseLock.Release();
}
}
 
#endregion