15 #ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_CLIENT_H
16 #define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_CLIENT_H
19 #include "google/cloud/storage/internal/logging_client.h"
20 #include "google/cloud/storage/internal/parameter_pack_validation.h"
21 #include "google/cloud/storage/internal/policy_document_request.h"
22 #include "google/cloud/storage/internal/retry_client.h"
23 #include "google/cloud/storage/internal/signed_url_requests.h"
24 #include "google/cloud/storage/internal/tuple_filter.h"
37 #include "google/cloud/internal/throw_delegate.h"
40 #include "absl/meta/type_traits.h"
41 #include <type_traits>
51 class NonResumableParallelUploadState;
52 class ResumableParallelUploadState;
205 template <
typename... Policies>
207 :
Client(CreateDefaultInternalClient(std::move(options)),
208 std::forward<Policies>(policies)...) {}
225 template <
typename... Policies>
226 explicit Client(std::shared_ptr<oauth2::Credentials> credentials,
227 Policies&&... policies)
229 std::forward<Policies>(policies)...) {}
233 template <
typename... Policies>
234 explicit Client(std::shared_ptr<internal::RawClient> client,
235 Policies&&... policies)
237 Decorate(std::move(client), std::forward<Policies>(policies)...)) {}
244 : raw_client_(std::move(client)) {}
247 static StatusOr<Client> CreateDefaultClient();
280 template <
typename... Options>
282 Options&&... options) {
283 internal::ListBucketsRequest request(project_id);
284 request.set_multiple_options(std::forward<Options>(options)...);
285 auto client = raw_client_;
286 return google::cloud::internal::MakePaginationRange<ListBucketsReader>(
288 [client](internal::ListBucketsRequest
const& r) {
289 return client->ListBuckets(r);
291 [](internal::ListBucketsResponse r) {
return std::move(r.items); });
314 template <
typename... Options>
316 auto const& project_id = raw_client_->client_options().project_id();
317 return ListBucketsForProject(project_id, std::forward<Options>(options)...);
347 template <
typename... Options>
350 Options&&... options) {
351 auto const& project_id = raw_client_->client_options().project_id();
352 return CreateBucketForProject(std::move(bucket_name), project_id,
354 std::forward<Options>(options)...);
383 template <
typename... Options>
385 std::string project_id,
387 Options&&... options) {
388 metadata.
set_name(std::move(bucket_name));
389 internal::CreateBucketRequest request(std::move(project_id),
390 std::move(metadata));
391 request.set_multiple_options(std::forward<Options>(options)...);
392 return raw_client_->CreateBucket(request);
409 template <
typename... Options>
411 Options&&... options) {
412 internal::GetBucketMetadataRequest request(bucket_name);
413 request.set_multiple_options(std::forward<Options>(options)...);
414 return raw_client_->GetBucketMetadata(request);
432 template <
typename... Options>
433 Status
DeleteBucket(std::string
const& bucket_name, Options&&... options) {
434 internal::DeleteBucketRequest request(bucket_name);
435 request.set_multiple_options(std::forward<Options>(options)...);
436 return raw_client_->DeleteBucket(request).status();
472 template <
typename... Options>
475 Options&&... options) {
476 metadata.
set_name(std::move(bucket_name));
477 internal::UpdateBucketRequest request(std::move(metadata));
478 request.set_multiple_options(std::forward<Options>(options)...);
479 return raw_client_->UpdateBucket(request);
519 template <
typename... Options>
523 Options&&... options) {
524 internal::PatchBucketRequest request(std::move(bucket_name), original,
526 request.set_multiple_options(std::forward<Options>(options)...);
527 return raw_client_->PatchBucket(request);
562 template <
typename... Options>
565 Options&&... options) {
566 internal::PatchBucketRequest request(std::move(bucket_name), builder);
567 request.set_multiple_options(std::forward<Options>(options)...);
568 return raw_client_->PatchBucket(request);
606 template <
typename... Options>
608 StatusOr<IamPolicy> GetBucketIamPolicy(std::
string const& bucket_name,
609 Options&&... options) {
610 internal::GetBucketIamPolicyRequest request(bucket_name);
611 request.set_multiple_options(std::forward<Options>(options)...);
612 return raw_client_->GetBucketIamPolicy(request);
647 template <
typename... Options>
649 std::string
const& bucket_name, Options&&... options) {
650 internal::GetBucketIamPolicyRequest request(bucket_name);
651 request.set_multiple_options(std::forward<Options>(options)...);
652 return raw_client_->GetNativeBucketIamPolicy(request);
700 template <
typename... Options>
702 StatusOr<IamPolicy> SetBucketIamPolicy(std::
string const& bucket_name,
703 IamPolicy const& iam_policy,
704 Options&&... options) {
705 internal::SetBucketIamPolicyRequest request(bucket_name, iam_policy);
706 request.set_multiple_options(std::forward<Options>(options)...);
707 return raw_client_->SetBucketIamPolicy(request);
755 template <
typename... Options>
758 Options&&... options) {
759 internal::SetNativeBucketIamPolicyRequest request(bucket_name, iam_policy);
760 request.set_multiple_options(std::forward<Options>(options)...);
761 return raw_client_->SetNativeBucketIamPolicy(request);
791 template <
typename... Options>
793 std::string bucket_name, std::vector<std::string> permissions,
794 Options&&... options) {
795 internal::TestBucketIamPermissionsRequest request(std::move(bucket_name),
796 std::move(permissions));
797 request.set_multiple_options(std::forward<Options>(options)...);
798 auto result = raw_client_->TestBucketIamPermissions(request);
800 return std::move(result).status();
802 return std::move(result.value().permissions);
851 template <
typename... Options>
853 std::string
const& bucket_name, std::uint64_t metageneration,
854 Options&&... options) {
855 internal::LockBucketRetentionPolicyRequest request(bucket_name,
857 request.set_multiple_options(std::forward<Options>(options)...);
858 return raw_client_->LockBucketRetentionPolicy(request);
899 template <
typename... Options>
901 std::string
const& object_name,
902 std::string contents,
903 Options&&... options) {
904 internal::InsertObjectMediaRequest request(bucket_name, object_name,
905 std::move(contents));
906 request.set_multiple_options(std::forward<Options>(options)...);
907 return raw_client_->InsertObjectMedia(request);
950 template <
typename... Options>
951 StatusOr<ObjectMetadata>
CopyObject(std::string source_bucket_name,
952 std::string source_object_name,
953 std::string destination_bucket_name,
954 std::string destination_object_name,
955 Options&&... options) {
956 internal::CopyObjectRequest request(
957 std::move(source_bucket_name), std::move(source_object_name),
958 std::move(destination_bucket_name), std::move(destination_object_name));
959 request.set_multiple_options(std::forward<Options>(options)...);
960 return raw_client_->CopyObject(request);
979 template <
typename... Options>
981 std::string
const& object_name,
982 Options&&... options) {
983 internal::GetObjectMetadataRequest request(bucket_name, object_name);
984 request.set_multiple_options(std::forward<Options>(options)...);
985 return raw_client_->GetObjectMetadata(request);
1004 template <
typename... Options>
1006 Options&&... options) {
1007 internal::ListObjectsRequest request(bucket_name);
1008 request.set_multiple_options(std::forward<Options>(options)...);
1009 auto client = raw_client_;
1010 return google::cloud::internal::MakePaginationRange<ListObjectsReader>(
1012 [client](internal::ListObjectsRequest
const& r) {
1013 return client->ListObjects(r);
1015 [](internal::ListObjectsResponse r) {
return std::move(r.items); });
1034 template <
typename... Options>
1036 std::string
const& bucket_name, Options&&... options) {
1037 internal::ListObjectsRequest request(bucket_name);
1038 request.set_multiple_options(std::forward<Options>(options)...);
1039 auto client = raw_client_;
1040 return google::cloud::internal::MakePaginationRange<
1043 [client](internal::ListObjectsRequest
const& r) {
1044 return client->ListObjects(r);
1046 [](internal::ListObjectsResponse r) {
1047 std::vector<ObjectOrPrefix> result;
1048 for (
auto& item : r.items) {
1049 result.emplace_back(std::move(item));
1051 for (
auto& prefix : r.prefixes) {
1052 result.emplace_back(std::move(prefix));
1054 internal::SortObjectsAndPrefixes(result);
1091 template <
typename... Options>
1093 std::string
const& object_name,
1094 Options&&... options) {
1096 :
public absl::disjunction<std::is_same<ReadRange, Options>...> {};
1097 struct HasReadFromOffset
1098 :
public absl::disjunction<std::is_same<ReadFromOffset, Options>...> {};
1100 :
public absl::disjunction<std::is_same<ReadLast, Options>...> {};
1102 struct HasIncompatibleRangeOptions
1103 :
public std::integral_constant<bool, HasReadLast::value &&
1104 (HasReadFromOffset::value ||
1105 HasReadRange::value)> {};
1107 static_assert(!HasIncompatibleRangeOptions::value,
1108 "Cannot set ReadLast option with either ReadFromOffset or "
1111 internal::ReadObjectRangeRequest request(bucket_name, object_name);
1112 request.set_multiple_options(std::forward<Options>(options)...);
1113 return ReadObjectImpl(request);
1198 template <
typename... Options>
1200 std::string
const& object_name,
1201 Options&&... options) {
1202 internal::ResumableUploadRequest request(bucket_name, object_name);
1203 request.set_multiple_options(std::forward<Options>(options)...);
1204 return WriteObjectImpl(request);
1237 template <
typename... Options>
1238 StatusOr<ObjectMetadata>
UploadFile(std::string
const& file_name,
1239 std::string
const& bucket_name,
1240 std::string
const& object_name,
1241 Options&&... options) {
1246 using HasUseResumableUpload =
1247 absl::disjunction<std::is_same<UseResumableUploadSession, Options>...>;
1248 return UploadFileImpl(file_name, bucket_name, object_name,
1249 HasUseResumableUpload{},
1250 std::forward<Options>(options)...);
1265 template <
typename... Options>
1267 Options&&... options) {
1268 internal::DeleteResumableUploadRequest request(upload_session_url);
1269 request.set_multiple_options(std::forward<Options>(options)...);
1270 return raw_client_->DeleteResumableUpload(request).status();
1292 template <
typename... Options>
1294 std::string
const& object_name,
1295 std::string
const& file_name, Options&&... options) {
1296 internal::ReadObjectRangeRequest request(bucket_name, object_name);
1297 request.set_multiple_options(std::forward<Options>(options)...);
1298 return DownloadFileImpl(request, file_name);
1319 template <
typename... Options>
1321 std::string
const& object_name, Options&&... options) {
1322 internal::DeleteObjectRequest request(bucket_name, object_name);
1323 request.set_multiple_options(std::forward<Options>(options)...);
1324 return raw_client_->DeleteObject(request).status();
1349 template <
typename... Options>
1351 std::string object_name,
1353 Options&&... options) {
1354 internal::UpdateObjectRequest request(
1355 std::move(bucket_name), std::move(object_name), std::move(metadata));
1356 request.set_multiple_options(std::forward<Options>(options)...);
1357 return raw_client_->UpdateObject(request);
1386 template <
typename... Options>
1388 std::string object_name,
1391 Options&&... options) {
1392 internal::PatchObjectRequest request(
1393 std::move(bucket_name), std::move(object_name), original, updated);
1394 request.set_multiple_options(std::forward<Options>(options)...);
1395 return raw_client_->PatchObject(request);
1422 template <
typename... Options>
1424 std::string bucket_name, std::string object_name,
1426 internal::PatchObjectRequest request(std::move(bucket_name),
1427 std::move(object_name), builder);
1428 request.set_multiple_options(std::forward<Options>(options)...);
1429 return raw_client_->PatchObject(request);
1455 template <
typename... Options>
1457 std::string bucket_name, std::vector<ComposeSourceObject> source_objects,
1458 std::string destination_object_name, Options&&... options) {
1459 internal::ComposeObjectRequest request(std::move(bucket_name),
1460 std::move(source_objects),
1461 std::move(destination_object_name));
1462 request.set_multiple_options(std::forward<Options>(options)...);
1463 return raw_client_->ComposeObject(request);
1504 template <
typename... Options>
1506 std::string source_object_name,
1507 std::string destination_bucket_name,
1508 std::string destination_object_name,
1509 Options&&... options) {
1510 return ResumeRewriteObject(
1511 std::move(source_bucket_name), std::move(source_object_name),
1512 std::move(destination_bucket_name), std::move(destination_object_name),
1513 std::string{}, std::forward<Options>(options)...);
1556 template <
typename... Options>
1558 std::string source_object_name,
1559 std::string destination_bucket_name,
1560 std::string destination_object_name,
1561 std::string rewrite_token,
1562 Options&&... options) {
1563 internal::RewriteObjectRequest request(
1564 std::move(source_bucket_name), std::move(source_object_name),
1565 std::move(destination_bucket_name), std::move(destination_object_name),
1566 std::move(rewrite_token));
1567 request.set_multiple_options(std::forward<Options>(options)...);
1614 template <
typename... Options>
1616 std::string source_bucket_name, std::string source_object_name,
1617 std::string destination_bucket_name, std::string destination_object_name,
1618 Options&&... options) {
1619 return ResumeRewriteObject(std::move(source_bucket_name),
1620 std::move(source_object_name),
1621 std::move(destination_bucket_name),
1622 std::move(destination_object_name),
1623 std::string{}, std::forward<Options>(options)...)
1672 template <
typename... Options>
1674 std::string
const& bucket_name, Options&&... options) {
1675 internal::ListBucketAclRequest request(bucket_name);
1676 request.set_multiple_options(std::forward<Options>(options)...);
1677 auto items = raw_client_->ListBucketAcl(request);
1679 return std::move(items).status();
1681 return std::move(items.value().items);
1705 template <
typename... Options>
1707 std::string
const& entity,
1708 std::string
const& role,
1709 Options&&... options) {
1710 internal::CreateBucketAclRequest request(bucket_name, entity, role);
1711 request.set_multiple_options(std::forward<Options>(options)...);
1712 return raw_client_->CreateBucketAcl(request);
1733 template <
typename... Options>
1735 std::string
const& entity, Options&&... options) {
1736 internal::DeleteBucketAclRequest request(bucket_name, entity);
1737 request.set_multiple_options(std::forward<Options>(options)...);
1738 return raw_client_->DeleteBucketAcl(request).status();
1758 template <
typename... Options>
1760 std::string
const& entity,
1761 Options&&... options) {
1762 internal::GetBucketAclRequest request(bucket_name, entity);
1763 request.set_multiple_options(std::forward<Options>(options)...);
1764 return raw_client_->GetBucketAcl(request);
1797 template <
typename... Options>
1800 Options&&... options) {
1801 internal::UpdateBucketAclRequest request(bucket_name, acl.entity(),
1803 request.set_multiple_options(std::forward<Options>(options)...);
1804 return raw_client_->UpdateBucketAcl(request);
1842 template <
typename... Options>
1844 std::string
const& bucket_name, std::string
const& entity,
1847 internal::PatchBucketAclRequest request(bucket_name, entity, original_acl,
1849 request.set_multiple_options(std::forward<Options>(options)...);
1850 return raw_client_->PatchBucketAcl(request);
1886 template <
typename... Options>
1888 std::string
const& bucket_name, std::string
const& entity,
1890 internal::PatchBucketAclRequest request(bucket_name, entity, builder);
1891 request.set_multiple_options(std::forward<Options>(options)...);
1892 return raw_client_->PatchBucketAcl(request);
1934 template <
typename... Options>
1936 std::string
const& bucket_name, std::string
const& object_name,
1937 Options&&... options) {
1938 internal::ListObjectAclRequest request(bucket_name, object_name);
1939 request.set_multiple_options(std::forward<Options>(options)...);
1940 auto result = raw_client_->ListObjectAcl(request);
1942 return std::move(result).status();
1944 return std::move(result.value().items);
1969 template <
typename... Options>
1971 std::string
const& object_name,
1972 std::string
const& entity,
1973 std::string
const& role,
1974 Options&&... options) {
1975 internal::CreateObjectAclRequest request(bucket_name, object_name, entity,
1977 request.set_multiple_options(std::forward<Options>(options)...);
1978 return raw_client_->CreateObjectAcl(request);
2001 template <
typename... Options>
2003 std::string
const& object_name,
2004 std::string
const& entity, Options&&... options) {
2005 internal::DeleteObjectAclRequest request(bucket_name, object_name, entity);
2006 request.set_multiple_options(std::forward<Options>(options)...);
2007 return raw_client_->DeleteObjectAcl(request).status();
2028 template <
typename... Options>
2030 std::string
const& object_name,
2031 std::string
const& entity,
2032 Options&&... options) {
2033 internal::GetObjectAclRequest request(bucket_name, object_name, entity);
2034 request.set_multiple_options(std::forward<Options>(options)...);
2035 return raw_client_->GetObjectAcl(request);
2067 template <
typename... Options>
2069 std::string
const& object_name,
2071 Options&&... options) {
2072 internal::UpdateObjectAclRequest request(bucket_name, object_name,
2073 acl.entity(), acl.role());
2074 request.set_multiple_options(std::forward<Options>(options)...);
2075 return raw_client_->UpdateObjectAcl(request);
2114 template <
typename... Options>
2116 std::string
const& bucket_name, std::string
const& object_name,
2119 internal::PatchObjectAclRequest request(bucket_name, object_name, entity,
2120 original_acl, new_acl);
2121 request.set_multiple_options(std::forward<Options>(options)...);
2122 return raw_client_->PatchObjectAcl(request);
2159 template <
typename... Options>
2161 std::string
const& bucket_name, std::string
const& object_name,
2163 Options&&... options) {
2164 internal::PatchObjectAclRequest request(bucket_name, object_name, entity,
2166 request.set_multiple_options(std::forward<Options>(options)...);
2167 return raw_client_->PatchObjectAcl(request);
2208 template <
typename... Options>
2210 std::string
const& bucket_name, Options&&... options) {
2211 internal::ListDefaultObjectAclRequest request(bucket_name);
2212 request.set_multiple_options(std::forward<Options>(options)...);
2213 auto response = raw_client_->ListDefaultObjectAcl(request);
2215 return std::move(response).status();
2217 return std::move(response.value().items);
2246 template <
typename... Options>
2248 std::string
const& bucket_name, std::string
const& entity,
2249 std::string
const& role, Options&&... options) {
2250 internal::CreateDefaultObjectAclRequest request(bucket_name, entity, role);
2251 request.set_multiple_options(std::forward<Options>(options)...);
2252 return raw_client_->CreateDefaultObjectAcl(request);
2278 template <
typename... Options>
2280 std::string
const& entity,
2281 Options&&... options) {
2282 internal::DeleteDefaultObjectAclRequest request(bucket_name, entity);
2283 request.set_multiple_options(std::forward<Options>(options)...);
2284 return raw_client_->DeleteDefaultObjectAcl(request).status();
2309 template <
typename... Options>
2311 std::string
const& bucket_name, std::string
const& entity,
2312 Options&&... options) {
2313 internal::GetDefaultObjectAclRequest request(bucket_name, entity);
2314 request.set_multiple_options(std::forward<Options>(options)...);
2315 return raw_client_->GetDefaultObjectAcl(request);
2351 template <
typename... Options>
2354 Options&&... options) {
2355 internal::UpdateDefaultObjectAclRequest request(bucket_name, acl.entity(),
2357 request.set_multiple_options(std::forward<Options>(options)...);
2358 return raw_client_->UpdateDefaultObjectAcl(request);
2399 template <
typename... Options>
2401 std::string
const& bucket_name, std::string
const& entity,
2404 internal::PatchDefaultObjectAclRequest request(bucket_name, entity,
2405 original_acl, new_acl);
2406 request.set_multiple_options(std::forward<Options>(options)...);
2407 return raw_client_->PatchDefaultObjectAcl(request);
2447 template <
typename... Options>
2449 std::string
const& bucket_name, std::string
const& entity,
2451 internal::PatchDefaultObjectAclRequest request(bucket_name, entity,
2453 request.set_multiple_options(std::forward<Options>(options)...);
2454 return raw_client_->PatchDefaultObjectAcl(request);
2491 template <
typename... Options>
2493 std::string
const& project_id, Options&&... options) {
2494 internal::GetProjectServiceAccountRequest request(project_id);
2495 request.set_multiple_options(std::forward<Options>(options)...);
2496 return raw_client_->GetServiceAccount(request);
2526 template <
typename... Options>
2528 auto const& project_id = raw_client_->client_options().project_id();
2529 return GetServiceAccountForProject(project_id,
2530 std::forward<Options>(options)...);
2562 template <
typename... Options>
2564 auto const& project_id = raw_client_->client_options().project_id();
2565 internal::ListHmacKeysRequest request(project_id);
2566 request.set_multiple_options(std::forward<Options>(options)...);
2567 auto client = raw_client_;
2568 return google::cloud::internal::MakePaginationRange<ListHmacKeysReader>(
2570 [client](internal::ListHmacKeysRequest
const& r) {
2571 return client->ListHmacKeys(r);
2573 [](internal::ListHmacKeysResponse r) {
return std::move(r.items); });
2609 template <
typename... Options>
2611 std::string service_account, Options&&... options) {
2612 auto const& project_id = raw_client_->client_options().project_id();
2613 internal::CreateHmacKeyRequest request(project_id,
2614 std::move(service_account));
2615 request.set_multiple_options(std::forward<Options>(options)...);
2616 auto result = raw_client_->CreateHmacKey(request);
2618 return result.status();
2620 return std::make_pair(std::move(result->metadata),
2621 std::move(result->secret));
2652 template <
typename... Options>
2654 auto const& project_id = raw_client_->client_options().project_id();
2655 internal::DeleteHmacKeyRequest request(project_id, std::move(access_id));
2656 request.set_multiple_options(std::forward<Options>(options)...);
2657 return raw_client_->DeleteHmacKey(request).status();
2687 template <
typename... Options>
2689 Options&&... options) {
2690 auto const& project_id = raw_client_->client_options().project_id();
2691 internal::GetHmacKeyRequest request(project_id, std::move(access_id));
2692 request.set_multiple_options(std::forward<Options>(options)...);
2693 return raw_client_->GetHmacKey(request);
2727 template <
typename... Options>
2730 Options&&... options) {
2731 auto const& project_id = raw_client_->client_options().project_id();
2732 internal::UpdateHmacKeyRequest request(project_id, std::move(access_id),
2733 std::move(resource));
2734 request.set_multiple_options(std::forward<Options>(options)...);
2735 return raw_client_->UpdateHmacKey(request);
2793 template <
typename... Options>
2795 std::string bucket_name,
2796 std::string object_name,
2797 Options&&... options) {
2798 internal::V2SignUrlRequest request(std::move(verb), std::move(bucket_name),
2799 std::move(object_name));
2800 request.set_multiple_options(std::forward<Options>(options)...);
2801 return SignUrlV2(request);
2856 template <
typename... Options>
2858 std::string bucket_name,
2859 std::string object_name,
2860 Options&&... options) {
2861 internal::V4SignUrlRequest request(std::move(verb), std::move(bucket_name),
2862 std::move(object_name));
2863 request.set_multiple_options(std::forward<Options>(options)...);
2864 return SignUrlV4(std::move(request));
2900 template <
typename... Options>
2903 internal::PolicyDocumentRequest request(std::move(document));
2904 request.set_multiple_options(std::forward<Options>(options)...);
2905 return SignPolicyDocument(request);
2941 template <
typename... Options>
2944 internal::PolicyDocumentV4Request request(std::move(document));
2945 request.set_multiple_options(std::forward<Options>(options)...);
2946 return SignPolicyDocumentV4(std::move(request));
2976 template <
typename... Options>
2978 std::string
const& bucket_name, Options&&... options) {
2979 internal::ListNotificationsRequest request(bucket_name);
2980 request.set_multiple_options(std::forward<Options>(options)...);
2981 auto result = raw_client_->ListNotifications(request);
2983 return std::move(result).status();
2985 return std::move(result).value().items;
3021 template <
typename... Options>
3023 std::string
const& bucket_name, std::string
const& topic_name,
3025 Options&&... options) {
3027 internal::CreateNotificationRequest request(bucket_name, metadata);
3028 request.set_multiple_options(std::forward<Options>(options)...);
3029 return raw_client_->CreateNotification(request);
3057 template <
typename... Options>
3059 std::string
const& bucket_name, std::string
const& notification_id,
3060 Options&&... options) {
3061 internal::GetNotificationRequest request(bucket_name, notification_id);
3062 request.set_multiple_options(std::forward<Options>(options)...);
3063 return raw_client_->GetNotification(request);
3093 template <
typename... Options>
3095 std::string
const& notification_id,
3096 Options&&... options) {
3097 internal::DeleteNotificationRequest request(bucket_name, notification_id);
3098 request.set_multiple_options(std::forward<Options>(options)...);
3099 return std::move(raw_client_->DeleteNotification(request)).status();
3105 static std::shared_ptr<internal::RawClient> CreateDefaultInternalClient(
3108 template <
typename... Policies>
3109 std::shared_ptr<internal::RawClient> Decorate(
3110 std::shared_ptr<internal::RawClient> client, Policies&&... policies) {
3111 if (client->client_options().enable_raw_client_tracing()) {
3112 client = std::make_shared<internal::LoggingClient>(std::move(client));
3114 auto retry = std::make_shared<internal::RetryClient>(
3115 std::move(client), std::forward<Policies>(policies)...);
3119 ObjectReadStream ReadObjectImpl(
3120 internal::ReadObjectRangeRequest
const& request);
3122 ObjectWriteStream WriteObjectImpl(
3123 internal::ResumableUploadRequest
const& request);
3127 template <
typename... Options>
3128 StatusOr<ObjectMetadata> UploadFileImpl(std::string
const& file_name,
3129 std::string
const& bucket_name,
3130 std::string
const& object_name,
3132 Options&&... options) {
3133 internal::ResumableUploadRequest request(bucket_name, object_name);
3134 request.set_multiple_options(std::forward<Options>(options)...);
3135 return UploadFileResumable(file_name, std::move(request));
3141 template <
typename... Options>
3142 StatusOr<ObjectMetadata> UploadFileImpl(std::string
const& file_name,
3143 std::string
const& bucket_name,
3144 std::string
const& object_name,
3146 Options&&... options) {
3147 std::size_t file_size = 0;
3148 if (UseSimpleUpload(file_name, file_size)) {
3149 internal::InsertObjectMediaRequest request(bucket_name, object_name,
3151 request.set_multiple_options(std::forward<Options>(options)...);
3152 return UploadFileSimple(file_name, file_size, request);
3154 internal::ResumableUploadRequest request(bucket_name, object_name);
3155 request.set_multiple_options(std::forward<Options>(options)...);
3156 return UploadFileResumable(file_name, std::move(request));
3159 bool UseSimpleUpload(std::string
const& file_name, std::size_t& size)
const;
3161 StatusOr<ObjectMetadata> UploadFileSimple(
3162 std::string
const& file_name, std::size_t file_size,
3163 internal::InsertObjectMediaRequest request);
3165 StatusOr<ObjectMetadata> UploadFileResumable(
3166 std::string
const& file_name, internal::ResumableUploadRequest request);
3168 StatusOr<ObjectMetadata> UploadStreamResumable(
3169 std::istream& source, internal::ResumableUploadRequest
const& request);
3171 Status DownloadFileImpl(internal::ReadObjectRangeRequest
const& request,
3172 std::string
const& file_name);
3175 std::string SigningEmail(SigningAccount
const& signing_account);
3179 struct SignBlobResponseRaw {
3181 std::vector<std::uint8_t> signed_blob;
3185 StatusOr<SignBlobResponseRaw> SignBlobImpl(
3186 SigningAccount
const& signing_account, std::string
const& string_to_sign);
3188 StatusOr<std::string> SignUrlV2(internal::V2SignUrlRequest
const& request);
3189 StatusOr<std::string> SignUrlV4(internal::V4SignUrlRequest request);
3191 StatusOr<PolicyDocumentResult> SignPolicyDocument(
3192 internal::PolicyDocumentRequest
const& request);
3193 StatusOr<PolicyDocumentV4Result> SignPolicyDocumentV4(
3194 internal::PolicyDocumentV4Request request);
3196 std::shared_ptr<internal::RawClient> raw_client_;
3198 friend class internal::NonResumableParallelUploadState;
3199 friend class internal::ResumableParallelUploadState;
3200 friend class testing::ClientTester;
3221 namespace internal {
3224 struct DeleteApplyHelper {
3225 template <
typename... Options>
3226 Status operator()(Options... options)
const {
3227 return client.DeleteObject(bucket_name, object_name, std::move(options)...);
3231 std::string bucket_name;
3232 std::string object_name;
3236 struct InsertObjectApplyHelper {
3237 template <
typename... Options>
3238 StatusOr<ObjectMetadata> operator()(Options... options)
const {
3239 return client.InsertObject(bucket_name, object_name, std::move(contents),
3240 std::move(options)...);
3244 std::string
const& bucket_name;
3245 std::string
const& object_name;
3246 std::string contents;
3262 template <
typename... Options>
3263 StatusOr<ObjectMetadata> LockPrefix(Client& client,
3264 std::string
const& bucket_name,
3265 std::string
const& prefix,
3266 Options&&... options) {
3267 return google::cloud::internal::apply(
3268 internal::InsertObjectApplyHelper{client, bucket_name, prefix,
""},
3270 std::make_tuple(IfGenerationMatch(0)),
3271 internal::StaticTupleFilter<
3272 internal::Among<EncryptionKey, KmsKeyName, PredefinedAcl,
3273 Projection, UserProject>::TPred>(
3274 std::forward_as_tuple(std::forward<Options>(options)...))));
3289 template <
typename... Options>
3291 std::string
const& prefix, Options&&... options) {
3292 using internal::NotAmong;
3293 using internal::StaticTupleFilter;
3295 auto all_options = std::tie(options...);
3298 std::tuple_size<decltype(
3300 NotAmong<QuotaUser, UserIp, UserProject, Versions>::TPred>(
3301 all_options))>::value == 0,
3302 "This functions accepts only options of type QuotaUser, UserIp, "
3303 "UserProject or Versions.");
3304 for (
auto const&
object :
3306 std::forward<Options>(options)...)) {
3308 return object.status();
3311 auto deletion_status = google::cloud::internal::apply(
3312 internal::DeleteApplyHelper{client, bucket_name,
object->name()},
3315 StaticTupleFilter<NotAmong<Versions>::TPred>(all_options)));
3317 if (!deletion_status.ok()) {
3318 return deletion_status;
3324 namespace internal {
3327 struct ComposeApplyHelper {
3328 template <
typename... Options>
3329 StatusOr<ObjectMetadata> operator()(Options... options)
const {
3330 return client.ComposeObject(
3331 std::move(bucket_name), std::move(source_objects),
3332 std::move(destination_object_name), std::move(options)...);
3336 std::string bucket_name;
3337 std::vector<ComposeSourceObject> source_objects;
3338 std::string destination_object_name;
3342 class ScopedDeleter {
3347 ScopedDeleter(std::function<Status(std::string, std::int64_t)> delete_fun);
3348 ScopedDeleter(ScopedDeleter
const&) =
delete;
3349 ScopedDeleter& operator=(ScopedDeleter
const&) =
delete;
3353 void Add(ObjectMetadata
const&
object);
3356 void Add(std::string object_name, std::int64_t generation);
3359 Status ExecuteDelete();
3361 void Enable(
bool enable) { enabled_ = enable; }
3365 std::function<Status(std::string, std::int64_t)> delete_fun_;
3366 std::vector<std::pair<std::string, std::int64_t>> object_list_;
3414 template <
typename... Options>
3416 Client& client, std::string
const& bucket_name,
3417 std::vector<ComposeSourceObject> source_objects, std::string
const& prefix,
3418 std::string destination_object_name,
bool ignore_cleanup_failures,
3419 Options&&... options) {
3420 using internal::Among;
3421 using internal::NotAmong;
3422 using internal::StaticTupleFilter;
3423 std::size_t
const max_num_objects = 32;
3425 if (source_objects.empty()) {
3426 return Status(StatusCode::kInvalidArgument,
3427 "ComposeMany requires at least one source object.");
3430 auto all_options = std::make_tuple(options...);
3434 std::tuple_size<decltype(
3435 StaticTupleFilter<NotAmong<
3439 all_options))>::value == 0,
3440 "This functions accepts only options of type DestinationPredefinedAcl, "
3441 "EncryptionKey, IfGenerationMatch, IfMetagenerationMatch, KmsKeyName, "
3442 "QuotaUser, UserIp, UserProject or WithObjectMetadata.");
3444 internal::ScopedDeleter deleter(
3445 [&](std::string
const& object_name, std::int64_t generation) {
3446 return google::cloud::internal::apply(
3447 internal::DeleteApplyHelper{client, bucket_name, object_name},
3450 StaticTupleFilter<Among<QuotaUser, UserProject, UserIp>::TPred>(
3454 auto lock = internal::LockPrefix(client, bucket_name, prefix,
"",
3455 std::make_tuple(options...));
3458 lock.status().code(),
3459 "Failed to lock prefix for ComposeMany: " + lock.status().message());
3463 std::size_t num_tmp_objects = 0;
3464 auto tmpobject_name_gen = [&num_tmp_objects, &prefix] {
3465 return prefix +
".compose-tmp-" + std::to_string(num_tmp_objects++);
3468 auto to_source_objects = [](std::vector<ObjectMetadata> objects) {
3469 std::vector<ComposeSourceObject> sources(objects.size());
3470 std::transform(objects.begin(), objects.end(), sources.begin(),
3472 return ComposeSourceObject{m.name(), m.generation(), {}};
3477 auto composer = [&](std::vector<ComposeSourceObject> compose_range,
3478 bool is_final) -> StatusOr<ObjectMetadata> {
3480 return google::cloud::internal::apply(
3481 internal::ComposeApplyHelper{client, bucket_name,
3482 std::move(compose_range),
3483 std::move(destination_object_name)},
3484 std::tuple_cat(std::make_tuple(IfGenerationMatch(0)), all_options));
3486 return google::cloud::internal::apply(
3487 internal::ComposeApplyHelper{client, bucket_name,
3488 std::move(compose_range),
3489 tmpobject_name_gen()},
3491 NotAmong<IfGenerationMatch, IfMetagenerationMatch>::TPred>(
3495 auto reduce = [&](std::vector<ComposeSourceObject> source_objects)
3496 -> StatusOr<std::vector<ObjectMetadata>> {
3497 std::vector<ObjectMetadata> objects;
3498 for (
auto range_begin = source_objects.begin();
3499 range_begin != source_objects.end();) {
3500 std::size_t range_size = std::min<std::size_t>(
3501 std::distance(range_begin, source_objects.end()), max_num_objects);
3502 auto range_end = std::next(range_begin, range_size);
3503 std::vector<ComposeSourceObject> compose_range(range_size);
3504 std::move(range_begin, range_end, compose_range.begin());
3506 bool const is_final_composition =
3507 source_objects.size() <= max_num_objects;
3508 auto object = composer(std::move(compose_range), is_final_composition);
3510 return std::move(
object).status();
3512 objects.push_back(*std::move(
object));
3513 if (!is_final_composition) {
3514 deleter.Add(objects.back());
3516 range_begin = range_end;
3521 StatusOr<ObjectMetadata> result;
3523 StatusOr<std::vector<ObjectMetadata>> objects = reduce(source_objects);
3525 return objects.status();
3527 if (objects->size() == 1) {
3528 if (!ignore_cleanup_failures) {
3529 auto delete_status = deleter.ExecuteDelete();
3530 if (!delete_status.ok()) {
3531 return delete_status;
3534 result = std::move((*objects)[0]);
3537 source_objects = to_source_objects(*std::move(objects));
3538 }
while (source_objects.size() > 1);
3547 #endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_CLIENT_H