Introduce smaller interval for scheduled channels

src/mappings/utils.ts

@@ -19,7 +19,11 @@ import { VideoRelevanceManager } from '../utils/VideoRelevanceManager'
 
 export const commentCountersManager = new CommentCountersManager()
 export const videoRelevanceManager = new VideoRelevanceManager()
-videoRelevanceManager.init(1000 * 60 * 60 * 12)
+// eslint-disable-next-line no-void
+void videoRelevanceManager.init({
+  fullUpdateLoopTime: 1000 * 60 * 60 * 12, // 12 hrs
+  scheduledUpdateLookTime: 1000 * 60 * 10, // 10 mins
+})
 
 export const JOYSTREAM_SS58_PREFIX = 126
 

src/processor.ts

@@ -284,7 +284,6 @@ async function processEvent<EventName extends EventNames>(
 async function afterDbUpdate(em: EntityManager) {
   await commentCountersManager.updateVideoCommentsCounters(em)
   await commentCountersManager.updateParentRepliesCounters(em)
-  await videoRelevanceManager.updateVideoRelevanceValue(em)
 }
 
 processor.run(new TypeormDatabase({ isolationLevel: 'READ COMMITTED' }), async (ctx) => {

src/server-extension/resolvers/AdminResolver/utils.ts

@@ -1,17 +1,14 @@
 import { EntityManager, In } from 'typeorm'
 import { CommentCountersManager } from '../../../utils/CommentsCountersManager'
 import { Comment } from '../../../model'
-import { VideoRelevanceManager } from '../../../utils/VideoRelevanceManager'
 
 export async function processCommentsCensorshipStatusUpdate(em: EntityManager, ids: string[]) {
   const manager = new CommentCountersManager()
-  const videoRelevanceManager = new VideoRelevanceManager()
   const comments = await em.getRepository(Comment).find({ where: { id: In(ids) } })
   comments.forEach((c) => {
     manager.scheduleRecalcForComment(c.parentCommentId)
     manager.scheduleRecalcForVideo(c.videoId)
   })
   await manager.updateVideoCommentsCounters(em)
   await manager.updateParentRepliesCounters(em)
-  await videoRelevanceManager.updateVideoRelevanceValue(em)
 }

src/server-extension/resolvers/VideosResolver/index.ts

@@ -240,7 +240,6 @@ export class VideosResolver {
       const tick = await config.get(ConfigVariable.VideoRelevanceViewsTick, em)
       if (video.viewsNum % tick === 0) {
         videoRelevanceManager.scheduleRecalcForChannel(video.channelId)
-        await videoRelevanceManager.updateVideoRelevanceValue(em)
       }
       await em.save([video, video.channel, newView])
       return {

src/utils/VideoRelevanceManager.ts

@@ -5,6 +5,11 @@ import { globalEm } from './globalEm'
 // constant used to parse seconds from creation
 export const NEWNESS_SECONDS_DIVIDER = 60 * 60 * 24
 
+type VideoRelevanceManagerLoops = {
+  fullUpdateLoopTime: number
+  scheduledUpdateLookTime: number
+}
+
 export class VideoRelevanceManager {
   private channelsToUpdate: Set<string> = new Set()
   private _isVideoRelevanceEnabled = false
@@ -13,8 +18,22 @@ export class VideoRelevanceManager {
     return this._isVideoRelevanceEnabled
   }
 
-  init(intervalMs: number): void {
-    this.updateLoop(intervalMs)
+  async init({
+    fullUpdateLoopTime,
+    scheduledUpdateLookTime,
+  }: VideoRelevanceManagerLoops): Promise<void> {
+    const em = await globalEm
+
+    this.updateScheduledLoop(em, scheduledUpdateLookTime)
+      .then(() => {
+        /* Do nothing */
+      })
+      .catch((err) => {
+        console.error(err)
+        process.exit(-1)
+      })
+
+    this.updateFullUpdateLoop(em, fullUpdateLoopTime)
       .then(() => {
         /* Do nothing */
       })
@@ -91,8 +110,14 @@ export class VideoRelevanceManager {
     this.channelsToUpdate.clear()
   }
 
-  private async updateLoop(intervalMs: number): Promise<void> {
-    const em = await globalEm
+  private async updateScheduledLoop(em: EntityManager, intervalMs: number): Promise<void> {
+    while (true) {
+      await this.updateVideoRelevanceValue(em)
+      await new Promise((resolve) => setTimeout(resolve, intervalMs))
+    }
+  }
+
+  private async updateFullUpdateLoop(em: EntityManager, intervalMs: number): Promise<void> {
     while (true) {
       await this.updateVideoRelevanceValue(em)
       await new Promise((resolve) => setTimeout(resolve, intervalMs))