[InlineData("Backup_12Nov2013_2043")] // Wrong timestamp format (missing trailing "Z")
public void ReturnsNullForNonMatchingDatabaseName(string name)
{
Assert.Null(DatabaseBackup <SqlDatabase> .Create(new SqlDatabase()
{
name = name
}));
}
private void btnSelectData_Click(object sender, EventArgs e)
{
if (tbConnectionSource.Text.Length > 0 && cbDatabaseSource.SelectedIndex != -1)
{
backup = new DatabaseBackup(db_source, cbDatabaseSource.SelectedItem.ToString(), settings.rowPerInsert, settings.insertColumnName);
backup.UpdateStatus += new EventHandler <string>(UpdateStatus);
frmDataSelector frmDataSelector = new frmDataSelector(db_source, cbDatabaseSource.SelectedItem.ToString(), ref backup);
if (frmDataSelector.ShowDialog() == DialogResult.OK)
{
string schema = string.Empty;
SaveFileDialog sfd = new SaveFileDialog {
FileName = cbDatabaseSource.SelectedItem.ToString(),
Filter = "SQL (*.sql)|*.sql|Text (*.txt)|*.txt"
};
if (sfd.ShowDialog() == DialogResult.OK)
{
DisableForm();
if (backup.GetDatabase())
{
StreamWriter sw = File.CreateText(sfd.FileName);
#if DEBUG
backup.GetSchema(sw);
#else
new Thread(() => { backup.getSchema(sw); }).Start();
#endif
}
}
}
}
}
public override Task DoWork(CancellationToken cancellationToken)
{
Task.Run(async() =>
{
_logger.LogInformation($"{nameof(DatabaseBackupCronJob)} Running Job");
using IServiceScope? services = _serviceScopeFactory.CreateScope();
using IAIDungeonPromptsDbContext? dbContext =
services.ServiceProvider.GetRequiredService <IAIDungeonPromptsDbContext>();
if (dbContext == null)
{
_logger.LogWarning($"{nameof(DatabaseBackupCronJob)}: Could not get DbContext from services");
return;
}
using BackupDbContext? backupContext = services.ServiceProvider.GetRequiredService <BackupDbContext>();
if (backupContext == null)
{
_logger.LogWarning(
$"{nameof(DatabaseBackupCronJob)}: Could not get Backup DbContext from services");
return;
}
await DatabaseBackup.BackupDatabase(dbContext, backupContext, cancellationToken);
_logger.LogInformation($"{nameof(DatabaseBackupCronJob)} Job Complete");
});
return(Task.CompletedTask);
}
private void Conf_RestoreDlg_Load(object sender, EventArgs e)
{
dbBackup = new DatabaseBackup();
dbBackup.BackupProgress += dbBackup_OnBackupProgress;
dbBackup.BackupError += dbBackup_OnBackupDataError;
dbBackup.Completed += dbBackup_Completed;
if (backup)
{
dbBackup.BackupThumbs = backupThumbs;
}
else
{
dbBackup.RestoreThumbs = restoreThumbs;
dbBackup.EmulatorMergeType = emulatorMergeType;
dbBackup.GameMergeType = gameMergeType;
dbBackup.CleanRestore = CleanRestore;
}
worker = new Thread(new ThreadStart(delegate()
{
if (backup)
dbBackup.Backup(path);
else
dbBackup.Restore(path);
}));
worker.Start();
}
public int insertUpdateEmpGeneralDetails(DatabaseBE _objDatabase)
{
int returnvalue = 0;
try
{
if (_objDatabase.TaskID != 0)
{
var objDb = objEntity.DatabaseBackups.FirstOrDefault(z => z.TaskID == _objDatabase.TaskID);
objDb.ScheduleType = _objDatabase.ScheduleType;
objDb.Monday = _objDatabase.IsMonday;
objDb.Tuesday = _objDatabase.IsTuesday;
objDb.Wednesday = _objDatabase.IsWednesday;
objDb.Thursday = _objDatabase.IsThursday;
objDb.Friday = _objDatabase.IsFriday;
objDb.Saturday = _objDatabase.IsSaturday;
objDb.Sunday = _objDatabase.IsSunday;
objDb.TaskName = _objDatabase.TaskName;
objDb.Overright = _objDatabase.IsOverride;
objDb.StartTime = _objDatabase.TimeValue;
objDb.FolderName = _objDatabase.ServerPath;
objDb.LastModifiedOn = DateTime.Now;
objDb.Status = true;
objDb.LastModifiedBy = _objDatabase.LastModifiedBy;
objEntity.SaveChanges();
returnvalue = objDb.TaskID;
}
else
{
DatabaseBackup objDb = new DatabaseBackup();
objDb.TaskID = _objDatabase.TaskID;
objDb.ScheduleType = _objDatabase.ScheduleType;
objDb.Monday = _objDatabase.IsMonday;
objDb.Tuesday = _objDatabase.IsTuesday;
objDb.Wednesday = _objDatabase.IsWednesday;
objDb.Thursday = _objDatabase.IsThursday;
objDb.Friday = _objDatabase.IsFriday;
objDb.Saturday = _objDatabase.IsSaturday;
objDb.Sunday = _objDatabase.IsSunday;
objDb.TaskName = _objDatabase.TaskName;
objDb.Overright = _objDatabase.IsOverride;
objDb.StartTime = _objDatabase.TimeValue;
objDb.FolderName = _objDatabase.ServerPath;
objDb.AddedOn = DateTime.Now;
objDb.AddedBy = _objDatabase.AddedBy;
objDb.Status = true;
objEntity.AddToDatabaseBackups(objDb);
objEntity.SaveChanges();
returnvalue = objDb.TaskID;
}
return(returnvalue);
}
catch (Exception e)
{
return(0);
}
}
internal static string GetBackupFilename(DatabaseBackup dbBackup, string backupPath, DateTime backupTime)
{
var dbFilename = Path.GetFileNameWithoutExtension(dbBackup.DatabasePath);
var dbExt = Path.GetExtension(dbBackup.DatabasePath);
if (string.IsNullOrEmpty(dbExt))
{
dbExt = ".db";
}
return(Path.Join(backupPath, $"{dbFilename}.{dbBackup.DatabaseBackupId}.backup.{backupTime:yyyyMMddHHmmss}{dbExt}"));
}
public async Task AuditEventAsync(DatabaseBackup databaseBackup, string auditLog)
{
await _context.BackupAudits.AddAsync(new BackupAudit
{
DatabaseBackup = databaseBackup,
AuditLog = auditLog,
TimestampCreated = DateTime.UtcNow
});
await _context.SaveChangesAsync();
}
public void ParsesMatchingNameCorrectly(string name, string prefix, string expectedTimestamp)
{
var parsed = DatabaseBackup <SqlDatabase> .Create(new SqlDatabase()
{
name = name
});
Assert.NotNull(parsed);
Assert.Equal(prefix, parsed.Prefix);
Assert.Equal(expectedTimestamp, parsed.Timestamp.ToString("s"));
}
/// <summary>
/// Process returns a copy of the media database, and can be used to return SQL deltas to update
/// the local copy of the media database
/// </summary>
public void Process(UriWrapper uri, IHttpProcessor processor, User user)
{
// If ID set, return all queries >= this id
if (uri.Id != null)
{
processor.WriteJson(new DatabaseResponse(null, Injection.Kernel.Get <IDatabase>().QueryLogsSinceId((int)uri.Id)));
return;
}
// No id parameter, so send down the whole backup database
long databaseLastQueryId = -1;
string databaseFileName = DatabaseBackup.Backup(out databaseLastQueryId);
// Verify database filename present
if ((object)databaseFileName == null)
{
processor.WriteErrorHeader();
return;
}
try
{
// Read in entire database file
Stream stream = new FileStream(ServerUtility.RootPath() + databaseFileName, FileMode.Open, FileAccess.Read);
long length = stream.Length;
int startOffset = 0;
// Handle the Range header to start from later in the file if connection interrupted
if (processor.HttpHeaders.ContainsKey("Range"))
{
string range = (string)processor.HttpHeaders["Range"];
string start = range.Split(new char[] { '-', '=' })[1];
logger.IfInfo("Connection retried. Resuming from " + start);
startOffset = Convert.ToInt32(start);
}
// We send the last query id as a custom header
IDictionary <string, string> customHeader = new Dictionary <string, string>();
customHeader["WaveBox-LastQueryId"] = databaseLastQueryId.ToString();
// Send the database file
processor.WriteFile(stream, startOffset, length, "application/octet-stream", customHeader, true, new FileInfo(ServerUtility.RootPath() + databaseFileName).LastWriteTimeUtc);
stream.Close();
}
catch
{
// Send JSON on error
processor.WriteJson(new DatabaseResponse("Could not open backup database " + databaseFileName, null));
}
return;
}
private void txtusername_KeyDown(object sender, KeyEventArgs e)
{
if (e.Control && e.KeyCode == Keys.B)
{
DatabaseBackup db = new DatabaseBackup();
db.ShowDialog();
}
else if (e.Control && e.KeyCode == Keys.S)
{
SalesDataTaxCalculate sd = new SalesDataTaxCalculate();
sd.Show();
}
}
private void BtnDoBackup_Click(object sender, RoutedEventArgs e)
{
DatabaseBackup dtbk = new DatabaseBackup();
try
{
dtbk.DoBackup();
}
catch (FailedOperationException)
{
LblError.Content = "Cannot backup Azure Database, use Azure portal instead.";
}
}
public async Task <DatabaseBackup> StartAsync(StartDatabaseBackupRequest request)
{
Ensure.NotNull(request, nameof(request));
var id = await DatabaseBackupId.NextAsync(db.Context, request.DatabaseId);
var backup = new DatabaseBackup(
id: id,
bucketId: request.BucketId,
name: request.Name
);
await db.DatabaseBackups.InsertAsync(backup);
return(backup);
}
public frmDataSelector(proGEDIA.Utilities.Database database, string db_name, ref DatabaseBackup backup_settings)
{
this.database = database;
this.db_name = db_name;
this.backup_settings = backup_settings;
InitializeComponent();
for (int i = 0; i < dgvTableList.Columns.Count; i++)
{
dgvTableList.Columns[i].HeaderCell.Style.Alignment = DataGridViewContentAlignment.BottomCenter;
}
dgvTableList.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.None;
dgvTableList.AllowUserToResizeRows = false;
this.MinimumSize = this.Size;
}
protected internal override async Task <JobContinuation> Execute()
{
ServerName = String.IsNullOrEmpty(ServerName) ? Utils.GetSqlServerName(Config.Sql.Legacy.DataSource) : ServerName;
// Capture the current time in case the date changes during invocation
DateTimeOffset now = DateTimeOffset.UtcNow;
// Resolve the connection if not specified explicitly
Log.PreparingToClean(ServerName);
// Connect to the master database
using (var sql = CloudContext.Clients.CreateSqlManagementClient(Azure.GetCredentials(throwIfMissing: true)))
{
// Get online databases
Log.GettingDatabaseList(ServerName);
var dbs = (await sql.Databases.ListAsync(ServerName)).ToList();
Log.GotDatabases(dbs.Count, ServerName);
// Determine which of these are backups
var backups = dbs
.Select(d => DatabaseBackup <Database> .Create(d))
.Where(b => b != null && String.Equals(NamePrefix, b.Prefix, StringComparison.OrdinalIgnoreCase))
.ToList();
// Start collecting a list of backups we're going to keep
var keepers = new HashSet <DatabaseBackup <Database> >();
// Group backups by UTC Day
var backupsByDate = backups
.GroupBy(b => b.Timestamp.UtcDateTime.Date)
.OrderByDescending(g => g.Key);
// Keep the last backup from today and the max daily backups if any
var dailyBackups = backupsByDate
.Take(MaxDailyCopies ?? 1)
.Select(g => g.OrderBy(db => db.Timestamp).Last());
foreach (var keeper in dailyBackups)
{
keepers.Add(keeper);
}
// Keep the most recent backups based on MaxRunningBackups
foreach (var keeper in backups.OrderByDescending(b => b.Timestamp).Take(MaxRunningCopies ?? 1))
{
keepers.Add(keeper);
}
// Report keepers
foreach (var keeper in keepers)
{
Log.KeepingBackup(keeper.Db.Name);
}
// Delete the others!
foreach (var db in backups.Select(b => b.Db.Name).Except(keepers.Select(b => b.Db.Name), StringComparer.OrdinalIgnoreCase))
{
Log.DeletingBackup(db);
if (!WhatIf)
{
await sql.Databases.DeleteAsync(ServerName, db);
}
Log.DeletedBackup(db);
}
// Clean out CopyTemp databases older than 3 hours
var copytemps = dbs
.Where(db =>
db.Name.StartsWith("copytemp", StringComparison.OrdinalIgnoreCase) &&
db.CreationDate < DateTime.UtcNow.AddHours(-3));
foreach (var copytemp in copytemps)
{
Log.DeletingBackup(copytemp.Name);
if (!WhatIf)
{
await sql.Databases.DeleteAsync(ServerName, copytemp.Name);
}
Log.DeletedBackup(copytemp.Name);
}
}
return(Complete());
}
private async Task UploadLastBackupAsync(IDatabaseBackupRepository databaseBackupRepository, DatabaseBackup dbBackup, string backupPath, IDropboxUploadClient dropboxUploadClient)
{
var backupFile = new FileInfo(DatabaseBackupJob.GetBackupFilename(dbBackup, backupPath, dbBackup.LastBackupTime.GetValueOrDefault()));
if (!backupFile.Exists)
{
_logger.LogWarning($"Database backup file [{backupFile.FullName}] does not exist, cannot perform upload");
return;
}
_logger.LogInformation($"Uploading latest database backup [{dbBackup.DatabasePath}]: {backupFile}");
await dropboxUploadClient.UploadFileAsync(backupFile, $"{Path.GetFileName(dbBackup.DatabasePath)}.{dbBackup.DatabaseBackupId}");
_logger.LogInformation($"Successfully uploaded latest database backup: {dbBackup.DatabasePath}");
dbBackup.LastUploadToDropboxTime = DateTime.UtcNow;
await databaseBackupRepository.UpdateAsync(dbBackup);
}
public Task UpdateAsync(DatabaseBackup databaseBackup)
{
_context.DatabaseBackups.Update(databaseBackup);
return(_context.SaveChangesAsync());
}
private IEnumerable <string> PurgeBackupsInternal(DirectoryInfo backupPath, int backupsToKeep, DatabaseBackup backupToDelete)
{
if (!backupPath?.Exists ?? true)
{
yield break;
}
const string backupFileSegment = ".backup.";
foreach (var backup in backupPath
.GetFiles($"*{backupFileSegment}*")
.Select(fi =>
{
var nullValue = new { FileInfo = (FileInfo)null, BackupId = default(int), BackupDate = (DateTime?)null };
var backupIdx = fi.Name.LastIndexOf(backupFileSegment);
if (backupIdx < 0)
{
return(nullValue);
}
var filenameAndIdWithoutExt = fi.Name.Substring(0, backupIdx);
var filenameAndIdIdx = filenameAndIdWithoutExt.LastIndexOf('.');
if (filenameAndIdIdx < 0)
{
return(nullValue);
}
var filenameWithoutExt = filenameAndIdWithoutExt.Substring(0, filenameAndIdIdx);
var backupIdSegment = filenameAndIdWithoutExt.Substring(filenameAndIdIdx + 1);
if (!int.TryParse(backupIdSegment, out var backupId))
{
return(nullValue);
}
if (backupToDelete != null && (
backupId != backupToDelete.DatabaseBackupId ||
filenameWithoutExt != Path.GetFileNameWithoutExtension(backupToDelete.DatabasePath) ||
fi.Extension != Path.GetExtension(backupToDelete.DatabasePath)
))
{
return(nullValue);
}
var dateAndExt = fi.Name.Substring(backupIdx + backupFileSegment.Length);
var datePartIdx = dateAndExt.IndexOf('.');
if (datePartIdx < 0)
{
return(nullValue);
}
if (dateAndExt.Substring(datePartIdx + 1).Contains('.'))
{
return(nullValue);
}
var datePart = dateAndExt.Substring(0, datePartIdx);
if (!DateTime.TryParseExact(datePart, "yyyyMMddHHmmss", null, DateTimeStyles.AssumeUniversal, out var backupDateTime))
{
return(nullValue);
}
_logger.LogTrace($"Backup file: [{fi.Name}]");
return(new { FileInfo = fi, BackupId = backupId, BackupDate = (DateTime?)backupDateTime });
})
.Where(backups => backups.FileInfo != null)
.GroupBy(backups => backups.BackupId))
{
foreach (var toDelete in backup.OrderByDescending(b => b.BackupDate).Skip(backupsToKeep))
{
_logger.LogInformation($"Removing old backup: {toDelete.FileInfo.FullName}");
toDelete.FileInfo.Delete();
yield return(toDelete.FileInfo.FullName);
}
}
}
public IEnumerable <string> PurgeBackups(DirectoryInfo backupPath, int backupsToKeep, DatabaseBackup backupToDelete = null) => PurgeBackupsInternal(backupPath, backupsToKeep, backupToDelete).ToList();
private void run()
{
try {
runningStatus = Common.Messages.Information.Info001;
if (!DBConnector.getInstance().isSucceededConnection())
{
hasError = true;
ShowMessage.error(Common.Messages.Error.Error001);
}
else
{
runningStatus = Common.Messages.Information.Info002;
/*DatabaseBackup databaseBackup = new DatabaseBackup();
* databaseBackup.autoBackup();
* runningStatus = Common.Messages.Information.Info006;*/
runningStatus = Common.Messages.Information.Info007;
MetaManagerImpl metaManagerImpl = new MetaManagerImpl();
List <Meta> listMeta = metaManagerImpl.get(new Meta());
Dictionary <String, int> dic = new Dictionary <String, int>();
foreach (Meta meta in listMeta)
{
dic.Add(meta.Key, meta.Value);
}
runningStatus = Common.Messages.Information.Info008;
Session.Meta = dic;
runningStatus = Common.Messages.Information.Info009;
if (Session.Meta["isTrial"] == 1 && Session.Meta["trialLeft"] < 1)
{
runningStatus = Common.Messages.Information.Info010;
/*for(int i = 5; i > 0; i--) {
* runningStatus = Common.Messages.Information.Info010 + " " + i;
* Thread.Sleep(1000);
* }*/
ShowMessage.information(Common.Messages.Information.Info014);
hasError = true;
}
else if (Session.Meta["isTrial"] == 1)
{
runningStatus = Common.Messages.Information.Info011 + " " + Session.Meta["trialLeft"];
//Thread.Sleep(300);
//ShowMessage.information(Common.Messages.Information.Info011 + " " + Session.Meta["trialLeft"]);
metaManagerImpl.subtractTrial();
}
runningStatus = Common.Messages.Information.Info012;
PreferenceManagerImpl preferenceImpl = new PreferenceManagerImpl();
List <Preference> listPreference = preferenceImpl.get(new Preference());
Dictionary <String, String> dicP = new Dictionary <String, String>();
foreach (Preference preference in listPreference)
{
dicP.Add(preference.Key, preference.Value);
}
runningStatus = Common.Messages.Information.Info008;
Session.Preference = dicP;
DatabaseBackup databaseBackup = new DatabaseBackup();
databaseBackup.autoBackup();
isFinishedThread = true;
}
} catch (Exception) {
}
}
public Task DeleteAsync(DatabaseBackup databaseBackup)
{
_context.DatabaseBackups.Remove(databaseBackup);
return(_context.SaveChangesAsync());
}
private async Task BackupDbAsync(IDatabaseBackupRepository databaseBackupRepository, DatabaseBackup dbBackup, string backupPath,
IBackupAuditRepository backupAuditRepository)
{
if (!File.Exists(dbBackup.DatabasePath))
{
_logger.LogWarning($"Database file [{dbBackup.DatabasePath}] does not exist, cannot perform backup");
await backupAuditRepository.AuditEventAsync(dbBackup, "Backup failed: database file does not exist");
return;
}
var backupTime = DateTime.UtcNow;
var backupFilename = GetBackupFilename(dbBackup, backupPath, backupTime);
if (File.Exists(backupFilename))
{
_logger.LogError($"Backup file named [{backupFilename}] already exists, cannot perform backup");
await backupAuditRepository.AuditEventAsync(dbBackup, "Backup failed: file already exists");
return;
}
if (!Directory.Exists(backupPath))
{
Directory.CreateDirectory(backupPath);
}
using var dbToBackupConn = new SQLiteConnection($"Data Source={dbBackup.DatabasePath};FailIfMissing=True;");
await dbToBackupConn.OpenAsync();
using var dbCommand = dbToBackupConn.CreateCommand();
dbCommand.CommandType = CommandType.Text;
dbCommand.CommandText = $"vacuum into @vacuumInto";
var dbParam = dbCommand.CreateParameter();
dbParam.ParameterName = "@vacuumInto";
dbParam.Value = backupFilename;
dbCommand.Parameters.Add(dbParam);
await dbCommand.ExecuteNonQueryAsync();
_logger.LogInformation($"Successfully backed up database: {dbBackup.DatabasePath}");
dbBackup.LastBackupTime = backupTime;
await databaseBackupRepository.UpdateAsync(dbBackup);
}
private void BackupDB_Click(object sender, RoutedEventArgs e)
{
DatabaseBackup.Backup();
}
