private async Task StoreElementAsync(XElement element, string friendlyName)
{
var parameterName = _parameterNamePrefix +
(friendlyName ??
element.Attribute("id")?.Value ??
Guid.NewGuid().ToString());
try
{
var request = new PutParameterRequest
{
Name = parameterName,
Value = element.ToString(),
Type = ParameterType.SecureString,
Description = "ASP.NET Core DataProtection Key"
};
if (!string.IsNullOrEmpty(_options.KMSKeyId))
{
request.KeyId = _options.KMSKeyId;
}
await _ssmClient.PutParameterAsync(request);
_logger.LogInformation($"Saved DataProtection key to SSM Parameter Store with parameter name {parameterName}");
}
catch (Exception e)
{
_logger.LogError($"Error saving DataProtection key to SSM Parameter Store with parameter name {parameterName}: {e.Message}");
throw;
}
}
public async Task <PutParameterResponse> CreateParameter(PutParameterRequest parameterToCreate)
{
using (var client = new AmazonSimpleSystemsManagementClient())
{
return(await client.PutParameterAsync(parameterToCreate));
}
}
public void updateValue(SSMStructure structure)
{
PutParameterRequest request = new PutParameterRequest();
request.Overwrite = true;
request.Name = Resources.ssmParameter;
request.Value = JsonConvert.SerializeObject(structure);
client.PutParameter(request);
}
private async Task UpdateMessageAsync()
{
PutParameterRequest request = new PutParameterRequest
{
Name = MessageParameterName,
Overwrite = true,
Value = Message,
};
await _ssm.PutParameterAsync(request);
}
private async Task UpdatePhoneNumberAsync()
{
PutParameterRequest request = new PutParameterRequest
{
Name = TargetPhoneNumberParameterName,
Overwrite = true,
Value = PhoneNumber,
};
await _ssm.PutParameterAsync(request);
}
static async Task PutParameterAsync(IAmazonSimpleSystemsManagement ssm, string name, string value)
{
var request = new PutParameterRequest
{
Name = name,
Value = value,
Type = ParameterType.SecureString,
Overwrite = true
};
await ssm.PutParameterAsync(request).ConfigureAwait(false);
}
public void StoreElement(XElement element, string friendlyName)
{
var request = new PutParameterRequest
{
Name = "/CookieEncryptionKey/" + friendlyName,
Value = element.ToString(),
Description = "Key-" + friendlyName,
Overwrite = true,
Type = ParameterType.String
};
_client.PutParameterAsync(request);
}
private async Task <string> PutSecureParameter(string parameterName, string value)
{
var client = new AmazonSimpleSystemsManagementClient(RegionEndpoint.APSoutheast2);
var request = new PutParameterRequest
{
Name = parameterName,
Overwrite = true,
Value = value,
Type = ParameterType.SecureString
};
var response = await client.PutParameterAsync(request);
return(response.ToString());
}
public async Task <Result> UpdateElectionConfig(ElectionsConfig config)
{
var putParameterRequest = new PutParameterRequest
{
Name = $"/{Consts.PARAMETER_STORE_NAME}/settings/electionsConfig",
Value = JsonConvert.SerializeObject(config),
Type = ParameterType.String,
Overwrite = true
};
var response = await _amazonSettingsClient.PutParameterAsync(putParameterRequest);
if (response.HttpStatusCode == HttpStatusCode.OK)
{
return(Result.Ok());
}
return(Result.Failure("Couldn't update the job timer"));
}
public async Task <Result> UpdateInterval(int seconds)
{
var putParameterRequest = new PutParameterRequest
{
Name = $"/{Consts.PARAMETER_STORE_NAME}/settings/intervalInSeconds",
Value = seconds.ToString(),
Type = ParameterType.String,
Overwrite = true
};
var response = await _amazonSettingsClient.PutParameterAsync(putParameterRequest);
if (response.HttpStatusCode == HttpStatusCode.OK)
{
return(Result.Ok());
}
return(Result.Failure("Couldn't update the job timer"));
}
public async override Task <ParameterDto> Handle(AddOrUpdateParameterCommand command, CancellationToken cancellationToken = default)
{
using var client = _awsClientFactory.Create <AmazonSimpleSystemsManagementClient>(command.AssumeProfile);
ParameterDto result = null;
var request = new PutParameterRequest()
{
Name = command.Parameter.Name,
Value = command.Parameter.Value,
Type = command.Parameter.ParamType,
Overwrite = command.Parameter.Overwrite,
Tags = command.Parameter.Tags?.Select(kv => new Tag {
Key = kv.Key, Value = kv.Value
}).ToList()
};
try
{
var response = await client.PutParameterAsync(request, cancellationToken);
if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
result = new ParameterDto
{
Name = command.Parameter.Name,
Overwrite = command.Parameter.Overwrite,
Value = command.Parameter.Value,
Version = command.Parameter.Version,
Tags = command.Parameter.Tags,
ParamType = command.Parameter.ParamType
};
}
}
catch (AmazonServiceException e)
{
throw new Exception(e.Message, e);
}
return(result);
}
/// <inheritdoc />
/// <summary>
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
/// <param name="secure"></param>
public async Task PutParameter(string name, string value, bool secure = true)
{
using (var client = _injector.GetSsmClient(_region))
{
var fullName = $"{_parameterPath}/{name}";
Console.WriteLine(fullName);
var putRequest = new PutParameterRequest
{
Name = fullName
, Overwrite = true
, Value = value
, Type = secure ? ParameterType.SecureString : ParameterType.String
};
var putResponse = await client.PutParameterAsync(putRequest);
if (putResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new Exception("unable to put the parameter");
}
}
}
public async Task <ActionResult> SetIntervalInSeconds([FromQuery] int seconds)
{
try
{
var putParameterRequest = new PutParameterRequest
{
Name = $"/{Consts.ParameterStoreName}/settings/intervalInSeconds",
Value = seconds.ToString(),
Type = ParameterType.String,
Overwrite = true
};
var response = await _amazonSettingsClient.PutParameterAsync(putParameterRequest);
if (response.HttpStatusCode == HttpStatusCode.OK)
{
return(Ok(response));
}
return(BadRequest("Couldn't update the value"));
}
catch (Exception e)
{
throw;
}
}
public static async Task UpdateParameter(string value, string parameterKey)
{
var request = new PutParameterRequest()
{
Name = parameterKey,
Value = value,
Type = ParameterType.String,
Overwrite = true,
};
try
{
using (var client = new AmazonSimpleSystemsManagementClient())
{
await client.PutParameterAsync(request);
Console.WriteLine($"Parameter {parameterKey} updated successfully");
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"Failed to put parameter {parameterKey}, Error message: {ex.Message}");
}
}
/// <summary>
/// Add one or more paramaters to the system.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the PutParameter service method.</param>
///
/// <returns>The response from the PutParameter service method, as returned by SimpleSystemsManagement.</returns>
/// <exception cref="Amazon.SimpleSystemsManagement.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
/// <exception cref="Amazon.SimpleSystemsManagement.Model.InvalidKeyIdException">
/// The query key ID is not valid.
/// </exception>
/// <exception cref="Amazon.SimpleSystemsManagement.Model.ParameterAlreadyExistsException">
/// The parameter already exists. You can't create duplicate parameters.
/// </exception>
/// <exception cref="Amazon.SimpleSystemsManagement.Model.ParameterLimitExceededException">
/// You have exceeded the number of parameters for this AWS account. Delete one or more
/// parameters and try again.
/// </exception>
/// <exception cref="Amazon.SimpleSystemsManagement.Model.TooManyUpdatesException">
/// There are concurrent updates for a resource that supports one update at a time.
/// </exception>
/// <exception cref="Amazon.SimpleSystemsManagement.Model.UnsupportedParameterTypeException">
/// The parameter type is not supported.
/// </exception>
public PutParameterResponse PutParameter(PutParameterRequest request)
{
var marshaller = new PutParameterRequestMarshaller();
var unmarshaller = PutParameterResponseUnmarshaller.Instance;
return Invoke<PutParameterRequest,PutParameterResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Initiates the asynchronous execution of the PutParameter operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutParameter operation on AmazonSimpleSystemsManagementClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutParameter
/// operation.</returns>
public IAsyncResult BeginPutParameter(PutParameterRequest request, AsyncCallback callback, object state)
{
var marshaller = new PutParameterRequestMarshaller();
var unmarshaller = PutParameterResponseUnmarshaller.Instance;
return BeginInvoke<PutParameterRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// Initiates the asynchronous execution of the PutParameter operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutParameter operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<PutParameterResponse> PutParameterAsync(PutParameterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new PutParameterRequestMarshaller();
var unmarshaller = PutParameterResponseUnmarshaller.Instance;
return InvokeAsync<PutParameterRequest,PutParameterResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
