Skip to content

rollback smithy s3 client changes #3294

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
sbiscigl wants to merge 1 commit into from
Closed

rollback smithy s3 client changes #3294

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
32 changes: 8 additions & 24 deletions generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Client.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,22 +4,14 @@
*/

#pragma once

#include <aws/s3/S3_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/s3/S3ServiceClientModel.h>
#include <smithy/client/AwsSmithyClient.h>
#include <smithy/identity/auth/built-in/SigV4MultiAuthResolver.h>
#include <smithy/identity/auth/built-in/SigV4AuthScheme.h>
#include <smithy/identity/auth/built-in/SigV4aAuthScheme.h>
#include <aws/s3/S3ExpressSigV4AuthScheme.h>
#include <smithy/client/serializer/XmlOutcomeSerializer.h>
#include <aws/core/auth/AWSAuthSigner.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/core/utils/DNS.h>

#include <aws/s3/S3ErrorMarshaller.h>


#include <aws/s3/S3ServiceClientModel.h>

// TODO: temporary fix for naming conflicts on Windows.
#ifdef _WIN32
Expand All @@ -40,28 +32,19 @@ namespace Aws
static const char SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY[] = "x-amz-server-side-encryption-customer-key";
static const char SERVER_SIDE_ENCRYPTION_CUSTOMER_KEY_MD5[] = "x-amz-server-side-encryption-customer-key-MD5";
} // SS3Headers
AWS_S3_API extern const char SERVICE_NAME[];

//max expiration for presigned urls in s3 is 7 days.
static const unsigned MAX_EXPIRATION_SECONDS = 7 * 24 * 60 * 60;

/**
* <p/>
*/
class AWS_S3_API S3Client : public smithy::client::AwsSmithyClientT<Aws::S3::SERVICE_NAME,
Aws::S3::S3ClientConfiguration,
smithy::SigV4MultiAuthSchemeResolver<S3EndpointProvider, Aws::S3::S3ClientConfiguration>,
Aws::Crt::Variant<smithy::SigV4AuthScheme,S3::S3ExpressSigV4AuthScheme,smithy::SigV4aAuthScheme>,
S3EndpointProviderBase,
smithy::client::XmlOutcomeSerializer,
smithy::client::XmlOutcome,
Aws::Client::S3ErrorMarshaller>,
Aws::Client::ClientWithAsyncTemplateMethods<S3Client>
class AWS_S3_API S3Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<S3Client>
{
public:
typedef Aws::Client::AWSXMLClient BASECLASS;
static const char* GetServiceName();
static const char* GetAllocationTag();
inline const char* GetServiceClientName() const override { return "S3"; }

typedef S3ClientConfiguration ClientConfigurationType;
typedef S3EndpointProvider EndpointProviderType;
Expand Down Expand Up @@ -7006,7 +6989,8 @@ namespace Aws
private:
friend class Aws::Client::ClientWithAsyncTemplateMethods<S3Client>;
void init(const S3ClientConfiguration& clientConfiguration);

S3ClientConfiguration m_clientConfiguration;
std::shared_ptr<S3EndpointProviderBase> m_endpointProvider;
};

} // namespace S3
Expand Down
4 changes: 0 additions & 4 deletions generated/src/aws-cpp-sdk-s3/include/aws/s3/S3ClientConfiguration.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -62,10 +62,6 @@ namespace Aws
IdentityProviderSupplier identityProviderSupplier = [](const S3Client &client) -> std::shared_ptr<S3ExpressIdentityProvider> {
return Aws::MakeShared<DefaultS3ExpressIdentityProvider>("S3ClientConfiguration", client);
};
using SmithyIdentityProviderSupplier = std::function<std::shared_ptr<SmithyS3ExpressIdentityProvider> (const S3Client &)>;
SmithyIdentityProviderSupplier smithyIdentityProviderSupplier = [](const S3Client &client) -> std::shared_ptr<SmithyS3ExpressIdentityProvider> {
return Aws::MakeShared<SmithyDefaultS3ExpressIdentityProvider>("S3ClientConfiguration", client);
};
private:
void LoadS3SpecificConfig(const Aws::String& profileName);
};
Expand Down
64 changes: 0 additions & 64 deletions generated/src/aws-cpp-sdk-s3/include/aws/s3/S3ExpressAuthSchemeResolver.h
View file
Open in desktop

