public static void UpdateSettingsForGlacier(GlacierSettings glacierSettings, string databaseName)
{
if (glacierSettings != null)
{
glacierSettings.RemoteFolderName = GetUpdatedPath(glacierSettings.RemoteFolderName, databaseName);
}
}
public RavenAwsGlacierClient(GlacierSettings glacierSettings, Progress progress = null, CancellationToken?cancellationToken = null)
: base(glacierSettings, progress, cancellationToken)
{
if (string.IsNullOrWhiteSpace(glacierSettings.VaultName))
{
throw new ArgumentException("AWS vault name can't be null or empty");
}
_vaultName = glacierSettings.VaultName;
}
public RavenAwsGlacierClient(GlacierSettings glacierSettings, Config.Categories.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 override DynamicJsonValue ToJson()
{
var json = base.ToJson();
json[nameof(LocalSettings)] = LocalSettings?.ToJson();
json[nameof(S3Settings)] = S3Settings?.ToJson();
json[nameof(AzureSettings)] = AzureSettings?.ToJson();
json[nameof(GlacierSettings)] = GlacierSettings?.ToJson();
json[nameof(GoogleCloudSettings)] = GoogleCloudSettings?.ToJson();
json[nameof(FtpSettings)] = FtpSettings?.ToJson();
return(json);
}
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 RavenAwsGlacierClient(GlacierSettings glacierSettings, Progress progress = null, Logger logger = null, CancellationToken?cancellationToken = null)
: base(glacierSettings, progress, cancellationToken)
{
if (string.IsNullOrWhiteSpace(glacierSettings.VaultName))
{
throw new ArgumentException("AWS vault name can't be null or empty");
}
if (string.IsNullOrWhiteSpace(glacierSettings.AwsRegionName))
{
throw new ArgumentException("AWS region cannot be null or empty");
}
AwsRegion = glacierSettings.AwsRegionName.ToLower();
_vaultName = glacierSettings.VaultName;
_logger = logger;
}
protected override void ValidateImpl(ref List <string> errors)
{
if (S3Settings != null)
{
if (S3Settings.HasSettings() == false)
{
errors.Add($"{nameof(S3Settings)} has no valid setting. '{nameof(S3Settings.BucketName)}' and '{nameof(GetBackupConfigurationScript)}' are both null");
}
}
if (AzureSettings != null)
{
if (AzureSettings.HasSettings() == false)
{
errors.Add($"{nameof(AzureSettings)} has no valid setting. '{nameof(AzureSettings.StorageContainer)}' and '{nameof(GetBackupConfigurationScript)}' are both null");
}
}
if (GlacierSettings != null)
{
if (GlacierSettings.HasSettings() == false)
{
errors.Add($"{nameof(GlacierSettings)} has no valid setting. '{nameof(GlacierSettings.VaultName)}' and '{nameof(GetBackupConfigurationScript)}' are both null");
}
}
if (GoogleCloudSettings != null)
{
if (GoogleCloudSettings.HasSettings() == false)
{
errors.Add($"{nameof(GoogleCloudSettings)} has no valid setting. '{nameof(GoogleCloudSettings.BucketName)}' and '{nameof(GetBackupConfigurationScript)}' are both null");
}
}
if (FtpSettings != null)
{
if (FtpSettings.HasSettings() == false)
{
errors.Add($"{nameof(FtpSettings)} has no valid setting. '{nameof(FtpSettings.Port)}' is 0 and '{nameof(FtpSettings.Url)}' and '{nameof(GetBackupConfigurationScript)}' are both null");
}
}
if (LocalSettings != null)
{
if (LocalSettings.HasSettings() == false)
{
errors.Add($"{nameof(LocalSettings)} has no valid setting. '{nameof(LocalSettings.FolderPath)}' and '{nameof(GetBackupConfigurationScript)}' are both null");
}
}
}
static AmazonGlacierTheoryAttribute()
{
var glacierSettingsString = Environment.GetEnvironmentVariable(GlacierCredentialEnvironmentVariable);
if (glacierSettingsString == null)
{
EnvVariableMissing = true;
return;
}
try
{
_glacierSettings = JsonConvert.DeserializeObject <GlacierSettings>(glacierSettingsString);
}
catch (Exception e)
{
ParsingError = e.ToString();
}
}
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 static GlacierSettings GetGlacierSettings(string region, string vaultName)
{
var glacierSettings = AmazonGlacierFactAttribute.GlacierSettings;
if (glacierSettings == null)
{
return(null);
}
var settings = new GlacierSettings
{
VaultName = vaultName,
AwsAccessKey = glacierSettings.AwsAccessKey,
AwsSecretKey = glacierSettings.AwsSecretKey,
AwsRegionName = region
};
return(settings);
}
public bool Equals(GlacierSettings other)
{
if (other == null)
{
return(false);
}
if (WasEnabled(other))
{
return(true);
}
if (other.AwsRegionName != AwsRegionName)
{
return(false);
}
if (other.VaultName != VaultName)
{
return(false);
}
return(true);
}
