introduce support for checking multiple rooms in one go

2026-01-10 16:06:33 +01:00 · 2025-08-17 18:38:04 +02:00 · 2025-08-17 18:38:04 +02:00 · c42777e741
commit c42777e741
parent cbba786b5c
2 changed files with 142 additions and 89 deletions
--- a/main.go
+++ b/main.go
@ -23,12 +23,19 @@ type HomeserverServerVersionInfo struct {
 	ServerVersionInfo fclient.Version
 }

+type MaxRoomVersionPath struct {
+	RoomID         id.RoomID
+	MaxRoomVersion string
+}
+
 type ServerPath struct {
+	RoomID         id.RoomID
 	MaxRoomVersion string
 	Server         string
 }

 type VersionPath struct {
+	RoomID         id.RoomID
 	MaxRoomVersion string
 	Server         string
 	Version        string
@ -308,119 +315,149 @@ func main() {
 		fclient.WithTimeout(config.HomeserverVersionInfoTimeout),
 	)

-	var roomId id.RoomID
-	// Check, if given room is an alias and try to resolve it into a room id.
-	if strings.HasPrefix(config.Room, "#") {
-		resolvedAlias, err := client.ResolveAlias(context.Background(), id.RoomAlias(config.Room))
+	givenRoomsByRoomID := make(map[id.RoomID]string)
+	for _, room := range config.Rooms {
+		// Check, if given room is an alias and try to resolve it into a room id.
+		if strings.HasPrefix(room, "#") {
+			resolvedAlias, err := client.ResolveAlias(context.Background(), id.RoomAlias(room))
+			if err != nil {
+				log.Fatal(err)
+			}
+			givenRoomsByRoomID[resolvedAlias.RoomID] = room
+		} else {
+			givenRoomsByRoomID[id.RoomID(room)] = room
+		}
+	}
+
+	joinedMembersByRoomID := make(map[id.RoomID]*mautrix.RespJoinedMembers)
+	for roomID := range givenRoomsByRoomID {
+		joinedMembers, err := client.JoinedMembers(context.Background(), roomID)
 		if err != nil {
 			log.Fatal(err)
 		}
-		roomId = resolvedAlias.RoomID
-	} else {
-		roomId = id.RoomID(config.Room)
+		joinedMembersByRoomID[roomID] = joinedMembers
 	}

-	joinedMembers, err := client.JoinedMembers(context.Background(), roomId)
-	if err != nil {
-		log.Fatal(err)
+	membersByHomeserverByRoomID := make(map[id.RoomID](map[string]uint))
+	for roomID, joinedMembers := range joinedMembersByRoomID {
+		membersByHomeserver := make(map[string]uint)
+		for key := range joinedMembers.Joined {
+			membersByHomeserver[key.Homeserver()]++
+		}
+		membersByHomeserverByRoomID[roomID] = membersByHomeserver
 	}

-	membersByHomeservers := make(map[string]uint)
-	for key := range joinedMembers.Joined {
-		membersByHomeservers[key.Homeserver()]++
+	homeserverSet := make(map[string]bool)
+	for _, membersByHomeserver := range membersByHomeserverByRoomID {
+		for hs := range membersByHomeserver {
+			homeserverSet[hs] = true
+		}
 	}

-	homeservers := make([]string, 0, len(membersByHomeservers))
-	for hs := range membersByHomeservers {
+	homeservers := make([]string, 0, len(homeserverSet))
+	for hs := range homeserverSet {
 		homeservers = append(homeservers, hs)
 	}

 	serverVersionInfoByHomeserver := getServerVersionInfoByHomeserver(homeservers, federationClient)

 	// Info map tree.
-	maxRoomVersionInfo := make(map[string](map[string](map[string](map[string]uint))))
+	roomMaxVersionInfos := make(map[id.RoomID](map[string](map[string](map[string](map[string]uint)))))
 	// Member counters.
-	membersByMaxRoomVersion := make(map[string]uint)
+	membersByRoomID := make(map[id.RoomID]uint)
+	membersByMaxRoomVersion := make(map[MaxRoomVersionPath]uint)
 	membersByServerPath := make(map[ServerPath]uint)
 	membersByVersionPath := make(map[VersionPath]uint)

-	for key, value := range membersByHomeservers {
-		serverVersionInfo := serverVersionInfoByHomeserver[key]
+	for roomID, membersByHomeserver := range membersByHomeserverByRoomID {
+		for hs, members := range membersByHomeserver {
+			serverVersionInfo := serverVersionInfoByHomeserver[hs]

-		maxRoomVersion := getMaxRoomVersion(serverVersionInfo)
+			maxRoomVersion := getMaxRoomVersion(serverVersionInfo)

-		// Add to counters.
-		membersByMaxRoomVersion[maxRoomVersion] += value
-		membersByServerPath[ServerPath{maxRoomVersion, serverVersionInfo.Server.Name}] += value
-		membersByVersionPath[VersionPath{maxRoomVersion, serverVersionInfo.Server.Name, serverVersionInfo.Server.Version}] += value
+			// Add to counters.
+			membersByRoomID[roomID] += members
+			membersByMaxRoomVersion[MaxRoomVersionPath{roomID, maxRoomVersion}] += members
+			membersByServerPath[ServerPath{roomID, maxRoomVersion, serverVersionInfo.Server.Name}] += members
+			membersByVersionPath[VersionPath{roomID, maxRoomVersion, serverVersionInfo.Server.Name, serverVersionInfo.Server.Version}] += members

-		// Sort into maxRoomVersionInfo map tree.
-		serverMap, ok := maxRoomVersionInfo[maxRoomVersion]
-		if !ok {
-			serverMap = make(map[string](map[string](map[string]uint)))
-			maxRoomVersionInfo[maxRoomVersion] = serverMap
-		}
-		versionMap, ok := serverMap[serverVersionInfo.Server.Name]
-		if !ok {
-			versionMap = make(map[string](map[string]uint))
-			serverMap[serverVersionInfo.Server.Name] = versionMap
-		}
-		homeserverMap, ok := versionMap[serverVersionInfo.Server.Version]
-		if !ok {
-			homeserverMap = make(map[string]uint)
-			versionMap[serverVersionInfo.Server.Version] = homeserverMap
-		}
-		homeserverMap[key] = value
-	}
-
-	fmt.Println("Room:")
-	fmt.Printf("%s -> %d\n\n", config.Room, len(joinedMembers.Joined))
-
-	fmt.Println("Version Support:")
-
-	maxRoomVersionKeys := make([]string, 0, len(maxRoomVersionInfo))
-	for key := range maxRoomVersionInfo {
-		maxRoomVersionKeys = append(maxRoomVersionKeys, key)
-	}
-	slices.SortFunc(maxRoomVersionKeys, compareVersionStrings)
-	for _, maxRoomVersionKey := range maxRoomVersionKeys {
-		maxRoomVersionValue := maxRoomVersionInfo[maxRoomVersionKey]
-
-		fmt.Printf("%s -> %d\n", maxRoomVersionKey, membersByMaxRoomVersion[maxRoomVersionKey])
-
-		serverKeys := make([]string, 0, len(maxRoomVersionValue))
-		for key := range maxRoomVersionValue {
-			serverKeys = append(serverKeys, key)
-		}
-		sort.Strings(serverKeys)
-		for _, serverKey := range serverKeys {
-			serverValue := maxRoomVersionValue[serverKey]
-
-			fmt.Printf("  %s -> %d\n", serverKey, membersByServerPath[ServerPath{maxRoomVersionKey, serverKey}])
-
-			versionKeys := make([]string, 0, len(serverValue))
-			for key := range serverValue {
-				versionKeys = append(versionKeys, key)
+			// Sort into roomMaxVersionInfos map tree.
+			maxRoomVersionMap, ok := roomMaxVersionInfos[roomID]
+			if !ok {
+				maxRoomVersionMap = make(map[string](map[string](map[string](map[string]uint))))
+				roomMaxVersionInfos[roomID] = maxRoomVersionMap
 			}
-			slices.SortFunc(versionKeys, compareVersionStrings)
-			for _, versionKey := range versionKeys {
-				versionValue := serverValue[versionKey]
+			serverMap, ok := maxRoomVersionMap[maxRoomVersion]
+			if !ok {
+				serverMap = make(map[string](map[string](map[string]uint)))
+				maxRoomVersionMap[maxRoomVersion] = serverMap
+			}
+			versionMap, ok := serverMap[serverVersionInfo.Server.Name]
+			if !ok {
+				versionMap = make(map[string](map[string]uint))
+				serverMap[serverVersionInfo.Server.Name] = versionMap
+			}
+			homeserverMap, ok := versionMap[serverVersionInfo.Server.Version]
+			if !ok {
+				homeserverMap = make(map[string]uint)
+				versionMap[serverVersionInfo.Server.Version] = homeserverMap
+			}
+			homeserverMap[hs] = members
+		}
+	}

-				fmt.Printf("    %s -> %d\n", versionKey, membersByVersionPath[VersionPath{maxRoomVersionKey, serverKey, versionKey}])
+	for roomID, roomIDValue := range roomMaxVersionInfos {
+		fmt.Println("Room:")
+		fmt.Printf("  %s -> %d\n", givenRoomsByRoomID[roomID], membersByRoomID[roomID])

-				if config.PrintHomeserverMemberCount {
-					homeserverKeys := make([]string, 0, len(versionValue))
-					for key := range versionValue {
-						homeserverKeys = append(homeserverKeys, key)
-					}
-					sort.Strings(homeserverKeys)
-					for _, homeserverKey := range homeserverKeys {
-						homeserverValue := versionValue[homeserverKey]
+		fmt.Println("Version Support:")

-						fmt.Printf("      %s -> %d\n", homeserverKey, homeserverValue)
+		maxRoomVersionKeys := make([]string, 0, len(roomIDValue))
+		for key := range roomIDValue {
+			maxRoomVersionKeys = append(maxRoomVersionKeys, key)
+		}
+		slices.SortFunc(maxRoomVersionKeys, compareVersionStrings)
+		for _, maxRoomVersionKey := range maxRoomVersionKeys {
+			maxRoomVersionValue := roomIDValue[maxRoomVersionKey]
+
+			fmt.Printf("  %s -> %d\n", maxRoomVersionKey, membersByMaxRoomVersion[MaxRoomVersionPath{roomID, maxRoomVersionKey}])
+
+			serverKeys := make([]string, 0, len(maxRoomVersionValue))
+			for key := range maxRoomVersionValue {
+				serverKeys = append(serverKeys, key)
+			}
+			sort.Strings(serverKeys)
+			for _, serverKey := range serverKeys {
+				serverValue := maxRoomVersionValue[serverKey]
+
+				fmt.Printf("    %s -> %d\n", serverKey, membersByServerPath[ServerPath{roomID, maxRoomVersionKey, serverKey}])
+
+				versionKeys := make([]string, 0, len(serverValue))
+				for key := range serverValue {
+					versionKeys = append(versionKeys, key)
+				}
+				slices.SortFunc(versionKeys, compareVersionStrings)
+				for _, versionKey := range versionKeys {
+					versionValue := serverValue[versionKey]
+
+					fmt.Printf("      %s -> %d\n", versionKey, membersByVersionPath[VersionPath{roomID, maxRoomVersionKey, serverKey, versionKey}])
+
+					if config.PrintHomeserverMemberCount {
+						homeserverKeys := make([]string, 0, len(versionValue))
+						for key := range versionValue {
+							homeserverKeys = append(homeserverKeys, key)
+						}
+						sort.Strings(homeserverKeys)
+						for _, homeserverKey := range homeserverKeys {
+							homeserverValue := versionValue[homeserverKey]
+
+							fmt.Printf("        %s -> %d\n", homeserverKey, homeserverValue)
+						}
 					}
 				}
 			}
 		}
+
+		fmt.Println()
 	}
 }