Short Trip into Reactive System space with Lagom

Krzysztof Borowski @liosedhel

Trip plan

  • Domain Driven Design
  • Reactive Systems
  • Reactive Programming
  • ES and CQRS
  • Lagom 
  • Demo

PhotoTrip App

  • Mark on the map our trip
  • Add photos
  • Collaborate with others in real time
  • Add Comments

Domain Driven Design

Bounded Context

 

Bounded Context is a central pattern in Domain-Driven Design. It is the focus of DDD's strategic design section which is all about dealing with large models and teams. DDD deals with large models by dividing them into different Bounded Contexts and being explicit about their interrelationships.

Martin Fowler

Bounded Context

Aggregate

  • A cluster of domain objects that can be treated as a single unit.
  • Aggregates domain objects and theirs behaviour
  • Every change of the state within aggregate is transactional

Aggregates

Entity

  • Has unique identificator
  • Can mutate the state
  • Contains other entities or value objects
 case class WorldMap(
    id: WorldMapId, 
    creatorId: String,
    description: String
 )

Reactive Systems Space

Reactive System Definition

https://www.reactivemanifesto.org/

Systems spectrum

It is time to apply these design principles consciously from the start instead of rediscovering them each time.

https://www.reactivemanifesto.org/

Why should​ we care?

  • Our software operates 24/7 
  • Dealing with high load, responding in milliseconds
  • Solving more and more complicated domain problems
  • The codebase is growing, software is evolving quickly

Problems

​

  • Handling distributed architecture deployment
  • Defining proper service boundaries
  • Reliable messaging system
  • Data streams, asynchronous communication
  • Lack of well defined, tested in production frameworks
  • Domain Driven Design (~2003)
  • Persistent Messages Queues (Kafka (~2012))
  • Reactive Programming (~2007)
  • Lagom, Project Reactor (~2016)
  • Containers & Orchestration (~2013)

Problems

Solutions

Reactive Programming

Reactive Programming 

  • reacting to changes
  • often via data streams
  • program using and relying on events instead of the order of lines in the code

https://www.quora.com/What-is-reactive-programming

https://stackoverflow.com/questions/1028250/what-is-functional-reactive-programming​

Using reactive programming tools does not imply having ​a Reactive System!

Reactive Programming Marketplace

concepts: ReactiveX, Reactive Streams

ready to use: RxJava, RxKotlin, RxSwift, RxJS, Monix,

akka-streams, vert.x, Ratpack

Functional Reactive Programming?

Event Sourcing

Command/Query Responsibility Segregation

with ES

Lightbend Factory

                 akka ~> akka-persistence ~> lagom
    akka ~> akka-cluster ~> akka-sharding ~> lagom
akka ~> akka-streams ~> akka-http ~> play ~> lagom ~> docker ~> kubernetes
                                    kafka ~> lagom 
               (cassandra, postgres, ...) ~> lagom

an open source framework for building reactive microservice systems in Java or Scala.

focus on solving business problems instead of wiring services together

Looking inside

Service internals

Aggregate - Write Side

class WorldMapAggregate(pubSubRegistry: PubSubRegistry) extends PersistentEntity {

  import WorldMapAggregate._

  override type Command = WorldMapCommand[_]
  override type Event   = WorldMapEvent

  override type State = WorldMapAggregate.WorldMapState

  override def initialState: WorldMapAggregate.WorldMapState = UninitializedWordMap

  override def behavior: Behavior = {
    case UninitializedWordMap =>
      Actions()
        .onCommand[CreateNewMap, Done] {
          case (CreateNewMap(id, creatorId, description), ctx, _) =>
            ctx.thenPersist(
              WorldMapCreated(id, creatorId, description)
            ) { _ => ctx.reply(Done) }
        }
        .onEvent {
          case (WorldMapCreated(id, creatorId, description), _) =>
            WorldMap(id, creatorId, description)
        }
    ...
  }
}

Processor - Read Side

class WorldMapEventProcessor(
  readSide: CassandraReadSide,
  worldMapsRepository: WorldMapsRepository
) extends ReadSideProcessor[WorldMapEvent] {

  override def buildHandler(): ReadSideProcessor.ReadSideHandler[WorldMapEvent] = {
    val builder = readSide.builder[WorldMapEvent]("worldmaps")
    builder
      .setEventHandler[WorldMapCreated](
        eventStreamElement => worldMapsRepository.saveMap(eventStreamElement.event)
      )
      .build()
  }

  override def aggregateTags = Set(WorldMapEvent.Tag)

}


 //register event processor
 readSide.register[WorldMapAggregate.WorldMapEvent](
    new WorldMapEventProcessor(cassandraReadSide, worldMapsRepository)
 )

