From f10a0556b3487511b6678cd3729b521c4c06952a Mon Sep 17 00:00:00 2001 From: Thibault Duplessis Date: Wed, 12 Jul 2023 08:49:03 +0200 Subject: [PATCH] remove A.unit, also scala tweaks apparently we no longer need to explicitely return a Unit --- app/Env.scala | 2 +- app/controllers/Account.scala | 2 +- app/controllers/Auth.scala | 2 +- app/controllers/Clas.scala | 2 +- app/controllers/Fishnet.scala | 2 +- app/controllers/LilaController.scala | 2 +- app/controllers/Team.scala | 2 +- modules/activity/src/main/Env.scala | 37 +++-- modules/analyse/src/main/Env.scala | 2 +- modules/api/src/main/AccountClosure.scala | 4 +- modules/api/src/main/Env.scala | 4 +- modules/api/src/main/EventStream.scala | 12 +- modules/bookmark/src/main/Env.scala | 7 +- modules/bot/src/main/GameStateStream.scala | 19 ++- .../challenge/src/main/ChallengeBulk.scala | 2 +- .../src/main/ChallengeKeepAliveStream.scala | 34 ++--- modules/challenge/src/main/Env.scala | 4 +- modules/chat/src/main/ChatApi.scala | 6 +- modules/clas/src/main/ClasStudentCache.scala | 14 +- modules/clas/src/main/Env.scala | 9 +- modules/common/src/main/Bus.scala | 8 +- modules/common/src/main/Chronometer.scala | 14 +- modules/common/src/main/Debouncer.scala | 2 - modules/common/src/main/LilaScheduler.scala | 4 +- modules/common/src/main/MarkdownRender.scala | 96 ++++++------- .../src/main/base/LilaLibraryExtensions.scala | 2 - modules/db/src/main/dsl.scala | 2 - modules/fishnet/src/main/Cleaner.scala | 5 +- modules/fishnet/src/main/Env.scala | 20 ++- modules/fishnet/src/main/FishnetRedis.scala | 12 +- modules/forum/src/main/Env.scala | 19 +-- modules/forumSearch/src/main/Env.scala | 24 ++-- modules/game/src/main/Captcher.scala | 6 +- modules/game/src/main/GameRepo.scala | 4 +- modules/game/src/main/GamesByIdsStream.scala | 51 ++++--- .../game/src/main/GamesByUsersStream.scala | 31 ++-- modules/gameSearch/src/main/Env.scala | 7 +- modules/hub/src/main/AsyncActorConcMap.scala | 34 ++--- modules/hub/src/main/SyncActorMap.scala | 4 +- modules/insight/src/main/Env.scala | 2 +- modules/irc/src/main/Env.scala | 7 +- modules/irwin/src/main/Env.scala | 8 +- modules/irwin/src/main/IrwinApi.scala | 4 +- modules/irwin/src/main/IrwinStream.scala | 16 +-- modules/irwin/src/main/KaladinApi.scala | 10 +- .../lobby/src/main/BoardApiHookStream.scala | 1 - modules/lobby/src/main/Env.scala | 2 +- modules/lobby/src/main/LobbySocket.scala | 6 +- modules/mailer/src/main/AutomaticEmail.scala | 4 +- modules/mailer/src/main/Env.scala | 12 +- modules/mailer/src/main/Mailer.scala | 26 ++-- modules/memo/src/main/CacheApi.scala | 11 +- .../memo/src/main/ExpirableCallbackMemo.scala | 25 ++-- .../src/main/FutureConcurrencyLimit.scala | 7 +- modules/mod/src/main/Env.scala | 11 +- modules/mod/src/main/ModApi.scala | 19 +-- modules/mod/src/main/ModStream.scala | 16 +-- modules/mod/src/main/RatingRefund.scala | 2 +- modules/msg/src/main/Env.scala | 2 +- modules/msg/src/main/MsgNotify.scala | 19 ++- modules/notify/src/main/Env.scala | 8 +- modules/oauth/src/main/AuthorizationApi.scala | 2 - modules/perfStat/src/main/Env.scala | 2 +- modules/plan/src/main/Env.scala | 31 ++-- modules/plan/src/main/PlanApi.scala | 4 +- modules/playban/src/main/PlaybanApi.scala | 7 +- modules/puzzle/src/main/Env.scala | 2 +- modules/puzzle/src/main/PuzzleSelector.scala | 2 +- modules/puzzle/src/main/PuzzleStreak.scala | 109 +++++++-------- modules/racer/src/main/RacerSocket.scala | 2 +- modules/relation/src/main/RelationApi.scala | 8 +- modules/relay/src/main/Env.scala | 6 +- modules/relay/src/main/RelayFetch.scala | 2 +- modules/relay/src/main/RelayPgnStream.scala | 14 +- modules/report/src/main/AutoAnalysis.scala | 2 +- modules/report/src/main/Env.scala | 10 +- modules/report/src/main/ReportApi.scala | 4 +- modules/room/src/main/RoomSocket.scala | 2 +- modules/round/src/main/ApiMoveStream.scala | 2 +- modules/round/src/main/CorresAlarm.scala | 8 +- .../round/src/main/CorrespondenceEmail.scala | 5 +- modules/round/src/main/Env.scala | 2 +- modules/round/src/main/Finisher.scala | 2 +- modules/round/src/main/GameProxy.scala | 3 +- modules/round/src/main/Messenger.scala | 8 +- modules/round/src/main/MoveLatMonitor.scala | 7 +- modules/round/src/main/Player.scala | 2 +- modules/round/src/main/RoundAsyncActor.scala | 6 +- modules/round/src/main/RoundSocket.scala | 28 ++-- modules/round/src/main/Takebacker.scala | 14 +- modules/round/src/main/Titivate.scala | 6 +- .../src/main/DisposableEmailAttempt.scala | 10 +- modules/security/src/main/Env.scala | 10 +- modules/security/src/main/Firewall.scala | 5 +- .../security/src/main/GarbageCollector.scala | 4 +- modules/security/src/main/Ip2Proxy.scala | 4 +- modules/setup/src/main/SetupBulk.scala | 7 +- modules/shutup/src/main/Env.scala | 15 +- modules/simul/src/main/SimulApi.scala | 2 +- modules/socket/src/main/RemoteSocket.scala | 14 +- modules/storm/src/main/StormDay.scala | 14 +- modules/storm/src/main/StormSelector.scala | 132 ++++++++---------- modules/streamer/src/main/Env.scala | 11 +- modules/study/src/main/Env.scala | 5 +- modules/study/src/main/StudyTopic.scala | 80 +++++------ modules/studySearch/src/main/Env.scala | 23 ++- modules/swiss/src/main/Env.scala | 27 ++-- modules/swiss/src/main/PairingSystem.scala | 11 +- modules/swiss/src/main/SwissApi.scala | 27 ++-- modules/swiss/src/main/SwissJson.scala | 8 +- modules/team/src/main/Env.scala | 2 +- modules/teamSearch/src/main/Env.scala | 7 +- modules/timeline/src/main/Env.scala | 6 +- modules/tournament/src/main/Duel.scala | 5 +- modules/tournament/src/main/Env.scala | 9 +- .../src/main/StartedOrganizer.scala | 24 +--- .../tournament/src/main/TournamentApi.scala | 19 +-- .../src/main/TournamentBusHandler.scala | 20 ++- .../src/main/TournamentLilaHttp.scala | 4 +- .../src/main/TournamentShield.scala | 5 +- .../src/main/TournamentSocket.scala | 2 +- modules/tournament/src/main/WinnersApi.scala | 19 +-- modules/tutor/src/main/TutorApi.scala | 5 +- modules/ublog/src/main/UblogApi.scala | 2 +- modules/user/src/main/Env.scala | 6 +- modules/user/src/main/RankingApi.scala | 1 - modules/user/src/main/UserRepo.scala | 3 +- modules/video/src/main/Env.scala | 10 +- 128 files changed, 695 insertions(+), 896 deletions(-) diff --git a/app/Env.scala b/app/Env.scala index e0d40270ff53e..5e2531979cdb8 100644 --- a/app/Env.scala +++ b/app/Env.scala @@ -184,7 +184,7 @@ final class EnvBoot( export netConfig.{ domain, baseUrl } // eagerly load the Uptime object to fix a precise date - lila.common.Uptime.startedAt.unit + lila.common.Uptime.startedAt // wire all the lila modules lazy val memo: lila.memo.Env = wire[lila.memo.Env] diff --git a/app/controllers/Account.scala b/app/controllers/Account.scala index a2e0ad0093da4..3388a21c326b3 100644 --- a/app/controllers/Account.scala +++ b/app/controllers/Account.scala @@ -339,7 +339,7 @@ final class Account( case Some(user) => env.report.api.reopenReports(lila.report.Suspect(user)) >> auth.authenticateUser(user, remember = true) andDo - lila.mon.user.auth.reopenConfirm("success").increment().unit + lila.mon.user.auth.reopenConfirm("success").increment() } def data = Auth { _ ?=> me ?=> diff --git a/app/controllers/Auth.scala b/app/controllers/Auth.scala index a21781f88eec3..55edd6308a3e3 100644 --- a/app/controllers/Auth.scala +++ b/app/controllers/Auth.scala @@ -428,7 +428,7 @@ final class Auth( case Some(user) => authLog(user.username, none, "Magic link") authenticateUser(user, remember = true) andDo - lila.mon.user.auth.magicLinkConfirm("success").increment().unit + lila.mon.user.auth.magicLinkConfirm("success").increment() } def makeLoginToken = AuthOrScoped(_.Web.Login) { ctx ?=> me ?=> diff --git a/app/controllers/Clas.scala b/app/controllers/Clas.scala index 65f3e5002d9b0..d2a5b38a73f60 100644 --- a/app/controllers/Clas.scala +++ b/app/controllers/Clas.scala @@ -177,7 +177,7 @@ final class Clas(env: Env, authC: Auth) extends LilaController(env): env.msg.api .multiPost(Source(students.map(_.user.id)), full) .addEffect: nb => - lila.mon.msg.clasBulk(clas.id.value).record(nb).unit + lila.mon.msg.clasBulk(clas.id.value).record(nb) .inject(redirectTo(clas).flashSuccess) } ) diff --git a/app/controllers/Fishnet.scala b/app/controllers/Fishnet.scala index 63e3631b73b4e..f4261bd758781 100644 --- a/app/controllers/Fishnet.scala +++ b/app/controllers/Fishnet.scala @@ -17,7 +17,7 @@ final class Fishnet(env: Env) extends LilaController(env): def acquire(slow: Boolean = false) = ClientAction[JsonApi.Request.Acquire] { _ => client => api.acquire(client, slow) addEffect { jobOpt => - lila.mon.fishnet.http.request(jobOpt.isDefined).increment().unit + lila.mon.fishnet.http.request(jobOpt.isDefined).increment() } map Right.apply } diff --git a/app/controllers/LilaController.scala b/app/controllers/LilaController.scala index 0b9f240942582..d0f65e5c99a2c 100644 --- a/app/controllers/LilaController.scala +++ b/app/controllers/LilaController.scala @@ -300,7 +300,7 @@ abstract private[controllers] class LilaController(val env: Env) ) def pageHit(using req: RequestHeader): Unit = - if HTTPRequest.isHuman(req) then lila.mon.http.path(req.path).increment().unit + if HTTPRequest.isHuman(req) then lila.mon.http.path(req.path).increment() def LangPage(call: Call)(f: Context ?=> Fu[Result])(langCode: String): EssentialAction = LangPage(call.url)(f)(langCode) diff --git a/app/controllers/Team.scala b/app/controllers/Team.scala index 144c5e13b915d..24725ace2a9a3 100644 --- a/app/controllers/Team.scala +++ b/app/controllers/Team.scala @@ -410,7 +410,7 @@ final class Team( full ) .addEffect: nb => - lila.mon.msg.teamBulk(team.id).record(nb).unit + lila.mon.msg.teamBulk(team.id).record(nb) // we don't wait for the stream to complete, it would make lichess time out fuccess(Result.Through) }(Result.Limited) diff --git a/modules/activity/src/main/Env.scala b/modules/activity/src/main/Env.scala index 4a4f5645ca8b3..ec97a43b62129 100644 --- a/modules/activity/src/main/Env.scala +++ b/modules/activity/src/main/Env.scala @@ -36,19 +36,19 @@ final class Env( lila.common.Bus.subscribeFuns( "finishGame" -> { - case lila.game.actorApi.FinishGame(game, _) if !game.aborted => write.game(game).unit + case lila.game.actorApi.FinishGame(game, _) if !game.aborted => write.game(game) }, "finishPuzzle" -> { case res: lila.puzzle.Puzzle.UserResult => - write.puzzle(res).unit + write.puzzle(res) }, "stormRun" -> { case lila.hub.actorApi.puzzle.StormRun(userId, score) => - write.storm(userId, score).unit + write.storm(userId, score) }, "racerRun" -> { case lila.hub.actorApi.puzzle.RacerRun(userId, score) => - write.racer(userId, score).unit + write.racer(userId, score) }, "streakRun" -> { case lila.hub.actorApi.puzzle.StreakRun(userId, score) => - write.streak(userId, score).unit + write.streak(userId, score) } ) @@ -64,19 +64,18 @@ final class Env( "startStudy", "streamStart", "swissFinish" - ) { - case lila.forum.CreatePost(post) => write.forumPost(post).unit - case lila.ublog.UblogPost.Create(post) => write.ublogPost(post).unit - case prog: lila.practice.PracticeProgress.OnComplete => write.practice(prog).unit - case lila.simul.Simul.OnStart(simul) => write.simul(simul).unit - case CorresMoveEvent(move, Some(userId), _, _, false) => write.corresMove(move.gameId, userId).unit - case lila.hub.actorApi.plan.MonthInc(userId, months) => write.plan(userId, months).unit - case lila.hub.actorApi.relation.Follow(from, to) => write.follow(from, to).unit + ): + case lila.forum.CreatePost(post) => write.forumPost(post) + case lila.ublog.UblogPost.Create(post) => write.ublogPost(post) + case prog: lila.practice.PracticeProgress.OnComplete => write.practice(prog) + case lila.simul.Simul.OnStart(simul) => write.simul(simul) + case CorresMoveEvent(move, Some(userId), _, _, false) => write.corresMove(move.gameId, userId) + case lila.hub.actorApi.plan.MonthInc(userId, months) => write.plan(userId, months) + case lila.hub.actorApi.relation.Follow(from, to) => write.follow(from, to) case lila.study.actorApi.StartStudy(id) => // wait some time in case the study turns private - scheduler.scheduleOnce(5 minutes) { write.study(id).unit }.unit - case lila.hub.actorApi.team.CreateTeam(id, _, userId) => write.team(id, userId).unit - case lila.hub.actorApi.team.JoinTeam(id, userId) => write.team(id, userId).unit - case lila.hub.actorApi.streamer.StreamStart(userId, _) => write.streamStart(userId).unit - case lila.swiss.SwissFinish(swissId, ranking) => write.swiss(swissId, ranking).unit - } + scheduler.scheduleOnce(5 minutes) { write.study(id) } + case lila.hub.actorApi.team.CreateTeam(id, _, userId) => write.team(id, userId) + case lila.hub.actorApi.team.JoinTeam(id, userId) => write.team(id, userId) + case lila.hub.actorApi.streamer.StreamStart(userId, _) => write.streamStart(userId) + case lila.swiss.SwissFinish(swissId, ranking) => write.swiss(swissId, ranking) diff --git a/modules/analyse/src/main/Env.scala b/modules/analyse/src/main/Env.scala index 1555ccaf984f7..790ed2712a43b 100644 --- a/modules/analyse/src/main/Env.scala +++ b/modules/analyse/src/main/Env.scala @@ -23,5 +23,5 @@ final class Env( lazy val externalEngine = ExternalEngineApi(db(CollName("external_engine")), cacheApi) lila.common.Bus.subscribeFun("oauth") { case lila.hub.actorApi.oauth.TokenRevoke(id) => - externalEngine onTokenRevoke id unit + externalEngine onTokenRevoke id } diff --git a/modules/api/src/main/AccountClosure.scala b/modules/api/src/main/AccountClosure.scala index 7a2c26819cbcd..5ccc8e76c8e88 100644 --- a/modules/api/src/main/AccountClosure.scala +++ b/modules/api/src/main/AccountClosure.scala @@ -29,9 +29,9 @@ final class AccountClosure( Bus.subscribeFuns( "garbageCollect" -> { case lila.hub.actorApi.security.GarbageCollect(userId) => - (modApi.garbageCollect(userId) >> lichessClose(userId)).unit + (modApi.garbageCollect(userId) >> lichessClose(userId)) }, - "rageSitClose" -> { case lila.hub.actorApi.playban.RageSitClose(userId) => lichessClose(userId).unit } + "rageSitClose" -> { case lila.hub.actorApi.playban.RageSitClose(userId) => lichessClose(userId) } ) def close(u: User)(using me: Me): Funit = for diff --git a/modules/api/src/main/Env.scala b/modules/api/src/main/Env.scala index 456ba09ac3cfd..3d6950ae9c3c3 100644 --- a/modules/api/src/main/Env.scala +++ b/modules/api/src/main/Env.scala @@ -120,7 +120,7 @@ final class Env( promise completeWith chatFreshness.of(source) }, "announce" -> { - case Announce(msg, date, _) if msg contains "will restart" => pagerDuty.lilaRestart(date).unit + case Announce(msg, date, _) if msg contains "will restart" => pagerDuty.lilaRestart(date) }, "lpv" -> { case AllPgnsFromText(text, p) => p completeWith textLpvExpand.allPgnsFromText(text) @@ -129,7 +129,7 @@ final class Env( ) scheduler.scheduleWithFixedDelay(1 minute, 1 minute): () => - lila.mon.bus.classifiers.update(lila.common.Bus.size()).unit + lila.mon.bus.classifiers.update(lila.common.Bus.size()) lila.mon.jvm.threads() // ensure the Lichess user is online socketEnv.remoteSocket.onlineUserIds.getAndUpdate(_ + User.lichessId) diff --git a/modules/api/src/main/EventStream.scala b/modules/api/src/main/EventStream.scala index 209ef6c2ae0b1..1082e028375a3 100644 --- a/modules/api/src/main/EventStream.scala +++ b/modules/api/src/main/EventStream.scala @@ -82,24 +82,22 @@ final class EventStream( // gotta send a message to check if the client has disconnected queue offer None self ! SetOnline - .unit - case StartGame(game) => queue.offer(gameJson(game, "gameStart")).unit + case StartGame(game) => queue.offer(gameJson(game, "gameStart")) - case FinishGame(game, _) => queue.offer(gameJson(game, "gameFinish")).unit + case FinishGame(game, _) => queue.offer(gameJson(game, "gameFinish")) case lila.challenge.Event.Create(c) if isMyChallenge(c) => val json = challengeJson("challenge")(c) ++ challengeCompat(c) lila.common.LilaFuture // give time for anon challenger to load the challenge page .delay(if c.challengerIsAnon then 2.seconds else 0.seconds): queue.offer(json.some).void - .unit case lila.challenge.Event.Decline(c) if isMyChallenge(c) => - queue.offer(challengeJson("challengeDeclined")(c).some).unit + queue.offer(challengeJson("challengeDeclined")(c).some) case lila.challenge.Event.Cancel(c) if isMyChallenge(c) => - queue.offer(challengeJson("challengeCanceled")(c).some).unit + queue.offer(challengeJson("challengeCanceled")(c).some) // pretend like the rematch is a challenge case lila.hub.actorApi.round.RematchOffer(gameId) => @@ -121,7 +119,7 @@ final class EventStream( .foreach: _.foreach: c => val json = challengeJson("challengeCanceled")(c) ++ challengeCompat(c) - queue.offer(json.some).unit + queue.offer(json.some) private def isMyChallenge(c: Challenge) = me.is(c.destUserId) || me.is(c.challengerUserId) diff --git a/modules/bookmark/src/main/Env.scala b/modules/bookmark/src/main/Env.scala index cba6805dad3fd..a8d798b87f556 100644 --- a/modules/bookmark/src/main/Env.scala +++ b/modules/bookmark/src/main/Env.scala @@ -33,10 +33,9 @@ final class Env( system.actorOf( Props( new Actor: - def receive = { - case Toggle(gameId, userId) => api.toggle(gameId, userId).unit - case Remove(gameId) => api.removeByGameId(gameId).unit - } + def receive = + case Toggle(gameId, userId) => api.toggle(gameId, userId) + case Remove(gameId) => api.removeByGameId(gameId) ), name = config.actorName ) diff --git a/modules/bot/src/main/GameStateStream.scala b/modules/bot/src/main/GameStateStream.scala index f3f821ddf2669..0a3c0dc3fd7cf 100644 --- a/modules/bot/src/main/GameStateStream.scala +++ b/modules/bot/src/main/GameStateStream.scala @@ -101,18 +101,18 @@ final class GameStateStream( context.system.scheduler.scheduleOnce(if gameOver then 10 second else 1 second): Bus.publish(Tell(init.game.id.value, BotConnected(as, v = false)), "roundSocket") queue.complete() - lila.mon.bot.gameStream("stop").increment().unit + lila.mon.bot.gameStream("stop").increment() def receive = - case MoveGameEvent(g, _, _) if g.id == id && !g.finished => pushState(g).unit + case MoveGameEvent(g, _, _) if g.id == id && !g.finished => pushState(g) case lila.chat.ChatLine(chatId, UserLine(username, _, _, text, false, false)) => - pushChatLine(username, text, chatId.value.lengthIs == GameId.size).unit - case FinishGame(g, _) if g.id == id => onGameOver(g.some).unit - case AbortedBy(pov) if pov.gameId == id => onGameOver(pov.game.some).unit - case BoardDrawOffer(g) if g.id == id => pushState(g).unit - case BoardTakebackOffer(g) if g.id == id => pushState(g).unit - case BoardTakeback(g) if g.id == id => pushState(g).unit - case BoardGone(pov, seconds) if pov.gameId == id && pov.color != as => opponentGone(seconds).unit + pushChatLine(username, text, chatId.value.lengthIs == GameId.size) + case FinishGame(g, _) if g.id == id => onGameOver(g.some) + case AbortedBy(pov) if pov.gameId == id => onGameOver(pov.game.some) + case BoardDrawOffer(g) if g.id == id => pushState(g) + case BoardTakebackOffer(g) if g.id == id => pushState(g) + case BoardTakeback(g) if g.id == id => pushState(g) + case BoardGone(pov, seconds) if pov.gameId == id && pov.color != as => opponentGone(seconds) case SetOnline => onlineApiUsers.setOnline(user.id) context.system.scheduler @@ -121,7 +121,6 @@ final class GameStateStream( queue offer None self ! SetOnline Bus.publish(Tell(id.value, QuietFlag), "roundSocket") - .unit def pushState(g: Game): Funit = jsonView gameState Game.WithInitialFen(g, init.fen) dmap some flatMap queue.offer void diff --git a/modules/challenge/src/main/ChallengeBulk.scala b/modules/challenge/src/main/ChallengeBulk.scala index 94caa1485edb1..dd96b4fe08b10 100644 --- a/modules/challenge/src/main/ChallengeBulk.scala +++ b/modules/challenge/src/main/ChallengeBulk.scala @@ -113,7 +113,7 @@ final class ChallengeBulkApi( .toMat(LilaStream.sinkCount)(Keep.right) .run() .addEffect { nb => - lila.mon.api.challenge.bulk.createNb(bulk.by.value).increment(nb).unit + lila.mon.api.challenge.bulk.createNb(bulk.by.value).increment(nb) } >> { if bulk.startClocksAt.isDefined then coll.updateField($id(bulk._id), "pairedAt", nowInstant) diff --git a/modules/challenge/src/main/ChallengeKeepAliveStream.scala b/modules/challenge/src/main/ChallengeKeepAliveStream.scala index 68ddffe8ef77d..3e985d46e07eb 100644 --- a/modules/challenge/src/main/ChallengeKeepAliveStream.scala +++ b/modules/challenge/src/main/ChallengeKeepAliveStream.scala @@ -11,20 +11,20 @@ final class ChallengeKeepAliveStream(api: ChallengeApi)(using ): def apply(challenge: Challenge, initialJson: JsObject): Source[JsValue, ?] = Source(List(initialJson)) concat - Source.queue[JsObject](1, akka.stream.OverflowStrategy.dropHead).mapMaterializedValue { queue => - val keepAliveInterval = scheduler.scheduleWithFixedDelay(15 seconds, 15 seconds) { () => - api.ping(challenge.id).unit - } - def completeWith(msg: String) = { - queue.offer(Json.obj("done" -> msg)) andDo queue.complete() - }.unit - val sub = Bus.subscribeFun("challenge") { - case Event.Accept(c, _) if c.id == challenge.id => completeWith("accepted") - case Event.Cancel(c) if c.id == challenge.id => completeWith("canceled") - case Event.Decline(c) if c.id == challenge.id => completeWith("declined") - } - queue.watchCompletion().addEffectAnyway { - keepAliveInterval.cancel() - Bus.unsubscribe(sub, "challenge") - } - } + Source + .queue[JsObject](1, akka.stream.OverflowStrategy.dropHead) + .mapMaterializedValue: queue => + val keepAliveInterval = scheduler.scheduleWithFixedDelay(15 seconds, 15 seconds): () => + api.ping(challenge.id) + def completeWith(msg: String) = + queue.offer(Json.obj("done" -> msg)) andDo queue.complete() + val sub = Bus.subscribeFun("challenge"): + case Event.Accept(c, _) if c.id == challenge.id => completeWith("accepted") + case Event.Cancel(c) if c.id == challenge.id => completeWith("canceled") + case Event.Decline(c) if c.id == challenge.id => completeWith("declined") + + queue + .watchCompletion() + .addEffectAnyway: + keepAliveInterval.cancel() + Bus.unsubscribe(sub, "challenge") diff --git a/modules/challenge/src/main/Env.scala b/modules/challenge/src/main/Env.scala index ac5dae5131d66..4ac42d3f46521 100644 --- a/modules/challenge/src/main/Env.scala +++ b/modules/challenge/src/main/Env.scala @@ -59,10 +59,10 @@ final class Env( val forms = new ChallengeForm system.scheduler.scheduleWithFixedDelay(10 seconds, 3343 millis): () => - api.sweep.unit + api.sweep system.scheduler.scheduleWithFixedDelay(20 seconds, 2897 millis): () => - bulk.tick.unit + bulk.tick private class ChallengeColls(db: lila.db.Db): val challenge = db(CollName("challenge")) diff --git a/modules/chat/src/main/ChatApi.scala b/modules/chat/src/main/ChatApi.scala index 694ca77d3bd51..e16c9f427349c 100644 --- a/modules/chat/src/main/ChatApi.scala +++ b/modules/chat/src/main/ChatApi.scala @@ -95,7 +95,7 @@ final class ChatApi( lila.mon.chat .message(publicSource.fold("player")(_.parentName), line.troll) .increment() - .unit + publish(chatId, ChatLine(chatId, line), busChan) else logger.info(s"Link check rejected $line in $publicSource") @@ -132,7 +132,7 @@ final class ChatApi( publish(chatId, ChatLine(chatId, line), busChan) def service(chatId: ChatId, text: String, busChan: BusChan.Select, isVolatile: Boolean): Unit = - (if isVolatile then volatile else system) (chatId, text, busChan).unit + (if isVolatile then volatile else system) (chatId, text, busChan) def timeout( chatId: ChatId, @@ -274,7 +274,7 @@ final class ChatApi( makeLine(chatId, color, text).so: line => persistLine(chatId, line).andDo: publish(chatId, ChatLine(chatId, line), busChan) - lila.mon.chat.message("anonPlayer", troll = false).increment().unit + lila.mon.chat.message("anonPlayer", troll = false).increment() private def makeLine(chatId: ChatId, color: Color, t1: String): Option[Line] = Writer.preprocessUserInput(t1, none) flatMap { t2 => diff --git a/modules/clas/src/main/ClasStudentCache.scala b/modules/clas/src/main/ClasStudentCache.scala index 473dea7aa7945..044df7b6c618b 100644 --- a/modules/clas/src/main/ClasStudentCache.scala +++ b/modules/clas/src/main/ClasStudentCache.scala @@ -19,26 +19,22 @@ final class ClasStudentCache(colls: ClasColls)(using scheduler: Scheduler)(using def addStudent(userId: UserId): Unit = bloomFilter add userId.value private def rebuildBloomFilter(): Unit = - colls.student.countAll foreach { count => + colls.student.countAll.foreach: count => val nextBloom = BloomFilter[String](count + 1, falsePositiveRate) colls.student .find($doc("archived" $exists false), $doc("userId" -> true, "_id" -> false).some) .cursor[Bdoc](ReadPref.priTemp) .documentSource() .throttle(300, 1.second) - .toMat(Sink.fold[Int, Bdoc](0) { case (counter, doc) => + .runWith(Sink.fold[Int, Bdoc](0): (counter, doc) => if counter % 500 == 0 then logger.info(s"ClasStudentCache.rebuild $counter") doc.string("userId") foreach nextBloom.add counter + 1 - })(Keep.right) - .run() - .addEffect { nb => + ) + .addEffect: nb => lila.mon.clas.student.bloomFilter.count.update(nb) bloomFilter.dispose() bloomFilter = nextBloom - } .monSuccess(_.clas.student.bloomFilter.fu) - .unit - } - scheduler.scheduleWithFixedDelay(71.seconds, 24.hours) { (() => rebuildBloomFilter()) }.unit + scheduler.scheduleWithFixedDelay(71.seconds, 24.hours) { (() => rebuildBloomFilter()) } diff --git a/modules/clas/src/main/Env.scala b/modules/clas/src/main/Env.scala index 691784f20a7eb..1cf2a3b9b7854 100644 --- a/modules/clas/src/main/Env.scala +++ b/modules/clas/src/main/Env.scala @@ -19,12 +19,7 @@ final class Env( authenticator: lila.user.Authenticator, cacheApi: lila.memo.CacheApi, baseUrl: BaseUrl -)(using - ec: Executor, - scheduler: Scheduler, - mat: akka.stream.Materializer, - mode: play.api.Mode -): +)(using Executor, Scheduler, akka.stream.Materializer, play.api.Mode): lazy val nameGenerator: NameGenerator = wire[NameGenerator] @@ -47,7 +42,7 @@ final class Env( lila.common.Bus.subscribeFuns( "finishGame" -> { case lila.game.actorApi.FinishGame(game, _) => - progressApi.onFinishGame(game).unit + progressApi.onFinishGame(game) }, "clas" -> { case lila.hub.actorApi.clas.IsTeacherOf(teacher, student, promise) => diff --git a/modules/common/src/main/Bus.scala b/modules/common/src/main/Bus.scala index 9b83b45863e1c..05fbe6ce390b7 100644 --- a/modules/common/src/main/Bus.scala +++ b/modules/common/src/main/Bus.scala @@ -50,7 +50,7 @@ object Bus: .withTimeout(timeout, s"Bus.ask $channel $msg") .monSuccess(_.bus.ask(s"${channel}_${msg.getClass}")) - private val bus = new EventBus[Matchable, Channel, Tellable]( + private val bus = EventBus[Matchable, Channel, Tellable]( initialCapacity = 4096, publish = (tellable, event) => tellable ! event ) @@ -60,9 +60,7 @@ final private class EventBus[Event, Channel, Subscriber]( publish: (Subscriber, Event) => Unit ): - import java.util.concurrent.ConcurrentHashMap - - private val entries = new ConcurrentHashMap[Channel, Set[Subscriber]](initialCapacity) + private val entries = java.util.concurrent.ConcurrentHashMap[Channel, Set[Subscriber]](initialCapacity) export entries.size def subscribe(subscriber: Subscriber, channel: Channel): Unit = @@ -71,7 +69,6 @@ final private class EventBus[Event, Channel, Subscriber]( channel, (_: Channel, subs: Set[Subscriber]) => Option(subs).fold(Set(subscriber))(_ + subscriber) ) - .unit def unsubscribe(subscriber: Subscriber, channel: Channel): Unit = entries @@ -82,7 +79,6 @@ final private class EventBus[Event, Channel, Subscriber]( if newSubs.isEmpty then null else newSubs ) - .unit def publish(event: Event, channel: Channel): Unit = Option(entries get channel).foreach: diff --git a/modules/common/src/main/Chronometer.scala b/modules/common/src/main/Chronometer.scala index 55e65c8d6c308..bbbecc73da6c1 100644 --- a/modules/common/src/main/Chronometer.scala +++ b/modules/common/src/main/Chronometer.scala @@ -19,11 +19,11 @@ object Chronometer: this def mon(path: lila.mon.TimerPath) = - path(lila.mon).record(nanos).unit + path(lila.mon).record(nanos) this def monValue(path: A => lila.mon.TimerPath) = - path(result)(lila.mon).record(nanos).unit + path(result)(lila.mon).record(nanos) this def pp: A = @@ -44,19 +44,19 @@ object Chronometer: case class FuLap[A](lap: Fu[Lap[A]]) extends AnyVal: def logIfSlow(threshold: Int, logger: lila.log.Logger)(msg: A => String) = - lap.dforeach(_.logIfSlow(threshold, logger)(msg).unit) + lap.dforeach(_.logIfSlow(threshold, logger)(msg)) this def mon(path: lila.mon.TimerPath) = - lap dforeach { _.mon(path).unit } + lap.dforeach(_.mon(path)) this def monValue(path: A => lila.mon.TimerPath) = - lap dforeach { _.monValue(path).unit } + lap.dforeach(_.monValue(path)) this def log(logger: lila.log.Logger)(msg: A => String) = - lap.dforeach(_.log(logger)(msg).unit) + lap.dforeach(_.log(logger)(msg)) this def pp: Fu[A] = lap.dmap(_.pp) @@ -73,7 +73,7 @@ object Chronometer: def mon(path: Try[A] => kamon.metric.Timer) = lap.dforeach: l => - path(l.result).record(l.nanos).unit + path(l.result).record(l.nanos) this def result = diff --git a/modules/common/src/main/Debouncer.scala b/modules/common/src/main/Debouncer.scala index 42ad685c777bc..1e7ede74af54f 100644 --- a/modules/common/src/main/Debouncer.scala +++ b/modules/common/src/main/Debouncer.scala @@ -26,7 +26,6 @@ final class Debouncer[Id](duration: FiniteDuration, initialCapacity: Int = 64)( Queued.Empty case _ => Queued.Another ) - .unit private def runScheduled(id: Id): Unit = debounces .computeIfPresent( @@ -38,6 +37,5 @@ final class Debouncer[Id](duration: FiniteDuration, initialCapacity: Int = 64)( Queued.Empty else nullToRemove ) - .unit private[this] var nullToRemove: Queued = _ diff --git a/modules/common/src/main/LilaScheduler.scala b/modules/common/src/main/LilaScheduler.scala index def6595af17a7..513b73ab7b998 100644 --- a/modules/common/src/main/LilaScheduler.scala +++ b/modules/common/src/main/LilaScheduler.scala @@ -19,10 +19,8 @@ object LilaScheduler: run() .withTimeout(timeout(config).value, s"LilaScheduler $name") .addEffectAnyway: - scheduler.scheduleOnce(every(config).value) { runAndScheduleNext() }.unit - .unit + scheduler.scheduleOnce(every(config).value) { runAndScheduleNext() } scheduler .scheduleOnce(initialDelay(config).value): runAndScheduleNext() - .unit diff --git a/modules/common/src/main/MarkdownRender.scala b/modules/common/src/main/MarkdownRender.scala index d70b307213280..248093622d0fd 100644 --- a/modules/common/src/main/MarkdownRender.scala +++ b/modules/common/src/main/MarkdownRender.scala @@ -142,59 +142,51 @@ object MarkdownRender: def create(assetDomain: Option[AssetDomain]) = new HtmlRenderer.HtmlRendererExtension: override def rendererOptions(options: MutableDataHolder) = () override def extend(htmlRendererBuilder: HtmlRenderer.Builder, rendererType: String) = - htmlRendererBuilder - .nodeRendererFactory( - new NodeRendererFactory: - override def apply(options: DataHolder) = new NodeRenderer: - override def getNodeRenderingHandlers() = - Set(NodeRenderingHandler(classOf[Image], render _)).asJava - ) + htmlRendererBuilder.nodeRendererFactory: + new: + override def apply(options: DataHolder) = new NodeRenderer: + override def getNodeRenderingHandlers() = + Set(NodeRenderingHandler(classOf[Image], render _)).asJava private def render(node: Image, context: NodeRendererContext, html: HtmlWriter): Unit = // Based on implementation in CoreNodeRenderer. if context.isDoNotRenderLinks || CoreNodeRenderer.isSuppressedLinkPrefix(node.getUrl(), context) then context.renderChildren(node) else - { - val resolvedLink = context.resolveLink(LinkType.IMAGE, node.getUrl().unescape(), null, null) - val url = resolvedLink.getUrl() - val altText = new TextCollectingVisitor().collectAndGetText(node) - whitelistedSrc(url, assetDomain) match - case Some(src) => - html - .srcPos(node.getChars()) - .attr("src", src) - .attr("alt", altText) - .attr(resolvedLink.getNonNullAttributes()) - .withAttr(resolvedLink) - .tagVoid("img") - case None => - html - .srcPos(node.getChars()) - .attr("href", url) - .attr("rel", rel) - .withAttr(resolvedLink) - .tag("a") - .text(altText) - .tag("/a") - }.unit + val resolvedLink = context.resolveLink(LinkType.IMAGE, node.getUrl().unescape(), null, null) + val url = resolvedLink.getUrl() + val altText = new TextCollectingVisitor().collectAndGetText(node) + whitelistedSrc(url, assetDomain) match + case Some(src) => + html + .srcPos(node.getChars()) + .attr("src", src) + .attr("alt", altText) + .attr(resolvedLink.getNonNullAttributes()) + .withAttr(resolvedLink) + .tagVoid("img") + case None => + html + .srcPos(node.getChars()) + .attr("href", url) + .attr("rel", rel) + .withAttr(resolvedLink) + .tag("a") + .text(altText) + .tag("/a") private class PgnEmbedExtension(expander: PgnSourceExpand) extends HtmlRenderer.HtmlRendererExtension: override def rendererOptions(options: MutableDataHolder) = () override def extend(htmlRendererBuilder: HtmlRenderer.Builder, rendererType: String) = - htmlRendererBuilder - .nodeRendererFactory( - new NodeRendererFactory: - override def apply(options: DataHolder) = new PgnEmbedNodeRenderer(expander) - ) - .unit + htmlRendererBuilder.nodeRendererFactory: + new: + override def apply(options: DataHolder) = new PgnEmbedNodeRenderer(expander) + private class PgnEmbedNodeRenderer(expander: PgnSourceExpand) extends NodeRenderer: - override def getNodeRenderingHandlers() = - new java.util.HashSet( - Arrays.asList( - new NodeRenderingHandler(classOf[Link], renderLink _), - new NodeRenderingHandler(classOf[AutoLink], renderAutoLink _) - ) + override def getNodeRenderingHandlers() = java.util.HashSet: + Arrays.asList( + NodeRenderingHandler(classOf[Link], renderLink _), + NodeRenderingHandler(classOf[AutoLink], renderAutoLink _) ) final class PgnRegexes(val game: Regex, val chapter: Regex) @@ -241,7 +233,7 @@ object MarkdownRender: html.attr(link.getNonNullAttributes()) html.srcPos(node.getChars()).withAttr(link).tag("a") context.renderChildren(node) - html.tag("/a").unit + html.tag("/a") private def renderPgnViewer( node: LinkNode, @@ -268,26 +260,23 @@ object MarkdownRender: private object LilaLinkExtension extends HtmlRenderer.HtmlRendererExtension: override def rendererOptions(options: MutableDataHolder) = () override def extend(htmlRendererBuilder: HtmlRenderer.Builder, rendererType: String) = - htmlRendererBuilder - .attributeProviderFactory( - new IndependentAttributeProviderFactory: - override def apply(context: LinkResolverContext): AttributeProvider = lilaLinkAttributeProvider - ) - .unit + htmlRendererBuilder.attributeProviderFactory: + new IndependentAttributeProviderFactory: + override def apply(context: LinkResolverContext): AttributeProvider = lilaLinkAttributeProvider private val lilaLinkAttributeProvider = new AttributeProvider: override def setAttributes(node: Node, part: AttributablePart, attributes: MutableAttributes) = if (node.isInstanceOf[Link] || node.isInstanceOf[AutoLink]) && part == AttributablePart.LINK then - attributes.replaceValue("rel", rel).unit - attributes.replaceValue("href", RawHtml.removeUrlTrackingParameters(attributes.getValue("href"))).unit + attributes.replaceValue("rel", rel) + attributes.replaceValue("href", RawHtml.removeUrlTrackingParameters(attributes.getValue("href"))) private val tableWrapperExtension = new HtmlRenderer.HtmlRendererExtension: override def rendererOptions(options: MutableDataHolder) = () - override def extend(builder: HtmlRenderer.Builder, rendererType: String) = builder.nodeRendererFactory( + override def extend(builder: HtmlRenderer.Builder, rendererType: String) = builder.nodeRendererFactory: new NodeRendererFactory: override def apply(options: DataHolder) = new NodeRenderer: override def getNodeRenderingHandlers() = Set( - new NodeRenderingHandler( + NodeRenderingHandler( classOf[TableBlock], (node: TableBlock, context: NodeRendererContext, html: HtmlWriter) => html.withAttr().attr("class", "slist-wrapper").tag("div") @@ -295,4 +284,3 @@ object MarkdownRender: html.tag("/div") ) ).asJava - ) diff --git a/modules/common/src/main/base/LilaLibraryExtensions.scala b/modules/common/src/main/base/LilaLibraryExtensions.scala index 1a6a416111bf4..03bf2e51a5a40 100644 --- a/modules/common/src/main/base/LilaLibraryExtensions.scala +++ b/modules/common/src/main/base/LilaLibraryExtensions.scala @@ -16,8 +16,6 @@ import scala.annotation.targetName trait LilaLibraryExtensions extends LilaTypes: - extension [A](self: A) def unit: Unit = () - extension (self: Long) def atLeast(bottomValue: Long): Long = max(self, bottomValue) def atMost(topValue: Long): Long = min(self, topValue) diff --git a/modules/db/src/main/dsl.scala b/modules/db/src/main/dsl.scala index 52b224f8eec00..fce6d6db51af6 100644 --- a/modules/db/src/main/dsl.scala +++ b/modules/db/src/main/dsl.scala @@ -516,7 +516,6 @@ object dsl extends dsl with Handlers: coll .update(ordered = false, writeConcern = WriteConcern.Unacknowledged) .one(selector, $set(field -> value)) - .unit def incField(selector: Bdoc, field: String, value: Int = 1) = coll.update.one(selector, $inc(field -> value)) @@ -525,7 +524,6 @@ object dsl extends dsl with Handlers: coll .update(ordered = false, writeConcern = WriteConcern.Unacknowledged) .one(selector, $inc(field -> value)) - .unit def unsetField(selector: Bdoc, field: String, multi: Boolean = false) = coll.update.one(selector, $unset(field), multi = multi) diff --git a/modules/fishnet/src/main/Cleaner.scala b/modules/fishnet/src/main/Cleaner.scala index 978fecac98b26..fb7618a01b0e0 100644 --- a/modules/fishnet/src/main/Cleaner.scala +++ b/modules/fishnet/src/main/Cleaner.scala @@ -37,9 +37,8 @@ final private class Cleaner( .runWith(Sink.ignore) .void - system.scheduler.scheduleWithFixedDelay(15 seconds, 10 seconds) { () => - cleanAnalysis.unit - } + system.scheduler.scheduleWithFixedDelay(15 seconds, 10 seconds): () => + cleanAnalysis object Cleaner: val timeoutPerPly = 7.seconds diff --git a/modules/fishnet/src/main/Env.scala b/modules/fishnet/src/main/Env.scala index 91f0613fda25f..fb85947eb9cec 100644 --- a/modules/fishnet/src/main/Env.scala +++ b/modules/fishnet/src/main/Env.scala @@ -105,14 +105,11 @@ final class Env( system.actorOf( Props( new Actor: - def receive = { + def receive = case lila.hub.actorApi.fishnet.AutoAnalyse(gameId) => - analyser( - gameId, - Work.Sender(userId = lila.user.User.lichessId, ip = none, mod = false, system = true) - ).unit - case req: lila.hub.actorApi.fishnet.StudyChapterRequest => analyser.study(req).unit - } + val sender = Work.Sender(userId = lila.user.User.lichessId, ip = none, mod = false, system = true) + analyser(gameId, sender) + case req: lila.hub.actorApi.fishnet.StudyChapterRequest => analyser.study(req) ), name = config.actorName ) @@ -137,8 +134,7 @@ final class Env( repo toKey key flatMap { repo.enableClient(_, v = true) } inject "done!" case "fishnet" :: "client" :: "disable" :: key :: Nil => disable(key) inject "done!" - Bus.subscribeFun("adjustCheater", "adjustBooster", "shadowban") { - case lila.hub.actorApi.mod.MarkCheater(userId, true) => disable(userId.value).unit - case lila.hub.actorApi.mod.MarkBooster(userId) => disable(userId.value).unit - case lila.hub.actorApi.mod.Shadowban(userId, true) => disable(userId.value).unit - } + Bus.subscribeFun("adjustCheater", "adjustBooster", "shadowban"): + case lila.hub.actorApi.mod.MarkCheater(userId, true) => disable(userId.value) + case lila.hub.actorApi.mod.MarkBooster(userId) => disable(userId.value) + case lila.hub.actorApi.mod.Shadowban(userId, true) => disable(userId.value) diff --git a/modules/fishnet/src/main/FishnetRedis.scala b/modules/fishnet/src/main/FishnetRedis.scala index be49efba21fed..b79d541c97d53 100644 --- a/modules/fishnet/src/main/FishnetRedis.scala +++ b/modules/fishnet/src/main/FishnetRedis.scala @@ -22,13 +22,12 @@ final class FishnetRedis( private var stopping = false def request(work: Work.Move): Unit = - if !stopping then connOut.async.publish(chanOut, writeWork(work)).unit + if !stopping then connOut.async.publish(chanOut, writeWork(work)) connIn.async.subscribe(chanIn) - connIn.addListener( + connIn.addListener: new RedisPubSubAdapter[String, String]: - override def message(chan: String, msg: String): Unit = msg split ' ' match case Array("start") => Bus.publish(TellAll(FishnetStart), "roundSocket") @@ -37,14 +36,11 @@ final class FishnetRedis( Bus.publish(Tell(gameId, FishnetPlay(move, sign)), "roundSocket") } case _ => - ) - Lilakka.shutdown(shutdown, _.PhaseServiceUnbind, "Stopping the fishnet redis pool") { () => - Future { + Lilakka.shutdown(shutdown, _.PhaseServiceUnbind, "Stopping the fishnet redis pool"): () => + Future: stopping = true client.shutdown() - } - } private def writeWork(work: Work.Move): String = List( diff --git a/modules/forum/src/main/Env.scala b/modules/forum/src/main/Env.scala index 1d81097a389ab..eb3c26f308251 100644 --- a/modules/forum/src/main/Env.scala +++ b/modules/forum/src/main/Env.scala @@ -38,11 +38,7 @@ final class Env( gameRepo: lila.game.GameRepo, cacheApi: lila.memo.CacheApi, ws: StandaloneWSClient -)(using - ec: Executor, - scheduler: Scheduler, - mat: akka.stream.Materializer -): +)(using Executor, Scheduler, akka.stream.Materializer): private val config = appConfig.get[ForumConfig]("forum")(AutoConfig.loader) @@ -51,7 +47,7 @@ final class Env( lazy val postRepo = new ForumPostRepo(db(CollName("f_post"))) private lazy val detectLanguage = - new DetectLanguage(ws, appConfig.get[DetectLanguage.Config]("detectlanguage.api")) + DetectLanguage(ws, appConfig.get[DetectLanguage.Config]("detectlanguage.api")) private lazy val textExpand = wire[ForumTextExpand] @@ -68,13 +64,12 @@ final class Env( lazy val mentionNotifier: MentionNotifier = wire[MentionNotifier] lazy val forms = wire[ForumForm] - lazy val recentTeamPosts = - RecentTeamPosts(id => postRepo.recentInCateg(ForumCateg.fromTeamId(id), 6) flatMap postApi.miniPosts) + lazy val recentTeamPosts = RecentTeamPosts: id => + postRepo.recentInCateg(ForumCateg.fromTeamId(id), 6) flatMap postApi.miniPosts - lila.common.Bus.subscribeFun("team", "gdprErase") { - case CreateTeam(id, name, _) => categApi.makeTeam(id, name).unit - case lila.user.User.GDPRErase(user) => postApi.eraseFromSearchIndex(user).unit - } + lila.common.Bus.subscribeFun("team", "gdprErase"): + case CreateTeam(id, name, _) => categApi.makeTeam(id, name) + case lila.user.User.GDPRErase(user) => postApi.eraseFromSearchIndex(user) private type RecentTeamPostsType = TeamId => Fu[List[MiniForumPost]] opaque type RecentTeamPosts <: RecentTeamPostsType = RecentTeamPostsType diff --git a/modules/forumSearch/src/main/Env.scala b/modules/forumSearch/src/main/Env.scala index 3f392cc3a3fc9..8fcc74afa3ff2 100644 --- a/modules/forumSearch/src/main/Env.scala +++ b/modules/forumSearch/src/main/Env.scala @@ -20,11 +20,7 @@ final class Env( makeClient: Index => ESClient, postApi: lila.forum.ForumPostApi, postRepo: lila.forum.ForumPostRepo -)(using - ec: Executor, - system: ActorSystem, - mat: akka.stream.Materializer -): +)(using Executor, akka.stream.Materializer)(using system: ActorSystem): private val config = appConfig.get[ForumSearchConfig]("forumSearch")(AutoConfig.loader) @@ -35,22 +31,20 @@ final class Env( def apply(text: String, page: Int, troll: Boolean) = paginatorBuilder(Query(text take 100, troll), page) - def cli = - new lila.common.Cli: - def process = { case "forum" :: "search" :: "reset" :: Nil => - api.reset inject "done" - } + def cli: lila.common.Cli = new: + def process = { case "forum" :: "search" :: "reset" :: Nil => + api.reset inject "done" + } private lazy val paginatorBuilder = lila.search.PaginatorBuilder(api, config.maxPerPage) system.actorOf( Props(new Actor: import lila.forum.* - def receive = { - case InsertPost(post) => api.store(post).unit - case RemovePost(id) => client.deleteById(id into Id).unit - case RemovePosts(ids) => client.deleteByIds(Id.from[List, ForumPostId](ids)).unit - } + def receive = + case InsertPost(post) => api.store(post) + case RemovePost(id) => client.deleteById(id into Id) + case RemovePosts(ids) => client.deleteByIds(Id.from[List, ForumPostId](ids)) ), name = config.actorName ) diff --git a/modules/game/src/main/Captcher.scala b/modules/game/src/main/Captcher.scala index 2afc319780112..bfb1897c416ba 100644 --- a/modules/game/src/main/Captcher.scala +++ b/modules/game/src/main/Captcher.scala @@ -17,11 +17,11 @@ final private class Captcher(gameRepo: GameRepo)(using Executor) extends Actor: case AnyCaptcha => sender() ! Impl.current - case GetCaptcha(id) => Impl.get(id).pipeTo(sender()).unit + case GetCaptcha(id) => Impl.get(id).pipeTo(sender()) - case actorApi.NewCaptcha => Impl.refresh.unit + case actorApi.NewCaptcha => Impl.refresh - case ValidCaptcha(id, solution) => Impl.get(id).map(_ valid solution).pipeTo(sender()).unit + case ValidCaptcha(id, solution) => Impl.get(id).map(_ valid solution).pipeTo(sender()) private object Impl: diff --git a/modules/game/src/main/GameRepo.scala b/modules/game/src/main/GameRepo.scala index d99341ef6208b..d1e58e99ca8d1 100644 --- a/modules/game/src/main/GameRepo.scala +++ b/modules/game/src/main/GameRepo.scala @@ -412,7 +412,7 @@ final class GameRepo(val coll: Coll)(using Executor): F.playingUids -> (g2.started && userIds.nonEmpty).option(userIds) ) coll.insert.one(bson) addFailureEffect { - case wr: WriteResult if isDuplicateKey(wr) => lila.mon.game.idCollision.increment().unit + case wr: WriteResult if isDuplicateKey(wr) => lila.mon.game.idCollision.increment() } void def removeRecentChallengesOf(userId: UserId) = @@ -428,7 +428,7 @@ final class GameRepo(val coll: Coll)(using Executor): coll.unsetField($id(id), F.checkAt).void def unsetPlayingUids(g: Game): Unit = - coll.update(ordered = false, WriteConcern.Unacknowledged).one($id(g.id), $unset(F.playingUids)).unit + coll.update(ordered = false, WriteConcern.Unacknowledged).one($id(g.id), $unset(F.playingUids)) // used to make a compound sparse index def setImportCreatedAt(g: Game) = diff --git a/modules/game/src/main/GamesByIdsStream.scala b/modules/game/src/main/GamesByIdsStream.scala index f590357add5f2..49638563ba841 100644 --- a/modules/game/src/main/GamesByIdsStream.scala +++ b/modules/game/src/main/GamesByIdsStream.scala @@ -7,33 +7,32 @@ import play.api.libs.json.* import lila.common.Bus import lila.db.dsl.{ *, given } -final class GamesByIdsStream(gameRepo: lila.game.GameRepo)(using - mat: akka.stream.Materializer, - ec: Executor -): +final class GamesByIdsStream(gameRepo: lila.game.GameRepo)(using akka.stream.Materializer, Executor): + def apply(streamId: String, initialIds: Set[GameId], maxGames: Int): Source[JsValue, ?] = - val startStream = Source.queue[Game]( - bufferSize = maxGames, - akka.stream.OverflowStrategy.dropHead - ) mapMaterializedValue { queue => - var watchedIds = initialIds - val chans = List("startGame", "finishGame", streamChan(streamId)) - val sub = Bus.subscribeFun(chans*) { - case StartGame(game) if watchedIds(game.id) => queue.offer(game).unit - case FinishGame(game, _) if watchedIds(game.id) => - queue.offer(game).unit - watchedIds = watchedIds - game.id - case WatchGames(ids) => - val newIds = ids diff watchedIds - watchedIds = (watchedIds ++ newIds) take maxGames - gameSource(newIds intersect watchedIds) - .runWith(Sink.foreach(g => queue.offer(g).unit)) - .unit - } - queue.watchCompletion().addEffectAnyway { - Bus.unsubscribe(sub, chans) - } - } + val startStream = Source + .queue[Game]( + bufferSize = maxGames, + akka.stream.OverflowStrategy.dropHead + ) + .mapMaterializedValue: queue => + var watchedIds = initialIds + val chans = List("startGame", "finishGame", streamChan(streamId)) + val sub = Bus.subscribeFun(chans*) { + case StartGame(game) if watchedIds(game.id) => queue.offer(game) + case FinishGame(game, _) if watchedIds(game.id) => + queue.offer(game) + watchedIds = watchedIds - game.id + case WatchGames(ids) => + val newIds = ids diff watchedIds + watchedIds = (watchedIds ++ newIds) take maxGames + gameSource(newIds intersect watchedIds) + .runWith(Sink.foreach(g => queue.offer(g))) + } + queue + .watchCompletion() + .addEffectAnyway: + Bus.unsubscribe(sub, chans) gameSource(initialIds) .concat(startStream) .mapAsync(1)(gameRepo.withInitialFen) diff --git a/modules/game/src/main/GamesByUsersStream.scala b/modules/game/src/main/GamesByUsersStream.scala index 54f1f548ba3dd..cf20f0f7b1c98 100644 --- a/modules/game/src/main/GamesByUsersStream.scala +++ b/modules/game/src/main/GamesByUsersStream.scala @@ -19,17 +19,16 @@ final class GamesByUsersStream(gameRepo: lila.game.GameRepo)(using val initialGames = if withCurrentGames then currentGamesSource(userIds) else Source.empty val startStream = Source.queue[Game](150, akka.stream.OverflowStrategy.dropHead) mapMaterializedValue { queue => - def matches(game: Game) = - game.userIds match - case List(u1, u2) if u1 != u2 => userIds(u1) && userIds(u2) - case _ => false - val sub = Bus.subscribeFun(chans*) { - case StartGame(game) if matches(game) => queue.offer(game).unit - case FinishGame(game, _) if matches(game) => queue.offer(game).unit - } - queue.watchCompletion().addEffectAnyway { - Bus.unsubscribe(sub, chans) - } + def matches(game: Game) = game.userIds match + case List(u1, u2) if u1 != u2 => userIds(u1) && userIds(u2) + case _ => false + val sub = Bus.subscribeFun(chans*): + case StartGame(game) if matches(game) => queue.offer(game) + case FinishGame(game, _) if matches(game) => queue.offer(game) + queue + .watchCompletion() + .addEffectAnyway: + Bus.unsubscribe(sub, chans) } initialGames .concat(startStream) @@ -45,11 +44,10 @@ final class GamesByUsersStream(gameRepo: lila.game.GameRepo)(using import framework.* List( Match($doc(Game.BSONFields.playingUids $in userIds)), - AddFields( - $doc( + AddFields: + $doc: "both" -> $doc("$setIsSubset" -> $arr("$" + Game.BSONFields.playingUids, userIds)) - ) - ), + , Match($doc("both" -> true)) ) .documentSource() @@ -57,7 +55,7 @@ final class GamesByUsersStream(gameRepo: lila.game.GameRepo)(using private object GameStream: - val gameWithInitialFenWriter: OWrites[Game.WithInitialFen] = OWrites { + val gameWithInitialFenWriter: OWrites[Game.WithInitialFen] = OWrites: case Game.WithInitialFen(g, initialFen) => Json .obj( @@ -84,4 +82,3 @@ private object GameStream: "increment" -> clock.incrementSeconds )) .add("daysPerTurn" -> g.daysPerTurn) - } diff --git a/modules/gameSearch/src/main/Env.scala b/modules/gameSearch/src/main/Env.scala index 5f2d8f9269eeb..359e4ba44894f 100644 --- a/modules/gameSearch/src/main/Env.scala +++ b/modules/gameSearch/src/main/Env.scala @@ -34,7 +34,6 @@ final class Env( lazy val userGameSearch = wire[UserGameSearch] - lila.common.Bus.subscribeFun("finishGame", "gameSearchInsert") { - case FinishGame(game, _) if !game.aborted => api.store(game).unit - case InsertGame(game) => api.store(game).unit - } + lila.common.Bus.subscribeFun("finishGame", "gameSearchInsert"): + case FinishGame(game, _) if !game.aborted => api.store(game) + case InsertGame(game) => api.store(game) diff --git a/modules/hub/src/main/AsyncActorConcMap.scala b/modules/hub/src/main/AsyncActorConcMap.scala index 57dd773ff2cb1..da125f07e45c4 100644 --- a/modules/hub/src/main/AsyncActorConcMap.scala +++ b/modules/hub/src/main/AsyncActorConcMap.scala @@ -34,7 +34,7 @@ final class AsyncActorConcMap[Id, D <: AsyncActor]( def exists(id: Id): Boolean = asyncActors.get(id) != null def foreachKey(f: Id => Unit): Unit = - asyncActors.forEachKey(16, k => f(k)) + asyncActors.forEachKey(16, f(_)) def tellAllWithAck(makeMsg: Promise[Unit] => Matchable)(using Executor): Fu[Int] = asyncActors.values.asScala @@ -45,26 +45,22 @@ final class AsyncActorConcMap[Id, D <: AsyncActor]( def size: Int = asyncActors.size() def loadOrTell(id: Id, load: () => D, tell: D => Unit): Unit = - asyncActors - .compute( - id, - (_, a) => - Option(a).fold(load()) { present => - tell(present) - present - } - ) - .unit + asyncActors.compute( + id, + (_, a) => + Option(a).fold(load()) { present => + tell(present) + present + } + ) def terminate(id: Id, lastWill: AsyncActor => Unit): Unit = - asyncActors - .computeIfPresent( - id, - (_, d) => - lastWill(d) - nullD - ) - .unit + asyncActors.computeIfPresent( + id, + (_, d) => + lastWill(d) + nullD + ) private[this] val asyncActors = new ConcurrentHashMap[Id, D](initialCapacity) diff --git a/modules/hub/src/main/SyncActorMap.scala b/modules/hub/src/main/SyncActorMap.scala index 3be55319723f8..cc51cf23fdab8 100644 --- a/modules/hub/src/main/SyncActorMap.scala +++ b/modules/hub/src/main/SyncActorMap.scala @@ -10,13 +10,13 @@ final class SyncActorMap[Id, T <: SyncActor]( def getOrMake(id: Id): T = actors get id - def touchOrMake(id: Id): Unit = getOrMake(id).unit + def touchOrMake(id: Id): Unit = getOrMake(id) def getIfPresent(id: Id): Option[T] = actors getIfPresent id def tell(id: Id, msg: Matchable): Unit = getOrMake(id) ! msg - def tellIfPresent(id: Id, msg: => Matchable): Unit = getIfPresent(id) foreach (_ ! msg) + def tellIfPresent(id: Id, msg: => Matchable): Unit = getIfPresent(id).foreach(_ ! msg) def ask[A](id: Id)(makeMsg: Promise[A] => Matchable): Fu[A] = getOrMake(id).ask(makeMsg) diff --git a/modules/insight/src/main/Env.scala b/modules/insight/src/main/Env.scala index 0484087308aa8..bccf23df88af8 100644 --- a/modules/insight/src/main/Env.scala +++ b/modules/insight/src/main/Env.scala @@ -47,7 +47,7 @@ final class Env( lazy val api = wire[InsightApi] lila.common.Bus.subscribeFun("analysisReady") { case lila.analyse.actorApi.AnalysisReady(game, _) => - api.updateGame(game).unit + api.updateGame(game) } trait InsightDb diff --git a/modules/irc/src/main/Env.scala b/modules/irc/src/main/Env.scala index c2e12e0cf336b..1886463692530 100644 --- a/modules/irc/src/main/Env.scala +++ b/modules/irc/src/main/Env.scala @@ -31,7 +31,6 @@ final class Env( api.stop() funit // don't wait for zulip aknowledgment to restart lila. - lila.common.Bus.subscribeFun("slack", "plan") { - case d: ChargeEvent => api.charge(d).unit - case e: Event => api.publishEvent(e).unit - } + lila.common.Bus.subscribeFun("slack", "plan"): + case d: ChargeEvent => api.charge(d) + case e: Event => api.publishEvent(e) diff --git a/modules/irwin/src/main/Env.scala b/modules/irwin/src/main/Env.scala index 39dc2e3e2736d..4b23c87d4d774 100644 --- a/modules/irwin/src/main/Env.scala +++ b/modules/irwin/src/main/Env.scala @@ -56,17 +56,17 @@ final class Env( .map(_.flatten.map(Suspect.apply)) _ <- irwinApi.requests.fromTournamentLeaders(suspects) _ <- kaladinApi.tournamentLeaders(suspects) - yield ()).unit + yield ()) scheduler.scheduleWithFixedDelay(15 minutes, 15 minutes): () => (for topOnline <- userCache.getTop50Online suspects = topOnline.map(_.user) map Suspect.apply _ <- irwinApi.requests.topOnline(suspects) _ <- kaladinApi.topOnline(suspects) - yield ()).unit + yield ()) scheduler.scheduleWithFixedDelay(83 seconds, 5 seconds): () => - kaladinApi.readResponses.unit + kaladinApi.readResponses scheduler.scheduleWithFixedDelay(1 minute, 1 minute): () => - kaladinApi.monitorQueued.unit + kaladinApi.monitorQueued diff --git a/modules/irwin/src/main/IrwinApi.scala b/modules/irwin/src/main/IrwinApi.scala index cd4ceb81fc603..d382811c0d342 100644 --- a/modules/irwin/src/main/IrwinApi.scala +++ b/modules/irwin/src/main/IrwinApi.scala @@ -41,7 +41,7 @@ final class IrwinApi( _ <- markOrReport(report) yield notification(report) - lila.mon.mod.irwin.ownerReport(report.owner).increment().unit + lila.mon.mod.irwin.ownerReport(report.owner).increment() def get(user: User): Fu[Option[IrwinReport]] = get(user.id) @@ -80,7 +80,7 @@ final class IrwinApi( text = s"${report.activation}% over ${report.games.size} games" ) ) - yield lila.mon.mod.irwin.report.increment().unit + yield lila.mon.mod.irwin.report.increment() else funit } diff --git a/modules/irwin/src/main/IrwinStream.scala b/modules/irwin/src/main/IrwinStream.scala index c0d0953302aca..10abb6c03bd8d 100644 --- a/modules/irwin/src/main/IrwinStream.scala +++ b/modules/irwin/src/main/IrwinStream.scala @@ -16,21 +16,20 @@ final class IrwinStream: Source .queue[IrwinRequest](64, akka.stream.OverflowStrategy.dropHead) .map(requestJson) - .map { js => + .map: js => s"${Json.stringify(js)}\n" - } .keepAlive(60.seconds, () => keepAliveMsg) def apply()(using Executor): Source[String, ?] = blueprint mapMaterializedValue { queue => val sub = Bus.subscribeFun(channel) { case req: IrwinRequest => lila.mon.mod.irwin.streamEventType("request").increment() - queue.offer(req).unit - } - - queue.watchCompletion() addEffectAnyway { - Bus.unsubscribe(sub, channel) + queue.offer(req) } + queue + .watchCompletion() + .addEffectAnyway: + Bus.unsubscribe(sub, channel) } private def requestJson(req: IrwinRequest) = @@ -58,8 +57,7 @@ final class IrwinStream: } orElse info.mate.map { mate => Json.obj("mate" -> mate.value) - } getOrElse - JsNull + } getOrElse JsNull } } ) diff --git a/modules/irwin/src/main/KaladinApi.scala b/modules/irwin/src/main/KaladinApi.scala index bac4003c7a11c..7d3b7ee03a371 100644 --- a/modules/irwin/src/main/KaladinApi.scala +++ b/modules/irwin/src/main/KaladinApi.scala @@ -95,12 +95,12 @@ final class KaladinApi( case Some(pred) => markOrReport(user, pred) andDo { notification(user) - lila.mon.mod.kaladin.activation.record(pred.percent).unit + lila.mon.mod.kaladin.activation.record(pred.percent) } case None => fuccess: res.err.foreach: err => - lila.mon.mod.kaladin.error(err).increment().unit + lila.mon.mod.kaladin.error(err).increment() private def markOrReport(user: KaladinUser, pred: KaladinUser.Pred): Funit = @@ -116,7 +116,9 @@ final class KaladinApi( text = pred.note ) ) - yield lila.mon.mod.kaladin.report.increment().unit + yield + lila.mon.mod.kaladin.report.increment() + () if pred.percent >= thresholds.get().mark then userRepo.hasTitle(user.id) flatMap { @@ -212,5 +214,5 @@ final class KaladinApi( userRepo byId suspectId orFail s"suspect $suspectId not found" dmap Suspect.apply lila.common.Bus.subscribeFun("cheatReport") { case lila.hub.actorApi.report.CheatReportCreated(userId) => - getSuspect(userId) flatMap autoRequest(KaladinUser.Requester.Report) unit + getSuspect(userId) flatMap autoRequest(KaladinUser.Requester.Report) } diff --git a/modules/lobby/src/main/BoardApiHookStream.scala b/modules/lobby/src/main/BoardApiHookStream.scala index ce2bea938ca12..bf19cebc403f1 100644 --- a/modules/lobby/src/main/BoardApiHookStream.scala +++ b/modules/lobby/src/main/BoardApiHookStream.scala @@ -50,4 +50,3 @@ final class BoardApiHookStream( // gotta send a message to check if the client has disconnected queue offer None self ! SetOnline - .unit diff --git a/modules/lobby/src/main/Env.scala b/modules/lobby/src/main/Env.scala index 074e392dfc93b..f60b0888b9325 100644 --- a/modules/lobby/src/main/Env.scala +++ b/modules/lobby/src/main/Env.scala @@ -47,4 +47,4 @@ final class Env( val socket = wire[LobbySocket] lila.common.Bus.subscribeFun("abortGame"): - case lila.game.actorApi.AbortedBy(pov) => abortListener(pov).unit + case lila.game.actorApi.AbortedBy(pov) => abortListener(pov) diff --git a/modules/lobby/src/main/LobbySocket.scala b/modules/lobby/src/main/LobbySocket.scala index 6f3ce4ada376a..5ba0fb7c2a4e8 100644 --- a/modules/lobby/src/main/LobbySocket.scala +++ b/modules/lobby/src/main/LobbySocket.scala @@ -51,7 +51,7 @@ final class LobbySocket( case GetSrisP(promise) => promise success Sris(members.asMap().keySet.map(Sri(_)).toSet) lila.mon.lobby.socket.idle.update(idleSris.size) - lila.mon.lobby.socket.hookSubscribers.update(hookSubscriberSris.size).unit + lila.mon.lobby.socket.hookSubscribers.update(hookSubscriberSris.size) case Cleanup => val membersMap = members.asMap() @@ -78,13 +78,13 @@ final class LobbySocket( ) ) - case RemoveHook(hookId) => removedHookIds.append(hookId).unit + case RemoveHook(hookId) => removedHookIds.append(hookId) case SendHookRemovals => if removedHookIds.nonEmpty then tellActiveHookSubscribers(makeMessage("hrm", removedHookIds.toString)) removedHookIds.clear() - scheduler.scheduleOnce(1249 millis)(this ! SendHookRemovals).unit + scheduler.scheduleOnce(1249 millis)(this ! SendHookRemovals) case JoinHook(sri, hook, game, creatorColor) => lila.mon.lobby.hook.join.increment() diff --git a/modules/mailer/src/main/AutomaticEmail.scala b/modules/mailer/src/main/AutomaticEmail.scala index 64d6312041d41..7ba3319713a8d 100644 --- a/modules/mailer/src/main/AutomaticEmail.scala +++ b/modules/mailer/src/main/AutomaticEmail.scala @@ -45,7 +45,6 @@ The Lichess team""" given Lang = lang import lila.i18n.I18nKeys.* s"""${welcome.txt()}\n${lichessPatronInfo.txt()}""" - .unit def onTitleSet(username: UserStr): Funit = { for @@ -165,10 +164,9 @@ To make a new donation, head to $baseUrl/patron""" else "Patron wings for one month" alsoSendAsPrivateMessage(from): _ => s"""You gift @${to.username} the $wings. Thank you so much!""" - .unit alsoSendAsPrivateMessage(to): _ => s"""@${from.username} gifts you the $wings!""" - .unit + } private[mailer] def dailyCorrespondenceNotice( diff --git a/modules/mailer/src/main/Env.scala b/modules/mailer/src/main/Env.scala index 613a4476def27..9378ce8b01cab 100644 --- a/modules/mailer/src/main/Env.scala +++ b/modules/mailer/src/main/Env.scala @@ -27,7 +27,7 @@ final class Env( text = "Permille of mails to send using secondary SMTP configuration".some ) - lazy val mailer = new Mailer( + lazy val mailer = Mailer( config, getSecondaryPermille = () => mailerSecondaryPermilleSetting.get() ) @@ -36,19 +36,19 @@ final class Env( lila.common.Bus.subscribeFuns( "fishnet" -> { case lila.hub.actorApi.fishnet.NewKey(userId, key) => - automaticEmail.onFishnetKey(userId, key).unit + automaticEmail.onFishnetKey(userId, key) }, "planStart" -> { case lila.hub.actorApi.plan.PlanStart(userId) => - automaticEmail.onPatronNew(userId).unit + automaticEmail.onPatronNew(userId) case lila.hub.actorApi.plan.PlanGift(from, to, lifetime) => - automaticEmail.onPatronGift(from, to, lifetime).unit + automaticEmail.onPatronGift(from, to, lifetime) }, "planExpire" -> { case lila.hub.actorApi.plan.PlanExpire(userId) => - automaticEmail.onPatronStop(userId).unit + automaticEmail.onPatronStop(userId) }, "dailyCorrespondenceNotif" -> { case lila.hub.actorApi.mailer.CorrespondenceOpponents(userId, opponents) => - automaticEmail.dailyCorrespondenceNotice(userId, opponents).unit + automaticEmail.dailyCorrespondenceNotice(userId, opponents) } ) diff --git a/modules/mailer/src/main/Mailer.scala b/modules/mailer/src/main/Mailer.scala index 0d679f04ae4ef..d72fe1d23b2de 100644 --- a/modules/mailer/src/main/Mailer.scala +++ b/modules/mailer/src/main/Mailer.scala @@ -34,24 +34,18 @@ final class Mailer( logger.warn(s"Can't send ${msg.subject} to noreply email ${msg.to}") funit else - Future { - Chronometer.syncMon(_.email.send.time) { - blocking { + Future: + Chronometer.syncMon(_.email.send.time): + blocking: val (client, config) = randomClient() - client - .send( - Email( - subject = msg.subject, - from = config.sender, - to = Seq(msg.to.value), - bodyText = msg.text.some, - bodyHtml = msg.htmlBody map { body => Mailer.html.wrap(msg.subject, body).render } - ) + client.send: + Email( + subject = msg.subject, + from = config.sender, + to = Seq(msg.to.value), + bodyText = msg.text.some, + bodyHtml = msg.htmlBody map { body => Mailer.html.wrap(msg.subject, body).render } ) - .unit - } - } - } object Mailer: diff --git a/modules/memo/src/main/CacheApi.scala b/modules/memo/src/main/CacheApi.scala index cc7514d95ed9a..0ab2c2d5dd89d 100644 --- a/modules/memo/src/main/CacheApi.scala +++ b/modules/memo/src/main/CacheApi.scala @@ -34,7 +34,7 @@ final class CacheApi(mode: Mode)(using Executor, Scheduler): expireAfter: Syncache.ExpireAfter ): Syncache[K, V] = val actualCapacity = - if (mode != Mode.Prod) math.sqrt(initialCapacity.toDouble).toInt atLeast 1 + if mode != Mode.Prod then math.sqrt(initialCapacity.toDouble).toInt atLeast 1 else initialCapacity val cache = new Syncache(name, actualCapacity, compute, default, strategy, expireAfter) monitor(name, cache.cache) @@ -68,7 +68,7 @@ final class CacheApi(mode: Mode)(using Executor, Scheduler): startMonitor(name, cache) def actualCapacity(c: Int) = - if (mode != Mode.Prod) math.sqrt(c.toDouble).toInt atLeast 1 + if mode != Mode.Prod then math.sqrt(c.toDouble).toInt atLeast 1 else c object CacheApi: @@ -96,8 +96,5 @@ object CacheApi: name: String, cache: caffeine.cache.Cache[?, ?] )(using ec: Executor, scheduler: Scheduler): Unit = - scheduler - .scheduleWithFixedDelay(1 minute, 1 minute) { () => - lila.mon.caffeineStats(cache, name) - } - .unit + scheduler.scheduleWithFixedDelay(1 minute, 1 minute): () => + lila.mon.caffeineStats(cache, name) diff --git a/modules/memo/src/main/ExpirableCallbackMemo.scala b/modules/memo/src/main/ExpirableCallbackMemo.scala index a0be5122aa27c..8de15b720a02b 100644 --- a/modules/memo/src/main/ExpirableCallbackMemo.scala +++ b/modules/memo/src/main/ExpirableCallbackMemo.scala @@ -14,24 +14,19 @@ final class ExpireCallbackMemo[K]( private val timeouts = ConcurrentHashMap[K, Cancellable](initialCapacity) - def get(key: K): Boolean = timeouts contains key - - def put(key: K): Unit = timeouts - .compute( - key, - (_, canc) => { - Option(canc).foreach(_.cancel()) - scheduler.scheduleOnce(ttl) { - remove(key) - callback(key) - } + export timeouts.{ contains as get, size as count } + + def put(key: K): Unit = timeouts.compute( + key, + (_, canc) => + Option(canc).foreach(_.cancel()) + scheduler.scheduleOnce(ttl) { + remove(key) + callback(key) } - ) - .unit + ) // does not call the expiration callback def remove(key: K): Unit = Option(timeouts remove key).foreach(_.cancel()) - def count: Int = timeouts.size - def keySet: Set[K] = timeouts.keySet.asScala.toSet diff --git a/modules/memo/src/main/FutureConcurrencyLimit.scala b/modules/memo/src/main/FutureConcurrencyLimit.scala index b2b0c2694bdca..373be6a5638b0 100644 --- a/modules/memo/src/main/FutureConcurrencyLimit.scala +++ b/modules/memo/src/main/FutureConcurrencyLimit.scala @@ -11,7 +11,7 @@ final class FutureConcurrencyLimit[K]( toString: K => String = (k: K) => k.toString )(using Executor): - private val storage = new ConcurrencyLimit.Storage(ttl, maxConcurrency, toString) + private val storage = ConcurrencyLimit.Storage(ttl, maxConcurrency, toString) private lazy val monitor = lila.mon.security.concurrencyLimit(key) @@ -22,6 +22,5 @@ final class FutureConcurrencyLimit[K]( limited case c @ _ => storage.inc(k) - op addEffectAnyway { - storage.dec(k).unit - } + op.addEffectAnyway: + storage.dec(k) diff --git a/modules/mod/src/main/Env.scala b/modules/mod/src/main/Env.scala index 1dd21a7c57e39..e8a27986bd638 100644 --- a/modules/mod/src/main/Env.scala +++ b/modules/mod/src/main/Env.scala @@ -92,20 +92,19 @@ final class Env( } }, "analysisReady" -> { case lila.analyse.actorApi.AnalysisReady(game, analysis) => - assessApi.onAnalysisReady(game, analysis).unit + assessApi.onAnalysisReady(game, analysis) }, "deletePublicChats" -> { case lila.hub.actorApi.security.DeletePublicChats(userId) => - publicChat.deleteAll(userId).unit + publicChat.deleteAll(userId) }, "autoWarning" -> { case lila.hub.actorApi.mod.AutoWarning(userId, subject) => - logApi.modMessage(userId, subject)(using User.lichessIdAsMe).unit + logApi.modMessage(userId, subject)(using User.lichessIdAsMe) }, "selfReportMark" -> { case lila.hub.actorApi.mod.SelfReportMark(suspectId, name) => - api - .autoMark(SuspectId(suspectId), s"Self report: ${name}")(using User.lichessIdAsMe) + api.autoMark(SuspectId(suspectId), s"Self report: ${name}")(using User.lichessIdAsMe) }, "chatTimeout" -> { case lila.hub.actorApi.mod.ChatTimeout(mod, user, reason, text) => - logApi.chatTimeout(user, reason, text)(using mod.into(Me.Id)).unit + logApi.chatTimeout(user, reason, text)(using mod.into(Me.Id)) }, "loginWithWeakPassword" -> { case u: User => logApi.loginWithWeakPassword(u.id) }, "loginWithBlankedPassword" -> { case u: User => logApi.loginWithBlankedPassword(u.id) } diff --git a/modules/mod/src/main/ModApi.scala b/modules/mod/src/main/ModApi.scala index b8170dc043486..0ef073b20d045 100644 --- a/modules/mod/src/main/ModApi.scala +++ b/modules/mod/src/main/ModApi.scala @@ -20,7 +20,7 @@ final class ModApi( _ <- userRepo.setAlt(prev.user.id, v) sus = prev.set(_.withMarks(_.set(_.Alt, v))) _ <- logApi.alt(sus, v) - yield if v then notifier.reporters(me.modId, sus).unit + yield if v then notifier.reporters(me.modId, sus) def setEngine(prev: Suspect, v: Boolean)(using me: Me.Id): Funit = (prev.user.marks.engine != v) so { @@ -64,14 +64,15 @@ final class ModApi( def setTroll(prev: Suspect, value: Boolean)(using me: Me.Id): Fu[Suspect] = val changed = value != prev.user.marks.troll val sus = prev.set(_.withMarks(_.set(_.Troll, value))) - changed so { - userRepo.updateTroll(sus.user).void andDo { - logApi.troll(sus) - Bus.publish(lila.hub.actorApi.mod.Shadowban(sus.user.id, value), "shadowban") - } - } andDo { - if value then notifier.reporters(me.modId, sus).unit - } inject sus + changed + .so: + userRepo.updateTroll(sus.user).void andDo { + logApi.troll(sus) + Bus.publish(lila.hub.actorApi.mod.Shadowban(sus.user.id, value), "shadowban") + } + .andDo: + if value then notifier.reporters(me.modId, sus) + .inject(sus) def autoTroll(sus: Suspect, note: String): Funit = given Me.Id = User.lichessIdAsMe diff --git a/modules/mod/src/main/ModStream.scala b/modules/mod/src/main/ModStream.scala index f210c76b6c362..d8ab7c80b45f5 100644 --- a/modules/mod/src/main/ModStream.scala +++ b/modules/mod/src/main/ModStream.scala @@ -30,12 +30,10 @@ final class ModStream: } def apply()(using Executor): Source[String, ?] = - blueprint mapMaterializedValue { queue => - val sub = Bus.subscribeFun(classifier) { case signup: UserSignup => - queue.offer(signup).unit - } - - queue.watchCompletion() addEffectAnyway { - Bus.unsubscribe(sub, classifier) - } - } + blueprint.mapMaterializedValue: queue => + val sub = Bus.subscribeFun(classifier): + case signup: UserSignup => queue.offer(signup) + queue + .watchCompletion() + .addEffectAnyway: + Bus.unsubscribe(sub, classifier) diff --git a/modules/mod/src/main/RatingRefund.scala b/modules/mod/src/main/RatingRefund.scala index 8f7f46db6de10..dee981f0f277e 100644 --- a/modules/mod/src/main/RatingRefund.scala +++ b/modules/mod/src/main/RatingRefund.scala @@ -23,7 +23,7 @@ final private class RatingRefund( import RatingRefund.* - def schedule(sus: Suspect): Unit = scheduler.scheduleOnce(delay)(apply(sus).unit).unit + def schedule(sus: Suspect): Unit = scheduler.scheduleOnce(delay)(apply(sus)) private def apply(sus: Suspect): Funit = logApi.wasUnengined(sus) flatMap { diff --git a/modules/msg/src/main/Env.scala b/modules/msg/src/main/Env.scala index 991581a1a7978..68269260dc231 100644 --- a/modules/msg/src/main/Env.scala +++ b/modules/msg/src/main/Env.scala @@ -52,7 +52,7 @@ final class Env( Bus.subscribeFuns( "msgSystemSend" -> { case lila.hub.actorApi.msg.SystemMsg(userId, text) => - api.systemPost(userId, text).unit + api.systemPost(userId, text) }, "remoteSocketIn:msgRead" -> { case TellUserIn(userId, msg) => msg.get[UserId]("d") foreach { api.setRead(userId, _) } diff --git a/modules/msg/src/main/MsgNotify.scala b/modules/msg/src/main/MsgNotify.scala index 0fe56644bdb50..e7dc0b13f58fc 100644 --- a/modules/msg/src/main/MsgNotify.scala +++ b/modules/msg/src/main/MsgNotify.scala @@ -43,17 +43,14 @@ final private class MsgNotify( .parallel .void - private def schedule(threadId: MsgThread.Id): Unit = - delayed - .compute( - threadId, - (id, canc) => - Option(canc).foreach(_.cancel()) - scheduler.scheduleOnce(delay): - delayed remove id - doNotify(threadId).unit - ) - .unit + private def schedule(threadId: MsgThread.Id): Unit = delayed.compute( + threadId, + (id, canc) => + Option(canc).foreach(_.cancel()) + scheduler.scheduleOnce(delay): + delayed remove id + doNotify(threadId) + ) private def cancel(threadId: MsgThread.Id): Boolean = Option(delayed remove threadId).map(_.cancel()).isDefined diff --git a/modules/notify/src/main/Env.scala b/modules/notify/src/main/Env.scala index a161937fe9184..79b2b4824535a 100644 --- a/modules/notify/src/main/Env.scala +++ b/modules/notify/src/main/Env.scala @@ -37,15 +37,11 @@ final class Env( // api actor Bus.subscribeFuns( "notify" -> { - case lila.hub.actorApi.notify.NotifiedBatch(userIds) => - api.markAllRead(userIds) unit + case lila.hub.actorApi.notify.NotifiedBatch(userIds) => api.markAllRead(userIds) case lila.game.actorApi.CorresAlarmEvent(pov) => pov.player.userId.so: userId => lila.game.Namer.playerText(pov.opponent)(using getLightUser) foreach { opponent => - api.notifyOne( - userId, - CorresAlarm(gameId = pov.gameId, opponent = opponent) - ) + api.notifyOne(userId, CorresAlarm(gameId = pov.gameId, opponent = opponent)) } }, "streamStart" -> { case lila.hub.actorApi.streamer.StreamStart(userId, streamerName) => diff --git a/modules/oauth/src/main/AuthorizationApi.scala b/modules/oauth/src/main/AuthorizationApi.scala index 032e8749a2a3c..dcbbc2e9fea44 100644 --- a/modules/oauth/src/main/AuthorizationApi.scala +++ b/modules/oauth/src/main/AuthorizationApi.scala @@ -37,12 +37,10 @@ final class AuthorizationApi(val coll: Coll)(using Executor): request.clientSecret .toValid(LegacyClientApi.ClientSecretIgnored) .ensure(LegacyClientApi.MismatchingClientSecret)(_.matches(hashedClientSecret)) - .map(_.unit) case Right(codeChallenge) => request.codeVerifier .toValid(LegacyClientApi.CodeVerifierIgnored) .ensure(Protocol.Error.MismatchingCodeVerifier)(_.matches(codeChallenge)) - .map(_.unit) yield AccessTokenRequest.Granted(pending.userId, pending.scopes into TokenScopes, pending.redirectUri) } diff --git a/modules/perfStat/src/main/Env.scala b/modules/perfStat/src/main/Env.scala index a50b2431bd320..7c891ef4d27e2 100644 --- a/modules/perfStat/src/main/Env.scala +++ b/modules/perfStat/src/main/Env.scala @@ -29,4 +29,4 @@ final class Env( case lila.game.actorApi.FinishGame(game, _) if !game.aborted => indexer addGame game addFailureEffect { e => lila.log("perfStat").error(s"index game ${game.id}", e) - } unit + } diff --git a/modules/plan/src/main/Env.scala b/modules/plan/src/main/Env.scala index 6c852ae8c21c0..2970f5a8fda17 100644 --- a/modules/plan/src/main/Env.scala +++ b/modules/plan/src/main/Env.scala @@ -79,22 +79,19 @@ final class Env( notifier ) - system.scheduler.scheduleWithFixedDelay(5 minutes, 5 minutes) { () => - expiration.run.unit - } - - lila.common.Bus.subscribeFun("email") { case lila.hub.actorApi.user.ChangeEmail(userId, email) => - api.onEmailChange(userId, email).unit - } - - def cli = - new lila.common.Cli: - def process = - case "patron" :: "lifetime" :: user :: Nil => - userRepo byId UserStr(user) flatMapz api.setLifetime inject "ok" - case "patron" :: "month" :: user :: Nil => - userRepo byId UserStr(user) flatMapz api.freeMonth inject "ok" - case "patron" :: "remove" :: user :: Nil => - userRepo byId UserStr(user) flatMapz api.remove inject "ok" + system.scheduler.scheduleWithFixedDelay(5 minutes, 5 minutes): () => + expiration.run + + lila.common.Bus.subscribeFun("email"): + case lila.hub.actorApi.user.ChangeEmail(userId, email) => api.onEmailChange(userId, email) + + def cli = new lila.common.Cli: + def process = + case "patron" :: "lifetime" :: user :: Nil => + userRepo byId UserStr(user) flatMapz api.setLifetime inject "ok" + case "patron" :: "month" :: user :: Nil => + userRepo byId UserStr(user) flatMapz api.freeMonth inject "ok" + case "patron" :: "remove" :: user :: Nil => + userRepo byId UserStr(user) flatMapz api.remove inject "ok" final private class PlanMongo(val patron: Coll, val charge: Coll) diff --git a/modules/plan/src/main/PlanApi.scala b/modules/plan/src/main/PlanApi.scala index 52380bec4bbb4..13b8de0e6b43c 100644 --- a/modules/plan/src/main/PlanApi.scala +++ b/modules/plan/src/main/PlanApi.scala @@ -635,9 +635,9 @@ final class PlanApi( .record(charge.usd.cents) charge.userId.so { userId => mongo.charge.countSel($doc("userId" -> userId)) map { - case 1 => lila.mon.plan.charge.first(charge.serviceName).increment().unit + case 1 => lila.mon.plan.charge.first(charge.serviceName).increment() case _ => - } + } void } >> monthlyGoalApi.get .map: m => diff --git a/modules/playban/src/main/PlaybanApi.scala b/modules/playban/src/main/PlaybanApi.scala index 4a9df2976a68e..b39002fb60ed9 100644 --- a/modules/playban/src/main/PlaybanApi.scala +++ b/modules/playban/src/main/PlaybanApi.scala @@ -223,7 +223,7 @@ final class PlaybanApi( record .bannable(accCreatedAt) .ifFalse(record.banInEffect) - .so { ban => + .so: ban => lila.mon.playban.ban.count.increment() lila.mon.playban.ban.mins.record(ban.mins) Bus.publish( @@ -242,14 +242,13 @@ final class PlaybanApi( ), fetchNewObject = true ) - } .dmap(_ | record) andDo cleanUserIds.remove(record.userId) private def registerRageSit(record: UserRecord, update: RageSit.Update): Funit = update match case RageSit.Update.Inc(delta) => rageSitCache.put(record.userId, fuccess(record.rageSit)) - (delta < 0 && record.rageSit.isVeryBad) so { + (delta < 0 && record.rageSit.isVeryBad).so: messenger.postPreset(record.userId, MsgPreset.sittingAuto).void andDo { Bus.publish( lila.hub.actorApi.mod.AutoWarning(record.userId, MsgPreset.sittingAuto.name), @@ -261,7 +260,5 @@ final class PlaybanApi( .flatMapz: user => noteApi.lichessWrite(user, "Closed for ragesit recidive") andDo Bus.publish(lila.hub.actorApi.playban.RageSitClose(user.id), "rageSitClose") - .unit } - } case _ => funit diff --git a/modules/puzzle/src/main/Env.scala b/modules/puzzle/src/main/Env.scala index ee92514a6495d..a65169a94c388 100644 --- a/modules/puzzle/src/main/Env.scala +++ b/modules/puzzle/src/main/Env.scala @@ -86,7 +86,7 @@ final class Env( private lazy val tagger = wire[PuzzleTagger] scheduler.scheduleAtFixedRate(10 minutes, 1 day): () => - tagger.addAllMissing unit + tagger.addAllMissing if mode == play.api.Mode.Prod then scheduler.scheduleAtFixedRate(1 hour, 1 hour): () => diff --git a/modules/puzzle/src/main/PuzzleSelector.scala b/modules/puzzle/src/main/PuzzleSelector.scala index c8fa839f974dc..8804e17ad8738 100644 --- a/modules/puzzle/src/main/PuzzleSelector.scala +++ b/modules/puzzle/src/main/PuzzleSelector.scala @@ -54,7 +54,7 @@ final class PuzzleSelector( .ratingDiff(angle.key, session.settings.difficulty.key) .record(math.abs(puzzle.glicko.intRating.value - perf.intRating.value)) mon.ratingDev(angle.key).record(puzzle.glicko.intDeviation) - mon.tier(session.path.tier.key, angle.key, session.settings.difficulty.key).increment().unit + mon.tier(session.path.tier.key, angle.key, session.settings.difficulty.key).increment() puzzle nextPuzzleResult(session).flatMap: diff --git a/modules/puzzle/src/main/PuzzleStreak.scala b/modules/puzzle/src/main/PuzzleStreak.scala index d6b992d6473f8..5f284c4d48ab8 100644 --- a/modules/puzzle/src/main/PuzzleStreak.scala +++ b/modules/puzzle/src/main/PuzzleStreak.scala @@ -34,63 +34,56 @@ final class PuzzleStreakApi(colls: PuzzleColls, cacheApi: CacheApi)(using Execut private val poolSize = buckets.map(_._2).sum private val theme = lila.puzzle.PuzzleTheme.mix.key - private val current = cacheApi.unit[Option[PuzzleStreak]] { - _.refreshAfterWrite(30 seconds) - .buildAsyncFuture { _ => - colls - .path { - _.aggregateList(poolSize) { framework => - import framework.* - Facet( - buckets.map { case (rating, nbPuzzles) => - val (tier, samples, deviation) = - if rating > 2300 then (PuzzleTier.good, 5, 110) else (PuzzleTier.top, 1, 85) - rating.toString -> List( - Match( - $doc( - "min" $lte f"${theme}${sep}${tier}${sep}${rating}%04d", - "max" $gte f"${theme}${sep}${tier}${sep}${rating}%04d" - ) - ), - Sample(samples), - Project($doc("_id" -> false, "ids" -> true)), - UnwindField("ids"), - // ensure we have enough after filtering deviation - Sample(nbPuzzles * 4), - PipelineOperator( - $lookup.pipeline( - from = colls.puzzle, - as = "puzzle", - local = "ids", - foreign = "_id", - pipe = List($doc("$match" -> $doc("glicko.d" $lte deviation))) - ) - ), - UnwindField("puzzle"), - Sample(nbPuzzles), - ReplaceRootField("puzzle") - ) - } - ) -> List( - Project($doc("all" -> $doc("$setUnion" -> buckets.map(r => s"$$${r._1}")))), - UnwindField("all"), - ReplaceRootField("all"), - Sort(Ascending("glicko.r")), - Limit(poolSize) - ) - }.map { - _.flatMap(puzzleReader.readOpt) - } - } - .mon(_.streak.selector.time) - .addEffect(monitor) - .map { puzzles => - puzzles.headOption map { - PuzzleStreak(puzzles.map(_.id) mkString " ", _) - } - } - } - } + private val current = cacheApi.unit[Option[PuzzleStreak]]: + _.refreshAfterWrite(30 seconds).buildAsyncFuture: _ => + colls + .path: + _.aggregateList(poolSize): framework => + import framework.* + Facet( + buckets.map { case (rating, nbPuzzles) => + val (tier, samples, deviation) = + if rating > 2300 then (PuzzleTier.good, 5, 110) else (PuzzleTier.top, 1, 85) + rating.toString -> List( + Match( + $doc( + "min" $lte f"${theme}${sep}${tier}${sep}${rating}%04d", + "max" $gte f"${theme}${sep}${tier}${sep}${rating}%04d" + ) + ), + Sample(samples), + Project($doc("_id" -> false, "ids" -> true)), + UnwindField("ids"), + // ensure we have enough after filtering deviation + Sample(nbPuzzles * 4), + PipelineOperator( + $lookup.pipeline( + from = colls.puzzle, + as = "puzzle", + local = "ids", + foreign = "_id", + pipe = List($doc("$match" -> $doc("glicko.d" $lte deviation))) + ) + ), + UnwindField("puzzle"), + Sample(nbPuzzles), + ReplaceRootField("puzzle") + ) + } + ) -> List( + Project($doc("all" -> $doc("$setUnion" -> buckets.map(r => s"$$${r._1}")))), + UnwindField("all"), + ReplaceRootField("all"), + Sort(Ascending("glicko.r")), + Limit(poolSize) + ) + .map: + _.flatMap(puzzleReader.readOpt) + .mon(_.streak.selector.time) + .addEffect(monitor) + .map: puzzles => + puzzles.headOption.map: + PuzzleStreak(puzzles.map(_.id) mkString " ", _) private def monitor(puzzles: List[Puzzle]): Unit = val nb = puzzles.size @@ -99,7 +92,7 @@ final class PuzzleStreakApi(colls: PuzzleColls, cacheApi: CacheApi)(using Execut if nb > 1 then val rest = puzzles.toVector drop 1 lila.common.Maths.mean(rest.map(_.glicko.intRating.value)) foreach { r => - lila.mon.streak.selector.rating.record(r.toInt).unit + lila.mon.streak.selector.rating.record(r.toInt) } (0 to poolSize by 10) foreach { i => val slice = rest drop i take 10 diff --git a/modules/racer/src/main/RacerSocket.scala b/modules/racer/src/main/RacerSocket.scala index 1ebb19580bb98..2299b01424982 100644 --- a/modules/racer/src/main/RacerSocket.scala +++ b/modules/racer/src/main/RacerSocket.scala @@ -21,7 +21,7 @@ final private class RacerSocket( private lazy val racerHandler: Handler = case Protocol.In.PlayerJoin(raceId, playerId) => - api.join(raceId, playerId).unit + api.join(raceId, playerId) case Protocol.In.PlayerScore(raceId, playerId, score) => api.registerPlayerScore(raceId, playerId, score) case Protocol.In.RaceStart(raceId, playerId) => diff --git a/modules/relation/src/main/RelationApi.scala b/modules/relation/src/main/RelationApi.scala index b3a2edcaa6084..fb464fde10f08 100644 --- a/modules/relation/src/main/RelationApi.scala +++ b/modules/relation/src/main/RelationApi.scala @@ -115,7 +115,7 @@ final class RelationApi( countFollowingCache.update(u1, prev => (prev + 1) atMost config.maxFollow.value) timeline ! Propagate(FollowUser(u1, u2)).toFriendsOf(u1) Bus.publish(lila.hub.actorApi.relation.Follow(u1, u2), "relation") - lila.mon.relation.follow.increment().unit + lila.mon.relation.follow.increment() } } } @@ -157,7 +157,7 @@ final class RelationApi( lila.hub.actorApi.socket.SendTo(u2, lila.socket.Socket.makeMessage("blockedBy", u1)), "socketUsers" ) - lila.mon.relation.block.increment().unit + lila.mon.relation.block.increment() } def unfollow(u1: UserId, u2: UserId): Funit = @@ -166,7 +166,7 @@ final class RelationApi( repo.unfollow(u1, u2) andDo { countFollowingCache.update(u1, _ - 1) Bus.publish(lila.hub.actorApi.relation.UnFollow(u1, u2), "relation") - lila.mon.relation.unfollow.increment().unit + lila.mon.relation.unfollow.increment() } } @@ -181,7 +181,7 @@ final class RelationApi( lila.hub.actorApi.socket.SendTo(u2, lila.socket.Socket.makeMessage("unblockedBy", u1)), "socketUsers" ) - lila.mon.relation.unblock.increment().unit + lila.mon.relation.unblock.increment() } else funit } diff --git a/modules/relay/src/main/Env.scala b/modules/relay/src/main/Env.scala index 83c420dcb354e..fdb54cd7453ab 100644 --- a/modules/relay/src/main/Env.scala +++ b/modules/relay/src/main/Env.scala @@ -63,14 +63,12 @@ final class Env( // start the sync scheduler wire[RelayFetch] - system.scheduler.scheduleWithFixedDelay(1 minute, 1 minute) { () => + system.scheduler.scheduleWithFixedDelay(1 minute, 1 minute): () => api.autoStart >> api.autoFinishNotSyncing - () - } lila.common.Bus.subscribeFuns( "study" -> { case lila.hub.actorApi.study.RemoveStudy(studyId, _) => - api.onStudyRemove(studyId).unit + api.onStudyRemove(studyId) }, "relayToggle" -> { case lila.study.actorApi.RelayToggle(id, v, who) => studyApi.isContributor(id, who.u) foreach { diff --git a/modules/relay/src/main/RelayFetch.scala b/modules/relay/src/main/RelayFetch.scala index 6468d039dbb7c..ef52dd94071f3 100644 --- a/modules/relay/src/main/RelayFetch.scala +++ b/modules/relay/src/main/RelayFetch.scala @@ -65,7 +65,7 @@ final private class RelayFetch( fetchGames(rt) .map(games => rt.tour.players.fold(games)(_ update games)) .mon(_.relay.fetchTime(rt.tour.official, rt.round.slug)) - .addEffect(gs => lila.mon.relay.games(rt.tour.official, rt.round.slug).update(gs.size).unit) + .addEffect(gs => lila.mon.relay.games(rt.tour.official, rt.round.slug).update(gs.size)) .flatMap: games => sync(rt, games) .withTimeoutError(7 seconds, SyncResult.Timeout) diff --git a/modules/relay/src/main/RelayPgnStream.scala b/modules/relay/src/main/RelayPgnStream.scala index 5cab5b7f89dc4..0a145fc04cd3f 100644 --- a/modules/relay/src/main/RelayPgnStream.scala +++ b/modules/relay/src/main/RelayPgnStream.scala @@ -42,17 +42,15 @@ final class RelayPgnStream( else Source.empty[PgnStr] } concat Source .queue[Set[StudyChapterId]](8, akka.stream.OverflowStrategy.dropHead) - .mapMaterializedValue { queue => + .mapMaterializedValue: queue => val chan = SyncResult busChannel rt.relay.id val sub = Bus.subscribeFun(chan) { case SyncResult.Ok(chapters, _) => - queue - .offer(chapters.view.filter(c => c.tagUpdate || c.newMoves > 0).map(_.id).toSet) - .unit + queue.offer(chapters.view.filter(c => c.tagUpdate || c.newMoves > 0).map(_.id).toSet) } - queue.watchCompletion().addEffectAnyway { - Bus.unsubscribe(sub, chan) - } - } + queue + .watchCompletion() + .addEffectAnyway: + Bus.unsubscribe(sub, chan) .flatMapConcat(studyChapterRepo.byIdsSource) .throttle(16, 1 second) .mapAsync(1)(studyPgnDump.ofChapter(rt.study, flags)) diff --git a/modules/report/src/main/AutoAnalysis.scala b/modules/report/src/main/AutoAnalysis.scala index 3cba8870d5c33..73c30e7b64f13 100644 --- a/modules/report/src/main/AutoAnalysis.scala +++ b/modules/report/src/main/AutoAnalysis.scala @@ -15,7 +15,7 @@ final class AutoAnalysis( else candidate.isPrint so fuccess: List(30, 90).foreach: minutes => - scheduler.scheduleOnce(minutes minutes) { doItNow(candidate).unit } + scheduler.scheduleOnce(minutes minutes) { doItNow(candidate) } private def doItNow(candidate: Report.Candidate) = gamesToAnalyse(candidate).map: games => diff --git a/modules/report/src/main/Env.scala b/modules/report/src/main/Env.scala index 57eebd4029903..6b3633454b25f 100644 --- a/modules/report/src/main/Env.scala +++ b/modules/report/src/main/Env.scala @@ -64,17 +64,17 @@ final class Env( new Actor: def receive = case lila.hub.actorApi.report.Cheater(userId, text) => - api.autoCheatReport(userId, text).unit + api.autoCheatReport(userId, text) case lila.hub.actorApi.report.Shutup(userId, text, critical) => - api.autoCommReport(userId, text, critical).unit + api.autoCommReport(userId, text, critical) ), name = config.actorName ) lila.common.Bus.subscribeFun("playban", "autoFlag"): - case lila.hub.actorApi.playban.Playban(userId, mins, _) => api.maybeAutoPlaybanReport(userId, mins).unit + case lila.hub.actorApi.playban.Playban(userId, mins, _) => api.maybeAutoPlaybanReport(userId, mins) case lila.hub.actorApi.report.AutoFlag(suspectId, resource, text, critical) => - api.autoCommFlag(SuspectId(suspectId), resource, text, critical).unit + api.autoCommFlag(SuspectId(suspectId), resource, text, critical) scheduler.scheduleWithFixedDelay(1 minute, 1 minute): () => - api.inquiries.expire.unit + api.inquiries.expire diff --git a/modules/report/src/main/ReportApi.scala b/modules/report/src/main/ReportApi.scala index 9b3046864cad1..14634495bbfef 100644 --- a/modules/report/src/main/ReportApi.scala +++ b/modules/report/src/main/ReportApi.scala @@ -285,7 +285,7 @@ final class ReportApi( ) doProcessReport(selector, unsetInquiry = true).void andDo maxScoreCache.invalidateUnit() andDo - lila.mon.mod.report.close.increment().unit + lila.mon.mod.report.close.increment() private def doProcessReport(selector: Bdoc, unsetInquiry: Boolean)(using me: Me.Id): Funit = coll.update @@ -356,7 +356,7 @@ final class ReportApi( room -> s.so(_.toInt) .toMap .addEffect: scores => - lila.mon.mod.report.highest.update(scores.highest).unit + lila.mon.mod.report.highest.update(scores.highest) def maxScores = maxScoreCache.getUnit diff --git a/modules/room/src/main/RoomSocket.scala b/modules/room/src/main/RoomSocket.scala index dcee422b76157..88c8ec6ec6cea 100644 --- a/modules/room/src/main/RoomSocket.scala +++ b/modules/room/src/main/RoomSocket.scala @@ -62,7 +62,7 @@ object RoomSocket: publicSource(roomId)(PublicSource), chatBusChan ) - .unit + case Protocol.In.ChatTimeout(roomId, modId, suspect, reason, text) => lila.chat.ChatTimeout.Reason(reason) foreach { r => localTimeout.so { _(roomId, modId, suspect) } foreach { local => diff --git a/modules/round/src/main/ApiMoveStream.scala b/modules/round/src/main/ApiMoveStream.scala index 7495cac252f47..91f1de9b1ad7e 100644 --- a/modules/round/src/main/ApiMoveStream.scala +++ b/modules/round/src/main/ApiMoveStream.scala @@ -64,7 +64,7 @@ final class ApiMoveStream( val chans = List(MoveGameEvent makeChan game.id, "finishGame") val sub = Bus.subscribeFun(chans*): case MoveGameEvent(g, fen, move) => - queue.offer(toJson(g, fen, move.some)).unit + queue.offer(toJson(g, fen, move.some)) case FinishGame(g, _) if g.id == game.id => queue offer makeGameJson(g) (1 to buffer.size) foreach { _ => queue.offer(Json.obj()) } // push buffer content out diff --git a/modules/round/src/main/CorresAlarm.scala b/modules/round/src/main/CorresAlarm.scala index 849ebf5c59006..2fcf3a887af48 100644 --- a/modules/round/src/main/CorresAlarm.scala +++ b/modules/round/src/main/CorresAlarm.scala @@ -27,12 +27,12 @@ final private class CorresAlarm( private given BSONDocumentHandler[Alarm] = Macros.handler Bus.subscribeFun("finishGame") { case lila.game.actorApi.FinishGame(game, _) => - if game.hasCorrespondenceClock && !game.hasAi then coll.delete.one($id(game.id)).unit + if game.hasCorrespondenceClock && !game.hasAi then coll.delete.one($id(game.id)) } Bus.subscribeFun("moveEventCorres") { case lila.hub.actorApi.round.CorresMoveEvent(move, _, _, true, _) => - proxyGame(move.gameId) foreach { - _ foreach { game => + proxyGame(move.gameId).foreach: + _.foreach: game => game.playableCorrespondenceClock.ifTrue(game.bothPlayersHaveMoved) so { clock => val remainingSeconds = clock remainingTime game.turnColor val ringsAt = nowInstant.plusSeconds(remainingSeconds.toInt * 8 / 10) @@ -48,8 +48,6 @@ final private class CorresAlarm( ) .void } - } - } } LilaScheduler("CorresAlarm", _.Every(10 seconds), _.AtMost(10 seconds), _.Delay(2 minutes)) { diff --git a/modules/round/src/main/CorrespondenceEmail.scala b/modules/round/src/main/CorrespondenceEmail.scala index f44430324df07..730b6f93a09ec 100644 --- a/modules/round/src/main/CorrespondenceEmail.scala +++ b/modules/round/src/main/CorrespondenceEmail.scala @@ -20,16 +20,15 @@ final private class CorrespondenceEmail(gameRepo: GameRepo, userRepo: UserRepo, private val (runAfter, runBefore) = (LocalTime parse "05:00", LocalTime parse "05:11") - def tick(): Unit = { + def tick(): Unit = val now = LocalTime.now if now.isAfter(runAfter) && now.isBefore(runBefore) then run() - }.unit private def run() = opponentStream .map { Bus.publish(_, "dailyCorrespondenceNotif") } .runWith(LilaStream.sinkCount) - .addEffect(lila.mon.round.correspondenceEmail.emails.record(_).unit) + .addEffect(lila.mon.round.correspondenceEmail.emails.record(_)) .monSuccess(_.round.correspondenceEmail.time) private def opponentStream = diff --git a/modules/round/src/main/Env.scala b/modules/round/src/main/Env.scala index dbd999e179a81..7420e351f63ad 100644 --- a/modules/round/src/main/Env.scala +++ b/modules/round/src/main/Env.scala @@ -96,7 +96,7 @@ final class Env( onStart(gameId) }, "selfReport" -> { case RoundSocket.Protocol.In.SelfReport(fullId, ip, userId, name) => - selfReport(userId, ip, fullId, name).unit + selfReport(userId, ip, fullId, name) }, "adjustCheater" -> { case lila.hub.actorApi.mod.MarkCheater(userId, true) => resignAllGamesOf(userId) diff --git a/modules/round/src/main/Finisher.scala b/modules/round/src/main/Finisher.scala index 7056b79fb1e06..32382433b61de 100644 --- a/modules/round/src/main/Finisher.scala +++ b/modules/round/src/main/Finisher.scala @@ -65,7 +65,7 @@ final private class Finisher( winner: Option[Color], message: Option[Messenger.SystemMessage] = None )(using GameProxy): Fu[Events] = - apply(game, status, winner, message) andDo playban.other(game, status, winner).unit + apply(game, status, winner, message) andDo playban.other(game, status, winner) private def recordLagStats(game: Game) = for clock <- game.clock diff --git a/modules/round/src/main/GameProxy.scala b/modules/round/src/main/GameProxy.scala index dd8d944333bbc..9c8b9c56e5776 100644 --- a/modules/round/src/main/GameProxy.scala +++ b/modules/round/src/main/GameProxy.scala @@ -79,7 +79,8 @@ final private class GameProxy( private def scheduleFlushProgress(): Unit = scheduledFlush.cancel() - scheduledFlush = scheduler.scheduleOnce(scheduleDelay) { flushProgress().unit } + scheduledFlush = scheduler.scheduleOnce(scheduleDelay): + flushProgress() private def flushProgress(): Funit = scheduledFlush.cancel() diff --git a/modules/round/src/main/Messenger.scala b/modules/round/src/main/Messenger.scala index e4aeb938fa0b9..25a5bf02b4018 100644 --- a/modules/round/src/main/Messenger.scala +++ b/modules/round/src/main/Messenger.scala @@ -18,11 +18,9 @@ final class Messenger(api: ChatApi): case Messenger.SystemMessage.Volatile(msg) => system(persistent = false)(game, msg) def system(persistent: Boolean)(game: Game, message: String): Unit = if game.nonAi then - { - api.userChat.volatile(chatWatcherId(game.id into ChatId), message, _.Round) - if persistent then api.userChat.system(game.id into ChatId, message, _.Round) - else api.userChat.volatile(game.id into ChatId, message, _.Round) - }.unit + api.userChat.volatile(chatWatcherId(game.id into ChatId), message, _.Round) + if persistent then api.userChat.system(game.id into ChatId, message, _.Round) + else api.userChat.volatile(game.id into ChatId, message, _.Round) def watcher(gameId: GameId, userId: UserId, text: String) = api.userChat.write(gameWatcherId(gameId), userId, text, PublicSource.Watcher(gameId).some, _.Round) diff --git a/modules/round/src/main/MoveLatMonitor.scala b/modules/round/src/main/MoveLatMonitor.scala index 0cceb257349bd..d1b65a398c119 100644 --- a/modules/round/src/main/MoveLatMonitor.scala +++ b/modules/round/src/main/MoveLatMonitor.scala @@ -7,19 +7,18 @@ private object MoveLatMonitor: private case class Latency(totalMillis: Long = 0, count: Int = 0): def recordMillis(millis: Int) = copy(totalMillis + millis, count + 1) def average = (totalMillis / count.atLeast(1)).toInt - private val latency = new AtomicReference(Latency()) + private val latency = AtomicReference(Latency()) private def microsToMillis(micros: Int) = Math.ceil(micros.toFloat / 1000).toInt def recordMicros(micros: Int): Unit = - latency.getAndUpdate(_ recordMillis microsToMillis(micros)).unit + latency.getAndUpdate(_ recordMillis microsToMillis(micros)) object wsLatency: var latestMillis = 0 def set(millis: Int) = latestMillis = millis def start(scheduler: Scheduler)(using Executor) = - scheduler.scheduleWithFixedDelay(10 second, 2 second) { () => + scheduler.scheduleWithFixedDelay(10 second, 2 second): () => val full = latency.getAndSet(Latency()).average + wsLatency.latestMillis lila.common.Bus.publish(lila.hub.actorApi.round.Mlat(full), "mlat") - } diff --git a/modules/round/src/main/Player.scala b/modules/round/src/main/Player.scala index bb0f7b63055b2..e5c8ca64d48d5 100644 --- a/modules/round/src/main/Player.scala +++ b/modules/round/src/main/Player.scala @@ -100,7 +100,7 @@ final private class Player( .save(progress) .andDo: uciMemo.add(progress.game, moveOrDrop) - lila.mon.fishnet.move(~game.aiLevel).increment().unit + lila.mon.fishnet.move(~game.aiLevel).increment() notifyMove(moveOrDrop, progress.game) .>> { if progress.game.finished then moveFinish(progress.game) dmap { progress.events ::: _ } diff --git a/modules/round/src/main/RoundAsyncActor.scala b/modules/round/src/main/RoundAsyncActor.scala index 1a696364ea7eb..ca638e587ec9e 100644 --- a/modules/round/src/main/RoundAsyncActor.scala +++ b/modules/round/src/main/RoundAsyncActor.scala @@ -456,13 +456,13 @@ final private[round] class RoundAsyncActor( private def errorHandler(name: String): PartialFunction[Throwable, Unit] = case e: FishnetError => logger.info(s"Round fishnet error $name: ${e.getMessage}") - lila.mon.round.error.fishnet.increment().unit + lila.mon.round.error.fishnet.increment() case e: BenignError => logger.info(s"Round client error $name: ${e.getMessage}") - lila.mon.round.error.client.increment().unit + lila.mon.round.error.client.increment() case e: Exception => logger.warn(s"$name: ${e.getMessage}") - lila.mon.round.error.other.increment().unit + lila.mon.round.error.other.increment() def roomId = gameId into RoomId diff --git a/modules/round/src/main/RoundSocket.scala b/modules/round/src/main/RoundSocket.scala index 44d0a1e7beba2..402671dbb8cf8 100644 --- a/modules/round/src/main/RoundSocket.scala +++ b/modules/round/src/main/RoundSocket.scala @@ -108,13 +108,13 @@ final class RoundSocket( case Protocol.In.PlayerChatSay(id, Right(color), msg) => gameIfPresent(id).foreach: _.foreach: - messenger.owner(_, color, msg).unit + messenger.owner(_, color, msg) case Protocol.In.PlayerChatSay(id, Left(userId), msg) => - messenger.owner(id, userId, msg).unit + messenger.owner(id, userId, msg) case Protocol.In.WatcherChatSay(id, userId, msg) => - messenger.watcher(id, userId, msg).unit + messenger.watcher(id, userId, msg) case RP.In.ChatTimeout(roomId, modId, suspect, reason, text) => - messenger.timeout(ChatId(s"$roomId/w"), suspect, reason, text)(using modId).unit + messenger.timeout(ChatId(s"$roomId/w"), suspect, reason, text)(using modId) case Protocol.In.Berserk(gameId, userId) => Bus.publish(Berserk(gameId, userId), "berserk") case Protocol.In.PlayerOnlines(onlines) => onlines.foreach: @@ -197,7 +197,7 @@ final class RoundSocket( rounds.tellAll(RoundAsyncActor.Tick) scheduler.scheduleWithFixedDelay(60 seconds, 60 seconds): () => - lila.mon.round.asyncActorCount.update(rounds.size).unit + lila.mon.round.asyncActorCount.update(rounds.size) private val terminationDelay = TerminationDelay(scheduler, 1 minute, finishRound) @@ -425,16 +425,14 @@ object RoundSocket: private[this] val terminations = ConcurrentHashMap[GameId, Cancellable](65536) def schedule(gameId: GameId): Unit = - terminations - .compute( - gameId, - (id, canc) => - Option(canc).foreach(_.cancel()) - scheduler.scheduleOnce(duration): - terminations remove id - terminate(id) - ) - .unit + terminations.compute( + gameId, + (id, canc) => + Option(canc).foreach(_.cancel()) + scheduler.scheduleOnce(duration): + terminations remove id + terminate(id) + ) def cancel(gameId: GameId): Unit = Option(terminations remove gameId).foreach(_.cancel()) diff --git a/modules/round/src/main/Takebacker.scala b/modules/round/src/main/Takebacker.scala index c3463a33afd79..753d35307fb52 100644 --- a/modules/round/src/main/Takebacker.scala +++ b/modules/round/src/main/Takebacker.scala @@ -121,13 +121,9 @@ final private class Takebacker( private def publishTakeback(prevPov: Pov)(using proxy: GameProxy): Unit = if lila.game.Game.isBoardOrBotCompatible(prevPov.game) then - proxy - .withPov(prevPov.color) { p => - fuccess( - Bus.publish( - lila.game.actorApi.BoardTakeback(p.game), - lila.game.actorApi.BoardTakeback makeChan prevPov.gameId - ) + proxy.withPov(prevPov.color): p => + fuccess: + Bus.publish( + lila.game.actorApi.BoardTakeback(p.game), + lila.game.actorApi.BoardTakeback makeChan prevPov.gameId ) - } - .unit diff --git a/modules/round/src/main/Titivate.scala b/modules/round/src/main/Titivate.scala index 63efc2e6ed398..4ae773fe39053 100644 --- a/modules/round/src/main/Titivate.scala +++ b/modules/round/src/main/Titivate.scala @@ -30,7 +30,7 @@ final private[round] class Titivate( given Executor = context.system.dispatcher - def scheduleNext(): Unit = context.system.scheduler.scheduleOnce(5 seconds, self, Run).unit + def scheduleNext(): Unit = context.system.scheduler.scheduleOnce(5 seconds, self, Run) def receive = case ReceiveTimeout => @@ -48,7 +48,7 @@ final private[round] class Titivate( .via(gameFlow) .toMat(LilaStream.sinkCount)(Keep.right) .run() - .addEffect(lila.mon.round.titivate.game.record(_).unit) + .addEffect(lila.mon.round.titivate.game.record(_)) .>> { gameRepo .countSec(_.checkableOld) @@ -56,7 +56,7 @@ final private[round] class Titivate( } .monSuccess(_.round.titivate.time) .logFailure(logBranch) - .addEffectAnyway(scheduleNext().unit) + .addEffectAnyway(scheduleNext()) } private val logBranch = logger branch "titivate" diff --git a/modules/security/src/main/DisposableEmailAttempt.scala b/modules/security/src/main/DisposableEmailAttempt.scala index fa6dc362dcd47..5870ec8033a06 100644 --- a/modules/security/src/main/DisposableEmailAttempt.scala +++ b/modules/security/src/main/DisposableEmailAttempt.scala @@ -16,14 +16,12 @@ final class DisposableEmailAttempt( import DisposableEmailAttempt.* private val byIp = - cacheApi.notLoadingSync[IpAddress, Set[Attempt]](64, "security.disposableEmailAttempt.ip") { + cacheApi.notLoadingSync[IpAddress, Set[Attempt]](64, "security.disposableEmailAttempt.ip"): _.expireAfterWrite(1 day).build() - } private val byId = - cacheApi.notLoadingSync[UserId, Set[Attempt]](64, "security.disposableEmailAttempt.id") { + cacheApi.notLoadingSync[UserId, Set[Attempt]](64, "security.disposableEmailAttempt.id"): _.expireAfterWrite(1 day).build() - } def onFail(form: Form[?], ip: IpAddress): Unit = for email <- form("email").value flatMap EmailAddress.from @@ -32,8 +30,8 @@ final class DisposableEmailAttempt( u <- UserStr read str yield val attempt = Attempt(u.id, email, ip) - byIp.underlying.asMap.compute(ip, (_, attempts) => ~Option(attempts) + attempt).unit - byId.underlying.asMap.compute(u.id, (_, attempts) => ~Option(attempts) + attempt).unit + byIp.underlying.asMap.compute(ip, (_, attempts) => ~Option(attempts) + attempt) + byId.underlying.asMap.compute(u.id, (_, attempts) => ~Option(attempts) + attempt) def onSuccess(user: User, email: EmailAddress, ip: IpAddress) = val attempts = ~byIp.getIfPresent(ip) ++ ~byId.getIfPresent(user.id) diff --git a/modules/security/src/main/Env.scala b/modules/security/src/main/Env.scala index f6f80bd072f14..3add05b031c89 100644 --- a/modules/security/src/main/Env.scala +++ b/modules/security/src/main/Env.scala @@ -133,18 +133,16 @@ final class Env( scheduler.scheduleWithFixedDelay( config.disposableEmail.refreshDelay, config.disposableEmail.refreshDelay - ) { () => + ): () => disposableEmailDomain.refresh() - } lazy val tor: Tor = wire[Tor] if config.tor.enabled then - scheduler.scheduleOnce(44 seconds)(tor.refresh.unit) - scheduler.scheduleWithFixedDelay(config.tor.refreshDelay, config.tor.refreshDelay) { () => + scheduler.scheduleOnce(44 seconds): + tor.refresh + scheduler.scheduleWithFixedDelay(config.tor.refreshDelay, config.tor.refreshDelay): () => tor.refresh flatMap firewall.unblockIps - () - } lazy val ipTrust: IpTrust = wire[IpTrust] diff --git a/modules/security/src/main/Firewall.scala b/modules/security/src/main/Firewall.scala index 17ddc2e7ef8be..3984eb222a301 100644 --- a/modules/security/src/main/Firewall.scala +++ b/modules/security/src/main/Firewall.scala @@ -12,7 +12,8 @@ final class Firewall( private var current: Set[String] = Set.empty - scheduler.scheduleOnce(10 minutes)(loadFromDb.unit) + scheduler.scheduleOnce(10 minutes): + loadFromDb def blocksIp(ip: IpAddress): Boolean = current contains ip.value @@ -36,7 +37,7 @@ final class Firewall( } >> loadFromDb def unblockIps(ips: Iterable[IpAddress]): Funit = - coll.delete.one($inIds(ips)).void andDo loadFromDb.unit + coll.delete.one($inIds(ips)).void andDo loadFromDb private def loadFromDb: Funit = coll.distinctEasy[String, Set]("_id", $empty).map { ips => diff --git a/modules/security/src/main/GarbageCollector.scala b/modules/security/src/main/GarbageCollector.scala index 7c3fadd3ebd93..adcfcfdd74162 100644 --- a/modules/security/src/main/GarbageCollector.scala +++ b/modules/security/src/main/GarbageCollector.scala @@ -102,7 +102,9 @@ final class GarbageCollector( s"Will dispose of https://lichess.org/${user.username} in $wait. Email: ${email.value}. $msg${!armed so " [SIMULATION]"}" logger.info(message) noteApi.lichessWrite(user, s"Garbage collected because of $msg") - if armed then scheduler.scheduleOnce(wait) { doCollect(user.id) }.unit + if armed then + scheduler.scheduleOnce(wait): + doCollect(user.id) } private def hasBeenCollectedBefore(user: User): Fu[Boolean] = diff --git a/modules/security/src/main/Ip2Proxy.scala b/modules/security/src/main/Ip2Proxy.scala index 1beab702042af..0d54e64826901 100644 --- a/modules/security/src/main/Ip2Proxy.scala +++ b/modules/security/src/main/Ip2Proxy.scala @@ -71,7 +71,7 @@ final class Ip2ProxyServer( .addEffect: _.zip(ips).foreach: (proxy, ip) => cache.put(ip, fuccess(proxy)) - lila.mon.security.proxy.result(proxy.value).increment().unit + lila.mon.security.proxy.result(proxy.value).increment() } private val cache = cacheApi[IpAddress, IsProxy](16_384, "ip2proxy.ip"): @@ -85,7 +85,7 @@ final class Ip2ProxyServer( .dmap(readProxyName) .monSuccess(_.security.proxy.request) .addEffect: result => - lila.mon.security.proxy.result(result.value).increment().unit + lila.mon.security.proxy.result(result.value).increment() private def readProxyName(js: JsValue): IsProxy = IsProxy { for diff --git a/modules/setup/src/main/SetupBulk.scala b/modules/setup/src/main/SetupBulk.scala index bc0d078046ba9..d5a8628ccf93a 100644 --- a/modules/setup/src/main/SetupBulk.scala +++ b/modules/setup/src/main/SetupBulk.scala @@ -225,15 +225,14 @@ final class SetupBulkApi(oauthServer: OAuthServer, idGenerator: IdGenerator)(usi val nbGames = pairs.size val cost = nbGames * (if me.isVerified || me.isApiHog then 1 else 3) rateLimit(me.id, fuccess(Left(ScheduleError.RateLimited)), cost = cost): - lila.mon.api.challenge.bulk.scheduleNb(me.id.value).increment(nbGames).unit + lila.mon.api.challenge.bulk.scheduleNb(me.id.value).increment(nbGames) idGenerator .games(nbGames) .map: _.toList zip pairs .map: - _.map { case (id, (w, b)) => - ScheduledGame(id, w, b) - } + _.map: + case (id, (w, b)) => ScheduledGame(id, w, b) .dmap: ScheduledBulk( _id = ThreadLocalRandom nextString 8, diff --git a/modules/shutup/src/main/Env.scala b/modules/shutup/src/main/Env.scala index dab31dcf83a66..79af5f2c2e346 100644 --- a/modules/shutup/src/main/Env.scala +++ b/modules/shutup/src/main/Env.scala @@ -33,16 +33,11 @@ final class Env( Props(new Actor: import lila.hub.actorApi.shutup.* def receive = - case RecordPublicForumMessage(userId, text) => - api.publicForumMessage(userId, text).unit - case RecordTeamForumMessage(userId, text) => - api.teamForumMessage(userId, text).unit - case RecordPrivateMessage(userId, toUserId, text) => - api.privateMessage(userId, toUserId, text).unit - case RecordPrivateChat(chatId, userId, text) => - api.privateChat(chatId, userId, text).unit - case RecordPublicChat(userId, text, source) => - api.publicChat(userId, text, source).unit + case RecordPublicForumMessage(userId, text) => api.publicForumMessage(userId, text) + case RecordTeamForumMessage(userId, text) => api.teamForumMessage(userId, text) + case RecordPrivateMessage(userId, toUserId, text) => api.privateMessage(userId, toUserId, text) + case RecordPrivateChat(chatId, userId, text) => api.privateChat(chatId, userId, text) + case RecordPublicChat(userId, text, source) => api.publicChat(userId, text, source) ), name = config.actorName ) diff --git a/modules/simul/src/main/SimulApi.scala b/modules/simul/src/main/SimulApi.scala index bf5d6f232365c..e39308c1033cd 100644 --- a/modules/simul/src/main/SimulApi.scala +++ b/modules/simul/src/main/SimulApi.scala @@ -273,4 +273,4 @@ final class SimulApi( private object publish: private val siteMessage = SendToFlag("simul", Json.obj("t" -> "reload")) private val debouncer = Debouncer[Unit](5 seconds, 1)(_ => Bus.publish(siteMessage, "sendToFlag")) - def apply() = debouncer.push(()).unit + def apply() = debouncer.push(()) diff --git a/modules/socket/src/main/RemoteSocket.scala b/modules/socket/src/main/RemoteSocket.scala index 7286ced3a0c6d..66510d3c59ebc 100644 --- a/modules/socket/src/main/RemoteSocket.scala +++ b/modules/socket/src/main/RemoteSocket.scala @@ -29,18 +29,18 @@ final class RemoteSocket(redisClient: RedisClient, shutdown: CoordinatedShutdown val baseHandler: Handler = case In.ConnectUser(userId) => - onlineUserIds.getAndUpdate(_ + userId).unit + onlineUserIds.getAndUpdate(_ + userId) case In.ConnectUsers(userIds) => - onlineUserIds.getAndUpdate(_ ++ userIds).unit + onlineUserIds.getAndUpdate(_ ++ userIds) case In.DisconnectUsers(userIds) => - onlineUserIds.getAndUpdate(_ -- userIds).unit + onlineUserIds.getAndUpdate(_ -- userIds) case In.NotifiedBatch(userIds) => Bus.publish(lila.hub.actorApi.notify.NotifiedBatch(userIds), "notify") case In.Lags(lags) => lags.foreach: (userId, centis) => UserLagCache.put(userId, centis) // this shouldn't be necessary... ensure that users are known to be online - onlineUserIds.getAndUpdate((x: UserIds) => x ++ lags.keys).unit + onlineUserIds.getAndUpdate((x: UserIds) => x ++ lags.keys) case In.TellSri(sri, userId, typ, msg) => Bus.publish(TellSriIn(sri.value, userId, msg), s"remoteSocketIn:$typ") case In.TellUser(userId, typ, msg) => @@ -91,13 +91,13 @@ final class RemoteSocket(redisClient: RedisClient, shutdown: CoordinatedShutdown send(Out.impersonate(userId, modId)) case ApiUserIsOnline(userId, value) => send(Out.apiUserOnline(userId, value)) - if value then onlineUserIds.getAndUpdate(_ + userId).unit + if value then onlineUserIds.getAndUpdate(_ + userId) case Follow(u1, u2) => send(Out.follow(u1, u2)) case UnFollow(u1, u2) => send(Out.unfollow(u1, u2)) } final class StoppableSender(val conn: PubSub[String, String], channel: Channel) extends Sender: - def apply(msg: String) = if !stopping then super.send(channel, msg).unit + def apply(msg: String) = if !stopping then super.send(channel, msg) def sticky(_id: String, msg: String) = apply(msg) final class RoundRobinSender(val conn: PubSub[String, String], channel: Channel, parallelism: Int) @@ -107,7 +107,7 @@ final class RemoteSocket(redisClient: RedisClient, shutdown: CoordinatedShutdown def sticky(id: String, msg: String): Unit = publish(id.hashCode.abs % parallelism, msg) private def publish(subChannel: Int, msg: String) = - if !stopping then conn.async.publish(s"$channel:$subChannel", msg).unit + if !stopping then conn.async.publish(s"$channel:$subChannel", msg) def makeSender(channel: Channel, parallelism: Int = 1): Sender = if parallelism > 1 then RoundRobinSender(redisClient.connectPubSub(), channel, parallelism) diff --git a/modules/storm/src/main/StormDay.scala b/modules/storm/src/main/StormDay.scala index e9d4308054b40..2d93abcf42fe0 100644 --- a/modules/storm/src/main/StormDay.scala +++ b/modules/storm/src/main/StormDay.scala @@ -58,24 +58,21 @@ final class StormDayApi(coll: Coll, highApi: StormHighApi, perfsRepo: UserPerfsR user: Option[User], mobile: Boolean ): Fu[Option[StormHigh.NewHigh]] = - lila.mon.storm.run.score(user.isDefined).record(data.score).unit - user so { u => + lila.mon.storm.run.score(user.isDefined).record(data.score) + user.so: u => if mobile || sign.check(u, ~data.signed) then Bus.publish(lila.hub.actorApi.puzzle.StormRun(u.id, data.score), "stormRun") highApi get u.id flatMap { prevHigh => val todayId = Id today u.id coll .one[StormDay]($id(todayId)) - .map { + .map: _.getOrElse(StormDay empty todayId) add data - } - .flatMap { day => + .flatMap: day => coll.update.one($id(day._id), day, upsert = true) - } - .flatMap { _ => + .flatMap: _ => val high = highApi.update(u.id, prevHigh, data.score) perfsRepo.addStormRun(u.id, data.score) inject high - } } else if data.time > 40 then @@ -89,7 +86,6 @@ final class StormDayApi(coll: Coll, highApi: StormHighApi, perfsRepo: UserPerfsR ) .increment() fuccess(none) - } def history(userId: UserId, page: Int): Fu[Paginator[StormDay]] = Paginator( diff --git a/modules/storm/src/main/StormSelector.scala b/modules/storm/src/main/StormSelector.scala index 8d0b162db3660..a5ca477db7671 100644 --- a/modules/storm/src/main/StormSelector.scala +++ b/modules/storm/src/main/StormSelector.scala @@ -41,80 +41,70 @@ final class StormSelector(colls: PuzzleColls, cacheApi: CacheApi)(using Executor acc + nb } - private val current = cacheApi.unit[List[StormPuzzle]] { - _.refreshAfterWrite(6 seconds) - .buildAsyncFuture { _ => - colls - .path { - _.aggregateList(poolSize) { framework => - import framework.* - val fenColorRegex = $doc( - "$regexMatch" -> $doc( - "input" -> "$fen", - "regex" -> { if scala.util.Random.nextBoolean() then " w " else " b " } - ) + private val current = cacheApi.unit[List[StormPuzzle]]: + _.refreshAfterWrite(6 seconds).buildAsyncFuture: _ => + colls + .path: + _.aggregateList(poolSize): framework => + import framework.* + val fenColorRegex = $doc: + "$regexMatch" -> $doc( + "input" -> "$fen", + "regex" -> { if scala.util.Random.nextBoolean() then " w " else " b " } ) - Facet( - ratingBuckets.map { (rating, nbPuzzles) => - rating.toString -> List( - Match( - $doc( - "min" $lte f"${theme}${sep}${tier}${sep}${rating}%04d", - "max" $gte f"${theme}${sep}${tier}${sep}${rating}%04d" - ) - ), - Sample(1), - Project($doc("_id" -> false, "ids" -> true)), - UnwindField("ids"), - // ensure we have enough after filtering deviation & color - Sample(nbPuzzles * 7), - PipelineOperator( - $lookup.pipelineFull( - from = colls.puzzle.name.value, - as = "puzzle", - let = $doc("id" -> "$ids"), - pipe = List( - $doc( - "$match" -> $expr( - $and( - $doc("$eq" -> $arr("$_id", "$$id")), - $doc("$lte" -> $arr("$glicko.d", maxDeviation)), - fenColorRegex - ) - ) - ), - $doc( - "$project" -> $doc( - "fen" -> true, - "line" -> true, - "rating" -> $doc("$toInt" -> "$glicko.r") + Facet( + ratingBuckets.map: (rating, nbPuzzles) => + rating.toString -> List( + Match: + $doc( + "min" $lte f"${theme}${sep}${tier}${sep}${rating}%04d", + "max" $gte f"${theme}${sep}${tier}${sep}${rating}%04d" + ) + , + Sample(1), + Project($doc("_id" -> false, "ids" -> true)), + UnwindField("ids"), + // ensure we have enough after filtering deviation & color + Sample(nbPuzzles * 7), + PipelineOperator: + $lookup.pipelineFull( + from = colls.puzzle.name.value, + as = "puzzle", + let = $doc("id" -> "$ids"), + pipe = List( + $doc: + "$match" -> $expr: + $and( + $doc("$eq" -> $arr("$_id", "$$id")), + $doc("$lte" -> $arr("$glicko.d", maxDeviation)), + fenColorRegex ) + , + $doc: + "$project" -> $doc( + "fen" -> true, + "line" -> true, + "rating" -> $doc("$toInt" -> "$glicko.r") ) - ) ) - ), - UnwindField("puzzle"), - Sample(nbPuzzles), - ReplaceRootField("puzzle") - ) - } - ) -> List( - Project($doc("all" -> $doc("$setUnion" -> ratingBuckets.map(r => s"$$${r._1}")))), - UnwindField("all"), - ReplaceRootField("all"), - Sort(Ascending("rating")), - Limit(poolSize) - ) - }.map { - _.flatMap(puzzleReader.readOpt) - } - } - .mon(_.storm.selector.time) - .addEffect { puzzles => - monitor(puzzles.toVector, poolSize) - } - } - } + ) + , + UnwindField("puzzle"), + Sample(nbPuzzles), + ReplaceRootField("puzzle") + ) + ) -> List( + Project($doc("all" -> $doc("$setUnion" -> ratingBuckets.map(r => s"$$${r._1}")))), + UnwindField("all"), + ReplaceRootField("all"), + Sort(Ascending("rating")), + Limit(poolSize) + ) + .map: + _.flatMap(puzzleReader.readOpt) + .mon(_.storm.selector.time) + .addEffect: puzzles => + monitor(puzzles.toVector, poolSize) private def monitor(puzzles: Vector[StormPuzzle], poolSize: Int): Unit = val nb = puzzles.size @@ -123,7 +113,7 @@ final class StormSelector(colls: PuzzleColls, cacheApi: CacheApi)(using Executor if nb > 1 then val rest = puzzles.toVector drop 1 lila.common.Maths.mean(IntRating raw rest.map(_.rating)) foreach { r => - lila.mon.storm.selector.rating.record(r.toInt).unit + lila.mon.storm.selector.rating.record(r.toInt) } (0 to poolSize by 10) foreach { i => val slice = rest drop i take 10 diff --git a/modules/streamer/src/main/Env.scala b/modules/streamer/src/main/Env.scala index 6b5df574de94c..fb896c25c04ac 100644 --- a/modules/streamer/src/main/Env.scala +++ b/modules/streamer/src/main/Env.scala @@ -81,11 +81,12 @@ final class Env( lazy val liveStreamApi = wire[LiveStreamApi] lila.common.Bus.subscribeFun("adjustCheater", "adjustBooster", "shadowban") { - case lila.hub.actorApi.mod.MarkCheater(userId, true) => api.demote(userId).unit - case lila.hub.actorApi.mod.MarkBooster(userId) => api.demote(userId).unit - case lila.hub.actorApi.mod.Shadowban(userId, true) => api.demote(userId).unit + case lila.hub.actorApi.mod.MarkCheater(userId, true) => api.demote(userId) + case lila.hub.actorApi.mod.MarkBooster(userId) => api.demote(userId) + case lila.hub.actorApi.mod.Shadowban(userId, true) => api.demote(userId) } scheduler.scheduleWithFixedDelay(1 hour, 1 day): () => - api.autoDemoteFakes.unit - scheduler.scheduleWithFixedDelay(21 minutes, 8 days)(() => ytApi.subscribeAll.unit) + api.autoDemoteFakes + scheduler.scheduleWithFixedDelay(21 minutes, 8 days): () => + ytApi.subscribeAll diff --git a/modules/study/src/main/Env.scala b/modules/study/src/main/Env.scala index ce3cce32ab9b1..7ed4d027b3e56 100644 --- a/modules/study/src/main/Env.scala +++ b/modules/study/src/main/Env.scala @@ -88,7 +88,6 @@ final class Env( s"$count done" } - lila.common.Bus.subscribeFun("studyAnalysisProgress") { + lila.common.Bus.subscribeFun("studyAnalysisProgress"): case lila.analyse.actorApi.StudyAnalysisProgress(analysis, complete) => - serverEvalMerger(analysis, complete).unit - } + serverEvalMerger(analysis, complete) diff --git a/modules/study/src/main/StudyTopic.scala b/modules/study/src/main/StudyTopic.scala index 532a91c010c9f..ba64e98f57934 100644 --- a/modules/study/src/main/StudyTopic.scala +++ b/modules/study/src/main/StudyTopic.scala @@ -48,22 +48,18 @@ final class StudyTopicApi(topicRepo: StudyTopicRepo, userTopicRepo: StudyUserTop def findLike(str: String, myId: Option[UserId], nb: Int = 10): Fu[StudyTopics] = StudyTopics from { (str.lengthIs >= 2) so { val favsFu: Fu[List[StudyTopic]] = - myId.so { userId => - userTopics(userId).map { + myId.so: userId => + userTopics(userId).map: _.value.filter(_.value startsWith str) take nb - } - } - favsFu flatMap { favs => + favsFu.flatMap: favs => topicRepo - .coll { + .coll: _.find($doc("_id".$startsWith(java.util.regex.Pattern.quote(str), "i"))) .sort($sort.naturalAsc) .cursor[Bdoc]() .list(nb - favs.size) - } .dmap { _ flatMap docTopic } .dmap { favs ::: _ } - } } } @@ -82,34 +78,34 @@ final class StudyTopicApi(topicRepo: StudyTopicRepo, userTopicRepo: StudyUserTop Json.parse(json).validate[List[TagifyTopic]] match case JsSuccess(topics, _) => StudyTopics.fromStrs(topics.map(_.value), StudyTopics.userMax) case _ => StudyTopics.empty - userTopicRepo.coll { - _.update.one( - $id(user.id), - $set("topics" -> topics), - upsert = true - ) - }.void + userTopicRepo + .coll: + _.update.one( + $id(user.id), + $set("topics" -> topics), + upsert = true + ) + .void def userTopicsAdd(userId: UserId, topics: StudyTopics): Funit = topics.value.nonEmpty so userTopics(userId).flatMap { prev => val newTopics = prev ++ topics (newTopics != prev) so - userTopicRepo.coll { - _.update.one($id(userId), $set("topics" -> newTopics), upsert = true) - }.void + userTopicRepo + .coll: + _.update.one($id(userId), $set("topics" -> newTopics), upsert = true) + .void } def popular(nb: Int): Fu[StudyTopics] = StudyTopics from topicRepo - .coll { + .coll: _.find($empty) .sort($sort.naturalAsc) .cursor[Bdoc]() .list(nb) - } - .dmap { + .dmap: _ flatMap docTopic - } private def docTopic(doc: Bdoc): Option[StudyTopic] = doc.getAsOpt[StudyTopic]("_id") @@ -122,27 +118,27 @@ final class StudyTopicApi(topicRepo: StudyTopicRepo, userTopicRepo: StudyUserTop ) def recompute(): Unit = - recomputeWorkQueue(LilaFuture.makeItLast(60 seconds)(recomputeNow)).recover { + recomputeWorkQueue(LilaFuture.makeItLast(60 seconds)(recomputeNow)).recover: case _: lila.hub.BoundedAsyncActor.EnqueueException => () case e: Exception => logger.warn("Can't recompute study topics!", e) - }.unit private def recomputeNow: Funit = - studyRepo.coll { - _.aggregateWith[Bdoc]() { framework => - import framework.* - List( - Match( - $doc( - "topics" $exists true, - "visibility" -> "public" - ) - ), - Project($doc("topics" -> true, "_id" -> false)), - UnwindField("topics"), - SortByFieldCount("topics"), - Project($doc("_id" -> true)), - Out(topicRepo.coll.name.value) - ) - }.headOption - }.void + studyRepo + .coll: + _.aggregateWith[Bdoc](): framework => + import framework.* + List( + Match( + $doc( + "topics" $exists true, + "visibility" -> "public" + ) + ), + Project($doc("topics" -> true, "_id" -> false)), + UnwindField("topics"), + SortByFieldCount("topics"), + Project($doc("_id" -> true)), + Out(topicRepo.coll.name.value) + ) + .headOption + .void diff --git a/modules/studySearch/src/main/Env.scala b/modules/studySearch/src/main/Env.scala index 49e73c00c34c2..2a96b0acf8b1a 100644 --- a/modules/studySearch/src/main/Env.scala +++ b/modules/studySearch/src/main/Env.scala @@ -16,12 +16,7 @@ final class Env( chapterRepo: lila.study.ChapterRepo, pager: lila.study.StudyPager, makeClient: Index => ESClient -)(using - ec: Executor, - system: ActorSystem, - scheduler: Scheduler, - mat: akka.stream.Materializer -): +)(using Executor, ActorSystem, Scheduler, akka.stream.Materializer): private val client = makeClient(Index("study")) @@ -40,13 +35,11 @@ final class Env( maxPerPage = pager.maxPerPage ) - def cli = - new lila.common.Cli: - def process = - case "study" :: "search" :: "reset" :: Nil => api.reset("reset") inject "done" - case "study" :: "search" :: "index" :: since :: Nil => api.reset(since) inject "done" + def cli = new lila.common.Cli: + def process = + case "study" :: "search" :: "reset" :: Nil => api.reset("reset") inject "done" + case "study" :: "search" :: "index" :: since :: Nil => api.reset(since) inject "done" - Bus.subscribeFun("study") { - case lila.study.actorApi.SaveStudy(study) => api.store(study).unit - case RemoveStudy(id, _) => client.deleteById(id into Id).unit - } + Bus.subscribeFun("study"): + case lila.study.actorApi.SaveStudy(study) => api.store(study) + case RemoveStudy(id, _) => client.deleteById(id into Id) diff --git a/modules/swiss/src/main/Env.scala b/modules/swiss/src/main/Env.scala index 2a5a9a98bd924..88a0576d3395a 100644 --- a/modules/swiss/src/main/Env.scala +++ b/modules/swiss/src/main/Env.scala @@ -91,28 +91,19 @@ final class Env( wire[SwissNotify] - lila.common.Bus.subscribeFun( - "finishGame", - "adjustCheater", - "adjustBooster", - "teamLeave" - ) { - case lila.game.actorApi.FinishGame(game, _) => api.finishGame(game).unit - case lila.hub.actorApi.team.LeaveTeam(teamId, userId) => api.leaveTeam(teamId, userId).unit - case lila.hub.actorApi.mod.MarkCheater(userId, true) => api.kickLame(userId).unit - case lila.hub.actorApi.mod.MarkBooster(userId) => api.kickLame(userId).unit - } - - LilaScheduler("Swiss.startPendingRounds", _.Every(1 seconds), _.AtMost(20 seconds), _.Delay(20 seconds))( + lila.common.Bus.subscribeFun("finishGame", "adjustCheater", "adjustBooster", "teamLeave"): + case lila.game.actorApi.FinishGame(game, _) => api.finishGame(game) + case lila.hub.actorApi.team.LeaveTeam(teamId, userId) => api.leaveTeam(teamId, userId) + case lila.hub.actorApi.mod.MarkCheater(userId, true) => api.kickLame(userId) + case lila.hub.actorApi.mod.MarkBooster(userId) => api.kickLame(userId) + + LilaScheduler("Swiss.startPendingRounds", _.Every(1 seconds), _.AtMost(20 seconds), _.Delay(20 seconds)): api.startPendingRounds - ) - LilaScheduler("Swiss.checkOngoingGames", _.Every(10 seconds), _.AtMost(15 seconds), _.Delay(20 seconds))( + LilaScheduler("Swiss.checkOngoingGames", _.Every(10 seconds), _.AtMost(15 seconds), _.Delay(20 seconds)): api.checkOngoingGames - ) - LilaScheduler("Swiss.generate", _.Every(3 hours), _.AtMost(15 seconds), _.Delay(15 minutes))( + LilaScheduler("Swiss.generate", _.Every(3 hours), _.AtMost(15 seconds), _.Delay(15 minutes)): officialSchedule.generate - ) final private class SwissMongo(val swiss: Coll, val player: Coll, val pairing: Coll, val ban: Coll) diff --git a/modules/swiss/src/main/PairingSystem.scala b/modules/swiss/src/main/PairingSystem.scala index 9950284cf6999..7d216326e81e6 100644 --- a/modules/swiss/src/main/PairingSystem.scala +++ b/modules/swiss/src/main/PairingSystem.scala @@ -27,11 +27,9 @@ final private class PairingSystem(trf: SwissTrf, executable: String)(using val command = s"$executable --$flavour $file -p" val stdout = new collection.mutable.ListBuffer[String] val stderr = new StringBuilder - val status = lila.common.Chronometer.syncMon(_.swiss.bbpairing) { - blocking { - command ! ProcessLogger(stdout append _, stderr append _ unit) - } - } + val status = lila.common.Chronometer.syncMon(_.swiss.bbpairing): + blocking: + command ! ProcessLogger(stdout append _, stderr append _) if status != 0 then val error = stderr.toString if error contains "No valid pairing exists" then Nil @@ -43,7 +41,7 @@ final private class PairingSystem(trf: SwissTrf, executable: String)(using output .drop(1) // first line is the number of pairings .map(_ split ' ') - .collect { + .collect: case Array(p, "0") => p.toIntOption flatMap idsToPlayers.get map { userId => Left(SwissPairing.Bye(userId)) @@ -53,7 +51,6 @@ final private class PairingSystem(trf: SwissTrf, executable: String)(using white <- w.toIntOption flatMap idsToPlayers.get black <- b.toIntOption flatMap idsToPlayers.get yield Right(SwissPairing.Pending(white, black)) - } .flatten def withTempFile[A](swiss: Swiss, contents: Source[String, ?])(f: File => A): Fu[A] = diff --git a/modules/swiss/src/main/SwissApi.scala b/modules/swiss/src/main/SwissApi.scala index 09d71577d49fe..0e668286d2492 100644 --- a/modules/swiss/src/main/SwissApi.scala +++ b/modules/swiss/src/main/SwissApi.scala @@ -465,26 +465,23 @@ final class SwissApi( mongo.pairing.delete.one($doc(f.swissId -> swiss.id, f.status -> true)) map { res => if res.n > 0 then logger.warn(s"Swiss ${swiss.id} finished with ${res.n} ongoing pairings") } - .void andDo { - systemChat(swiss.id, s"Tournament completed!") - cache.swissCache clear swiss.id - socket.reload(swiss.id) - scheduler - .scheduleOnce(10 seconds): - // we're delaying this to make sure the ranking has been recomputed - // since doFinish is called by finishGame before that - rankingApi(swiss) foreach { ranking => - Bus.publish(SwissFinish(swiss.id, ranking), "swissFinish") - } - .unit - } + .void + .andDo: + systemChat(swiss.id, s"Tournament completed!") + cache.swissCache clear swiss.id + socket.reload(swiss.id) + scheduler + .scheduleOnce(10 seconds): + // we're delaying this to make sure the ranking has been recomputed + // since doFinish is called by finishGame before that + rankingApi(swiss).foreach: ranking => + Bus.publish(SwissFinish(swiss.id, ranking), "swissFinish") def kill(swiss: Swiss): Funit = { if swiss.isStarted then - finish(swiss) andDo { + finish(swiss).andDo: logger.info(s"Tournament ${swiss.id} cancelled by its creator.") systemChat(swiss.id, "Tournament cancelled by its creator.") - } else if swiss.isCreated then destroy(swiss) else funit } andDo cache.featuredInTeam.invalidate(swiss.teamId) diff --git a/modules/swiss/src/main/SwissJson.scala b/modules/swiss/src/main/SwissJson.scala index e6399642dd443..5dfe9d0301b71 100644 --- a/modules/swiss/src/main/SwissJson.scala +++ b/modules/swiss/src/main/SwissJson.scala @@ -118,19 +118,17 @@ final class SwissJson( top3.headOption .map(_.userId) .filter(w => swiss.winnerId.fold(true)(w !=)) - .foreach { + .foreach: mongo.swiss.updateField($id(swiss.id), "winnerId", _).void - } - .unit + userRepo.filterLame(top3.map(_.userId)) map { lame => JsArray( - top3.map { player => + top3.map: player => playerJsonBase( player, lightUserApi.syncFallback(player.userId), performance = true ).add("lame", lame(player.userId)) - } ).some } } diff --git a/modules/team/src/main/Env.scala b/modules/team/src/main/Env.scala index f5e468711381b..972eda1170260 100644 --- a/modules/team/src/main/Env.scala +++ b/modules/team/src/main/Env.scala @@ -61,7 +61,7 @@ final class Env( lila.common.Bus.subscribeFuns( "shadowban" -> { case lila.hub.actorApi.mod.Shadowban(userId, true) => - api.deleteRequestsByUserId(userId).unit + api.deleteRequestsByUserId(userId) }, "teamIsLeader" -> { case lila.hub.actorApi.team.IsLeader(teamId, userId, promise) => promise completeWith cached.isLeader(teamId, userId) diff --git a/modules/teamSearch/src/main/Env.scala b/modules/teamSearch/src/main/Env.scala index 22669b3eb76c9..d2d8156b41003 100644 --- a/modules/teamSearch/src/main/Env.scala +++ b/modules/teamSearch/src/main/Env.scala @@ -44,10 +44,9 @@ final class Env( system.actorOf( Props(new Actor: import lila.team.{ InsertTeam, RemoveTeam } - def receive = { - case InsertTeam(team) => api.store(team).unit - case RemoveTeam(id) => client.deleteById(id into Id).unit - } + def receive = + case InsertTeam(team) => api.store(team) + case RemoveTeam(id) => client.deleteById(id into Id) ), name = config.actorName ) diff --git a/modules/timeline/src/main/Env.scala b/modules/timeline/src/main/Env.scala index 703ce65ca2ebb..6cb8c4d7dc584 100644 --- a/modules/timeline/src/main/Env.scala +++ b/modules/timeline/src/main/Env.scala @@ -32,13 +32,13 @@ final class Env( private val config = appConfig.get[TimelineConfig]("timeline")(AutoConfig.loader) - lazy val entryApi = new EntryApi( + lazy val entryApi = EntryApi( coll = db(config.entryColl), cacheApi = cacheApi, userMax = config.userDisplayMax ) - lazy val unsubApi = new UnsubApi(db(config.unsubColl)) + lazy val unsubApi = UnsubApi(db(config.unsubColl)) def isUnsub(channel: String)(using me: Me): Fu[Boolean] = unsubApi.get(channel, me) @@ -56,5 +56,5 @@ final class Env( system.actorOf(Props(wire[TimelinePush]), name = config.userActorName) lila.common.Bus.subscribeFun("shadowban") { case lila.hub.actorApi.mod.Shadowban(userId, true) => - entryApi.removeRecentFollowsBy(userId).unit + entryApi.removeRecentFollowsBy(userId) } diff --git a/modules/tournament/src/main/Duel.scala b/modules/tournament/src/main/Duel.scala index 3642a0606bab4..8f9192ef2260a 100644 --- a/modules/tournament/src/main/Duel.scala +++ b/modules/tournament/src/main/Duel.scala @@ -69,12 +69,11 @@ final private class DuelStore: ) def remove(game: Game): Unit = - game.tournamentId foreach { tourId => + game.tournamentId.foreach: tourId => byTourId.computeIfPresent( tourId, (_: TourId, tb: TreeSet[Duel]) => val w = tb - emptyGameId(game.id) if w.isEmpty then null else w ) - } - def remove(tour: Tournament): Unit = byTourId.remove(tour.id).unit + def remove(tour: Tournament): Unit = byTourId.remove(tour.id) diff --git a/modules/tournament/src/main/Env.scala b/modules/tournament/src/main/Env.scala index da23e62036988..80363ca93fc1b 100644 --- a/modules/tournament/src/main/Env.scala +++ b/modules/tournament/src/main/Env.scala @@ -70,10 +70,8 @@ final class Env( clearJsonViewCache = jsonView.clearCache, clearWinnersCache = winners.clearCache, clearTrophyCache = tour => - { - if tour.isShield then scheduler.scheduleOnce(10 seconds) { shieldApi.clear() } - else if Revolution is tour then scheduler.scheduleOnce(10 seconds) { revolutionApi.clear() }.unit - }.unit, + if tour.isShield then scheduler.scheduleOnce(10 seconds) { shieldApi.clear() } + else if Revolution is tour then scheduler.scheduleOnce(10 seconds) { revolutionApi.clear() }, indexLeaderboard = leaderboardIndexer.indexOne ) @@ -115,9 +113,8 @@ final class Env( wire[TournamentScheduler] - scheduler.scheduleWithFixedDelay(1 minute, 1 minute) { () => + scheduler.scheduleWithFixedDelay(1 minute, 1 minute) :() => tournamentRepo.countCreated foreach { lila.mon.tournament.created.update(_) } - } private val redisClient = RedisClient create RedisURI.create(appConfig.get[String]("socket.redis.uri")) val lilaHttp = wire[TournamentLilaHttp] diff --git a/modules/tournament/src/main/StartedOrganizer.scala b/modules/tournament/src/main/StartedOrganizer.scala index 8dd51d0956406..e73311d4f4dac 100644 --- a/modules/tournament/src/main/StartedOrganizer.scala +++ b/modules/tournament/src/main/StartedOrganizer.scala @@ -13,37 +13,28 @@ final private class StartedOrganizer( var runCounter = 0 - LilaScheduler( - "Tournament.StartedOrganizer", - _.Every(1 seconds), - _.AtMost(30 seconds), - _.Delay(26 seconds) - ) { + LilaScheduler("Tournament.StartedOrganizer", _.Every(1 seconds), _.AtMost(30 seconds), _.Delay(26 seconds)): val doAllTournaments = runCounter % 15 == 0 tournamentRepo - .startedCursorWithNbPlayersGte { + .startedCursorWithNbPlayersGte: if doAllTournaments then none // every 15s, do all tournaments else if runCounter % 2 == 0 then 50.some // every 2s, do all decent tournaments else 1000.some // always do massive tournaments - } .documentSource() - .mapAsyncUnordered(4) { tour => + .mapAsyncUnordered(4): tour => processTour(tour) recover { case e: Exception => logger.error(s"StartedOrganizer $tour", e) 0 } - } .toMat(LilaStream.sinkCount)(Keep.right) .run() - .addEffect { nb => - if doAllTournaments then lila.mon.tournament.started.update(nb).unit + .addEffect: nb => + if doAllTournaments then lila.mon.tournament.started.update(nb) runCounter = runCounter + 1 - } .monSuccess(_.tournament.startedOrganizer.tick) .void - } private def processTour(tour: Tournament): Funit = if tour.secondsToFinish <= 0 then api finish tour @@ -62,7 +53,6 @@ final private class StartedOrganizer( socket .getWaitingUsers(tour) .monSuccess(_.tournament.startedOrganizer.waitingUsers) - .flatMap { waiting => - lila.mon.tournament.waitingPlayers.record(waiting.size).unit + .flatMap: waiting => + lila.mon.tournament.waitingPlayers.record(waiting.size) api.makePairings(tour, waiting, smallTourNbActivePlayers) - } diff --git a/modules/tournament/src/main/TournamentApi.scala b/modules/tournament/src/main/TournamentApi.scala index 863f07d579897..2549722335827 100644 --- a/modules/tournament/src/main/TournamentApi.scala +++ b/modules/tournament/src/main/TournamentApi.scala @@ -154,13 +154,16 @@ final class TournamentApi( .map { socket.startGame(tour.id, _) } .parallel .void - .mon(_.tournament.pairing.createInserts) andDo { - lila.mon.tournament.pairing.batchSize.record(pairings.size).unit - waitingUsers.registerPairedUsers(tour.id, pairings.view.flatMap(_.pairing.users).toSet) - socket.reload(tour.id) - hadPairings put tour.id - featureOneOf(tour, pairings, ranking.ranking).unit // do outside of queue - } + .mon(_.tournament.pairing.createInserts) + .andDo: + lila.mon.tournament.pairing.batchSize.record(pairings.size) + waitingUsers.registerPairedUsers( + tour.id, + pairings.view.flatMap(_.pairing.users).toSet + ) + socket.reload(tour.id) + hadPairings put tour.id + featureOneOf(tour, pairings, ranking.ranking) // do outside of queue } } .monSuccess(_.tournament.pairing.create) @@ -718,7 +721,7 @@ final class TournamentApi( "sendToFlag" ) } - def apply() = debouncer.push(()).unit + def apply() = debouncer.push(()) private object updateTournamentStanding: diff --git a/modules/tournament/src/main/TournamentBusHandler.scala b/modules/tournament/src/main/TournamentBusHandler.scala index 3b5e16dceb438..c5d61034d55a8 100644 --- a/modules/tournament/src/main/TournamentBusHandler.scala +++ b/modules/tournament/src/main/TournamentBusHandler.scala @@ -19,9 +19,7 @@ final private class TournamentBusHandler( "berserk" ): - case FinishGame(game, _) => api.finishGame(game).unit - - case lila.playban.SittingDetected(game, player) => api.sittingDetected(game, player).unit + case FinishGame(game, _) => api.finishGame(game) case lila.hub.actorApi.mod.MarkCheater(userId, true) => ejectFromEnterable(userId) >> @@ -36,17 +34,15 @@ final private class TournamentBusHandler( winnersApi.clearAfterMarking(userId) () - case lila.hub.actorApi.mod.MarkBooster(userId) => ejectFromEnterable(userId).unit - - case lila.hub.actorApi.round.Berserk(gameId, userId) => api.berserk(gameId, userId).unit - - case lila.hub.actorApi.playban.Playban(userId, _, true) => api.pausePlaybanned(userId).unit - - case lila.hub.actorApi.team.KickFromTeam(teamId, userId) => api.kickFromTeam(teamId, userId).unit + case lila.hub.actorApi.mod.MarkBooster(userId) => ejectFromEnterable(userId) + case lila.hub.actorApi.round.Berserk(gameId, userId) => api.berserk(gameId, userId) + case lila.hub.actorApi.playban.Playban(userId, _, true) => api.pausePlaybanned(userId) + case lila.hub.actorApi.team.KickFromTeam(teamId, userId) => api.kickFromTeam(teamId, userId) + case lila.playban.SittingDetected(game, player) => api.sittingDetected(game, player) private def ejectFromEnterable(userId: UserId) = tournamentRepo.withdrawableIds(userId, reason = "ejectFromEnterable") flatMap { - _.map { + _.traverse_ { api.ejectLameFromEnterable(_, userId) - }.parallel + } } diff --git a/modules/tournament/src/main/TournamentLilaHttp.scala b/modules/tournament/src/main/TournamentLilaHttp.scala index 7a73ab77540c2..58aa175700bd1 100644 --- a/modules/tournament/src/main/TournamentLilaHttp.scala +++ b/modules/tournament/src/main/TournamentLilaHttp.scala @@ -41,10 +41,10 @@ final class TournamentLilaHttp( arenaFullJson(tour) map Json.stringify .map: str => lila.mon.tournament.lilaHttp.fullSize.record(str.size) - conn.async.publish(channel, str).unit + conn.async.publish(channel, str) .runWith(LilaStream.sinkCount) .monSuccess(_.tournament.lilaHttp.tick) - .addEffect(lila.mon.tournament.lilaHttp.nbTours.update(_).unit) + .addEffect(lila.mon.tournament.lilaHttp.nbTours.update(_)) .void } diff --git a/modules/tournament/src/main/TournamentShield.scala b/modules/tournament/src/main/TournamentShield.scala index 0007b859049f1..e5fec17d8c148 100644 --- a/modules/tournament/src/main/TournamentShield.scala +++ b/modules/tournament/src/main/TournamentShield.scala @@ -36,12 +36,11 @@ final class TournamentShieldApi( history(none).map(_.current(cat).map(_.owner)) } - private[tournament] def clear(): Unit = cache.invalidateUnit().unit + private[tournament] def clear(): Unit = cache.invalidateUnit() - private[tournament] def clearAfterMarking(userId: UserId): Funit = cache.getUnit map { hist => + private[tournament] def clearAfterMarking(userId: UserId): Funit = cache.getUnit.map: hist => if hist.value.exists(_._2.exists(_.owner == userId)) then clear() - } private val cache = cacheApi.unit[History]: _.refreshAfterWrite(1 day).buildAsyncFuture: _ => diff --git a/modules/tournament/src/main/TournamentSocket.scala b/modules/tournament/src/main/TournamentSocket.scala index 27ce3096c7fa5..9b86891871a89 100644 --- a/modules/tournament/src/main/TournamentSocket.scala +++ b/modules/tournament/src/main/TournamentSocket.scala @@ -69,7 +69,7 @@ final private class TournamentSocket( ) private lazy val tourHandler: Handler = { case Protocol.In.WaitingUsers(roomId, users) => - waitingUsers.registerWaitingUsers(roomId into TourId, users).unit + waitingUsers.registerWaitingUsers(roomId into TourId, users) } private lazy val send: String => Unit = remoteSocketApi.makeSender("tour-out").apply diff --git a/modules/tournament/src/main/WinnersApi.scala b/modules/tournament/src/main/WinnersApi.scala index 0bdbac6535669..f2b07ce8c75a2 100644 --- a/modules/tournament/src/main/WinnersApi.scala +++ b/modules/tournament/src/main/WinnersApi.scala @@ -65,22 +65,20 @@ final class WinnersApi( private def fetchLastFreq(freq: Freq, since: Instant): Fu[List[Tournament]] = tournamentRepo.coll - .find( + .find: $doc( "schedule.freq" -> freq.name, "startsAt" $gt since.minusHours(12), "winner" $exists true ) - ) .sort($sort desc "startsAt") .cursor[Tournament](ReadPref.sec) .list(Int.MaxValue) private def firstStandardWinner(tours: List[Tournament], speed: Speed): Option[Winner] = tours - .find { t => + .find: t => t.variant.standard && t.schedule.exists(_.speed == speed) - } .flatMap(_.winner) private def firstVariantWinner(tours: List[Tournament], variant: Variant): Option[Winner] = @@ -123,21 +121,18 @@ final class WinnersApi( private val allCache = mongoCache.unit[AllWinners]( "tournament:winner:all", 59 minutes - ) { loader => - _.refreshAfterWrite(1 hour) - .buildAsyncFuture(loader(_ => fetchAll)) - } + ): loader => + _.refreshAfterWrite(1 hour).buildAsyncFuture(loader(_ => fetchAll)) def all: Fu[AllWinners] = allCache.get {} // because we read on secondaries, delay cache clear def clearCache(tour: Tournament): Unit = if tour.schedule.exists(_.freq.isDailyOrBetter) then - scheduler.scheduleOnce(5.seconds) { allCache.invalidate {}.unit }.unit + scheduler.scheduleOnce(5.seconds) { allCache.invalidate {} } - private[tournament] def clearAfterMarking(userId: UserId): Funit = all map { winners => - if winners.userIds contains userId then allCache.invalidate {}.unit - } + private[tournament] def clearAfterMarking(userId: UserId): Funit = all.map: winners => + if winners.userIds contains userId then allCache.invalidate {} object WinnersApi: diff --git a/modules/tutor/src/main/TutorApi.scala b/modules/tutor/src/main/TutorApi.scala index dbaad9b897b6b..8e9c43d3f2813 100644 --- a/modules/tutor/src/main/TutorApi.scala +++ b/modules/tutor/src/main/TutorApi.scala @@ -43,7 +43,7 @@ final class TutorApi( val expired = started.isBefore(nowInstant minusSeconds builder.maxTime.toSeconds.toInt) || started.isBefore(Uptime.startedAt) - expired so queue.remove(next.userId) andDo lila.mon.tutor.buildTimeout.increment().unit + expired so queue.remove(next.userId) andDo lila.mon.tutor.buildTimeout.increment() } // we only wait for queue.start @@ -61,12 +61,11 @@ final class TutorApi( queue.remove(userId) } - private val cache = cacheApi[UserId, Option[TutorFullReport]](256, "tutor.report") { + private val cache = cacheApi[UserId, Option[TutorFullReport]](256, "tutor.report"): // _.expireAfterAccess(if (mode == Mode.Prod) 5 minutes else 1 second) _.expireAfterAccess(3.minutes) .maximumSize(1024) .buildAsyncFuture(findLatest) - } private def findLatest(userId: UserId) = colls.report .find($doc(TutorFullReport.F.user -> userId)) diff --git a/modules/ublog/src/main/UblogApi.scala b/modules/ublog/src/main/UblogApi.scala index ca69d4bee2e7b..613c209b431e8 100644 --- a/modules/ublog/src/main/UblogApi.scala +++ b/modules/ublog/src/main/UblogApi.scala @@ -45,7 +45,7 @@ final class UblogApi( timeline ! Propagate( lila.hub.actorApi.timeline.UblogPost(user.id, post.id, post.slug, post.title) ).toFollowersOf(user.id) - if blog.modTier.isEmpty then sendPostToZulipMaybe(user, post).unit + if blog.modTier.isEmpty then sendPostToZulipMaybe(user, post) def getUserBlog(user: User, insertMissing: Boolean = false): Fu[UblogBlog] = getBlog(UblogBlog.Id.User(user.id)) getOrElse { diff --git a/modules/user/src/main/Env.scala b/modules/user/src/main/Env.scala index 38cec839ea457..df33b5d35d06b 100644 --- a/modules/user/src/main/Env.scala +++ b/modules/user/src/main/Env.scala @@ -74,13 +74,13 @@ final class Env( lila.common.Bus.subscribeFuns( "adjustCheater" -> { case lila.hub.actorApi.mod.MarkCheater(userId, true) => rankingApi remove userId - repo.setRoles(userId, Nil).unit + repo.setRoles(userId, Nil) }, "adjustBooster" -> { case lila.hub.actorApi.mod.MarkBooster(userId) => rankingApi remove userId - repo.setRoles(userId, Nil).unit + repo.setRoles(userId, Nil) }, "kickFromRankings" -> { case lila.hub.actorApi.mod.KickFromRankings(userId) => - rankingApi.remove(userId).unit + rankingApi.remove(userId) } ) diff --git a/modules/user/src/main/RankingApi.scala b/modules/user/src/main/RankingApi.scala index 526c540563471..e1728bb3bad99 100644 --- a/modules/user/src/main/RankingApi.scala +++ b/modules/user/src/main/RankingApi.scala @@ -200,7 +200,6 @@ final class RankingApi( lila.mon.rating.distribution(pt.key.value, rating).update(prev.toDouble / total) acc } - .unit object RankingApi: diff --git a/modules/user/src/main/UserRepo.scala b/modules/user/src/main/UserRepo.scala index 20d461efe8d5b..cc78fa2398822 100644 --- a/modules/user/src/main/UserRepo.scala +++ b/modules/user/src/main/UserRepo.scala @@ -156,7 +156,6 @@ final class UserRepo(val coll: Coll)(using Executor): $id(userId) ++ $doc(F.colorIt -> $not(if value < 0 then $lte(-3) else $gte(5))), $inc(F.colorIt -> value) ) - .unit def lichess = byId(User.lichessId) def irwin = byId(User.irwinId) @@ -168,7 +167,7 @@ final class UserRepo(val coll: Coll)(using Executor): def setUsernameCased(id: UserId, name: UserName): Funit = if id is name then coll.update.one( - $id(id) ++ (F.changedCase $exists false), + $id(id) ++ F.changedCase.$exists(false), $set(F.username -> name, F.changedCase -> true) ) flatMap { result => if result.n == 0 then fufail(s"You have already changed your username") diff --git a/modules/video/src/main/Env.scala b/modules/video/src/main/Env.scala index 9997c5ef7ca8e..f2086d0a84e24 100644 --- a/modules/video/src/main/Env.scala +++ b/modules/video/src/main/Env.scala @@ -53,10 +53,8 @@ final class Env( sheet.fetchAll map { nb => s"Processed $nb videos" } if mode == Mode.Prod then - scheduler.scheduleWithFixedDelay(config.sheetDelay, config.sheetDelay) { () => - sheet.fetchAll.logFailure(logger).unit - } + scheduler.scheduleWithFixedDelay(config.sheetDelay, config.sheetDelay): () => + sheet.fetchAll.logFailure(logger) - scheduler.scheduleWithFixedDelay(config.youtubeDelay, config.youtubeDelay) { () => - youtube.updateAll.logFailure(logger).unit - } + scheduler.scheduleWithFixedDelay(config.youtubeDelay, config.youtubeDelay): () => + youtube.updateAll.logFailure(logger)