introduce support for checking multiple rooms in one go

config/config.go

@@ -10,6 +10,8 @@ import (
 	"time"
 )
 
+type rooms []string
+
 type configOption[T any] struct {
 	flagName         string
 	flagDefaultValue T
@@ -20,7 +22,7 @@ type configOption[T any] struct {
 type configOptions struct {
 	userID                       configOption[string]
 	token                        configOption[string]
-	room                         configOption[string]
+	rooms                        configOption[rooms]
 	printHomeserverMemberCount   configOption[bool]
 	homeserverVersionInfoTimeout configOption[time.Duration]
 }
@@ -28,7 +30,7 @@ type configOptions struct {
 type Config struct {
 	UserID                       string
 	Token                        string
-	Room                         string
+	Rooms                        rooms
 	PrintHomeserverMemberCount   bool
 	HomeserverVersionInfoTimeout time.Duration
 }
@@ -36,11 +38,20 @@ type Config struct {
 var configOpts = configOptions{
 	userID:                       configOption[string]{"user-id", "", "The Matrix user ID to use.", "MRVC_USER_ID"},
 	token:                        configOption[string]{"token", "", "The Matrix access token to use.", "MRVC_TOKEN"},
-	room:                         configOption[string]{"room", "", "The Matrix room to check.", "MRVC_ROOM"},
+	rooms:                        configOption[rooms]{"room", []string{}, "The Matrix room to check. The flag can be set multiple times to check multiple rooms.", "MRVC_ROOM"},
 	printHomeserverMemberCount:   configOption[bool]{"print-homeserver-member-count", false, "Print the member count for each homeserver.", "MRVC_PRINT_HOMESERVER_MEMBER_COUNT"},
 	homeserverVersionInfoTimeout: configOption[time.Duration]{"homeserver-version-info-timeout", time.Second * 5, "Timeout for getting the homeservers version information per homeserver.", "MRVC_HOMESERVER_VERSION_INFO_TIMEOUT"},
 }
 
+func (r *rooms) String() string {
+	return fmt.Sprint(*r)
+}
+
+func (r *rooms) Set(value string) error {
+	*r = append(*r, value)
+	return nil
+}
+
 func (configOpt configOption[T]) getFlagHelp() string {
 	return fmt.Sprintf("%s (EnvVar: %s)", configOpt.flagHelpBase, configOpt.envVarName)
 }
@@ -74,10 +85,15 @@ func (configOpt configOption[T]) getConfigValueWithError(configFlag *T, visitedF
 
 var userIdFlag = flag.String(configOpts.userID.getFlagArgs())
 var tokenFlag = flag.String(configOpts.token.getFlagArgs())
-var roomFlag = flag.String(configOpts.room.getFlagArgs())
 var printHomeserverMemberCountFlag = flag.Bool(configOpts.printHomeserverMemberCount.getFlagArgs())
 var homeserverVersionInfoTimeoutFlag = flag.Duration(configOpts.homeserverVersionInfoTimeout.getFlagArgs())
 
+var roomsFlag rooms
+
+func init() {
+	flag.Var(&roomsFlag, configOpts.rooms.flagName, configOpts.rooms.getFlagHelp())
+}
+
 func Get() Config {
 	flag.Parse()
 
@@ -98,7 +114,7 @@ func Get() Config {
 	if err != nil {
 		log.Fatal("A Matrix access token must be provided.")
 	}
-	config.Room, err = configOpts.room.getConfigValueWithError(roomFlag, visitedFlags, func(envVar string) string { return envVar })
+	config.Rooms, err = configOpts.rooms.getConfigValueWithError(&roomsFlag, visitedFlags, func(envVar string) rooms { return []string{envVar} })
 	if err != nil {
 		log.Fatal("A Matrix room must be provided.")
 	}

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,57 +315,82 @@ func main() {
 		fclient.WithTimeout(config.HomeserverVersionInfoTimeout),
 	)
 
-	var roomId id.RoomID
+	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(config.Room, "#") {
-		resolvedAlias, err := client.ResolveAlias(context.Background(), id.RoomAlias(config.Room))
+		if strings.HasPrefix(room, "#") {
+			resolvedAlias, err := client.ResolveAlias(context.Background(), id.RoomAlias(room))
 			if err != nil {
 				log.Fatal(err)
 			}
-		roomId = resolvedAlias.RoomID
+			givenRoomsByRoomID[resolvedAlias.RoomID] = room
 		} else {
-		roomId = id.RoomID(config.Room)
+			givenRoomsByRoomID[id.RoomID(room)] = room
+		}
 	}
 
-	joinedMembers, err := client.JoinedMembers(context.Background(), roomId)
+	joinedMembersByRoomID := make(map[id.RoomID]*mautrix.RespJoinedMembers)
+	for roomID := range givenRoomsByRoomID {
+		joinedMembers, err := client.JoinedMembers(context.Background(), roomID)
 		if err != nil {
 			log.Fatal(err)
 		}
-
-	membersByHomeservers := make(map[string]uint)
-	for key := range joinedMembers.Joined {
-		membersByHomeservers[key.Homeserver()]++
+		joinedMembersByRoomID[roomID] = joinedMembers
 	}
 
-	homeservers := make([]string, 0, len(membersByHomeservers))
-	for hs := range membersByHomeservers {
+	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
+	}
+
+	homeserverSet := make(map[string]bool)
+	for _, membersByHomeserver := range membersByHomeserverByRoomID {
+		for hs := range membersByHomeserver {
+			homeserverSet[hs] = true
+		}
+	}
+
+	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)
 
 			// Add to counters.
-		membersByMaxRoomVersion[maxRoomVersion] += value
-		membersByServerPath[ServerPath{maxRoomVersion, serverVersionInfo.Server.Name}] += value
-		membersByVersionPath[VersionPath{maxRoomVersion, serverVersionInfo.Server.Name, serverVersionInfo.Server.Version}] += value
+			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]
+			// 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
+			}
+			serverMap, ok := maxRoomVersionMap[maxRoomVersion]
 			if !ok {
 				serverMap = make(map[string](map[string](map[string]uint)))
-			maxRoomVersionInfo[maxRoomVersion] = serverMap
+				maxRoomVersionMap[maxRoomVersion] = serverMap
 			}
 			versionMap, ok := serverMap[serverVersionInfo.Server.Name]
 			if !ok {
@@ -370,23 +402,25 @@ func main() {
 				homeserverMap = make(map[string]uint)
 				versionMap[serverVersionInfo.Server.Version] = homeserverMap
 			}
-		homeserverMap[key] = value
+			homeserverMap[hs] = members
+		}
 	}
 
+	for roomID, roomIDValue := range roomMaxVersionInfos {
 		fmt.Println("Room:")
-	fmt.Printf("%s -> %d\n\n", config.Room, len(joinedMembers.Joined))
+		fmt.Printf("  %s -> %d\n", givenRoomsByRoomID[roomID], membersByRoomID[roomID])
 
 		fmt.Println("Version Support:")
 
-	maxRoomVersionKeys := make([]string, 0, len(maxRoomVersionInfo))
-	for key := range maxRoomVersionInfo {
+		maxRoomVersionKeys := make([]string, 0, len(roomIDValue))
+		for key := range roomIDValue {
 			maxRoomVersionKeys = append(maxRoomVersionKeys, key)
 		}
 		slices.SortFunc(maxRoomVersionKeys, compareVersionStrings)
 		for _, maxRoomVersionKey := range maxRoomVersionKeys {
-		maxRoomVersionValue := maxRoomVersionInfo[maxRoomVersionKey]
+			maxRoomVersionValue := roomIDValue[maxRoomVersionKey]
 
-		fmt.Printf("%s -> %d\n", maxRoomVersionKey, membersByMaxRoomVersion[maxRoomVersionKey])
+			fmt.Printf("  %s -> %d\n", maxRoomVersionKey, membersByMaxRoomVersion[MaxRoomVersionPath{roomID, maxRoomVersionKey}])
 
 			serverKeys := make([]string, 0, len(maxRoomVersionValue))
 			for key := range maxRoomVersionValue {
@@ -396,7 +430,7 @@ func main() {
 			for _, serverKey := range serverKeys {
 				serverValue := maxRoomVersionValue[serverKey]
 
-			fmt.Printf("  %s -> %d\n", serverKey, membersByServerPath[ServerPath{maxRoomVersionKey, serverKey}])
+				fmt.Printf("    %s -> %d\n", serverKey, membersByServerPath[ServerPath{roomID, maxRoomVersionKey, serverKey}])
 
 				versionKeys := make([]string, 0, len(serverValue))
 				for key := range serverValue {
@@ -406,7 +440,7 @@ func main() {
 				for _, versionKey := range versionKeys {
 					versionValue := serverValue[versionKey]
 
-				fmt.Printf("    %s -> %d\n", versionKey, membersByVersionPath[VersionPath{maxRoomVersionKey, serverKey, versionKey}])
+					fmt.Printf("      %s -> %d\n", versionKey, membersByVersionPath[VersionPath{roomID, maxRoomVersionKey, serverKey, versionKey}])
 
 					if config.PrintHomeserverMemberCount {
 						homeserverKeys := make([]string, 0, len(versionValue))
@@ -423,4 +457,7 @@ func main() {
 				}
 			}
 		}
+
+		fmt.Println()
+	}
 }