Internal Pub-Sub


// send created place to internal topic
val place = Place(placeId, worldMapId, description, coordinates, photoLinks)
val topic = pubSubRegistry.refFor(TopicId[Place](worldMapId.id))
topic.publish(place)


// subscribing
val worldMapId = WorldMapId(mapId)
val topic      = pubSub.refFor(TopicId[PlaceAggregate.Place](worldMapId.id))
topic
  .subscriber //akka-streams
  .map(
    p =>
      WorldMapApiModel.Place(
        p.id,
        p.description,
        p.coordinates,
        p.photoLinks
      )
  )

Going outside

Public APIs

Service API

trait WorldMapService extends Service {

  def worldMap(mapId: String): ServiceCall[NotUsed, WorldMap]

  def createWorldMap(): ServiceCall[NewWorldMap, Done]

  override def descriptor: Descriptor = {
    import Service._
    named("worldmap")
      .withCalls(
        pathCall("/api/world-map/map/:id", worldMap _),
        pathCall("/api/world-map/map", createWorldMap _)
  }
}

Service Implementation - Write Side

override def createWorldMap(): ServiceCall[WorldMapDetails, Done] =
    ServiceCall[WorldMapDetails, Done] { worldMap =>
      val worldMapAggregate =
        persistentEntityRegistry.refFor[WorldMapAggregate](worldMap.mapId.id)
      worldMapAggregate.ask(
        WorldMapAggregate.CreateNewMap(
          worldMap.mapId,
          worldMap.creatorId,
          worldMap.description.getOrElse("")
        )
      )
    }

Service Implementation - Read Side

  override def worldMap(mapId: String): ServiceCall[NotUsed, WorldMap] =
    ServiceCall { _ =>
      val worldMapId = WorldMapId(mapId)
      for {
        worldMap <- worldMapsRepository.getMap(worldMapId)
        places   <- placesRepository.getPlaces(worldMapId)
      } yield WorldMapApiModel.WorldMap(
                worldMapId, 
                worldMap.creatorId, 
                worldMap.description, 
                places
              )
    }

External topics

//topics available externally
def worldMapCreatedTopic(): Topic[WorldMapCreated]

override def descriptor: Descriptor = {
    import Service._
    named("worldmap")
      .withTopics(
        topic(WorldMapService.WORLD_MAP_CREATED, worldMapCreatedTopic())
          .addProperty(
            KafkaProperties.partitionKeyStrategy,
            PartitionKeyStrategy[WorldMapCreated](_.worldMapId.id)
          )
    )
}

External topic implementation

override def worldMapCreatedTopic(): 
    Topic[WorldMapApiEvents.WorldMapCreated] = {
    TopicProducer.singleStreamWithOffset { fromOffset =>
      persistentEntityRegistry
        .eventStream(WorldMapAggregate.WorldMapEvent.Tag, fromOffset)
        .mapConcat(filterWorldMapCreated)
    }
  }

External topics - subscribing

worldMapService
    .worldMapCreatedTopic()
    .subscribe
    .atLeastOnce(
      Flow[WorldMapCreated].map { worldMapCreated =>
        analyticsRepository.save(worldMapCreated)
        Done
      }
    )

Gluing services

lazy val `mytrip` = 
  (project in file("."))
    .aggregate(
      `mytrip-worldmap-api`,
      `mytrip-worldmap-impl`,
      ...
    )

lazy val `mytrip-worldmap-api` = 
  (project in file("mytrip-worldmap-api"))
    .settings(
      libraryDependencies ++= Seq(
        lagomScaladslApi,
        ...
      )
    )

lazy val `mytrip-worldmap-impl` = 
  (project in file("mytrip-worldmap-impl"))
    .enablePlugins(LagomScala)
    .settings(
      libraryDependencies ++= Seq(
        ...
      )
    )
    .dependsOn(`mytrip-worldmap-api`)

Service Locator

A Service Locator is embedded in Lagom’s development environment, allowing services to discover and communicate with each other.

API Gateway

External clients need a stable address to communicate to and here’s where the Service Gateway comes in. The Service Gateway will expose and reverse proxy all public endpoints registered by your services.

Lagom show time!

What to do next

Inspiration

Thank you :)

Feedback appreciated: https://goo.gl/euhFXD

Short Trip into Reactive System space with Lagom - AGH

By liosedhel

Made with Slides.com

Short Trip into Reactive System space with Lagom - AGH

  • 1,304

More from liosedhel