/// <summary>
/// delete backup configuration
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public int DeleteBackupConfig(string id)
{
BackupConfiguration entity = context.Backups.Find(id);
context.Backups.Remove(entity);
return(context.SaveChanges());
}
public void Backup()
{
var bitnamiRedmineService = SimpleIoc.Default.GetInstance <IBitnamiRedmineService>();
var stacks = bitnamiRedmineService.GetBitnamiRedmineStacks().ToArray();
Assert.IsTrue(stacks.Length != 0);
var backupService = SimpleIoc.Default.GetInstance <IBackupService>();
foreach (var stack in stacks)
{
var targetDirectory = @"F:\RedArmory";
var directory = DateTime.Now.ToString("yyyyMMdd_hhmmsshhh");
var path = Path.Combine(targetDirectory, directory);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
var configuration = new BackupConfiguration();
configuration.Themes = true;
configuration.Files = true;
configuration.Plugins = true;
backupService.Backup(stack, configuration, path, new Progress <ProgressReportsModel>());
}
}
public BackupTask(DocumentDatabase database, BackupParameters backupParameters, BackupConfiguration configuration, Logger logger, PeriodicBackupRunner.TestingStuff forTestingPurposes = null)
{
_database = database;
_taskName = backupParameters.Name;
_operationId = backupParameters.OperationId;
_previousBackupStatus = backupParameters.BackupStatus;
_startTimeUtc = backupParameters.StartTimeUtc;
_isOneTimeBackup = backupParameters.IsOneTimeBackup;
_isFullBackup = backupParameters.IsFullBackup;
_backupToLocalFolder = backupParameters.BackupToLocalFolder;
_tempBackupPath = backupParameters.TempBackupPath;
_configuration = configuration;
_logger = logger;
_isServerWide = backupParameters.Name?.StartsWith(ServerWideBackupConfiguration.NamePrefix, StringComparison.OrdinalIgnoreCase) ?? false;
_isBackupEncrypted = IsBackupEncrypted(_database, _configuration);
_forTestingPurposes = forTestingPurposes;
_backupResult = GenerateBackupResult();
TaskCancelToken = new OperationCancelToken(_database.DatabaseShutdown, CancellationToken.None);
_retentionPolicyParameters = new RetentionPolicyBaseParameters
{
RetentionPolicy = backupParameters.RetentionPolicy,
DatabaseName = _database.Name,
IsFullBackup = _isFullBackup,
OnProgress = AddInfo,
CancellationToken = TaskCancelToken.Token
};
}
protected override async void Execute()
{
var configuration = new BackupConfiguration
{
Database = this.HasDatabase && this.Database,
Files = this.HasFile && this.Files,
Plugins = this.HasPlugin && this.Plugins,
Themes = this.HasTheme && this.Themes
};
// リストア処理の実行
string message = null;
try
{
var progressDialogService = new ProgressDialogService {
IsAutoClose = true
};
var engine = new RestoreEngine(this._BitnamiRedmineService,
this._BackupService,
this._DispatcherService,
this._LogService,
configuration,
this.Stack,
this.Directory);
var report = engine.PrepareRestore();
progressDialogService.Action = () =>
{
engine.ExecuteRestore();
};
progressDialogService.Report = report;
await progressDialogService.ShowMessage(null, null);
if (progressDialogService.Result == MessageBoxResult.Cancel)
{
message = Resources.Msg_RestoreCancel;
}
else
{
message = Resources.Msg_RestoreComplete;
}
}
catch (Exception ex)
{
message = $"Exception is thown. Reason is {ex.Message}";
this._LogService.Error(message);
message = $"StackTrace is {ex.StackTrace}";
this._LogService.Error(message);
message = Resources.Msg_BackupFailed;
}
finally
{
await this._DialogService.ShowMessage(MessageBoxButton.OK, message, null);
}
}
public string StartLanCopyFileJob(BackupConfiguration item)
{
string jobId = $"{item.Id}";// _{Convert.ToBase64String(item.RowVersion)}";
Exception localEx = null;
try
{
var msg = $"({item.Id}) - START";
logger.Debug(msg);
webapi.LogActivity(item.Id, msg, string.Empty, "OK");
ReportAgentStatus(StatusType.Starting, $"Starting copy operation - ({item.Id})", 0, item.Id);
if (item.SrcUser.IndexOf(@"@") < 0)
{
throw new ArgumentException("Source user must be in format john@computer");
}
if (item.DestUser.IndexOf(@"@") < 0)
{
throw new ArgumentException("Destination user must be in format john@computer");
}
string domainSrc = item.SrcUser.Substring(item.SrcUser.IndexOf(@"@") + 1);
string usernameSrc = item.SrcUser.Substring(0, item.SrcUser.IndexOf(@"@"));
string domainDest = item.DestUser.Substring(item.DestUser.IndexOf(@"@") + 1);
string usernameDest = item.DestUser.Substring(0, item.DestUser.IndexOf(@"@"));
Exception outEx;
if (!CopyFolderAndFilesWithImpersonation(item.Id, item.SrcFolder, domainSrc, usernameSrc, item.SrcPass,
item.DestLanFolder, domainDest, usernameDest, item.DestPass, out outEx))
{
if (outEx != null)
{
localEx = outEx;
logger.Error($"CopyFolderAndFilesWithImpersonation ERR : {outEx}");
ReportAgentStatus(StatusType.Error, "Error... " + outEx.Message, 100);
}
}
else
{
ReportAgentStatus(StatusType.Idle, $"Finished - ({item.Id})...", 100);
}
}
catch (Exception ex)
{
localEx = ex;
logger.Error($"Background job ERR : {ex}");
ReportAgentStatus(StatusType.Error, $"Error - ({item.Id}) - " + ex.Message, 0);
}
finally
{
var msg = $"({item.Id}) - END";
logger.Debug(msg);
webapi.LogActivity(item.Id, msg, localEx != null ? localEx.Message : string.Empty, localEx != null ? "ERR" : "OK");
}
return(jobId);
}
static EtlTestBase()
{
var configuration = RavenConfiguration.CreateForTesting("foo", ResourceType.Database);
configuration.Initialize();
DefaultBackupConfiguration = configuration.Backup;
}
public Service(BackupConfiguration backupConfiguration, PowerBIConnection powerBIConnection, AzureBlobConnection azureBlobConnection)
{
BackupConfiguration = backupConfiguration;
PowerBIConnection = powerBIConnection;
AzureBlobConnection = azureBlobConnection;
SetConnections();
}
public static FullBackup CreateNew(VirtualMachine vm, BackupConfiguration backupConfiguration)
{
var locationType = backupConfiguration.TargetLocationType;
var path = backupConfiguration.BackupLocation;
FullBackup fullBackup = new FullBackup(vm, locationType, path, DateTime.UtcNow);
return(fullBackup);
}
public static bool IsBackupEncrypted(DocumentDatabase database, BackupConfiguration configuration)
{
if (database.MasterKey != null && configuration.BackupEncryptionSettings == null)
{
return(true);
}
return(configuration.BackupEncryptionSettings != null &&
configuration.BackupEncryptionSettings.EncryptionMode != EncryptionMode.None);
}
public HttpTrigger(AlertingConfiguration alertingConfiguration,
BackupArchivingConfiguration backupArchivingConfiguration,
BackupConfiguration backupConfiguration,
CassandraConfiguration cassandraConfiguration)
{
_alertingConfiguration = alertingConfiguration;
_backupArchivingConfiguration = backupArchivingConfiguration;
_backupConfiguration = backupConfiguration;
_cassandraConfiguration = cassandraConfiguration;
}
public RavenAwsGlacierClient(GlacierSettings glacierSettings, BackupConfiguration configuration, Progress progress = null, CancellationToken cancellationToken = default)
{
if (glacierSettings == null)
{
throw new ArgumentNullException(nameof(glacierSettings));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (string.IsNullOrWhiteSpace(glacierSettings.AwsAccessKey))
{
throw new ArgumentException("AWS Access Key cannot be null or empty");
}
if (string.IsNullOrWhiteSpace(glacierSettings.AwsSecretKey))
{
throw new ArgumentException("AWS Secret Key cannot be null or empty");
}
if (string.IsNullOrWhiteSpace(glacierSettings.VaultName))
{
throw new ArgumentException("AWS Vault Name cannot be null or empty");
}
if (string.IsNullOrWhiteSpace(glacierSettings.AwsRegionName))
{
throw new ArgumentException("AWS Region Name cannot be null or empty");
}
var region = RegionEndpoint.GetBySystemName(glacierSettings.AwsRegionName);
AWSCredentials credentials;
if (string.IsNullOrWhiteSpace(glacierSettings.AwsSessionToken))
{
credentials = new BasicAWSCredentials(glacierSettings.AwsAccessKey, glacierSettings.AwsSecretKey);
}
else
{
credentials = new SessionAWSCredentials(glacierSettings.AwsAccessKey, glacierSettings.AwsSecretKey, glacierSettings.AwsSessionToken);
}
_client = new AmazonGlacierClient(credentials, new AmazonGlacierConfig
{
RegionEndpoint = region,
Timeout = configuration.CloudStorageOperationTimeout.AsTimeSpan
});
_region = glacierSettings.AwsRegionName;
_vaultName = glacierSettings.VaultName;
_progress = progress;
_cancellationToken = cancellationToken;
}
public async Task <FullBackup> BackupAsync(VirtualMachine vm, BackupConfiguration backupConfiguration)
{
FullBackup backup = FullBackup.CreateNew(vm, backupConfiguration);
Task[] backupTasks = new Task[vm.VirtualDisks.Count];
for (int i = 0; i < vm.VirtualDisks.Count; i++)
{
VirtualDisk vd = vm.VirtualDisks[i];
backupTasks[i] = BackupVirtualDisk(backup, vd, vm.SourceLocationType);
}
await Task.WhenAll(backupTasks);
return(backup);
}
//MUST BE STATIC so it can be called from Hangfire
public static string DoCopyJob(BackupConfiguration item)
{
string result = string.Empty;
try
{
result = DI.Container.GetInstance <LanCopyController>().StartLanCopyFileJob(item);
}
catch (Exception ex)
{
var logger = DI.Container.GetInstance <ILogger>();
logger.Error(ex, "DoCopyJoberror:");
}
return(result);
}
public Runner(ILogger logger, ICounter counter, ICassandraService cassandraService,
CassandraConfiguration cassandraConfiguration, BackupConfiguration backupConfiguration,
BackupArchivingConfiguration backupArchivingConfiguration, IAlerter alerter,
AlertingConfiguration alertingConfiguration, IPatternMatching patternMatching)
{
_logger = logger;
_alerter = alerter;
_counter = counter;
_cassandraService = cassandraService;
_cassandraConfiguration = cassandraConfiguration;
_backupArchivingConfiguration = backupArchivingConfiguration;
_backupConfiguration = backupConfiguration;
_alertingConfiguration = alertingConfiguration;
_patternMatching = patternMatching;
}
private RavenConfiguration(string resourceName, ResourceType resourceType, string customConfigPath = null, bool skipEnvironmentVariables = false)
{
_logger = LoggingSource.Instance.GetLogger <RavenConfiguration>(resourceName);
ResourceName = resourceName;
ResourceType = resourceType;
_customConfigPath = customConfigPath;
PathSettingBase <string> .ValidatePath(_customConfigPath);
_configBuilder = new ConfigurationBuilder();
if (skipEnvironmentVariables == false)
{
AddEnvironmentVariables();
}
AddJsonConfigurationVariables(customConfigPath);
Settings = _configBuilder.Build();
Core = new CoreConfiguration();
Http = new HttpConfiguration();
Replication = new ReplicationConfiguration();
Cluster = new ClusterConfiguration();
Etl = new EtlConfiguration();
Storage = new StorageConfiguration();
Security = new SecurityConfiguration();
Backup = new BackupConfiguration();
PerformanceHints = new PerformanceHintsConfiguration();
Indexing = new IndexingConfiguration(this);
Monitoring = new MonitoringConfiguration();
Queries = new QueryConfiguration();
Patching = new PatchingConfiguration();
Logs = new LogsConfiguration();
Server = new ServerConfiguration();
Embedded = new EmbeddedConfiguration();
Databases = new DatabaseConfiguration(Storage.ForceUsing32BitsPager);
Memory = new MemoryConfiguration();
Studio = new StudioConfiguration();
Licensing = new LicenseConfiguration();
Tombstones = new TombstoneConfiguration();
Subscriptions = new SubscriptionsConfiguration();
TransactionMergerConfiguration = new TransactionMergerConfiguration(Storage.ForceUsing32BitsPager);
Notifications = new NotificationsConfiguration();
Updates = new UpdatesConfiguration();
Migration = new MigrationConfiguration();
Integrations = new IntegrationsConfiguration();
}
public static void AssertDestinationAndRegionAreAllowed(BackupConfiguration configuration, ServerStore serverStore)
{
foreach (var backupDestination in configuration.GetDestinations())
{
serverStore.Configuration.Backup.AssertDestinationAllowed(backupDestination);
}
if (configuration.S3Settings != null && configuration.S3Settings.Disabled == false)
{
serverStore.Configuration.Backup.AssertRegionAllowed(configuration.S3Settings.AwsRegionName);
}
if (configuration.GlacierSettings != null && configuration.GlacierSettings.Disabled == false)
{
serverStore.Configuration.Backup.AssertRegionAllowed(configuration.GlacierSettings.AwsRegionName);
}
}
public void CanSetupConfiguration()
{
var allDestinations = new HashSet <string>(BackupConfiguration._allDestinations);
allDestinations.Remove(PeriodicBackupConfiguration.BackupDestination.None.ToString());
var backupConfiguration = new BackupConfiguration();
foreach (var destination in allDestinations)
{
backupConfiguration.AssertDestinationAllowed(destination);
}
backupConfiguration.AllowedDestinations = allDestinations.ToArray();
foreach (var destination in allDestinations)
{
backupConfiguration.AssertDestinationAllowed(destination);
}
backupConfiguration.AllowedDestinations = new[] { "Amazonglacier", "Amazons3", "googleCloud" };
backupConfiguration.ValidateAllowedDestinations();
backupConfiguration.AssertDestinationAllowed("AmazonGlacier");
backupConfiguration.AssertDestinationAllowed("AmazonS3");
backupConfiguration.AssertDestinationAllowed("GoogleCloud");
var exception = Assert.Throws <ArgumentException>(() => backupConfiguration.AssertDestinationAllowed("Google Cloud"));
Assert.StartsWith("The selected backup destination 'Google Cloud' is not allowed in this RavenDB server", exception.Message);
backupConfiguration.AllowedDestinations = new[] { "None" };
foreach (var destination in allDestinations)
{
AssertNoneAllowedDestinations(destination);
}
backupConfiguration.AllowedDestinations = new[] { "nOnE" };
foreach (var destination in allDestinations)
{
AssertNoneAllowedDestinations(destination);
}
void AssertNoneAllowedDestinations(string destination)
{
exception = Assert.Throws <ArgumentException>(() => backupConfiguration.AssertDestinationAllowed(destination));
Assert.Equal("Backups are not allowed in this RavenDB server. Contact the administrator for more information.", exception.Message);
}
}
public async Task BackupAsync(BackupConfiguration configuration, BackupMode mode)
{
var watch = new Stopwatch();
watch.Start();
configuration.Validate();
var storageFacade = CreateStorageFacade(configuration.StorageAccount);
ILogger logger = new StorageFolderLogger(storageFacade.ChangeFolder("logs"));
var cosmosFacade = CreateCosmosFacade(configuration.CosmosAccount, logger);
var scheduler = new BackupScheduler(
logger,
cosmosFacade,
storageFacade,
configuration.GetCollectionPlans(),
configuration.Constants);
try
{
await scheduler.InitializeAsync();
try
{
if (mode == BackupMode.Iterative)
{
await scheduler.ProcessIterationAsync();
}
else
{
await scheduler.ProcessContinuouslyAsync();
}
logger.Display($"Elapsed Time: {watch.Elapsed}");
logger.Display("Memory used: "
+ $"{Process.GetCurrentProcess().PrivateMemorySize64 / 1024 / 1024} Mb");
}
finally
{
await Task.WhenAll(scheduler.DisposeAsync(), logger.FlushAsync());
}
}
catch (Exception ex)
{
logger.DisplayError(ex);
}
}
public void BackupLocationTypeCorrect()
{
// Setup
List <string> vhdPaths = new List <string> {
"mypath/disk1.vhd"
};
Guid vmId = Guid.NewGuid();
string testVmName = "test1";
VirtualMachine vm = VirtualMachine.FromExisting(vmId, testVmName, vhdPaths);
IBackupLocationFactoryResolver resolver = new MemoryBackupLocationFactoryResolver();
string backupLocation = "newBackupLocation";
LocationType targetLocationType = LocationType.CIFS;
BackupConfiguration backupConfig = new BackupConfiguration()
{
BackupLocation = backupLocation, TargetLocationType = targetLocationType
};
// Run
FullBackup backup = FullBackup.CreateNew(vm, backupConfig);
}
private static async Task BackupAsync(Container sourceContainer)
{
var metaController = new MetaController();
var backupConfiguration = new BackupConfiguration
{
CosmosAccount = CosmosCollectionRental.CosmosConfiguration,
StorageAccount = Storage.StorageConfiguration,
Collections = new[]
{
new CollectionBackupPlanOverride
{
Db = CosmosCollectionRental.DatabaseName,
Collection = sourceContainer.Id
}
}
};
await metaController.BackupAsync(backupConfiguration, BackupMode.Iterative);
}
public BackupEngine(
IBitnamiRedmineService bitnamiRedmineService,
IBackupService backupService,
IDispatcherService dispatcherService,
ILogService logService,
BackupConfiguration configuration,
BitnamiRedmineStack stack,
string outputPath)
{
if (bitnamiRedmineService == null)
{
throw new ArgumentNullException(nameof(bitnamiRedmineService));
}
if (backupService == null)
{
throw new ArgumentNullException(nameof(backupService));
}
if (logService == null)
{
throw new ArgumentNullException(nameof(logService));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (stack == null)
{
throw new ArgumentNullException(nameof(stack));
}
this._BitnamiRedmineService = bitnamiRedmineService;
this._BackupService = backupService;
this._DispatcherService = dispatcherService;
this._LogService = logService;
this._Configuration = configuration;
this._Stack = stack;
this._OutputPath = outputPath;
}
public RestoreEngine(
IBitnamiRedmineService bitnamiRedmineService,
IBackupService backupService,
IDispatcherService dispatcherService,
ILogService logService,
BackupConfiguration configuration,
BitnamiRedmineStack stack,
string inputDirectory)
{
if (bitnamiRedmineService == null)
{
throw new ArgumentNullException(nameof(bitnamiRedmineService));
}
if (backupService == null)
{
throw new ArgumentNullException(nameof(backupService));
}
if (logService == null)
{
throw new ArgumentNullException(nameof(logService));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (stack == null)
{
throw new ArgumentNullException(nameof(stack));
}
this._BitnamiRedmineService = bitnamiRedmineService;
this._BackupService = backupService;
this._DispatcherService = dispatcherService;
this._LogService = logService;
this._Configuration = configuration;
this._Stack = stack;
this._InputDirectory = inputDirectory;
}
public RavenGoogleCloudClient(GoogleCloudSettings settings, BackupConfiguration configuration, Progress progress = null, CancellationToken?cancellationToken = null)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (string.IsNullOrWhiteSpace(settings.BucketName))
{
throw new ArgumentException("Google Cloud Bucket name cannot be null or empty");
}
if (string.IsNullOrWhiteSpace(settings.GoogleCredentialsJson))
{
throw new ArgumentException("Google Credentials JSON cannot be null or empty");
}
try
{
_client = StorageClient.Create(GoogleCredential.FromJson(settings.GoogleCredentialsJson));
_client.Service.HttpClient.Timeout = configuration.CloudStorageOperationTimeout.AsTimeSpan;
}
catch (Exception e)
{
throw new ArgumentException("Wrong format for Google Credentials.", e);
}
var credentialJsonType = JObject.Parse(settings.GoogleCredentialsJson);
if (credentialJsonType.TryGetValue(ProjectIdPropertyName, StringComparison.OrdinalIgnoreCase, out var value))
{
_projectId = value.Value <string>();
}
_bucketName = settings.BucketName;
CancellationToken = cancellationToken ?? CancellationToken.None;
_progress = progress;
}
public void Restore()
{
var bitnamiRedmineService = SimpleIoc.Default.GetInstance <IBitnamiRedmineService>();
var stacks = bitnamiRedmineService.GetBitnamiRedmineStacks().ToArray();
Assert.IsTrue(stacks.Length != 0);
var backupService = SimpleIoc.Default.GetInstance <IBackupService>();
var path = @"F:\RedArmory\20151213_03084403";
foreach (var stack in stacks)
{
var configuration = new BackupConfiguration();
configuration.Themes = true;
configuration.Files = true;
configuration.Plugins = true;
backupService.Restore(stack, configuration, path, new Progress <ProgressReportsModel>());
}
}
public static void AssertBackupConfigurationInternal(BackupConfiguration configuration)
{
var localSettings = configuration.LocalSettings;
if (localSettings != null && localSettings.Disabled == false)
{
if (localSettings.HasSettings() == false)
{
throw new ArgumentException(
$"{nameof(localSettings.FolderPath)} and {nameof(localSettings.GetBackupConfigurationScript)} cannot be both null or empty");
}
if (string.IsNullOrEmpty(localSettings.FolderPath) == false)
{
if (DataDirectoryInfo.CanAccessPath(localSettings.FolderPath, out var error) == false)
{
throw new ArgumentException(error);
}
}
}
}
public RavenConfiguration(string resourceName, ResourceType resourceType, string customConfigPath = null)
{
ResourceName = resourceName;
ResourceType = resourceType;
_customConfigPath = customConfigPath;
PathSettingBase <string> .ValidatePath(_customConfigPath);
_configBuilder = new ConfigurationBuilder();
AddEnvironmentVariables();
AddJsonConfigurationVariables(customConfigPath);
Settings = _configBuilder.Build();
Core = new CoreConfiguration();
Http = new HttpConfiguration();
Replication = new ReplicationConfiguration();
Cluster = new ClusterConfiguration();
Etl = new EtlConfiguration();
Storage = new StorageConfiguration();
Security = new SecurityConfiguration();
Backup = new BackupConfiguration();
PerformanceHints = new PerformanceHintsConfiguration();
Indexing = new IndexingConfiguration(this);
Monitoring = new MonitoringConfiguration();
Queries = new QueryConfiguration();
Patching = new PatchingConfiguration();
Logs = new LogsConfiguration();
Server = new ServerConfiguration();
Testing = new TestingConfiguration();
Databases = new DatabaseConfiguration();
Memory = new MemoryConfiguration();
Studio = new StudioConfiguration();
Licensing = new LicenseConfiguration();
Tombstones = new TombstoneConfiguration();
Subscriptions = new SubscriptionConfiguration();
TransactionMergerConfiguration = new TransactionMergerConfiguration(Storage.ForceUsing32BitsPager);
}
public static void AssertDestinationAndRegionAreAllowed(BackupConfiguration configuration, ServerStore serverStore)
{
if (configuration.ValidateDestinations(out var errorMassage) == false)
{
throw new InvalidOperationException(errorMassage);
}
foreach (var backupDestination in configuration.GetDestinations())
{
serverStore.Configuration.Backup.AssertDestinationAllowed(backupDestination);
}
if (configuration.S3Settings != null && configuration.S3Settings.Disabled == false)
{
serverStore.Configuration.Backup.AssertRegionAllowed(configuration.S3Settings.AwsRegionName);
}
if (configuration.GlacierSettings != null && configuration.GlacierSettings.Disabled == false)
{
serverStore.Configuration.Backup.AssertRegionAllowed(configuration.GlacierSettings.AwsRegionName);
}
}
public async Task DataNotCorrupt()
{
//throw new NotImplementedException();
// Setup
List <string> vhdPaths = new List <string> {
"mypath/disk1.vhd"
};
Guid vmId = Guid.NewGuid();
string testVmName = "test1";
VirtualMachine vm = VirtualMachine.FromExisting(vmId, testVmName, vhdPaths);
IBackupLocationFactoryResolver resolver = new MemoryBackupLocationFactoryResolver();
string backupLocation = "newBackupLocation";
LocationType backupLocationType = LocationType.CIFS;
// Run
FullBackupService backupService = new FullBackupService(resolver);
BackupConfiguration backupConfig = new BackupConfiguration()
{
BackupLocation = backupLocation, TargetLocationType = backupLocationType
};
FullBackup backup = await backupService.BackupAsync(vm, backupConfig);
// Test
IBackupLocationFactory factory = resolver.Resolve(LocationType.CIFS);
// Get the byte[] that was written (our backup)
string virtualDiskBackupLocation = $"{backup.Path}/{vm.VirtualDisks[0].FileName}";
Stream savedDataStream = factory.Open(virtualDiskBackupLocation);
MemoryStream savedDataMs = new MemoryStream();
savedDataStream.CopyTo(savedDataMs);
byte[] savedData = savedDataMs.ToArray();
// Get the byte[] we started with
Stream originalDataStream = factory.Open(vm.VirtualDisks[0]);
MemoryStream originalDataMs = new MemoryStream();
originalDataStream.CopyTo(originalDataMs);
byte[] originalData = originalDataMs.ToArray();
Assert.True(originalData.SequenceEqual(savedData), "Data saved does not match original data");
}
public ConcurrentBackupsCounter(BackupConfiguration backupConfiguration, LicenseManager licenseManager)
{
_licenseManager = licenseManager;
int numberOfCoresToUse;
var skipModifications = backupConfiguration.MaxNumberOfConcurrentBackups != null;
if (skipModifications)
{
numberOfCoresToUse = backupConfiguration.MaxNumberOfConcurrentBackups.Value;
}
else
{
var utilizedCores = _licenseManager.GetCoresLimitForNode(out _, false);
numberOfCoresToUse = GetNumberOfCoresToUseForBackup(utilizedCores);
}
_concurrentBackups = numberOfCoresToUse;
_maxConcurrentBackups = numberOfCoresToUse;
_concurrentBackupsDelay = backupConfiguration.ConcurrentBackupsDelay.AsTimeSpan;
_skipModifications = skipModifications;
}
public void BackupPathCorrect()
{
// Setup
List <string> vhdPaths = new List <string> {
"mypath/disk1.vhd"
};
Guid vmId = Guid.NewGuid();
string testVmName = "test1";
VirtualMachine vm = VirtualMachine.FromExisting(vmId, testVmName, vhdPaths);
LocationType locationType = LocationType.CIFS;
string backupLocation = "newBackupLocation";
BackupConfiguration backupConfig = new BackupConfiguration {
BackupLocation = backupLocation, TargetLocationType = locationType
};
// Run
FullBackup backup = FullBackup.CreateNew(vm, backupConfig);
//FullBackup backup = await FullBackup.CreateNewAsync(vm, resolver, BackupLocationType.CIFS, backupLocation);
// Test
string expectedPath = $"{backupLocation}";
Assert.True(backup.Path == expectedPath, "Backup.Path does not equal the expected path");
}
