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