#include <XrdClS3Factory.hh>

Inheritance diagram for XrdClS3::Factory:

Collaboration diagram for XrdClS3::Factory:

Public Member Functions
	Factory ()
	Factory (const Factory &)=delete
virtual	~Factory ()
virtual XrdCl::FilePlugIn *	CreateFile (const std::string &url) override
	Create a file plug-in for the given URL.
virtual XrdCl::FileSystemPlugIn *	CreateFileSystem (const std::string &url) override
	Create a file system plug-in for the given URL.
Public Member Functions inherited from XrdCl::PlugInFactory
virtual	~PlugInFactory ()
	Destructor.

Static Public Member Functions
static std::string	CleanObjectName (const std::string &object)
static std::string_view	ExtractHostname (const std::string_view url)
static bool	GenerateHttpUrl (const std::string &s3_url, std::string &https_url, std::string *obj_result, std::string &err_msg)
static bool	GenerateV4Signature (const std::string &url, const std::string &verb, std::vector< std::pair< std::string, std::string > > &headers, std::string &auth_token, std::string &err_msg)
static std::string	GetBucketFromHttpsUrl (const std::string &url)
static std::tuple< std::string, std::string, bool >	GetCredentialsForBucket (const std::string &bucket, std::string &err_msg)
static const std::string &	GetMkdirSentinel ()
static std::string	PathEncode (const std::string_view url)
static void	ResetCredCache ()
static void	SetBucketCredentials (const std::string &bucket, const std::string &access_key, const std::string &secret_key)
static void	SetDefaultCredentials (const std::string &access_key, const std::string &secret_key)
static void	SetEndpoint (const std::string &endpoint)
static void	SetRegion (const std::string &region)
static void	SetService (const std::string &service)
static void	SetUrlStyle (const std::string &url_style)
static std::string_view	TrimView (const std::string_view str)

Detailed Description

Definition at line 39 of file XrdClS3Factory.hh.

Constructor & Destructor Documentation

◆ Factory() [1/2]

Factory::Factory ( )

Definition at line 85 of file XrdClS3Factory.cc.

                 {
    std::call_once(m_init_once, [&] {
        m_log = XrdCl::DefaultEnv::GetLog();
        if (!m_log) {
            return;
        }
        m_log->SetTopicName(kLogXrdClS3, "XrdClS3");
 
        auto env = XrdCl::DefaultEnv::GetEnv();
        if (!env) {
            return;
        }
        InitS3Config();
        m_initialized = true;
    });
}

References Factory(), XrdCl::DefaultEnv::GetEnv(), XrdCl::DefaultEnv::GetLog(), and XrdClS3::kLogXrdClS3.

Referenced by Factory(), and Factory().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~Factory()

virtual XrdClS3::Factory::~Factory ( )

inlinevirtual

Definition at line 42 of file XrdClS3Factory.hh.

42{}

◆ Factory() [2/2]

XrdClS3::Factory::Factory ( const Factory & )

delete

References Factory().

Here is the call graph for this function:

Member Function Documentation

◆ CleanObjectName()

std::string Factory::CleanObjectName ( const std::string & object )

static

Definition at line 293 of file XrdClS3Factory.cc.

                                                    {
    std::string obj = input_obj;
    auto loc = input_obj.find('?');
    if (loc != std::string::npos) {
        auto query = std::string_view(input_obj).substr(loc + 1);
        obj = obj.substr(0, loc);
        bool added_query = false;
        while (!query.empty()) {
            auto next_query_loc = query.find('&');
            auto current_query = (next_query_loc == std::string::npos) ? query : query.substr(0, next_query_loc);
            query = (next_query_loc == std::string::npos) ? "" : query.substr(next_query_loc + 1);
            if (current_query.empty()) {
                continue;
            }
            auto equal_loc = current_query.find('=');
            if (equal_loc != std::string::npos) {
                auto key = current_query.substr(0, equal_loc);
                if (key != "authz") {
                    obj += (added_query ? "&" : "?") + std::string(current_query);
                    added_query = true;
                }
            } else if (current_query != "authz") {
                obj += (added_query ? "&" : "?") + std::string(current_query);
                added_query = true;
            }
        }
    } else {
        obj = input_obj;
    }
    return obj;
}

