public void SetUp() { _tempDir = new DirectoryInfo(@"C:\Temp\Gu.Persist"); _setting = new BackupSettings(true, _tempDir, ".bak", BackupSettings.DefaultTimeStampFormat, false, 1, Int32.MaxValue); _file = _tempDir.CreateFileInfoInDirectory("Meh.cfg"); _backup = _tempDir.CreateFileInfoInDirectory("Meh.bak"); _backup1 = _tempDir.CreateFileInfoInDirectory(string.Format("Meh{0}.bak", new DateTime(2015, 06, 13, 21, 38, 00).ToString(BackupSettings.DefaultTimeStampFormat, CultureInfo.InvariantCulture))); _backup2 = _tempDir.CreateFileInfoInDirectory(string.Format("Meh{0}.bak", new DateTime(2015, 06, 13, 21, 37, 00).ToString(BackupSettings.DefaultTimeStampFormat, CultureInfo.InvariantCulture))); _backup3 = _tempDir.CreateFileInfoInDirectory(string.Format("Meh{0}.bak", new DateTime(2015, 06, 12, 21, 38, 00).ToString(BackupSettings.DefaultTimeStampFormat, CultureInfo.InvariantCulture))); _backup4 = _tempDir.CreateFileInfoInDirectory(string.Format("Meh{0}.bak", new DateTime(2015, 06, 11, 21, 38, 00).ToString(BackupSettings.DefaultTimeStampFormat, CultureInfo.InvariantCulture))); _backup5 = _tempDir.CreateFileInfoInDirectory(string.Format("Meh{0}.bak", new DateTime(2015, 06, 10, 21, 38, 00).ToString(BackupSettings.DefaultTimeStampFormat, CultureInfo.InvariantCulture))); _otherBackup = _tempDir.CreateFileInfoInDirectory(string.Format("Other{0}.bak", new DateTime(2015, 06, 13, 21, 38, 00).ToString(BackupSettings.DefaultTimeStampFormat, CultureInfo.InvariantCulture))); _softDelete = _tempDir.CreateFileInfoInDirectory(string.Format("Meh{0}.bak.delete", new DateTime(2015, 06, 10, 21, 38, 00).ToString(BackupSettings.DefaultTimeStampFormat, CultureInfo.InvariantCulture))); _timestampedBackups = new FileInfo[] { _backup1, _backup2, _backup3, _backup4, _backup5 }; _file.Delete(); _backup.Delete(); foreach (var backup in _timestampedBackups) { backup.Delete(); } _otherBackup.Delete(); _otherBackup.VoidCreate(); _softDelete.VoidCreate(); _backuper = new Backuper(_setting); }
public override string Query() { LogOptions.GetLogger().Info("Starting to run mysqldump of database"); var settings = BackupSettings.GetInstance(); var executable = settings.Executable; var arguments = $"-u {settings.User} -p{settings.Password} {settings.Database}"; LogOptions.GetLogger().Info("Starting dump {executable} {arguments}", executable, arguments); try { var processStartInfo = new ProcessStartInfo { FileName = executable, Arguments = arguments, RedirectStandardError = true, RedirectStandardOutput = true, CreateNoWindow = true, UseShellExecute = false }; var p = Process.Start(processStartInfo); var standardOutput = p?.StandardOutput.ReadToEnd(); p?.WaitForExit(); return(standardOutput); } catch (Exception e) { LogOptions.GetLogger().Fatal(e, "Exception in dump mysql database {message}", e.Message); return(string.Empty); } }
public BackupTests() { Directory = new DirectoryInfo(@"C:\Temp\Gu.Settings\" + GetType().Name); Directory.CreateIfNotExists(); Setting = new BackupSettings(Directory, true, BackupSettings.DefaultExtension, BackupSettings.DefaultTimeStampFormat, false, 2, 3); File = Directory.CreateFileInfoInDirectory("Meh.cfg"); SoftDelete = File.WithAppendedExtension(FileHelper.SoftDeleteExtension); Backup = Directory.CreateFileInfoInDirectory("Meh.bak"); BackupOneMinuteOld = Backup.WithTimeStamp(DateTime.Now.AddMinutes(-1), Setting); BackupOneHourOld = Backup.WithTimeStamp(DateTime.Now.AddHours(-1), Setting); BackupOneDayOld = Backup.WithTimeStamp(DateTime.Now.AddDays(-1), Setting); BackupOneMonthOld = Backup.WithTimeStamp(DateTime.Now.AddMonths(-1), Setting); BackupOneYearOld = Backup.WithTimeStamp(DateTime.Now.AddYears(-1), Setting); OtherBackup = Directory.CreateFileInfoInDirectory("Other.bak").WithTimeStamp(DateTime.Now.AddHours(1), Setting); TimestampedBackups = new[] { BackupOneMinuteOld, BackupOneHourOld, BackupOneDayOld, BackupOneMonthOld, BackupOneYearOld }; }
private static bool CopyFileForBackup(BackupSettings config, String sDst, String item, Logger log) { SafeNativeMethods.CopyFileFlags dwCopyFlags = 0; if (config.IgnoreEncryption) { dwCopyFlags = SafeNativeMethods.CopyFileFlags.COPY_FILE_ALLOW_DECRYPTED_DESTINATION; } bool pbCancel = false; SafeNativeMethods.CopyProgressRoutine cb = new SafeNativeMethods.CopyProgressRoutine(callback); StartTimeCopy = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond; //CopyFileEx //https://msdn.microsoft.com/en-us/library/windows/desktop/aa363852%28v=vs.85%29.aspx log("Starting copying..."); bool bOK = SafeNativeMethods.CopyFileEx(item, sDst, cb, IntPtr.Zero, ref pbCancel, dwCopyFlags); if (!bOK) { log("Failed to copy file: " + new Win32Exception(Marshal.GetLastWin32Error()).Message); } return(bOK); }
private /*async*/ void startAsyncWork() { Console.WriteLine("DoWork Starting"); //await Task.Run(() => Task t = Task.Factory.StartNew(() => { int iError = 0; BackupSettings config = BackupSettingsDao.loadSettings(); BackupTool.setFileLabel(this.lblFilename); BackupTool.setProgressBar(this.pbCopyProgress); BackupTool.setTotalProgressBar(this.pbTotalProgress); BackupTool.setMegaByesPerSecondLabel(this.lblMegaBytesPerSecond); if (config != null && config.LastRun == null) { startCountdown(config, LogToScreen); iError = BackupTool.tryBackup(config, LogToScreen); } else if (config != null && config.LastRun.AddDays(config.Interval) <= DateTime.Now) { startCountdown(config, LogToScreen); iError = BackupTool.tryBackup(config, LogToScreen); } if (iError == 0) { Application.Exit(); } else { BackupTool.CanExit = true; //allow manual closing } }); }
/// <summary> /// Deletes any target files that are not listed in the source array. /// </summary> private void DeleteSourceFilesFromTarget(IEnumerable <string> sourceFiles, DirectoryInfo targetDirInfo) { // Get names only as lowercase for comparison string[] sourceFileNames = sourceFiles.Select(f => Path.GetFileName(f).ToLower()).ToArray(); // Get full paths to target (maintain case, UNIX names can be case sensitive.) string[] targetFiles = Directory.EnumerateFiles(targetDirInfo.FullName, "*.*", SearchOption.TopDirectoryOnly).ToArray(); // Need to check for files that exist in target but not in source foreach (string file in targetFiles) { // Compare names as lowercase string nameOnly = Path.GetFileName(file).ToLower(); // Only name will match, full paths are from different locations bool remove = !sourceFileNames.Contains(nameOnly); // Remove if ext is now excluded remove |= BackupSettings.IsFileTypeExcluded(file); // Remove if hidden options changed remove |= BackupSettings.IgnoreHiddenFiles && (File.GetAttributes(file) & FileAttributes.Hidden) > 0; if (remove) { // Delete using full path DeleteFile(file); } } }
/// <summary> /// Saves the current settings from the form to disk /// </summary> /// <returns>true, if save action was successful</returns> private bool saveSettings() { //preserve hidden flags //BackupSettings config = BackupSettingsDao.loadSettings(); if (config == null) { config = new BackupSettings(); } config.DestinationPath = txtDestination.Text; config.Interval = (int)numInterval.Value; config.BackupProgram = txtBackupExe.Text; config.BackupPrefix = txtPrefix.Text; config.BackupSuffix = txtSuffix.Text; config.PostBackupCmd = txtPostBackupCmd.Text; config.BackupAll = cbxBackupAll.Checked; config.CountdownSeconds = (int)numCountdown.Value; if (String.IsNullOrEmpty(txtLastBackup.Text)) { config.LastRun = DateTime.MinValue; } config.Items.Clear(); for (int i = 0; i < lvStores.Items.Count; i++) { if (lvStores.Items[i].Checked) { config.Items.Add(lvStores.Items[i].Text); } } return(BackupSettingsDao.saveSettings(config)); }
public DatabaseBackupService(DatabaseRepository database, IConfiguration configuration) { this.database = database; settings = new BackupSettings(); configuration.Bind("BackupSettings", settings); }
public BackupTests() { this.Directory = new DirectoryInfo(@"C:\Temp\Gu.Persist\" + this.GetType().Name); this.Directory.CreateIfNotExists(); this.File = this.Directory.CreateFileInfoInDirectory("Meh.cfg"); this.SoftDelete = this.File.WithAppendedExtension(FileHelper.SoftDeleteExtension); this.Backup = this.Directory.CreateFileInfoInDirectory("Meh.bak"); var settings = new BackupSettings(this.Directory.FullName, BackupSettings.DefaultExtension, BackupSettings.DefaultTimeStampFormat, 3, 3); this.BackupOneMinuteOld = this.Backup.WithTimeStamp(DateTime.Now.AddMinutes(-1), settings); this.BackupOneHourOld = this.Backup.WithTimeStamp(DateTime.Now.AddHours(-1), settings); this.BackupOneDayOld = this.Backup.WithTimeStamp(DateTime.Now.AddDays(-1), settings); this.BackupOneMonthOld = this.Backup.WithTimeStamp(DateTime.Now.AddMonths(-1), settings); this.BackupOneYearOld = this.Backup.WithTimeStamp(DateTime.Now.AddYears(-1), settings); this.OtherBackup = this.Directory.CreateFileInfoInDirectory("Other.bak").WithTimeStamp(DateTime.Now.AddHours(1), settings); this.TimestampedBackups = new[] { this.BackupOneMinuteOld, this.BackupOneHourOld, this.BackupOneDayOld, this.BackupOneMonthOld, this.BackupOneYearOld }; }
public void GetTimeStamp(string fileName) { var file = new FileInfo(fileName); var setting = new BackupSettings(true, file.Directory, ".bak", BackupSettings.DefaultTimeStampFormat, false, 1, Int32.MaxValue); var timeStamp = BackupFile.GetTimeStamp(file, setting); Assert.AreEqual(new DateTime(2015, 06, 13, 17, 05, 15), timeStamp); }
public void CreateForNoTimestamp(string fileName, string expected) { var file = new FileInfo(fileName); var setting = new BackupSettings(true, file.Directory, ".bak", null, false, 1, Int32.MaxValue); var backup = BackupFile.CreateFor(file, setting); Assert.AreEqual(expected, backup.FullName); }
/// <summary> /// Creates a backuper for the given settings. /// </summary> /// <remarks> /// If <paramref name="setting"/> is null a <see cref="NullBackuper"/> is returned. /// </remarks> /// <param name="setting">The setting to use for backups.</param> /// <returns></returns> public static IBackuper Create(BackupSettings setting) { if (setting != null) { return(new Backuper(setting)); } return(NullBackuper.Default); }
private static JsonRepository CreateJsonRepository() { var jsonSerializerSettings = JsonRepositorySettings.DefaultJsonSettings; var backupSettings = new BackupSettings(Directories.DefaultBackup, 10, 2); var jsonRepositorySettings = new JsonRepositorySettings(jsonSerializerSettings, true, true, backupSettings); return(new JsonRepository(jsonRepositorySettings)); }
public async Task <IActionResult> BackupSave(BackupSettings settings) { if (ModelState.IsValid) { await _settingsService.UpdateBackupSettings(settings); } return(RedirectToAction("Backup", "Home")); }
public void CreateFor(string expected) { this.File.CreatePlaceHolder(); var backupSettings = new BackupSettings(this.Directory.FullName, BackupSettings.DefaultExtension, BackupSettings.DefaultTimeStampFormat, 1, 1); var backup = BackupFile.CreateFor(this.File, backupSettings); StringAssert.IsMatch(expected, backup.FullName); }
public void CreateForNoTimestamp(string expected) { this.File.CreatePlaceHolder(); var setting = new BackupSettings(this.File.DirectoryName, BackupSettings.DefaultExtension, null, 1, int.MaxValue); var backup = BackupFile.CreateFor(this.File, setting); Assert.AreEqual(expected, backup.FullName); }
public void CreateForNoTimestamp(string expected) { File.VoidCreate(); var setting = new BackupSettings(File.Directory, true, BackupSettings.DefaultExtension, null, false, 1, Int32.MaxValue); var backup = BackupFile.CreateFor(File, setting); Assert.AreEqual(expected, backup.FullName); }
public void GetTimeStamp(string fileName) { var file = new FileInfo(fileName); var setting = new BackupSettings(this.Directory.FullName, BackupSettings.DefaultExtension, BackupSettings.DefaultTimeStampFormat, 1, int.MaxValue); var timeStamp = file.GetTimeStamp(setting); Assert.AreEqual(new DateTime(2015, 06, 13, 17, 05, 15), timeStamp); }
protected override void OnExecuting() { foreach (var extraPath in BackupSettings.GetInstance().CopyBackupsTo) { var destinationPath = Path.Combine(extraPath, _subPath); CopyFile(destinationPath); } }
/// <summary> Initializes a new instance of the <see cref="RepositorySettings"/> class. </summary> public RepositorySettings( string directory, bool isTrackingDirty, BackupSettings backupSettings, string extension = ".cfg", string tempExtension = ".tmp") : base(directory, isTrackingDirty, backupSettings, extension, tempExtension) { }
public void RoundtripBackupSettingsWithNullTimestampFormat() { var backupSettings = new BackupSettings(BackupDir.FullName, ".abc", null, 2, 3); var json = JsonConvert.SerializeObject(backupSettings); var roundtripped = JsonConvert.DeserializeObject <BackupSettings>(json); AssertProperties(backupSettings, roundtripped); Assert.IsTrue(JsonEqualsComparer <BackupSettings> .Default.Equals(backupSettings, roundtripped)); }
public static void CreateForNoTimestamp() { var file = CreateFile(); file.CreateFileOnDisk(); var setting = new BackupSettings(file.DirectoryName, BackupSettings.DefaultExtension, null, 1, int.MaxValue); var backup = BackupFile.CreateFor(file, setting); StringAssert.IsMatch(@"BackupFileTests\\CreateForNoTimestamp\.bak", backup.FullName); }
/// <summary> /// Initializes a new instance of the <see cref="DataRepositorySettings"/> class. /// </summary> public DataRepositorySettings( string directory, bool isTrackingDirty, bool saveNullDeletesFile, BackupSettings backupSettings, string extension = ".cfg", string tempExtension = ".tmp") : base(directory, isTrackingDirty, saveNullDeletesFile, backupSettings, extension, tempExtension) { }
public void RoundtripRepositorySettingsWithRepo() { var backupSettings = new BackupSettings(new DirectoryInfo(@"C:\Temp\Gu.Settings\" + GetType().Name + @"\Backup")); var directory = new DirectoryInfo(@"C:\Temp\Gu.Settings\" + GetType().Name); var settings = new XmlRepositorySettings(directory, true, true, backupSettings, ".cfg", ".tmp"); var repository = new XmlRepository(settings); repository.Save(settings); var repositorySettings = repository.Read <XmlRepositorySettings>(); }
public static void CreateFor() { var file = CreateFile(); file.CreateFileOnDisk(); var backupSettings = new BackupSettings(Directory.FullName, BackupSettings.DefaultExtension, BackupSettings.DefaultTimeStampFormat, 1, 1); var backup = BackupFile.CreateFor(file, backupSettings); StringAssert.IsMatch(@"BackupFileTests\\CreateFor\.\d\d\d\d_\d\d_\d\d_\d\d_\d\d_\d\d\.bak", backup.FullName); }
// zapisanie do pliku przesłanej konfiguracji public void SaveConfiguration(BackupConfigurationData backupConf, CallBackDel callBack) { BackupSettings settings; // jeżeli plik nie istnieje to jest tworzony i zapisywane są do niego dane if (!fileHasAnyData()) { try { using (var fs = new FileStream(xmlFilePath, FileMode.Open)) { settings = new BackupSettings(); backupConf.Id = randomIntGuid(); settings.ConfigurationList.Add(backupConf); xs.Serialize(fs, settings); } callBack(new CallBackModel { Success = true, Message = "Konfiguracja została zapisana !" }); } catch (Exception ex) { LogInfo.LogErrorWrite("Nie udało się zapisać konfiguracji backup'u do pustego pliku", ex); callBack(new CallBackModel { Success = false }); } } else // jeżeli plik istnieje to dane są 'dokładane' na koniec { try { using (var fs = new FileStream(xmlFilePath, FileMode.Open)) { settings = (BackupSettings)xs.Deserialize(fs); fs.SetLength(0); backupConf.Id = randomIntGuid(); settings.ConfigurationList.Add(backupConf); xs.Serialize(fs, settings); } callBack(new CallBackModel { Success = true, Message = "Konfiguracja została zapisana !" }); } catch (Exception ex) { LogInfo.LogErrorWrite("Nie udało się zapisać konfiguracji backup'u do pliku", ex); callBack(new CallBackModel { Success = false }); } } }
/// <summary> /// Waits, till outlook ends and then starts the backup process /// </summary> /// <param name="config">Stored configuration from outlook plugin</param> /// <param name="log">logging delegate to send error information</param> /// <returns>number of occurred errors</returns> public static int tryBackup(BackupSettings config, Logger log) { int iError = 0; if (config == null) { log("backup not configured"); return(0); } log("Starting backup...please wait..."); try { if (config.Items.Count > 0) { log("Check whether outlooks is still running ..."); if (WaitForProcessEnd(OUTLOOK_PROC, log)) { log("No outlook process found"); iError += doBackup(config, log); if (!String.IsNullOrEmpty(config.PostBackupCmd)) { int iRes = RunPostCmd(config.PostBackupCmd, config.ProfileName, log); iError += iRes; } } else { iError++; log("Error waiting for " + OUTLOOK_PROC); } } else { iError++; log("Error: no files for backup selected"); } //if no errors occurred, save current timestamp if (iError == 0) { config.LastRun = DateTime.Now; BackupSettingsDao.saveSettings(config); } } catch (InstanceAlreadyRunningException) { log("Backup already running..."); iError++; } return(iError); }
public BackupForm() { InitializeComponent(); // Load current settings this.settings = new BackupSettings(); settings.LoadSettings(); // Populate storage accounts UpdateStorageAccounts(); }
static int Main(string[] args) { int RetCode = 0; Dictionary <String, String> argsDict = new Dictionary <String, String>(); if (!parseArgs(args, argsDict)) { showHelp(args); return(0); } if (argsDict.ContainsKey("/register")) { RetCode = registerPlugin(true) ? 0 : 1; } else if (argsDict.ContainsKey("/registersetup")) { RetCode = registerPlugin(false) ? 0 : 1; } else if (argsDict.ContainsKey("/unregister")) { RetCode = unregisterPlugin() ? 0 : 1; } else if (argsDict.ContainsKey("/backupnow")) { int iError = 0; SafeNativeMethods.AttachConsole(SafeNativeMethods.ATTACH_PARENT_PROCESS); try { LogToConsole("Reading settings ..."); BackupSettings config = BackupSettingsDao.loadSettings(); LogToConsole("Reading settings finished"); iError = BackupTool.tryBackup(config, LogToConsole); } catch (Exception e) { LogToConsole(e.Message); LogToConsole(e.StackTrace); } SendKeys.SendWait("{ENTER}"); SafeNativeMethods.FreeConsole(); RetCode = iError; } else { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new frmMain()); } return(RetCode); }
public void SetUp() { this.setting = new BackupSettings( this.directoryInfo.FullName, BackupSettings.DefaultExtension, BackupSettings.DefaultTimeStampFormat, 3, 3); this.file = this.directoryInfo.CreateFileInfoInDirectory("Meh.cfg"); this.backupFile = this.file.WithNewExtension(this.setting.Extension); }
public SqlDatabasesBackup(BackupSettings settings, DatabaseBackupLogger logger, string[] databaseNames) { this.settings = settings; this.logger = logger; this.databaseNames = databaseNames; }
protected override void ApplySettings(HydraTaskSettings settings) { _settings = new BackupSettings(settings); if (settings.IsDefault) { _settings.Offset = 1; _settings.StartFrom = new DateTime(1900, 1, 1); _settings.Interval = TimeSpan.FromDays(1); _settings.Service = BackupServices.AwsS3; _settings.Address = RegionEndpoint.USEast1.SystemName; _settings.ServiceRepo = "stocksharp"; _settings.Login = string.Empty; _settings.Password = new SecureString(); } }