async execute()

in ts/src/client.ts [1175:1323]
135 lines of code
26 McCabe index (conditional complexity)

  async execute(params: $OpenApiUtil.Params, request: $OpenApiUtil.OpenApiRequest, runtime: $dara.RuntimeOptions): Promise<{[key: string]: any}> {
    let _runtime: { [key: string]: any } = {
      key: runtime.key || this._key,
      cert: runtime.cert || this._cert,
      ca: runtime.ca || this._ca,
      readTimeout: runtime.readTimeout || this._readTimeout,
      connectTimeout: runtime.connectTimeout || this._connectTimeout,
      httpProxy: runtime.httpProxy || this._httpProxy,
      httpsProxy: runtime.httpsProxy || this._httpsProxy,
      noProxy: runtime.noProxy || this._noProxy,
      socks5Proxy: runtime.socks5Proxy || this._socks5Proxy,
      socks5NetWork: runtime.socks5NetWork || this._socks5NetWork,
      maxIdleConns: runtime.maxIdleConns || this._maxIdleConns,
      retryOptions: this._retryOptions,
      ignoreSSL: runtime.ignoreSSL,
      tlsMinVersion: this._tlsMinVersion,
      disableHttp2: this._disableHttp2 || false,
    }

    let _retriesAttempted = 0;
    let _lastRequest = null, _lastResponse = null;
    let _context = new $dara.RetryPolicyContext({
      retriesAttempted: _retriesAttempted,
    });
    while ($dara.shouldRetry(_runtime['retryOptions'], _context)) {
      if (_retriesAttempted > 0) {
        let _backoffTime = $dara.getBackoffDelay(_runtime['retryOptions'], _context);
        if (_backoffTime > 0) {
          await $dara.sleep(_backoffTime);
        }
      }

      _retriesAttempted = _retriesAttempted + 1;
      try {
        let request_ = new $dara.Request();
        // spi = new Gateway();//Gateway implements SPI，这一步在产品 SDK 中实例化
        let headers = this.getRpcHeaders();
        let globalQueries : {[key: string ]: string} = { };
        let globalHeaders : {[key: string ]: string} = { };
        if (!$dara.isNull(this._globalParameters)) {
          let globalParams = this._globalParameters;
          if (!$dara.isNull(globalParams.queries)) {
            globalQueries = globalParams.queries;
          }

          if (!$dara.isNull(globalParams.headers)) {
            globalHeaders = globalParams.headers;
          }

        }

        let extendsHeaders : {[key: string ]: string} = { };
        let extendsQueries : {[key: string ]: string} = { };
        if (!$dara.isNull(runtime.extendsParameters)) {
          let extendsParameters = runtime.extendsParameters;
          if (!$dara.isNull(extendsParameters.headers)) {
            extendsHeaders = extendsParameters.headers;
          }

          if (!$dara.isNull(extendsParameters.queries)) {
            extendsQueries = extendsParameters.queries;
          }

        }

        let requestContext = new $SPI.InterceptorContextRequest({
          headers: {
            ...globalHeaders,
            ...extendsHeaders,
            ...request.headers,
            ...headers,
          },
          query: {
            ...globalQueries,
            ...extendsQueries,
            ...request.query,
          },
          body: request.body,
          stream: request.stream,
          hostMap: request.hostMap,
          pathname: params.pathname,
          productId: this._productId,
          action: params.action,
          version: params.version,
          protocol: this._protocol || params.protocol,
          method: this._method || params.method,
          authType: params.authType,
          bodyType: params.bodyType,
          reqBodyType: params.reqBodyType,
          style: params.style,
          credential: this._credential,
          signatureVersion: this._signatureVersion,
          signatureAlgorithm: this._signatureAlgorithm,
          userAgent: OpenApiUtil.getUserAgent(this._userAgent),
        });
        let configurationContext = new $SPI.InterceptorContextConfiguration({
          regionId: this._regionId,
          endpoint: request.endpointOverride || this._endpoint,
          endpointRule: this._endpointRule,
          endpointMap: this._endpointMap,
          endpointType: this._endpointType,
          network: this._network,
          suffix: this._suffix,
        });
        let interceptorContext = new $SPI.InterceptorContext({
          request: requestContext,
          configuration: configurationContext,
        });
        let attributeMap = new $SPI.AttributeMap({ });
        // 1. spi.modifyConfiguration(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
        await this._spi.modifyConfiguration(interceptorContext, attributeMap);
        // 2. spi.modifyRequest(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
        await this._spi.modifyRequest(interceptorContext, attributeMap);
        request_.protocol = interceptorContext.request.protocol;
        request_.method = interceptorContext.request.method;
        request_.pathname = interceptorContext.request.pathname;
        request_.query = interceptorContext.request.query;
        request_.body = interceptorContext.request.stream;
        request_.headers = interceptorContext.request.headers;
        let response_ = await $dara.doAction(request_, _runtime);
        _lastRequest = request_;
        _lastResponse = response_;

        let responseContext = new $SPI.InterceptorContextResponse({
          statusCode: response_.statusCode,
          headers: response_.headers,
          body: response_.body,
        });
        interceptorContext.response = responseContext;
        // 3. spi.modifyResponse(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
        await this._spi.modifyResponse(interceptorContext, attributeMap);
        return {
          headers: interceptorContext.response.headers,
          statusCode: interceptorContext.response.statusCode,
          body: interceptorContext.response.deserializedBody,
        };
      } catch (ex) {
        _context = new $dara.RetryPolicyContext({
          retriesAttempted : _retriesAttempted,
          httpRequest : _lastRequest,
          httpResponse : _lastResponse,
          exception : ex,
        });
        continue;
      }
    }

    throw $dara.newUnretryableError(_context);
  }