Make AbstractCurlBackend async friendly

core/src/main/scalanative/sttp/client4/curl/AbstractCurlBackend.scala

@@ -14,6 +14,7 @@ import sttp.monad.MonadError
 import sttp.monad.syntax._
 
 import scala.collection.immutable.Seq
+import scala.collection.mutable.ArrayBuffer
 import scala.io.Source
 import scala.scalanative.libc.stdio.{fclose, fopen, FILE}
 import scala.scalanative.libc.stdlib._
@@ -25,33 +26,68 @@ import scala.scalanative.unsigned._
 abstract class AbstractCurlBackend[F[_]](_monad: MonadError[F], verbose: Boolean) extends GenericBackend[F, Any] {
  override implicit def monad: MonadError[F] = _monad
 
+ /** Given a [[CurlHandle]], perform the request and return a [[CurlCode]]. */
+ protected def performCurl(c: CurlHandle): F[CurlCode]
+
+ /** Same as [[performCurl]], but also checks and throws runtime exceptions on bad [[CurlCode]]s. */
+ private final def perform(c: CurlHandle) = performCurl(c).flatMap(lift)
+
  type R = Any with Effect[F]
 
  override def close(): F[Unit] = monad.unit(())
 
- private var headers: CurlList = _
- private var multiPartHeaders: Seq[CurlList] = Seq()
+ /** A request-specific context, with allocated zones and headers. */
+ private class Context() {
+ implicit val zone: Zone = Zone.open()
+ private val headers = ArrayBuffer[CurlList]()
+
+ /** Create a new Headers list that gets cleaned up when the context is destroyed. */
+ def transformHeaders(reqHeaders: Iterable[Header]): CurlList = {
+ val h = reqHeaders
+ .map(header => s"${header.name}: ${header.value}")
+ .foldLeft(new CurlList(null)) { case (acc, h) =>
+ new CurlList(acc.ptr.append(h))
+ }
+ headers += h
+ h
+ }
+
+ def close() = {
+ zone.close()
+ headers.foreach(l => if (l.ptr != null) l.ptr.free())
+ }
+ }
+
+ private object Context {
+
+ /** Create a new context and evaluates the body with it. Closes the context at the end. */
+ def evaluateUsing[T](body: Context => F[T]): F[T] = {
+ implicit val ctx = new Context()
+ body(ctx).ensure(monad.unit(ctx.close()))
+ }
+ }
 
  override def send[T](request: GenericRequest[T, R]): F[Response[T]] =
  adjustExceptions(request) {
- unsafe.Zone { implicit z =>
+ def perform(implicit ctx: Context): F[Response[T]] = {
+ implicit val z = ctx.zone
  val curl = CurlApi.init
  if (verbose) {
  curl.option(Verbose, parameter = true)
  }
  if (request.tags.nonEmpty) {
- monad.error(new UnsupportedOperationException("Tags are not supported"))
+ return monad.error(new UnsupportedOperationException("Tags are not supported"))
  }
  val reqHeaders = request.headers
  if (reqHeaders.nonEmpty) {
  reqHeaders.find(_.name == "Accept-Encoding").foreach(h => curl.option(AcceptEncoding, h.value))
- request.body match {
+ val headers = request.body match {
  case _: MultipartBody[_] =>
- headers = transformHeaders(
+ ctx.transformHeaders(
  reqHeaders :+ Header.contentType(MediaType.MultipartFormData)
  )
  case _ =>
- headers = transformHeaders(reqHeaders)
+ ctx.transformHeaders(reqHeaders)
  }
  curl.option(HttpHeader, headers.ptr)
  }
@@ -62,6 +98,8 @@ abstract class AbstractCurlBackend[F[_]](_monad: MonadError[F], verbose: Boolean
  case None => handleBase(request, curl, spaces)
  }
  }
+
+ Context.evaluateUsing(ctx => perform(ctx))
  }
 
  private def adjustExceptions[T](request: GenericRequest[_, _])(t: => F[T]): F[T] =
@@ -70,22 +108,21 @@ abstract class AbstractCurlBackend[F[_]](_monad: MonadError[F], verbose: Boolean
  )
 
  private def handleBase[T](request: GenericRequest[T, R], curl: CurlHandle, spaces: CurlSpaces)(implicit
- z: unsafe.Zone
+ ctx: Context
  ) = {
+ implicit val z = ctx.zone
  curl.option(WriteFunction, AbstractCurlBackend.wdFunc)
  curl.option(WriteData, spaces.bodyResp)
  curl.option(TimeoutMs, request.options.readTimeout.toMillis)
  curl.option(HeaderData, spaces.headersResp)
  curl.option(Url, request.uri.toString)
  setMethod(curl, request.method)
  setRequestBody(curl, request.body)
- monad.flatMap(lift(curl.perform)) { _ =>
+ monad.flatMap(perform(curl)) { _ =>
  curl.info(ResponseCode, spaces.httpCode)
  val responseBody = fromCString((!spaces.bodyResp)._1)
  val responseHeaders_ = parseHeaders(fromCString((!spaces.headersResp)._1))
  val httpCode = StatusCode((!spaces.httpCode).toInt)
- if (headers.ptr != null) headers.ptr.free()
- multiPartHeaders.foreach(_.ptr.free())
  free((!spaces.bodyResp)._1)
  free((!spaces.headersResp)._1)
  free(spaces.bodyResp.asInstanceOf[Ptr[CSignedChar]])
@@ -112,19 +149,18 @@ abstract class AbstractCurlBackend[F[_]](_monad: MonadError[F], verbose: Boolean
  }
 
  private def handleFile[T](request: GenericRequest[T, R], curl: CurlHandle, file: SttpFile, spaces: CurlSpaces)(
- implicit z: unsafe.Zone
+ implicit ctx: Context
  ) = {
+ implicit val z = ctx.zone
  val outputPath = file.toPath.toString
  val outputFilePtr: Ptr[FILE] = fopen(toCString(outputPath), toCString("wb"))
  curl.option(WriteData, outputFilePtr)
  curl.option(Url, request.uri.toString)
  setMethod(curl, request.method)
  setRequestBody(curl, request.body)
- monad.flatMap(lift(curl.perform)) { _ =>
+ monad.flatMap(perform(curl)) { _ =>
  curl.info(ResponseCode, spaces.httpCode)
  val httpCode = StatusCode((!spaces.httpCode).toInt)
- if (headers.ptr != null) headers.ptr.free()
- multiPartHeaders.foreach(_.ptr.free())
  free(spaces.httpCode.asInstanceOf[Ptr[CSignedChar]])
  fclose(outputFilePtr)
  curl.cleanup()
@@ -159,7 +195,10 @@ abstract class AbstractCurlBackend[F[_]](_monad: MonadError[F], verbose: Boolean
  lift(m)
  }
 
- private def setRequestBody(curl: CurlHandle, body: GenericRequestBody[R])(implicit zone: Zone): F[CurlCode] =
+ private def setRequestBody(curl: CurlHandle, body: GenericRequestBody[R])(implicit
+ ctx: Context
+ ): F[CurlCode] = {
+ implicit val z = ctx.zone
  body match { // todo: assign to monad object
  case b: BasicBodyPart =>
  val str = basicBodyToString(b)
@@ -176,9 +215,8 @@ abstract class AbstractCurlBackend[F[_]](_monad: MonadError[F], verbose: Boolean
 
  val otherHeaders = headers.filterNot(_.is(HeaderNames.ContentType))
  if (otherHeaders.nonEmpty) {
- val curlList = transformHeaders(otherHeaders)
+ val curlList = ctx.transformHeaders(otherHeaders)
  part.withHeaders(curlList.ptr)
- multiPartHeaders = multiPartHeaders :+ curlList
  }
  }
  lift(curl.option(Mimepost, mime))
@@ -187,6 +225,7 @@ abstract class AbstractCurlBackend[F[_]](_monad: MonadError[F], verbose: Boolean
  case NoBody =>
  monad.unit(CurlCode.Ok)
  }
+ }
 
  private def basicBodyToString(body: BodyPart[_]): String =
  body match {
@@ -253,13 +292,6 @@ abstract class AbstractCurlBackend[F[_]](_monad: MonadError[F], verbose: Boolean
  override protected def cleanupWhenGotWebSocket(response: Nothing, e: GotAWebSocketException): F[Unit] = response
  }
 
- private def transformHeaders(reqHeaders: Iterable[Header])(implicit z: Zone): CurlList =
- reqHeaders
- .map(header => s"${header.name}: ${header.value}")
- .foldLeft(new CurlList(null)) { case (acc, h) =>
- new CurlList(acc.ptr.append(h))
- }
-
  private def toByteArray(str: String): F[Array[Byte]] = monad.unit(str.getBytes)
 
  private def lift(code: CurlCode): F[CurlCode] =
@@ -269,6 +301,12 @@ abstract class AbstractCurlBackend[F[_]](_monad: MonadError[F], verbose: Boolean
  }
 }
 
+/** Curl backends that performs the curl operation with a simple `curl_easy_perform`. */
+abstract class AbstractSyncCurlBackend[F[_]](_monad: MonadError[F], verbose: Boolean)
+ extends AbstractCurlBackend[F](_monad, verbose) {
+ override def performCurl(c: CurlHandle): F[CurlCode.CurlCode] = monad.unit(c.perform)
+}
+
 object AbstractCurlBackend {
  val wdFunc: CFuncPtr4[Ptr[Byte], CSize, CSize, Ptr[CurlFetch], CSize] = {
  (ptr: Ptr[CChar], size: CSize, nmemb: CSize, data: Ptr[CurlFetch]) =>

core/src/main/scalanative/sttp/client4/curl/CurlBackends.scala

@@ -9,13 +9,13 @@ import scala.util.Try
 
 // Curl supports redirects, but it doesn't store the history, so using FollowRedirectsBackend is more convenient
 
-private class CurlBackend(verbose: Boolean) extends AbstractCurlBackend(IdMonad, verbose) with SyncBackend {}
+private class CurlBackend(verbose: Boolean) extends AbstractSyncCurlBackend(IdMonad, verbose) with SyncBackend {}
 
 object CurlBackend {
  def apply(verbose: Boolean = false): SyncBackend = FollowRedirectsBackend(new CurlBackend(verbose))
 }
 
-private class CurlTryBackend(verbose: Boolean) extends AbstractCurlBackend(TryMonad, verbose) with Backend[Try] {}
+private class CurlTryBackend(verbose: Boolean) extends AbstractSyncCurlBackend(TryMonad, verbose) with Backend[Try] {}
 
 object CurlTryBackend {
  def apply(verbose: Boolean = false): Backend[Try] = FollowRedirectsBackend(new CurlTryBackend(verbose))