References CleanObjectName().

Referenced by CleanObjectName(), CreateFile(), GenerateHttpUrl(), XrdClS3::Filesystem::Locate(), XrdClS3::Filesystem::Query(), XrdClS3::Filesystem::Rm(), and XrdClS3::Filesystem::Stat().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateFile()

virtual XrdCl::FilePlugIn * XrdClS3::Factory::CreateFile ( const std::string & url )

overridevirtual

Create a file plug-in for the given URL.

Implements XrdCl::PlugInFactory.

References CleanObjectName(), CreateFileSystem(), ExtractHostname(), GenerateHttpUrl(), GenerateV4Signature(), GetBucketFromHttpsUrl(), GetCredentialsForBucket(), PathEncode(), and TrimView().

Here is the call graph for this function:

◆ CreateFileSystem()

XrdCl::FileSystemPlugIn * Factory::CreateFileSystem ( const std::string & url )

overridevirtual

Create a file system plug-in for the given URL.

Implements XrdCl::PlugInFactory.

Definition at line 360 of file XrdClHttpFactory.cc.

                                               {
    Initialize();
    if (!m_initialized) {return nullptr;}
    return new Filesystem(url, m_queue, m_log);
}

References CreateFileSystem().

Referenced by CreateFile(), and CreateFileSystem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractHostname()

std::string_view Factory::ExtractHostname ( const std::string_view url )

static

Definition at line 326 of file XrdClS3Factory.cc.

                                                 {
    auto loc = url.find("://");
    if (loc == std::string_view::npos) {
        return {};
    }
    loc += 3; // Move past "://"
    auto slash_loc = url.find('/', loc);
    auto query_loc = url.find('?', loc);
    if (query_loc != std::string_view::npos && (slash_loc == std::string_view::npos || query_loc < slash_loc)) {
        slash_loc = query_loc; // If there's a query, we stop at it
    }
    auto authority = url.substr(loc, slash_loc - loc);
    if (authority.empty()) {
        return {};
    }
    auto at_loc = authority.find('@');
    if (at_loc != std::string_view::npos) {
        // If there's an '@', we have user info, so we skip it
        authority = authority.substr(at_loc + 1);
    }
    // If the authority contains a port, we need to strip it
    auto colon_loc = authority.find(':');
    if (colon_loc != std::string_view::npos) {
        authority = authority.substr(0, colon_loc);
    }
    return authority;
}

References ExtractHostname().

Referenced by CreateFile(), ExtractHostname(), GenerateHttpUrl(), GenerateV4Signature(), and GetBucketFromHttpsUrl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateHttpUrl()

bool Factory::GenerateHttpUrl	(	const std::string &	s3_url,
		std::string &	https_url,
		std::string *	obj_result,
		std::string &	err_msg )

static

