public async Task <IDictionary <string, string> > GetParameters(string path)
{
var request = new GetParametersByPathRequest()
{
Path = path,
WithDecryption = true,
Recursive = true
};
var response = await SimpleSystemsManagement.GetParametersByPathAsync(request);
return(response.Parameters.ToDictionary(p => p.Name, p => p.Value));
}
public IReadOnlyCollection <XElement> GetAllElements()
{
var request = new GetParametersByPathRequest
{
Path = "/CookieEncryptionKey"
};
var response = _client.GetParametersByPathAsync(request).Result;
var result = new List <XElement>(response.Parameters.Count);
response.Parameters.ForEach(x => result.Add(XElement.Parse(x.Value)));
return(result);
}
public override ICollection <KeyValuePair <string, string> > GetAllValues(string prefix)
{
if (_client == null)
{
return(null);
}
var request = new GetParametersByPathRequest
{
Path = $"{BaseParameterPath}/{prefix}",
WithDecryption = true,
};
var response = _client.GetParametersByPathAsync(request).Result;
var result = response.Parameters.ToDictionary(param => param.Name, param => param.Value, StringComparer.OrdinalIgnoreCase);
return(result);
}
private async Task <IReadOnlyCollection <XElement> > GetAllElementsAsync()
{
var request = new GetParametersByPathRequest
{
Path = _parameterNamePrefix,
WithDecryption = true
};
GetParametersByPathResponse response = null;
var results = new List <XElement>();
do
{
request.NextToken = response?.NextToken;
try
{
response = await _ssmClient.GetParametersByPathAsync(request);
}
catch (Exception e)
{
_logger.LogError($"Error calling SSM to get parameters starting with {_parameterNamePrefix}: {e.Message}");
throw;
}
foreach (var parameter in response.Parameters)
{
try
{
var xml = XElement.Parse(parameter.Value);
results.Add(xml);
}
catch (Exception e)
{
_logger.LogError($"Error parsing key {parameter.Name}, key will be skipped: {e.Message}");
}
}
} while(!string.IsNullOrEmpty(response.NextToken));
_logger.LogInformation($"Loaded {results.Count} DataProtection keys");
return(results);
}
//--- Extension Methods ---
public async static Task <Dictionary <string, KeyValuePair <string, string> > > GetAllParametersByPathAsync(this IAmazonSimpleSystemsManagement client, string path)
{
var parametersRequest = new GetParametersByPathRequest {
MaxResults = 10,
Recursive = true,
Path = path
};
var result = new Dictionary <string, KeyValuePair <string, string> >();
do
{
var response = await client.GetParametersByPathAsync(parametersRequest);
foreach (var parameter in response.Parameters)
{
result[parameter.Name] = new KeyValuePair <string, string>(parameter.Type, parameter.Value);
}
parametersRequest.NextToken = response.NextToken;
} while(parametersRequest.NextToken != null);
return(result);
}
private AppConfig()
{
var parameters = new List <Parameter>();
Parameters = new Dictionary <string, string>();
try
{
using (var client = new AmazonSimpleSystemsManagementClient())
{
var req = new GetParametersByPathRequest
{
Path = ParameterPath,
Recursive = true,
WithDecryption = true
};
string nextToken;
do
{
var result = client.GetParametersByPathAsync(req).Result;
Console.WriteLine($"api result parameters count: {result.Parameters.Count}");
parameters.AddRange(result.Parameters);
nextToken = result.NextToken;
} while (!string.IsNullOrEmpty(nextToken));
Console.WriteLine($"{parameters.Count} found");
foreach (var p in parameters)
{
var name = p.Name.Replace(ParameterPath, string.Empty);
Console.WriteLine($"found {name}");
var value = p.Value;
Parameters.Add(name, value);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private AppConfig()
{
List <Parameter> paramList = new List <Parameter>();
string nextToken = string.Empty;
Parameters = new Dictionary <string, string>();
var client = new AmazonSimpleSystemsManagementClient(RegionEndpoint.GetBySystemName(Region));
var request = new GetParametersByPathRequest
{
Path = ParameterPath,
Recursive = true,
WithDecryption = true
};
var task = client.GetParametersByPathAsync(request);
task.Wait();
paramList.AddRange(task.Result.Parameters);
nextToken = task.Result.NextToken;
while (!string.IsNullOrEmpty(nextToken))
{
request.NextToken = nextToken;
task = client.GetParametersByPathAsync(request);
task.Wait();
paramList.AddRange(task.Result.Parameters);
nextToken = task.Result.NextToken;
}
foreach (var p in paramList)
{
string name = p.Name.Replace(ParameterPath, string.Empty);
string value = p.Value;
Parameters.Add(name, value);
}
}
private async Task FillPhoneNumberOptionsAsync()
{
GetParametersByPathRequest request = new GetParametersByPathRequest
{
Path = PhoneNumberOptionsParameterPath,
WithDecryption = true,
};
GetParametersByPathResponse response = await _ssm.GetParametersByPathAsync(request);
PhoneNumberOptions.Clear();
IEnumerable <Parameter> sortedParameters = (from p in response.Parameters orderby p.Name select p);
foreach (Parameter parameter in sortedParameters)
{
PhoneNumberOptions.Add(new SelectListItem
{
Text = parameter.Name.Substring(parameter.Name.LastIndexOf('/') + 1),
Value = parameter.Value,
});
}
}
private async Task <IDictionary <string, string> > GetParametersAsync(IAmazonSimpleSystemsManagement ssm, string path)
{
var request = new GetParametersByPathRequest
{
Path = path,
MaxResults = 10,
WithDecryption = true,
Recursive = true
};
var result = new Dictionary <string, string>();
do
{
var response = await ssm.GetParametersByPathAsync(request).ConfigureAwait(false);
this.logger.LogInformation("EC2 ParameterStore has {ParametersCount} parameters in \'{ParametersPath}\'",
response.Parameters.Count,
path);
foreach (var resultParameter in response.Parameters)
{
LogParameter(resultParameter);
foreach (var kvp in BuildParameters(resultParameter, parseStringListAsList))
{
result.Add(kvp.Key, kvp.Value);
}
}
request.NextToken = response.NextToken;
} while (!string.IsNullOrEmpty(request.NextToken));
this.logger.LogInformation(
"EC2 ParameterStore has returned {TotalParametersCount} parameters in total",
result.Count);
return(result);
}
private async Task <GetParametersByPathResponse> GetParametersByPath(GetParametersByPathRequest request)
{
++NumTimesGetParamsByPathCalled;
var primaryResponse = new GetParametersByPathResponse
{
NextToken = "some-token",
Parameters = new List <Parameter>
{
new Parameter
{
Name = "/app/someapp/dev/thing/testing/name1",
Value = "value1"
}
}
};
var secondaryResponse = new GetParametersByPathResponse
{
NextToken = null,
Parameters = new List <Parameter>
{
new Parameter
{
Name = "/app/someapp/dev/thing/testing/name2",
Value = "value2"
}
}
};
var response = primaryResponse;
if (NumTimesGetParamsByPathCalled > 1)
{
response = secondaryResponse;
}
return(await Task.FromResult(response));
}
/// <summary>
/// Can be overridden by a mocking framework, but shouldn't be overridden for production purposes.
/// </summary>
private void Initialize()
{
var parameters = new List <Parameter>();
Parameters = new Dictionary <string, string>();
try
{
using (var client = _injector.GetSsmClient(_region))
{
var req = new GetParametersByPathRequest
{
Path = _parameterPath ?? "/",
Recursive = true,
WithDecryption = true
};
do
{
var result = client.GetParametersByPathAsync(req).Result;
req.NextToken = result.NextToken;
parameters.AddRange(result.Parameters);
} while (!string.IsNullOrEmpty(req.NextToken));
foreach (var p in parameters)
{
var key = Regex.Match(p.Name, _keyPattern).Groups["key"].Value;
var value = p.Value;
Parameters.Add(key, value);
}
}
}
catch (Exception e)
{
Console.WriteLine($"could not get params {e}"); //just log it on the console for now.
throw;
}
}
