RPC Unary Services: IsEmpty

Author: franciscodr

README.md

@@ -12,6 +12,11 @@
     - [Client](#client)
 - [Evolving the Avro schema](#evolving-the-avro-schema)
   - [Protocol](#protocol-1)
+- [Unary RPC service: `IsEmpty`](#unary-rpc-service-isempty)
+  - [Protocol](#protocol-2)
+  - [Server](#server-1)
+  - [Client](#client-1)
+  - [Result](#result)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
@@ -353,6 +358,105 @@ INFO  - PeopleService - Request: PeopleRequest(baz)
 INFO  - PeopleService - Sending response: Person(baz,17,(206) 812-1984)
 ```
 
+## Unary RPC service: `IsEmpty`
+
+Having said this, now it's the right moment to get started to develop the features of the SmartHome, and discard the `People` stuff. As we said above, we want also to build a unary RPC service to let clients know if there is somebody in the home or there is not.
+
+### Protocol
+
+In order to show another way to define protocols, we are going to express our models and services using directly Scala code, and using **ProtocolBuffer** as serialiser instead of **Avro**.
+
+So the protocol module can adopt know this shape (of course we should also discard the `idlgens` references at `ProjectPlugin.scala` and `plugins.sbt`):
+
+```scala
+├── protocol
+│   └── src
+│       └── main
+│           └── scala
+│               └── protocol
+│                   ├── Messages.scala
+│                   └── SmartHomeService.scala
+```
+
+**_Messages.scala_**
+
+Where we defined the messages flowing through the wire:
+
+```scala
+@message
+final case class IsEmptyRequest()
+
+@message
+final case class IsEmptyResponse(result: Boolean)
+```
+
+**_SmartHomeService.scala_**
+
+Where we defined interface of the RPC service:
+
+```scala
+@service(Protobuf) trait SmartHomeService[F[_]] {
+
+  def isEmpty(request: IsEmptyRequest): F[IsEmptyResponse]
+
+}
+```
+
+### Server
+
+Now, we have to implement an interpreter for the new service `SmartHomeService`:
+
+```scala
+class SmartHomeServiceHandler[F[_]: Sync: Logger] extends SmartHomeService[F] {
+  val serviceName = "SmartHomeService"
+
+  override def isEmpty(request: IsEmptyRequest): F[IsEmptyResponse] =
+    Logger[F].info(s"$serviceName - Request: $request").as(IsEmptyResponse(true))
+
+}
+```
+
+And bind it to the gRPC server:
+
+```scala
+val grpcConfigs: List[GrpcConfig] = List(AddService(SmartHomeService.bindService[F]))
+```
+
+### Client
+
+And the client, of course, needs an algebra to describe the same operation:
+
+```scala
+trait SmartHomeServiceApi[F[_]] {
+  def isEmpty(): F[Boolean]
+}
+```
+
+That will be called when the app is running
+
+```scala
+for {
+  serviceApi <- SmartHomeServiceApi.createInstance(config.host.value, config.port.value)
+  _          <- Stream.eval(serviceApi.isEmpty)
+} yield StreamApp.ExitCode.Success
+```
+
+### Result
+
+When we run the client now with `sbt runClient` we get:
+
+```bash
+INFO  - Created new RPC client for (localhost,19683)
+INFO  - Result: IsEmptyResponse(true)
+INFO  - Removed 1 RPC clients from cache.
+```
+
+And the server log the request as expected:
+
+```bash
+INFO  - SmartHomeService - Request: IsEmptyRequest()
+```
+
 <!-- DOCTOC SKIP -->
 # Copyright
 

client/src/main/scala/client/ClientApp.scala

@@ -1,11 +1,8 @@
 package com.fortyseven.client
 
 import cats.effect.{Effect, IO, Timer}
-import cats.instances.list._
-import cats.syntax.traverse._
 import com.fortyseven.commons._
 import com.fortyseven.commons.config.ServiceConfig
-import com.fortyseven.protocol.Person
 import fs2.{Stream, StreamApp}
 import io.chrisdavenport.log4cats.Logger
 import monix.execution.Scheduler
@@ -18,11 +15,9 @@ class ClientProgram[F[_]: Effect: Logger] extends AppBoot[F] {
 
   override def appStream(config: ServiceConfig): fs2.Stream[F, StreamApp.ExitCode] =
     for {
-      peopleApi <- PeopleServiceApi.createInstance(config.host.value, config.port.value)
-      exitCode <- Stream
-        .eval(List("foo", "bar", "baz").traverse[F, Person](peopleApi.getPersonByName))
-        .as(StreamApp.ExitCode.Success)
-    } yield exitCode
+      serviceApi <- SmartHomeServiceApi.createInstance(config.host.value, config.port.value)
+      _          <- Stream.eval(serviceApi.isEmpty)
+    } yield StreamApp.ExitCode.Success
 }
 
 object ClientApp extends ClientProgram[IO]

client/src/main/scala/client/PeopleServiceApi.scala renamed to client/src/main/scala/client/SmartHomeServiceApi.scala

@@ -11,24 +11,22 @@ import monix.execution.Scheduler
 
 import scala.concurrent.duration._
 
-trait PeopleServiceApi[F[_]] {
-
-  def getPersonByName(name: String): F[Person]
+trait SmartHomeServiceApi[F[_]] {
 
+  def isEmpty: F[Boolean]
 }
 
-object PeopleServiceApi {
+object SmartHomeServiceApi {
 
-  def apply[F[_]: Effect](clientRPCF: F[PeopleService.Client[F]])(
+  def apply[F[_]: Effect](clientRPCF: F[SmartHomeService.Client[F]])(
       implicit L: Logger[F]
-  ): PeopleServiceApi[F] = new PeopleServiceApi[F] {
-    override def getPersonByName(name: String): F[Person] =
+  ): SmartHomeServiceApi[F] = new SmartHomeServiceApi[F] {
+    override def isEmpty: F[Boolean] =
       for {
         clientRPC <- clientRPCF
-        _         <- L.info(s"Request: $name")
-        result    <- clientRPC.getPerson(PeopleRequest(name))
+        result    <- clientRPC.isEmpty(IsEmptyRequest())
         _         <- L.info(s"Result: $result")
-      } yield result.person
+      } yield result.result
   }
 
   def createInstance[F[_]: Effect](
@@ -39,10 +37,10 @@ object PeopleServiceApi {
       removeUnusedAfter: FiniteDuration = 1.hour)(
       implicit L: Logger[F],
       TM: Timer[F],
-      S: Scheduler): fs2.Stream[F, PeopleServiceApi[F]] = {
+      S: Scheduler): fs2.Stream[F, SmartHomeServiceApi[F]] = {
 
-    def fromChannel(channel: ManagedChannel): PeopleService.Client[F] =
-      PeopleService.clientFromChannel(channel, CallOptions.DEFAULT)
+    def fromChannel(channel: ManagedChannel): SmartHomeService.Client[F] =
+      SmartHomeService.clientFromChannel(channel, CallOptions.DEFAULT)
 
     ClientRPC
       .clientCache(
@@ -51,6 +49,6 @@ object PeopleServiceApi {
         tryToRemoveUnusedEvery,
         removeUnusedAfter,
         fromChannel)
-      .map(cache => PeopleServiceApi(cache.getClient))
+      .map(cache => SmartHomeServiceApi(cache.getClient))
   }
 }

project/ProjectPlugin.scala

@@ -1,4 +1,3 @@
-import freestyle.rpc.idlgen.IdlGenPlugin.autoImport._
 import org.scalafmt.sbt.ScalafmtPlugin.autoImport._
 import sbt.Keys._
 import sbt._
@@ -35,12 +34,7 @@ object ProjectPlugin extends AutoPlugin {
   lazy val commonsSettings: Seq[Def.Setting[_]] = logSettings ++ configSettings
 
   lazy val rpcProtocolSettings: Seq[Def.Setting[_]] = Seq(
-    idlType := "avro",
-    srcGenSerializationType := "AvroWithSchema",
-    sourceGenerators in Compile += (srcGen in Compile).taskValue,
-    libraryDependencies ++= Seq(
-      "io.frees" %% "frees-rpc-client-core" % V.freestyleRPC
-    )
+    libraryDependencies ++= Seq("io.frees" %% "frees-rpc-client-core" % V.freestyleRPC)
   )
 
   lazy val rpcClientSettings: Seq[Def.Setting[_]] = logSettings ++ Seq(

project/plugins.sbt

@@ -1,3 +1,2 @@
-addSbtPlugin("com.geirsson"      % "sbt-scalafmt"         % "1.5.1")
-addSbtPlugin("de.heikoseeberger" % "sbt-groll"            % "6.0.0")
-addSbtPlugin("io.frees"          % "sbt-frees-rpc-idlgen" % "0.14.1")
+addSbtPlugin("com.geirsson"      % "sbt-scalafmt" % "1.5.1")
+addSbtPlugin("de.heikoseeberger" % "sbt-groll"    % "6.0.0")

protocol/src/main/resources/People.avdl

@@ -0,0 +1,9 @@
+package com.fortyseven.protocol
+
+import freestyle.rpc.protocol.message
+
+@message
+final case class IsEmptyRequest()
+
+@message
+final case class IsEmptyResponse(result: Boolean)

protocol/src/main/resources/PeopleService.avdl

@@ -0,0 +1,9 @@
+package com.fortyseven.protocol
+
+import freestyle.rpc.protocol.{service, Protobuf}
+
+@service(Protobuf) trait SmartHomeService[F[_]] {
+
+  def isEmpty(request: IsEmptyRequest): F[IsEmptyResponse]
+
+}