Definition at line 413 of file XrdClS3Factory.cc.

                                                                                                                 {
    if (s3_url.substr(0, 5) != "s3://") {
        err_msg = "Provided URL does not start with s3://";
        return false;
    }
    auto loc = s3_url.find('/', 5);
    auto bucket = s3_url.substr(5, loc - 5);
    auto at_loc = bucket.find('@');
    if (at_loc != std::string::npos) {
        std::string login = "";
        login = bucket.substr(0, at_loc);
        bucket = bucket.substr(at_loc + 1);
    }
    std::string endpoint = m_endpoint;
    std::string region = m_region;
    if ((bucket == m_endpoint) || m_endpoint.empty()) {
        endpoint = bucket;
        auto old_loc = loc + 1;
        loc = s3_url.find('/', loc + 1);
        if (loc == std::string::npos) {
            err_msg = "Provided S3 URL does not contain a bucket in path";
            return false;
        }
        bucket = s3_url.substr(old_loc, loc - old_loc);
    } else {
        auto authority = ExtractHostname(s3_url);
        std::string test_endpoint = "." + endpoint;
        if (!m_region.empty()) {
            auto bucket_loc = authority.rfind("." + m_region + test_endpoint);
            if (bucket_loc != std::string::npos) {
                bucket = authority.substr(0, bucket_loc);
            } else {
                auto bucket_loc = authority.rfind(test_endpoint);
                if (bucket_loc != std::string::npos) {
                    bucket = authority.substr(0, bucket_loc);
                }
            }
        } else {
            auto bucket_loc = authority.rfind(test_endpoint);
            if (bucket_loc != std::string::npos) {
                bucket = authority.substr(0, bucket_loc);
            }
        }
    }
    std::string obj;
    if (loc != std::string::npos) {
        obj = s3_url.substr(loc + 1);
    }
    // Strip out "authz" query parameters; those are internal to XRootD.
    obj = CleanObjectName(obj);
    if (obj_result) {
        *obj_result = obj;
    }
    if (m_url_style == "virtual" || m_url_style.empty()) {
        https_url = "https://" + bucket + "." + m_region + "." + endpoint + (obj_result ? "" : ("/" + obj));
        return true;
    } else if (m_url_style == "path") {
        if (!m_region.empty()) {
            https_url = "https://" + m_region + "." + endpoint + "/" + bucket + (obj_result ? "" : ("/" + obj));
        } else {
            https_url = "https://" + endpoint + "/" + bucket + (obj_result ? "" : ("/" + obj));
        }
        return true;
    } else {
        err_msg = "Server configuration has invalid setting for URL style";
        return false;
    }
}

References CleanObjectName(), ExtractHostname(), and GenerateHttpUrl().

Referenced by CreateFile(), XrdClS3::Filesystem::DirList(), GenerateHttpUrl(), and XrdClS3::Filesystem::MkDir().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateV4Signature()

bool Factory::GenerateV4Signature	(	const std::string &	url,
		const std::string &	verb,
		std::vector< std::pair< std::string, std::string > > &	headers,
		std::string &	auth_token,
		std::string &	err_msg )

static

