文件管理

int PutObjectDemo(Client& client,const std::string& bucketName, const std::string objectKey){
    // 获取文件数据流
    FileInputStream inputStream("/path/to/test.zip"); // bcesdk/util/util.h
	int ret = 0;
    // 以文件名作为参数上传Object
    ret = client.upload_file(bucketName, objectKey, "/path/to/test.zip");
    // 以数据流形式上传Object
    ret = client.upload_file(bucketName, objectKey, inputStream);
    // 以文件描述符形式上传Object    
    fd_t fd = open("/path/to/test.zip", O_RDWR, 0666);//linux下，fd_t在common.h中定义
    ret = client.upload_file(bucketName, objectKey, fd);
    // 以字符串形式上传Object
    std::string data = "this is data";
	ret = client.put_object(bucketName, objectKey, data);
    return ret;
}

int PutLargeObjectDemo(Client& client,const std::string& bucketName, const std::string objectKey){
    std::string fileName = "/path/to/test.zip"
    return client.upload_super_file(bucketName, objectKey, fileName);//第三个参数用fd_t形式也可行
}

...
// 初始化meta
ObjectMetaData meta;

// 设置ContentType
meta.set_content_type("application/json");

// 设置cache-control
meta.set_cache_control("no-cache");

// 设置x-bce-storage-class
meta.set_storage_class("STANDARD");

ret = client.upload_file(bucketName, objectKey, content, meta);
...

// 设置自定义元数据name的值为my-data
meta.set_user_meta("name", "my-data");
    
// 上传Object
ret = client.upload_file(bucketName, objectKey, file_name, meta);

// 初始化BosClient
Client client = ...;

// 创建CopyObjectRequest对象
CopyObjectRequest copyObjectRequest(destBucketName, destKey, srcBucketName, srcKey);
CopyObjectResponse copyObjectResponse；

// 设置新的Metadata
StringMap& userMetadata = *(meta.mutable_user_meta());//StringMap == map<string, string>
userMetadata.clear();
userMetadata["<user-meta-key>"] = "<user-meta-value>";

copyObjectRequest.set_meta(&meta, false);//第二个参数(is_own)若为true则由copyObjectRequest析构时delete meta
//copy-source-if-match
copyObjectRequest.set_if_match("111111111183bf192b57a4afc76fa632");
//copy-source-if-none-match
copyObjectRequest.set_if_none_match("111111111183bf192b57a4afc76fa632");
        
std::string gmtDate = TimeUtil::now_gmttime();//当前GMT格式时间 

//copy-source-if-modified-since
copyObjectRequest.set_if_modified_since(gmtDate);

//copy-source-if-unmodified-since
copyObjectRequest.set_if_unmodified_since(gmtDate);

// 复制Object
client.copy_object(copyObjectRequest， copyObjectResponse；);

std::cout << "ETag: " << copyObjectResponse.etag() << " LastModified: " <<      copyObjectResponse.last_modified() << std::endl;

void print_common_response(BceResponse &result) {
    printf("status:%d\n", result.status_code());
    if (result.is_ok()) {
        printf("request-id:%s\n", result.request_id().c_str());
        printf("debug-id:%s\n", result.debug_id().c_str());
    }
    if (result.is_fail()) {
        printf("error-message:%s\n", result.error().message().c_str());
    }
}
int putObjectStorageClass(){
    std::string filename = "file.txt";  
    FileInputStream file(filename); 
    PutObjectRequest request(bucket, object, &file); 
    request.mutable_meta()->set_storage_class("STANDARD_IA");
    PutObjectResponse result;
    client.put_object(request, &result);
    print_common_response(result);  
    printf("etag: %s\n", result.etag().c_str());
}

// 上传进度回调函数
// 注意该回调函数中不得出现耗时较长/阻塞操作, 会影响数据上传性能. 
// increment: 当次上传的数据量
// transfered: 已上传数据量
// total: 需上传的数据总量
// userData: 用户自定义数据, 例如object bucket+key等.
void progress_callback(int64_t increment, int64_t transfered, int64_t total, void* user_data) {
    std::cout << "progress_callback[" << user_data << "] => " <<
    increment <<" ," << transfered << "," << total << std::endl;
}

