GetLiveChannelHistoryResponse Alibabacloud_OSS::Client::getLiveChannelHistory()

in cpp/src/oss.cpp [3617:3744]
128 lines of code
11 McCabe index (conditional complexity)

GetLiveChannelHistoryResponse Alibabacloud_OSS::Client::getLiveChannelHistory(
    shared_ptr<GetLiveChannelHistoryRequest> request,
    shared_ptr<Alibabacloud_OSSUtil::RuntimeOptions> runtime) {
  request->validate();
  runtime->validate();
  shared_ptr<map<string, boost::any>> runtime_ = make_shared<
      map<string, boost::any>>(map<string, boost::any>(
      {{"timeouted", boost::any(string("retry"))},
       {"readTimeout", boost::any(Darabonba_Util::Client::defaultNumber(
                           runtime->readTimeout, _readTimeout))},
       {"connectTimeout", boost::any(Darabonba_Util::Client::defaultNumber(
                              runtime->connectTimeout, _connectTimeout))},
       {"localAddr", boost::any(string(Darabonba_Util::Client::defaultString(
                         runtime->localAddr, _localAddr)))},
       {"httpProxy", boost::any(string(Darabonba_Util::Client::defaultString(
                         runtime->httpProxy, _httpProxy)))},
       {"httpsProxy", boost::any(string(Darabonba_Util::Client::defaultString(
                          runtime->httpsProxy, _httpsProxy)))},
       {"noProxy", boost::any(string(Darabonba_Util::Client::defaultString(
                       runtime->noProxy, _noProxy)))},
       {"socks5Proxy", boost::any(string(Darabonba_Util::Client::defaultString(
                           runtime->socks5Proxy, _socks5Proxy)))},
       {"socks5NetWork",
        boost::any(string(Darabonba_Util::Client::defaultString(
            runtime->socks5NetWork, _socks5NetWork)))},
       {"maxIdleConns", boost::any(Darabonba_Util::Client::defaultNumber(
                            runtime->maxIdleConns, _maxIdleConns))},
       {"retry", boost::any(map<string, boost::any>(
                     {{"retryable", !runtime->autoretry
                                        ? boost::any()
                                        : boost::any(*runtime->autoretry)},
                      {"maxAttempts",
                       boost::any(Darabonba_Util::Client::defaultNumber(
                           runtime->maxAttempts, make_shared<int>(3)))}}))},
       {"backoff",
        boost::any(map<string, boost::any>(
            {{"policy",
              boost::any(string(Darabonba_Util::Client::defaultString(
                  runtime->backoffPolicy, make_shared<string>("no"))))},
             {"period", boost::any(Darabonba_Util::Client::defaultNumber(
                            runtime->backoffPeriod, make_shared<int>(1)))}}))},
       {"ignoreSSL", !runtime->ignoreSSL ? boost::any()
                                         : boost::any(*runtime->ignoreSSL)}}));
  shared_ptr<Darabonba::Request> _lastRequest;
  shared_ptr<std::exception> _lastException;
  shared_ptr<int> _now = make_shared<int>(0);
  shared_ptr<int> _retryTimes = make_shared<int>(0);
  while (Darabonba::Core::allowRetry(
      make_shared<boost::any>((*runtime_)["retry"]), _retryTimes, _now)) {
    if (*_retryTimes > 0) {
      shared_ptr<int> _backoffTime =
          make_shared<int>(Darabonba::Core::getBackoffTime(
              make_shared<boost::any>((*runtime_)["backoff"]), _retryTimes));
      if (*_backoffTime > 0) {
        Darabonba::Core::sleep(_backoffTime);
      }
    }
    _retryTimes = make_shared<int>(*_retryTimes + 1);
    try {
      shared_ptr<Darabonba::Request> request_ =
          make_shared<Darabonba::Request>();
      shared_ptr<string> accessKeyId =
          make_shared<string>(_credential->getAccessKeyId());
      shared_ptr<string> accessKeySecret =
          make_shared<string>(_credential->getAccessKeySecret());
      shared_ptr<string> token =
          make_shared<string>(_credential->getSecurityToken());
      request_->protocol = *_protocol;
      request_->method = "GET";
      request_->pathname =
          string("/") + string(*request->channelName) + string("?live");
      request_->headers = {
          {"host", Alibabacloud_OSSUtil::Client::getHost(
                       request->bucketName, _regionId, _endpoint, _hostModel)},
          {"date", Darabonba_Util::Client::getDateUTCString()},
          {"user-agent", getUserAgent()}};
      if (!Darabonba_Util::Client::empty(token)) {
        request_->headers.insert(
            pair<string, string>("x-oss-security-token", *token));
      }
      request_->query = Darabonba_Util::Client::stringifyMapValue(
          make_shared<map<string, boost::any>>(request->filter->toMap()));
      request_->headers.insert(pair<string, string>(
          "authorization",
          Alibabacloud_OSSUtil::Client::getSignature(
              request_, request->bucketName, accessKeyId, accessKeySecret,
              _signatureVersion, _addtionalHeaders)));
      _lastRequest = request_;
      shared_ptr<Darabonba::Response> response_ =
          make_shared<Darabonba::Response>(
              Darabonba::Core::doAction(request_, runtime_));
      shared_ptr<map<string, boost::any>> respMap;
      shared_ptr<string> bodyStr;
      if (Darabonba_Util::Client::is4xx(
              make_shared<int>(response_->statusCode)) ||
          Darabonba_Util::Client::is5xx(
              make_shared<int>(response_->statusCode))) {
        bodyStr = make_shared<string>(
            Darabonba_Util::Client::readAsString(response_->body));
        respMap = make_shared<map<string, boost::any>>(
            Alibabacloud_OSSUtil::Client::getErrMessage(bodyStr));
        BOOST_THROW_EXCEPTION(Darabonba::Error(map<string, boost::any>(
            {{"code", (*respMap)["Code"]},
             {"message", (*respMap)["Message"]},
             {"data", boost::any(map<string, boost::any>(
                          {{"httpCode", boost::any(response_->statusCode)},
                           {"requestId", (*respMap)["RequestId"]},
                           {"hostId", (*respMap)["HostId"]}}))}})));
      }
      bodyStr = make_shared<string>(
          Darabonba_Util::Client::readAsString(response_->body));
      respMap = make_shared<map<string, boost::any>>(
          Darabonba_XML::Client::parseXml(bodyStr, nullptr));
      return GetLiveChannelHistoryResponse(Darabonba::Converter::merge(
          map<string, boost::any>(
              {{"LiveChannelHistory", (*respMap)["LiveChannelHistory"]}}),
          Darabonba::Converter::toGenericMap(response_->headers)));
    } catch (std::exception &e) {
      if (Darabonba::Core::isRetryable(e)) {
        _lastException = make_shared<std::exception>(e);
        continue;
      }
      BOOST_THROW_EXCEPTION(e);
    }
  }
  BOOST_THROW_EXCEPTION(
      Darabonba::UnretryableError(_lastRequest, _lastException));
}