X-Git-Url: https://juplo.de/gitweb/?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fde%2Fjuplo%2Fkafka%2Fchat%2Fbackend%2Fpersistence%2Fkafka%2FKafkaChatRoomService.java;h=91b50312cf80a86f28ee35c87db10db2174f8f1d;hb=cdf16c3c5f657a2c07cc2b9f34a30a03eb9ddb9d;hp=79f2e63a0023c29967389a0c422e06d3b58018b6;hpb=409bf8614f1fb53cfb199b2377b1aae9fa3dd433;p=demos%2Fkafka%2Fchat

diff --git a/src/main/java/de/juplo/kafka/chat/backend/persistence/kafka/KafkaChatRoomService.java b/src/main/java/de/juplo/kafka/chat/backend/persistence/kafka/KafkaChatRoomService.java
index 79f2e63a..91b50312 100644
--- a/src/main/java/de/juplo/kafka/chat/backend/persistence/kafka/KafkaChatRoomService.java
+++ b/src/main/java/de/juplo/kafka/chat/backend/persistence/kafka/KafkaChatRoomService.java
@@ -3,10 +3,8 @@ package de.juplo.kafka.chat.backend.persistence.kafka;
 import de.juplo.kafka.chat.backend.domain.ChatRoomService;
 import de.juplo.kafka.chat.backend.domain.Message;
 import de.juplo.kafka.chat.backend.domain.MessageMutationException;
-import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.kafka.clients.producer.Producer;
-import org.apache.kafka.clients.producer.ProducerRecord;
 import org.apache.kafka.common.TopicPartition;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -18,7 +16,6 @@ import java.util.UUID;
 
 
 @Slf4j
-@RequiredArgsConstructor
 public class KafkaChatRoomService implements ChatRoomService
 {
   private final Producer<String, MessageTo> producer;
@@ -28,74 +25,73 @@ public class KafkaChatRoomService implements ChatRoomService
 
   private final LinkedHashMap<Message.MessageKey, Message> messages = new LinkedHashMap<>();
 
-  private long offset = 0l;
+  private volatile MessageHandlingStrategy strategy;
+
+
+  public KafkaChatRoomService(
+      Producer<String, MessageTo> producer,
+      TopicPartition tp,
+      UUID chatRoomId,
+      ZoneOffset zoneOffset)
+  {
+    this.producer = producer;
+    this.tp = tp;
+    this.chatRoomId = chatRoomId;
+    this.zoneOffset = zoneOffset;
+    this.strategy = new ChatroomInactiveMessageHandlingStrategy(tp);
+  }
 
 
   @Override
-  public Mono<Message> persistMessage(
+  synchronized public Mono<Message> persistMessage(
     Message.MessageKey key,
     LocalDateTime timestamp,
     String text)
   {
-    return Mono.create(sink ->
-    {
-      ProducerRecord<String, MessageTo> record =
-          new ProducerRecord<>(
-              tp.topic(),
-              tp.partition(),
-              timestamp.toEpochSecond(zoneOffset),
-              chatRoomId.toString(),
-              MessageTo.of(key.getUsername(), key.getMessageId(), text));
+    return strategy.persistMessage(key, timestamp, text);
+  }
 
-      producer.send(record, ((metadata, exception) ->
+  protected void addMessage(Message message) throws MessageMutationException
+  {
+    Message existingMessage = messages.get(message.getKey());
+
+    // TODO: Ist der Test nötig, oder wird das durch den Kontrollierten Wechsel
+    // der Strategie ggf. schon abgefangen? Weil: Wenn es nur um die Sorge geht,
+    // das eine Nachricht schon "durch den Nutzer" anders geschrieben wurde,
+    // fängt dies bereits der ChatRoom ab.
+    // Die Überprüfung hier war vor dem Hintergrund der Sorge hinzugefügt worden,
+    // dass die Nachricht wegen Verschluckern in Kafka / beim Strategiewechsel / ??
+    // doppelt aufschlägt...
+    if (existingMessage == null)
+    {
+      messages.put(message.getKey(), message);
+    }
+    else
+    {
+      if (!existingMessage.getMessageText().equals(message.getMessageText()))
       {
-        if (metadata != null)
-        {
-          // On successful send
-          Message message = messages.get(key);
-          if (message != null)
-          {
-            if (message.getMessageText().equals(text))
-            {
-              // Warn and emit existing message
-              log.warn(
-                  "Keeping existing message with {}@{} for {}",
-                  message.getSerialNumber(),
-                  message.getTimestamp(), key);
-            }
-            else
-            {
-              // Emit error and abort
-              sink.error(new MessageMutationException(message, text));
-              return;
-            }
-          }
-          else
-          {
-            // Emit new message
-            message = new Message(key, metadata.offset(), timestamp, text);
-            messages.put(message.getKey(), message);
-          }
+        throw new MessageMutationException(existingMessage, message.getMessageText());
+      }
 
-          sink.success();
-        }
-        else
-        {
-          // On send-failure
-          sink.error(exception);
-        }
-      }));
-    });
+      // Warn and emit existing message
+      log.warn(
+          "Keeping existing message with {}@{} for {}",
+          existingMessage.getSerialNumber(),
+          existingMessage.getTimestamp(),
+          existingMessage.getKey());
+    }
   }
 
   @Override
-  public Mono<Message> getMessage(Message.MessageKey key)
+  synchronized public Mono<Message> getMessage(Message.MessageKey key)
   {
+    // TODO: Aufrufe, auf eine Nachricht (einge gewisse Zeit) warten lassen
+    // und dann bedienen, wenn der der Callback vom Producer aufgerufen wird?
     return Mono.fromSupplier(() -> messages.get(key));
   }
 
   @Override
-  public Flux<Message> getMessages(long first, long last)
+  synchronized public Flux<Message> getMessages(long first, long last)
   {
     return Flux.fromStream(messages
       .values()