//待上传文件
std::string filename = "/tmp/put_file_test";  
FileInputStream file(filename); 

PutObjectRequest req(BUCKET, "transfer_progress_t1", &file);
PutObjectResponse rsp;
   
// 设置上传进度相关数据
// TransferProgress结构在头文件: "bcesdk/common/common.h"
TransferProgress progress;
progress.transfer_progress_cb = progress_callback;
req.set_progress(progress);

//将filename文件中数据上传
int ret = client()->put_object(req, &rsp);
if (ret) {
    LOGF(WARN, "client err: %d", ret);
}
if (rsp.is_fail()) {
    LOGF(WARN,
        "put_object: [status_code = %d], [message = %s], [requestid = %s]",
         rsp.status_code(),
         rsp.error().message().c_str(),
         rsp.error().request_id().c_str());
}
 

int AppendObjectDemo(Client& client,const std::string& bucketName, const std::string& objectKey) {

    // 获取数据流
    FileInputStream inputStream("/path/to/test.zip");

    // 以数据流形式上传Object
    AppendObjectRequest appendObjectFromInputStreamRequest(bucketName, objectKey, &inputStream);
    AppendObjectResponse appendObjectFromInputStreamResponse;
    int ret = client.append_object(appendObjectFromInputStreamRequest, &appendObjectFromInputStreamResponse);
   
    // 以字符串上传Object
    std::string data = "this is data";
    AppendObjectRequest appendObjecFromStringtRequest(bucketName, objectKey, data);
    AppendObjectResponse appendObjectFromStringResponse; 
    
    ret = client.appendObject(appendObjecFromStringtRequest, &appendObjectFromStringResponse);

    // 打印ETag
    std::cout << appendObjectFromInputStreamResponse.etag() << std::endl;
    // 打印NextAppendOffset
    std::cout << appendObjectFromInputStreamResponse.next_append_offset() << std::endl;


    // 追加上传的示例，需要在请求中加上下次追加写的位置
    long long nextAppendOffset = appendObjectFromInputStreamResponse.next_append_offset();
    AppendObjectRequest appendObjectFromStringRequest(bucketName,objectKey,data);
    appendObjectFromStringRequest.set_offset(nextAppendOffset);
    AppendObjectResponse appendObjectFromStringResponse;
    ret = client.append_object(appendObjectFromStringRequest, &appendObjectFromStringResponse);
    return ret;
}

// 开始Multipart Upload
InitMultiUploadRequest initMultiUploadRequest(bucketName, objectKey);
InitMultiUploadResponse initMultiUploadResponse;
int ret = client.init_multipart_upload(initMultiUploadRequest, &initMultiUploadResponse);
//异常处理
...    
// 打印UploadId
std::cout << "UploadId: " << initMultiUploadResponse.upload_id() << std::endl;

void putMultiUploadStorageClass(){
    ObjectMetaData meta;
    meta.set_storage_class("STANDARD_IA");
    InitMultiUploadRequest initMultiUploadRequest(bucketName, objectKey);
    InitMultiUploadResponse initMultiUploadResponse;
    initMultiUploadRequest.set_meta(&meta);
    client.init_multipart_upload(initMultiUploadRequest, &initMultiUploadResponse);
}

void putMultiUploadStorageClass(){
    ObjectMetaData meta;
    meta.set_storage_class("COLD)");
    InitMultiUploadRequest initMultiUploadRequest(bucketName, objectKey);
    InitMultiUploadResponse initMultiUploadResponse;
    initMultiUploadRequest.set_meta(&meta);
    client.init_multipart_upload(initMultiUploadRequest, &initMultiUploadResponse);
}

// 设置每块为 5MB
// [注意] 除了最后一个分块, 其余分块需满足size>=100kb
long partSize = 1024 * 1024 * 5L;

