Let's play a game

"Never have I ever"

• Used Spring in a project larger than hello world
• Added an annotation that required 3 more to work
• Used Play and tried to upgrade from 2.3
• Cursed at dependency injection

Just some of the horrors of frameworks

Microservices

A set of architectural patterns for building distributed systems

Microservices are usually

• small
• doing one thing well
• autonomous
• isolated
  
  
• hard to do

Microservices are dangerous

• lots of infrastructure needed
• the network isn't reliable
• debugging difficulty
• generally challenging and complex
• need constant evolution

Microservices can help with

• frequent, independent deployment
• resilience
• scalability
• ease of development (within a service)

There's a lot to keep in mind

Source (microservices.io)

Warning

Some examples may contain traces of Spring.

If you're allergic, please close your eyes.

Dependency injection

class UserService @Inject()(userRepo: UserRepo) {
  //...
}

class UserService(userRepo: UserRepo)

Beans

@Configuration class MyConfig {
  @Bean DataSource dataSource(){
    //some side-effecty things allocating some DB connection pool
  }
  @Bean UserRepository userRepository(DataSource dataSource) {
    return new UserRepositoryImpl(dataSource);
  }
}

object MyModule {
  def make: Resource[IO, Module] =
    DataSource.make[IO].map { implicit ds =>
        implicit val userRepository: UserRepository[IO] =
            UserRepository.make
        //...
    }
}

Startup/shutdown hooks

class DataSource @Inject()(
  config: Config,
  lifecycle: ApplicationLifecycle
) {
  val db = newHikariPool(config)

  lifecycle.addStopHook {
    db.close()
  }
}

Startup/shutdown hooks: FP

object DataSource {
  def make(config: Config): Resource[IO, DataSource] =
    Resource.make(newHikariPool(config))(_.close)
      .map(_.immutable)
      .map(new DataSource(_))
}

Scheduled jobs

@Service
class MySchedulingService {
    @Scheduled(fixedRate = 1000)
    void runJobAndThenWhat() {
        System.out.println("Dumping data to disk...");
        //try to figure out yourself
        //how to change error handling strategy
        throw new RuntimeException();
    }
}

Scheduled jobs: FP

val schedule = Stream.sleep[F](5.seconds).repeat

val orderCountScheduledJob: Stream[F, Unit] =
  Stream
    .repeatEval(storage.countOrders)
    .evalMap(count => log.info(s"Current order count: $count"))
    .zipLeft(schedule)

Resource lifetime

@RestController
class UserController {
    private UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/users")
    public List<User> getUsers() {
        return userService.getUsers();
    }
}

@RestController
class UserController2 {
    @GetMapping("/users")
    public List<User> getUsers(@Autowired UserService userService) {
        return userService.getUsers();
    }
}

Resource lifetime: global to per-request