This file was deleted.

212 changes: 68 additions & 144 deletions generated/src/aws-cpp-sdk-s3/include/aws/s3/S3ExpressIdentityProvider.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,12 +8,11 @@
#include <aws/core/utils/memory/stl/AWSSet.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/ConcurrentCache.h>
#include <smithy/identity/resolver/AwsIdentityResolverBase.h>
#include <smithy/identity/identity/AwsCredentialIdentity.h>
#include <aws/core/auth/signer/AWSAuthSignerBase.h>
#include <aws/s3/S3ExpressIdentity.h>
#include <smithy/identity/resolver/AwsIdentityResolverBase.h>
#include <thread>
#include <condition_variable>
#include <aws/s3/S3_EXPORTS.h>

namespace Aws {
namespace Http {
Expand All @@ -22,155 +21,80 @@ namespace Aws {

namespace S3 {
class S3Client;
class AWS_S3_API S3ExpressIdentityProvider : public smithy::IdentityResolverBase<S3ExpressIdentity> {
public:
explicit S3ExpressIdentityProvider(const S3Client& s3Client);
ResolveIdentityFutureOutcome getIdentity(
const IdentityProperties& identityProperties,
const AdditionalParameters& additionalParameters) override;

virtual S3ExpressIdentity
class S3ExpressIdentityProvider: public smithy::IdentityResolverBase<S3ExpressIdentity> {
public:
explicit S3ExpressIdentityProvider(const S3Client &s3Client) : m_s3Client(s3Client) {}

virtual S3ExpressIdentity
GetS3ExpressIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) = 0;

protected:

S3ExpressIdentity GetCredentialsFromBucket(const Aws::String& bucketName) const;
ResolveIdentityFutureOutcome
getIdentity(const IdentityProperties& identityProperties, const AdditionalParameters& additionalParameters) override;
S3ExpressIdentity
getIdentity(const Aws::String &bucketName);

private:
const Aws::S3::S3Client& m_s3Client;
mutable std::mutex m_bucketNameMapMutex;
Aws::Map<Aws::String, std::shared_ptr<std::mutex>> m_bucketNameMutex;
virtual ~S3ExpressIdentityProvider() {}

protected:
std::shared_ptr<std::mutex> GetMutexForBucketName(const Aws::String& bucketName);
};


class AWS_S3_API DefaultS3ExpressIdentityProvider : public S3ExpressIdentityProvider {
public:
explicit DefaultS3ExpressIdentityProvider(const S3Client& s3Client);
explicit DefaultS3ExpressIdentityProvider(
const S3Client& s3Client,
std::shared_ptr<Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> credentialsCache);
DefaultS3ExpressIdentityProvider(const DefaultS3ExpressIdentityProvider& other) = delete;
DefaultS3ExpressIdentityProvider(DefaultS3ExpressIdentityProvider&& other) noexcept = delete;
DefaultS3ExpressIdentityProvider& operator=(const DefaultS3ExpressIdentityProvider& other) = delete;
DefaultS3ExpressIdentityProvider& operator=(DefaultS3ExpressIdentityProvider&& other) noexcept = delete;
virtual ~DefaultS3ExpressIdentityProvider() override = default;
S3ExpressIdentity GetS3ExpressIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) override;

private:
mutable std::shared_ptr<Aws::Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> m_credentialsCache;
};
protected:
std::shared_ptr<std::mutex> GetMutexForBucketName(const Aws::String& bucketName);

class AWS_S3_API DefaultAsyncS3ExpressIdentityProvider : public S3ExpressIdentityProvider {
public:
explicit DefaultAsyncS3ExpressIdentityProvider(
const S3Client& s3Client,
std::chrono::minutes refreshPeriod = std::chrono::minutes(1));

explicit DefaultAsyncS3ExpressIdentityProvider(
const S3Client& s3Client,
std::shared_ptr<Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> credentialsCache,
std::chrono::minutes refreshPeriod = std::chrono::minutes(1));

DefaultAsyncS3ExpressIdentityProvider(const DefaultAsyncS3ExpressIdentityProvider& other) = delete;
DefaultAsyncS3ExpressIdentityProvider(DefaultAsyncS3ExpressIdentityProvider&& other) noexcept = delete;
DefaultAsyncS3ExpressIdentityProvider& operator=(
const DefaultAsyncS3ExpressIdentityProvider& other) = delete;
DefaultAsyncS3ExpressIdentityProvider& operator=(DefaultAsyncS3ExpressIdentityProvider&& other) noexcept = delete;
virtual ~DefaultAsyncS3ExpressIdentityProvider() override;
S3ExpressIdentity GetS3ExpressIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) override;

private:
void refreshIdentities(std::chrono::minutes refreshPeriod);
void threadSafeKeyInsert(const Aws::String& key);
bool threadSafeKeyHas(const Aws::String& key);
void threadSafeKeyEmpty();

mutable std::shared_ptr<Aws::Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> m_credentialsCache;
Aws::Set<Aws::String> m_keysUsed;
mutable std::mutex m_keysUsedMutex;
mutable bool m_shouldStopBackgroundRefresh;
Aws::UniquePtr<std::thread> m_backgroundRefreshThread;
mutable std::mutex m_shutDownMutex;
mutable std::condition_variable m_shutdownCondition;
private:
const S3Client &m_s3Client;
mutable std::mutex m_bucketNameMapMutex;
Aws::Map<Aws::String, std::shared_ptr<std::mutex>> m_bucketNameMutex;
};

/*------ Smithy version -----*/
class AWS_S3_API SmithyS3ExpressIdentityProvider : public smithy::IdentityResolverBase<smithy::AwsCredentialIdentityBase> {
public:
explicit SmithyS3ExpressIdentityProvider(const S3Client& s3Client);
ResolveIdentityFutureOutcome getIdentity(
const IdentityProperties& identityProperties,
const AdditionalParameters& additionalParameters) override;

protected:

virtual smithy::AwsCredentialIdentity GetS3ExpressAwsIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) = 0;
smithy::AwsCredentialIdentity GetCredentialsFromBucket(const Aws::String& bucketName) const;

private:
const Aws::S3::S3Client& m_s3Client;
mutable std::mutex m_bucketNameMapMutex;
Aws::Map<Aws::String, std::shared_ptr<std::mutex>> m_bucketNameMutex;

protected:
std::shared_ptr<std::mutex> GetMutexForBucketName(const Aws::String& bucketName);
};
class DefaultS3ExpressIdentityProvider : public S3ExpressIdentityProvider {
public:
explicit DefaultS3ExpressIdentityProvider(const S3Client &m_s3Client);

class AWS_S3_API SmithyDefaultS3ExpressIdentityProvider : public SmithyS3ExpressIdentityProvider {
public:
explicit SmithyDefaultS3ExpressIdentityProvider(const S3Client& s3Client);
explicit SmithyDefaultS3ExpressIdentityProvider(
const S3Client& s3Client,
std::shared_ptr<Utils::ConcurrentCache<Aws::String, smithy::AwsCredentialIdentity>> credentialsCache);
SmithyDefaultS3ExpressIdentityProvider(const SmithyDefaultS3ExpressIdentityProvider& other) = delete;
SmithyDefaultS3ExpressIdentityProvider(SmithyDefaultS3ExpressIdentityProvider&& other) noexcept = delete;
SmithyDefaultS3ExpressIdentityProvider& operator=(const SmithyDefaultS3ExpressIdentityProvider& other) = delete;
SmithyDefaultS3ExpressIdentityProvider& operator=(SmithyDefaultS3ExpressIdentityProvider&& other) noexcept = delete;
virtual ~SmithyDefaultS3ExpressIdentityProvider() override = default;

protected:
smithy::AwsCredentialIdentity GetS3ExpressAwsIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) override;

private:
mutable std::shared_ptr<Aws::Utils::ConcurrentCache<Aws::String, smithy::AwsCredentialIdentity>> m_credentialsCache;
DefaultS3ExpressIdentityProvider(const S3Client &s3Client,
std::shared_ptr<Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> credentialsCache);

DefaultS3ExpressIdentityProvider(const DefaultS3ExpressIdentityProvider& other) = delete;
DefaultS3ExpressIdentityProvider(DefaultS3ExpressIdentityProvider&& other) noexcept = delete;
DefaultS3ExpressIdentityProvider& operator=(const DefaultS3ExpressIdentityProvider& other) = delete;
DefaultS3ExpressIdentityProvider& operator=(DefaultS3ExpressIdentityProvider&& other) noexcept = delete;

virtual ~DefaultS3ExpressIdentityProvider() override = default;

S3ExpressIdentity GetS3ExpressIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) override;

private:
mutable std::shared_ptr<Aws::Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> m_credentialsCache;
};