// 注意: 当分块上传的数据为string/内存数据, UploadPartRequest的构造函数如下:    
// UploadPartRequest(const std::string &bucket_name, const std::string &object_name,  const std::string &data, int part_number, const std::string &upload_id)     
// 其中data字段为std::string, 不得传入C风格的char*串, 会导致计算数据size错误. 

//待分块上传文件
std::string partFileName = "/path/to/file.zip";
FileInputStream file(partFileName);

// 计算分块数目
int partCount = static_cast<int>(file.get_size() / partSize);
if (file.get_size() % partSize != 0){
    partCount++;
}

int64_t size = file.size(); 
int64_t off = 0;
for (int i = 0; off < file.size(); ++i) {
    if (off + partSize > size) {
        partSize = size - off;
    }
    FileInputStream partFile(file.fd(), off, partSize);
    UploadPartRequest uploadPartRequest = UploadPartRequest(bucketName, objectName, partFile, i + 1, initMultiUploadResponse.upload_id());
    UploadPartResponse uploadPartResponse;

    int ret = client.upload_part(uploadPartRequest, &uploadPartResponse);
    //校验返回值

    // 将返回的PartETag保存到List中。
    part_t partInfo;
    partInfo.part_number = i+1;
    partInfo.etag = uploadPartResponse.etag();
    partEtags.push_back(partInfo);
    
    off += partSize;
}

CompleteMultipartUploadRequest completeMultipartUploadRequest(bucketName, objectKey, initMultiUploadResponse.upload_id());

//添加part信息，即part合并顺序
for (part_t partInfo : partEtags) {
    completeMultipartUploadRequest.add_part(partInfo.part_number, partInfo.etag);
}
    
// 完成分块上传
CompleteMultipartUploadResponse completeMultipartUploadResponse;
int ret = client.complete_multipart_upload(completeMultipartUploadRequest, &completeMultipartUploadResponse);
    
// 打印Object的ETag
std::cout << completeMultipartUploadResponse.etag() << std::endl;

AbortMultipartUploadRequest abortMultipartUploadRequest(bucketName, objectKey, uploadId);
AbortMultipartUploadResponse abortMultipartUploadResponse;
// 取消分块上传
int ret = client.abort_multipart_upload(abortMultipartUploadRequest, &abortMultipartUploadResponse);

ListMultipartUploadsRequest listMultipartUploadsRequest(bucketName);
ListMultipartUploadsResponse listMultipartUploadsResponse;
// 获取Bucket内所有上传事件
int ret = client.list_multipart_uploads(listMultipartUploadsRequest, &
listMultipartUploadsResponse);

if (ret != 0) {
    return ret;
}    

// 遍历所有上传事件
for (const MultipartUploadSummary& multipartUpload : listMultipartUploadsResponse.uploads()) {
    std::cout << "Key: " << multipartUpload.key << 
        " UploadId: " << multipartUpload.upload_id << std::endl;
}

ListPartsRequest listPartsRequest(bucketName, objectKey, uploadId);
    
// 获取上传的所有Part信息
ListPartsResponse listPartsResponse;
int ret = client.list_parts(listPartsRequest, &listPartsResponse);

if (ret != 0) {
    return ret;
}    

// 遍历所有Part
for (consr PartSummary& part : listPartsResponse.parts()) {
    std::cout << "PartNumber: " << part.part_number << " ETag: " << part.etag;
}

public void listPartsStorageClass(){
    ListPartsRequest listPartsRequest(bucketName, objectKey, uploadId);
    
    // 获取上传的所有Part信息
    ListPartsResponse listPartsResponse;
    int ret = client.list_parts(listPartsRequest, &listPartsResponse);

    if (ret != 0) {
        return ret;
    }    
    std::string storageClass = listPartsResponse.storage_class();
}

