【玩转腾讯云】cos c++ sdk v5接入项目 避坑指南

1、Poco的安装和编译,依赖本地的openssl库,这个ssl库可能跟项目用的库相冲突(1.0和1.1的openssl库冲突)。

这时候需要安装项目的openssl版本,编译poco库完成后,再产生cossdk.a,否则版本冲突。

2、编译cossdk.a时,注意设置openssl版本“SET(OPENSSL_VERSION 1.0.2f)”。同时注意这个版本必须和poco编译时使用的版本相同

3、默认openssl的库,一般在/lib64目录下,建议备份原来的,安装新的。

下面是一个cos demo


// Created: 07/18/17

// Description:

#include <iostream>

#include <map>

#include <string>

#include <vector>

#include "util/auth_tool.h"

#include "cos_api.h"

#include "cos_sys_config.h"

#include "cos_defines.h"

using namespace qcloud_cos;

void PrintResult(const qcloud_cos::CosResult& result, const qcloud_cos::BaseResp& resp) {

if (result.IsSucc()) {
    std::cout << resp.DebugString() << std::endl;
} else {
    std::cout << "ErrorInfo=" << result.GetErrorInfo() << std::endl;
    std::cout << "HttpStatus=" << result.GetHttpStatus() << std::endl;
    std::cout << "ErrorCode=" << result.GetErrorCode() << std::endl;
    std::cout << "ErrorMsg=" << result.GetErrorMsg() << std::endl;
    std::cout << "ResourceAddr=" << result.GetResourceAddr() << std::endl;
    std::cout << "XCosRequestId=" << result.GetXCosRequestId() << std::endl;
    std::cout << "XCosTraceId=" << result.GetXCosTraceId() << std::endl;
    // std::cout << "result=" << result << std::endl;
}

}

void GetService(qcloud_cos::CosAPI& cos) {

qcloud_cos::GetServiceReq req;
qcloud_cos::GetServiceResp resp;
qcloud_cos::CosResult result = cos.GetService(req, &resp);
std::cout << "===================GetService=====================" << std::endl;
PrintResult(result, resp);
const qcloud_cos::Owner& owner = resp.GetOwner();
const std::vector<qcloud_cos::Bucket>& buckets = resp.GetBuckets();
std::cout << "owner.m_id=" << owner.m_id << ", owner.display_name=" << owner.m_display_name << std::endl;
for (std::vector<qcloud_cos::Bucket>::const_iterator itr = buckets.begin(); itr != buckets.end(); ++itr) {
    const qcloud_cos::Bucket& bucket = *itr;
    std::cout << "Bucket name=" << bucket.m_name << ", location="
        << bucket.m_location << ", create_date=" << bucket.m_create_date << std::endl;
}
std::cout << "=========================================================" << std::endl;

}

void HeadBucket(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::HeadBucketReq req(bucket_name);
qcloud_cos::HeadBucketResp resp;
qcloud_cos::CosResult result = cos.HeadBucket(req, &resp);
std::cout << "===================HeadBucketResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "==========================================================" << std::endl;

}

void DeleteBucket(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::DeleteBucketReq req(bucket_name);
qcloud_cos::DeleteBucketResp resp;
qcloud_cos::CosResult result = cos.DeleteBucket(req, &resp);
std::cout << "===================DeleteBucketResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "=========================================================" << std::endl;

}

void PutBucket(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::PutBucketReq req(bucket_name);
qcloud_cos::PutBucketResp resp;
qcloud_cos::CosResult result = cos.PutBucket(req, &resp);
std::cout << "===================PutBucketResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "=========================================================" << std::endl;

}

void GetBucket(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::GetBucketReq req(bucket_name);
qcloud_cos::GetBucketResp resp;
qcloud_cos::CosResult result = cos.GetBucket(req, &resp);
std::cout << "===================GetBucketResponse=====================" << std::endl;
PrintResult(result, resp);
std::vector<qcloud_cos::Content> cotents = resp.GetContents();
for (std::vector<qcloud_cos::Content>::const_iterator itr = cotents.begin(); itr != cotents.end(); ++itr)
{
    const qcloud_cos::Content &content = *itr;
    std::cout << "key name=" << content.m_key << ", lastmodified ="
              << content.m_last_modified << ", size=" << content.m_size << std::endl;
}
std::cout << "=========================================================" << std::endl;

}

