Improve Logs and little bit of documentation

Author: knutwalker

backend/src/main/scala/de/knutwalker/wdcm/HandoutSystem.scala

@@ -22,7 +22,7 @@ object HandoutSystem {
 
     def sendOutgoing: Source[BespokeMessage, Unit] =
       Source.actorRef[BespokeMessage](10, OverflowStrategy.dropTail)
-      .mapMaterializedValue(ref => handoutActor ! NewViewer(ref.asInstanceOf[ActorRef[BespokeMessage]]))
+      .mapMaterializedValue(ref ⇒ handoutActor ! NewViewer(ref.asInstanceOf[ActorRef[BespokeMessage]]))
 
     new HandoutSystem {
       def handoutFlow: Flow[Any, BespokeMessage, Unit] =
@@ -34,36 +34,41 @@ object HandoutSystem {
   }
 
   private final class HandoutActor extends Actor with ActorLogging {
-    private[this] var viewers = Set.empty[ActorRef[BespokeMessage]]
+    private[this] var viewers  = Set.empty[ActorRef[BespokeMessage]]
     private[this] var sequence = Vector.empty[BespokeMessage]
 
     def receive: Receive = LoggingReceive {
-      case NewViewer(ref)       ⇒
+      case NewViewer(ref)                 ⇒
         context watch ref.asInstanceOf[UntypedActorRef]
-        sequence.foreach(ref ! _)
         viewers += ref
-      case Terminated(ref)      ⇒
+        log.info(s"A new viewer joined, total of ${viewers.size } now")
+        log.info(s"Replaying ${sequence.size } messages")
+        sequence.foreach(ref ! _)
+      case Terminated(ref)                ⇒
         viewers -= ref.asInstanceOf[ActorRef[BespokeMessage]]
-      case m: BespokeMessage.Activate ⇒
+        log.info(s"A viewer left, total of ${viewers.size } now")
+      case m: BespokeMessage.Activate     ⇒
         sequence :+= m
         viewers.foreach(_ ! m)
-      case m: BespokeMessage.Slide ⇒
+      case m: BespokeMessage.Slide        ⇒
         sequence :+= m
         viewers.foreach(_ ! m)
-      case m: BespokeMessage.Prev ⇒
+      case m: BespokeMessage.Prev         ⇒
         sequence :+= m
         viewers.foreach(_ ! m)
-      case m: BespokeMessage.Next ⇒
+      case m: BespokeMessage.Next         ⇒
         sequence :+= m
         viewers.foreach(_ ! m)
       case m@BespokeMessage.Deactivate(n) ⇒
         sequence :+= m
         viewers.foreach(_ ! m)
       case BespokeMessage.Connect         ⇒
         sequence = Vector(BespokeMessage.Connect)
+        log.info(s"Presenter joined, telling ${viewers.size } viewers to get ready")
         viewers.foreach(_ ! BespokeMessage.Connect)
       case BespokeMessage.Disconnect      ⇒
         sequence = Vector()
+        log.info(s"Presenter left, disconnecting from ${viewers.size } viewers")
         viewers.foreach(_ ! BespokeMessage.Disconnect)
     }
   }

frontend/src/main/scala/de/knutwalker/wdcm/Handout.scala

@@ -21,8 +21,13 @@ case object Handout extends Plugin with Websockets {
     var active = -1
     var max = 0
 
+    // block requests to a certain slide if it was not yet seen
     deck.on("slide", (e: BespokeEvent) ⇒ e.index <= max)
+
+    // block requests to the next slide if it was not yet seen
     deck.on("next", (e: BespokeEvent) ⇒ e.index < max)
+
+    // block requests to a certain slide if it was not yet seen
     deck.on("activate", (e: BespokeEvent) ⇒ (e.index <= max) && {
       Toastr.clear()
       active = e.index
@@ -33,16 +38,26 @@ case object Handout extends Plugin with Websockets {
       val data = TypedArrayBuffer.wrap(wsMsg.data.asInstanceOf[ArrayBuffer])
       val message = unpickler.fromBytes(data)
       message match {
+
+        // next is only processed if the handout is on the correct slide
         case BespokeMessage.Next(n) if n == active ⇒
           max = js.Math.max(n, max)
           deck.next()
+
+        // prev is only processed if the handout is on the correct slide
         case BespokeMessage.Prev(n) if n == active ⇒
           max = js.Math.max(n, max)
           deck.prev()
-        case BespokeMessage.Slide(n) if n != active    ⇒
+
+        // slide is always processed, as it signals a forced jump by the presenter
+        case BespokeMessage.Slide(n) if n != active ⇒
           max = js.Math.max(n, max)
           Toastr.remove()
           deck.slide(n)
+
+        // activate happens when the presenter proceeds to the next slide.
+        // it is only processed when the target is not already the current slide
+        // and it only applies automatically if the slide would be the next one
         case BespokeMessage.Activate(n) if n != active ⇒
           max = js.Math.max(n, max)
           val delta = n - previousPresenter
@@ -52,13 +67,20 @@ case object Handout extends Plugin with Websockets {
           } else toast(active, n) {
             deck.slide(n)
           }
+
+        // save which page the presenter moved away from to determine the
+        // direction they are going
         case BespokeMessage.Deactivate(n) ⇒
           previousPresenter = n
+
+        // connect signals a new presenter, so reset everything to zero
         case BespokeMessage.Connect                    ⇒
           max = 0
           active = 0
           deck.slide(0)
           Toastr.clear()
+
+        // don't handle other events (and don't fail when they arrive)
         case otherwise                                 ⇒
       }
     }