void getObject(Client& client, const std::string& bucketName, const std::string& objectKey) {
    
    //获取文件输出流
    FileOutputStream outStream("test.txt");

    //方法一，通过request、response
    //初始化request
    GetObjectRequest getObjectRequest(bucketName, objectKey);
    //将outStream作为输出对象
    GetObjectResponse getObjectResponse(&outStream);
    int ret = client.get_object(getObjectRequest, &getObjectResponse);

    //方法二，通过便利接口,将Object写到outStream文件流中
    ret = client.download_file(bucketName, objectKey, outStream);
    ...
}

// 下载Object到文件
std::string localFileName = "test.txt";
ObjectMetaData ObjectMetaData;

//设置Object读取范围
int64_t start = 0;
int64_t length = 100;
//下载Object
int ret = client.download_file(bucketName, objectKey, localFileName, start, length, &ObjectMetaData); //存到test.txt中,ObjectMetaData
...

// 上传进度回调函数
// 注意该回调函数中不得出现耗时较长/阻塞操作, 会影响数据下载性能. 
// increment: 当次下载的数据量
// transfered: 已下载数据量
// total: 需下载的数据总量
// userData: 用户自定义数据, 例如object bucket+key等.
void progress_callback(int64_t increment, int64_t transfered, int64_t total, void* user_data) {
    std::cout << "progress_callback[" << user_data << "] => " <<
    increment <<" ," << transfered << "," << total << std::endl;
}

// 本地待接收数据文件
std::string filename = "/tmp/get_file_test";  
FileOutputStream outStream(filename); 

GetObjectRequest req(BUCKET, "transfer_progress_2");
GetObjectResponse rsp(&outStream);

// 设置下载进度条相关数据
TransferProgress progress;
progress.transfer_progress_cb = progress_callback;
rsp.set_progress(progress);

// 下载数据到本地filename文件中
int ret =  client()->get_object(req, &rsp);
if (ret) {
    LOGF(WARN, "client err: %d", ret);
}
if (rsp.is_fail()) {
    LOGF(WARN,
        "get_object: [status_code = %d], [message = %s], [requestid = %s]",
         rsp.status_code(),
         rsp.error().message().c_str(),
         rsp.error().request_id().c_str());
}

std::string inMemoryData;
//方法一，通过request、response
GetObjectRequest getObjectRequest(bucketName, objectKey);
//将inMemoryData作为输出对象
GetObjectResponse getObjectResponse(&inMemoryData);
int ret = client.get_object(getObjectRequest, &getObjectResponse);

if (ret != 0) {
    return ret;
}

//方法二，通过便利接口
ret = client.get_object(bucketName, objectKey, &inMemoryData);
//打印出来
std::cout << inMemoryData << std::endl;

GetObjectRequest getObjectRequest(bucketName, objectKey);
//初始化文件输出流
FileOutputStream outStream("test.txt");
GetObjectResponse getObjectResponse(&outStream);
//设置下载范围[0，100]字节数据
getObjectRequest.set_range(0, 100);
int ret = client.get_object(getObjectRequest, &getObjectResponse);

if (ret != 0) {
    return ret;
}
return 0;

int getObjectStorageClass(){
    HeadObjectRequest request(bucketName, objectKey);
    HeadObjectResponse response;
    int ret = client.head_object(request, &response);
    if (ret != 0) {
        return ret;
    }
    ObjectMetaData& meta = response.meta();
    std::string storageClass = meta.storage_class();
    std::cout << storageClass << std::endl;
    return 0;
}

// 标准存储转为低频存储
CopyObjectRequest copyObjectRequest(destBucketName, destKey, srcBucketName, srcKey);
copyObjectRequest.mutable_meta()->set_storage_class("STANDARD_IA");
CopyObjectResponse copyObjectResponse;
int ret = client.copy_object(copyObjectRequest, &copyObjectResponse);

// 低频存储转为冷存储
CopyObjectRequest copyObjectRequest(destBucketName, destKey, srcBucketName, srcKey);
copyObjectRequest.mutable_meta()->set_storage_class("COLD");
CopyObjectResponse copyObjectResponse;
ret = client.copy_object(copyObjectRequest, &copyObjectResponse);

