1947 lines
65 KiB
C++
1947 lines
65 KiB
C++
// Copyright (c) 2017, Tencent Inc.
|
||
// All rights reserved.
|
||
//
|
||
// Author: sevenyou <sevenyou@tencent.com>
|
||
// Created: 07/21/17
|
||
// Description:
|
||
#pragma once
|
||
|
||
#include <map>
|
||
#include <sstream>
|
||
#include <vector>
|
||
#if defined(_WIN32)
|
||
#include <codecvt>
|
||
#endif
|
||
#include "cos_sys_config.h"
|
||
#include "request/base_req.h"
|
||
#include "trsf/async_context.h"
|
||
#include "util/file_util.h"
|
||
#include "util/illegal_intercept.h"
|
||
|
||
namespace qcloud_cos {
|
||
|
||
class ObjectReq : public BaseReq {
|
||
public:
|
||
ObjectReq(const std::string& bucket_name, const std::string& object_name)
|
||
: m_bucket_name(bucket_name), m_progress_cb(NULL), m_done_cb(NULL),
|
||
m_user_data(NULL) {
|
||
if (!IllegalIntercept::CheckBucket(bucket_name)) {
|
||
throw std::invalid_argument("Invalid bucket_name argument :" + bucket_name);
|
||
}
|
||
SetObjectName(object_name);
|
||
}
|
||
|
||
ObjectReq() {}
|
||
|
||
virtual ~ObjectReq() {}
|
||
|
||
// getter and setter
|
||
std::string GetBucketName() const { return m_bucket_name; }
|
||
void SetBucketName(const std::string& bucket_name) {
|
||
if (!IllegalIntercept::CheckBucket(bucket_name)) {
|
||
throw std::invalid_argument("Invalid bucket_name argument :" + bucket_name);
|
||
}
|
||
m_bucket_name = bucket_name;
|
||
}
|
||
std::string GetObjectName() const { return m_object_name; }
|
||
void SetObjectName(const std::string& object_name) {
|
||
if (StringUtil::StringStartsWith(object_name, "/")) {
|
||
m_object_name = object_name.substr(1);
|
||
} else {
|
||
m_object_name = object_name;
|
||
}
|
||
m_path = "/" + m_object_name;
|
||
}
|
||
#if 1
|
||
/// @brief 设置进度回调函数
|
||
void SetTransferProgressCallback(const TransferProgressCallback& process_cb) {
|
||
m_progress_cb = process_cb;
|
||
}
|
||
/// @brief 设置完成回调函数
|
||
void SetDoneCallback(const DoneCallback& done_cb) { m_done_cb = done_cb; }
|
||
/// @brief 设置回调私有数据
|
||
void SetUserData(void* user_data) { m_user_data = user_data; }
|
||
|
||
TransferProgressCallback GetTransferProgressCallback() const {
|
||
return m_progress_cb;
|
||
}
|
||
DoneCallback GetDoneCallback() const { return m_done_cb; }
|
||
void* GetUserData() const { return m_user_data; }
|
||
|
||
//virtual uint64_t GetLocalFileSize() const { return 0; }
|
||
virtual std::string GetLocalFilePath() const { return ""; }
|
||
#endif
|
||
private:
|
||
std::string m_bucket_name;
|
||
std::string m_object_name;
|
||
TransferProgressCallback m_progress_cb; // 进度回调
|
||
DoneCallback m_done_cb; // 完成回调
|
||
void* m_user_data; // 私有数据
|
||
};
|
||
|
||
class GetObjectReq : public ObjectReq {
|
||
public:
|
||
/// \brief 设置响应头部中的 Content-Type 参数
|
||
void SetResponseContentType(const std::string& str) {
|
||
AddParam("response-content-type", str);
|
||
}
|
||
|
||
/// \brief 设置响应头部中的 Content-Language 参数
|
||
void SetResponseContentLang(const std::string& str) {
|
||
AddParam("response-content-language", str);
|
||
}
|
||
|
||
/// \brief 设置响应头部中的 Content-Expires 参数
|
||
void SetResponseExpires(const std::string& str) {
|
||
AddParam("response-expires", str);
|
||
}
|
||
|
||
/// \brief 设置响应头部中的 Cache-Control 参数
|
||
void SetResponseCacheControl(const std::string& str) {
|
||
AddParam("response-cache-control", str);
|
||
}
|
||
|
||
/// \brief 设置响应头部中的 Content-Disposition 参数
|
||
void SetResponseContentEncoding(const std::string& str) {
|
||
AddParam("response-content-encoding", str);
|
||
}
|
||
|
||
/// \brief 设置响应头部中的 Content-Encoding 参数
|
||
void SetResponseContentDisposition(const std::string& str) {
|
||
AddParam("response-content-disposition", str);
|
||
}
|
||
|
||
/// \brief 设置单链接限速
|
||
/// 参考https://cloud.tencent.com/document/product/436/40140
|
||
void SetTrafficLimit(const uint64_t traffic_limit) {
|
||
AddHeader("x-cos-traffic-limit", std::to_string(traffic_limit));
|
||
}
|
||
|
||
/// \brief 设置单链接限速
|
||
/// 参考https://cloud.tencent.com/document/product/436/40140
|
||
void SetTrafficLimit(const std::string& traffic_limit) {
|
||
AddHeader("x-cos-traffic-limit", traffic_limit);
|
||
}
|
||
|
||
protected:
|
||
GetObjectReq(const std::string& bucket_name, const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
m_method = "GET";
|
||
}
|
||
|
||
virtual ~GetObjectReq() {}
|
||
};
|
||
|
||
class GetObjectByStreamReq : public GetObjectReq {
|
||
public:
|
||
GetObjectByStreamReq(const std::string& bucket_name,
|
||
const std::string& object_name, std::ostream& os)
|
||
: GetObjectReq(bucket_name, object_name), m_os(os) {
|
||
m_method = "GET";
|
||
}
|
||
|
||
virtual ~GetObjectByStreamReq() {}
|
||
|
||
std::ostream& GetStream() const { return m_os; }
|
||
|
||
private:
|
||
std::ostream& m_os;
|
||
};
|
||
|
||
class GetObjectByFileReq : public GetObjectReq {
|
||
public:
|
||
GetObjectByFileReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& local_file_path = "")
|
||
: GetObjectReq(bucket_name, object_name),
|
||
m_local_file_path(local_file_path) {
|
||
if (m_local_file_path.empty()) {
|
||
m_local_file_path = "./" + object_name;
|
||
}
|
||
}
|
||
|
||
virtual ~GetObjectByFileReq() {}
|
||
|
||
void SetLocalFilePath(const std::string& local_file_path) {
|
||
m_local_file_path = local_file_path;
|
||
}
|
||
|
||
std::string GetLocalFilePath() const { return m_local_file_path; }
|
||
|
||
uint64_t GetLocalFileSize() const { return 0; }
|
||
|
||
#if defined(_WIN32)
|
||
/// \brief 如果本地文件路径为宽字符（中文，韩文等）,需要调用该函数
|
||
void SetWideCharPath() { mb_is_widechar_path = true; }
|
||
|
||
bool IsWideCharPath() const { return mb_is_widechar_path; }
|
||
|
||
std::wstring GetWideCharLocalFilePath() const {
|
||
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
|
||
return converter.from_bytes(m_local_file_path);
|
||
}
|
||
#endif
|
||
|
||
private:
|
||
#if defined(_WIN32)
|
||
bool mb_is_widechar_path;
|
||
#endif
|
||
std::string m_local_file_path;
|
||
};
|
||
|
||
#if 0
|
||
class MultiGetObjectReq : public GetObjectReq {
|
||
public:
|
||
MultiGetObjectReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& local_file_path = "")
|
||
: GetObjectReq(bucket_name, object_name) {
|
||
// 默认使用配置文件配置的分块大小和线程池大小
|
||
m_slice_size = CosSysConfig::GetDownSliceSize();
|
||
m_thread_pool_size = CosSysConfig::GetDownThreadPoolSize();
|
||
|
||
if (local_file_path.empty()) {
|
||
m_local_file_path = "./" + object_name;
|
||
} else {
|
||
m_local_file_path = local_file_path;
|
||
}
|
||
}
|
||
|
||
virtual ~MultiGetObjectReq() {}
|
||
|
||
void SetLocalFilePath(const std::string& local_file_path) {
|
||
m_local_file_path = local_file_path;
|
||
}
|
||
|
||
std::string GetLocalFilePath() const { return m_local_file_path; }
|
||
|
||
/// \brief 设置分片大小
|
||
void SetSliceSize(uint64_t bytes) { m_slice_size = bytes; }
|
||
|
||
/// \brief 获取分片大小
|
||
uint64_t GetSliceSize() const { return m_slice_size; }
|
||
|
||
/// \brief 设置线程池大小
|
||
void SetThreadPoolSize(int size) {
|
||
assert(size > 0);
|
||
m_thread_pool_size = size;
|
||
}
|
||
|
||
/// \brief 获取线程池大小
|
||
int GetThreadPoolSize() const { return m_thread_pool_size; }
|
||
|
||
private:
|
||
std::string m_local_file_path;
|
||
uint64_t m_slice_size;
|
||
int m_thread_pool_size;
|
||
};
|
||
#endif
|
||
class PutObjectReq : public ObjectReq {
|
||
public:
|
||
/// Cache-Control RFC 2616 中定义的缓存策略，将作为 Object 元数据保存
|
||
void SetCacheControl(const std::string& str) {
|
||
AddHeader("Cache-Control", str);
|
||
}
|
||
|
||
/// Content-Disposition RFC 2616 中定义的文件名称，将作为 Object 元数据保存
|
||
void SetContentDisposition(const std::string& str) {
|
||
AddHeader("Content-Disposition", str);
|
||
}
|
||
|
||
/// Content-Encoding RFC 2616 中定义的编码格式，将作为 Object 元数据保存
|
||
void SetContentEncoding(const std::string& str) {
|
||
AddHeader("Content-Encoding", str);
|
||
}
|
||
|
||
/// Content-Type RFC 2616 中定义的内容类型（MIME），将作为 Object
|
||
/// 元数据保存
|
||
void SetContentType(const std::string& str) {
|
||
AddHeader("Content-Type", str);
|
||
}
|
||
|
||
/// Expect 当使用 Expect: 100-continue
|
||
/// 时，在收到服务端确认后，才会发送请求内容
|
||
void SetExpect(const std::string& str) { AddHeader("Expect", str); }
|
||
|
||
/// Expires RFC 2616 中定义的过期时间，将作为 Object 元数据保存
|
||
void SetExpires(const std::string& str) { AddHeader("Expires", str); }
|
||
|
||
/// 允许用户自定义的头部信息,将作为 Object 元数据返回.大小限制2K
|
||
void SetXCosMeta(const std::string& key, const std::string& value) {
|
||
AddHeader("x-cos-meta-" + key, value);
|
||
}
|
||
|
||
/// 设置 Object 的存储类型
|
||
/// 枚举值：MAZ_STANDARD，MAZ_STANDARD_IA，INTELLIGENT_TIERING，MAZ_INTELLIGENT_TIERING，STANDARD_IA，ARCHIVE，DEEP_ARCHIVE
|
||
/// 默认值：STANDARD
|
||
void SetXCosStorageClass(const std::string& storage_class) {
|
||
AddHeader("x-cos-storage-class", storage_class);
|
||
}
|
||
|
||
/// 定义Object的ACL属性,有效值：default,private,public-read
|
||
/// 默认值：private
|
||
void SetXCosAcl(const std::string& str) { AddHeader("x-cos-acl", str); }
|
||
|
||
/// 赋予被授权者读的权限.格式：x-cos-grant-read: id=" ",id=" ".
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>"
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantRead(const std::string& str) {
|
||
AddHeader("x-cos-grant-read", str);
|
||
}
|
||
|
||
/// 赋予被授权者写的权限,格式：x-cos-grant-write: id=" ",id=" "./
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantWrite(const std::string& str) {
|
||
AddHeader("x-cos-grant-write", str);
|
||
}
|
||
|
||
/// 赋予被授权者读写权限.格式：x-cos-grant-full-control: id=" ",id=" ".
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantFullControl(const std::string& str) {
|
||
AddHeader("x-cos-grant-full-control", str);
|
||
}
|
||
|
||
/// 设置Server端加密使用的算法, 目前支持AES256
|
||
void SetXCosServerSideEncryption(const std::string& str) {
|
||
AddHeader("x-cos-server-side-encryption", str);
|
||
}
|
||
|
||
/// \brief 设置单链接限速
|
||
/// 参考https://cloud.tencent.com/document/product/436/40140
|
||
void SetTrafficLimit(const uint64_t traffic_limit) {
|
||
AddHeader("x-cos-traffic-limit", std::to_string(traffic_limit));
|
||
}
|
||
|
||
/// \brief 设置单链接限速
|
||
/// 参考https://cloud.tencent.com/document/product/436/40140
|
||
void SetTrafficLimit(const std::string& traffic_limit) {
|
||
AddHeader("x-cos-traffic-limit", traffic_limit);
|
||
}
|
||
|
||
/// \brief 关闭MD5上传校验
|
||
void TurnOffComputeConentMd5() { m_need_compute_contentmd5 = false; }
|
||
|
||
bool ShouldComputeContentMd5() const { return m_need_compute_contentmd5; }
|
||
|
||
bool ShouldCheckETag() const { return m_need_check_etag; }
|
||
|
||
protected:
|
||
PutObjectReq(const std::string& bucket_name, const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
m_method = "PUT";
|
||
m_need_compute_contentmd5 = true;
|
||
m_need_check_etag = true;
|
||
}
|
||
|
||
PutObjectReq() {}
|
||
|
||
virtual ~PutObjectReq() {}
|
||
|
||
/// \brief 不检查ETag
|
||
void TurnOffCheckETag() { m_need_check_etag = false; }
|
||
|
||
private:
|
||
bool m_need_compute_contentmd5;
|
||
bool m_need_check_etag; // 某些api，比如append操作不检查响应中的ETag
|
||
};
|
||
|
||
class PutObjectByStreamReq : public PutObjectReq {
|
||
public:
|
||
PutObjectByStreamReq(const std::string& bucket_name,
|
||
const std::string& object_name, std::istream& in_stream)
|
||
: PutObjectReq(bucket_name, object_name), m_in_stream(in_stream) {}
|
||
|
||
virtual ~PutObjectByStreamReq() {}
|
||
|
||
std::istream& GetStream() const { return m_in_stream; }
|
||
|
||
private:
|
||
std::istream& m_in_stream;
|
||
};
|
||
|
||
class PutObjectByFileReq : public PutObjectReq {
|
||
public:
|
||
PutObjectByFileReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& local_file_path = "")
|
||
: PutObjectReq(bucket_name, object_name) {
|
||
if (local_file_path.empty()) {
|
||
m_local_file_path = "./" + object_name;
|
||
} else {
|
||
m_local_file_path = local_file_path;
|
||
}
|
||
#if defined(_WIN32)
|
||
mb_is_widechar_path = false;
|
||
#endif
|
||
mb_check_part_crc64 = false;
|
||
}
|
||
|
||
virtual ~PutObjectByFileReq() {}
|
||
|
||
virtual uint64_t GetLocalFileSize() const {
|
||
#if defined(_WIN32)
|
||
if (mb_is_widechar_path)
|
||
return FileUtil::GetFileLen(GetWideCharLocalFilePath());
|
||
else
|
||
#endif
|
||
return FileUtil::GetFileLen(m_local_file_path);
|
||
}
|
||
|
||
void SetLocalFilePath(const std::string& local_file_path) {
|
||
m_local_file_path = local_file_path;
|
||
}
|
||
|
||
// MultiPutObjectReq: use crc64 instead of md5 for consistency check
|
||
void SetCheckPartCrc64(bool part_crc64) {
|
||
mb_check_part_crc64 = part_crc64;
|
||
}
|
||
|
||
bool CheckPartCrc64() const {
|
||
return mb_check_part_crc64;
|
||
}
|
||
|
||
std::string GetLocalFilePath() const { return m_local_file_path; }
|
||
|
||
#if defined(_WIN32)
|
||
/// \brief 如果本地文件路径为宽字符（中文，韩文等）,需要调用该函数
|
||
void SetWideCharPath() { mb_is_widechar_path = true; }
|
||
|
||
bool IsWideCharPath() const { return mb_is_widechar_path; }
|
||
|
||
std::wstring GetWideCharLocalFilePath() const {
|
||
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
|
||
return converter.from_bytes(m_local_file_path);
|
||
}
|
||
#endif
|
||
|
||
private:
|
||
std::string m_local_file_path;
|
||
#if defined(_WIN32)
|
||
bool mb_is_widechar_path; // 标识文件路径是否为宽字符
|
||
#endif
|
||
bool mb_check_part_crc64;
|
||
};
|
||
|
||
class DeleteObjectReq : public ObjectReq {
|
||
public:
|
||
DeleteObjectReq(const std::string& bucket_name,
|
||
const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
SetMethod("DELETE");
|
||
}
|
||
|
||
DeleteObjectReq(const std::string& bucket_name,
|
||
const std::string& object_name, const std::string& version_id)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
SetMethod("DELETE");
|
||
AddParam("versionId", version_id);
|
||
}
|
||
|
||
~DeleteObjectReq() {}
|
||
|
||
/// \brief 删除指定版本号的对象
|
||
void SetXCosVersionId(const std::string& version_id) {
|
||
AddParam("versionId", version_id);
|
||
}
|
||
};
|
||
|
||
class DeleteObjectsReq : public BaseReq {
|
||
public:
|
||
explicit DeleteObjectsReq(const std::string& bucket_name)
|
||
: m_is_quiet(false), m_bucket_name(bucket_name) {
|
||
if (!IllegalIntercept::CheckBucket(bucket_name)) {
|
||
throw std::invalid_argument("Invalid bucket_name argument :" + bucket_name);
|
||
}
|
||
SetMethod("POST");
|
||
AddParam("delete", "");
|
||
}
|
||
|
||
DeleteObjectsReq(const std::string& bucket_name,
|
||
const std::vector<ObjectVersionPair>& objects)
|
||
: m_is_quiet(false), m_bucket_name(bucket_name) {
|
||
if (!IllegalIntercept::CheckBucket(bucket_name)) {
|
||
throw std::invalid_argument("Invalid bucket_name argument :" + bucket_name);
|
||
}
|
||
SetMethod("POST");
|
||
AddParam("delete", "");
|
||
m_objvers = objects;
|
||
}
|
||
|
||
~DeleteObjectsReq() {}
|
||
|
||
bool GenerateRequestBody(std::string* body) const;
|
||
|
||
void SetQuiet() { m_is_quiet = true; }
|
||
|
||
// getter and setter
|
||
std::string GetBucketName() const { return m_bucket_name; }
|
||
|
||
void SetBucketName(const std::string& bucket_name) {
|
||
if (!IllegalIntercept::CheckBucket(bucket_name)) {
|
||
throw std::invalid_argument("Invalid bucket_name argument :" + bucket_name);
|
||
}
|
||
m_bucket_name = bucket_name;
|
||
}
|
||
|
||
std::vector<ObjectVersionPair> GetObjectVersions() const { return m_objvers; }
|
||
|
||
uint32_t GetObjectVerionsSize() const { return m_objvers.size(); }
|
||
|
||
void AddObjectVersion(const std::string& object, const std::string& version) {
|
||
ObjectVersionPair pair;
|
||
pair.m_object_name = object;
|
||
pair.m_version_id = version;
|
||
m_objvers.push_back(pair);
|
||
}
|
||
|
||
void AddObject(const std::string& object) {
|
||
ObjectVersionPair pair;
|
||
pair.m_object_name = object;
|
||
pair.m_version_id = "";
|
||
m_objvers.push_back(pair);
|
||
}
|
||
|
||
private:
|
||
bool m_is_quiet;
|
||
std::string m_bucket_name;
|
||
std::vector<ObjectVersionPair> m_objvers;
|
||
};
|
||
|
||
class HeadObjectReq : public ObjectReq {
|
||
public:
|
||
HeadObjectReq(const std::string& bucket_name, const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
m_method = "HEAD";
|
||
}
|
||
|
||
virtual ~HeadObjectReq() {}
|
||
};
|
||
|
||
class InitMultiUploadReq : public ObjectReq {
|
||
public:
|
||
InitMultiUploadReq(const std::string& bucket_name,
|
||
const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
m_method = "POST";
|
||
}
|
||
virtual ~InitMultiUploadReq() {}
|
||
|
||
/// Cache-Control RFC 2616 中定义的缓存策略，将作为 Object 元数据保存
|
||
void SetCacheControl(const std::string& str) {
|
||
AddHeader("Cache-Control", str);
|
||
}
|
||
|
||
/// Content-Disposition RFC 2616 中定义的文件名称，将作为 Object 元数据保存
|
||
void SetContentDisposition(const std::string& str) {
|
||
AddHeader("Content-Disposition", str);
|
||
}
|
||
|
||
/// Content-Encoding RFC 2616 中定义的编码格式，将作为 Object 元数据保存
|
||
void SetContentEncoding(const std::string& str) {
|
||
AddHeader("Content-Encoding", str);
|
||
}
|
||
|
||
/// Content-Type RFC 2616 中定义的内容类型（MIME），将作为 Object
|
||
/// 元数据保存
|
||
void SetContentType(const std::string& str) {
|
||
AddHeader("Content-Type", str);
|
||
}
|
||
|
||
/// Expires RFC 2616 中定义的过期时间，将作为 Object 元数据保存
|
||
void SetExpires(const std::string& str) { AddHeader("Expires", str); }
|
||
|
||
/// 允许用户自定义的头部信息,将作为 Object 元数据返回.大小限制2K
|
||
void SetXCosMeta(const std::string& key, const std::string& value) {
|
||
AddHeader("x-cos-meta-" + key, value);
|
||
}
|
||
|
||
/// x-cos-storage-class 设置 Object 的存储级别，枚举值：STANDARD,STANDARD_IA，
|
||
/// 默认值：STANDARD
|
||
void SetXCosStorageClass(const std::string& storage_class) {
|
||
AddHeader("x-cos-storage-class", storage_class);
|
||
}
|
||
|
||
/// 定义Object的ACL属性,有效值：default,private,public-read
|
||
/// 默认值：private
|
||
void SetXCosAcl(const std::string& str) { AddHeader("x-cos-acl", str); }
|
||
|
||
/// 赋予被授权者读的权限.格式：x-cos-grant-read: id=" ",id=" ".
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>"
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantRead(const std::string& str) {
|
||
AddHeader("x-cos-grant-read", str);
|
||
}
|
||
|
||
/// 赋予被授权者写的权限,格式：x-cos-grant-write: id=" ",id=" "./
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantWrite(const std::string& str) {
|
||
AddHeader("x-cos-grant-write", str);
|
||
}
|
||
|
||
/// 赋予被授权者读写权限.格式：x-cos-grant-full-control: id=" ",id=" ".
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantFullControl(const std::string& str) {
|
||
AddHeader("x-cos-grant-full-control", str);
|
||
}
|
||
|
||
/// 设置Server端加密使用的算法, 目前支持AES256
|
||
void SetXCosServerSideEncryption(const std::string& str) {
|
||
AddHeader("x-cos-server-side-encryption", str);
|
||
}
|
||
};
|
||
|
||
class UploadPartDataReq : public ObjectReq {
|
||
public:
|
||
UploadPartDataReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& upload_id, std::istream& in_stream)
|
||
: ObjectReq(bucket_name, object_name), m_in_stream(in_stream),
|
||
m_upload_id(upload_id), m_part_number(1) {
|
||
m_method = "PUT";
|
||
m_need_compute_contentmd5 = true;
|
||
}
|
||
|
||
/// \brief 设置本次分块上传的ID
|
||
void SetUploadId(const std::string& upload_id) { m_upload_id = upload_id; }
|
||
/// \brief 设置本次分块上传的编号
|
||
void SetPartNumber(uint64_t part_number) { m_part_number = part_number; }
|
||
|
||
std::string GetUploadId() const { return m_upload_id; }
|
||
|
||
uint64_t GetPartNumber() const { return m_part_number; }
|
||
|
||
std::istream& GetStream() const { return m_in_stream; }
|
||
// 默认开启MD5上传校验
|
||
void TurnOnComputeConentMd5() { m_need_compute_contentmd5 = true; }
|
||
|
||
void TurnOffComputeConentMd5() { m_need_compute_contentmd5 = false; }
|
||
|
||
bool ShouldComputeContentMd5() const { return m_need_compute_contentmd5; }
|
||
|
||
/// \brief 设置单链接限速
|
||
/// 参考https://cloud.tencent.com/document/product/436/40140
|
||
void SetTrafficLimit(const uint64_t traffic_limit) {
|
||
AddHeader("x-cos-traffic-limit", std::to_string(traffic_limit));
|
||
}
|
||
|
||
/// \brief 设置单链接限速
|
||
/// 参考https://cloud.tencent.com/document/product/436/40140
|
||
void SetTrafficLimit(const std::string& traffic_limit) {
|
||
AddHeader("x-cos-traffic-limit", traffic_limit);
|
||
}
|
||
|
||
private:
|
||
std::istream& m_in_stream;
|
||
std::string m_upload_id;
|
||
uint64_t m_part_number;
|
||
bool m_need_compute_contentmd5;
|
||
};
|
||
|
||
class UploadPartCopyDataReq : public ObjectReq {
|
||
public:
|
||
UploadPartCopyDataReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& upload_id)
|
||
: ObjectReq(bucket_name, object_name), m_upload_id(upload_id),
|
||
m_part_number(1) {
|
||
m_method = "PUT";
|
||
}
|
||
|
||
UploadPartCopyDataReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& upload_id, uint64_t part_number)
|
||
: ObjectReq(bucket_name, object_name), m_upload_id(upload_id),
|
||
m_part_number(part_number) {
|
||
m_method = "PUT";
|
||
}
|
||
|
||
/// \brief 设置本次分块复制的ID
|
||
void SetUploadId(const std::string& upload_id) { m_upload_id = upload_id; }
|
||
/// \brief 设置本次分块复制的编号
|
||
void SetPartNumber(uint64_t part_number) { m_part_number = part_number; }
|
||
|
||
std::string GetUploadId() const { return m_upload_id; }
|
||
|
||
uint64_t GetPartNumber() const { return m_part_number; }
|
||
|
||
/// \brief 设置本次分块复制的源文件 URL 路径，可以通过 versionid
|
||
/// 子资源指定历史版本
|
||
void SetXCosCopySource(const std::string& src) {
|
||
AddHeader("x-cos-copy-source", src);
|
||
}
|
||
|
||
/// \brief 设置源文件的字节范围，
|
||
/// 范围值必须使用 bytes=first-last 格式，first 和 last 都是基于 0
|
||
/// 开始的偏移量。 例如 bytes=0-9
|
||
/// 表示你希望拷贝源文件的开头10个字节的数据，如果不指定，则表示拷贝整个文件
|
||
void SetXCosCopySourceRange(const std::string& range) {
|
||
AddHeader("x-cos-copy-source-range", range);
|
||
}
|
||
|
||
/// \brief 当 Object 在指定时间后被修改，则执行操作，否则返回 412
|
||
void SetXCosCopySourceIfModifiedSince(const std::string& date) {
|
||
AddHeader("x-cos-copy-source-If-Modified-Since", date);
|
||
}
|
||
|
||
/// \brief 当 Object 在指定时间后未被修改，则执行操作，否则返回 412
|
||
void SetXCosCopySourceIfUnmodifiedSince(const std::string& date) {
|
||
AddHeader("x-cos-copy-source-If-Unmodified-Since", date);
|
||
}
|
||
|
||
/// \brief 当 Object 的 Etag 和给定一致时，则执行操作，否则返回 412
|
||
void SetXCosCopySourceIfMatch(const std::string& etag) {
|
||
AddHeader("x-cos-copy-source-If-Match", etag);
|
||
}
|
||
|
||
/// \brief 当 Object 的 Etag 和给定不一致时，则执行操作，否则返回 412
|
||
void SetXCosCopySourceIfNoneMatch(const std::string& etag) {
|
||
AddHeader("x-cos-copy-source-If-None-Match", etag);
|
||
}
|
||
|
||
private:
|
||
std::string m_upload_id;
|
||
uint64_t m_part_number;
|
||
};
|
||
|
||
class CompleteMultiUploadReq : public ObjectReq {
|
||
public:
|
||
CompleteMultiUploadReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& upload_id)
|
||
: ObjectReq(bucket_name, object_name), m_upload_id(upload_id) {
|
||
m_method = "POST";
|
||
}
|
||
|
||
virtual ~CompleteMultiUploadReq() {}
|
||
|
||
std::string GetUploadId() const { return m_upload_id; }
|
||
/// \brief 设置上传的ID
|
||
void SetUploadId(const std::string& upload_id) { m_upload_id = upload_id; }
|
||
|
||
std::vector<uint64_t> GetPartNumbers() const { return m_part_numbers; }
|
||
/// \brief 设置上传的所有分块编号
|
||
void SetPartNumbers(const std::vector<uint64_t>& part_numbers) {
|
||
m_part_numbers.clear();
|
||
m_part_numbers.insert(m_part_numbers.end(), part_numbers.begin(),
|
||
part_numbers.end());
|
||
}
|
||
|
||
std::vector<std::string> GetEtags() const { return m_etags; }
|
||
/// \brief 设置上传的所有分块etag
|
||
void SetEtags(const std::vector<std::string>& etags) {
|
||
m_etags.clear();
|
||
m_etags.insert(m_etags.end(), etags.begin(), etags.end());
|
||
}
|
||
|
||
void AddPartEtagPair(uint64_t part_number, const std::string& etag) {
|
||
m_part_numbers.push_back(part_number);
|
||
m_etags.push_back(etag);
|
||
}
|
||
|
||
bool GenerateRequestBody(std::string* body) const;
|
||
|
||
private:
|
||
std::string m_upload_id;
|
||
std::vector<uint64_t> m_part_numbers;
|
||
std::vector<std::string> m_etags;
|
||
};
|
||
|
||
/*
|
||
class PutObjectByFile : public ObjectReq {
|
||
public:
|
||
PutObjectByFile(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& local_file_path = "")
|
||
: ObjectReq(bucket_name, object_name)
|
||
#if defined(_WIN32)
|
||
,
|
||
mb_is_widechar_path(false)
|
||
#endif
|
||
{
|
||
// 默认使用配置文件配置的分块大小和线程池大小
|
||
m_part_size = CosSysConfig::GetUploadPartSize();
|
||
m_thread_pool_size = CosSysConfig::GetUploadThreadPoolSize();
|
||
mb_set_meta = false;
|
||
|
||
// 默认打开当前路径下object的同名文件
|
||
if (local_file_path.empty()) {
|
||
m_local_file_path = "./" + object_name;
|
||
} else {
|
||
m_local_file_path = local_file_path;
|
||
}
|
||
// 分块上传默认检查crc64
|
||
SetCheckCRC64(true);
|
||
}
|
||
virtual ~PutObjectByFile() {}
|
||
|
||
void SetLocalFilePath(const std::string& local_file_path) {
|
||
m_local_file_path = local_file_path;
|
||
}
|
||
|
||
std::string GetLocalFilePath() const { return m_local_file_path; }
|
||
|
||
/// \brief 设置分块大小,若小于1M,则按1M计算;若大于5G,则按5G计算
|
||
void SetPartSize(uint64_t bytes) {
|
||
if (bytes <= kPartSize1M) {
|
||
m_part_size = kPartSize1M;
|
||
} else if (bytes >= kPartSize5G) {
|
||
m_part_size = kPartSize5G;
|
||
} else {
|
||
m_part_size = bytes;
|
||
}
|
||
}
|
||
|
||
/// \brief 获取分块大小
|
||
uint64_t GetPartSize() const { return m_part_size; }
|
||
|
||
void SetThreadPoolSize(int size) {
|
||
assert(size > 0);
|
||
m_thread_pool_size = size;
|
||
}
|
||
|
||
int GetThreadPoolSize() const { return m_thread_pool_size; }
|
||
|
||
/// \brief 设置Server端加密使用的算法, 目前支持AES256
|
||
void SetXCosServerSideEncryption(const std::string& str) {
|
||
AddHeader("x-cos-server-side-encryption", str);
|
||
}
|
||
|
||
/// \brief 允许用户自定义的头部信息,将作为 Object 元数据返回.大小限制2K
|
||
void SetXCosMeta(const std::string& key, const std::string& value) {
|
||
mb_set_meta = true;
|
||
m_xcos_meta.insert(std::pair<std::string, std::string>(key, value));
|
||
}
|
||
|
||
bool IsSetXCosMeta() const { return mb_set_meta; }
|
||
|
||
std::map<std::string, std::string> GetXCosMeta() const { return m_xcos_meta; }
|
||
|
||
/// \brief 请求参数中设置单链接限速, 参考
|
||
/// https://cloud.tencent.com/document/product/436/40140
|
||
void SetTrafficLimitByParam(const std::string& str) {
|
||
if (GetHeader("x-cos-traffic-limit") == "") {
|
||
AddParam("x-cos-traffic-limit", str);
|
||
}
|
||
}
|
||
|
||
/// \brief 请求头中参数中设置单链接限速
|
||
void SetTrafficLimitByHeader(const std::string& str) {
|
||
if (GetParam("x-cos-traffic-limit") == "") {
|
||
AddHeader("x-cos-traffic-limit", str);
|
||
}
|
||
}
|
||
|
||
/// \brief 设置 Object 的存储类型
|
||
///
|
||
枚举值：MAZ_STANDARD，MAZ_STANDARD_IA，INTELLIGENT_TIERING，MAZ_INTELLIGENT_TIERING，STANDARD_IA，ARCHIVE，DEEP_ARCHIVE
|
||
/// 默认值：STANDARD
|
||
void SetXCosStorageClass(const std::string& storage_class) {
|
||
AddHeader("x-cos-storage-class", storage_class);
|
||
}
|
||
|
||
/// \brief 设置Object的ACL属性
|
||
void SetXCosAcl(const std::string& str) { AddHeader("x-cos-acl", str); }
|
||
|
||
/// \briefCache-Control RFC 2616 中定义的缓存策略，将作为 Object 元数据保存
|
||
void SetCacheControl(const std::string& str) {
|
||
AddHeader("Cache-Control", str);
|
||
}
|
||
|
||
/// \brief Content-Disposition RFC 2616 中定义的文件名称，将作为 Object
|
||
/// 元数据保存
|
||
void SetContentDisposition(const std::string& str) {
|
||
AddHeader("Content-Disposition", str);
|
||
}
|
||
|
||
/// \brief Content-Encoding RFC 2616 中定义的编码格式，将作为 Object
|
||
/// 元数据保存
|
||
void SetContentEncoding(const std::string& str) {
|
||
AddHeader("Content-Encoding", str);
|
||
}
|
||
|
||
/// \brief Content-Type RFC 2616 中定义的内容类型（MIME），将作为 Object
|
||
/// 元数据保存
|
||
void SetContentType(const std::string& str) {
|
||
AddHeader("Content-Type", str);
|
||
}
|
||
|
||
/// \brief Expect 当使用 Expect: 100-continue
|
||
/// 时，在收到服务端确认后，才会发送请求内容
|
||
void SetExpect(const std::string& str) { AddHeader("Expect", str); }
|
||
|
||
/// \brief Expires RFC 2616 中定义的过期时间，将作为 Object 元数据保存
|
||
void SetExpires(const std::string& str) { AddHeader("Expires", str); }
|
||
|
||
void SetUploadID(const std::string& uploadid) {
|
||
if (!uploadid.empty()) {
|
||
m_uploadid = uploadid;
|
||
}
|
||
}
|
||
|
||
std::string GetUploadID() const { return m_uploadid; }
|
||
#if defined(_WIN32)
|
||
/// \brief 如果本地文件路径为宽字符（中文，韩文等）,需要调用该函数
|
||
void SetWideCharPath() { mb_is_widechar_path = true; }
|
||
|
||
bool IsWideCharPath() const { return mb_is_widechar_path; }
|
||
|
||
std::wstring GetWideCharLocalFilePath() const {
|
||
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
|
||
return converter.from_bytes(m_local_file_path);
|
||
}
|
||
#endif
|
||
private:
|
||
std::string m_local_file_path;
|
||
uint64_t m_part_size;
|
||
int m_thread_pool_size;
|
||
std::map<std::string, std::string> m_xcos_meta;
|
||
bool mb_set_meta;
|
||
std::string m_uploadid;
|
||
#if defined(_WIN32)
|
||
bool mb_is_widechar_path; // 标识文件路径是否为宽字符
|
||
#endif
|
||
}; // namespace qcloud_cos
|
||
*/
|
||
class AbortMultiUploadReq : public ObjectReq {
|
||
public:
|
||
AbortMultiUploadReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& upload_id)
|
||
: ObjectReq(bucket_name, object_name), m_upload_id(upload_id) {
|
||
m_method = "DELETE";
|
||
}
|
||
|
||
virtual ~AbortMultiUploadReq() {}
|
||
|
||
std::string GetUploadId() const { return m_upload_id; }
|
||
|
||
/// \brief 设置本次终止上传的uploadId
|
||
void SetUploadId(const std::string& upload_id) { m_upload_id = upload_id; }
|
||
|
||
private:
|
||
std::string m_upload_id;
|
||
};
|
||
|
||
class ListPartsReq : public ObjectReq {
|
||
public:
|
||
ListPartsReq(const std::string& bucket_name, const std::string& object_name,
|
||
const std::string& upload_id)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
m_method = "GET";
|
||
AddParam("uploadId", upload_id);
|
||
}
|
||
|
||
virtual ~ListPartsReq() {}
|
||
|
||
/// \brief 规定返回值的编码方式
|
||
void SetEncodingType(const std::string& encoding_type) {
|
||
AddParam("encoding-type", encoding_type);
|
||
}
|
||
|
||
/// \brief 单次返回最大的条目数量，若不设置，默认 1000
|
||
void SetMaxParts(uint64_t max_parts) {
|
||
AddParam("max-parts", StringUtil::Uint64ToString(max_parts));
|
||
}
|
||
|
||
/// \brief 默认以 UTF-8 二进制顺序列出条目，所有列出条目从 marker 开始
|
||
void SetPartNumberMarker(const std::string& part_number_marker) {
|
||
AddParam("part-number-marker", part_number_marker);
|
||
}
|
||
};
|
||
|
||
class GetObjectACLReq : public ObjectReq {
|
||
public:
|
||
GetObjectACLReq(const std::string& bucket_name,
|
||
const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
m_method = "GET";
|
||
AddParam("acl", "");
|
||
}
|
||
|
||
virtual ~GetObjectACLReq() {}
|
||
};
|
||
|
||
class PutObjectACLReq : public ObjectReq {
|
||
public:
|
||
PutObjectACLReq(const std::string& bucket_name,
|
||
const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
m_method = "PUT";
|
||
AddParam("acl", "");
|
||
}
|
||
|
||
virtual ~PutObjectACLReq() {}
|
||
|
||
/// 定义Object的ACL属性,有效值：default,private,public-read
|
||
/// 默认值：private
|
||
void SetXCosAcl(const std::string& str) { AddHeader("x-cos-acl", str); }
|
||
|
||
/// 赋予被授权者读的权限.格式：x-cos-grant-read: id=" ",id=" ".
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>"
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantRead(const std::string& str) {
|
||
AddHeader("x-cos-grant-read", str);
|
||
}
|
||
|
||
/// 赋予被授权者写的权限,格式：x-cos-grant-write: id=" ",id=" ".
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantWrite(const std::string& str) {
|
||
AddHeader("x-cos-grant-write", str);
|
||
}
|
||
|
||
/// 赋予被授权者读写权限.格式：x-cos-grant-full-control: id=" ",id=" ".
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantFullControl(const std::string& str) {
|
||
AddHeader("x-cos-grant-full-control", str);
|
||
}
|
||
|
||
/// Object Owner设置
|
||
void SetOwner(const Owner& owner) { m_owner = owner; }
|
||
|
||
/// 设置被授权者信息与权限信息
|
||
void SetAccessControlList(const std::vector<Grant>& grants) {
|
||
m_acl = grants;
|
||
}
|
||
|
||
/// 添加单个 Bucket 的授权信息
|
||
void AddAccessControlList(const Grant& grant) { m_acl.push_back(grant); }
|
||
|
||
/// 清空权限信息
|
||
void ClearAccessControlList() {
|
||
std::vector<Grant> tmp;
|
||
m_acl.swap(tmp);
|
||
}
|
||
|
||
bool GenerateRequestBody(std::string* body) const;
|
||
|
||
private:
|
||
Owner m_owner;
|
||
std::vector<Grant> m_acl;
|
||
};
|
||
|
||
class PutObjectTaggingReq : public ObjectReq {
|
||
public:
|
||
PutObjectTaggingReq(const std::string& bucket_name, const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
SetMethod("PUT");
|
||
AddParam("tagging", "");
|
||
}
|
||
|
||
void SetTagSet(std::vector<Tag>& tagset) { m_tagset = tagset; }
|
||
|
||
std::vector<Tag> GetTagSet() { return m_tagset; }
|
||
|
||
//清除tag规则.
|
||
void ClearTagSet() {
|
||
std::vector<Tag> temp;
|
||
m_tagset.swap(temp);
|
||
}
|
||
|
||
/// 添加单个tag.
|
||
void AddTag(const Tag& tag) { m_tagset.push_back(tag); }
|
||
|
||
void SetVersionId(const std::string& str) {
|
||
AddParam("VersionId", str);
|
||
}
|
||
|
||
bool GenerateRequestBody(std::string* body) const;
|
||
|
||
virtual ~PutObjectTaggingReq() {}
|
||
|
||
private:
|
||
std::vector<Tag> m_tagset;
|
||
};
|
||
|
||
class GetObjectTaggingReq : public ObjectReq {
|
||
public:
|
||
GetObjectTaggingReq(const std::string& bucket_name, const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
SetMethod("GET");
|
||
AddParam("tagging", "");
|
||
}
|
||
|
||
void SetVersionId(const std::string& str) {
|
||
AddParam("VersionId", str);
|
||
}
|
||
|
||
virtual ~GetObjectTaggingReq() {}
|
||
};
|
||
|
||
class DeleteObjectTaggingReq : public ObjectReq {
|
||
public:
|
||
DeleteObjectTaggingReq(const std::string& bucket_name, const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
SetMethod("DELETE");
|
||
AddParam("tagging", "");
|
||
}
|
||
|
||
void SetVersionId(const std::string& str) {
|
||
AddParam("VersionId", str);
|
||
}
|
||
|
||
virtual ~DeleteObjectTaggingReq() {}
|
||
};
|
||
|
||
class PutObjectCopyReq : public ObjectReq {
|
||
public:
|
||
PutObjectCopyReq(const std::string& bucket_name,
|
||
const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
m_method = "PUT";
|
||
}
|
||
|
||
virtual ~PutObjectCopyReq() {}
|
||
|
||
/// 源文件 URL 路径，可以通过 versionid 子资源指定历史版本
|
||
void SetXCosCopySource(const std::string& str) {
|
||
AddHeader("x-cos-copy-source", str);
|
||
}
|
||
|
||
/// 是否拷贝元数据，枚举值：Copy, Replaced，默认值 Copy。
|
||
/// 假如标记为 Copy，忽略 Header 中的用户元数据信息直接复制；
|
||
/// 假如标记为 Replaced，按 Header 信息修改元数据。
|
||
/// 当目标路径和原路径一致，即用户试图修改元数据时，必须为 Replaced
|
||
void SetXCosMetadataDirective(const std::string& str) {
|
||
AddHeader("x-cos-metadata-directive", str);
|
||
}
|
||
|
||
/// 当 Object 在指定时间后被修改，则执行操作，否则返回 412。
|
||
/// 可与 x-cos-copy-source-If-None-Match
|
||
/// 一起使用，与其他条件联合使用返回冲突。
|
||
void SetXCosCopySourceIfModifiedSince(const std::string& str) {
|
||
AddHeader("x-cos-copy-source-If-Modified-Since", str);
|
||
}
|
||
|
||
/// 当 Object 在指定时间后未被修改，则执行操作，否则返回 412。
|
||
/// 可与 x-cos-copy-source-If-Match 一起使用，与其他条件联合使用返回冲突。
|
||
void SetXCosCopySourceIfUnmodifiedSince(const std::string& str) {
|
||
AddHeader("x-cos-copy-source-If-Unmodified-Since", str);
|
||
}
|
||
|
||
/// 当 Object 的 Etag 和给定一致时，则执行操作，否则返回 412。
|
||
/// 可与x-cos-copy-source-If-Unmodified-Since
|
||
/// 一起使用，与其他条件联合使用返回冲突
|
||
void SetXCosCopySourceIfMatch(const std::string& str) {
|
||
AddHeader("x-cos-copy-source-If-Match", str);
|
||
}
|
||
|
||
/// 当 Object 的 Etag 和给定不一致时，则执行操作，否则返回 412。
|
||
/// 可与 x-cos-copy-source-If-Modified-Since
|
||
/// 一起使用，与其他条件联合使用返回冲突。
|
||
void SetXCosCopySourceIfNoneMatch(const std::string& str) {
|
||
AddHeader("x-cos-copy-source-If-None-Match", str);
|
||
}
|
||
|
||
/// 设置 Object 的存储类型
|
||
/// 枚举值：MAZ_STANDARD，MAZ_STANDARD_IA，INTELLIGENT_TIERING，MAZ_INTELLIGENT_TIERING，STANDARD_IA，ARCHIVE，DEEP_ARCHIVE
|
||
/// 默认值：STANDARD
|
||
void SetXCosStorageClass(const std::string& storage_class) {
|
||
AddHeader("x-cos-storage-class", storage_class);
|
||
}
|
||
|
||
/// 定义Object的ACL属性,有效值：default,private,public-read
|
||
/// 默认值：private
|
||
void SetXCosAcl(const std::string& str) { AddHeader("x-cos-acl", str); }
|
||
|
||
/// 赋予被授权者读的权限.格式：x-cos-grant-read: id=" ",id=" ".
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>"
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantRead(const std::string& str) {
|
||
AddHeader("x-cos-grant-read", str);
|
||
}
|
||
|
||
/// 赋予被授权者写的权限,格式：x-cos-grant-write: id=" ",id=" "./
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantWrite(const std::string& str) {
|
||
AddHeader("x-cos-grant-write", str);
|
||
}
|
||
|
||
/// 赋予被授权者读写权限.格式：x-cos-grant-full-control: id=" ",id=" ".
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantFullControl(const std::string& str) {
|
||
AddHeader("x-cos-grant-full-control", str);
|
||
}
|
||
|
||
/// 允许用户自定义的头部信息,将作为 Object 元数据返回.大小限制2K
|
||
void SetXCosMeta(const std::string& key, const std::string& value) {
|
||
AddHeader("x-cos-meta-" + key, value);
|
||
}
|
||
|
||
/// 设置Server端加密使用的算法, 目前支持AES256
|
||
void SetXCosServerSideEncryption(const std::string& str) {
|
||
AddHeader("x-cos-server-side-encryption", str);
|
||
}
|
||
};
|
||
|
||
class CopyReq : public ObjectReq {
|
||
public:
|
||
CopyReq(const std::string& bucket_name, const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
// 默认使用配置文件配置的分块大小和线程池大小
|
||
m_part_size = CosSysConfig::GetUploadCopyPartSize();
|
||
m_thread_pool_size = CosSysConfig::GetUploadThreadPoolSize();
|
||
}
|
||
|
||
virtual ~CopyReq() {}
|
||
|
||
/// 源文件 URL 路径，可以通过 versionid 子资源指定历史版本
|
||
void SetXCosCopySource(const std::string& str) {
|
||
AddHeader("x-cos-copy-source", str);
|
||
}
|
||
|
||
/// 是否拷贝元数据，枚举值：Copy, Replaced，默认值 Copy。
|
||
/// 假如标记为 Copy，忽略 Header 中的用户元数据信息直接复制；
|
||
/// 假如标记为 Replaced，按 Header 信息修改元数据。
|
||
/// 当目标路径和原路径一致，即用户试图修改元数据时，必须为 Replaced
|
||
void SetXCosMetadataDirective(const std::string& str) {
|
||
AddHeader("x-cos-metadata-directive", str);
|
||
}
|
||
|
||
/// 当 Object 在指定时间后被修改，则执行操作，否则返回 412。
|
||
/// 可与 x-cos-copy-source-If-None-Match
|
||
/// 一起使用，与其他条件联合使用返回冲突。
|
||
void SetXCosCopySourceIfModifiedSince(const std::string& str) {
|
||
AddHeader("x-cos-copy-source-If-Modified-Since", str);
|
||
}
|
||
|
||
/// 当 Object 在指定时间后未被修改，则执行操作，否则返回 412。
|
||
/// 可与 x-cos-copy-source-If-Match 一起使用，与其他条件联合使用返回冲突。
|
||
void SetXCosCopySourceIfUnmodifiedSince(const std::string& str) {
|
||
AddHeader("x-cos-copy-source-If-Unmodified-Since", str);
|
||
}
|
||
|
||
/// 当 Object 的 Etag 和给定一致时，则执行操作，否则返回 412。
|
||
/// 可与x-cos-copy-source-If-Unmodified-Since
|
||
/// 一起使用，与其他条件联合使用返回冲突
|
||
void SetXCosCopySourceIfMatch(const std::string& str) {
|
||
AddHeader("x-cos-copy-source-If-Match", str);
|
||
}
|
||
|
||
/// 当 Object 的 Etag 和给定不一致时，则执行操作，否则返回 412。
|
||
/// 可与 x-cos-copy-source-If-Modified-Since
|
||
/// 一起使用，与其他条件联合使用返回冲突。
|
||
void SetXCosCopySourceIfNoneMatch(const std::string& str) {
|
||
AddHeader("x-cos-copy-source-If-None-Match", str);
|
||
}
|
||
|
||
/// 设置 Object 的存储类型
|
||
/// 枚举值：MAZ_STANDARD，MAZ_STANDARD_IA，INTELLIGENT_TIERING，MAZ_INTELLIGENT_TIERING，STANDARD_IA，ARCHIVE，DEEP_ARCHIVE
|
||
/// 默认值：STANDARD
|
||
void SetXCosStorageClass(const std::string& storage_class) {
|
||
AddHeader("x-cos-storage-class", storage_class);
|
||
}
|
||
|
||
/// 定义Object的ACL属性,有效值：default,private,public-read
|
||
/// 默认值：private
|
||
void SetXCosAcl(const std::string& str) { AddHeader("x-cos-acl", str); }
|
||
|
||
/// 赋予被授权者读的权限.格式：x-cos-grant-read: id=" ",id=" ".
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>"
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantRead(const std::string& str) {
|
||
AddHeader("x-cos-grant-read", str);
|
||
}
|
||
|
||
/// 赋予被授权者写的权限,格式：x-cos-grant-write: id=" ",id=" "./
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantWrite(const std::string& str) {
|
||
AddHeader("x-cos-grant-write", str);
|
||
}
|
||
|
||
/// 赋予被授权者读写权限.格式：x-cos-grant-full-control: id=" ",id=" ".
|
||
/// 当需要给子账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<SubUin>",
|
||
/// 当需要给根账户授权时,id="qcs::cam::uin/<OwnerUin>:uin/<OwnerUin>"
|
||
void SetXCosGrantFullControl(const std::string& str) {
|
||
AddHeader("x-cos-grant-full-control", str);
|
||
}
|
||
|
||
/// 允许用户自定义的头部信息,将作为 Object 元数据返回.大小限制2K
|
||
void SetXCosMeta(const std::string& key, const std::string& value) {
|
||
AddHeader("x-cos-meta-" + key, value);
|
||
}
|
||
|
||
std::map<std::string, std::string> GetPartCopyHeader() const;
|
||
std::map<std::string, std::string> GetInitHeader() const;
|
||
|
||
// 设置分块大小,若小于1M,则按1M计算;若大于5G,则按5G计算
|
||
void SetPartSize(uint64_t bytes) {
|
||
if (bytes <= kPartSize1M) {
|
||
m_part_size = kPartSize1M;
|
||
} else if (bytes >= kPartSize5G) {
|
||
m_part_size = kPartSize5G;
|
||
} else {
|
||
m_part_size = bytes;
|
||
}
|
||
}
|
||
|
||
// 获取分块大小
|
||
uint64_t GetPartSize() const { return m_part_size; }
|
||
|
||
void SetThreadPoolSize(unsigned size) {
|
||
assert(size > 0);
|
||
m_thread_pool_size = size;
|
||
}
|
||
|
||
unsigned GetThreadPoolSize() const { return m_thread_pool_size; }
|
||
|
||
private:
|
||
uint64_t m_part_size;
|
||
unsigned m_thread_pool_size;
|
||
};
|
||
|
||
class PostObjectRestoreReq : public ObjectReq {
|
||
public:
|
||
PostObjectRestoreReq(const std::string& bucket_name,
|
||
const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name), m_expiry_days(0),
|
||
m_tier("Standard") {
|
||
m_method = "POST";
|
||
AddParam("restore", "");
|
||
}
|
||
|
||
PostObjectRestoreReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& version_id)
|
||
: ObjectReq(bucket_name, object_name), m_expiry_days(0),
|
||
m_tier("Standard") {
|
||
m_method = "POST";
|
||
AddParam("restore", "");
|
||
if (!version_id.empty()) {
|
||
AddHeader("x-cos-version-id", version_id);
|
||
}
|
||
}
|
||
|
||
PostObjectRestoreReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& version_id, const std::string& tier)
|
||
: ObjectReq(bucket_name, object_name), m_expiry_days(0), m_tier(tier) {
|
||
m_method = "POST";
|
||
AddParam("restore", "");
|
||
if (!version_id.empty()) {
|
||
AddHeader("x-cos-version-id", version_id);
|
||
}
|
||
}
|
||
|
||
virtual ~PostObjectRestoreReq() {}
|
||
|
||
/// \brief 设置临时副本的过期时间
|
||
void SetExiryDays(uint64_t days) { m_expiry_days = days; }
|
||
|
||
/// \brief 指定版本号的对象
|
||
void SetXCosVersionId(const std::string& version_id) {
|
||
AddHeader("x-cos-version-id", version_id);
|
||
}
|
||
|
||
// \brief 具体复原过程类型，枚举值： Expedited ，Standard
|
||
// ，Bulk；默认值：Standard
|
||
void SetTier(const std::string& tier) { m_tier = tier; }
|
||
|
||
bool GenerateRequestBody(std::string* body) const;
|
||
|
||
private:
|
||
uint64_t m_expiry_days;
|
||
std::string m_tier;
|
||
};
|
||
|
||
class GeneratePresignedUrlReq : public ObjectReq {
|
||
public:
|
||
GeneratePresignedUrlReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
HTTP_METHOD http_method)
|
||
: ObjectReq(bucket_name, object_name), m_start_time_in_s(0),
|
||
m_expired_time_in_s(0), m_use_https(true) {
|
||
m_path = "/" + object_name;
|
||
m_method = StringUtil::HttpMethodToString(http_method);
|
||
}
|
||
|
||
virtual ~GeneratePresignedUrlReq() {}
|
||
|
||
uint64_t GetStartTimeInSec() const { return m_start_time_in_s; }
|
||
uint64_t GetExpiredTimeInSec() const { return m_expired_time_in_s; }
|
||
void SetStartTimeInSec(uint64_t start_time) {
|
||
m_start_time_in_s = start_time;
|
||
}
|
||
void SetExpiredTimeInSec(uint64_t expired_time) {
|
||
m_expired_time_in_s = expired_time;
|
||
}
|
||
|
||
/// \brief 是否生成https链接，默认为true
|
||
void SetUseHttps(bool use_https) { m_use_https = use_https; }
|
||
bool UseHttps() const { return m_use_https; }
|
||
|
||
|
||
private:
|
||
uint64_t m_start_time_in_s;
|
||
uint64_t m_expired_time_in_s;
|
||
bool m_use_https; // 是否启用https
|
||
};
|
||
|
||
class OptionsObjectReq : public ObjectReq {
|
||
public:
|
||
OptionsObjectReq(const std::string& bucket_name,
|
||
const std::string& object_name)
|
||
: ObjectReq(bucket_name, object_name) {
|
||
m_method = "OPTIONS";
|
||
m_path = "/" + object_name;
|
||
}
|
||
|
||
virtual ~OptionsObjectReq() {}
|
||
|
||
/// \brief
|
||
/// 添加Origin头部，参考官网https://cloud.tencent.com/document/product/436/8288
|
||
void SetOrigin(const std::string& origin) { AddHeader("Origin", origin); }
|
||
|
||
/// \brief 添加跨域访问的请求HTTP方法的头部
|
||
void SetAccessControlRequestMethod(const std::string& method) {
|
||
AddHeader("Access-Control-Request-Method", method);
|
||
}
|
||
|
||
/// \brief 添加跨域访问的请求头部的头部
|
||
void SetAccessControlRequestHeaders(const std::string& headers) {
|
||
AddHeader("Access-Control-Request-Headers", headers);
|
||
}
|
||
};
|
||
|
||
class SelectObjectContentReq : public ObjectReq {
|
||
public:
|
||
/// \brief
|
||
/// input_file_type: 待检索对象的格式为csv或者json
|
||
/// out_file_type: 输出格式为csv或者json
|
||
SelectObjectContentReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
int input_file_type = CSV,
|
||
int input_compress_type = COMPRESS_NONE,
|
||
int out_file_type = CSV)
|
||
: ObjectReq(bucket_name, object_name), m_input_file_type(input_file_type),
|
||
m_input_compress_type(input_compress_type),
|
||
m_output_file_type(out_file_type), m_expression_type("SQL"),
|
||
m_request_progress(false) {
|
||
m_method = "POST";
|
||
m_path = "/" + object_name;
|
||
AddParam("select", "");
|
||
AddParam("select-type", "2");
|
||
GenDefaultInputSerialization();
|
||
GenDefaultOutputSerialization();
|
||
}
|
||
|
||
virtual ~SelectObjectContentReq() {}
|
||
|
||
/// \brief
|
||
/// 设置SQL表达式，参考官网https://cloud.tencent.com/document/product/436/37641
|
||
void SetSqlExpression(const std::string& sql_expression) {
|
||
m_sql_expression = sql_expression;
|
||
}
|
||
|
||
/// \brief 设置SQL表达式类型，目前只支持SQL
|
||
void SetExpressionType(const std::string& expression_type) {
|
||
m_sql_expression = expression_type;
|
||
}
|
||
|
||
/// \brief input描述待检索对象的格式
|
||
void SetInputSerialization(const std::string& input) {
|
||
m_inputserialization = input;
|
||
}
|
||
|
||
/// \brief output描述检索结果的输出格式
|
||
void SetOutputSerialization(const std::string& output) {
|
||
m_outputserialization = output;
|
||
}
|
||
|
||
/// \brief 是否需要返回查询进度 QueryProgress 信息，如果选中 COS Select
|
||
/// 将周期性返回查询进度
|
||
void SetRequestProgress(bool progress) { m_request_progress = progress; }
|
||
|
||
bool GenerateRequestBody(std::string* body) const;
|
||
|
||
private:
|
||
/// \brief 根据m_input_csv产生默认的待检索对象的格式
|
||
void GenDefaultInputSerialization() {
|
||
std::ostringstream input_xml;
|
||
input_xml << "<InputSerialization>";
|
||
if (m_input_compress_type == COMPRESS_GZIP) {
|
||
input_xml << "<CompressionType>GZIP</CompressionType>";
|
||
} else if (m_input_compress_type == COMPRESS_BZIP2) {
|
||
input_xml << "<CompressionType>BZIP2</CompressionType>";
|
||
} else {
|
||
input_xml << "<CompressionType>NONE</CompressionType>";
|
||
}
|
||
if (m_input_file_type == CSV) {
|
||
input_xml << "<CSV>";
|
||
input_xml << "<FileHeaderInfo>NONE</FileHeaderInfo>";
|
||
input_xml << "<RecordDelimiter>\\n</RecordDelimiter>";
|
||
input_xml << "<FieldDelimiter>,</FieldDelimiter>";
|
||
input_xml << "<QuoteCharacter>\"</QuoteCharacter>";
|
||
input_xml << "<QuoteEscapeCharacter>\"</QuoteEscapeCharacter>";
|
||
input_xml << "<Comments>#</Comments>";
|
||
input_xml
|
||
<< "<AllowQuotedRecordDelimiter>FALSE</AllowQuotedRecordDelimiter>";
|
||
input_xml << "</CSV>";
|
||
input_xml << "</InputSerialization>";
|
||
} else if (m_input_file_type == JSON) {
|
||
input_xml << "<JSON>";
|
||
input_xml << "<Type>DOCUMENT</Type>";
|
||
input_xml << "</JSON>";
|
||
input_xml << "</InputSerialization>";
|
||
}
|
||
m_inputserialization = input_xml.str();
|
||
}
|
||
|
||
/// \brief 根据m_out_csv产生默认的检索结果的输出格式
|
||
void GenDefaultOutputSerialization() {
|
||
std::ostringstream output_xml;
|
||
if ((m_output_file_type == CSV)) {
|
||
output_xml << "<OutputSerialization>";
|
||
output_xml << "<CSV>";
|
||
output_xml << "<QuoteFields>ASNEEDED</QuoteFields>";
|
||
output_xml << "<RecordDelimiter>\\n</RecordDelimiter>";
|
||
output_xml << "<FieldDelimiter>,</FieldDelimiter>";
|
||
output_xml << "<QuoteCharacter>\"</QuoteCharacter>";
|
||
output_xml << "<QuoteEscapeCharacter>\"</QuoteEscapeCharacter>";
|
||
output_xml << "</CSV>";
|
||
output_xml << "</OutputSerialization>";
|
||
} else if (m_output_file_type == JSON) {
|
||
output_xml << "<OutputSerialization>";
|
||
output_xml << "<JSON>";
|
||
output_xml << "<RecordDelimiter>\\n</RecordDelimiter>";
|
||
output_xml << "</JSON>";
|
||
output_xml << "</OutputSerialization>";
|
||
}
|
||
m_outputserialization = output_xml.str();
|
||
}
|
||
|
||
int m_input_file_type; // csv or json
|
||
int m_input_compress_type; // NONE,GZIP,BZIP2
|
||
int m_output_file_type; // csv or json
|
||
std::string m_sql_expression; // like "Select * from COSObject"
|
||
std::string m_expression_type; // default is "SQL"
|
||
std::string m_inputserialization; // xml format
|
||
std::string m_outputserialization; // xml format
|
||
bool m_request_progress; // default is false
|
||
};
|
||
|
||
class AppendObjectReq : public PutObjectByStreamReq {
|
||
public:
|
||
AppendObjectReq(const std::string& bucket_name,
|
||
const std::string& object_name, std::istream& in_stream)
|
||
: PutObjectByStreamReq(bucket_name, object_name, in_stream) {
|
||
m_method = "POST";
|
||
m_path = "/" + object_name;
|
||
AddParam("append", "");
|
||
AddParam("position", "0");
|
||
// append返回的ETag不是body的MD5，不需要检查Etag
|
||
TurnOffCheckETag();
|
||
}
|
||
|
||
virtual ~AppendObjectReq() {}
|
||
|
||
/// \brief
|
||
/// 添加position参数，参考官网https://cloud.tencent.com/document/product/436/7741
|
||
void SetPosition(const std::string& position) {
|
||
AddParam("position", position);
|
||
}
|
||
};
|
||
|
||
/// \brief: 创建直播通道请求
|
||
class PutLiveChannelReq : public ObjectReq {
|
||
public:
|
||
/// \brief
|
||
/// channel_name: 通道名
|
||
PutLiveChannelReq(const std::string& bucket_name,
|
||
const std::string& channel_name)
|
||
: ObjectReq(bucket_name, channel_name) {
|
||
m_method = "PUT";
|
||
m_path = "/" + channel_name;
|
||
AddParam("live", "");
|
||
m_expire_sec = 3600;
|
||
}
|
||
|
||
virtual ~PutLiveChannelReq() {}
|
||
|
||
void SetLiveChannelConfig(const LiveChannelConfiguration& config) {
|
||
m_config = config;
|
||
}
|
||
|
||
/// brief: 设置url参数
|
||
void SetUrlParams(const std::map<std::string, std::string>& url_params) {
|
||
m_url_params = url_params;
|
||
}
|
||
|
||
const std::map<std::string, std::string>& GetUrlParams() const {
|
||
return m_url_params;
|
||
}
|
||
|
||
/// brief: 设置推流签名过期时间
|
||
void SetExpire(int expire) { m_expire_sec = expire; }
|
||
|
||
int GetExpire() const { return m_expire_sec; }
|
||
|
||
bool GenerateRequestBody(std::string* body) const;
|
||
|
||
private:
|
||
LiveChannelConfiguration m_config;
|
||
std::map<std::string, std::string> m_url_params;
|
||
int m_expire_sec;
|
||
};
|
||
|
||
/// \brief: 启用或者禁用直播通道请求
|
||
class PutLiveChannelSwitchReq : public ObjectReq {
|
||
public:
|
||
/// \brief
|
||
/// channel_name: 通道名
|
||
PutLiveChannelSwitchReq(const std::string& bucket_name,
|
||
const std::string& channel_name)
|
||
: ObjectReq(bucket_name, channel_name) {
|
||
m_method = "PUT";
|
||
m_path = "/" + channel_name;
|
||
AddParam("live", "");
|
||
AddParam("switch", "enabled");
|
||
}
|
||
|
||
virtual ~PutLiveChannelSwitchReq() {}
|
||
|
||
/// \brief 启用通道
|
||
void SetEnabled() { AddParam("switch", "enabled"); }
|
||
|
||
/// \brief 禁用通道
|
||
void SetDisabled() { AddParam("switch", "disabled"); }
|
||
};
|
||
|
||
/// \brief: 获取直播通道配置
|
||
class GetLiveChannelReq : public ObjectReq {
|
||
public:
|
||
GetLiveChannelReq(const std::string& bucket_name,
|
||
const std::string& channel_name)
|
||
: ObjectReq(bucket_name, channel_name) {
|
||
m_method = "GET";
|
||
m_path = "/" + channel_name;
|
||
AddParam("live", "");
|
||
}
|
||
virtual ~GetLiveChannelReq() {}
|
||
};
|
||
|
||
/// \brief: 获取直播通道推流历史
|
||
class GetLiveChannelHistoryReq : public ObjectReq {
|
||
public:
|
||
GetLiveChannelHistoryReq(const std::string& bucket_name,
|
||
const std::string& channel_name)
|
||
: ObjectReq(bucket_name, channel_name) {
|
||
m_method = "GET";
|
||
m_path = "/" + channel_name;
|
||
AddParam("live", "");
|
||
AddParam("comp", "history");
|
||
}
|
||
virtual ~GetLiveChannelHistoryReq() {}
|
||
};
|
||
|
||
/// \brief: 获取直播通道推流状态
|
||
class GetLiveChannelStatusReq : public ObjectReq {
|
||
public:
|
||
GetLiveChannelStatusReq(const std::string& bucket_name,
|
||
const std::string& channel_name)
|
||
: ObjectReq(bucket_name, channel_name) {
|
||
m_method = "GET";
|
||
m_path = "/" + channel_name;
|
||
AddParam("live", "");
|
||
AddParam("comp", "status");
|
||
}
|
||
virtual ~GetLiveChannelStatusReq() {}
|
||
};
|
||
|
||
/// \brief: 删除直播通道
|
||
class DeleteLiveChannelReq : public ObjectReq {
|
||
public:
|
||
DeleteLiveChannelReq(const std::string& bucket_name,
|
||
const std::string& channel_name)
|
||
: ObjectReq(bucket_name, channel_name) {
|
||
m_method = "DELETE";
|
||
m_path = "/" + channel_name;
|
||
AddParam("live", "");
|
||
}
|
||
virtual ~DeleteLiveChannelReq() {}
|
||
};
|
||
|
||
/// \brief: 查询指定通道在指定时间段推流生成的播放列表
|
||
class GetLiveChannelVodPlaylistReq : public ObjectReq {
|
||
public:
|
||
GetLiveChannelVodPlaylistReq(const std::string& bucket_name,
|
||
const std::string& channel_name)
|
||
: ObjectReq(bucket_name, channel_name) {
|
||
m_method = "GET";
|
||
m_path = "/" + channel_name;
|
||
AddParam("vod", "");
|
||
}
|
||
virtual ~GetLiveChannelVodPlaylistReq() {}
|
||
/// \brief time格式为unix时间戳，必须调用该接口设置开始时间和结束时间
|
||
void SetTime(uint64_t starttime, uint64_t endtime) {
|
||
AddParam("starttime", StringUtil::Uint64ToString(starttime));
|
||
AddParam("endtime", StringUtil::Uint64ToString(endtime));
|
||
}
|
||
};
|
||
|
||
/// \brief: 为指定通道生成一个可供点播例用的播放列表
|
||
class PostLiveChannelVodPlaylistReq : public ObjectReq {
|
||
public:
|
||
PostLiveChannelVodPlaylistReq(const std::string& bucket_name,
|
||
const std::string& channel_name)
|
||
: ObjectReq(bucket_name, channel_name) {
|
||
m_method = "POST";
|
||
m_path = "/" + channel_name;
|
||
AddParam("vod", "");
|
||
}
|
||
virtual ~PostLiveChannelVodPlaylistReq() {}
|
||
|
||
/// \brief time格式为unix时间戳，必须调用该接口设置开始时间和结束时间
|
||
void SetTime(uint64_t starttime, uint64_t endtime) {
|
||
AddParam("starttime", StringUtil::Uint64ToString(starttime));
|
||
AddParam("endtime", StringUtil::Uint64ToString(endtime));
|
||
}
|
||
|
||
/// \brief 必须调用该接口设置播放列表名称
|
||
void SetPlaylistName(const std::string& playlist_name) {
|
||
m_path.append("/" + playlist_name);
|
||
}
|
||
};
|
||
|
||
/* Multithread接口 */
|
||
|
||
class MultiPutObjectReq : public PutObjectByFileReq {
|
||
public:
|
||
MultiPutObjectReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& local_file_path)
|
||
: PutObjectByFileReq(bucket_name, object_name, local_file_path) {
|
||
SetCheckCRC64(true);
|
||
}
|
||
virtual ~MultiPutObjectReq() {}
|
||
};
|
||
|
||
class MultiGetObjectReq : public GetObjectByFileReq {
|
||
public:
|
||
MultiGetObjectReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& local_file_path)
|
||
: GetObjectByFileReq(bucket_name, object_name, local_file_path) {}
|
||
virtual ~MultiGetObjectReq() {}
|
||
};
|
||
|
||
class PutObjectResumableSingleSyncReq : public PutObjectByFileReq {
|
||
public:
|
||
PutObjectResumableSingleSyncReq(const std::string& bucket_name,
|
||
const std::string& object_name,
|
||
const std::string& local_file_path)
|
||
: PutObjectByFileReq(bucket_name, object_name, local_file_path) {
|
||
SetCheckCRC64(true);
|
||
}
|
||
virtual ~PutObjectResumableSingleSyncReq() {}
|
||
};
|
||
|
||
/* Async接口 */
|
||
|
||
#if 0
|
||
class AsyncReq {
|
||
public:
|
||
AsyncReq(const std::string& bucket_name, const std::string& object_name,
|
||
const std::string& local_file_path, bool wide_char_path = false)
|
||
: m_bucket_name(bucket_name), m_object_name(object_name),
|
||
m_local_file_path(local_file_path) {}
|
||
|
||
virtual ~AsyncReq() {}
|
||
std::string GetBucketName() const { return m_bucket_name; }
|
||
std::string GetObjectName() const { return m_object_name; }
|
||
std::string GetLocalFilePath() const { return m_local_file_path; }
|
||
virtual uint64_t GetLocalFileSize() const { return 0; }
|
||
#if defined(_WIN32)
|
||
/// \brief 如果本地文件路径为宽字符（中文，韩文等）,需要调用该函数
|
||
void SetWideCharPath() { mb_is_widechar_path = true; }
|
||
|
||
bool IsWideCharPath() const { return mb_is_widechar_path; }
|
||
/// \brief 获取宽字符路径
|
||
std::wstring GetWideCharLocalFilePath() const {
|
||
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
|
||
return converter.from_bytes(m_local_file_path);
|
||
}
|
||
#endif
|
||
/// @brief 设置进度回调函数
|
||
void SetTransferProgressCallback(const TransferProgressCallback& process_cb) {
|
||
m_progress_cb = process_cb;
|
||
}
|
||
/// @brief 设置完成回调函数
|
||
void SetDoneCallback(const DoneCallback& done_cb) { m_done_cb = done_cb; }
|
||
/// @brief 设置回调私有数据
|
||
void SetUserData(void* user_data) { m_user_data = user_data; }
|
||
|
||
TransferProgressCallback GetTransferProgressCallback() const {
|
||
return m_progress_cb;
|
||
}
|
||
DoneCallback GetDoneCallback() const { return m_done_cb; }
|
||
void* GetUserData() const { return m_user_data; }
|
||
|
||
protected:
|
||
std::string m_bucket_name;
|
||
std::string m_object_name;
|
||
bool mb_is_widechar_path;
|
||
std::string m_local_file_path;
|
||
TransferProgressCallback m_progress_cb; // 进度回调
|
||
DoneCallback m_done_cb; // 完成回调
|
||
void* m_user_data;
|
||
};
|
||
#endif
|
||
|
||
class AsyncPutObjectReq : public PutObjectByFileReq {
|
||
public:
|
||
AsyncPutObjectReq(const std::string& bucket_name, const std::string& object_name,
|
||
const std::string& local_file_path)
|
||
: PutObjectByFileReq(bucket_name, object_name, local_file_path) {}
|
||
|
||
virtual ~AsyncPutObjectReq() {}
|
||
};
|
||
|
||
class AsyncPutObjectByStreamReq : public PutObjectByStreamReq {
|
||
public:
|
||
AsyncPutObjectByStreamReq(const std::string& bucket_name, const std::string& object_name,
|
||
std::istream& in_stream)
|
||
: PutObjectByStreamReq(bucket_name, object_name, in_stream) {}
|
||
|
||
virtual ~AsyncPutObjectByStreamReq() {}
|
||
};
|
||
|
||
class AsyncMultiPutObjectReq : public PutObjectByFileReq {
|
||
public:
|
||
AsyncMultiPutObjectReq(const std::string& bucket_name, const std::string& object_name,
|
||
const std::string& local_file_path)
|
||
: PutObjectByFileReq(bucket_name, object_name, local_file_path) {}
|
||
|
||
virtual ~AsyncMultiPutObjectReq() {}
|
||
};
|
||
|
||
class AsyncGetObjectReq : public GetObjectByFileReq {
|
||
public:
|
||
AsyncGetObjectReq(const std::string& bucket_name, const std::string& object_name,
|
||
const std::string& local_file_path)
|
||
: GetObjectByFileReq(bucket_name, object_name, local_file_path) {}
|
||
|
||
virtual ~AsyncGetObjectReq() {}
|
||
};
|
||
|
||
class AsyncMultiGetObjectReq : public GetObjectByFileReq {
|
||
public:
|
||
AsyncMultiGetObjectReq(const std::string& bucket_name, const std::string& object_name,
|
||
const std::string& local_file_path)
|
||
: GetObjectByFileReq(bucket_name, object_name, local_file_path) {}
|
||
|
||
virtual ~AsyncMultiGetObjectReq() {}
|
||
};
|
||
/* 批量及目录操作接口 */
|
||
|
||
class PutObjectsByDirectoryReq : public PutObjectReq {
|
||
public:
|
||
PutObjectsByDirectoryReq(const std::string& bucket_name,
|
||
const std::string& directory_name)
|
||
: m_bucket_name(bucket_name), m_directory_name(directory_name),
|
||
m_cos_path("") {
|
||
if (!IllegalIntercept::CheckBucket(bucket_name)) {
|
||
throw std::invalid_argument("Invalid bucket_name argument :" + bucket_name);
|
||
}
|
||
m_need_compute_contentmd5 = true; // 默认打开
|
||
}
|
||
|
||
PutObjectsByDirectoryReq(const std::string& bucket_name,
|
||
const std::string& directory_name,
|
||
const std::string& cos_path)
|
||
: m_bucket_name(bucket_name), m_directory_name(directory_name),
|
||
m_cos_path(cos_path) {
|
||
if (!IllegalIntercept::CheckBucket(bucket_name)) {
|
||
throw std::invalid_argument("Invalid bucket_name argument :" + bucket_name);
|
||
}
|
||
m_need_compute_contentmd5 = true; // 默认打开
|
||
}
|
||
|
||
virtual ~PutObjectsByDirectoryReq() {}
|
||
|
||
std::string GetBucketName() const { return m_bucket_name; }
|
||
|
||
std::string GetDirectoryName() const { return m_directory_name; }
|
||
|
||
// 设置上传到cos的路径
|
||
void SetCosPath(const std::string& cos_path) { m_cos_path = cos_path; }
|
||
|
||
std::string GetCosPath() const { return m_cos_path; }
|
||
|
||
void TurnOnComputeConentMd5() { m_need_compute_contentmd5 = true; }
|
||
|
||
void TurnOffComputeConentMd5() { m_need_compute_contentmd5 = false; }
|
||
|
||
bool ShouldComputeContentMd5() const { return m_need_compute_contentmd5; }
|
||
|
||
private:
|
||
// TODO 支持前缀和后缀
|
||
std::string m_bucket_name;
|
||
std::string m_directory_name;
|
||
std::string m_cos_path;
|
||
bool m_need_compute_contentmd5;
|
||
};
|
||
|
||
class PutDirectoryReq : public PutObjectReq {
|
||
public:
|
||
PutDirectoryReq(const std::string& bucket_name,
|
||
const std::string& directory_name)
|
||
: PutObjectReq(bucket_name, directory_name) {}
|
||
|
||
virtual ~PutDirectoryReq() {}
|
||
};
|
||
|
||
class MoveObjectReq : public ObjectReq {
|
||
public:
|
||
MoveObjectReq(const std::string& bucket_name,
|
||
const std::string& src_object_name,
|
||
const std::string& dst_object_name)
|
||
: m_bucket_name(bucket_name), m_src_object_name(src_object_name),
|
||
m_dst_object_name(dst_object_name) {
|
||
if (!IllegalIntercept::CheckBucket(bucket_name)) {
|
||
throw std::invalid_argument("Invalid bucket_name argument :" + bucket_name);
|
||
}
|
||
}
|
||
virtual ~MoveObjectReq() {}
|
||
|
||
std::string GetBucketName() const { return m_bucket_name; }
|
||
|
||
std::string GetSrcObjectName() const { return m_src_object_name; }
|
||
|
||
std::string GetDstObjectName() const { return m_dst_object_name; }
|
||
|
||
private:
|
||
std::string m_bucket_name;
|
||
std::string m_src_object_name;
|
||
std::string m_dst_object_name;
|
||
};
|
||
|
||
class DeleteObjectsByPrefixReq {
|
||
public:
|
||
DeleteObjectsByPrefixReq(const std::string& bucket_name,
|
||
const std::string& prefix)
|
||
: m_bucket_name(bucket_name), m_prefix(prefix) {
|
||
if (!IllegalIntercept::CheckBucket(bucket_name)) {
|
||
throw std::invalid_argument("Invalid bucket_name argument :" + bucket_name);
|
||
}
|
||
}
|
||
virtual ~DeleteObjectsByPrefixReq() {}
|
||
|
||
std::string GetBucketName() const { return m_bucket_name; }
|
||
|
||
std::string GetPrefix() const { return m_prefix; }
|
||
|
||
private:
|
||
std::string m_bucket_name;
|
||
std::string m_prefix;
|
||
};
|
||
|
||
} // namespace qcloud_cos
|