AWSCredentialsProvider.h

Go to the documentation of this file.

 
#pragma once
 
#include <aws/core/Core_EXPORTS.h>
#include <aws/core/utils/UnreferencedParam.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/threading/ReaderWriterLock.h>
#include <aws/core/internal/AWSHttpResourceClient.h>
#include <aws/core/auth/AWSCredentials.h>
#include <aws/core/config/AWSProfileConfigLoader.h>
#include <aws/core/client/RetryStrategy.h>
#include <memory>
 
namespace Aws
{
    namespace Auth
    {
        constexpr int REFRESH_THRESHOLD = 1000 * 60 * 5;
 
        AWS_CORE_API Aws::String GetConfigProfileFilename(); //defaults to "config"
 
        AWS_CORE_API Aws::String GetConfigProfileName(); //defaults to "default"
 
        /*
         * Fetches credentials by executing the process in the parameter
         */
        AWS_CORE_API AWSCredentials GetCredentialsFromProcess(const Aws::String& process);
 
        class AWS_CORE_API AWSCredentialsProvider
        {
        public:
            AWSCredentialsProvider() : m_lastLoadedMs(0)
            {
            }
 
            virtual ~AWSCredentialsProvider() = default;
 
            virtual AWSCredentials GetAWSCredentials() = 0;
 
        protected:
            virtual bool IsTimeToRefresh(long reloadFrequency);
            virtual void Reload();
            mutable Aws::Utils::Threading::ReaderWriterLock m_reloadLock;
        private:
            long long m_lastLoadedMs;
        };
 
        class AWS_CORE_API AnonymousAWSCredentialsProvider : public AWSCredentialsProvider
        {
        public:
            inline AWSCredentials GetAWSCredentials() override { return AWSCredentials(); }
        };
 
        class AWS_CORE_API SimpleAWSCredentialsProvider : public AWSCredentialsProvider
        {
        public:
            inline SimpleAWSCredentialsProvider(const Aws::String& awsAccessKeyId, const Aws::String& awsSecretAccessKey, const Aws::String& sessionToken = "")
                : m_credentials(awsAccessKeyId, awsSecretAccessKey, sessionToken)
            { }
 
            inline SimpleAWSCredentialsProvider(const AWSCredentials& credentials)
                : m_credentials(credentials)
            { }
 
            inline AWSCredentials GetAWSCredentials() override
            {
                return m_credentials;
            }
 
        private:
            AWSCredentials m_credentials;
        };
 
        class AWS_CORE_API EnvironmentAWSCredentialsProvider : public AWSCredentialsProvider
        {
        public:
            AWSCredentials GetAWSCredentials() override;
        };
 
        class AWS_CORE_API ProfileConfigFileAWSCredentialsProvider : public AWSCredentialsProvider
        {
        public:
 
            ProfileConfigFileAWSCredentialsProvider(long refreshRateMs = REFRESH_THRESHOLD);
 
            ProfileConfigFileAWSCredentialsProvider(const char* profile, long refreshRateMs = REFRESH_THRESHOLD);
 
            AWSCredentials GetAWSCredentials() override;
 
            static Aws::String GetCredentialsProfileFilename();
 
            static Aws::String GetProfileDirectory();
 
        protected:
            void Reload() override;
        private:
 
            void RefreshIfExpired();
 
            Aws::String m_profileToUse;
            Aws::Config::AWSConfigFileProfileConfigLoader m_credentialsFileLoader;
            long m_loadFrequencyMs;
        };
 
        class AWS_CORE_API InstanceProfileCredentialsProvider : public AWSCredentialsProvider
        {
        public:
            InstanceProfileCredentialsProvider(long refreshRateMs = REFRESH_THRESHOLD);
 
            InstanceProfileCredentialsProvider(const std::shared_ptr<Aws::Config::EC2InstanceProfileConfigLoader>&, long refreshRateMs = REFRESH_THRESHOLD);
 
            AWSCredentials GetAWSCredentials() override;
 
        protected:
            void Reload() override;
 
        private:
            void RefreshIfExpired();
 
            std::shared_ptr<Aws::Config::AWSProfileConfigLoader> m_ec2MetadataConfigLoader;
            long m_loadFrequencyMs;
        };
 
        class AWS_CORE_API TaskRoleCredentialsProvider : public AWSCredentialsProvider
        {
        public:
            TaskRoleCredentialsProvider(const char* resourcePath, long refreshRateMs = REFRESH_THRESHOLD);
 
            TaskRoleCredentialsProvider(const char* endpoint, const char* token, long refreshRateMs = REFRESH_THRESHOLD);
 
            TaskRoleCredentialsProvider(const std::shared_ptr<Aws::Internal::ECSCredentialsClient>& client,
                    long refreshRateMs = REFRESH_THRESHOLD);
            AWSCredentials GetAWSCredentials() override;
 
        protected:
            void Reload() override;
        private:
            bool ExpiresSoon() const;
            void RefreshIfExpired();
 
        private:
            std::shared_ptr<Aws::Internal::ECSCredentialsClient> m_ecsCredentialsClient;
            long m_loadFrequencyMs;
            Aws::Auth::AWSCredentials m_credentials;
        };
 
        class AWS_CORE_API ProcessCredentialsProvider : public AWSCredentialsProvider
        {
        public:
            ProcessCredentialsProvider();
 
            ProcessCredentialsProvider(const Aws::String& profile);
 
            AWSCredentials GetAWSCredentials() override;
 
        protected:
            void Reload() override;
        private:
            void RefreshIfExpired();
 
        private:
            Aws::String m_profileToUse;
            Aws::Auth::AWSCredentials m_credentials;
        };
    } // namespace Auth
} // namespace Aws