void PutBucketVersioning(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::PutBucketVersioningReq req(bucket_name);
req.SetStatus(true);
qcloud_cos::PutBucketVersioningResp resp;
qcloud_cos::CosResult result = cos.PutBucketVersioning(req, &resp);
std::cout << "===================PutBucketVersioningResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void GetBucketVersioning(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::GetBucketVersioningReq req(bucket_name);
qcloud_cos::GetBucketVersioningResp resp;
qcloud_cos::CosResult result = cos.GetBucketVersioning(req, &resp);
std::cout << "Bucket status= " << resp.GetStatus() << std::endl;
std::cout << "===================GetBucketVersioningResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void PutBucketReplication(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::PutBucketReplicationReq req(bucket_name);
req.SetRole("qcs::cam::uin/2779643970:uin/2779643970");
qcloud_cos::ReplicationRule rule("",
                                 "qcs:id/0:cos:cn-south:appid/1251668577:sevenyoutest1251668577",
                                 "", "", true);
req.AddReplicationRule(rule);
qcloud_cos::PutBucketReplicationResp resp;
qcloud_cos::CosResult result = cos.PutBucketReplication(req, &resp);
std::cout << "===================PutBucketReplicationResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void GetBucketReplication(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::GetBucketReplicationReq req(bucket_name);
qcloud_cos::GetBucketReplicationResp resp;
qcloud_cos::CosResult result = cos.GetBucketReplication(req, &resp);
std::cout << "===================GetBucketReplicationResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void DeleteBucketReplication(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::DeleteBucketReplicationReq req(bucket_name);
qcloud_cos::DeleteBucketReplicationResp resp;
qcloud_cos::CosResult result = cos.DeleteBucketReplication(req, &resp);
std::cout << "===================DeleteBucketReplicationResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void PutBucketLifecycle(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::PutBucketLifecycleReq req(bucket_name);
{
    qcloud_cos::LifecycleRule rule;
    rule.SetIsEnable(true);
    rule.SetId("lifecycle_rule00");
    qcloud_cos::LifecycleFilter filter;
    filter.SetPrefix("sevenyou_e1");
    rule.SetFilter(filter);
    qcloud_cos::LifecycleTransition transition;
    transition.SetDays(30);
    transition.SetStorageClass("Standard_IA");
    rule.AddTransition(transition);
    req.AddRule(rule);
}
{
    qcloud_cos::LifecycleRule rule;
    rule.SetIsEnable(true);
    rule.SetId("lifecycle_rule01");
    qcloud_cos::LifecycleFilter filter;
    filter.SetPrefix("sevenyou_e1");
    rule.SetFilter(filter);
    qcloud_cos::LifecycleTransition transition;
    transition.SetDays(1);
    transition.SetStorageClass("Standard");
    rule.AddTransition(transition);
    qcloud_cos::LifecycleTransition transition2;
    transition2.SetDays(2);
    transition2.SetStorageClass("Standard_IA");
    rule.AddTransition(transition2);
    req.AddRule(rule);
}
qcloud_cos::PutBucketLifecycleResp resp;
qcloud_cos::CosResult result = cos.PutBucketLifecycle(req, &resp);
std::cout << "===================PutBucketLifecycleResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void GetBucketLifecycle(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::GetBucketLifecycleReq req(bucket_name);
qcloud_cos::GetBucketLifecycleResp resp;
qcloud_cos::CosResult result = cos.GetBucketLifecycle(req, &resp);
const std::vector<qcloud_cos::LifecycleRule>& rules = resp.GetRules();
for (int idx = 0; idx != rules.size(); ++idx) {
    std::cout << "id = " << rules[idx].GetId() << std::endl;
}
std::cout << "===================GetBucketLifecycleResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void DeleteBucketLifecycle(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::DeleteBucketLifecycleReq req(bucket_name);
qcloud_cos::DeleteBucketLifecycleResp resp;
qcloud_cos::CosResult result = cos.DeleteBucketLifecycle(req, &resp);
std::cout << "===================DeleteBucketLifecycleResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void PutBucketACL(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

// 1. 设置ACL配置(通过Body, 设置ACL可以通过Body、Header两种方式,但只能二选一,否则会有冲突)
{
    qcloud_cos::PutBucketACLReq req(bucket_name);
    qcloud_cos::Owner owner = {"qcs::cam::uin/491107627:uin/491107627", "qcs::cam::uin/491107627:uin/491107627" };
    qcloud_cos::Grant grant;
    req.SetOwner(owner);
    grant.m_grantee.m_type = "Group";
    grant.m_grantee.m_uri = "http://cam.qcloud.com/groups/global/AllUsers";
    grant.m_perm = "READ";
    req.AddAccessControlList(grant);
    qcloud_cos::PutBucketACLResp resp;
    qcloud_cos::CosResult result = cos.PutBucketACL(req, &resp);
    std::cout << "===================PutBucketACLResponse=====================" << std::endl;
    PrintResult(result, resp);
    std::cout << "====================================================================" << std::endl;
}

#if 0

// 2. 设置ACL配置(通过Header, 设置ACL可以通过Body、Header两种方式,但只能二选一,否则会有冲突)
{
    qcloud_cos::PutBucketACLReq req(bucket_name);
    req.SetXCosAcl("public-read-write");
    qcloud_cos::PutBucketACLResp resp;
    qcloud_cos::CosResult result = cos.PutBucketACL(req, &resp);
    std::cout << "===================PutBucketACLResponse=====================" << std::endl;
    PrintResult(result, resp);
    std::cout << "====================================================================" << std::endl;
}

#endif

}

