misc/infrastructure/powerbot/powerlevels.go

   1 package main
   2
   3 import (
   4         "github.com/google/go-cmp/cmp"
   5         "log"
   6         "math"
   7         "maunium.net/go/mautrix"
   8         "maunium.net/go/mautrix/event"
   9         "maunium.net/go/mautrix/id"
  10         "time"
  11 )
  12
  13 const (
  14         idleScore   = 1
  15         activeScore = 100
  16         activeTime  = 5 * time.Minute
  17         // 15 minutes idling = PL 1.
  18         minPowerScore = 15 * 60 * idleScore
  19         minPowerLevel = 1
  20         // 1 year fulltime active dev = PL 10.
  21         maxPowerScore = 3600 * (365*24*idleScore + 8*261*(activeScore-idleScore))
  22         maxPowerLevel = 9
  23         // Expire power level if no event for 1 month. Level comes back on next event, including join.
  24         powerExpireTime = time.Hour * 24 * 30
  25         // Maximum count of ACL entries. Should avoid hitting the 64k limit.
  26         maxPowerLevelEntries = 2048
  27 )
  28
  29 func logPowerLevelBounds() {
  30         for i := minPowerLevel; i <= maxPowerLevel; i++ {
  31                 score := minPowerScore * math.Pow(maxPowerScore/minPowerScore, float64(i-minPowerLevel)/float64(maxPowerLevel-minPowerLevel))
  32                 log.Printf("Power level %d requires score %v (= %v idle or %v active).",
  33                         i, score,
  34                         time.Duration(float64(time.Second)*score/idleScore),
  35                         time.Duration(float64(time.Second)*score/activeScore),
  36                 )
  37         }
  38 }
  39
  40 func computePowerLevel(def int, score Score) (int, float64) {
  41         points := score.Idle.Seconds()*idleScore + score.Active.Seconds()*activeScore
  42         if points <= 0 {
  43                 return def, math.Inf(-1)
  44         }
  45         raw := minPowerLevel + (maxPowerLevel-minPowerLevel)*math.Log(points/minPowerScore)/math.Log(maxPowerScore/minPowerScore)
  46         if raw < minPowerLevel {
  47                 return def, raw
  48         }
  49         if points > maxPowerScore {
  50                 return maxPowerLevel, raw
  51         }
  52         return int(math.Floor(raw)), raw
  53 }
  54
  55 func allPowerLevels(roomLevels *event.PowerLevelsEventContent) []int {
  56         ret := make([]int, 0, len(roomLevels.Events)+5)
  57         for _, level := range roomLevels.Events {
  58                 ret = append(ret, level)
  59         }
  60         ret = append(ret, roomLevels.EventsDefault)
  61         if roomLevels.InvitePtr != nil {
  62                 ret = append(ret, *roomLevels.InvitePtr)
  63         }
  64         if roomLevels.KickPtr != nil {
  65                 ret = append(ret, *roomLevels.KickPtr)
  66         }
  67         if roomLevels.BanPtr != nil {
  68                 ret = append(ret, *roomLevels.BanPtr)
  69         }
  70         if roomLevels.RedactPtr != nil {
  71                 ret = append(ret, *roomLevels.RedactPtr)
  72         }
  73         return ret
  74 }
  75
  76 func syncPowerLevels(client *mautrix.Client, room id.RoomID, roomGroup []id.RoomID, scores map[id.RoomID]map[id.UserID]*Score, force bool) {
  77         roomLevels := roomPowerLevels[room]
  78         if roomLevels == nil {
  79                 log.Printf("trying to ensure power levels for room %v, but did not get power level map yet", room)
  80                 return
  81         }
  82         tryUpdate := force
  83         for _, level := range allPowerLevels(roomLevels) {
  84                 if minPowerLevel <= level && level <= maxPowerLevel {
  85                         tryUpdate = true
  86                 }
  87         }
  88         if !tryUpdate {
  89                 log.Printf("room %v skipping because PLs currently do not matter", room)
  90                 return
  91         }
  92         log.Printf("room %v considering to update PLs", room)
  93         if fullySynced {
  94                 for user, score := range scores[room] {
  95                         // Expire users that for some reason did not get pruned from the database.
  96                         // This may cause them to lose their power level below.
  97                         if _, found := roomUsers[room][user]; !found && score.CurrentState != NotActive {
  98                                 log.Printf("Pruning long inactive user %v from room %v.", user, room)
  99                                 setUserStateAt(room, user, time.Now(), NotActive, NotActive)
 100                                 score.CurrentState = NotActive
 101                         }
 102                 }
 103         }
 104         newRoomLevels := *roomLevels
 105         newRoomLevels.Users = make(map[id.UserID]int)
 106         for user, level := range roomLevels.Users {
 107                 if level == roomLevels.UsersDefault {
 108                         continue
 109                 }
 110                 // TODO: Also skip users who aren't in the room for ages.
 111                 score := scores[room][user]
 112                 if level >= minPowerLevel && level <= maxPowerLevel && score.CurrentState == NotActive && time.Now().After(score.LastEvent.Add(powerExpireTime)) {
 113                         // User is inactive - prune them from the power level list. Saves space.
 114                         // But this doesn't mark the list dirty as there is no need to send an update.
 115                         log.Printf("room %v user %v power level: PRUNE %v (%v)", room, user, level, score)
 116                         continue
 117                 }
 118                 newRoomLevels.Users[user] = level
 119         }
 120         dirty := false
 121         log.Printf("room %v", room)
 122         for user, score := range scores[room] {
 123                 if score.CurrentState == NotActive {
 124                         // Do not add/bump power levels for users not in the room.
 125                         continue
 126                 }
 127                 prevLevel := roomLevels.Users[user]
 128                 level, raw := computePowerLevel(roomLevels.UsersDefault, *score)
 129                 for _, otherRoom := range roomGroup {
 130                         if otherRoom == room {
 131                                 continue
 132                         }
 133                         otherScore := scores[otherRoom][user]
 134                         if otherScore == nil {
 135                                 continue
 136                         }
 137                         otherLevel, otherRaw := computePowerLevel(roomLevels.UsersDefault, *otherScore)
 138                         if otherLevel > level {
 139                                 level = otherLevel
 140                         }
 141                         if otherRaw > raw {
 142                                 raw = otherRaw
 143                         }
 144                 }
 145                 if level > prevLevel {
 146                         log.Printf("room %v user %v power level: INCREASE %v -> %v (%v, %v)", room, user, prevLevel, level, raw, score)
 147                         newRoomLevels.Users[user] = level
 148                         dirty = true
 149                 } else if level < prevLevel {
 150                         log.Printf("room %v user %v power level: SKIP %v -> %v (%v, %v)", room, user, prevLevel, level, raw, score)
 151                 } else {
 152                         log.Printf("room %v user %v power level: KEEP %v -> %v (%v, %v)", room, user, prevLevel, level, raw, score)
 153                 }
 154         }
 155         clearPowerLevel := minPowerLevel
 156         for len(newRoomLevels.Users) > maxPowerLevelEntries && clearPowerLevel <= maxPowerLevel {
 157                 log.Printf("room %v not including power level %d to reduce message size", clearPowerLevel)
 158                 for user, level := range newRoomLevels.Users {
 159                         if level == clearPowerLevel {
 160                                 delete(newRoomLevels.Users, user)
 161                                 dirty = true
 162                         }
 163                 }
 164                 clearPowerLevel++
 165         }
 166         if dirty {
 167                 diff := cmp.Diff(roomLevels.Users, newRoomLevels.Users)
 168                 log.Printf("room %v power level update:\n%v", room, diff)
 169                 _, err := client.SendStateEvent(room, event.StatePowerLevels, "", newRoomLevels)
 170                 if err != nil {
 171                         log.Printf("Failed to update power levels: %v", err)
 172                 }
 173         } else {
 174                 log.Printf("room %v nothing to update", room)
 175         }
 176 }