aboutsummaryrefslogtreecommitdiffhomepage
path: root/server/lib/schedulers/update-videos-scheduler.ts
blob: d123c3ceba6cb40f28390a00c9038ff6c1f7058f (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import { isTestInstance } from '../../helpers/core-utils'
import { logger } from '../../helpers/logger'
import { JobQueue } from '../job-queue'
import { AbstractScheduler } from './abstract-scheduler'
import { ScheduleVideoUpdateModel } from '../../models/video/schedule-video-update'
import { retryTransactionWrapper } from '../../helpers/database-utils'
import { federateVideoIfNeeded } from '../activitypub'
import { SCHEDULER_INTERVALS_MS, sequelizeTypescript } from '../../initializers'
import { VideoPrivacy } from '../../../shared/models/videos'

export class UpdateVideosScheduler extends AbstractScheduler {

  private static instance: AbstractScheduler

  protected schedulerIntervalMs = SCHEDULER_INTERVALS_MS.updateVideos

  private isRunning = false

  private constructor () {
    super()
  }

  async execute () {
    if (this.isRunning === true) return
    this.isRunning = true

    try {
      await retryTransactionWrapper(this.updateVideos.bind(this))
    } catch (err) {
      logger.error('Cannot execute update videos scheduler.', { err })
    } finally {
      this.isRunning = false
    }
  }

  private updateVideos () {
    return sequelizeTypescript.transaction(async t => {
      const schedules = await ScheduleVideoUpdateModel.listVideosToUpdate(t)

      for (const schedule of schedules) {
        const video = schedule.Video
        logger.info('Executing scheduled video update on %s.', video.uuid)

        if (schedule.privacy) {
          const oldPrivacy = video.privacy

          video.privacy = schedule.privacy
          await video.save({ transaction: t })

          const isNewVideo = oldPrivacy === VideoPrivacy.PRIVATE
          await federateVideoIfNeeded(video, isNewVideo, t)
        }

        await schedule.destroy({ transaction: t })
      }
    })
  }

  static get Instance () {
    return this.instance || (this.instance = new this())
  }
}