Definition at line 483 of file XrdClS3Factory.cc.

                                                                                                                                                                      {
    auto bucket = GetBucketFromHttpsUrl(url);
 
    // If we're using temporary credentials, we need to add the token
    // header here as well.  We set saKey and keyID here (well before
    // necessary) since we'll get them for free when we get the token.
    auto [keyId, secretKey, ok] = GetCredentialsForBucket(bucket, err_msg);
    if (!ok) {
        return false;
    }
 
    if (secretKey.empty()) {
        auth_token = "";
        return true;
    }
 
    //
    // Create task 1's inputs.
    //
 
    auto canonicalURI = PathEncode(url);
 
    // The canonical query string is the alphabetically sorted list of
    // URI-encoded parameter names '=' values, separated by '&'s.
    auto canonicalQueryString = CanonicalizeQueryString(url);
 
    // The canonical headers must include the Host header, so add that
    // now if we don't have it.
    if (std::find_if(headers.begin(), headers.end(),
                        [](const auto &pair) { return pair.first == "Host"; }) == headers.end()) {
        auto host = ExtractHostname(url);
        if (host.empty()) {
            err_msg = "Unable to extract hostname from URL: " + url;
            return false;
        }
        headers.emplace_back("Host", host);
    }
 
    // S3 complains if x-amz-date isn't signed, so do this early.
    auto iter = std::find_if(headers.begin(), headers.end(),
        [](const auto &pair) { return !strcasecmp(pair.first.c_str(), "X-Amz-Date"); });
    std::string date_time;
    char date_char[] = "YYYYMMDD";
    if (iter == headers.end()) {
        time_t now;
        time(&now);
        struct tm brokenDownTime;
        gmtime_r(&now, &brokenDownTime);
 
        date_time =  "YYYYMMDDThhmmssZ";
        strftime(date_time.data(), date_time.size(), "%Y%m%dT%H%M%SZ", &brokenDownTime);
        headers.emplace_back("X-Amz-Date", date_time);
        strftime(date_char, sizeof(date_char), "%Y%m%d", &brokenDownTime);
    } else {
        date_time = iter->second;
        auto loc = date_time.find('T', 0);
        if (loc != 8) {
            err_msg = "Invalid value for X-Amz-Date";
            return false;
        }
        memcpy(date_char, date_time.c_str(), 8);
    }
 
    // The canonical payload hash is the lowercase hexadecimal string of the
    // (SHA256) hash value of the payload or "UNSIGNED-PAYLOAD" if
    // we are not signing the payload.
    std::string payload_hash = "UNSIGNED-PAYLOAD";
    iter = std::find_if(headers.begin(), headers.end(),
        [](const auto &pair) { return !strcasecmp(pair.first.c_str(), "X-Amz-Content-Sha256"); });
    if (iter == headers.end()) {
        headers.emplace_back("X-Amz-Content-Sha256", payload_hash);
    } else {
        payload_hash = iter->second;
    }
 
    // The canonical list of headers is a sorted list of lowercase header
    // names paired via ':' with the trimmed header value, each pair
    // terminated with a newline.
    std::vector<std::pair<std::string, std::string>> transformed_headers;
    transformed_headers.reserve(headers.size());
    for (const auto &info : headers) {
        std::string header = info.first;
        std::transform(header.begin(), header.end(), header.begin(), &tolower);
 
        std::string value = info.second;
        if (value.empty()) {
            continue;
        }
        auto value_trimmed = std::string(TrimView(value));
 
        // Convert internal runs of spaces into single spaces.
        unsigned left = 1;
        unsigned right = 1;
        bool inSpaces = false;
        while (right < value_trimmed.length()) {
            if (!inSpaces) {
                if (value_trimmed[right] == ' ') {
                    inSpaces = true;
                    left = right;
                    ++right;
                } else {
                    ++right;
                }
            } else {
                if (value_trimmed[right] == ' ') {
                    ++right;
                } else {
                    inSpaces = false;
                    value_trimmed.erase(left, right - left - 1);
                    right = left + 1;
                }
            }
        }
 
        transformed_headers.emplace_back(header, value);
    }
    std::sort(transformed_headers.begin(), transformed_headers.end(),
                [](const auto &a, const auto &b) { return a.first < b.first; });
 
    // The canonical list of signed headers is trivial to generate while
    // generating the list of headers.
    std::string signedHeaders, canonicalHeaders;
    for (const auto &info : transformed_headers) {
        canonicalHeaders += info.first + ":" + info.second + "\n";
        signedHeaders += info.first + ";";
    }
    signedHeaders.erase(signedHeaders.end() - 1);
 
    // Task 1: create the canonical request.
    auto canonicalRequest =
        verb + "\n" + canonicalURI + "\n" + canonicalQueryString + "\n" +
        canonicalHeaders + "\n" + signedHeaders + "\n" + payload_hash;
 
    //
    // Create task 2's inputs.
    //
 
    // Hash the canonical request the way we did the payload.
    std::string canonicalRequestHash;
    std::vector<unsigned char> messageDigest;
    messageDigest.resize(EVP_MAX_MD_SIZE);
    if (!ComputeSHA256(canonicalRequest, messageDigest)) {
        err_msg = "Unable to hash canonical request.";
        return false;
    }
    MessageDigestAsHex(messageDigest, canonicalRequestHash);
 
    // Task 2: create the string to sign.
    auto credentialScope = std::string(date_char) + "/" + m_region + "/" + m_service + "/aws4_request";
    auto stringToSign = std::string("AWS4-HMAC-SHA256\n") + date_time + "\n" + credentialScope + "\n" + canonicalRequestHash;
 
    //
    // Creating task 3's inputs was done when we checked to see if we needed
    // to get the security token, since they come along for free when we do.
    //
 
    // Task 3: calculate the signature.
    auto saKey = std::string("AWS4") + secretKey;
    unsigned int mdLength = 0;
    const unsigned char *hmac =
        HMAC(EVP_sha256(), saKey.c_str(), saKey.length(), (unsigned char *)date_char,
                sizeof(date_char) - 1, messageDigest.data(), &mdLength);
    if (hmac == NULL) {
        err_msg = "Unable to calculate HMAC for date.";
        return false;
    }
 
    unsigned int md2Length = 0;
    unsigned char messageDigest2[EVP_MAX_MD_SIZE];
    hmac = HMAC(EVP_sha256(), messageDigest.data(), mdLength,
                reinterpret_cast<unsigned char *>(m_region.data()), m_region.size(), messageDigest2,
                &md2Length);
    if (hmac == NULL) {
        err_msg = "Unable to calculate HMAC for region.";
        return false;
    }
 
    hmac = HMAC(EVP_sha256(), messageDigest2, md2Length,
                reinterpret_cast<unsigned char *>(m_service.data()), m_service.size(), messageDigest.data(),
                &mdLength);
    if (hmac == NULL) {
        err_msg = "Unable to calculate HMAC for service.";
        return false;
    }
 
    const char request_char[] = "aws4_request";
    hmac = HMAC(EVP_sha256(), messageDigest.data(), messageDigest.size(), reinterpret_cast<const unsigned char *>(request_char),
                sizeof(request_char) - 1, messageDigest2, &md2Length);
    if (hmac == NULL) {
        err_msg = "Unable to calculate HMAC for request.";
        return false;
    }
 
    hmac = HMAC(EVP_sha256(), messageDigest2, md2Length,
                reinterpret_cast<unsigned char *>(stringToSign.data()),
                stringToSign.size(), messageDigest.data(), &mdLength);
    if (hmac == NULL) {
        err_msg = "Unable to calculate HMAC for request string.";
        return false;
    }
 
    std::string signature;
    MessageDigestAsHex(messageDigest, signature);
 
    auth_token =
                std::string("AWS4-HMAC-SHA256 Credential=") + keyId + "/" + credentialScope +
                ",SignedHeaders=" + signedHeaders + ",Signature=" + signature;
    return true;
}