class AWS_S3_API SmithyDefaultAsyncS3ExpressIdentityProvider : public SmithyS3ExpressIdentityProvider {
public:
explicit SmithyDefaultAsyncS3ExpressIdentityProvider(
const S3Client& s3Client,
std::chrono::minutes refreshPeriod = std::chrono::minutes(1));

explicit SmithyDefaultAsyncS3ExpressIdentityProvider(
const S3Client& s3Client,
std::shared_ptr<Utils::ConcurrentCache<Aws::String, smithy::AwsCredentialIdentity>> credentialsCache,
std::chrono::minutes refreshPeriod = std::chrono::minutes(1));

SmithyDefaultAsyncS3ExpressIdentityProvider(const SmithyDefaultAsyncS3ExpressIdentityProvider& other) = delete;
SmithyDefaultAsyncS3ExpressIdentityProvider(SmithyDefaultAsyncS3ExpressIdentityProvider&& other) noexcept = delete;
SmithyDefaultAsyncS3ExpressIdentityProvider& operator=(
const SmithyDefaultAsyncS3ExpressIdentityProvider& other) = delete;
SmithyDefaultAsyncS3ExpressIdentityProvider& operator=(SmithyDefaultAsyncS3ExpressIdentityProvider&& other) noexcept = delete;
virtual ~SmithyDefaultAsyncS3ExpressIdentityProvider() override;
protected:
smithy::AwsCredentialIdentity GetS3ExpressAwsIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) override;

