From b767b34d97fdacd891702b041cc5eb1fdcb0b0a3 Mon Sep 17 00:00:00 2001
From: Sam Anthony <sam@samanthony.xyz>
Date: Fri, 15 Nov 2024 12:16:53 -0500
Subject: reliable multicast: record addresses of group members

---
 src/main/java/derms/net/rmulticast/Receive.java           |  7 ++++++-
 src/main/java/derms/net/rmulticast/ReliableMulticast.java | 14 ++++++++------
 2 files changed, 14 insertions(+), 7 deletions(-)

(limited to 'src/main/java/derms')

diff --git a/src/main/java/derms/net/rmulticast/Receive.java b/src/main/java/derms/net/rmulticast/Receive.java
index f0d1909..996e0db 100644
--- a/src/main/java/derms/net/rmulticast/Receive.java
+++ b/src/main/java/derms/net/rmulticast/Receive.java
@@ -6,6 +6,7 @@ import derms.net.Packet;
 import java.io.IOException;
 import java.io.Serializable;
 import java.net.DatagramPacket;
+import java.net.InetAddress;
 import java.util.Set;
 import java.util.concurrent.BlockingQueue;
 import java.util.logging.Logger;
@@ -18,15 +19,17 @@ class Receive<T extends Serializable & Hashable> implements Runnable {
     private final Set<MessageID> negativeAcks;
     private final ReceivedSet<T> received;
     private final BlockingQueue<Message<T>> retransmissions;
+    private final Set<InetAddress> groupMembers;
     private final BlockingQueue<Message<T>> delivered;
     private final Logger log;
 
-    Receive(ConcurrentMulticastSocket inSock, Set<MessageID> positiveAcks, Set<MessageID> negativeAcks, BlockingQueue<Message<T>> retransmissions, BlockingQueue<Message<T>> delivered) {
+    Receive(ConcurrentMulticastSocket inSock, Set<MessageID> positiveAcks, Set<MessageID> negativeAcks, BlockingQueue<Message<T>> retransmissions, Set<InetAddress> groupMembers, BlockingQueue<Message<T>> delivered) {
         this.inSock = inSock;
         this.positiveAcks = positiveAcks;
         this.negativeAcks = negativeAcks;
         this.received = new ReceivedSet<T>();
         this.retransmissions = retransmissions;
+        this.groupMembers = groupMembers;
         this.delivered = delivered;
         this.log = Logger.getLogger(this.getClass().getName());
     }
@@ -51,6 +54,8 @@ class Receive<T extends Serializable & Hashable> implements Runnable {
         received.add(msg);
         delivered.add(msg);
 
+        groupMembers.add(msg.sender);
+
         negativeAcks.remove(msg.id());
         retransmissions.remove(msg);
 
diff --git a/src/main/java/derms/net/rmulticast/ReliableMulticast.java b/src/main/java/derms/net/rmulticast/ReliableMulticast.java
index 8b39ae6..de07f39 100644
--- a/src/main/java/derms/net/rmulticast/ReliableMulticast.java
+++ b/src/main/java/derms/net/rmulticast/ReliableMulticast.java
@@ -16,28 +16,30 @@ import java.util.logging.Logger;
 
 /** TODO */
 public class ReliableMulticast<T extends Serializable & Hashable> {
+    private final SocketAddress group;
+    private final InetAddress laddr; // Local address.
     private final Set<MessageID> positiveAcks; // Positively acknowledged messages.
     private final Set<MessageID> negativeAcks; // Negatively acknowledged messages.
     private final BlockingQueue<Message<T>> retransmissions; // Messages pending retransmission.
     private final AtomicReference<Instant> lastSend;
-    private final SocketAddress group;
     private final ConcurrentMulticastSocket outSock;
-    private final InetAddress laddr; // Local address.
+    private final Set<InetAddress> groupMembers;
     private final BlockingQueue<Message<T>> delivered;
     private final Logger log;
 
     public ReliableMulticast(InetSocketAddress group, InetAddress laddr) throws IOException {
+        this.group = group;
+        this.laddr = laddr;
+
         this.positiveAcks = new ConcurrentHashMap<MessageID, Void>().keySet();
         this.negativeAcks = new ConcurrentHashMap<MessageID, Void>().keySet();
         this.retransmissions = new LinkedBlockingQueue<Message<T>>();
         this.lastSend = new AtomicReference<Instant>(Instant.now());
 
-        this.group = group;
-
         this.outSock = new ConcurrentMulticastSocket(group.getPort());
         this.outSock.joinGroup(group.getAddress());
 
-        this.laddr = laddr;
+        this.groupMembers = new ConcurrentHashMap<InetAddress, Void>().keySet();
 
         this.delivered = new LinkedBlockingQueue<Message<T>>();
 
@@ -45,7 +47,7 @@ public class ReliableMulticast<T extends Serializable & Hashable> {
 
         ConcurrentMulticastSocket inSock = new ConcurrentMulticastSocket();
         inSock.joinGroup(group.getAddress());
-        (new Thread(new Receive<T>(inSock, positiveAcks, negativeAcks, retransmissions, delivered))).start();
+        (new Thread(new Receive<T>(inSock, positiveAcks, negativeAcks, retransmissions, groupMembers, delivered))).start();
 
         (new Thread(new Retransmit<T>(retransmissions, outSock, group))).start();
     }
-- 
cgit v1.2.3