std::string generatePresignedUrl(Client& client, const std::string& bucketName, const std::string& objectKey, int expirationInSeconds) {

   //指定用户需要获取的Object所在的Bucket名称、该Object名称、URL的有效时长   
   return  client.generate_url(bucketName, objectKey, expirationInSeconds);
}

void listObjects(Client& client, const std::string bucketName) {
    ListObjectsRequest listObjectsRequest(bucketName);
    // 获取指定Bucket下的所有Object信息
    ListObjectsResponse listObjectsResponse;
    int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);

    if (ret != 0) return;
    if (listObjectResponse.is_fail()) {
        return;
    }
    // 遍历所有Object
    for (const ObjectSummary& objectSummary : listObjectsResponse.contents()) {
        std::cout << "ObjectKey: " << objectSummary.key << std::endl;
    }
}

// 指定最大返回条数为500
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_max_keys(500);
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;
...//response异常处理
for(const ObjectSummary& objectSummary :listObjectsResponse.contents()) {
    std::cout << "ObjectKey: " << objectSummary.key << std::endl;
}

// 指定返回前缀为test的object
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_prefix("test");
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;
...//response异常处理
for(const ObjectSummary& objectSummary :listObjectsResponse.contents()) {
    std::cout << "ObjectKey: " << objectSummary.key << std::endl;
}

// 用户可以定义不包括某object，从其之后开始返回
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_marker("object");
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;
...//response异常处理
for(const ObjectSummary& objectSummary :listObjectsResponse.contents()) {
    std::cout << "ObjectKey: " << objectSummary.key << std::endl;
}

// 用户可设置每页最多500条记录
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_max_keys(500);
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;
...//response异常处理

bool isTruncated = true;
while (isTruncated) {
    ListObjectsResponse listObjectsResponse;
    client.list_objects(listObjectsRequest, &listObjectsResponse);
    isTruncated = listObjectsResponse.is_truncated();
    if (listObjectsResponse.next_marker() != "") {
        listObjectsRequest.set_marker(listObjectsResponse.next_marker());
    }
}

// 用户可设置每页最多500条记录，并从某特定object之后开始获取
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_max_keys(500);
listObjectsRequest.set_marker("object");
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;

bool isTruncated = true;
while (isTruncated) {
    ListObjectsResponse listObjectsResponse;
    client.list_objects(listObjectsRequest, &listObjectsResponse);
    isTruncated = listObjectsResponse.is_truncated();
    if (listObjectsResponse.next_marker() != "") {
        listObjectsRequest.set_marker(listObjectsResponse.next_marker());
    }
}

// 用户可设置分页获取指定前缀的Object，每页最多500条记录
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_max_keys(500);
listObjectsRequest.set_prefix("object");
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;

bool isTruncated = true;
while (isTruncated) {
    ListObjectsResponse listObjectsResponse;
    client.list_objects(listObjectsRequest, &listObjectsResponse);
    isTruncated = listObjectsResponse.is_truncated();
    if (listObjectsResponse.next_marker() != "") {
        listObjectsRequest.set_marker(listObjectsResponse.next_marker());
    }
}

// 构造ListObjectsRequest请求
ListObjectsRequest listObjectsRequest("bucketName");
// 递归列出fun目录下的所有文件
listObjectsRequest.set_prefix("fun/");
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;
...//response异常处理
std::cout << "ObjectKeys:" << std::endl;
// 遍历所有Object
for(const ObjectSummary& objectSummary :listObjectsResponse.contents()) {
    std::cout << objectSummary.key << std::endl;
}

ObjectKeys:
fun/
fun/movie/001.avi
fun/movie/007.avi
fun/test.jpg

// 构造ListObjectsRequest请求
ListObjectsRequest listObjectsRequest("bucketName");

// "/" 为文件夹的分隔符
listObjectsRequest.set_delimiter("/");

