fgerlits commented on code in PR #2269:
URL: https://github.com/apache/nifi-minifi-cpp/pull/2269#discussion_r4642468267
##########
extensions/aws/controllerservices/AWSCredentialsService.cpp:
##########
@@ -14,25 +18,49 @@ void AWSCredentialsService::initialize() {
}
void AWSCredentialsService::onEnable() {
+ AWSCredentialsProviderSettings settings;
if (const auto access_key = getProperty(AccessKey.name)) {
- aws_credentials_provider_.setAccessKey(*access_key);
+ settings.access_key = *access_key;
}
if (const auto secret_key = getProperty(SecretKey.name)) {
- aws_credentials_provider_.setSecretKey(*secret_key);
+ settings.secret_key = *secret_key;
}
if (const auto credentials_file = getProperty(CredentialsFile.name)) {
- aws_credentials_provider_.setCredentialsFile(*credentials_file);
+ settings.credentials_file = *credentials_file;
+ }
+ if (const auto profile_name = getProperty(ProfileName.name)) {
+ settings.profile_name = *profile_name;
+ }
+ if (const auto sso_profile_name = getProperty(SSOProfileName.name)) {
+ settings.sso_profile_name = *sso_profile_name;
}
- if (const auto use_credentials = getProperty(UseDefaultCredentials.name) |
minifi::utils::andThen(parsing::parseBool)) {
- aws_credentials_provider_.setUseDefaultCredentials(*use_credentials);
+ if (const auto use_default_credentials =
getProperty(UseDefaultCredentials.name) |
minifi::utils::andThen(parsing::parseBool); use_default_credentials &&
*use_default_credentials) {
+ settings.credential_configuration_strategy =
CredentialConfigurationStrategyOption::DefaultCredentials;
}
+
+ if (const auto credential_configuration_strategy =
getProperty(CredentialConfigurationStrategy.name)) {
+ if (auto strategy =
magic_enum::enum_cast<CredentialConfigurationStrategyOption>(*credential_configuration_strategy,
magic_enum::case_insensitive)) {
+ if (settings.credential_configuration_strategy) {
+ throw Exception(PROCESS_SCHEDULE_EXCEPTION, fmt::format("Both {0} and
{1} properties are set! Only one of them should be set, please prefer using the
{0} property",
+
CredentialConfigurationStrategy.name, UseDefaultCredentials.name));
Review Comment:
We could be nice to the user, and only throw if `UseDefaultCredentials ==
true` and `CredentialConfigurationStrategy` is set _and_
`CredentialConfigurationStrategy != DefaultCredentials`.
##########
extensions/aws/controllerservices/AWSCredentialsService.cpp:
##########
@@ -14,25 +18,49 @@ void AWSCredentialsService::initialize() {
}
void AWSCredentialsService::onEnable() {
+ AWSCredentialsProviderSettings settings;
if (const auto access_key = getProperty(AccessKey.name)) {
- aws_credentials_provider_.setAccessKey(*access_key);
+ settings.access_key = *access_key;
}
if (const auto secret_key = getProperty(SecretKey.name)) {
- aws_credentials_provider_.setSecretKey(*secret_key);
+ settings.secret_key = *secret_key;
}
if (const auto credentials_file = getProperty(CredentialsFile.name)) {
- aws_credentials_provider_.setCredentialsFile(*credentials_file);
+ settings.credentials_file = *credentials_file;
+ }
+ if (const auto profile_name = getProperty(ProfileName.name)) {
+ settings.profile_name = *profile_name;
+ }
+ if (const auto sso_profile_name = getProperty(SSOProfileName.name)) {
+ settings.sso_profile_name = *sso_profile_name;
}
- if (const auto use_credentials = getProperty(UseDefaultCredentials.name) |
minifi::utils::andThen(parsing::parseBool)) {
- aws_credentials_provider_.setUseDefaultCredentials(*use_credentials);
+ if (const auto use_default_credentials =
getProperty(UseDefaultCredentials.name) |
minifi::utils::andThen(parsing::parseBool); use_default_credentials &&
*use_default_credentials) {
+ settings.credential_configuration_strategy =
CredentialConfigurationStrategyOption::DefaultCredentials;
}
+
+ if (const auto credential_configuration_strategy =
getProperty(CredentialConfigurationStrategy.name)) {
+ if (auto strategy =
magic_enum::enum_cast<CredentialConfigurationStrategyOption>(*credential_configuration_strategy,
magic_enum::case_insensitive)) {
+ if (settings.credential_configuration_strategy) {
+ throw Exception(PROCESS_SCHEDULE_EXCEPTION, fmt::format("Both {0} and
{1} properties are set! Only one of them should be set, please prefer using the
{0} property",
+
CredentialConfigurationStrategy.name, UseDefaultCredentials.name));
+ }
+ settings.credential_configuration_strategy = strategy;
+ } else {
+ throw Exception(PROCESS_SCHEDULE_EXCEPTION, fmt::format("Invalid value
for {} property: {}", CredentialConfigurationStrategy.name,
*credential_configuration_strategy));
+ }
+ }
+
+ std::lock_guard<std::mutex> lock(credentials_provider_mutex_);
+ credentials_provider_settings_ = std::move(settings);
+ credentials_provider_.reset();
}
-std::optional<Aws::Auth::AWSCredentials>
AWSCredentialsService::getAWSCredentials() {
- if (aws_credentials_provider_.getUseDefaultCredentials() ||
!aws_credentials_ || aws_credentials_->IsExpiredOrEmpty()) {
- aws_credentials_ = aws_credentials_provider_.getAWSCredentials();
+std::shared_ptr<Aws::Auth::AWSCredentialsProvider>
AWSCredentialsService::getAWSCredentialsProvider() {
+ std::lock_guard<std::mutex> lock(credentials_provider_mutex_);
+ if (!credentials_provider_) {
+ credentials_provider_ =
createAWSCredentialsProvider(credentials_provider_settings_, *logger_);
}
- return aws_credentials_;
+ return credentials_provider_;
Review Comment:
Here we hold the mutex for a long time, including during AWS library calls,
which is generally a bad idea. We could create the credentials provider object
outside the lock, and assign it to `credentials_provider_` under the lock.
##########
extensions/aws/processors/AwsProcessor.cpp:
##########
@@ -19,36 +19,35 @@
namespace org::apache::nifi::minifi::aws::processors {
-std::optional<Aws::Auth::AWSCredentials>
AwsProcessor::getAWSCredentialsFromControllerService(core::ProcessContext&
context) const {
+std::shared_ptr<Aws::Auth::AWSCredentialsProvider>
AwsProcessor::getAWSCredentialsProviderFromControllerService(core::ProcessContext&
context) const {
if (auto service =
minifi::utils::parseOptionalControllerService<controllers::AWSCredentialsService>(context,
AWSCredentialsProviderService, getUUID())) {
- return service->getAWSCredentials();
+ return service->getAWSCredentialsProvider();
}
Review Comment:
Here we don't distinguish the case when `service` is null (i.e., not set)
and when it is non-null but `service->getAWSCredentialsProvider()` returns null
(i.e., some of the properties of the controller service are set incorrectly);
we are falling back to the deprecated processor properties in both cases.
I think that in the first case, falling back is correct, but in the second
case, we should throw and fail to schedule the processor instead of falling
back.
##########
extensions/aws/AWSCredentialsProviderFactory.cpp:
##########
@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: See the NOTICE file distributed with this work for
additional information regarding copyright ownership
+// SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF)
under one or more contributor license agreements
+
+#include "AWSCredentialsProviderFactory.h"
+
+#include <filesystem>
+#include <string>
+#include <string_view>
+
+#include "aws/core/auth/AWSCredentialsProviderChain.h"
+#include "aws/core/auth/ProfileCredentialsProvider.h"
+#include "aws/core/auth/SSOCredentialsProvider.h"
+#include "aws/core/auth/STSCredentialsProvider.h"
+#include "minifi-cpp/properties/Properties.h"
+
+namespace org::apache::nifi::minifi::aws {
+
+namespace {
+
+std::shared_ptr<Aws::Auth::AWSCredentialsProvider> probeProvider(const
std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& provider,
+ std::string_view credentials_source, core::logging::Logger& logger) {
+ if (provider->GetAWSCredentials().IsEmpty()) {
+ logger.log_error("No AWS credentials were found in {}.",
credentials_source);
+ return nullptr;
+ }
+ logger.log_debug("Using AWS credentials from {}.", credentials_source);
+ return provider;
+}
+
+std::shared_ptr<Aws::Auth::AWSCredentialsProvider>
createProviderFromCredentialsFile(const std::string& credentials_file,
+ core::logging::Logger& logger) {
+ if (!std::filesystem::exists(credentials_file)) {
+ logger.log_error("The specified credentials file does not exist!");
+ return nullptr;
+ }
+
+ auto properties = minifi::Properties::create();
+ properties->loadConfigureFile(credentials_file.c_str());
+ std::string access_key;
+ std::string secret_key;
+ if (properties->getString("accessKey", access_key) && !access_key.empty() &&
properties->getString("secretKey", secret_key) &&
+ !secret_key.empty()) {
+ logger.log_debug("Using AWS credentials from credentials file.");
+ return
std::make_shared<Aws::Auth::SimpleAWSCredentialsProvider>(access_key,
secret_key);
+ }
+ logger.log_error("No AWS credentials were found in the credentials file.");
+ return nullptr;
+}
+
+} // namespace
+
+std::shared_ptr<Aws::Auth::AWSCredentialsProvider>
createAWSCredentialsProvider(const AWSCredentialsProviderSettings& settings,
+ core::logging::Logger& logger) {
+ if (!settings.credential_configuration_strategy) {
+ if (!settings.access_key.empty() && !settings.secret_key.empty()) {
+ logger.log_debug("Using access key and secret key as AWS credentials.");
+ return
std::make_shared<Aws::Auth::SimpleAWSCredentialsProvider>(settings.access_key,
settings.secret_key);
+ }
+
+ if (!settings.credentials_file.empty()) {
+ if (auto credentials_file_provider =
createProviderFromCredentialsFile(settings.credentials_file, logger)) {
+ return credentials_file_provider;
+ }
+ }
+
+ logger.log_error("No Credential Configuration Strategy was set and no AWS
credentials were set.");
+ return nullptr;
+ }
+
+ const auto strategy = *settings.credential_configuration_strategy;
+ if (strategy == CredentialConfigurationStrategyOption::FromProperties) {
+ if (settings.access_key.empty() || settings.secret_key.empty()) {
+ logger.log_error("Access key or secret key is missing for FromProperties
strategy.");
+ return nullptr;
+ }
+ logger.log_debug("Using access key and secret key as AWS credentials.");
+ return
std::make_shared<Aws::Auth::SimpleAWSCredentialsProvider>(settings.access_key,
settings.secret_key);
+ } else if (strategy ==
CredentialConfigurationStrategyOption::CredentialsFile) {
+ if (settings.credentials_file.empty()) {
+ logger.log_error("Credentials file path is empty for CredentialsFile
strategy.");
+ return nullptr;
+ }
+ return createProviderFromCredentialsFile(settings.credentials_file,
logger);
+ } else if (strategy ==
CredentialConfigurationStrategyOption::DefaultCredentials) {
+ logger.log_debug("Trying to use default AWS credentials provider chain.");
+ return
probeProvider(std::make_shared<Aws::Auth::DefaultAWSCredentialsProviderChain>(),
"the default AWS credentials provider chain", logger);
+ } else if (strategy ==
CredentialConfigurationStrategyOption::EnvironmentVariables) {
+ return
probeProvider(std::make_shared<Aws::Auth::EnvironmentAWSCredentialsProvider>(),
"environment variables", logger);
+ } else if (strategy ==
CredentialConfigurationStrategyOption::ProfileCredentials) {
+ auto profile_provider = settings.profile_name.empty()
+ ? std::make_shared<Aws::Auth::ProfileCredentialsProvider>()
+ :
std::make_shared<Aws::Auth::ProfileCredentialsProvider>(settings.profile_name.c_str());
+ return probeProvider(profile_provider, "profile", logger);
+ } else if (strategy ==
CredentialConfigurationStrategyOption::InstanceProfileCredentials) {
+ return
probeProvider(std::make_shared<Aws::Auth::InstanceProfileCredentialsProvider>(),
"instance profile", logger);
+ } else if (strategy ==
CredentialConfigurationStrategyOption::AnonymousCredentials) {
+ logger.log_debug("Using anonymous AWS credentials.");
+ return std::make_shared<Aws::Auth::AnonymousAWSCredentialsProvider>();
+ } else if (strategy ==
CredentialConfigurationStrategyOption::SSOCredentials) {
+ auto sso_provider = settings.sso_profile_name.empty()
+ ? std::make_shared<Aws::Auth::SSOCredentialsProvider>()
+ :
std::make_shared<Aws::Auth::SSOCredentialsProvider>(settings.sso_profile_name);
+ return probeProvider(sso_provider, "SSO", logger);
+ } else if (strategy ==
CredentialConfigurationStrategyOption::STSAssumeRoleWebIdentityCredentials) {
+ return
probeProvider(std::make_shared<Aws::Auth::STSAssumeRoleWebIdentityCredentialsProvider>(),
"STS Assume Role Web Identity", logger);
Review Comment:
Very minor, but since the user-facing name of this option is "STS Web
Identity", maybe we should print that in the log message, too?
We could also rename the option, as this is the only one in the
`CredentialConfigurationStrategyOption` enum where the internal and external
names are different.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]