/// <exception cref="System.InvalidOperationException">
/// Thrown when the previous backup operation has not finished yet.
/// </exception>
private BackupOperation CreateBackupOperation(Models.BackupPlan plan)
{
var dao = new BackupRepository();
Models.Backup latest = dao.GetLatestByPlan(plan);
MustResumeLastOperation = latest != null && latest.NeedsResume();
if (MustResumeLastOperation && !Options.Resume)
{
string message = string.Format("The backup (#{0}) has not finished yet."
+ " If it's still running, please, wait until it finishes,"
+ " otherwise you should resume it manually.",
latest.Id);
throw new InvalidOperationException(message);
}
// Create new backup or resume the last unfinished one.
BackupOperation obj = MustResumeLastOperation
? new ResumeBackupOperation(latest) as BackupOperation
: new NewBackupOperation(plan) as BackupOperation;
obj.Updated += (sender2, e2) => BackupUpdateStatsInfo(e2.Status, e2.TransferStatus);
//obj.EventLog = ...
//obj.TransferListControl = ...
BackupUpdateStatsInfo(BackupOperationStatus.Unknown, TransferStatus.STOPPED);
return(obj);
}
public void OneTimeSetup()
{
var connectionFatory = TestUtilities.GetIntegrationConnectionFactory();
var generalSqlRepository = new GeneralSqlRepository();
this.backupRepository = new BackupRepository(connectionFatory, generalSqlRepository);
}
public OctopusAsyncRepository(IOctopusAsyncClient client, RepositoryScope repositoryScope = null)
{
Client = client;
Scope = repositoryScope ?? RepositoryScope.Unspecified();
Accounts = new AccountRepository(this);
ActionTemplates = new ActionTemplateRepository(this);
Artifacts = new ArtifactRepository(this);
Backups = new BackupRepository(this);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(this);
CertificateConfiguration = new CertificateConfigurationRepository(this);
Certificates = new CertificateRepository(this);
Channels = new ChannelRepository(this);
CommunityActionTemplates = new CommunityActionTemplateRepository(this);
Configuration = new ConfigurationRepository(this);
DashboardConfigurations = new DashboardConfigurationRepository(this);
Dashboards = new DashboardRepository(this);
Defects = new DefectsRepository(this);
DeploymentProcesses = new DeploymentProcessRepository(this);
Deployments = new DeploymentRepository(this);
Environments = new EnvironmentRepository(this);
Events = new EventRepository(this);
FeaturesConfiguration = new FeaturesConfigurationRepository(this);
Feeds = new FeedRepository(this);
Interruptions = new InterruptionRepository(this);
LibraryVariableSets = new LibraryVariableSetRepository(this);
Lifecycles = new LifecyclesRepository(this);
MachinePolicies = new MachinePolicyRepository(this);
MachineRoles = new MachineRoleRepository(this);
Machines = new MachineRepository(this);
Migrations = new MigrationRepository(this);
OctopusServerNodes = new OctopusServerNodeRepository(this);
PerformanceConfiguration = new PerformanceConfigurationRepository(this);
PackageMetadataRepository = new PackageMetadataRepository(this);
ProjectGroups = new ProjectGroupRepository(this);
Projects = new ProjectRepository(this);
ProjectTriggers = new ProjectTriggerRepository(this);
Proxies = new ProxyRepository(this);
Releases = new ReleaseRepository(this);
RetentionPolicies = new RetentionPolicyRepository(this);
Schedulers = new SchedulerRepository(this);
ServerStatus = new ServerStatusRepository(this);
Spaces = new SpaceRepository(this);
Subscriptions = new SubscriptionRepository(this);
TagSets = new TagSetRepository(this);
Tasks = new TaskRepository(this);
Teams = new TeamsRepository(this);
Tenants = new TenantRepository(this);
TenantVariables = new TenantVariablesRepository(this);
UserInvites = new UserInvitesRepository(this);
UserRoles = new UserRolesRepository(this);
Users = new UserRepository(this);
VariableSets = new VariableSetRepository(this);
Workers = new WorkerRepository(this);
WorkerPools = new WorkerPoolRepository(this);
ScopedUserRoles = new ScopedUserRoleRepository(this);
UserPermissions = new UserPermissionsRepository(this);
loadRootResource = new Lazy <Task <RootResource> >(LoadRootDocumentInner, true);
loadSpaceRootResource = new Lazy <Task <SpaceRootResource> >(LoadSpaceRootDocumentInner, true);
}
public void ScheduleBackupTasks(BackupSchedulerService backupSchedulerService)
{
Log.DebugFormat("started to schedule backups");
var backupsToSchedule = BackupRepository.GetBackupSchedules().Where(schedule => Schedule.IsToBeProcessed(schedule)).ToList();
Log.DebugFormat("{0} backups are to schedule", backupsToSchedule.Count);
foreach (var schedule in backupsToSchedule)
{
if (!backupSchedulerService.IsStarted)
{
return;
}
try
{
var tariff = PaymentManager.GetTariff(schedule.TenantId);
if (tariff.State < TariffState.Delay)
{
schedule.LastBackupTime = DateTime.UtcNow;
BackupRepository.SaveBackupSchedule(schedule);
Log.DebugFormat("Start scheduled backup: {0}, {1}, {2}, {3}", schedule.TenantId, schedule.BackupMail, schedule.StorageType, schedule.StorageBasePath);
BackupWorker.StartScheduledBackup(schedule);
}
else
{
Log.DebugFormat("Skip portal {0} not paid", schedule.TenantId);
}
}
catch (Exception error)
{
Log.Error("error while scheduling backups: {0}", error);
}
}
}
public override void AddType(Type type)
{
SourceRepository.AddType(type);
BackupRepository.AddType(type);
ForEachWriteRepo(repo => repo.AddType(type));
base.AddType(type);
}
public IEnumerable <Backup> GetBackups()
{
var repository = new BackupRepository();
var output = repository.Get();
return(output);
}
public List <BackupHistoryRecord> GetBackupHistory(int tenantId)
{
var backupHistory = new List <BackupHistoryRecord>();
foreach (var record in BackupRepository.GetBackupRecordsByTenantId(tenantId))
{
var storage = BackupStorageFactory.GetBackupStorage(record);
if (storage == null)
{
continue;
}
if (storage.IsExists(record.StoragePath))
{
backupHistory.Add(new BackupHistoryRecord
{
Id = record.Id,
FileName = record.Name,
StorageType = record.StorageType,
CreatedOn = record.CreatedOn,
ExpiresOn = record.ExpiresOn
});
}
else
{
BackupRepository.DeleteBackupRecord(record.Id);
}
}
return(backupHistory);
}
public void StartRestore(StartRestoreRequest request)
{
if ((BackupStorageType)request.StorageType == BackupStorageType.Local)
{
if (string.IsNullOrEmpty(request.FilePathOrId) || !File.Exists(request.FilePathOrId))
{
throw new FileNotFoundException();
}
}
if (!request.BackupId.Equals(Guid.Empty))
{
var backupRecord = BackupRepository.GetBackupRecord(request.BackupId);
if (backupRecord == null)
{
throw new FileNotFoundException();
}
request.FilePathOrId = backupRecord.StoragePath;
request.StorageType = backupRecord.StorageType;
request.StorageParams = JsonConvert.DeserializeObject <Dictionary <string, string> >(backupRecord.StorageParams);
}
var progress = BackupWorker.StartRestore(request);
if (!string.IsNullOrEmpty(progress.Error))
{
throw new FaultException();
}
}
public void Undo()
{
if (Backup != null && !IsSaved)
{
BackupRepository daoBackup = new BackupRepository();
daoBackup.Refresh(Backup);
}
}
internal void DeleteExpiredBackups(BackupCleanerService backupCleanerService)
{
log.Debug("started to clean expired backups");
var backupsToRemove = BackupRepository.GetExpiredBackupRecords();
log.DebugFormat("found {0} backups which are expired", backupsToRemove.Count);
if (!backupCleanerService.IsStarted)
{
return;
}
foreach (var scheduledBackups in BackupRepository.GetScheduledBackupRecords().GroupBy(r => r.TenantId))
{
if (!backupCleanerService.IsStarted)
{
return;
}
var schedule = BackupRepository.GetBackupSchedule(scheduledBackups.Key);
if (schedule != null)
{
var scheduledBackupsToRemove = scheduledBackups.OrderByDescending(r => r.CreatedOn).Skip(schedule.BackupsStored).ToList();
if (scheduledBackupsToRemove.Any())
{
log.DebugFormat("only last {0} scheduled backup records are to keep for tenant {1} so {2} records must be removed", schedule.BackupsStored, schedule.TenantId, scheduledBackupsToRemove.Count);
backupsToRemove.AddRange(scheduledBackupsToRemove);
}
}
else
{
backupsToRemove.AddRange(scheduledBackups);
}
}
foreach (var backupRecord in backupsToRemove)
{
if (!backupCleanerService.IsStarted)
{
return;
}
try
{
var backupStorage = BackupStorageFactory.GetBackupStorage(backupRecord);
if (backupStorage == null)
{
continue;
}
backupStorage.Delete(backupRecord.StoragePath);
BackupRepository.DeleteBackupRecord(backupRecord.Id);
}
catch (Exception error)
{
log.Warn("can't remove backup record: {0}", error);
}
}
}
public void DoBackup(string username)
{
var repository = new BackupRepository();
var backupPath = ComicalConfiguration.BackupPath;
var filename = String.Format("Comical_{0}.bkp", DateTime.Now.ToString("yyyyMMdd_hhmmss"));
repository.DoBackup(filename, username);
}
public BackupCleanerHelperService(
IOptionsMonitor <ILog> options,
BackupRepository backupRepository,
BackupStorageFactory backupStorageFactory)
{
log = options.CurrentValue;
BackupRepository = backupRepository;
BackupStorageFactory = backupStorageFactory;
}
static void Main(string[] args)
{
System.Console.WriteLine("Hello World!");
var bs = new BackupService(@"Data Source=.\SQLEXPRESS;Initial Catalog=SafetyDesign_Dev;Integrated Security=True", @"D:\_TEMP\DbBackupManager");
var dbs = bs.GetAllUserDatabases().ToList();
dbs.ForEach(db => System.Console.WriteLine(db));
var br = new BackupRepository(@"d:\_TEMP\DbBackupManager\_backups.json");
var backups = br.GetAll();
}
public OctopusAsyncRepository(IOctopusAsyncClient client)
{
this.Client = client;
Accounts = new AccountRepository(client);
ActionTemplates = new ActionTemplateRepository(client);
Artifacts = new ArtifactRepository(client);
Backups = new BackupRepository(client);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(client);
CertificateConfiguration = new CertificateConfigurationRepository(client);
Certificates = new CertificateRepository(client);
Channels = new ChannelRepository(client);
CommunityActionTemplates = new CommunityActionTemplateRepository(client);
Configuration = new ConfigurationRepository(client);
DashboardConfigurations = new DashboardConfigurationRepository(client);
Dashboards = new DashboardRepository(client);
Defects = new DefectsRepository(client);
DeploymentProcesses = new DeploymentProcessRepository(client);
Deployments = new DeploymentRepository(client);
Environments = new EnvironmentRepository(client);
Events = new EventRepository(client);
FeaturesConfiguration = new FeaturesConfigurationRepository(client);
Feeds = new FeedRepository(client);
Interruptions = new InterruptionRepository(client);
LibraryVariableSets = new LibraryVariableSetRepository(client);
Lifecycles = new LifecyclesRepository(client);
MachinePolicies = new MachinePolicyRepository(client);
MachineRoles = new MachineRoleRepository(client);
Machines = new MachineRepository(client);
Migrations = new MigrationRepository(client);
OctopusServerNodes = new OctopusServerNodeRepository(client);
PerformanceConfiguration = new PerformanceConfigurationRepository(client);
ProjectGroups = new ProjectGroupRepository(client);
Projects = new ProjectRepository(client);
ProjectTriggers = new ProjectTriggerRepository(client);
Proxies = new ProxyRepository(client);
Releases = new ReleaseRepository(client);
RetentionPolicies = new RetentionPolicyRepository(client);
Schedulers = new SchedulerRepository(client);
ServerStatus = new ServerStatusRepository(client);
Subscriptions = new SubscriptionRepository(client);
TagSets = new TagSetRepository(client);
Tasks = new TaskRepository(client);
Teams = new TeamsRepository(client);
Tenants = new TenantRepository(client);
TenantVariables = new TenantVariablesRepository(client);
UserRoles = new UserRolesRepository(client);
Users = new UserRepository(client);
VariableSets = new VariableSetRepository(client);
Workers = new WorkerRepository(client);
WorkerPools = new WorkerPoolRepository(client);
}
public BackupService(
IOptionsMonitor <ILog> options,
BackupStorageFactory backupStorageFactory,
BackupWorker backupWorker,
BackupRepository backupRepository,
ConfigurationExtension configuration)
{
Log = options.CurrentValue;
BackupStorageFactory = backupStorageFactory;
BackupWorker = backupWorker;
BackupRepository = backupRepository;
Configuration = configuration;
}
public SaveApplicationDataCommand(
TaskListViewModel taskListViewModel,
DoneListViewModel doneListViewModel,
SettingsViewModel settingsViewModel,
FileDataRepository fileDataRepository,
BackupRepository backupRepository)
{
_taskListViewModel = taskListViewModel;
_doneListViewModel = doneListViewModel;
_settingsViewModel = settingsViewModel;
_fileDataRepository = fileDataRepository;
_backupRepository = backupRepository;
}
public BackupSchedulerServiceHelper(
IOptionsMonitor <ILog> options,
PaymentManager paymentManager,
BackupWorker backupWorker,
BackupRepository backupRepository,
Schedule schedule)
{
PaymentManager = paymentManager;
BackupWorker = backupWorker;
BackupRepository = backupRepository;
Schedule = schedule;
Log = options.CurrentValue;
}
private void SaveDtoToBackupRepository(object dtoInstance)
{
object existing = BackupRepository.Retrieve(dtoInstance.GetType(), dtoInstance.Property <string>("Uuid"));
if (existing != null)
{
BackupRepository.Save(dtoInstance);
}
else
{
BackupRepository.Create(dtoInstance);
}
}
public void DeleteBackup(Guid id)
{
var backupRecord = BackupRepository.GetBackupRecord(id);
BackupRepository.DeleteBackupRecord(backupRecord.Id);
var storage = BackupStorageFactory.GetBackupStorage(backupRecord);
if (storage == null)
{
return;
}
storage.Delete(backupRecord.StoragePath);
}
public void CreateSchedule(CreateScheduleRequest request)
{
BackupRepository.SaveBackupSchedule(
new BackupSchedule()
{
TenantId = request.TenantId,
Cron = request.Cron,
BackupMail = request.BackupMail,
BackupsStored = request.NumberOfBackupsStored,
StorageType = request.StorageType,
StorageBasePath = request.StorageBasePath,
StorageParams = JsonConvert.SerializeObject(request.StorageParams)
});
}
public async Task <FileVersionerResults> DoVersion(Models.Backup backup, LinkedList <string> filePaths, bool newVersion)
{
Assert.IsNotNull(backup);
Assert.AreEqual(TransferStatus.RUNNING, backup.Status);
Assert.IsNotNull(filePaths);
Results.Reset();
await ExecuteOnBackround(() =>
{
ISession session = NHibernateHelper.GetSession();
try
{
BackupRepository daoBackup = new BackupRepository(session);
BackupPlanFileRepository daoBackupPlanFile = new BackupPlanFileRepository(session);
Backup = daoBackup.Get(backup.Id);
IList <Models.BackupPlanFile> list = newVersion
? daoBackupPlanFile.GetAllByBackupPlan(Backup.BackupPlan)
: daoBackupPlanFile.GetAllPendingByBackup(Backup);
AllFilesFromPlan = list.ToDictionary <Models.BackupPlanFile, string>(p => p.Path);
Execute(Backup, filePaths, newVersion);
Save(session);
}
catch (Exception ex)
{
string message = string.Format("File versioning FAILED with an exception: {0}", ex.Message);
Results.OnError(this, message);
logger.Log(LogLevel.Error, ex, message);
throw ex;
}
finally
{
//session.Close();
if (session.IsConnected)
{
session.Disconnect();
}
}
}, CancellationToken);
return(Results);
}
public async Task OneTimeSetup()
{
var generalSqlRepository = new GeneralSqlRepository();
this.backupRepository = new BackupRepository(ConnectionFactorySetup.ConnectionFactory, generalSqlRepository);
// Run full and diff backups
await this.backupRepository.RunBackupAsync(BackupType.Full, Path.GetTempFileName());
await this.backupRepository.RunBackupAsync(BackupType.Differential, Path.GetTempFileName());
// Get the database name for queries (note: with localdb unit platform test implementation the database name probably has a random suffix)
using (var connection = ConnectionFactorySetup.ConnectionFactory.GetEddsPerformanceConnection())
{
this.databaseName = new SqlConnectionStringBuilder(connection.ConnectionString).InitialCatalog;
}
}
public BackupSchedulerServiceHelper(
IOptionsMonitor <ILog> options,
PaymentManager paymentManager,
BackupWorker backupWorker,
BackupRepository backupRepository,
Schedule schedule,
TenantManager tenantManager,
CoreBaseSettings coreBaseSettings)
{
PaymentManager = paymentManager;
BackupWorker = backupWorker;
BackupRepository = backupRepository;
Schedule = schedule;
TenantManager = tenantManager;
CoreBaseSettings = coreBaseSettings;
Log = options.CurrentValue;
}
private HashSet <OldToNewIdMapping> RestoreData(Database restoreTo, ILogger logger)
{
HashSet <OldToNewIdMapping> result = new HashSet <OldToNewIdMapping>();
DatabaseToRestoreTo = restoreTo;
DatabaseToRestoreTo.TryEnsureSchema(DaoTypes.First(), logger);
Dictionary <string, Dao> tempForeignKeyTargets = InsertTempForeignKeyTargets();
// for all the poco types load them all from the repo
foreach (Type pocoType in BackupRepository.StorableTypes)
{
// copy the poco as a dao and save it into the restoreTo
IEnumerable <object> all = BackupRepository.RetrieveAll(pocoType);
Type daoType = DaoTypes.FirstOrDefault(t => t.Name.Equals(pocoType.Name));
Args.ThrowIf <InvalidOperationException>(daoType == null, "The Dto of type {0} didn't have a corresponding Dao type", pocoType.Name);
foreach (object poco in all)
{
string uuid = Meta.GetUuid(poco, true);
Dao dao = (Dao)poco.CopyAs(daoType);
dao.IdValue = null;
dao.DataRow = null;
dao.ForceInsert = true;
dao.UniqueFilterProvider = () =>
{
return(Query.Where("Uuid") == uuid);
};
ForceUpdateIfExistsInTarget(uuid, dao);
SetTemporaryForeignKeys(dao, tempForeignKeyTargets);
dao.Save(DatabaseToRestoreTo);
OldToNewIdMapping idMapping = new OldToNewIdMapping
{
PocoType = pocoType,
DaoType = daoType,
OldId = (long)poco.Property("Id"),
NewId = (long)dao.IdValue,
Uuid = uuid
};
result.Add(idMapping);
}
}
return(result);
}
private void Backup(Database database, Dao dao)
{
if (database == SourceDatabase)
{
BackupTask = Task.Run(() =>
{
object dtoInstance = Dto.Copy(dao);
object existing = BackupRepository.Retrieve(dtoInstance.GetType(), dtoInstance.Property <string>("Uuid"));
if (existing != null)
{
BackupRepository.Save(dtoInstance);
}
else
{
BackupRepository.Create(dtoInstance);
}
});
BackupTask.ConfigureAwait(false);
}
}
public void DeleteAllBackups(int tenantId)
{
foreach (var backupRecord in BackupRepository.GetBackupRecordsByTenantId(tenantId))
{
try
{
BackupRepository.DeleteBackupRecord(backupRecord.Id);
var storage = BackupStorageFactory.GetBackupStorage(backupRecord);
if (storage == null)
{
continue;
}
storage.Delete(backupRecord.StoragePath);
}
catch (Exception error)
{
Log.Warn("error while removing backup record: {0}", error);
}
}
}
public ScheduleResponse GetSchedule(int tenantId)
{
var schedule = BackupRepository.GetBackupSchedule(tenantId);
if (schedule != null)
{
var tmp = new ScheduleResponse
{
StorageType = schedule.StorageType,
StorageBasePath = schedule.StorageBasePath,
BackupMail = schedule.BackupMail,
NumberOfBackupsStored = schedule.BackupsStored,
Cron = schedule.Cron,
LastBackupTime = schedule.LastBackupTime,
StorageParams = JsonConvert.DeserializeObject <Dictionary <string, string> >(schedule.StorageParams)
};
return(tmp);
}
else
{
return(null);
}
}
private void Save(ISession session)
{
Assert.IsFalse(IsSaved);
BatchProcessor batchProcessor = new BatchProcessor();
BackupRepository daoBackup = new BackupRepository(session);
BackupPlanFileRepository daoBackupPlanFile = new BackupPlanFileRepository(session);
BackupedFileRepository daoBackupedFile = new BackupedFileRepository(session);
BackupPlanPathNodeRepository daoBackupPlanPathNode = new BackupPlanPathNodeRepository(session);
#if false
var FilesToTrack = SuppliedFiles.Union(ChangeSet.DeletedFiles);
var FilesToInsertOrUpdate =
from f in FilesToTrack
where
// Keep it so we'll later add or update a `BackupedFile`.
((f.LastStatus == Models.BackupFileStatus.ADDED || f.LastStatus == Models.BackupFileStatus.MODIFIED))
// Keep it if `LastStatus` is different from `PreviousLastStatus`.
|| ((f.LastStatus == Models.BackupFileStatus.REMOVED || f.LastStatus == Models.BackupFileStatus.DELETED) && (f.LastStatus != f.PreviousLastStatus))
// Skip all UNCHANGED files.
select f;
#else
var FilesToTrack = SuppliedFiles;
var FilesToInsertOrUpdate =
from f in FilesToTrack
where
// Keep it so we'll later add or update a `BackupedFile`.
((f.LastStatus == Models.BackupFileStatus.ADDED || f.LastStatus == Models.BackupFileStatus.MODIFIED))
// Skip all UNCHANGED/DELETED/REMOVED files.
select f;
#endif
BlockPerfStats stats = new BlockPerfStats();
using (ITransaction tx = session.BeginTransaction())
{
try
{
// ------------------------------------------------------------------------------------
stats.Begin("STEP 1");
BackupPlanPathNodeCreator pathNodeCreator = new BackupPlanPathNodeCreator(daoBackupPlanPathNode, tx);
// 1 - Split path into its components and INSERT new path nodes if they don't exist yet.
foreach (Models.BackupPlanFile entry in FilesToInsertOrUpdate)
{
// Throw if the operation was canceled.
CancellationToken.ThrowIfCancellationRequested();
try
{
entry.PathNode = pathNodeCreator.CreateOrUpdatePathNodes(Backup.BackupPlan.StorageAccount, entry);
}
catch (Exception ex)
{
string message = string.Format("BUG: Failed to create/update {0} => {1}",
typeof(Models.BackupPlanPathNode).Name,
CustomJsonSerializer.SerializeObject(entry, 1));
Results.OnError(this, message);
logger.Log(LogLevel.Error, ex, message);
throw;
}
batchProcessor.ProcessBatch(session);
}
batchProcessor.ProcessBatch(session, true);
stats.End();
// ------------------------------------------------------------------------------------
stats.Begin("STEP 2");
// 2 - Insert/Update `BackupPlanFile`s as necessary.
foreach (Models.BackupPlanFile entry in FilesToInsertOrUpdate)
{
// Throw if the operation was canceled.
CancellationToken.ThrowIfCancellationRequested();
// IMPORTANT: It's important that we guarantee the referenced `BackupPlanFile` has a valid `Id`
// before we reference it elsewhere, otherwise NHibernate won't have a valid value to put on
// the `backup_plan_file_id` column.
try
{
daoBackupPlanFile.InsertOrUpdate(tx, entry); // Guarantee it's saved
}
catch (Exception ex)
{
string message = string.Format("BUG: Failed to insert/update {0} => {1}",
typeof(Models.BackupPlanFile).Name,
CustomJsonSerializer.SerializeObject(entry, 1));
Results.OnError(this, message);
logger.Log(LogLevel.Error, ex, message);
logger.Error("Dump of failed object: {0}", entry.DumpMe());
throw;
}
batchProcessor.ProcessBatch(session);
}
batchProcessor.ProcessBatch(session, true);
stats.End();
// ------------------------------------------------------------------------------------
stats.Begin("STEP 3");
// 3 - Insert/Update `BackupedFile`s as necessary and add them to the `Backup`.
//List<Models.BackupedFile> backupedFiles = new List<Models.BackupedFile>(FilesToInsertOrUpdate.Count());
foreach (Models.BackupPlanFile entry in FilesToInsertOrUpdate)
{
// Throw if the operation was canceled.
CancellationToken.ThrowIfCancellationRequested();
Models.BackupedFile backupedFile = daoBackupedFile.GetByBackupAndPath(Backup, entry.Path);
if (backupedFile == null) // If we're resuming, this should already exist.
{
// Create `BackupedFile`.
backupedFile = new Models.BackupedFile(Backup, entry);
}
backupedFile.FileSize = entry.LastSize;
backupedFile.FileStatus = entry.LastStatus;
backupedFile.FileLastWrittenAt = entry.LastWrittenAt;
backupedFile.FileLastChecksum = entry.LastChecksum;
switch (entry.LastStatus)
{
default:
backupedFile.TransferStatus = default(TransferStatus);
break;
case Models.BackupFileStatus.REMOVED:
case Models.BackupFileStatus.DELETED:
backupedFile.TransferStatus = TransferStatus.COMPLETED;
break;
}
backupedFile.UpdatedAt = DateTime.UtcNow;
try
{
daoBackupedFile.InsertOrUpdate(tx, backupedFile);
}
catch (Exception ex)
{
logger.Log(LogLevel.Error, ex, "BUG: Failed to insert/update {0} => {1}",
typeof(Models.BackupedFile).Name,
CustomJsonSerializer.SerializeObject(backupedFile, 1));
throw;
}
//backupedFiles.Add(backupedFile);
batchProcessor.ProcessBatch(session);
}
batchProcessor.ProcessBatch(session, true);
stats.End();
// ------------------------------------------------------------------------------------
stats.Begin("STEP 4");
// 4 - Update all `BackupPlanFile`s that already exist for the backup plan associated with this backup operation.
{
var AllFilesFromPlanThatWerentUpdatedYet = AllFilesFromPlan.Values.Except(FilesToInsertOrUpdate);
foreach (Models.BackupPlanFile file in AllFilesFromPlanThatWerentUpdatedYet)
{
// Throw if the operation was canceled.
CancellationToken.ThrowIfCancellationRequested();
//Console.WriteLine("2: {0}", file.Path);
try
{
daoBackupPlanFile.Update(tx, file);
}
catch (Exception ex)
{
string message = string.Format("BUG: Failed to update {0} => {1} ",
typeof(Models.BackupPlanFile).Name,
CustomJsonSerializer.SerializeObject(file, 1));
Results.OnError(this, message);
logger.Log(LogLevel.Error, ex, message);
throw;
}
batchProcessor.ProcessBatch(session);
}
}
batchProcessor.ProcessBatch(session, true);
stats.End();
// ------------------------------------------------------------------------------------
stats.Begin("STEP 5");
// 5 - Insert/Update `Backup` and its `BackupedFile`s into the database, also saving
// the `BackupPlanFile`s instances that may have been changed by step 2.
{
//foreach (var bf in backupedFiles)
//{
// // Throw if the operation was canceled.
// CancellationToken.ThrowIfCancellationRequested();
//
// Backup.Files.Add(bf);
//
// ProcessBatch(session);
//}
try
{
daoBackup.Update(tx, Backup);
}
catch (Exception ex)
{
string message = string.Format("BUG: Failed to update {0} => {1}",
typeof(Models.Backup).Name,
CustomJsonSerializer.SerializeObject(Backup, 1));
Results.OnError(this, message);
logger.Log(LogLevel.Error, ex, message);
throw;
}
}
batchProcessor.ProcessBatch(session, true);
stats.End();
// ------------------------------------------------------------------------------------
tx.Commit();
}
catch (OperationCanceledException)
{
string message = "Operation cancelled";
Results.OnError(this, message);
logger.Warn(message);
tx.Rollback(); // Rollback the transaction
throw;
}
catch (Exception ex)
{
string message = string.Format("Caught Exception: {0}", ex.Message);
Results.OnError(this, message);
logger.Log(LogLevel.Error, ex, message);
tx.Rollback(); // Rollback the transaction
throw;
}
finally
{
// ...
}
}
IsSaved = true;
// 6 - Create versioned files and remove files that won't belong to this backup.
TransferSet.Files = GetFilesToTransfer(Backup, SuppliedFiles);
// Test to see if things are okay!
{
var transferCount = TransferSet.Files.Count();
var filesCount = ChangeSet.AddedFiles.Count() + ChangeSet.ModifiedFiles.Count();
Assert.IsTrue(transferCount == filesCount, "TransferSet.Files must be equal (ChangeSet.AddedFiles + ChangeSet.ModifiedFiles)");
}
}
public BackupManager()
{
_backupRepository = new BackupRepository();
}
public void DoRestore(int backupId)
{
var repository = new BackupRepository();
repository.DoRestore(backupId);
}
