public void can_get_correct_error_glacier(string region1, string region2) { var vaultName1 = $"testing-{Guid.NewGuid()}"; var vaultName2 = $"testing-{Guid.NewGuid()}"; using (var clientRegion1 = new RavenAwsGlacierClient(GetGlacierSettings(region1, vaultName1))) using (var clientRegion2 = new RavenAwsGlacierClient(GetGlacierSettings(region2, vaultName2))) { var e = Assert.Throws <VaultNotFoundException>(() => { clientRegion2.UploadArchive( new MemoryStream(Encoding.UTF8.GetBytes("321")), "sample description"); }); Assert.Equal(e.Message, $"Vault name '{vaultName2}' doesn't exist in {region2}!"); e = Assert.Throws <VaultNotFoundException>(() => { clientRegion1.UploadArchive( new MemoryStream(Encoding.UTF8.GetBytes("321")), "sample description"); }); Assert.Equal(e.Message, $"Vault name '{vaultName1}' doesn't exist in {region1}!"); } }
public async Task can_get_correct_error_glacier(string region1, string region2) { var vaultName1 = $"testing-{Guid.NewGuid()}"; var vaultName2 = $"testing-{Guid.NewGuid()}"; using (var clientRegion1 = new RavenAwsGlacierClient(AwsAccessKey, AwsSecretKey, region1, vaultName1)) using (var clientRegion2 = new RavenAwsGlacierClient(AwsAccessKey, AwsSecretKey, region2, vaultName2)) { var e = await Assert.ThrowsAsync <VaultNotFoundException>(async() => { await clientRegion2.UploadArchive( new MemoryStream(Encoding.UTF8.GetBytes("321")), "sample description"); }); Assert.Equal(e.Message, $"Vault name '{vaultName2}' doesn't exist in {region2}!"); e = await Assert.ThrowsAsync <VaultNotFoundException>(async() => { await clientRegion1.UploadArchive( new MemoryStream(Encoding.UTF8.GetBytes("321")), "sample description"); }); Assert.Equal(e.Message, $"Vault name '{vaultName1}' doesn't exist in {region1}!"); } }
private void UploadToGlacier(string backupPath, PeriodicExportSetup localExportConfigs, bool isFullBackup) { using (var client = new RavenAwsGlacierClient(awsAccessKey, awsSecretKey, localExportConfigs.AwsRegionEndpoint ?? RavenAwsClient.DefaultRegion)) using (var fileStream = File.OpenRead(backupPath)) { var archiveId = client.UploadArchive(localExportConfigs.GlacierVaultName, fileStream, GetArchiveDescription(isFullBackup), 60 * 60); logger.Info(string.Format("Successfully uploaded backup {0} to Glacier, archive ID: {1}", Path.GetFileName(backupPath), archiveId)); } }
public void UploadArchive() { var glacierVaultName = "ravendb"; using (var client = new RavenAwsGlacierClient("<aws_access_key>", "<aws_secret_key>", "<aws_region_for_bucket>")) { var archiveId = client.UploadArchive(glacierVaultName, new MemoryStream(Encoding.UTF8.GetBytes("321")), "sample description", 60 * 60); Assert.NotNull(archiveId); } }
private void UploadToGlacier(string backupPath, PeriodicExportSetup localExportConfigs, bool isFullBackup) { if (awsAccessKey == Constants.DataCouldNotBeDecrypted || awsSecretKey == Constants.DataCouldNotBeDecrypted) { throw new InvalidOperationException("Could not decrypt the AWS access settings, if you are running on IIS, make sure that load user profile is set to true."); } using (var client = new RavenAwsGlacierClient(awsAccessKey, awsSecretKey, localExportConfigs.AwsRegionEndpoint ?? RavenAwsClient.DefaultRegion)) using (var fileStream = File.OpenRead(backupPath)) { var archiveId = client.UploadArchive(localExportConfigs.GlacierVaultName, fileStream, GetArchiveDescription(isFullBackup), 60 * 60); logger.Info(string.Format("Successfully uploaded backup {0} to Glacier, archive ID: {1}", Path.GetFileName(backupPath), archiveId)); } }
private void UploadToGlacier(GlacierSettings settings, Stream stream, Progress progress) { using (var client = new RavenAwsGlacierClient(settings, _settings.Configuration, progress, TaskCancelToken.Token)) { var key = CombinePathAndKey(settings.RemoteFolderName ?? _settings.DatabaseName); var archiveId = client.UploadArchive(stream, key); if (_logger.IsInfoEnabled) { _logger.Info($"{ReportSuccess(GlacierName)}, archive ID: {archiveId}"); } var runner = new GlacierRetentionPolicyRunner(_retentionPolicyParameters, client); runner.Execute(); } }
public async Task upload_archive(string region) { var vaultName = $"testing-{Guid.NewGuid()}"; using (var client = new RavenAwsGlacierClient(AwsAccessKey, AwsSecretKey, region, vaultName)) { await client.PutVault(); var archiveId = await client.UploadArchive( new MemoryStream(Encoding.UTF8.GetBytes("321")), "sample description"); Assert.NotNull(archiveId); } }
public void upload_archive(string region) { var vaultName = $"testing-{Guid.NewGuid()}"; using (var client = new RavenAwsGlacierClient(GetGlacierSettings(region, vaultName))) { client.PutVault(); var archiveId = client.UploadArchive( new MemoryStream(Encoding.UTF8.GetBytes("321")), "sample description"); Assert.NotNull(archiveId); } }
public void upload_archive_with_remote_folder_name(string region) { var vaultName = $"testing-{Guid.NewGuid()}"; var glacierSettings = GetGlacierSettings(region, vaultName); glacierSettings.RemoteFolderName = Guid.NewGuid().ToString(); using (var client = new RavenAwsGlacierClient(glacierSettings)) { client.PutVault(); var archiveId = client.UploadArchive( new MemoryStream(Encoding.UTF8.GetBytes("321")), "sample description"); Assert.NotNull(archiveId); } }
private async Task UploadToGlacier( GlacierSettings settings, Stream stream, string folderName, string fileName, Progress progress) { using (var client = new RavenAwsGlacierClient(settings.AwsAccessKey, settings.AwsSecretKey, settings.AwsRegionName, settings.VaultName, progress, TaskCancelToken.Token)) { var key = CombinePathAndKey(_database.Name, folderName, fileName); var archiveId = await client.UploadArchive(stream, key); if (_logger.IsInfoEnabled) { _logger.Info($"Successfully uploaded backup file '{fileName}' to Glacier, archive ID: {archiveId}"); } } }
private async Task UploadToGlacier(string exportPath, string fileName, bool isFullExport) { if (_awsAccessKey == Constants.DataCouldNotBeDecrypted || _awsSecretKey == Constants.DataCouldNotBeDecrypted) { throw new InvalidOperationException("Could not decrypt the AWS access settings, if you are running on IIS, make sure that load user profile is set to true."); } using (var client = new RavenAwsGlacierClient(_awsAccessKey, _awsSecretKey, _configuration.AwsRegionName ?? RavenAwsClient.DefaultRegion)) using (var fileStream = File.OpenRead(exportPath)) { var archiveId = await client.UploadArchive(_configuration.GlacierVaultName, fileStream, fileName, 60 *60); if (_logger.IsInfoEnabled) { _logger.Info($"Successfully uploaded export {fileName} to Glacier, archive ID: {archiveId}"); } } }
// ReSharper disable once InconsistentNaming private static async Task UploadArchive(string region, int sizeInMB, int minOnePartSizeInMB, UploadType uploadType) { var vaultName = $"testing-{Guid.NewGuid()}"; var uploadProgress = new UploadProgress(); var maxUploadArchiveSizeInBytes = ExpressionHelper.CreateFieldSetter <RavenAwsGlacierClient, int>("MaxUploadArchiveSizeInBytes"); var minOnePartUploadSizeLimitInBytes = ExpressionHelper.CreateFieldSetter <RavenAwsGlacierClient, int>("MinOnePartUploadSizeLimitInBytes"); using (var client = new RavenAwsGlacierClient(AwsAccessKey, AwsSecretKey, region, vaultName, uploadProgress)) { maxUploadArchiveSizeInBytes(client, 10 * 1024 * 1024); // 9MB minOnePartUploadSizeLimitInBytes(client, minOnePartSizeInMB * 1024 * 1024); await client.PutVault(); var sb = new StringBuilder(); for (var i = 0; i < sizeInMB * 1024 * 1024; i++) { sb.Append("a"); } long streamLength; using (var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(sb.ToString()))) { streamLength = memoryStream.Length; var archiveId = await client.UploadArchive(memoryStream, $"testing-upload-archive-{Guid.NewGuid()}"); Assert.NotNull(archiveId); } Assert.Equal(UploadState.Done, uploadProgress.UploadState); Assert.Equal(uploadType, uploadProgress.UploadType); Assert.Equal(streamLength, uploadProgress.TotalInBytes); Assert.Equal(streamLength, uploadProgress.UploadedInBytes); } }
// ReSharper disable once InconsistentNaming private static async Task UploadArchiveAsync(string region, int sizeInMB, int minOnePartSizeInMB, UploadType uploadType) { var vaultName = $"testing-{Guid.NewGuid()}"; var progress = new Progress(); using (var client = new RavenAwsGlacierClient(GetGlacierSettings(region, vaultName), DefaultConfiguration, progress)) { client.MaxUploadArchiveSize = new Size(9, SizeUnit.Megabytes); client.MinOnePartUploadSizeLimit = new Size(minOnePartSizeInMB, SizeUnit.Megabytes); await client.PutVaultAsync(); var sb = new StringBuilder(); for (var i = 0; i < sizeInMB * 1024 * 1024; i++) { sb.Append("a"); } long streamLength; using (var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(sb.ToString()))) { streamLength = memoryStream.Length; var archiveId = client.UploadArchive(memoryStream, $"testing-upload-archive-{Guid.NewGuid()}"); Assert.NotNull(archiveId); } Assert.Equal(UploadState.Done, progress.UploadProgress.UploadState); Assert.Equal(uploadType, progress.UploadProgress.UploadType); Assert.Equal(streamLength, progress.UploadProgress.TotalInBytes); Assert.Equal(streamLength, progress.UploadProgress.UploadedInBytes); } }
public async Task TestPeriodicBackupCredentials() { var type = GetQueryStringValueAndAssertIfSingleAndNotEmpty("type"); if (Enum.TryParse(type, out PeriodicBackupConnectionType connectionType) == false) { throw new ArgumentException($"Unknown backup connection: {type}"); } using (ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context)) { DynamicJsonValue result; try { var connectionInfo = await context.ReadForMemoryAsync(RequestBodyStream(), "test-connection"); switch (connectionType) { case PeriodicBackupConnectionType.S3: var s3Settings = JsonDeserializationClient.S3Settings(connectionInfo); using (var awsClient = new RavenAwsS3Client(s3Settings, ServerStore.Configuration.Backup, cancellationToken: ServerStore.ServerShutdown)) { awsClient.TestConnection(); } break; case PeriodicBackupConnectionType.Glacier: var glacierSettings = JsonDeserializationClient.GlacierSettings(connectionInfo); using (var glacierClient = new RavenAwsGlacierClient(glacierSettings, ServerStore.Configuration.Backup, cancellationToken: ServerStore.ServerShutdown)) { glacierClient.TestConnection(); } break; case PeriodicBackupConnectionType.Azure: var azureSettings = JsonDeserializationClient.AzureSettings(connectionInfo); using (var azureClient = RavenAzureClient.Create(azureSettings, ServerStore.Configuration.Backup, cancellationToken: ServerStore.ServerShutdown)) { azureClient.TestConnection(); } break; case PeriodicBackupConnectionType.GoogleCloud: var googleCloudSettings = JsonDeserializationClient.GoogleCloudSettings(connectionInfo); using (var googleCloudClient = new RavenGoogleCloudClient(googleCloudSettings, ServerStore.Configuration.Backup, cancellationToken: ServerStore.ServerShutdown)) { await googleCloudClient.TestConnection(); } break; case PeriodicBackupConnectionType.FTP: var ftpSettings = JsonDeserializationClient.FtpSettings(connectionInfo); using (var ftpClient = new RavenFtpClient(ftpSettings)) { ftpClient.TestConnection(); } break; case PeriodicBackupConnectionType.Local: case PeriodicBackupConnectionType.None: default: throw new ArgumentOutOfRangeException(); } result = new DynamicJsonValue { [nameof(NodeConnectionTestResult.Success)] = true, }; } catch (Exception e) { result = new DynamicJsonValue { [nameof(NodeConnectionTestResult.Success)] = false, [nameof(NodeConnectionTestResult.Error)] = e.ToString() }; } await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream())) { context.Write(writer, result); } } }
public GlacierRetentionPolicyRunner(RetentionPolicyBaseParameters parameters, RavenAwsGlacierClient client) : base(parameters) { _client = client; }