private:
void refreshIdentities(std::chrono::minutes refreshPeriod);
void threadSafeKeyInsert(const Aws::String& key);
bool threadSafeKeyHas(const Aws::String& key);
void threadSafeKeyEmpty();

mutable std::shared_ptr<Aws::Utils::ConcurrentCache<Aws::String, smithy::AwsCredentialIdentity>> m_credentialsCache;
Aws::Set<Aws::String> m_keysUsed;
mutable std::mutex m_keysUsedMutex;
mutable bool m_shouldStopBackgroundRefresh;
Aws::UniquePtr<std::thread> m_backgroundRefreshThread;
mutable std::mutex m_shutDownMutex;
mutable std::condition_variable m_shutdownCondition;

class DefaultAsyncS3ExpressIdentityProvider : public S3ExpressIdentityProvider {
public:
explicit DefaultAsyncS3ExpressIdentityProvider(const S3Client &m_s3Client,
std::chrono::minutes refreshPeriod = std::chrono::minutes(1));

DefaultAsyncS3ExpressIdentityProvider(const S3Client &s3Client,
std::shared_ptr<Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> credentialsCache,
std::chrono::minutes refreshPeriod = std::chrono::minutes(1));

DefaultAsyncS3ExpressIdentityProvider(const DefaultAsyncS3ExpressIdentityProvider& other) = delete;
DefaultAsyncS3ExpressIdentityProvider(DefaultAsyncS3ExpressIdentityProvider&& other) noexcept = delete;
DefaultAsyncS3ExpressIdentityProvider& operator=(const DefaultAsyncS3ExpressIdentityProvider& other) = delete;
DefaultAsyncS3ExpressIdentityProvider& operator=(DefaultAsyncS3ExpressIdentityProvider&& other) noexcept = delete;

virtual ~DefaultAsyncS3ExpressIdentityProvider() override;

S3ExpressIdentity GetS3ExpressIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) override;

private:
void refreshIdentities(std::chrono::minutes refreshPeriod);
void threadSafeKeyInsert(const Aws::String& key);
bool threadSafeKeyHas(const Aws::String& key);
void threadSafeKeyEmpty();

mutable std::shared_ptr<Aws::Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> m_credentialsCache;
Aws::Set<Aws::String> m_keysUsed;
mutable std::mutex m_keysUsedMutex;
mutable bool m_shouldStopBackgroundRefresh;
Aws::UniquePtr<std::thread> m_backgroundRefreshThread;
mutable std::mutex m_shutDownMutex;
mutable std::condition_variable m_shutdownCondition;
};
}
}
}
Loading
Loading