cos-nodejs-sdk-v5/sdk/base.js

cos nodejs sdk v5

var pkg = require('../package.json');
var REQUEST = require('cos-request');
var mime = require('mime-types');
var Stream = require('stream');
var util = require('./util');
var fs = require('fs');

// Bucket 相关

/**
 * 获取用户的 bucket 列表
 * @param  {Object}  params         回调函数，必须，下面为参数列表
 * 无特殊参数
 * @param  {Function}  callback     回调函数，必须
 */
function getService(params, callback) {
  var protocol = this.options.Protocol || (util.isBrowser && location.protocol === 'http:' ? 'http:' : 'https:');
  var domain = this.options.ServiceDomain;
  var appId = params.AppId || this.options.appId;
  var region = params.Region;
  if (domain) {
    domain = domain
      .replace(/\{\{AppId\}\}/gi, appId || '')
      .replace(/\{\{Region\}\}/gi, region || '')
      .replace(/\{\{.*?\}\}/gi, '');
    if (!/^[a-zA-Z]+:\/\//.test(domain)) {
      domain = protocol + '//' + domain;
    }
    if (domain.slice(-1) === '/') {
      domain = domain.slice(0, -1);
    }
  } else if (region) {
    domain = protocol + '//cos.' + region + '.myqcloud.com';
  } else {
    domain = protocol + '//service.cos.myqcloud.com';
  }

  var SignHost = '';
  var standardHost = region ? 'cos.' + region + '.myqcloud.com' : 'service.cos.myqcloud.com';
  var urlHost = domain.replace(/^https?:\/\/([^/]+)(\/.*)?$/, '$1');
  if (standardHost === urlHost) SignHost = standardHost;

  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetService',
      url: domain,
      method: 'GET',
      headers: params.Headers,
      SignHost: SignHost,
      qs: {
        tagkey: params.TagKey,
        tagvalue: params.TagValue,
        'create-time': params.CreateTime,
        range: params.CreateRange,
        marker: params.Marker,
        'max-keys': params.MaxKeys,
      },
    },
    function (err, data) {
      if (err) return callback(err);
      var buckets =
        (data &&
          data.ListAllMyBucketsResult &&
          data.ListAllMyBucketsResult.Buckets &&
          data.ListAllMyBucketsResult.Buckets.Bucket) ||
        [];
      buckets = util.isArray(buckets) ? buckets : [buckets];
      var owner = (data && data.ListAllMyBucketsResult && data.ListAllMyBucketsResult.Owner) || {};
      callback(null, {
        Buckets: buckets,
        Owner: owner,
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 创建 Bucket，并初始化访问权限
 * @param  {Object}  params                         参数对象，必须
 *     @param  {String}  params.Bucket              Bucket名称，必须
 *     @param  {String}  params.Region              地域名称，必须
 *     @param  {String}  params.ACL                 用户自定义文件权限，可以设置：private，public-read；默认值：private，非必须
 *     @param  {String}  params.GrantRead           赋予被授权者读的权限，格式x-cos-grant-read: uin=" ",uin=" "，非必须
 *     @param  {String}  params.GrantWrite          赋予被授权者写的权限，格式x-cos-grant-write: uin=" ",uin=" "，非必须
 *     @param  {String}  params.GrantFullControl    赋予被授权者读写权限，格式x-cos-grant-full-control: uin=" ",uin=" "，非必须
 * @param  {Function}  callback                     回调函数，必须
 * @return  {Object}  err                           请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                          返回的数据
 *     @return  {String}  data.Location             操作地址
 */
function putBucket(params, callback) {
  var self = this;

  var xml = '';
  var conf = {};
  if (params.BucketAZConfig) conf.BucketAZConfig = params.BucketAZConfig;
  if (params.BucketArchConfig) conf.BucketArchConfig = params.BucketArchConfig;
  if (conf.BucketAZConfig || conf.BucketArchConfig) xml = util.json2xml({ CreateBucketConfiguration: conf });

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucket',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      body: xml,
    },
    function (err, data) {
      if (err) return callback(err);
      var url = getUrl({
        protocol: self.options.Protocol,
        domain: self.options.Domain,
        bucket: params.Bucket,
        region: params.Region,
        isLocation: true,
      });
      callback(null, {
        Location: url,
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 查看是否存在该Bucket，是否有权限访问
 * @param  {Object}  params                     参数对象，必须
 *     @param  {String}  params.Bucket          Bucket名称，必须
 *     @param  {String}  params.Region          地域名称，必须
 * @param  {Function}  callback                 回调函数，必须
 * @return  {Object}  err                       请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                      返回的数据
 *     @return  {Boolean}  data.BucketExist     Bucket是否存在
 *     @return  {Boolean}  data.BucketAuth      是否有 Bucket 的访问权限
 */
function headBucket(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:HeadBucket',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      method: 'HEAD',
    },
    callback
  );
}

/**
 * 获取 Bucket 下的 object 列表
 * @param  {Object}  params                         参数对象，必须
 *     @param  {String}  params.Bucket              Bucket名称，必须
 *     @param  {String}  params.Region              地域名称，必须
 *     @param  {String}  params.Prefix              前缀匹配，用来规定返回的文件前缀地址，非必须
 *     @param  {String}  params.Delimiter           定界符为一个符号，如果有Prefix，则将Prefix到delimiter之间的相同路径归为一类，非必须
 *     @param  {String}  params.Marker              默认以UTF-8二进制顺序列出条目，所有列出条目从marker开始，非必须
 *     @param  {String}  params.MaxKeys             单次返回最大的条目数量，默认1000，非必须
 *     @param  {String}  params.EncodingType        规定返回值的编码方式，非必须
 * @param  {Function}  callback                     回调函数，必须
 * @return  {Object}  err                           请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                          返回的数据
 *     @return  {Object}  data.ListBucketResult     返回的 object 列表信息
 */
function getBucket(params, callback) {
  var reqParams = {};
  reqParams['prefix'] = params['Prefix'] || '';
  reqParams['delimiter'] = params['Delimiter'];
  reqParams['marker'] = params['Marker'];
  reqParams['max-keys'] = params['MaxKeys'];
  reqParams['encoding-type'] = params['EncodingType'];

  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucket',
      ResourceKey: reqParams['prefix'],
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      qs: reqParams,
    },
    function (err, data) {
      if (err) return callback(err);
      var ListBucketResult = data.ListBucketResult || {};
      var Contents = ListBucketResult.Contents || [];
      var CommonPrefixes = ListBucketResult.CommonPrefixes || [];

      Contents = util.isArray(Contents) ? Contents : [Contents];
      CommonPrefixes = util.isArray(CommonPrefixes) ? CommonPrefixes : [CommonPrefixes];

      var result = util.clone(ListBucketResult);
      util.extend(result, {
        Contents: Contents,
        CommonPrefixes: CommonPrefixes,
        statusCode: data.statusCode,
        headers: data.headers,
      });

      callback(null, result);
    }
  );
}

/**
 * 删除 Bucket
 * @param  {Object}  params                 参数对象，必须
 *     @param  {String}  params.Bucket      Bucket名称，必须
 *     @param  {String}  params.Region      地域名称，必须
 * @param  {Function}  callback             回调函数，必须
 * @return  {Object}  err                   请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                  返回的数据
 *     @return  {String}  data.Location     操作地址
 */
function deleteBucket(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:DeleteBucket',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      method: 'DELETE',
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 设置 Bucket 的 权限列表
 * @param  {Object}  params                         参数对象，必须
 *     @param  {String}  params.Bucket              Bucket名称，必须
 *     @param  {String}  params.Region              地域名称，必须
 *     @param  {String}  params.ACL                 用户自定义文件权限，可以设置：private，public-read；默认值：private，非必须
 *     @param  {String}  params.GrantRead           赋予被授权者读的权限，格式x-cos-grant-read: uin=" ",uin=" "，非必须
 *     @param  {String}  params.GrantWrite          赋予被授权者写的权限，格式x-cos-grant-write: uin=" ",uin=" "，非必须
 *     @param  {String}  params.GrantFullControl    赋予被授权者读写权限，格式x-cos-grant-full-control: uin=" ",uin=" "，非必须
 * @param  {Function}  callback                     回调函数，必须
 * @return  {Object}  err                           请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                          返回的数据
 */
function putBucketAcl(params, callback) {
  var headers = params.Headers;

  var xml = '';
  if (params['AccessControlPolicy']) {
    var AccessControlPolicy = util.clone(params['AccessControlPolicy'] || {});
    var Grants = AccessControlPolicy.Grants || AccessControlPolicy.Grant;
    Grants = util.isArray(Grants) ? Grants : [Grants];
    delete AccessControlPolicy.Grant;
    delete AccessControlPolicy.Grants;
    AccessControlPolicy.AccessControlList = { Grant: Grants };
    xml = util.json2xml({ AccessControlPolicy: AccessControlPolicy });

    headers['Content-Type'] = 'application/xml';
    headers['Content-MD5'] = util.binaryBase64(util.md5(xml));
  }

  // Grant Header 去重
  util.each(headers, function (val, key) {
    if (key.indexOf('x-cos-grant-') === 0) {
      headers[key] = uniqGrant(headers[key]);
    }
  });

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketACL',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: headers,
      action: 'acl',
      body: xml,
    },
    function (err, data) {
      if (err) return callback(err);
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 获取 Bucket 的 权限列表
 * @param  {Object}  params                         参数对象，必须
 *     @param  {String}  params.Bucket              Bucket名称，必须
 *     @param  {String}  params.Region              地域名称，必须
 * @param  {Function}  callback                     回调函数，必须
 * @return  {Object}  err                           请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                          返回的数据
 *     @return  {Object}  data.AccessControlPolicy  访问权限信息
 */
function getBucketAcl(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketACL',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'acl',
    },
    function (err, data) {
      if (err) return callback(err);
      var AccessControlPolicy = data.AccessControlPolicy || {};
      var Owner = AccessControlPolicy.Owner || {};
      var Grant = (AccessControlPolicy.AccessControlList && AccessControlPolicy.AccessControlList.Grant) || [];
      Grant = util.isArray(Grant) ? Grant : [Grant];
      var result = decodeAcl(AccessControlPolicy);
      if (data.headers && data.headers['x-cos-acl']) {
        result.ACL = data.headers['x-cos-acl'];
      }
      result = util.extend(result, {
        Owner: Owner,
        Grants: Grant,
        statusCode: data.statusCode,
        headers: data.headers,
      });
      callback(null, result);
    }
  );
}

/**
 * 设置 Bucket 的 跨域设置
 * @param  {Object}  params                             参数对象，必须
 *     @param  {String}  params.Bucket                  Bucket名称，必须
 *     @param  {String}  params.Region                  地域名称，必须
 *     @param  {Object}  params.CORSConfiguration       相关的跨域设置，必须
 * @param  {Array}  params.CORSConfiguration.CORSRules  对应的跨域规则
 * @param  {Function}  callback                         回调函数，必须
 * @return  {Object}  err                               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                              返回的数据
 */
function putBucketCors(params, callback) {
  var CORSConfiguration = params['CORSConfiguration'] || {};
  var CORSRules = CORSConfiguration['CORSRules'] || params['CORSRules'] || [];
  CORSRules = util.clone(util.isArray(CORSRules) ? CORSRules : [CORSRules]);
  util.each(CORSRules, function (rule) {
    util.each(['AllowedOrigin', 'AllowedHeader', 'AllowedMethod', 'ExposeHeader'], function (key) {
      var sKey = key + 's';
      var val = rule[sKey] || rule[key] || [];
      delete rule[sKey];
      rule[key] = util.isArray(val) ? val : [val];
    });
  });

  var Conf = { CORSRule: CORSRules };
  if (params.ResponseVary) Conf.ResponseVary = params.ResponseVary;

  var xml = util.json2xml({ CORSConfiguration: Conf });

  var headers = params.Headers;
  headers['Content-Type'] = 'application/xml';
  headers['Content-MD5'] = util.binaryBase64(util.md5(xml));

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketCORS',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      body: xml,
      action: 'cors',
      headers: headers,
    },
    function (err, data) {
      if (err) return callback(err);
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 获取 Bucket 的 跨域设置
 * @param  {Object}  params                         参数对象，必须
 *     @param  {String}  params.Bucket              Bucket名称，必须
 *     @param  {String}  params.Region              地域名称，必须
 * @param  {Function}  callback                     回调函数，必须
 * @return  {Object}  err                           请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                          返回的数据
 *     @return  {Object}  data.CORSRules            Bucket的跨域设置
 */
function getBucketCors(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketCORS',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'cors',
    },
    function (err, data) {
      if (err) {
        if (err.statusCode === 404 && err.error && err.error.Code === 'NoSuchCORSConfiguration') {
          var result = {
            CORSRules: [],
            statusCode: err.statusCode,
          };
          err.headers && (result.headers = err.headers);
          callback(null, result);
        } else {
          callback(err);
        }
        return;
      }
      var CORSConfiguration = data.CORSConfiguration || {};
      var CORSRules = CORSConfiguration.CORSRules || CORSConfiguration.CORSRule || [];
      CORSRules = util.clone(util.isArray(CORSRules) ? CORSRules : [CORSRules]);
      var ResponseVary = CORSConfiguration.ResponseVary;

      util.each(CORSRules, function (rule) {
        util.each(['AllowedOrigin', 'AllowedHeader', 'AllowedMethod', 'ExposeHeader'], function (key) {
          var sKey = key + 's';
          var val = rule[sKey] || rule[key] || [];
          delete rule[key];
          rule[sKey] = util.isArray(val) ? val : [val];
        });
      });

      callback(null, {
        CORSRules: CORSRules,
        ResponseVary: ResponseVary,
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 删除 Bucket 的 跨域设置
 * @param  {Object}  params                 参数对象，必须
 *     @param  {String}  params.Bucket      Bucket名称，必须
 *     @param  {String}  params.Region      地域名称，必须
 * @param  {Function}  callback             回调函数，必须
 * @return  {Object}  err                   请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                  返回的数据
 */
function deleteBucketCors(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:DeleteBucketCORS',
      method: 'DELETE',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'cors',
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode || err.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 获取 Bucket 的 地域信息
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据，包含地域信息 LocationConstraint
 */
function getBucketLocation(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketLocation',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'location',
    },
    callback
  );
}

function putBucketPolicy(params, callback) {
  var Policy = params['Policy'];
  try {
    if (typeof Policy === 'string') Policy = JSON.parse(Policy);
  } catch (e) {}
  if (!Policy || typeof Policy === 'string') return callback(util.error(new Error('Policy format error')));
  var PolicyStr = JSON.stringify(Policy);
  if (!Policy.version) Policy.version = '2.0';

  var headers = params.Headers;
  headers['Content-Type'] = 'application/json';
  headers['Content-MD5'] = util.binaryBase64(util.md5(PolicyStr));

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketPolicy',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      action: 'policy',
      body: PolicyStr,
      headers: headers,
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 获取 Bucket 的读取权限策略
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据
 */
function getBucketPolicy(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketPolicy',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'policy',
      rawBody: true,
    },
    function (err, data) {
      if (err) {
        if (err.statusCode && err.statusCode === 403) {
          return callback(util.error(err, { ErrorStatus: 'Access Denied' }));
        }
        if (err.statusCode && err.statusCode === 405) {
          return callback(util.error(err, { ErrorStatus: 'Method Not Allowed' }));
        }
        if (err.statusCode && err.statusCode === 404) {
          return callback(util.error(err, { ErrorStatus: 'Policy Not Found' }));
        }
        return callback(err);
      }
      var Policy = {};
      try {
        Policy = JSON.parse(data.body);
      } catch (e) {}
      callback(null, {
        Policy: Policy,
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 删除 Bucket 的 跨域设置
 * @param  {Object}  params                 参数对象，必须
 *     @param  {String}  params.Bucket      Bucket名称，必须
 *     @param  {String}  params.Region      地域名称，必须
 * @param  {Function}  callback             回调函数，必须
 * @return  {Object}  err                   请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                  返回的数据
 */
function deleteBucketPolicy(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:DeleteBucketPolicy',
      method: 'DELETE',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'policy',
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode || err.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 设置 Bucket 的标签
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 *     @param  {Array}   params.TagSet  标签设置，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据
 */
function putBucketTagging(params, callback) {
  var Tagging = params['Tagging'] || {};
  var Tags = Tagging.TagSet || Tagging.Tags || params['Tags'] || [];
  Tags = util.clone(util.isArray(Tags) ? Tags : [Tags]);
  var xml = util.json2xml({ Tagging: { TagSet: { Tag: Tags } } });

  var headers = params.Headers;
  headers['Content-Type'] = 'application/xml';
  headers['Content-MD5'] = util.binaryBase64(util.md5(xml));

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketTagging',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      body: xml,
      action: 'tagging',
      headers: headers,
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 获取 Bucket 的标签设置
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据
 */
function getBucketTagging(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketTagging',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'tagging',
    },
    function (err, data) {
      if (err) {
        if (err.statusCode === 404 && err.error && (err.error === 'Not Found' || err.error.Code === 'NoSuchTagSet')) {
          var result = {
            Tags: [],
            statusCode: err.statusCode,
          };
          err.headers && (result.headers = err.headers);
          callback(null, result);
        } else {
          callback(err);
        }
        return;
      }
      var Tags = [];
      try {
        Tags = data.Tagging.TagSet.Tag || [];
      } catch (e) {}
      Tags = util.clone(util.isArray(Tags) ? Tags : [Tags]);
      callback(null, {
        Tags: Tags,
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 删除 Bucket 的 标签设置
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回的数据
 */
function deleteBucketTagging(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:DeleteBucketTagging',
      method: 'DELETE',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'tagging',
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

function putBucketLifecycle(params, callback) {
  var LifecycleConfiguration = params['LifecycleConfiguration'] || {};
  var Rules = LifecycleConfiguration.Rules || params.Rules || [];
  Rules = util.clone(Rules);
  var xml = util.json2xml({ LifecycleConfiguration: { Rule: Rules } });

  var headers = params.Headers;
  headers['Content-Type'] = 'application/xml';
  headers['Content-MD5'] = util.binaryBase64(util.md5(xml));

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketLifecycle',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      body: xml,
      action: 'lifecycle',
      headers: headers,
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

function getBucketLifecycle(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketLifecycle',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'lifecycle',
    },
    function (err, data) {
      if (err) {
        if (err.statusCode === 404 && err.error && err.error.Code === 'NoSuchLifecycleConfiguration') {
          var result = {
            Rules: [],
            statusCode: err.statusCode,
          };
          err.headers && (result.headers = err.headers);
          callback(null, result);
        } else {
          callback(err);
        }
        return;
      }
      var Rules = [];
      try {
        Rules = data.LifecycleConfiguration.Rule || [];
      } catch (e) {}
      Rules = util.clone(util.isArray(Rules) ? Rules : [Rules]);
      callback(null, {
        Rules: Rules,
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

function deleteBucketLifecycle(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:DeleteBucketLifecycle',
      method: 'DELETE',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'lifecycle',
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

function putBucketVersioning(params, callback) {
  if (!params['VersioningConfiguration']) {
    callback(util.error(new Error('missing param VersioningConfiguration')));
    return;
  }
  var VersioningConfiguration = params['VersioningConfiguration'] || {};
  var xml = util.json2xml({ VersioningConfiguration: VersioningConfiguration });

  var headers = params.Headers;
  headers['Content-Type'] = 'application/xml';
  headers['Content-MD5'] = util.binaryBase64(util.md5(xml));

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketVersioning',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      body: xml,
      action: 'versioning',
      headers: headers,
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

function getBucketVersioning(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketVersioning',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'versioning',
    },
    function (err, data) {
      if (!err) {
        !data.VersioningConfiguration && (data.VersioningConfiguration = {});
      }
      callback(err, data);
    }
  );
}

function putBucketReplication(params, callback) {
  var ReplicationConfiguration = util.clone(params.ReplicationConfiguration);
  var xml = util.json2xml({ ReplicationConfiguration: ReplicationConfiguration });
  xml = xml.replace(/<(\/?)Rules>/gi, '<$1Rule>');
  xml = xml.replace(/<(\/?)Tags>/gi, '<$1Tag>');

  var headers = params.Headers;
  headers['Content-Type'] = 'application/xml';
  headers['Content-MD5'] = util.binaryBase64(util.md5(xml));

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketReplication',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      body: xml,
      action: 'replication',
      headers: headers,
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

function getBucketReplication(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketReplication',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'replication',
    },
    function (err, data) {
      if (err) {
        if (
          err.statusCode === 404 &&
          err.error &&
          (err.error === 'Not Found' || err.error.Code === 'ReplicationConfigurationnotFoundError')
        ) {
          var result = {
            ReplicationConfiguration: { Rules: [] },
            statusCode: err.statusCode,
          };
          err.headers && (result.headers = err.headers);
          callback(null, result);
        } else {
          callback(err);
        }
        return;
      }
      if (!err) {
        !data.ReplicationConfiguration && (data.ReplicationConfiguration = {});
      }
      if (data.ReplicationConfiguration.Rule) {
        data.ReplicationConfiguration.Rules = util.makeArray(data.ReplicationConfiguration.Rule);
        delete data.ReplicationConfiguration.Rule;
      }
      callback(err, data);
    }
  );
}

function deleteBucketReplication(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:DeleteBucketReplication',
      method: 'DELETE',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'replication',
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 设置 Bucket 静态网站配置信息
 * @param  {Object}  params                                                 参数对象，必须
 *     @param  {String}  params.Bucket                                      Bucket名称，必须
 *     @param  {String}  params.Region                                      地域名称，必须
 *     @param  {Object}  params.WebsiteConfiguration                        地域名称，必须
 *         @param  {Object}   WebsiteConfiguration.IndexDocument            索引文档，必须
 *         @param  {Object}   WebsiteConfiguration.ErrorDocument            错误文档，非必须
 *         @param  {Object}   WebsiteConfiguration.RedirectAllRequestsTo    重定向所有请求，非必须
 *         @param  {Array}   params.RoutingRules                            重定向规则，非必须
 * @param  {Function}  callback                                             回调函数，必须
 * @return  {Object}  err                                                   请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                                                  返回数据
 */
function putBucketWebsite(params, callback) {
  if (!params['WebsiteConfiguration']) {
    callback(util.error(new Error('missing param WebsiteConfiguration')));
    return;
  }

  var WebsiteConfiguration = util.clone(params['WebsiteConfiguration'] || {});
  var RoutingRules = WebsiteConfiguration['RoutingRules'] || WebsiteConfiguration['RoutingRule'] || [];
  RoutingRules = util.isArray(RoutingRules) ? RoutingRules : [RoutingRules];
  delete WebsiteConfiguration.RoutingRule;
  delete WebsiteConfiguration.RoutingRules;
  if (RoutingRules.length) WebsiteConfiguration.RoutingRules = { RoutingRule: RoutingRules };
  var xml = util.json2xml({ WebsiteConfiguration: WebsiteConfiguration });

  var headers = params.Headers;
  headers['Content-Type'] = 'application/xml';
  headers['Content-MD5'] = util.binaryBase64(util.md5(xml));

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketWebsite',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      body: xml,
      action: 'website',
      headers: headers,
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 获取 Bucket 的静态网站配置信息
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据
 */
function getBucketWebsite(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketWebsite',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      Key: params.Key,
      headers: params.Headers,
      action: 'website',
    },
    function (err, data) {
      if (err) {
        if (err.statusCode === 404 && err.error.Code === 'NoSuchWebsiteConfiguration') {
          var result = {
            WebsiteConfiguration: {},
            statusCode: err.statusCode,
          };
          err.headers && (result.headers = err.headers);
          callback(null, result);
        } else {
          callback(err);
        }
        return;
      }

      var WebsiteConfiguration = data.WebsiteConfiguration || {};
      if (WebsiteConfiguration['RoutingRules']) {
        var RoutingRules = util.clone(WebsiteConfiguration['RoutingRules'].RoutingRule || []);
        RoutingRules = util.makeArray(RoutingRules);
        WebsiteConfiguration.RoutingRules = RoutingRules;
      }

      callback(null, {
        WebsiteConfiguration: WebsiteConfiguration,
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 删除 Bucket 的静态网站配置
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据
 */
function deleteBucketWebsite(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:DeleteBucketWebsite',
      method: 'DELETE',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'website',
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 设置 Bucket 的防盗链白名单或者黑名单
 * @param  {Object}  params                                                 参数对象，必须
 *     @param  {String}  params.Bucket                                      Bucket名称，必须
 *     @param  {String}  params.Region                                      地域名称，必须
 *     @param  {Object}  params.RefererConfiguration                        地域名称，必须
 *         @param  {String}   RefererConfiguration.Status                   是否开启防盗链，枚举值：Enabled、Disabled
 *         @param  {String}   RefererConfiguration.RefererType              防盗链类型，枚举值：Black-List、White-List，必须
 *         @param  {Array}   RefererConfiguration.DomianList.Domain         生效域名，必须
 *         @param  {String}   RefererConfiguration.EmptyReferConfiguration  ，非必须
 * @param  {Function}  callback                                             回调函数，必须
 * @return  {Object}  err                                                   请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                                                  返回数据
 */
function putBucketReferer(params, callback) {
  if (!params['RefererConfiguration']) {
    callback(util.error(new Error('missing param RefererConfiguration')));
    return;
  }

  var RefererConfiguration = util.clone(params['RefererConfiguration'] || {});
  var DomainList = RefererConfiguration['DomainList'] || {};
  var Domains = DomainList['Domains'] || DomainList['Domain'] || [];
  Domains = util.isArray(Domains) ? Domains : [Domains];
  if (Domains.length) RefererConfiguration.DomainList = { Domain: Domains };
  var xml = util.json2xml({ RefererConfiguration: RefererConfiguration });

  var headers = params.Headers;
  headers['Content-Type'] = 'application/xml';
  headers['Content-MD5'] = util.binaryBase64(util.md5(xml));

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketReferer',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      body: xml,
      action: 'referer',
      headers: headers,
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 获取 Bucket 的防盗链白名单或者黑名单
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据
 */
function getBucketReferer(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketReferer',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      Key: params.Key,
      headers: params.Headers,
      action: 'referer',
    },
    function (err, data) {
      if (err) {
        if (err.statusCode === 404 && err.error.Code === 'NoSuchRefererConfiguration') {
          var result = {
            WebsiteConfiguration: {},
            statusCode: err.statusCode,
          };
          err.headers && (result.headers = err.headers);
          callback(null, result);
        } else {
          callback(err);
        }
        return;
      }

      var RefererConfiguration = data.RefererConfiguration || {};
      if (RefererConfiguration['DomainList']) {
        var Domains = util.makeArray(RefererConfiguration['DomainList'].Domain || []);
        RefererConfiguration.DomainList = { Domains: Domains };
      }

      callback(null, {
        RefererConfiguration: RefererConfiguration,
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 设置 Bucket 自定义域名
 * @param  {Object}  params                                                 参数对象，必须
 *     @param  {String}  params.Bucket                                      Bucket名称，必须
 *     @param  {String}  params.Region                                      地域名称，必须
 * @param  {Function}  callback                                             回调函数，必须
 * @return  {Object}  err                                                   请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                                                  返回数据
 */
function putBucketDomain(params, callback) {
  var DomainConfiguration = params['DomainConfiguration'] || {};
  var DomainRule = DomainConfiguration.DomainRule || params.DomainRule || [];
  DomainRule = util.clone(DomainRule);
  var xml = util.json2xml({ DomainConfiguration: { DomainRule: DomainRule } });

  var headers = params.Headers;
  headers['Content-Type'] = 'application/xml';
  headers['Content-MD5'] = util.binaryBase64(util.md5(xml));

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketDomain',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      body: xml,
      action: 'domain',
      headers: headers,
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 获取 Bucket 的自定义域名
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据
 */
function getBucketDomain(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketDomain',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'domain',
    },
    function (err, data) {
      if (err) return callback(err);

      var DomainRule = [];
      try {
        DomainRule = data.DomainConfiguration.DomainRule || [];
      } catch (e) {}
      DomainRule = util.clone(util.isArray(DomainRule) ? DomainRule : [DomainRule]);
      callback(null, {
        DomainRule: DomainRule,
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 删除 Bucket 自定义域名
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据
 */
function deleteBucketDomain(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:DeleteBucketDomain',
      method: 'DELETE',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'domain',
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 设置 Bucket 的回源
 * @param  {Object}  params                                                 参数对象，必须
 *     @param  {String}  params.Bucket                                      Bucket名称，必须
 *     @param  {String}  params.Region                                      地域名称，必须
 * @param  {Function}  callback                                             回调函数，必须
 * @return  {Object}  err                                                   请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                                                  返回数据
 */
function putBucketOrigin(params, callback) {
  var OriginConfiguration = params['OriginConfiguration'] || {};
  var OriginRule = OriginConfiguration.OriginRule || params.OriginRule || [];
  OriginRule = util.clone(OriginRule);
  var xml = util.json2xml({ OriginConfiguration: { OriginRule: OriginRule } });

  var headers = params.Headers;
  headers['Content-Type'] = 'application/xml';
  headers['Content-MD5'] = util.binaryBase64(util.md5(xml));

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketOrigin',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      body: xml,
      action: 'origin',
      headers: headers,
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 获取 Bucket 的回源
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据
 */
function getBucketOrigin(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketOrigin',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'origin',
    },
    function (err, data) {
      if (err) return callback(err);

      var OriginRule = [];
      try {
        OriginRule = data.OriginConfiguration.OriginRule || [];
      } catch (e) {}
      OriginRule = util.clone(util.isArray(OriginRule) ? OriginRule : [OriginRule]);
      callback(null, {
        OriginRule: OriginRule,
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 删除 Bucket 的回源
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据
 */
function deleteBucketOrigin(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:DeleteBucketOrigin',
      method: 'DELETE',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'origin',
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 设置 Bucket 的日志记录
 * @param  {Object}  params                                                 参数对象，必须
 *     @param  {String}  params.Bucket                                      Bucket名称，必须
 *     @param  {String}  params.Region                                      地域名称，必须
 *     @param  {(Object|String)}  params.BucketLoggingStatus                         说明日志记录配置的状态，如果无子节点信息则意为关闭日志记录，必须
 * @param  {Function}  callback                                             回调函数，必须
 * @return  {Object}  err                                                   请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data                                                  返回数据
 */
function putBucketLogging(params, callback) {
  var xml = util.json2xml({
    BucketLoggingStatus: params['BucketLoggingStatus'] || '',
  });

  var headers = params.Headers;
  headers['Content-Type'] = 'application/xml';
  headers['Content-MD5'] = util.binaryBase64(util.md5(xml));

  submitRequest.call(
    this,
    {
      Action: 'name/cos:PutBucketLogging',
      method: 'PUT',
      Bucket: params.Bucket,
      Region: params.Region,
      body: xml,
      action: 'logging',
      headers: headers,
    },
    function (err, data) {
      if (err && err.statusCode === 204) {
        return callback(null, { statusCode: err.statusCode });
      } else if (err) {
        return callback(err);
      }
      callback(null, {
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 获取 Bucket 的日志记录
 * @param  {Object}  params             参数对象，必须
 *     @param  {String}  params.Bucket  Bucket名称，必须
 *     @param  {String}  params.Region  地域名称，必须
 * @param  {Function}  callback         回调函数，必须
 * @return  {Object}  err               请求失败的错误，如果请求成功，则为空。https://cloud.tencent.com/document/product/436/7730
 * @return  {Object}  data              返回数据
 */
function getBucketLogging(params, callback) {
  submitRequest.call(
    this,
    {
      Action: 'name/cos:GetBucketLogging',
      method: 'GET',
      Bucket: params.Bucket,
      Region: params.Region,
      headers: params.Headers,
      action: 'logging',
    },
    function (err, data) {
      if (err) return callback(err);
      callback(null, {
        BucketLoggingStatus: data.BucketLoggingStatus,
        statusCode: data.statusCode,
        headers: data.headers,
      });
    }
  );
}

/**
 * 创建/编辑 Bucket 的清单任务
 * @param  {Object}  params