// 列出fun目录下的所有文件和文件夹
listObjectsRequest.set_prefix("fun/");

ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;   
// 遍历所有Object
std::cout << "\nObjectKeys:" << std::endl;
for(const ObjectSummary& objectSummary :listObjectsResponse.contents()) {
    std::cout << objectSummary.key << std::endl;
}
    
// 遍历所有CommonPrefix
std::cout << "CommonPrefixs:" << std::endl;
for (const std::string& commonPrefix : listObjectsResponse.common_prefixes()) {
    std::cout << commonPrefix << std::endl;
}

ObjectKeys:
fun/
fun/test.jpg

CommonPrefixs:
fun/movie/

public void listObjectsStorageClass(){
    ListObjectsRequest listObjectsRequest("bucketName");
    ListObjectsResponse listObjectsResponse;
    int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
    std::vector<ObjectSummary> objectList = listObjectResponse.contents();
    for(int i = 0; i<objectList.size(); i++) {
        std::cout << objectList[i].storage_class() << std::endl;
    }
}

struct BceRequestContext {
    BceRequest *request;
    BceResponse *response;
    bool is_own;
};
int send_request(int n, BceRequestContext ctx[], int max_parallel = 0);

PutObjectAclRequest putObjectAclRequest(bucketName, objectKey);
PutObjectAclResponse putObjectAclResponse;

// 1. 使用x-bce-acl Header设置
// cannedAcl支持:private、public-read
std::string cannedAcl="public-read";
putObjectAclRequest.set_canned_acl(cannedAcl);

// 2. 使用x-bce-grant-read / x-bce-grant-read-permission Header设置
// idStrings为id集合, 可一次传入多个id, 用逗号隔开, 字符串固定格式为:"id=/"xxxxx/", id=/"xxxxx/"";
std::string idStrings="id=\"77f47fbbc29d41xxxxxxxxxx6\"";
putObjectAclRequest.set_xbce_grant_read(idStrings);
putObjectAclRequest.set_xbce_grant_full_control(idStrings);

int ret = client.put_object_acl(putObjectAclRequest, &putObjectAclResponse);
if (ret) {
    LOGF(WARN, "client err: %d", ret);
}
if (putObjectAclResponse.is_fail()) {
    LOGF(WARN,"put_object_acl: [status_code = %d], [message = %s], [requestid = %s]",
         putObjectAclResponse.status_code(),
         putObjectAclResponse.error().message().c_str(),
         putObjectAclResponse.error().request_id().c_str());
}

PutObjectAclRequest putObjectAclRequest(bucketName, objectKey);
PutObjectAclResponse putObjectAclResponse;

// 1. 通过上传acl json串
std::string jsonAcl =
                "{\"accessControlList\":[{\"grantee\":[{\"id\":\"*\"}],\"permission\":[\"READ\"]},{"
                "\"grantee\":[{\"id\":\"cb5f8xxxxxxxxxx82bbc\"}],\"permission\":["
                "\"FULL_CONTROL\"]}]}";
std::string cannedAcl="public-read";
putObjectAclRequest.set_json_acl(jsonAcl);


// 2. 上传acl文件
std::string aclFilePath = "/tmp/acl.json"
int setRet = putObjectAclRequest.set_acl_file(aclFilePath);
if (ret) {
    LOGF(WARN, "client set_acl_file: %d", ret);
}

// 3. 通过设置access_control_list数据
std::vector<Grant> grants;
Grant grant;
grantee.id = "77fxxxxxxxxxxx5fa406";
grant.grantee.push_back(grantee);
grant.permission.push_back("READ");
grants.push_back(grant);
putObjectAclRequest.set_access_control_list(grants);

int ret = client.put_object_acl(putObjectAclRequest, &putObjectAclResponse);
if (ret) {
    LOGF(WARN, "client err: %d", ret);
}
if (putObjectAclResponse.is_fail()) {
    LOGF(WARN,"put_object_acl: [status_code = %d], [message = %s], [requestid = %s]",
         putObjectAclResponse.status_code(),
         putObjectAclResponse.error().message().c_str(),
         putObjectAclResponse.error().request_id().c_str());
}