void GetBucketACL(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::GetBucketACLReq req(bucket_name);
qcloud_cos::GetBucketACLResp resp;
qcloud_cos::CosResult result = cos.GetBucketACL(req, &resp);
std::vector<qcloud_cos::Grant> grants = resp.GetAccessControlList();
for (size_t idx = 0; idx < grants.size(); ++idx) {
    std::cout << "Type is " << grants[idx].m_grantee.m_type << std::endl;
}
std::cout << "===================GetBucketACLResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void PutBucketCORS(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::PutBucketCORSReq req(bucket_name);
qcloud_cos::CORSRule rule;
rule.m_id = "123";
rule.m_allowed_headers.push_back("x-cos-meta-test");
rule.m_allowed_origins.push_back("http://www.qq.com");
rule.m_allowed_origins.push_back("http://www.qcloud.com");
rule.m_allowed_methods.push_back("PUT");
rule.m_allowed_methods.push_back("GET");
rule.m_max_age_secs = "600";
rule.m_expose_headers.push_back("x-cos-expose");
req.AddRule(rule);
qcloud_cos::PutBucketCORSResp resp;
qcloud_cos::CosResult result = cos.PutBucketCORS(req, &resp);
std::cout << "===================PutBucketCORSResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void GetBucketCORS(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::GetBucketCORSReq req(bucket_name);
qcloud_cos::GetBucketCORSResp resp;
qcloud_cos::CosResult result = cos.GetBucketCORS(req, &resp);
std::cout << "===================GetBucketCORSResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void DeleteBucketCORS(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::DeleteBucketCORSReq req(bucket_name);
qcloud_cos::DeleteBucketCORSResp resp;
qcloud_cos::CosResult result = cos.DeleteBucketCORS(req, &resp);
std::cout << "===================DeleteBucketCORSResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void PutObjectByFile(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

                 const std::string& object_name, const std::string& file_path) {
qcloud_cos::PutObjectByFileReq req(bucket_name, object_name, file_path);
//req.AddParam("versionId", "MTg0NDY3NDI1NjQ4NjUyMjQ1MTA");
qcloud_cos::PutObjectByFileResp resp;
qcloud_cos::CosResult result = cos.PutObject(req, &resp);
std::cout << "===================PutObjectResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "=========================================================" << std::endl;

}

void PutObjectByStream(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

std::istringstream iss("put object");
qcloud_cos::PutObjectByStreamReq req(bucket_name, "sevenyou_10m", iss);
qcloud_cos::PutObjectByStreamResp resp;
qcloud_cos::CosResult result = cos.PutObject(req, &resp);
std::cout << "===================PutObjectResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "=========================================================" << std::endl;

}

void HeadObject(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

            const std::string& object_name) {
qcloud_cos::HeadObjectReq req(bucket_name, object_name);
//req.AddParam("versionId", "MTg0NDY3NDI1NjQ4NjUyMjQ1MTA");
qcloud_cos::HeadObjectResp resp;
qcloud_cos::CosResult result = cos.HeadObject(req, &resp);
std::cout << "===================HeadObjectResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "==========================================================" << std::endl;

}

void GetObjectByFile(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

                 const std::string& object_name, const std::string& file_path) {
qcloud_cos::GetObjectByFileReq req(bucket_name, object_name, file_path);
//req.AddParam("versionId", "MTg0NDY3NDI1NjQwODU3NzU2MTA");
qcloud_cos::GetObjectByFileResp resp;
qcloud_cos::CosResult result = cos.GetObject(req, &resp);
std::cout << "===================GetObjectResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "=========================================================" << std::endl;

}

void GetObjectByStream(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

                   const std::string& object_name) {
std::ostringstream os;
qcloud_cos::GetObjectByStreamReq req(bucket_name,
                                     object_name, os);
qcloud_cos::GetObjectByStreamResp resp;
qcloud_cos::CosResult result = cos.GetObject(req, &resp);
std::cout << "===================GetObjectResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "=========================================================" << std::endl;
std::cout << os.str() << std::endl;

}

// 将 Object 下载到本地文件中(多线程)

void MultiGetObject(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

                const std::string& object_name, const std::string& file_path) {
qcloud_cos::MultiGetObjectReq req(bucket_name,
                                  object_name, file_path);
qcloud_cos::MultiGetObjectResp resp;
qcloud_cos::CosResult result = cos.GetObject(req, &resp);
std::cout << "===================GetObjectResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "=========================================================" << std::endl;

}

void InitMultiUpload(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

                 const std::string& object_name, std::string* upload_id) {
qcloud_cos::InitMultiUploadReq req(bucket_name, object_name);
qcloud_cos::InitMultiUploadResp resp;
qcloud_cos::CosResult result = cos.InitMultiUpload(req, &resp);
std::cout << "=====================InitMultiUpload=====================";
PrintResult(result, resp);
std::cout << "=========================================================";
*upload_id = resp.GetUploadId();

}

void UploadPartData(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

                const std::string& object_name, const std::string& upload_id,
                std::fstream& is, uint64_t number,
                std::string* etag) {
qcloud_cos::UploadPartDataReq req(bucket_name, object_name,
                                  upload_id, is);
req.SetPartNumber(number);
qcloud_cos::UploadPartDataResp resp;
qcloud_cos::CosResult result = cos.UploadPartData(req, &resp);
*etag = resp.GetEtag();
std::cout << "======================UploadPartData=====================";
PrintResult(result, resp);
std::cout << "=========================================================";

}

