neutrinorpc.NeutrinoKitHandler.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of bitcoin-s-lnd-rpc_2.13 Show documentation
bitcoin-s-lnd-rpc
The newest version!

// Generated by Pekko gRPC. DO NOT EDIT.
package neutrinorpc

import scala.concurrent.ExecutionContext

import org.apache.pekko
import pekko.grpc.scaladsl.{ GrpcExceptionHandler, GrpcMarshalling }
import pekko.grpc.Trailers

import pekko.actor.ActorSystem
import pekko.actor.ClassicActorSystemProvider
import pekko.annotation.ApiMayChange
import pekko.http.scaladsl.model
import pekko.stream.{Materializer, SystemMaterializer}

import pekko.grpc.internal.TelemetryExtension

import pekko.grpc.PekkoGrpcGenerated




/*
 * Generated by Pekko gRPC. DO NOT EDIT.
 *
 * The API of this class may still change in future Pekko gRPC versions, see for instance
 * https://github.com/akka/akka-grpc/issues/994
 */
@ApiMayChange
@PekkoGrpcGenerated
object NeutrinoKitHandler {
    private val notFound = scala.concurrent.Future.successful(model.HttpResponse(model.StatusCodes.NotFound))
    private val unsupportedMediaType = scala.concurrent.Future.successful(model.HttpResponse(model.StatusCodes.UnsupportedMediaType))

    /**
     * Creates a `HttpRequest` to `HttpResponse` handler that can be used in for example `Http().bindAndHandleAsync`
     * for the generated partial function handler and ends with `StatusCodes.NotFound` if the request is not matching.
     *
     * Use `org.apache.pekko.grpc.scaladsl.ServiceHandler.concatOrNotFound` with `NeutrinoKitHandler.partial` when combining
     * several services.
     */
    def apply(implementation: NeutrinoKit)(implicit system: ClassicActorSystemProvider): model.HttpRequest => scala.concurrent.Future[model.HttpResponse] =
      partial(implementation).orElse { case _ => notFound }

    /**
     * Creates a `HttpRequest` to `HttpResponse` handler that can be used in for example `Http().bindAndHandleAsync`
     * for the generated partial function handler and ends with `StatusCodes.NotFound` if the request is not matching.
     *
     * Use `org.apache.pekko.grpc.scaladsl.ServiceHandler.concatOrNotFound` with `NeutrinoKitHandler.partial` when combining
     * several services.
     */
    def apply(implementation: NeutrinoKit, eHandler: ActorSystem => PartialFunction[Throwable, Trailers])(implicit system: ClassicActorSystemProvider): model.HttpRequest => scala.concurrent.Future[model.HttpResponse] =
      partial(implementation, NeutrinoKit.name, eHandler).orElse { case _ => notFound }

    /**
     * Creates a `HttpRequest` to `HttpResponse` handler that can be used in for example `Http().bindAndHandleAsync`
     * for the generated partial function handler and ends with `StatusCodes.NotFound` if the request is not matching.
     *
     * Use `org.apache.pekko.grpc.scaladsl.ServiceHandler.concatOrNotFound` with `NeutrinoKitHandler.partial` when combining
     * several services.
     *
     * Registering a gRPC service under a custom prefix is not widely supported and strongly discouraged by the specification.
     */
    def apply(implementation: NeutrinoKit, prefix: String)(implicit system: ClassicActorSystemProvider): model.HttpRequest => scala.concurrent.Future[model.HttpResponse] =
      partial(implementation, prefix).orElse { case _ => notFound }

    /**
     * Creates a `HttpRequest` to `HttpResponse` handler that can be used in for example `Http().bindAndHandleAsync`
     * for the generated partial function handler and ends with `StatusCodes.NotFound` if the request is not matching.
     *
     * Use `org.apache.pekko.grpc.scaladsl.ServiceHandler.concatOrNotFound` with `NeutrinoKitHandler.partial` when combining
     * several services.
     *
     * Registering a gRPC service under a custom prefix is not widely supported and strongly discouraged by the specification.
     */
    def apply(implementation: NeutrinoKit, prefix: String, eHandler: ActorSystem => PartialFunction[Throwable, Trailers])(implicit system: ClassicActorSystemProvider): model.HttpRequest => scala.concurrent.Future[model.HttpResponse] =
      partial(implementation, prefix, eHandler).orElse { case _ => notFound }



    /**
     * Creates a `HttpRequest` to `HttpResponse` handler that can be used in for example `Http().bindAndHandleAsync`
     * for the generated partial function handler. The generated handler falls back to a reflection handler for
     * `NeutrinoKit` and ends with `StatusCodes.NotFound` if the request is not matching.
     *
     * Use `org.apache.pekko.grpc.scaladsl.ServiceHandler.concatOrNotFound` with `NeutrinoKitHandler.partial` when combining
     * several services.
     */
    def withServerReflection(implementation: NeutrinoKit)(implicit system: ClassicActorSystemProvider): model.HttpRequest => scala.concurrent.Future[model.HttpResponse] =
        pekko.grpc.scaladsl.ServiceHandler.concatOrNotFound(
          NeutrinoKitHandler.partial(implementation),
          pekko.grpc.scaladsl.ServerReflection.partial(List(NeutrinoKit)))