GetObjectAclRequest getObjectAclRequest(bucketName, objectKey);
GetObjectAclResponse getObjectAclResponse;

int ret = client()->get_object_acl(getObjectAclRequest, &getObjectAclResponse);
if (ret) {
    LOGF(WARN, "get_object_acl err: %d", ret);
}

if (getObjectAclResponse.is_fail()) {
    LOGF(WARN,
         "get_object_acl: [status_code = %d], [message = %s], [requestid = %s]",
         getObjectAclResponse.status_code(),
         getObjectAclResponse.error().message().c_str(),
         getObjectAclResponse.error().request_id().c_str());
}

//获取具体权限(两种方式)
std::vector<Grant> objectAcl = getObjectAclResponse.access_control_list();
std::string objectAclJsonStr = getObjectAclResponse.json_access_control_list();

//acl具体结构
struct Grantee {
    std::string id;
};
struct Grant {
    std::vector<Grantee> grantee;
    std::vector<std::string> permission;
    //std::vector<std::string> resource;
    //std::vector<std::string> notResource;
    //Condition condition;
    //std::string effect;
}

DeleteObjectAclRequest deleteObjectAclRequest(BUCKET_NAME, OBJECT_NAME);
DeleteObjectAclResponse deleteObjectAclResponse;

int ret = client.delete_object_acl(deleteObjectAclRequest, &deleteObjectAclResponse);
if (ret) {
    LOGF(WARN, "client err: %d", ret);
}
if (deleteObjectAclResponse.is_fail()) {
    LOGF(WARN, "put_object_acl: [status_code = %d], [message = %s], [requestid = %s]",
         deleteObjectAclResponse.status_code(),
         deleteObjectAclResponse.error().message().c_str(),
         deleteObjectAclResponse.error().request_id().c_str());
}

int deleteObject(Client& client,const std::string bucketName, const std::string objectKey) {

    // 删除Object
    return client.delete_object(bucketName, objectKey);           //指定要删除的Object所在Bucket名称和该Object名称
}

int deleteMultiObject(Client& client, const& std::string bucketName, const std::vector<std::string>& objects) { 
    //批量删除object
    std::vector<BceRequestContext> ctx(objects.size());
    int i = 0;
    for (const std::string& objectKey : objects) {
        //构造上下文信息
        ctx[i].request = new DeleteObjectRequest(bucketName, objectKey);
        ctx[i].response = new DeleteObjectResponse;
        ctx[i].is_own = true;//自动析构request和response
        ++i;
    }
    //并发请求
    int ret = client.send_request((int)ctx.size(), &ctx.front());
    if (ret != 0) return ret;
    //处理response
    for (size_t i = 0; i < ctx.size(); ++i) {
        DeleteObjectRequest* request = (DeleteObjectRequest*)ctx[i].request;
        DeleteObjectResponse* response = (DeleteObjectResponse*)ctx[i].response;
        if (response->is_fail()) {//有请求删除失败，处理这种情况
            std::cout << "delete objectKey=" << request->object_name() << " failed"
                            << " reason: " << response->error().message();
            ret = RET_SERVICE_ERROR;
        }
    }
    return ret;
}

HeadObjectRequest request(bucketName, objectKey);
HeadObjectResponse response;
int ret = client.head_object(request, &response);
if (response.status_code() == 404) {
    std::cout << "ObjectKey not exist!" << std::endl;
}    

void setObjectMeta(Client& client, const std::string& bucketName, const std::string& objectKey, ObjectMetaData* newObjectMetadata) {
        
    CopyObjectRequest request(bucketName, objectKey, bucketName, objectKey);

    // 设置新的ObjectMetaData
    request.set_meta(newObjectMetaData);

    // 拷贝Object
    CopyObjectResponse copyObjectResponse;
    int ret = client.copy_object(request, &copyObjectResponse);
    if (ret != 0) {
        return;
    }
    // 打印结果
    std::cout << "ETag: " << copyObjectResponse.etag() << " LastModified: " << copyObjectResponse.last_modified() << std::endl;
}

