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); }