References ExtractHostname(), GenerateV4Signature(), GetBucketFromHttpsUrl(), GetCredentialsForBucket(), PathEncode(), and TrimView().

Referenced by CreateFile(), and GenerateV4Signature().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBucketFromHttpsUrl()

std::string Factory::GetBucketFromHttpsUrl ( const std::string & url )

static

Definition at line 694 of file XrdClS3Factory.cc.

                                                   {
    if (m_url_style == "virtual" || m_url_style.empty()) {
        // Virtual-hosted-style URLs are of the form https://bucket.region.endpoint/object
        auto hostname = ExtractHostname(url);
        if (hostname.empty()) {
            return {};
        }
        auto test_endpoint = "." + m_endpoint;
        if (!m_region.empty()) test_endpoint = "." + m_region + test_endpoint;
        auto loc = hostname.rfind(test_endpoint);
        if (loc == std::string::npos) {
            if (!m_region.empty()) {
                loc = hostname.rfind("." + m_endpoint);
                if (loc != std::string::npos) {
                    return std::string(hostname.substr(0, loc));
                }
            }
            return {};
        }
        return std::string(hostname.substr(0, loc));
    } else if (m_url_style == "path") {
        // Path style URLs are of the form https://region.endpoint/bucket/object
        auto loc = url.find("://");
        if (loc == std::string::npos) {
            return {};
        }
        loc += 3; // Move past "://"
        auto slash_loc = url.find('/', loc);
        if (slash_loc == std::string::npos) {
            return {};
        }
        auto bucket_start = slash_loc + 1;
        auto bucket_end = url.find('/', bucket_start);
        if (bucket_end == std::string::npos) {
            return url.substr(bucket_start);
        }
        return url.substr(bucket_start, bucket_end - bucket_start);
    } else {
        // Invalid URL style
        return {};
    }
}

