def closeConnectionPool()

in src/main/scala/com/gu/fastly/api/FastlyApiClient.scala [231:290]
49 lines of code
10 McCabe index (conditional complexity)

  def closeConnectionPool() = AsyncHttpExecutor.close()

  private object AsyncHttpExecutor {

    private lazy val defaultConfig = new DefaultAsyncHttpClientConfig.Builder()
      .setMaxConnections(50)
      .setMaxRequestRetry(3)
      .setRequestTimeout(Duration.ofMillis(20000))
      .build()

    private lazy val client = asyncHttpClient(config.getOrElse(defaultConfig))

    def close() = client.close()

    def execute(apiUrl: String,
                method: HttpMethod = GET,
                headers: Map[String, String] = Map.empty,
                parameters: Map[String, String] = Map.empty,
                part: Option[Part] = None) : Future[Response] = {
      val request = method match {
        case POST => client.preparePost(apiUrl)
        case PUT => client.preparePut(apiUrl)
        case DELETE => client.prepareDelete(apiUrl)
        case GET => client.prepareGet(apiUrl)
      }
      build(request, headers, parameters, part)

      proxyServer.map(request.setProxyServer)

      val p = Promise[Response]()
      val handler = new AsyncCompletionHandler[Unit] {
        def onCompleted(response: Response) = p.complete(Success(response))
      }
      request.execute(handler)
      p.future
    }

    private def build(request: BoundRequestBuilder,
                      headers: Map[String, String],
                      parameters: Map[String, String] = Map.empty,
                      maybePart: Option[Part] = None): Option[BoundRequestBuilder] = {

      headers.foreach {
        case (header, value) => request.addHeader(header, value)
      }

      request.build().getMethod match {
        case "GET" =>
          import scala.jdk.CollectionConverters.*
          val params = parameters.toList.map{case (name, value) => new Param(name, value)}.asJava
          request.setQueryParams(params)
        case _ =>
          val body = parameters.toList.map{case (name, value) => s"$name=$value"}.mkString("&")
          request.setBody(body)
          maybePart.map { part => request.addBodyPart(part) }
      }

      headers.get("Host").map(h => request.setVirtualHost(h))
    }
  }