15 #ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_CLIENT_H
16 #define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_CLIENT_H
18 #include "google/cloud/storage/hmac_key_metadata.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"
25 #include "google/cloud/storage/list_buckets_reader.h"
26 #include "google/cloud/storage/list_hmac_keys_reader.h"
27 #include "google/cloud/storage/list_objects_and_prefixes_reader.h"
28 #include "google/cloud/storage/list_objects_reader.h"
29 #include "google/cloud/storage/notification_event_type.h"
30 #include "google/cloud/storage/notification_payload_format.h"
31 #include "google/cloud/storage/oauth2/google_credentials.h"
32 #include "google/cloud/storage/object_rewriter.h"
33 #include "google/cloud/storage/object_stream.h"
34 #include "google/cloud/storage/retry_policy.h"
35 #include "google/cloud/storage/upload_options.h"
36 #include "google/cloud/storage/version.h"
37 #include "google/cloud/internal/throw_delegate.h"
38 #include "google/cloud/status.h"
39 #include "google/cloud/status_or.h"
40 #include "absl/meta/type_traits.h"
42 #include <type_traits>
50 class NonResumableParallelUploadState;
51 class ResumableParallelUploadState;
52 struct ClientImplDetails;
254 template <
typename... Policies>
256 :
Client(InternalOnly{}, internal::ApplyPolicies(
257 internal::MakeOptions(std::move(options)),
258 std::forward<Policies>(policies)...)) {}
271 template <
typename... Policies>
273 Policies&&... policies)
275 internal::ApplyPolicies(
276 internal::DefaultOptions(std::move(credentials),
{}),
277 std::forward<Policies>(policies)...)) {}
290 template <
typename... Policies>
291 #if !defined(_MSC_VER) || _MSC_VER >= 1920
292 GOOGLE_CLOUD_CPP_DEPRECATED(
293 "applications should not need this."
294 " Please use the constructors from ClientOptions instead."
295 " For mocking, please use testing::ClientFromMock() instead."
296 " Please file a bug at https://github.com/googleapis/google-cloud-cpp"
297 " if you have a use-case not covered by these.")
300 explicit Client(std::shared_ptr<internal::RawClient> client,
301 Policies&&... policies)
302 :
Client(InternalOnlyNoDecorations{},
303 CreateDefaultInternalClient(
304 internal::ApplyPolicies(
305 internal::DefaultOptions(
307 std::forward<Policies>(policies)...),
317 GOOGLE_CLOUD_CPP_DEPRECATED(
318 "applications should not need this."
319 " Please file a bug at https://github.com/googleapis/google-cloud-cpp"
322 :
Client(InternalOnlyNoDecorations{}, std::move(client)) {}
327 return a.raw_client_ == b.raw_client_;
334 GOOGLE_CLOUD_CPP_DEPRECATED(
335 "applications should not need this."
336 " Please file a bug at https://github.com/googleapis/google-cloud-cpp"
368 template <
typename... Options>
370 Options&&... options) {
371 internal::ListBucketsRequest request(project_id);
372 request.set_multiple_options(std::forward<Options>(options)...);
373 auto client = raw_client_;
374 return google::
cloud::internal::MakePaginationRange<ListBucketsReader>(
376 [client](internal::ListBucketsRequest
const& r) {
377 return client->ListBuckets(r);
379 [](internal::ListBucketsResponse r) {
return std::move(r.items); });
402 template <
typename... Options>
404 auto const& project_id = raw_client_->client_options()
.project_id();
405 return ListBucketsForProject(project_id, std::forward<Options>(options)...);
435 template <
typename... Options>
438 Options&&... options) {
439 auto const& project_id = raw_client_->client_options()
.project_id();
440 return CreateBucketForProject(std::move(bucket_name), project_id,
442 std::forward<Options>(options)...);
471 template <
typename... Options>
473 std::string project_id,
475 Options&&... options) {
477 internal::CreateBucketRequest request(std::move(project_id),
478 std::move(metadata));
479 request.set_multiple_options(std::forward<Options>(options)...);
480 return raw_client_->CreateBucket(request);
497 template <
typename... Options>
499 Options&&... options) {
500 internal::GetBucketMetadataRequest request(bucket_name);
501 request.set_multiple_options(std::forward<Options>(options)...);
502 return raw_client_->GetBucketMetadata(request);
520 template <
typename... Options>
522 internal::DeleteBucketRequest request(bucket_name);
523 request.set_multiple_options(std::forward<Options>(options)...);
524 return raw_client_->DeleteBucket(request)
.status();
560 template <
typename... Options>
563 Options&&... options) {
565 internal::UpdateBucketRequest request(std::move(metadata));
566 request.set_multiple_options(std::forward<Options>(options)...);
567 return raw_client_->UpdateBucket(request);
607 template <
typename... Options>
611 Options&&... options) {
612 internal::PatchBucketRequest request(std::move(bucket_name), original,
614 request.set_multiple_options(std::forward<Options>(options)...);
615 return raw_client_->PatchBucket(request);
650 template <
typename... Options>
653 Options&&... options) {
654 internal::PatchBucketRequest request(std::move(bucket_name), builder);
655 request.set_multiple_options(std::forward<Options>(options)...);
656 return raw_client_->PatchBucket(request);
692 template <
typename... Options>
694 std::string
const& bucket_name, Options&&... options) {
695 internal::GetBucketIamPolicyRequest request(bucket_name);
696 request.set_multiple_options(std::forward<Options>(options)...);
697 return raw_client_->GetNativeBucketIamPolicy(request);
746 template <
typename... Options>
749 Options&&... options) {
750 internal::SetNativeBucketIamPolicyRequest request(bucket_name, iam_policy);
751 request.set_multiple_options(std::forward<Options>(options)...);
752 return raw_client_->SetNativeBucketIamPolicy(request);
782 template <
typename... Options>
784 std::string bucket_name, std::vector<std::string> permissions,
785 Options&&... options) {
786 internal::TestBucketIamPermissionsRequest request(std::move(bucket_name),
787 std::move(permissions));
788 request.set_multiple_options(std::forward<Options>(options)...);
789 auto result = raw_client_->TestBucketIamPermissions(request);
793 return std::move(result
.value().permissions);
842 template <
typename... Options>
844 std::string
const& bucket_name, std::uint64_t metageneration,
845 Options&&... options) {
846 internal::LockBucketRetentionPolicyRequest request(bucket_name,
848 request.set_multiple_options(std::forward<Options>(options)...);
849 return raw_client_->LockBucketRetentionPolicy(request);
890 template <
typename... Options>
892 std::string
const& object_name,
893 std::string contents,
894 Options&&... options) {
895 internal::InsertObjectMediaRequest request(bucket_name, object_name,
896 std::move(contents));
897 request.set_multiple_options(std::forward<Options>(options)...);
898 return raw_client_->InsertObjectMedia(request);
941 template <
typename... Options>
943 std::string source_object_name,
944 std::string destination_bucket_name,
945 std::string destination_object_name,
946 Options&&... options) {
947 internal::CopyObjectRequest request(
948 std::move(source_bucket_name), std::move(source_object_name),
949 std::move(destination_bucket_name), std::move(destination_object_name));
950 request.set_multiple_options(std::forward<Options>(options)...);
951 return raw_client_->CopyObject(request);
970 template <
typename... Options>
972 std::string
const& object_name,
973 Options&&... options) {
974 internal::GetObjectMetadataRequest request(bucket_name, object_name);
975 request.set_multiple_options(std::forward<Options>(options)...);
976 return raw_client_->GetObjectMetadata(request);
995 template <
typename... Options>
997 Options&&... options) {
998 internal::ListObjectsRequest request(bucket_name);
999 request.set_multiple_options(std::forward<Options>(options)...);
1000 auto client = raw_client_;
1001 return google::
cloud::internal::MakePaginationRange<ListObjectsReader>(
1003 [client](internal::ListObjectsRequest
const& r) {
1004 return client->ListObjects(r);
1006 [](internal::ListObjectsResponse r) {
return std::move(r.items); });
1025 template <
typename... Options>
1027 std::string
const& bucket_name, Options&&... options) {
1028 internal::ListObjectsRequest request(bucket_name);
1029 request.set_multiple_options(std::forward<Options>(options)...);
1030 auto client = raw_client_;
1031 return google::
cloud::internal::MakePaginationRange<
1032 ListObjectsAndPrefixesReader>(
1034 [client](internal::ListObjectsRequest
const& r) {
1035 return client->ListObjects(r);
1037 [](internal::ListObjectsResponse r) {
1038 std::vector<ObjectOrPrefix> result;
1039 for (
auto& item : r.items) {
1040 result.emplace_back(std::move(item));
1042 for (
auto& prefix : r.prefixes) {
1043 result.emplace_back(std::move(prefix));
1045 internal::SortObjectsAndPrefixes(result);
1085 template <
typename... Options>
1087 std::string
const& object_name,
1088 Options&&... options) {
1090 :
public absl::disjunction<std::is_same<
ReadRange, Options>...> {};
1091 struct HasReadFromOffset
1092 :
public absl::disjunction<std::is_same<
ReadFromOffset, Options>...> {};
1094 :
public absl::disjunction<std::is_same<
ReadLast, Options>...> {};
1096 struct HasIncompatibleRangeOptions
1097 :
public std::integral_constant<
bool, HasReadLast::value &&
1098 (HasReadFromOffset::value ||
1099 HasReadRange::value)> {};
1101 static_assert(!HasIncompatibleRangeOptions::value,
1102 "Cannot set ReadLast option with either ReadFromOffset or "
1105 internal::ReadObjectRangeRequest request(bucket_name, object_name);
1106 request.set_multiple_options(std::forward<Options>(options)...);
1107 return ReadObjectImpl(request);
1171 template <
typename... Options>
1173 std::string
const& object_name,
1174 Options&&... options) {
1175 internal::ResumableUploadRequest request(bucket_name, object_name);
1176 request.set_multiple_options(std::forward<Options>(options)...);
1177 return WriteObjectImpl(request);
1210 template <
typename... Options>
1212 std::string
const& bucket_name,
1213 std::string
const& object_name,
1214 Options&&... options) {
1219 using HasUseResumableUpload =
1221 return UploadFileImpl(file_name, bucket_name, object_name,
1222 HasUseResumableUpload{},
1223 std::forward<Options>(options)...);
1238 template <
typename... Options>
1240 Options&&... options) {
1241 internal::DeleteResumableUploadRequest request(upload_session_url);
1242 request.set_multiple_options(std::forward<Options>(options)...);
1243 return raw_client_->DeleteResumableUpload(request)
.status();
1265 template <
typename... Options>
1267 std::string
const& object_name,
1268 std::string
const& file_name, Options&&... options) {
1269 internal::ReadObjectRangeRequest request(bucket_name, object_name);
1270 request.set_multiple_options(std::forward<Options>(options)...);
1271 return DownloadFileImpl(request, file_name);
1292 template <
typename... Options>
1294 std::string
const& object_name, Options&&... options) {
1295 internal::DeleteObjectRequest request(bucket_name, object_name);
1296 request.set_multiple_options(std::forward<Options>(options)...);
1297 return raw_client_->DeleteObject(request)
.status();
1322 template <
typename... Options>
1324 std::string object_name,
1326 Options&&... options) {
1327 internal::UpdateObjectRequest request(
1328 std::move(bucket_name), std::move(object_name), std::move(metadata));
1329 request.set_multiple_options(std::forward<Options>(options)...);
1330 return raw_client_->UpdateObject(request);
1359 template <
typename... Options>
1361 std::string object_name,
1364 Options&&... options) {
1365 internal::PatchObjectRequest request(
1366 std::move(bucket_name), std::move(object_name), original, updated);
1367 request.set_multiple_options(std::forward<Options>(options)...);
1368 return raw_client_->PatchObject(request);
1395 template <
typename... Options>
1397 std::string bucket_name, std::string object_name,
1399 internal::PatchObjectRequest request(std::move(bucket_name),
1400 std::move(object_name), builder);
1401 request.set_multiple_options(std::forward<Options>(options)...);
1402 return raw_client_->PatchObject(request);
1428 template <
typename... Options>
1431 std::string destination_object_name, Options&&... options) {
1432 internal::ComposeObjectRequest request(std::move(bucket_name),
1433 std::move(source_objects),
1434 std::move(destination_object_name));
1435 request.set_multiple_options(std::forward<Options>(options)...);
1436 return raw_client_->ComposeObject(request);
1477 template <
typename... Options>
1479 std::string source_object_name,
1480 std::string destination_bucket_name,
1481 std::string destination_object_name,
1482 Options&&... options) {
1483 return ResumeRewriteObject(
1484 std::move(source_bucket_name), std::move(source_object_name),
1485 std::move(destination_bucket_name), std::move(destination_object_name),
1486 std::string{}, std::forward<Options>(options)...);
1529 template <
typename... Options>
1531 std::string source_object_name,
1532 std::string destination_bucket_name,
1533 std::string destination_object_name,
1534 std::string rewrite_token,
1535 Options&&... options) {
1536 internal::RewriteObjectRequest request(
1537 std::move(source_bucket_name), std::move(source_object_name),
1538 std::move(destination_bucket_name), std::move(destination_object_name),
1539 std::move(rewrite_token));
1540 request.set_multiple_options(std::forward<Options>(options)...);
1587 template <
typename... Options>
1589 std::string source_bucket_name, std::string source_object_name,
1590 std::string destination_bucket_name, std::string destination_object_name,
1591 Options&&... options) {
1592 return ResumeRewriteObject(std::move(source_bucket_name),
1593 std::move(source_object_name),
1594 std::move(destination_bucket_name),
1595 std::move(destination_object_name),
1596 std::string{}, std::forward<Options>(options)...)
1645 template <
typename... Options>
1647 std::string
const& bucket_name, Options&&... options) {
1648 internal::ListBucketAclRequest request(bucket_name);
1649 request.set_multiple_options(std::forward<Options>(options)...);
1650 auto items = raw_client_->ListBucketAcl(request);
1654 return std::move(items
.value().items);
1678 template <
typename... Options>
1680 std::string
const& entity,
1681 std::string
const& role,
1682 Options&&... options) {
1683 internal::CreateBucketAclRequest request(bucket_name, entity, role);
1684 request.set_multiple_options(std::forward<Options>(options)...);
1685 return raw_client_->CreateBucketAcl(request);
1706 template <
typename... Options>
1708 std::string
const& entity, Options&&... options) {
1709 internal::DeleteBucketAclRequest request(bucket_name, entity);
1710 request.set_multiple_options(std::forward<Options>(options)...);
1711 return raw_client_->DeleteBucketAcl(request)
.status();
1731 template <
typename... Options>
1733 std::string
const& entity,
1734 Options&&... options) {
1735 internal::GetBucketAclRequest request(bucket_name, entity);
1736 request.set_multiple_options(std::forward<Options>(options)...);
1737 return raw_client_->GetBucketAcl(request);
1770 template <
typename... Options>
1773 Options&&... options) {
1774 internal::UpdateBucketAclRequest request(bucket_name, acl.entity(),
1776 request.set_multiple_options(std::forward<Options>(options)...);
1777 return raw_client_->UpdateBucketAcl(request);
1815 template <
typename... Options>
1817 std::string
const& bucket_name, std::string
const& entity,
1820 internal::PatchBucketAclRequest request(bucket_name, entity, original_acl,
1822 request.set_multiple_options(std::forward<Options>(options)...);
1823 return raw_client_->PatchBucketAcl(request);
1859 template <
typename... Options>
1861 std::string
const& bucket_name, std::string
const& entity,
1863 internal::PatchBucketAclRequest request(bucket_name, entity, builder);
1864 request.set_multiple_options(std::forward<Options>(options)...);
1865 return raw_client_->PatchBucketAcl(request);
1907 template <
typename... Options>
1909 std::string
const& bucket_name, std::string
const& object_name,
1910 Options&&... options) {
1911 internal::ListObjectAclRequest request(bucket_name, object_name);
1912 request.set_multiple_options(std::forward<Options>(options)...);
1913 auto result = raw_client_->ListObjectAcl(request);
1917 return std::move(result
.value().items);
1942 template <
typename... Options>
1944 std::string
const& object_name,
1945 std::string
const& entity,
1946 std::string
const& role,
1947 Options&&... options) {
1948 internal::CreateObjectAclRequest request(bucket_name, object_name, entity,
1950 request.set_multiple_options(std::forward<Options>(options)...);
1951 return raw_client_->CreateObjectAcl(request);
1974 template <
typename... Options>
1976 std::string
const& object_name,
1977 std::string
const& entity, Options&&... options) {
1978 internal::DeleteObjectAclRequest request(bucket_name, object_name, entity);
1979 request.set_multiple_options(std::forward<Options>(options)...);
1980 return raw_client_->DeleteObjectAcl(request)
.status();
2001 template <
typename... Options>
2003 std::string
const& object_name,
2004 std::string
const& entity,
2005 Options&&... options) {
2006 internal::GetObjectAclRequest request(bucket_name, object_name, entity);
2007 request.set_multiple_options(std::forward<Options>(options)...);
2008 return raw_client_->GetObjectAcl(request);
2040 template <
typename... Options>
2042 std::string
const& object_name,
2044 Options&&... options) {
2045 internal::UpdateObjectAclRequest request(bucket_name, object_name,
2046 acl.entity(), acl.role());
2047 request.set_multiple_options(std::forward<Options>(options)...);
2048 return raw_client_->UpdateObjectAcl(request);
2087 template <
typename... Options>
2089 std::string
const& bucket_name, std::string
const& object_name,
2092 internal::PatchObjectAclRequest request(bucket_name, object_name, entity,
2093 original_acl, new_acl);
2094 request.set_multiple_options(std::forward<Options>(options)...);
2095 return raw_client_->PatchObjectAcl(request);
2132 template <
typename... Options>
2134 std::string
const& bucket_name, std::string
const& object_name,
2136 Options&&... options) {
2137 internal::PatchObjectAclRequest request(bucket_name, object_name, entity,
2139 request.set_multiple_options(std::forward<Options>(options)...);
2140 return raw_client_->PatchObjectAcl(request);
2181 template <
typename... Options>
2183 std::string
const& bucket_name, Options&&... options) {
2184 internal::ListDefaultObjectAclRequest request(bucket_name);
2185 request.set_multiple_options(std::forward<Options>(options)...);
2186 auto response = raw_client_->ListDefaultObjectAcl(request);
2190 return std::move(response
.value().items);
2219 template <
typename... Options>
2221 std::string
const& bucket_name, std::string
const& entity,
2222 std::string
const& role, Options&&... options) {
2223 internal::CreateDefaultObjectAclRequest request(bucket_name, entity, role);
2224 request.set_multiple_options(std::forward<Options>(options)...);
2225 return raw_client_->CreateDefaultObjectAcl(request);
2251 template <
typename... Options>
2253 std::string
const& entity,
2254 Options&&... options) {
2255 internal::DeleteDefaultObjectAclRequest request(bucket_name, entity);
2256 request.set_multiple_options(std::forward<Options>(options)...);
2257 return raw_client_->DeleteDefaultObjectAcl(request)
.status();
2282 template <
typename... Options>
2284 std::string
const& bucket_name, std::string
const& entity,
2285 Options&&... options) {
2286 internal::GetDefaultObjectAclRequest request(bucket_name, entity);
2287 request.set_multiple_options(std::forward<Options>(options)...);
2288 return raw_client_->GetDefaultObjectAcl(request);
2324 template <
typename... Options>
2327 Options&&... options) {
2328 internal::UpdateDefaultObjectAclRequest request(bucket_name, acl.entity(),
2330 request.set_multiple_options(std::forward<Options>(options)...);
2331 return raw_client_->UpdateDefaultObjectAcl(request);
2372 template <
typename... Options>
2374 std::string
const& bucket_name, std::string
const& entity,
2377 internal::PatchDefaultObjectAclRequest request(bucket_name, entity,
2378 original_acl, new_acl);
2379 request.set_multiple_options(std::forward<Options>(options)...);
2380 return raw_client_->PatchDefaultObjectAcl(request);
2420 template <
typename... Options>
2422 std::string
const& bucket_name, std::string
const& entity,
2424 internal::PatchDefaultObjectAclRequest request(bucket_name, entity,
2426 request.set_multiple_options(std::forward<Options>(options)...);
2427 return raw_client_->PatchDefaultObjectAcl(request);
2464 template <
typename... Options>
2466 std::string
const& project_id, Options&&... options) {
2467 internal::GetProjectServiceAccountRequest request(project_id);
2468 request.set_multiple_options(std::forward<Options>(options)...);
2469 return raw_client_->GetServiceAccount(request);
2499 template <
typename... Options>
2501 auto const& project_id = raw_client_->client_options()
.project_id();
2502 return GetServiceAccountForProject(project_id,
2503 std::forward<Options>(options)...);
2535 template <
typename... Options>
2537 auto const& project_id = raw_client_->client_options()
.project_id();
2538 internal::ListHmacKeysRequest request(project_id);
2539 request.set_multiple_options(std::forward<Options>(options)...);
2540 auto client = raw_client_;
2541 return google::
cloud::internal::MakePaginationRange<ListHmacKeysReader>(
2543 [client](internal::ListHmacKeysRequest
const& r) {
2544 return client->ListHmacKeys(r);
2546 [](internal::ListHmacKeysResponse r) {
return std::move(r.items); });
2582 template <
typename... Options>
2584 std::string service_account, Options&&... options) {
2585 auto const& project_id = raw_client_->client_options()
.project_id();
2586 internal::CreateHmacKeyRequest request(project_id,
2587 std::move(service_account));
2588 request.set_multiple_options(std::forward<Options>(options)...);
2589 auto result = raw_client_->CreateHmacKey(request);
2593 return std::make_pair(std::move(result
->metadata),
2594 std::move(result
->secret));
2625 template <
typename... Options>
2627 auto const& project_id = raw_client_->client_options()
.project_id();
2628 internal::DeleteHmacKeyRequest request(project_id, std::move(access_id));
2629 request.set_multiple_options(std::forward<Options>(options)...);
2630 return raw_client_->DeleteHmacKey(request)
.status();
2660 template <
typename... Options>
2662 Options&&... options) {
2663 auto const& project_id = raw_client_->client_options()
.project_id();
2664 internal::GetHmacKeyRequest request(project_id, std::move(access_id));
2665 request.set_multiple_options(std::forward<Options>(options)...);
2666 return raw_client_->GetHmacKey(request);
2700 template <
typename... Options>
2703 Options&&... options) {
2704 auto const& project_id = raw_client_->client_options()
.project_id();
2705 internal::UpdateHmacKeyRequest request(project_id, std::move(access_id),
2706 std::move(resource));
2707 request.set_multiple_options(std::forward<Options>(options)...);
2708 return raw_client_->UpdateHmacKey(request);
2766 template <
typename... Options>
2768 std::string bucket_name,
2769 std::string object_name,
2770 Options&&... options) {
2771 internal::V2SignUrlRequest request(std::move(verb), std::move(bucket_name),
2772 std::move(object_name));
2773 request.set_multiple_options(std::forward<Options>(options)...);
2774 return SignUrlV2(request);
2829 template <
typename... Options>
2831 std::string bucket_name,
2832 std::string object_name,
2833 Options&&... options) {
2834 internal::V4SignUrlRequest request(std::move(verb), std::move(bucket_name),
2835 std::move(object_name));
2836 request.set_multiple_options(std::forward<Options>(options)...);
2837 return SignUrlV4(std::move(request));
2873 template <
typename... Options>
2876 internal::PolicyDocumentRequest request(std::move(document));
2877 request.set_multiple_options(std::forward<Options>(options)...);
2878 return SignPolicyDocument(request);
2914 template <
typename... Options>
2917 internal::PolicyDocumentV4Request request(std::move(document));
2918 request.set_multiple_options(std::forward<Options>(options)...);
2919 return SignPolicyDocumentV4(std::move(request));
2949 template <
typename... Options>
2951 std::string
const& bucket_name, Options&&... options) {
2952 internal::ListNotificationsRequest request(bucket_name);
2953 request.set_multiple_options(std::forward<Options>(options)...);
2954 auto result = raw_client_->ListNotifications(request);
2958 return std::move(result
.value().items);
2990 template <
typename... Options>
2992 std::string
const& bucket_name, std::string
const& topic_name,
2994 return CreateNotification(bucket_name, topic_name,
2996 std::forward<Options>(options)...);
3032 template <
typename... Options>
3034 std::string
const& bucket_name, std::string
const& topic_name,
3036 Options&&... options) {
3038 internal::CreateNotificationRequest request(bucket_name, metadata);
3039 request.set_multiple_options(std::forward<Options>(options)...);
3040 return raw_client_->CreateNotification(request);
3068 template <
typename... Options>
3070 std::string
const& bucket_name, std::string
const& notification_id,
3071 Options&&... options) {
3072 internal::GetNotificationRequest request(bucket_name, notification_id);
3073 request.set_multiple_options(std::forward<Options>(options)...);
3074 return raw_client_->GetNotification(request);
3104 template <
typename... Options>
3106 std::string
const& notification_id,
3107 Options&&... options) {
3108 internal::DeleteNotificationRequest request(bucket_name, notification_id);
3109 request.set_multiple_options(std::forward<Options>(options)...);
3110 return std::move(raw_client_->DeleteNotification(request))
.status();
3115 friend class internal::NonResumableParallelUploadState;
3116 friend class internal::ResumableParallelUploadState;
3117 friend internal::ClientImplDetails;
3119 struct InternalOnly {};
3120 struct InternalOnlyNoDecorations {};
3122 Client(InternalOnly,
Options const& opts)
3123 : raw_client_(CreateDefaultInternalClient(opts)) {}
3124 Client(InternalOnlyNoDecorations, std::shared_ptr<internal::RawClient> c)
3125 : raw_client_(std::move(c)) {}
3127 static std::shared_ptr<internal::RawClient> CreateDefaultInternalClient(
3128 Options const& opts, std::shared_ptr<internal::RawClient> client);
3129 static std::shared_ptr<internal::RawClient> CreateDefaultInternalClient(
3133 internal::ReadObjectRangeRequest
const& request);
3136 internal::ResumableUploadRequest
const& request);
3140 template <
typename... Options>
3141 StatusOr<
ObjectMetadata> UploadFileImpl(std::string
const& file_name,
3142 std::string
const& bucket_name,
3143 std::string
const& object_name,
3145 Options&&... options) {
3146 internal::ResumableUploadRequest request(bucket_name, object_name);
3147 request.set_multiple_options(std::forward<Options>(options)...);
3148 return UploadFileResumable(file_name, std::move(request));
3154 template <
typename... Options>
3155 StatusOr<
ObjectMetadata> UploadFileImpl(std::string
const& file_name,
3156 std::string
const& bucket_name,
3157 std::string
const& object_name,
3159 Options&&... options) {
3160 std::size_t file_size = 0;
3161 if (UseSimpleUpload(file_name, file_size)) {
3162 internal::InsertObjectMediaRequest request(bucket_name, object_name,
3164 request.set_multiple_options(std::forward<Options>(options)...);
3165 return UploadFileSimple(file_name, file_size, request);
3167 internal::ResumableUploadRequest request(bucket_name, object_name);
3168 request.set_multiple_options(std::forward<Options>(options)...);
3169 return UploadFileResumable(file_name, std::move(request));
3172 bool UseSimpleUpload(std::string
const& file_name, std::size_t& size)
const;
3175 std::string
const& file_name, std::size_t file_size,
3176 internal::InsertObjectMediaRequest request);
3179 std::string
const& file_name, internal::ResumableUploadRequest request);
3182 std::istream& source,
3183 internal::ResumableUploadRequest
const& request)
const;
3185 Status DownloadFileImpl(internal::ReadObjectRangeRequest
const& request,
3186 std::string
const& file_name);
3189 std::string SigningEmail(
SigningAccount const& signing_account)
const;
3193 struct SignBlobResponseRaw {
3195 std::vector<std::uint8_t> signed_blob;
3199 StatusOr<SignBlobResponseRaw> SignBlobImpl(
3200 SigningAccount const& signing_account, std::string
const& string_to_sign);
3202 StatusOr<std::string> SignUrlV2(internal::V2SignUrlRequest
const& request);
3203 StatusOr<std::string> SignUrlV4(internal::V4SignUrlRequest request);
3206 internal::PolicyDocumentRequest
const& request);
3208 internal::PolicyDocumentV4Request request);
3210 std::shared_ptr<internal::RawClient> raw_client_;
3231 namespace internal {
3232 struct ClientImplDetails {
3233 static std::shared_ptr<RawClient> GetRawClient(
Client& c) {
3234 return c.raw_client_;
3238 Client& client, std::istream& source,
3239 internal::ResumableUploadRequest
const& request) {
3240 return client.UploadStreamResumable(source, request);
3242 template <
typename... Policies>
3244 static Client CreateClient(std::shared_ptr<internal::RawClient> c,
3247 internal::ApplyPolicies(internal::MakeOptions(c->client_options()),
3248 std::forward<Policies>(p)...);
3250 Client::CreateDefaultInternalClient(opts, std::move(c)));
3253 static Client CreateWithoutDecorations(
3254 std::shared_ptr<internal::RawClient> c) {
3255 return Client(
Client::InternalOnlyNoDecorations{}, std::move(c));
3260 struct DeleteApplyHelper {
3261 template <
typename... Options>
3262 Status operator()(Options... options)
const {
3263 return client.DeleteObject(bucket_name, object_name,
Generation(generation),
3264 std::move(options)...);
3268 std::string bucket_name;
3269 std::string object_name;
3270 std::int64_t generation;
3274 struct InsertObjectApplyHelper {
3275 template <
typename... Options>
3277 return client.InsertObject(bucket_name, object_name, std::move(contents),
3278 std::move(options)...);
3282 std::string
const& bucket_name;
3283 std::string
const& object_name;
3284 std::string contents;
3300 template <
typename... Options>
3302 std::string
const& bucket_name,
3303 std::string
const& prefix,
3304 Options&&... options) {
3306 internal::InsertObjectApplyHelper{client, bucket_name, prefix,
""},
3309 internal::StaticTupleFilter<
3312 std::forward_as_tuple(std::forward<Options>(options)...))));
3327 template <
typename... Options>
3329 std::string
const& prefix, Options&&... options) {
3330 using internal::NotAmong;
3331 using internal::StaticTupleFilter;
3333 auto all_options = std::tie(options...);
3337 decltype(StaticTupleFilter<
3339 all_options))>::value == 0,
3340 "This functions accepts only options of type QuotaUser, UserIp, "
3341 "UserProject or Versions.");
3345 std::forward<Options>(options)...)) {
3346 if (!object)
return std::move(object).status();
3348 internal::DeleteApplyHelper{client, object->bucket(), object->name(),
3349 object->generation()},
3350 StaticTupleFilter<NotAmong<
Versions>::TPred>(all_options));
3353 status = std::move(del);
3358 namespace internal {
3361 struct ComposeApplyHelper {
3362 template <
typename... Options>
3364 return client.ComposeObject(
3365 std::move(bucket_name), std::move(source_objects),
3366 std::move(destination_object_name), std::move(options)...);
3370 std::string bucket_name;
3372 std::string destination_object_name;
3376 class ScopedDeleter {
3380 explicit ScopedDeleter(std::function<
Status(std::string, std::int64_t)> df);
3381 ScopedDeleter(ScopedDeleter
const&) =
delete;
3382 ScopedDeleter& operator=(ScopedDeleter
const&) =
delete;
3389 void Add(std::string object_name, std::int64_t generation);
3394 void Enable(
bool enable) { enabled_ = enable; }
3397 bool enabled_ =
true;
3398 std::function<
Status(std::string, std::int64_t)> delete_fun_;
3399 std::vector<std::pair<std::string, std::int64_t>> object_list_;
3447 template <
typename... Options>
3449 Client& client, std::string
const& bucket_name,
3451 std::string destination_object_name,
bool ignore_cleanup_failures,
3452 Options&&... options) {
3453 using internal::Among;
3454 using internal::NotAmong;
3455 using internal::StaticTupleFilter;
3456 std::size_t
const max_num_objects = 32;
3458 if (source_objects.empty()) {
3460 "ComposeMany requires at least one source object.");
3463 auto all_options = std::make_tuple(options...);
3468 decltype(StaticTupleFilter<
3474 "This functions accepts only options of type DestinationPredefinedAcl, "
3475 "EncryptionKey, IfGenerationMatch, IfMetagenerationMatch, KmsKeyName, "
3476 "QuotaUser, UserIp, UserProject or WithObjectMetadata.");
3478 internal::ScopedDeleter deleter(
3479 [&](std::string
const& object_name, std::int64_t generation) {
3481 internal::DeleteApplyHelper{client, bucket_name, object_name,
3487 auto lock = internal::LockPrefix(client, bucket_name, prefix,
"",
3488 std::make_tuple(options...));
3491 lock.status().code(),
3492 "Failed to lock prefix for ComposeMany: " + lock.status().message());
3496 std::size_t num_tmp_objects = 0;
3497 auto tmpobject_name_gen = [&num_tmp_objects, &prefix] {
3498 return prefix +
".compose-tmp-" + std::to_string(num_tmp_objects++);
3501 auto to_source_objects = [](std::vector<
ObjectMetadata> objects) {
3503 std::transform(objects.begin(), objects.end(), sources.begin(),
3514 internal::ComposeApplyHelper{client, bucket_name,
3515 std::move(compose_range),
3516 std::move(destination_object_name)},
3520 internal::ComposeApplyHelper{client, bucket_name,
3521 std::move(compose_range),
3522 tmpobject_name_gen()},
3531 for (
auto range_begin = source_objects.begin();
3532 range_begin != source_objects.end();) {
3533 std::size_t range_size = std::min<std::size_t>(
3534 std::distance(range_begin, source_objects.end()), max_num_objects);
3535 auto range_end = std::next(range_begin, range_size);
3537 std::move(range_begin, range_end, compose_range.begin());
3539 bool const is_final_composition =
3540 source_objects.size() <= max_num_objects;
3541 auto object = composer(std::move(compose_range), is_final_composition);
3543 return std::move(object).status();
3545 objects.push_back(*std::move(object));
3546 if (!is_final_composition) {
3547 deleter.Add(objects.back());
3549 range_begin = range_end;
3556 StatusOr<std::vector<
ObjectMetadata>> objects = reduce(source_objects);
3560 if (objects
->size() == 1) {
3561 if (!ignore_cleanup_failures) {
3562 auto delete_status = deleter.ExecuteDelete();
3563 if (!delete_status
.ok()) {
3564 return delete_status;
3567 result = std::move((
*objects)[0]);
3570 source_objects = to_source_objects(
*std::move(objects));
3571 }
while (source_objects.size() > 1);