public bool SaveTabPageCollection(TabPageDataCollection tabPageDataCollection, string password, bool saveToSharedFolder = false)
{
bool success = false;
try
{
var settings = new StorageManagerSettings(true, Environment.ProcessorCount, true, password);
var storageManager = new StorageManager(settings);
if (saveToSharedFolder)
{
string encodedConfigFilePath = GetFullPathToSharedDatabaseFile();
if (File.Exists(encodedConfigFilePath))
{
File.Delete(encodedConfigFilePath);
}
settings.Password = ConfSaltVal + settings.Password + ConfSaltVal2;
File.Copy(GetFullPathToDatabaseFile(), encodedConfigFilePath);
success = storageManager.SerializeObjectToFile(_appSettingsService.Settings, GetFullPathToSharedEncryptedConfigFile(), null);
}
else
{
success = storageManager.SerializeObjectToFile(tabPageDataCollection, GetFullPathToDatabaseFile(), null);
}
}
catch (Exception ex)
{
Log.Error(ex, "Error saving database");
}
return(success);
}
public FileSystemIOProvider()
{
InstanceId = Guid.NewGuid();
var settings = new StorageManagerSettings();
_storageManager = new StorageManager(settings);
}
public bool LoadFromFile(string filename, string password)
{
try
{
LoadedFromFile = true;
var settings = new StorageManagerSettings(false, Environment.ProcessorCount, true, password);
var storageManager = new StorageManager(settings);
var bookmarkContainer = storageManager.DeserializeObjectFromFile <BookmarkContainer>(filename, null);
if (bookmarkContainer?.RootFolder == null || string.IsNullOrEmpty(bookmarkContainer.ContainerId))
{
return(false);
}
int changesMade = PrepareContainer(bookmarkContainer);
_bookmarkContainer = bookmarkContainer;
RootFolder = _bookmarkContainer.RootFolder;
if (changesMade > 0)
{
Log.Information("Loaded Bookmaeksfile which had {changesMade} number of issues like faulty links. Resaving fixed file", changesMade);
SaveToFile(filename, password);
}
IsModified = true;
return(true);
}
catch (Exception ex)
{
Log.Error(ex, "BookmarkManager.LoadFromFile(string filename, string password) : " + ex.Message, ex);
}
return(false);
}
public bool SaveToFile(string filename, string password)
{
try
{
//Make a copy of the original file if the original file is above 1 kb
if (File.Exists(filename) && SystemIOHelper.GetFileSize(filename) > 1024)
{
string copyFilename = GeneralConverters.GetDirectoryNameFromPath(filename, true) + "BookmarksCopy.dat";
if (File.Exists(copyFilename))
{
File.Delete(copyFilename);
}
File.Copy(filename, copyFilename);
}
var settings = new StorageManagerSettings(false, Environment.ProcessorCount, true, password);
var storageManager = new StorageManager(settings);
bool successful = storageManager.SerializeObjectToFile(_bookmarkContainer, filename, null);
if (successful)
{
IsModified = false;
}
return(successful);
}
catch (Exception ex)
{
Log.Error(ex, "BookmarkManager.SaveToFile(string filename, string password) : " + ex.Message, ex);
return(false);
}
}
public SearchProfileRepository(IMapper mapper)
{
var settings = new StorageManagerSettings(true, Environment.ProcessorCount, true, DefaultPassword);
_storageManager = new StorageManager(settings);
_mapper = mapper;
}
private void SaveFileSystemImageToFile(FileSystemDrive fileSystemDrive, string path, string password)
{
var storageManagerProgress = new Progress <StorageManagerProgress>();
LoadAndSaveProgressBar.Visible = true;
storageManagerProgress.ProgressChanged += (s, e) =>
{
LoadAndSaveProgressBar.Value = e.ProgressPercentage;
LoadAndSaveProgressInfoLabel.Text = e.Text;
};
saveAsToolStripMenuItem.Enabled = false;
saveToolStripMenuItem.Enabled = false;
Task.Run(async() =>
{
var settings = new StorageManagerSettings(true, Environment.ProcessorCount, true, password);
var storageManager = new StorageManager(settings);
bool success = await storageManager.SerializeObjectToFileAsync(fileSystemDrive, path, storageManagerProgress);
OutcomeEventArgs outcomeEventArgs = success ? OutcomeEventArgs.Success : OutcomeEventArgs.Failure;
SaveFileEventHandler onSaveComplete = HandleSaveFileComplete;
BeginInvoke(onSaveComplete, this, outcomeEventArgs);
});
}
private bool SaveLocalDatabase()
{
if (_storageDictionary == null || !IsDirty)
{
return(false);
}
if (File.Exists(_localStorageFilePath))
{
File.Delete(_localStorageFilePath);
}
try
{
var settings = new StorageManagerSettings(false, Environment.ProcessorCount, true, LocalStoragePassword);
var storageManager = new StorageManager(settings);
bool res = storageManager.SerializeObjectToFile(_storageDictionary, _localStorageFilePath, null);
if (!res)
{
Log.Warning("Failed to serialize and save local reg dbfile");
}
return(res);
}
catch (Exception ex)
{
Log.Error(ex, "Exception when trying to deserialize LocalStorageRegistryAccess.dbfile");
}
return(false);
}
private static void Main(string[] args)
{
string testDataFilePath1 = Environment.CurrentDirectory + "\\orgImpl.7z";
string testDataFilePath2 = Environment.CurrentDirectory + "\\managedLZMA.7z";
const int dataLength = 0x19000000;
Stopwatch stopwatch = new Stopwatch();
SerializiableTestClass testClass = Utils.GetSerializiableTestClass(dataLength);
WriteToConsoleAndLog(string.Format("Test begining with {0} data using current C# single thread implementation", GeneralToolkitLib.Converters.GeneralConverters.FileSizeToStringFormater.ConvertFileSizeToString(dataLength)));
StorageManagerSettings settings = new StorageManagerSettings(true, 8, false, null);
StorageManager storageManager = new StorageManager(settings);
stopwatch.Start();
storageManager.SerializeObjectToFile(testClass, testDataFilePath1, null);
stopwatch.Stop();
WriteToConsoleAndLog("Test ended after: " + stopwatch.Elapsed);
ManagedIncludeDllCompression sevenZipCompression = new ManagedIncludeDllCompression();
stopwatch.Reset();
stopwatch.Start();
WriteToConsoleAndLog(string.Format("Test begining with {0} data using LZMA managed dll implementation", GeneralToolkitLib.Converters.GeneralConverters.FileSizeToStringFormater.ConvertFileSizeToString(dataLength)));
sevenZipCompression.TestManagedIncludeDllCompression(testDataFilePath2, testClass);
WriteToConsoleAndLog("Test ended after: " + stopwatch.Elapsed);
stopwatch.Stop();
Console.ReadLine();
}
public RestoreSyncDataResult RestoreBackupFromSyncFolder(string password)
{
var restoreSyncDataResult = new RestoreSyncDataResult();
string dbFilePath = GetFullPathToDatabaseFile();
try
{
if (!File.Exists(GetFullPathToSharedDatabaseFile()))
{
restoreSyncDataResult.ErrorCode = RestoreSyncDataErrorCodes.MemoDatabaseFileNotFound;
}
else if (!File.Exists(GetFullPathToSharedEncryptedConfigFile()))
{
restoreSyncDataResult.ErrorCode = restoreSyncDataResult.ErrorCode | RestoreSyncDataErrorCodes.ApplicationSettingsFileNotFound;
}
else
{
var settings = new StorageManagerSettings(true, Environment.ProcessorCount, true, ConfSaltVal + password + ConfSaltVal2);
var storageManager = new StorageManager(settings);
var secureMemoAppSettings = storageManager.DeserializeObjectFromFile <SecureMemoAppSettings>(GetFullPathToSharedEncryptedConfigFile(), null);
if (string.IsNullOrWhiteSpace(secureMemoAppSettings.ApplicationSaltValue) || string.IsNullOrWhiteSpace(secureMemoAppSettings.PasswordDerivedString))
{
restoreSyncDataResult.ErrorCode = restoreSyncDataResult.ErrorCode | RestoreSyncDataErrorCodes.ApplicationSettingsFileParseError;
restoreSyncDataResult.ErrorText = "Invalid password";
}
else
{
var s = _appSettingsService.Settings;
s.ApplicationSaltValue = secureMemoAppSettings.ApplicationSaltValue;
s.PasswordDerivedString = secureMemoAppSettings.PasswordDerivedString;
s.FontSettings = secureMemoAppSettings.FontSettings;
s.UseSharedSyncFolder = secureMemoAppSettings.UseSharedSyncFolder;
s.DefaultEmptyTabPages = secureMemoAppSettings.DefaultEmptyTabPages;
s.MainWindowHeight = secureMemoAppSettings.MainWindowHeight;
s.MainWindowWith = secureMemoAppSettings.MainWindowWith;
_appSettingsService.SaveSettings();
_appSettingsService.LoadSettings();
if (File.Exists(dbFilePath))
{
File.Delete(dbFilePath);
}
File.Copy(GetFullPathToSharedDatabaseFile(), dbFilePath);
restoreSyncDataResult.Successful = true;
}
}
}
catch (Exception ex)
{
Log.Error(ex, "Error when calling RestoreBackupFromSyncFolder() - {Message}", ex.Message);
restoreSyncDataResult.ErrorText = ex.Message;
}
return(restoreSyncDataResult);
}
public async Task LoadDatabaseAsync(string filename)
{
var settings = new StorageManagerSettings {
NumberOfThreads = Environment.ProcessorCount, Password = _passwordManager.GetPassword(_settingsManager.ApplicationSettings.DefaultKey), UseEncryption = true, UseMultithreading = true
};
StorageManager storage = new StorageManager(settings);
_dataCollection = await storage.DeserializeObjectFromFileAsync <FileHashCollectionDataModel>(filename, null);
}
public StorageManager(StorageManagerSettings settings)
{
_settings = settings;
if (settings == null)
{
throw new ArgumentException("StorageManagerSettings was null");
}
}
public async Task SaveDatabaseAsync(string filename)
{
var settings = new StorageManagerSettings {
NumberOfThreads = Environment.ProcessorCount, Password = _passwordManager.GetPassword(_settingsManager.ApplicationSettings.DefaultKey), UseEncryption = true, UseMultithreading = true
};
StorageManager storage = new StorageManager(settings);
_dataCollection.LastModified = DateTime.Now;
await storage.SerializeObjectToFileAsync(_dataCollection, filename, null);
}
public static StorageManagerSettings GetDefaultSettings()
{
StorageManagerSettings settings = new StorageManagerSettings
{
NumberOfThreads = 1,
UseEncryption = false,
Password = null,
UseMultithreading = false,
};
return(settings);
}
public TabPageDataCollection LoadTabPageCollection(string password)
{
TabPageDataCollection tabPageDataCollection = null;
try
{
var settings = new StorageManagerSettings(true, Environment.ProcessorCount, true, password);
var storageManager = new StorageManager(settings);
tabPageDataCollection = storageManager.DeserializeObjectFromFile <TabPageDataCollection>(GetFullPathToDatabaseFile(), null);
}
catch (Exception ex)
{
Log.Error(ex, "Error loading database");
}
return(tabPageDataCollection);
}
public void TestAsyncCompression()
{
string testFilePattern = @"c:\temp\testFile{0}.lzmc";
const int numberOfFiles = 5;
StorageManagerSettings storageManagerSettings = new StorageManagerSettings
{
UseMultithreading = true,
NumberOfThreads = 8,
UseEncryption = false,
Password = null
};
StorageManager storageManager = new StorageManager(storageManagerSettings);
List <SerializiableTestClass> testClasses = new List <SerializiableTestClass>();
Random rnd = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue));
for (int i = 0; i < numberOfFiles; i++)
{
int minSize = 0x100000 * 1;
int maxSize = 0x100000 * 10;
testClasses.Add(GetSerializiableTestClass(rnd.Next(minSize, maxSize)));
}
int testFileIndex = 1;
var taskList = new List <Task>();
foreach (SerializiableTestClass testClass in testClasses)
{
string fileName = string.Format(testFilePattern, testFileIndex);
var compressionTask = storageManager.SerializeObjectToFileAsync(testClass, fileName, null);
compressionTask.GetAwaiter().OnCompleted(delegate { Console.WriteLine(@"TaskId {0} completed completed with result: {1}", compressionTask.Id, compressionTask.Result); });
taskList.Add(compressionTask);
testFileIndex++;
}
while (!taskList.All(t => t.IsCompleted))
{
Task.WaitAny(taskList.ToArray());
}
}
public bool SaveTabPageCollection(TabPageDataCollection tabPageDataCollection, string password)
{
bool success = false;
try
{
var settings = new StorageManagerSettings(true, Environment.ProcessorCount, true, password);
var storageManager = new StorageManager(settings);
success = storageManager.SerializeObjectToFile(tabPageDataCollection, GetFullPathToDatabaseFile(), null);
}
catch (Exception ex)
{
Log.Error(ex, "Error saving database");
}
FoundDatabaseErrors = false;
return(success);
}
public void TestMultithreadCompression()
{
StorageManagerSettings storageManagerSettings = StorageManagerSettings.GetDefaultSettings();
storageManagerSettings.UseMultithreading = true;
storageManagerSettings.NumberOfThreads = 8;
storageManagerSettings.UseEncryption = false;
StorageManager storageManager = new StorageManager(storageManagerSettings);
SerializiableTestClass testClass = GetSerializiableTestClass(0x100000 * 100); //100 Mb
//SerializableTextDataClass tesTextDataClass = new SerializableTextDataClass();
bool compressionSuccessful = storageManager.SerializeObjectToFile(testClass, @"c:\temp\testdata.lzmc", null);
Assert.IsTrue(compressionSuccessful, "Failed to compress file");
SerializiableTestClass testClassRead = storageManager.DeserializeObjectFromFile <SerializiableTestClass>(@"c:\temp\testdata.lzmc", null);
Assert.IsNotNull(testClassRead, "Failed to decode file");
}
private void LoadFileSystemImageFromFile(string path, string password)
{
var storageManagerProgress = new Progress <StorageManagerProgress>();
LoadAndSaveProgressBar.Visible = true;
LoadAndSaveProgressInfoLabel.Visible = true;
openToolStripMenuItem.Enabled = false;
storageManagerProgress.ProgressChanged += (s, e) =>
{
LoadAndSaveProgressBar.Value = e.ProgressPercentage;
LoadAndSaveProgressInfoLabel.Text = e.Text;
};
Task.Run(async() =>
{
var settings = new StorageManagerSettings(true, Environment.ProcessorCount, true, password);
var storageManager = new StorageManager(settings);
_currentFileSystemDrive = await storageManager.DeserializeObjectFromFileAsync <FileSystemDrive>(path, storageManagerProgress);
Invoke(new EventHandler(HandleOpenFileComplete));
});
}
public bool LoadFromFileAndAppendBookmarks(string filename, string password)
{
try
{
LoadedFromFile = true;
var settings = new StorageManagerSettings(false, Environment.ProcessorCount, true, password);
var storageManager = new StorageManager(settings);
var bookmarkContainer = storageManager.DeserializeObjectFromFile <BookmarkContainer>(filename, null);
//storageManager.DeserializeObjectFromFile throws exception if the password is Incorrect and deserialization fails
//just in case bookmarkContainer is null
if (bookmarkContainer?.RootFolder == null || string.IsNullOrEmpty(bookmarkContainer.ContainerId))
{
throw new Exception("LoadFromFileAndAppendBookmarks failed, bookmarkContainer was null");
}
PrepareContainer(bookmarkContainer);
if (_bookmarkContainer == null)
{
_bookmarkContainer = bookmarkContainer;
}
else
{
RecursiveAdd(_bookmarkContainer.RootFolder, bookmarkContainer.RootFolder);
}
RootFolder = _bookmarkContainer.RootFolder;
IsModified = true;
return(true);
}
catch (Exception ex)
{
Log.Error(ex, "BookmarkManager.LoadFromFile(string filename, string password) : " + ex.Message);
}
return(false);
}
public void TestMultithreadCompressionWithEncryption()
{
StorageManagerSettings storageManagerSettings = new StorageManagerSettings
{
UseMultithreading = true,
NumberOfThreads = 8,
UseEncryption = true,
Password = "******"
};
StorageManager storageManager = new StorageManager(storageManagerSettings);
SerializiableTestClass testClass = GetSerializiableTestClass(0x100000 * 100); //100 Mb
bool compressionSuccessful = storageManager.SerializeObjectToFile(testClass, @"c:\temp\testdata.lzmc", null);
Assert.IsTrue(compressionSuccessful, "Failed to compress file");
//storageManagerSettings.Password = "******";
SerializiableTestClass testClassRead = storageManager.DeserializeObjectFromFile <SerializiableTestClass>(@"c:\temp\testdata.lzmc", null);
Assert.IsNotNull(testClassRead, "Failed to decode file");
}
private bool LoadLocalDatabase()
{
if (File.Exists(_localStorageFilePath))
{
try
{
var settings = new StorageManagerSettings(false, Environment.ProcessorCount, true, LocalStoragePassword);
var storageManager = new StorageManager(settings);
_storageDictionary = storageManager.DeserializeObjectFromFile <Dictionary <string, object> >(_localStorageFilePath, null);
return(true);
}
catch (Exception ex)
{
Log.Error(ex, "Exception when trying to deserialize LocalStorageRegistryAccess.dbfile");
}
}
else
{
_storageDictionary = new Dictionary <string, object>();
}
return(false);
}