References ExtractHostname(), and GetBucketFromHttpsUrl().

Referenced by CreateFile(), GenerateV4Signature(), and GetBucketFromHttpsUrl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCredentialsForBucket()

std::tuple< std::string, std::string, bool > Factory::GetCredentialsForBucket	(	const std::string &	bucket,
		std::string &	err_msg )

static

Definition at line 738 of file XrdClS3Factory.cc.

{
    auto now = std::chrono::steady_clock::now();
    {
        std::shared_lock lock(m_bucket_auth_map_mutex);
        auto iter = m_bucket_auth_map.find(bucket);
        if (iter != m_bucket_auth_map.end()) {
            // If we have credentials for this bucket, check if they are still valid.
            auto &creds = iter->second.first;
            auto &expiration = iter->second.second;
            if (now < expiration) {
                // Credentials are still valid, return them.
                return {creds.m_accesskey, creds.m_secretkey, true};
            }
        }
    }
 
    std::unique_lock lock(m_bucket_auth_map_mutex);
    auto iter = m_bucket_location_map.find(bucket);
    std::string access_key_location, secret_key_location;
    if (iter == m_bucket_location_map.end()) {
        // If we don't have credentials for this bucket, use the default.
        if (m_default_creds.m_accesskey.empty() || m_default_creds.m_secretkey.empty()) {
            // No credentials at all, so we assume public access.
            m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::minutes(1)};
            return {"", "", true};
        }
        access_key_location = m_default_creds.m_accesskey;
        secret_key_location = m_default_creds.m_secretkey;
    } else {
        access_key_location = iter->second.m_accesskey;
        secret_key_location = iter->second.m_secretkey;
    }
    if (access_key_location.empty() && secret_key_location.empty()) {
        // If both are empty, we assume public access.
        m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::minutes(1)};
        return {"", "", true};
    }
    if (access_key_location.empty() || secret_key_location.empty()) {
        err_msg = "No credentials available for bucket: " + bucket;
        m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::seconds(10)};
        return {"", "", false};
    }
 
    std::string access_key, secret_key;
    if (!ReadShortFile(access_key_location, access_key, err_msg)) {
        m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::seconds(10)};
        return {"", "", false};
    }
    access_key = TrimView(access_key);
 
    if (!ReadShortFile(secret_key_location, secret_key, err_msg)) {
        m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::seconds(10)};
        return {"", "", false};
    }
    secret_key = TrimView(secret_key);
 
    if (access_key.empty() || secret_key.empty()) {
        err_msg = "Credentials for bucket '" + bucket + "' are empty.";
        m_bucket_auth_map[bucket] = {{"", ""}, now + std::chrono::seconds(10)};
        return {"", "", false};
    }
    m_bucket_auth_map[bucket] = {{access_key, secret_key}, now + std::chrono::minutes(1)};
    return {access_key, secret_key, true};
}

References GetCredentialsForBucket(), and TrimView().

Referenced by CreateFile(), GenerateV4Signature(), and GetCredentialsForBucket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMkdirSentinel()

const std::string & XrdClS3::Factory::GetMkdirSentinel ( )

inlinestatic

Definition at line 81 of file XrdClS3Factory.hh.

81{return m_mkdir_sentinel;}

Referenced by XrdClS3::Filesystem::MkDir(), and XrdClS3::Filesystem::RmDir().

Here is the caller graph for this function:

◆ PathEncode()

std::string Factory::PathEncode ( const std::string_view url )

static