    /**
     * Creates a partial `HttpRequest` to `HttpResponse` handler that can be combined with handlers of other
     * services with `org.apache.pekko.grpc.scaladsl.ServiceHandler.concatOrNotFound` and then used in for example
     * `Http().bindAndHandleAsync`.
     *
     * Use `NeutrinoKitHandler.apply` if the server is only handling one service.
     *
     * Registering a gRPC service under a custom prefix is not widely supported and strongly discouraged by the specification.
     */
    def partial(implementation: NeutrinoKit, prefix: String = NeutrinoKit.name, eHandler: ActorSystem => PartialFunction[Throwable, Trailers] = GrpcExceptionHandler.defaultMapper)(implicit system: ClassicActorSystemProvider): PartialFunction[model.HttpRequest, scala.concurrent.Future[model.HttpResponse]] = {
      implicit val mat: Materializer = SystemMaterializer(system).materializer
      implicit val ec: ExecutionContext = mat.executionContext
      val spi = TelemetryExtension(system).spi

      import NeutrinoKit.Serializers._

      def handle(request: model.HttpRequest, method: String): scala.concurrent.Future[model.HttpResponse] =
        GrpcMarshalling.negotiated(request, (reader, writer) =>
          (method match {
            
            case "Status" =>
                
                GrpcMarshalling.unmarshal(request.entity)(StatusRequestSerializer, mat, reader)
                  .flatMap(implementation.status(_))
                  .map(e => GrpcMarshalling.marshal(e, eHandler)(StatusResponseSerializer, writer, system))
            
            case "AddPeer" =>
                
                GrpcMarshalling.unmarshal(request.entity)(AddPeerRequestSerializer, mat, reader)
                  .flatMap(implementation.addPeer(_))
                  .map(e => GrpcMarshalling.marshal(e, eHandler)(AddPeerResponseSerializer, writer, system))
            
            case "DisconnectPeer" =>
                
                GrpcMarshalling.unmarshal(request.entity)(DisconnectPeerRequestSerializer, mat, reader)
                  .flatMap(implementation.disconnectPeer(_))
                  .map(e => GrpcMarshalling.marshal(e, eHandler)(DisconnectPeerResponseSerializer, writer, system))
            
            case "IsBanned" =>
                
                GrpcMarshalling.unmarshal(request.entity)(IsBannedRequestSerializer, mat, reader)
                  .flatMap(implementation.isBanned(_))
                  .map(e => GrpcMarshalling.marshal(e, eHandler)(IsBannedResponseSerializer, writer, system))
            
            case "GetBlockHeader" =>
                
                GrpcMarshalling.unmarshal(request.entity)(GetBlockHeaderRequestSerializer, mat, reader)
                  .flatMap(implementation.getBlockHeader(_))
                  .map(e => GrpcMarshalling.marshal(e, eHandler)(GetBlockHeaderResponseSerializer, writer, system))
            
            case "GetBlock" =>
                
                GrpcMarshalling.unmarshal(request.entity)(GetBlockRequestSerializer, mat, reader)
                  .flatMap(implementation.getBlock(_))
                  .map(e => GrpcMarshalling.marshal(e, eHandler)(GetBlockResponseSerializer, writer, system))
            
            case "GetCFilter" =>
                
                GrpcMarshalling.unmarshal(request.entity)(GetCFilterRequestSerializer, mat, reader)
                  .flatMap(implementation.getCFilter(_))
                  .map(e => GrpcMarshalling.marshal(e, eHandler)(GetCFilterResponseSerializer, writer, system))
            
            case "GetBlockHash" =>
                
                GrpcMarshalling.unmarshal(request.entity)(GetBlockHashRequestSerializer, mat, reader)
                  .flatMap(implementation.getBlockHash(_))
                  .map(e => GrpcMarshalling.marshal(e, eHandler)(GetBlockHashResponseSerializer, writer, system))
            
            case m => scala.concurrent.Future.failed(new NotImplementedError(s"Not implemented: $m"))
          })
          .recoverWith(GrpcExceptionHandler.from(eHandler(system.classicSystem))(system, writer))
      ).getOrElse(unsupportedMediaType)

      Function.unlift((req: model.HttpRequest) => req.uri.path match {
        case model.Uri.Path.Slash(model.Uri.Path.Segment(`prefix`, model.Uri.Path.Slash(model.Uri.Path.Segment(method, model.Uri.Path.Empty)))) =>
          Some(handle(spi.onRequest(prefix, method, req), method))
        case _ =>
          None
      })
    }
  }