void AbortMultiUpload(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

                  const std::string& object_name, const std::string& upload_id) {
qcloud_cos::AbortMultiUploadReq req(bucket_name, object_name,
                                    upload_id);
qcloud_cos::AbortMultiUploadResp resp;
qcloud_cos::CosResult result = cos.AbortMultiUpload(req, &resp);
std::cout << "======================AbortUploadPart=====================";
PrintResult(result, resp);
std::cout << "=========================================================";

}

void CompleteMultiUpload(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

                     const std::string& object_name, const std::string& upload_id,
                     const std::vector<std::string>& etags,
                     const std::vector<uint64_t>& numbers) {
qcloud_cos::CompleteMultiUploadReq req(bucket_name, object_name, upload_id);
qcloud_cos::CompleteMultiUploadResp resp;
req.AddParam("versionId", "MTg0NDY3NDI1NjQ4NjUyMjQ1MTA");
req.SetEtags(etags);
req.SetPartNumbers(numbers);
qcloud_cos::CosResult result = cos.CompleteMultiUpload(req, &resp);
std::cout << "===================Complete=============================" << std::endl;
PrintResult(result, resp);
std::cout << "========================================================" << std::endl;

}

void MultiUploadObject(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

                   const std::string& object_name, const std::string& local_file) {
qcloud_cos::MultiUploadObjectReq req(bucket_name,
                                     object_name, local_file);
// Complete 接口内部 chunk 保活,建议设置较长时间的 timeout。
req.SetRecvTimeoutInms(1000 * 60);
qcloud_cos::MultiUploadObjectResp resp;
qcloud_cos::CosResult result = cos.MultiUploadObject(req, &resp);
if (result.IsSucc()) {
    std::cout << "MultiUpload Succ." << std::endl;
    std::cout << resp.GetLocation() << std::endl;
    std::cout << resp.GetKey() << std::endl;
    std::cout << resp.GetBucket() << std::endl;
    std::cout << resp.GetEtag() << std::endl;
    /*
    注意GetLocation不带http://
    private-deploy-package-1256237915.cos.ap-beijing.myqcloud.com/test/tmp3
    test/tmp3
    private-deploy-package-1256237915
    829eb686be4045b02c8f78167928a930-1
    */
   std::string url = "http://" + resp.GetLocation();
   std::cout << "url = " << url << std::endl;
} else {
    std::cout << "MultiUpload Fail." << std::endl;
    // 获取具体失败在哪一步
    std::string resp_tag = resp.GetRespTag();
    std::cout << "resp_tag=" << resp_tag << std::endl;
    if ("Init" == resp_tag) {
        // print result
    } else if ("Upload" == resp_tag) {
        // print result
    } else if ("Complete" == resp_tag) {
        // print result
    }
}
std::cout << "===================MultiUpload=============================" << std::endl;
PrintResult(result, resp);
std::cout << "========================================================" << std::endl;

}

void ListParts(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

           const std::string& object_name, const std::string& upload_id) {
qcloud_cos::ListPartsReq req(bucket_name, object_name, upload_id);
req.SetMaxParts(1);
req.SetPartNumberMarker("1");
qcloud_cos::ListPartsResp resp;
qcloud_cos::CosResult result = cos.ListParts(req, &resp);
std::cout << "===================ListParts=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void PutObjectACL(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

              const std::string& object_name) {
// 1 设置ACL配置(通过Body, 设置ACL可以通过Body、Header两种方式,但只能二选一,否则会有冲突)
{
    qcloud_cos::PutObjectACLReq req(bucket_name, object_name);
    qcloud_cos::Owner owner = {"qcs::cam::uin/491107627:uin/491107627", "qcs::cam::uin/491107627:uin/491107627" };
    qcloud_cos::Grant grant;
    req.SetOwner(owner);
    grant.m_grantee.m_type = "Group";
    grant.m_grantee.m_uri = "http://cam.qcloud.com/groups/global/AllUsers";
    grant.m_perm = "READ";
    req.AddAccessControlList(grant);
    qcloud_cos::PutObjectACLResp resp;
    qcloud_cos::CosResult result = cos.PutObjectACL(req, &resp);
    std::cout << "===================PutObjectACLResponse=====================" << std::endl;
    PrintResult(result, resp);
    std::cout << "====================================================================" << std::endl;
}
// 2 设置ACL配置(通过Header, 设置ACL可以通过Body、Header两种方式,但只能二选一,否则会有冲突)
{
    qcloud_cos::PutObjectACLReq req(bucket_name, object_name);
    req.SetXCosAcl("public-read-write");
    qcloud_cos::PutObjectACLResp resp;
    qcloud_cos::CosResult result = cos.PutObjectACL(req, &resp);
    std::cout << "===================PutObjectACLResponse=====================" << std::endl;
    PrintResult(result, resp);
    std::cout << "====================================================================" << std::endl;
}

}