void copyObject(Client& client, std::string destBucketName, std::string destKey, const std::string& srcBucketName, const std::string& srcKey) {
    
    // 拷贝Object
    int ret = client.copy_object(srcBucketName, srcKey, destBucketName, destKey, "STANDARD");//目标Object为标准存储
}

// 初始化Client
Client client = ...;
    
// 创建CopyObjectRequest对象
CopyObjectRequest copyObjectRequest(destBucketName, destKey, srcBucketName, srcKey);
    
// 设置Metadata
ObjectMetaData* userMetadata = copyObjectRequest.mutable_meta();
userMetadata->set_user_meta("userMetaKey", "userMetaValue");
    
// 复制Object
CopyObjectResponse copyObjectResponse;
int ret = client.copy_object(copyObjectRequest, &copyObjectResponse);
    
std::cout << "ETag: " + copyObjectResponse.etag() <<
 " LastModified: " << copyObjectResponse.last_modified());

// 第一步 init
InitMultiUploadRequest initMultiUploadRequest("targetBucketName","targetObjectName");
InitMultiUploadResponse initMultiUploadResponse;
client.init_multipart_upload(initMultiUploadRequest, &initMultiUploadResponse);
//获取Object大小
HeadObjectRequest request("targetBucketName", "targetObjectName");
HeadObjectResponse response;
client.head_object(request, &response);
if (response.is_fail()) {
    return RET_SERVICE_ERROR;
}
long left_size = response.meta().content_length();

// 第二步 分块拷贝
long skipBytes = 0;
int partNumber = 1;
std::vector<part_t> partETags;

while (left_size > 0) {
    long partSize = 1024 * 1024 * 5L;
    if (left_size < partSize) {
        partSize = left_size;
    }
    CopyPartRequest copyPartRequest;
    copyPartRequest.set_upload_id(initMultiUploadResponse.upload_id());
    copyPartRequest.set_bucket_name("targetBucketName");
    copyPartRequest.set_object_name("targetObjectName");
    copyPartRequest.set_source_bucket_name("sourceBucketName");
    copyPartRequest.set_source_object_name("sourceObjectName");
    copyPartRequest.set_range(skipBytes, skipBytes + partSize - 1);
    copyPartRequest.set_part_number(partNumber);

    CopyPartResponse copyPartResponse; 
    client.copy_part(copyPartRequest, &copyPartResponse);
    // 将返回的partNumber和ETag保存到vector
    part_t partInfo;
    partInfo.etag = copyPartResponse.etag(); 
    partInfo.part_number = partNumber;
    partETags.push_back(partInfo);
    left_size -= partSize;
    skipBytes += partSize;
    partNumber+=1;
}

// 第三步 complete
CompleteMultipartUploadRequest completeMultipartUploadRequest("targetBucketName", "targetObjectName", initMultiUploadResponse.upload_id());

//添加part信息，即part合并顺序
for (part_t partInfo : partEtags) {
    completeMultipartUploadRequest.add_part(partInfo.part_number, partInfo.etag);
}
    
// 完成分块上传
CompleteMultipartUploadResponse completeMultipartUploadResponse;
int ret = client.complete_multipart_upload(completeMultipartUploadRequest, &completeMultipartUploadResponse);
    
// 打印Object的ETag
std::cout << completeMultipartUploadResponse.etag() << std::endl;

client.parallel_copy(srcBucketName, sourceObjectName, destBucketName, destObjectName);

std::string filename = "test_archive";
FileInputStream file(filename);
PutObjectRequest request(bucket, "test_archive", &file);
request.mutable_meta()->set_storage_class("ARCHIVE");
PutObjectResponse result;
client.put_object(request, &result);

RestoreObjectRequest request(bucket, ""test_archive"");
RestoreObjectResponse response;
client.restore_object(request, &response);
print_common_response(response);