Merge pull request #510 from uptane/api-gw

improve RemoteServiceError handling

Author: simao

libats-http/src/main/scala/com/advancedtelematic/libats/http/ErrorHandler.scala

@@ -57,7 +57,7 @@ object Errors {
       with NoStackTrace
 
   case class RemoteServiceError(msg: String,
-                                status: StatusCode,
+                                response: HttpResponse,
                                 description: Json = Json.Null,
                                 causeCode: ErrorCode =
                                   ErrorCodes.RemoteServiceError,

libats-http/src/main/scala/com/advancedtelematic/libats/http/ServiceHttpClient.scala

@@ -1,21 +1,21 @@
 package com.advancedtelematic.libats.http
 
 import java.util.UUID
-
 import akka.actor.ActorSystem
 import akka.http.scaladsl.Http
-import akka.http.scaladsl.model._
+import akka.http.scaladsl.model.*
 import akka.http.scaladsl.model.headers.RawHeader
 import akka.http.scaladsl.unmarshalling.{FromEntityUnmarshaller, Unmarshaller}
 import akka.http.scaladsl.util.FastFuture
 import akka.stream.Materializer
-import cats.syntax.either._
-import cats.syntax.option._
+import akka.util.ByteString
+import cats.syntax.either.*
+import cats.syntax.option.*
 import com.advancedtelematic.libats.data.DataType.Namespace
 import com.advancedtelematic.libats.data.ErrorRepresentation
 import com.advancedtelematic.libats.http.Errors.RemoteServiceError
 import com.advancedtelematic.libats.http.ServiceHttpClient.{ServiceHttpFullResponse, ServiceHttpFullResponseEither}
-import de.heikoseeberger.akkahttpcirce.FailFastCirceSupport._
+import de.heikoseeberger.akkahttpcirce.FailFastCirceSupport.*
 import io.circe.{Encoder, Json}
 import org.slf4j.LoggerFactory
 
@@ -71,14 +71,24 @@ abstract class ServiceHttpClient(_httpClient: HttpRequest => Future[HttpResponse
     execHttpUnmarshalled(req)
   }
 
+  protected def execJsonHttpWithNamespace[Res : ClassTag : FromEntityUnmarshaller, Req : Encoder]
+  (ns: Namespace, request: HttpRequest, entity: Req): Future[Either[RemoteServiceError, Res]] = {
+    val req = request.addHeader(RawHeader("x-ats-namespace", ns.get))
+    execJsonHttp(req, entity)
+  }
+
+  // The entity is replaced into `response` so that it can be read again by api users, for example through `handleErrors`
   private def tryErrorParsing(response: HttpResponse)(implicit um: FromEntityUnmarshaller[ErrorRepresentation]): Future[RemoteServiceError] = {
     um(response.entity).map { rawError =>
-      RemoteServiceError(s"${rawError.description}", response.status, rawError.cause.getOrElse(Json.Null),
+      val entity = HttpEntity.Strict(response.entity.contentType, ByteString(rawError.asJson.noSpaces))
+      RemoteServiceError(s"${rawError.description}", response.withEntity(entity), rawError.cause.getOrElse(Json.Null),
         rawError.code, rawError.some, rawError.errorId.getOrElse(UUID.randomUUID()))
     }.recoverWith { case _ =>
-      Unmarshaller.stringUnmarshaller(response.entity).map(msg => RemoteServiceError(msg, response.status))
+      Unmarshaller.stringUnmarshaller(response.entity).map { str =>
+        RemoteServiceError(str, response.withEntity(HttpEntity.Strict(response.entity.contentType, ByteString(str))))
+      }
     }.recover { case _ =>
-      RemoteServiceError(s"Unknown error: $response", response.status)
+      RemoteServiceError(s"Unknown error: $response", response)
     }
   }
 

libats/src/main/scala/com/advancedtelematic/libats/data/PaginationResult.scala

@@ -1,5 +1,10 @@
 package com.advancedtelematic.libats.data
 
+import cats.{Applicative, Eval, Functor, Traverse}
+import cats.syntax.traverse.*
+import cats.syntax.foldable.*
+import cats.syntax.functor.*
+
 final case class PaginationResult[A](values: Seq[A], total: Long, offset: Long, limit: Long) {
   def map[B](f: A => B): PaginationResult[B] = this.copy(values = values.map(f))
 }
@@ -10,4 +15,26 @@ object PaginationResult {
 
   implicit def paginationResultEncoder[T : Encoder]: Encoder[PaginationResult[T]] = deriveEncoder
   implicit def paginationResultDecoder[T : Decoder]: Decoder[PaginationResult[T]] = deriveDecoder
+
+  implicit val functor: Functor[PaginationResult] = new Functor[PaginationResult] {
+    override def map[A, B](fa: PaginationResult[A])(f: A => B): PaginationResult[B] =
+      fa.map(f)
+  }
+
+  implicit val traverse: Traverse[PaginationResult] = new Traverse[PaginationResult] {
+    override def traverse[G[_]: Applicative, A, B](fa: PaginationResult[A])(
+      f: A => G[B]): G[PaginationResult[B]] = {
+      import cats.syntax.traverse.*
+      fa.values
+        .traverse(f)
+        .map(transformed => PaginationResult(transformed, fa.total, fa.offset, fa.limit))
+    }
+
+    override def foldLeft[A, B](fa: PaginationResult[A], b: B)(f: (B, A) => B): B =
+      fa.values.foldl(b)(f)
+
+    override def foldRight[A, B](fa: PaginationResult[A], lb: Eval[B])(
+      f: (A, Eval[B]) => Eval[B]): Eval[B] =
+      fa.values.foldr(lb)(f)
+  }
 }