void GetObjectACL(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

              const std::string& object_name) {
qcloud_cos::GetObjectACLReq req(bucket_name, object_name);
qcloud_cos::GetObjectACLResp resp;
qcloud_cos::CosResult result = cos.GetObjectACL(req, &resp);
std::cout << "===================GetObjectACLResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void PutObjectCopy(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

               const std::string& object_name, const std::string& source) {
qcloud_cos::PutObjectCopyReq req(bucket_name, object_name);
req.SetXCosCopySource(source);
qcloud_cos::PutObjectCopyResp resp;
qcloud_cos::CosResult result = cos.PutObjectCopy(req, &resp);
std::cout << "===================PutObjectCopyResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void DeleteObject(qcloud_cos::CosAPI& cos, const std::string& bucket_name, const std::string& object_name) {

qcloud_cos::DeleteObjectReq req(bucket_name, object_name);
qcloud_cos::DeleteObjectResp resp;
qcloud_cos::CosResult result = cos.DeleteObject(req, &resp);
std::cout << "===================DeleteObjectResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "=========================================================" << std::endl;

}

void DeleteObjects(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

               const std::vector<ObjectVersionPair>& objects) {
qcloud_cos::DeleteObjectsReq req(bucket_name, objects);
qcloud_cos::DeleteObjectsResp resp;
qcloud_cos::CosResult result = cos.DeleteObjects(req, &resp);
std::cout << "===================DeleteObjectsResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "=========================================================" << std::endl;
std::cout << "Resp body=[" << resp.DebugString() << "]" << std::endl;

}

void UploadPartCopy(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

                const std::string& object_name, const std::string& upload_id,
                const std::string& source, const std::string& range,
                uint64_t number, std::string* etag) {
qcloud_cos::UploadPartCopyDataReq req(bucket_name, object_name, upload_id, number);
req.SetXCosCopySource(source);
req.SetXCosCopySourceRange(range);
qcloud_cos::UploadPartCopyDataResp resp;
qcloud_cos::CosResult result = cos.UploadPartCopyData(req, &resp);
std::cout << "===================UploadPartCopyDataResp=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;
if (result.IsSucc()) {
    *etag = resp.GetEtag();
}

}