object UserRoutes {

- def make[F[_]: Sync: UserRepository]: HttpRoutes[F] = {
+ def make[F[_]: Async: ContextShift]: HttpRoutes[F] = {
    val dsl = new Http4sDsl[F] {}
    import dsl._

    HttpRoutes.of[F] {
-     case GET -> Root / "users" => UserRepository[F].findAll.map(_.asJson)
+     case GET -> Root / "users" => UserRepository.make[F].use(_.findAll).map(_.asJson)
    }
}

What's FP?

Lack of side effects

Definition of a side effect

Lack of referential transparency

Referential transparency

for any expression `a`
given `x = a`

All occurrences of `x` in a program `p` can be replaced with `a`

//Example
val prog1 = (x, x)
val prog2 = (a, a)

//both sides equivalent
prog1 <-> prog2

Pure expressions are RT

val y = 2

val x = y + 1

(x, x) <-> (y + 1, y + 1)

Side effects?

import scala.io.StdIn

val x = StdIn.readLine()
//< Foo

val L = (x, x)
//L = (Foo, Foo)

val R = (StdIn.readLine, StdIn.readLine)
//< Foo
//< Bar
//R = (Foo, Bar)

L <!-> R

Future

val x = Future(StdIn.readLine())

//a >> b is a.flatMap(_ => b)

(x >> x) <!-> (Future(StdIn.readLine()) >> Future(StdIn.readLine()))

IO

val x = IO(StdIn.readLine())

//(x, x) ?? (IO(StdIn.readLine()), IO(StdIn.readLine()))

//a >> b is a.flatMap(_ => b)
(x >> x) <-> (IO(StdIn.readLine()) >> IO(StdIn.readLine()))

RT == no side effects == FP

object ResourceUsage extends IOApp {

  def lock(name: String): Resource[IO, Unit] = {
    val acquire = IO(println(s"Acquiring $name"))
    val cleanup = IO(println(s"Releasing $name"))

    Resource.make(acquire)(_ => cleanup)
  }

  def file(name: String): Resource[IO, FileReader] = {
    val acquire = IO(println(s"Acquiring file reader: $name")) >> IO(new FileReader(name))

    def cleanup(fr: FileReader) = IO(println(s"Releasing file reader: $name")) >> IO(fr.close())

    Resource.make(acquire)(cleanup)
  }

  val megaResource: Resource[IO, FileReader] = for {
    _          <- lock("lock1")
    myResource <- file(".gitignore")
    _          <- lock("lock2")
  } yield myResource

  override def run(args: List[String]): IO[ExitCode] =
    megaResource
      .use(readLines(_) <* IO(println("Finished reading lines\n")))
      .flatMap(lines => IO(println(lines)))
      .as(ExitCode.Success)
}

Acquire/cleanup order

Acquiring lock1
Acquiring file reader: .gitignore
Acquiring lock2
Finished reading lines

Releasing lock2
Releasing file reader: .gitignore
Releasing lock1
.idea/
*.iml
*.iws
*.eml
out/

Http4s Route

type HttpRoutes = Request => Response

type HttpRoutes = Request => IO[Response]

type HttpRoutes = Request => IO[Option[Response]]

type HttpRoutes = Request[IO] => IO[Option[Response[IO]]]

//Kleisli[F[_], A, B] ~= A => F[B]
//OptionT[F, A] ~= F[Option[A]]
type HttpRoutes =
  Kleisli[OptionT[IO, ?], Request[IO], Response[IO]]

type HttpRoutes[F[_]] =
  Kleisli[OptionT[F, ?], Request[F], Response[F]]

If a route is just a function

...then we can modify its input and output

Example: Response timing

object ResponseTiming {
  def apply[F[_]: Clock: FlatMap](
    http: HttpApp[F],
    timeUnit: TimeUnit,
    headerName: CaseInsensitiveString): HttpApp[F] = {

    Kleisli { req =>
      for {
        before <- Clock[F].monotonic(timeUnit)
        resp   <- http(req)
        after  <- Clock[F].monotonic(timeUnit)
        header = Header(headerName.value, s"${after - before}")
      } yield resp.putHeaders(header)
    }
  }
}

Built-in server middleware (0.20.0-M5)

What about clients?

trait Client[F[_]] {
  def run(req: Request[F]): Resource[F, Response[F]]
  //...
}

object Client {

  def apply[F[_]](
    f: Request[F] => Resource[F, Response[F]]
  ): Client[F] = req => f(req)
}

Just another function

Built-in client middleware (0.20.0-M5)

Creating clients from routes - trivial server stubbing

object PaypalClient {

  def make[F[_]: Sync]: Client[F] = {
    val dsl = new Http4sDsl[F] {}
    import dsl._

    Client.fromHttpApp {
      HttpRoutes
        .of[F] {
          case req @ POST -> Root / "make-payment" =>
            for {
              body     <- req.decodeJson[PaymentRequest]
              response <- Ok(s"Accepted payment of ${body.amount}".asJson)
            } yield response
        }
        .orNotFound
    }
  }
}

Calling endpoint in test = calling a function

object RouteCallTest {
  val route: HttpApp[IO] = HttpApp.notFound[IO]

  val result = route(Request(method = GET, uri = Uri.uri("/home")))

  result.flatMap(_.bodyAsText.compile.foldMonoid).map {
    _ shouldBe "Not found"
  }
}

Transactor

val transactor: Resource[IO, HikariTransactor[IO]] = for {
  connectEc  <- ExecutionContexts.fixedThreadPool[IO](size = 10)
  transactEc <- ExecutionContexts.cachedThreadPool[IO]

  xa <- HikariTransactor.newHikariTransactor[IO](
    "org.postgresql.Driver",
    "jdbc:postgresql://localhost/postgres",
    "postgres",
    "postgres",
    connectEc,
    transactEc)
} yield xa

Query

def countryById(id: CountryId): Query0[Country] =
  sql"""select c.name, c.capital
        from countries
        where c.id = $id""".query[Country]

val countries: Query0[Country] =
  sql"select c.name, c.capital from countries"
    .query[Country]

val country1: ConnectionIO[Option[Country]] =
  countryById(CountryId(1L)).option

val countriesStream: Stream[ConnectionIO, Country] =
  countries.stream

ConnectionIO -> IO

transactor.use { xa =>
  country1
    .transact(xa)
    .flatMap(putStrLn(_)) // Some(Country(...))
}

End-to-end streaming with http4s

object DoobieMain extends IOApp with Http4sDsl[IO] {
  val streamCountries: Stream[ConnectionIO, Country] =
    sql"select c.name, c.capital from countries".query[Country].stream

  def countriesService(xa: Transactor[IO]): HttpApp[IO] =
    HttpRoutes
      .of[IO] {
        case GET -> Root / "countries" =>
          Ok(streamCountries.transact(xa).map(_.asJson))
      }
      .orNotFound

  override def run(args: List[String]): IO[ExitCode] = {
    val server = for {
      xa <- transactor
      _  <- BlazeServerBuilder[IO].withHttpApp(countriesService(xa)).resource
    } yield ()

    //never completes normally (so the server won't shut down)
    server.use(_ => IO.never).as(ExitCode.Success)
  }
}

Query typechecking

class AnalysisTestScalaCheck extends FunSuite with Matchers with IOChecker {

  val transactor = Transactor.fromDriverManager[IO](
    "org.postgresql.Driver", "jdbc:postgresql:world", "postgres", ""
  )

  test("countryById") { check(countryById(CountryId(1L)))  }
  test("countries") { check(countries) }
}

Questions

Thank you!

Get in touch

@kubukoz | kubukoz@gmail.com