Definition at line 805 of file XrdClS3Factory.cc.

                                            {
    auto loc = url.find("://");
    if (loc == std::string_view::npos) {
        return "";
    }
    auto path_loc = url.find("/", loc + 3);
    auto query_loc = url.find("?", loc + 3);
    if (query_loc != std::string_view::npos && (path_loc == std::string_view::npos || query_loc < path_loc)) {
        // No path, just a query string
        return "/";
    }
    auto path = url.substr(path_loc, query_loc - path_loc);
    std::string segment;
        std::string encoded;
        
        size_t next = 0;
        size_t offset = 0;
        const auto length = path.size();
        while (offset < length) {
                next = strcspn(path.data() + offset, "/");
                if (next == 0) {
                        encoded += "/";
                        offset += 1;
                        continue;
                }
        if (offset + next >= length) {
            next = length - offset;
        }
 
                segment = std::string(path.data() + offset, next);
                encoded += AmazonURLEncode(segment);
 
                offset += next;
        }
        return encoded;
}

References PathEncode().

Referenced by CreateFile(), GenerateV4Signature(), and PathEncode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ResetCredCache()

void XrdClS3::Factory::ResetCredCache ( )

inlinestatic

Definition at line 96 of file XrdClS3Factory.hh.

                                 {
        std::unique_lock lock(m_bucket_auth_map_mutex);
        m_bucket_auth_map.clear();
    }

◆ SetBucketCredentials()

void XrdClS3::Factory::SetBucketCredentials	(	const std::string &	bucket,
		const std::string &	access_key,
		const std::string &	secret_key )

inlinestatic

Definition at line 93 of file XrdClS3Factory.hh.

                                                                                                                        {
        m_bucket_location_map[bucket] = {access_key, secret_key};
    }

◆ SetDefaultCredentials()

void XrdClS3::Factory::SetDefaultCredentials	(	const std::string &	access_key,
		const std::string &	secret_key )

inlinestatic

Definition at line 89 of file XrdClS3Factory.hh.

                                                                                                {
        m_default_creds.m_accesskey = access_key;
        m_default_creds.m_secretkey = secret_key;
    }

◆ SetEndpoint()

void XrdClS3::Factory::SetEndpoint ( const std::string & endpoint )

inlinestatic

Definition at line 85 of file XrdClS3Factory.hh.

85{ m_endpoint = endpoint; }

◆ SetRegion()

void XrdClS3::Factory::SetRegion ( const std::string & region )

inlinestatic

Definition at line 87 of file XrdClS3Factory.hh.

87{ m_region = region; }

◆ SetService()

void XrdClS3::Factory::SetService ( const std::string & service )

inlinestatic

Definition at line 86 of file XrdClS3Factory.hh.

86{ m_service = service; }

◆ SetUrlStyle()

void XrdClS3::Factory::SetUrlStyle ( const std::string & url_style )

inlinestatic

Definition at line 88 of file XrdClS3Factory.hh.

88{ m_url_style = url_style; }

◆ TrimView()

std::string_view Factory::TrimView ( const std::string_view str )

static

Definition at line 844 of file XrdClS3Factory.cc.

                                                 {
    auto view = ltrim_view(input_view);
    for (size_t idx = 0; idx < input_view.size(); idx++) {
        if (!isspace(view[view.size() - 1 - idx])) {
            return view.substr(0, view.size() - idx);
        }
    }
    return "";
}

References TrimView().

Referenced by CreateFile(), GenerateV4Signature(), GetCredentialsForBucket(), and TrimView().

Here is the call graph for this function:

Here is the caller graph for this function:

The documentation for this class was generated from the following files:

	XRootD

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Factory() [1/2]

◆ ~Factory()

◆ Factory() [2/2]

Member Function Documentation

◆ CleanObjectName()

◆ CreateFile()

◆ CreateFileSystem()

◆ ExtractHostname()

◆ GenerateHttpUrl()

◆ GenerateV4Signature()

◆ GetBucketFromHttpsUrl()

◆ GetCredentialsForBucket()

◆ GetMkdirSentinel()

◆ PathEncode()

◆ ResetCredCache()

◆ SetBucketCredentials()

◆ SetDefaultCredentials()

◆ SetEndpoint()

◆ SetRegion()

◆ SetService()

◆ SetUrlStyle()

◆ TrimView()