void Copy(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

      const std::string& object_name, const std::string& source) {
qcloud_cos::CopyReq req(bucket_name, object_name);
qcloud_cos::CopyResp resp;
req.SetXCosCopySource(source);
qcloud_cos::CosResult result = cos.Copy(req, &resp);
std::cout << "===================Copy=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

void ListMultipartUpload(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::ListMultipartUploadReq req(bucket_name);
qcloud_cos::ListMultipartUploadResp resp;
qcloud_cos::CosResult result = cos.ListMultipartUpload(req, &resp);
std::vector<Upload> rst = resp.GetUpload();
for (std::vector<qcloud_cos::Upload>::const_iterator itr = rst.begin(); itr != rst.end(); ++itr) {
    const qcloud_cos::Upload& upload = *itr;
    std::cout << "key = " << upload.m_key << ", uploadid= " << upload.m_uploadid << ", storagen class = "
              << upload.m_storage_class << ", m_initiated= " << upload.m_initiated << std::endl;
}
std::cout << "===================ListMultipartUpload=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 开启bucket日志配置

void PutBucketLogging(qcloud_cos::CosAPI& cos, const std::string& bucket_name,

                  const std::string& TargetBucketname, 
                  const std::string& TargetPrefix) {
qcloud_cos::PutBucketLoggingReq req(bucket_name);
qcloud_cos::LoggingEnabled rules;
rules.SetTargetBucket(TargetBucketname);
rules.SetTargetPrefix(TargetPrefix);
req.SetLoggingEnabled(rules);
qcloud_cos::PutBucketLoggingResp resp;
qcloud_cos::CosResult result = cos.PutBucketLogging(req, &resp);
std::cout << "===================PutBucketLoggingResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 获取bucket日志配置

void GetBucketLogging(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::GetBucketLoggingReq req(bucket_name);
qcloud_cos::GetBucketLoggingResp resp;
qcloud_cos::CosResult result = cos.GetBucketLogging(req, &resp);
std::cout << "===================GetBucketLoggingResponse=====================" << std::endl;
const qcloud_cos::LoggingEnabled loggingenabled = resp.GetLoggingEnabled();
std::cout << "TargetBucket = " << loggingenabled.GetTargetBucket() << std::endl;
std::cout << "TargetPrefix = " << loggingenabled.GetTargetPrefix() << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 设置存储桶绑定自定义域名

void PutBucketDomain(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::PutBucketDomainReq req(bucket_name);
DomainRule rules;
rules.SetStatus("ENABLED");
rules.SetName("www.abc.com");
rules.SetType("REST");
//rules.SetForcedReplacement();
req.SetDomainRule(rules);
qcloud_cos::PutBucketDomainResp resp;
qcloud_cos::CosResult result = cos.PutBucketDomain(req, &resp);
std::cout << "===================PutBucketDomainResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 获取存储桶绑定自定义域名

void GetBucketDomain(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::GetBucketDomainReq req(bucket_name);
qcloud_cos::GetBucketDomainResp resp;
qcloud_cos::CosResult result = cos.GetBucketDomain(req, &resp);
std::cout << "===================GetBucketDomainResponse=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 为存储桶配置静态网站

void PutBucketWebsite(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::PutBucketWebsiteReq req(bucket_name);
qcloud_cos::PutBucketWebsiteResp resp;
req.SetSuffix("index.xml"); //必选项
req.SetProtocol("https");
req.SetKey("Error.html");
//设置重定向规则,最多设置100条 
//设置第一条规则
qcloud_cos::RoutingRule routerule1;
qcloud_cos::Condition temp_condtion1;
temp_condtion1.SetHttpErrorCodeReturnedEquals(404);//需要设置,默认404
routerule1.SetCondition(temp_condtion1);
qcloud_cos::Redirect temp_redirect1;
temp_redirect1.SetProtocol("https");
temp_redirect1.SetReplaceKeyWith("404.htmp");
routerule1.SetRedirect(temp_redirect1);
//设置第二条规则
qcloud_cos::RoutingRule routerule2;
qcloud_cos::Condition temp_condtion2;
temp_condtion2.SetHttpErrorCodeReturnedEquals(403);//需要设置,默认404
routerule2.SetCondition(temp_condtion2);
qcloud_cos::Redirect temp_redirect2;
temp_redirect2.SetProtocol("https");
temp_redirect2.SetReplaceKeyWith("403.htmp");
routerule2.SetRedirect(temp_redirect2);
//设置第三条规则
qcloud_cos::RoutingRule routerule3;
qcloud_cos::Condition temp_condtion3;
temp_condtion3.SetKeyPrefixEquals("img/");
temp_condtion3.SetHttpErrorCodeReturnedEquals(402);
routerule3.SetCondition(temp_condtion3);
qcloud_cos::Redirect temp_redirect3;
temp_redirect3.SetProtocol("https");
temp_redirect3.SetReplaceKeyWith("401.htmp");
routerule3.SetRedirect(temp_redirect3);
qcloud_cos::RoutingRule routerule4;
qcloud_cos::Condition temp_condtion4;
temp_condtion4.SetKeyPrefixEquals("img1/");
routerule4.SetCondition(temp_condtion4);
qcloud_cos::Redirect temp_redirect4;
temp_redirect4.SetProtocol("https");
temp_redirect4.SetReplaceKeyPrefixWith("402.htmp");
routerule4.SetRedirect(temp_redirect4);
req.AddRoutingRule(routerule1);
req.AddRoutingRule(routerule2);
req.AddRoutingRule(routerule3);
req.AddRoutingRule(routerule4);
qcloud_cos::CosResult result = cos.PutBucketWebsite(req, &resp);
std::cout << "===================PutBucketWebsite=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 获取与存储桶关联的静态网站配置信息

void GetBucketWebsite(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::GetBucketWebsiteReq req(bucket_name);
qcloud_cos::GetBucketWebsiteResp resp;
qcloud_cos::CosResult result = cos.GetBucketWebsite(req, &resp);
std::cout << "===================GetBucketWebsite=====================" << std::endl;
std::cout <<  "Suffix:" << resp.GetSuffix() << std::endl;
std::cout <<  "Protocol:" << resp.GetProtocol() << std::endl;
std::cout <<  "ErrorDocument:" << resp.GetKey() << std::endl;
std::vector<RoutingRule> routingrules = resp.GetRoutingRules();
std::vector<RoutingRule>::iterator it = routingrules.begin();
for(; it != routingrules.end(); ++it) {
    const Condition& condition = it->GetCondition();
    std::cout << "condition httpcode" << condition.GetHttpErrorCodeReturnedEquals() << std::endl;
    std::cout << "condition KeyPrefixEquals:" << condition.GetKeyPrefixEquals() << std::endl;
    const Redirect& redirect = it->GetRedirect();
    std::cout << "redirect Protocol:" <<redirect.GetProtocol() << std::endl;
    std::cout << "redirect ReplaceKeyWith" << redirect.GetReplaceKeyWith() << std::endl;
    std::cout << "redirect ReplaceKeyPrefixWith" <<redirect.GetReplaceKeyPrefixWith() << std::endl;
    std::cout << std::endl;
}
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 删除存储桶中的静态网站配置

void DeleteBucketWebsite(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::DeleteBucketWebsiteReq req(bucket_name);
qcloud_cos::DeleteBucketWebsiteResp resp;
qcloud_cos::CosResult result = cos.DeleteBucketWebsite(req, &resp);
std::cout << "===================DeleteBucketWebsite=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 为已存在的 Bucket 设置标签(Tag)

void PutBucketTagging(qcloud_cos::CosAPI& cos, const std::string& bucket_name, std::vector<Tag>& tagset) {

qcloud_cos::PutBucketTaggingReq req(bucket_name);
qcloud_cos::PutBucketTaggingResp resp;
req.SetTagSet(tagset);
qcloud_cos::CosResult result = cos.PutBucketTagging(req, &resp);
std::cout << "===================PutBucketTagging=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

//用于查询指定存储桶下已有的存储桶标签

void GetBucketTagging(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::GetBucketTaggingReq req(bucket_name);
qcloud_cos::GetBucketTaggingResp resp;
qcloud_cos::CosResult result = cos.GetBucketTagging(req, &resp);
std::cout << "===================GetBucketTagging=====================" << std::endl;
std::vector<Tag> tagset = resp.GetTagSet();
for(std::vector<Tag>::iterator it = tagset.begin(); it != tagset.end(); ++it) {
    std::cout << it->GetKey() << ":" << it->GetValue() << std::endl;
}
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

//删除指定存储桶下已有的存储桶标签

void DeleteBucketTagging(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::DeleteBucketTaggingReq req(bucket_name);
qcloud_cos::DeleteBucketTaggingResp resp;
qcloud_cos::CosResult result = cos.DeleteBucketTagging(req, &resp);
std::cout << "===================DeleteBucketTagging=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 在存储桶中创建清单任务

void PutBucketInventory(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::PutBucketInventoryReq req(bucket_name);
//req.SetId("list3");
//COSBucketDestination destination;
//destination.SetFormat("CSV");
//destination.SetAccountId("100010974959");
//destination.SetBucket("qcs::cos:ap-guangzhou::loggtest-1234567890");
//destination.SetPrefix("/");
//destination.SetEncryption(true);
//OptionalFields fields;

// fields.SetIsSize(true);

// fields.SetIsLastModified(true);

// fields.SetIsStorageClass(true);

// fields.SetIsMultipartUploaded(true);

// fields.SetIsReplicationStatus(true);

// fields.SetIsEtag(true);

//

// Inventory inventory;

// inventory.SetIsEnable(true);

// inventory.SetIncludedObjectVersions("All");

// inventory.SetFilter("/");

// inventory.SetId(req.GetId());

// inventory.SetFrequency("Daily");

// inventory.SetCOSBucketDestination(destination);

// inventory.SetOptionalFields(fields);

//

// req.SetInventory(inventory);

qcloud_cos::PutBucketInventoryResp resp;
qcloud_cos::CosResult result = cos.PutBucketInventory(req, &resp);
std::cout << "===================PutBucketinventory=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 用于查询存储桶中用户的清单任务信息

void GetBucketInventory(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::GetBucketInventoryReq req(bucket_name);
qcloud_cos::GetBucketInventoryResp resp;
req.SetId("list2");
qcloud_cos::CosResult result = cos.GetBucketInventory(req, &resp);
//std::cout << "===================GetBucketinventory=====================" << std::endl;
//    
//const Inventory inventory = resp.GetInventory();
//std::cout << "inventory isenabled:" << inventory.GetIsEnable() << std::endl;
//std::cout << "inventory IncludedObjectVersions:" << inventory.GetIncludedObjectVersions() << std::endl;
//std::cout << "inventory filter:" << inventory.GetFilter() << std::endl;
//std::cout << "inventory id:" << inventory.GetId() << std::endl;
//std::cout << "inventory Frequency:" << inventory.GetFrequency() << std::endl;
//std:: cout << "===================================" << std::endl;
//COSBucketDestination destination = inventory.GetCOSBucketDestination();
//std::cout << "destination Format:" << destination.GetFormat() << std::endl;
//std::cout << "destination AccountID:" << destination.GetAccountId() << std::endl;
//std::cout << "destination Bucket:" << destination.GetBucket() << std::endl;
//std::cout << "destination Encryption:" << destination.GetEncryption() << std::endl;
//std:: cout << "===================================" << std::endl;
//    
//OptionalFields fields = inventory.GetOptionalFields();
//std::cout << "fields Size:" << fields.GetIsSize() << std::endl;
//std::cout << "fields LastModified:" << fields.GetIsLastModified() << std::endl;
//std::cout << "fields StorageClass:" << fields.GetIsStorageClass() << std::endl;
//std::cout << "fields Region:" << fields.GetIsMultipartUploaded() << std::endl;
//std::cout << "fields ReplicationStatus:" << fields.GetIsReplicationStatus() << std::endl;
//std::cout << "fields Tag:" << fields.GetIsETag() << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 请求返回一个存储桶中的所有清单任务

void ListBucketInventoryConfigurations(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::ListBucketInventoryConfigurationsReq req(bucket_name);
qcloud_cos::ListBucketInventoryConfigurationsResp resp;
qcloud_cos::CosResult result = cos.ListBucketInventoryConfigurations(req, &resp);

// std::cout << "===================ListBucketInventoryConfigurations=====================" << std::endl;

//

// std::vector<Inventory> inventory_vec = resp.GetInventory();

//

// std::cout << resp.GetIsTruncated() << std::endl;

// std::cout << resp.GetContinuationToken() << std::endl;

// std::cout << resp.GetNextContinuationToken() << std::endl;

//

// std::vector<Inventory>::iterator itr = inventory_vec.begin();

// for(; itr != inventory_vec.end(); ++itr) {

//

// std:: cout << "==============Inventory=============================" << std::endl;

// std::cout << "inventory id:" << itr->GetId() << std::endl;

// std::cout << "inventory isenabled:" << itr->GetIsEnable() << std::endl;

// std::cout << "inventory IncludedObjectVersions:" << itr->GetIncludedObjectVersions() << std::endl;

// std::cout << "inventory filter:" << itr->GetFilter() << std::endl;

// std::cout << "inventory Frequency:" << itr->GetFrequency() << std::endl;

// std:: cout << "==============GetCOSBucketDestination==================" << std::endl;

// COSBucketDestination destination = itr->GetCOSBucketDestination();

// std::cout << "destination Format:" << destination.GetFormat() << std::endl;

// std::cout << "destination AccountID:" << destination.GetAccountId() << std::endl;

// std::cout << "destination Bucket:" << destination.GetBucket() << std::endl;

// std::cout << "destination Encryption:" << destination.GetEncryption() << std::endl;

//

//

// std:: cout << "===================OptionalFields======================" << std::endl;

// OptionalFields fields = itr->GetOptionalFields();

// std::cout << "fields Size:" << fields.GetIsSize() << std::endl;

// std::cout << "fields LastModified:" << fields.GetIsLastModified() << std::endl;

// std::cout << "fields StorageClass:" << fields.GetIsStorageClass() << std::endl;

// std::cout << "fields Region:" << fields.GetIsMultipartUploaded() << std::endl;

// std::cout << "fields ReplicationStatus:" << fields.GetIsReplicationStatus() << std::endl;

// std::cout << "fields Tag:" << fields.GetIsETag() << std::endl;

// }

// std::cout << "===============ListBucketInventoryConfigurations end================" << std::endl;

PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

// 用于删除存储桶中指定的清单任务.

void DeleteBucketInventory(qcloud_cos::CosAPI& cos, const std::string& bucket_name) {

qcloud_cos::DeleteBucketInventoryReq req(bucket_name);
qcloud_cos::DeleteBucketInventoryResp resp;
req.SetId("list");
qcloud_cos::CosResult result = cos.DeleteBucketInventory(req, &resp);
std::cout << "===================DeleteBucketinventory=====================" << std::endl;
PrintResult(result, resp);
std::cout << "====================================================================" << std::endl;

}

int main(int argc, char** argv) {

//v5版可以重复上传同名文件,不报错,会覆盖,v4的报错
uint64_t appid = 1256237915;
const std::string access_key = "AKIDdDYdYo";
const std::string secret_key = "CAwSlskaBW";
const std::string region = "ap-beijing";
//设置签名超时时间,单位:秒,7天
uint64_t expired_time_s = 60 * 60 * 24 * 7;
//设置连接超时时间,单位:毫秒
uint64_t conn_time_ms = 6000;
// qcloud_cos::CosConfig config("./config.json");
// qcloud_cos::CosConfig config;
// config.SetAccessKey(access_key);
// config.SetSecretKey(secret_key);
// config.SetRegion(region);
qcloud_cos::CosConfig config(appid, access_key, secret_key, region);
//设置签名超时时间,单位:秒,默认是60s
CosSysConfig::SetAuthExpiredTime(expired_time_s);
CosSysConfig::SetConnTimeoutInms(conn_time_ms);
// 日志级别,1:ERR,2:WARN,3:INFO,4:DBG 
CosSysConfig::SetLogLevel((LOG_LEVEL)(3));
// 日志输出类型,0:不输出,1:输出到屏幕,2:输出到 syslog  
CosSysConfig::SetLogOutType((LOG_OUT_TYPE)(0));
//设置文件分片并发上传线程池大小,默认: 5
CosSysConfig::SetUploadThreadPoolSize(30);
qcloud_cos::CosAPI cos(config);
// std::string bucket_name = "test1-1234567890";
//注意bucket在v4版本中不能带后面的数字,否则有一定几率上传不上去
std::string bucket_name = "private-deploy-package-1256237915";
//cos目录在v4版本中必须前面加/,v5版本没有这个要求,加不加都可以.但前加/会形成2个//形式的签名链接,可用但不规范
std::string object_name = "test/data";
std::string local_file = "/data/data.tar.gz";
std::string download_file_path = "./tmp/";
 //一复合上传接口
//void MultiUploadObject(qcloud_cos::CosAPI & cos, const std::string &bucket_name, const std::string &object_name, const std::string &local_file)
MultiUploadObject(cos, bucket_name, object_name, local_file);
qcloud_cos::GeneratePresignedUrlReq req(bucket_name, object_name, qcloud_cos::HTTP_GET);
std::string presigned_url = cos.GeneratePresignedUrl(req);
std::cout << "presigned_url = " << presigned_url << std::endl;

}


                                                        

注明:本文为星速云原创版权所有,禁止转载,一经发现将追究版权责任!

发表评论

登录后才能评论
问答社区 QQ客服
微信客服
微信客服
分享本页
返回顶部