server/lib/redis.ts

   1 import { createClient, RedisClientOptions, RedisModules, RedisScripts } from 'redis'
   2 import { exists } from '@server/helpers/custom-validators/misc'
   3 import { sha256 } from '@shared/extra-utils'
   4 import { logger } from '../helpers/logger'
   5 import { generateRandomString } from '../helpers/utils'
   6 import { CONFIG } from '../initializers/config'
   7 import {
   8   AP_CLEANER,
   9   CONTACT_FORM_LIFETIME,
  10   RESUMABLE_UPLOAD_SESSION_LIFETIME,
  11   TRACKER_RATE_LIMITS,
  12   USER_EMAIL_VERIFY_LIFETIME,
  13   USER_PASSWORD_CREATE_LIFETIME,
  14   USER_PASSWORD_RESET_LIFETIME,
  15   VIEW_LIFETIME,
  16   WEBSERVER
  17 } from '../initializers/constants'
  18
  19 // Only used for typings
  20 // TODO: remove when https://github.com/microsoft/TypeScript/issues/37181 is fixed
  21 const redisClientWrapperForType = () => createClient<{}, RedisScripts>()
  22
  23 class Redis {
  24
  25   private static instance: Redis
  26   private initialized = false
  27   private connected = false
  28   private client: ReturnType<typeof redisClientWrapperForType>
  29   private prefix: string
  30
  31   private constructor () {
  32   }
  33
  34   init () {
  35     // Already initialized
  36     if (this.initialized === true) return
  37     this.initialized = true
  38
  39     this.client = createClient(Redis.getRedisClientOptions())
  40
  41     logger.info('Connecting to redis...')
  42
  43     this.client.connect()
  44       .then(() => {
  45         logger.info('Connected to redis.')
  46
  47         this.connected = true
  48       }).catch(err => {
  49         logger.error('Cannot connect to redis', { err })
  50         process.exit(-1)
  51       })
  52
  53     this.prefix = 'redis-' + WEBSERVER.HOST + '-'
  54   }
  55
  56   static getRedisClientOptions () {
  57     let config: RedisClientOptions<RedisModules, {}> = {
  58       socket: {
  59         connectTimeout: 20000 // Could be slow since node use sync call to compile PeerTube
  60       }
  61     }
  62
  63     if (CONFIG.REDIS.AUTH) {
  64       config = { ...config, password: CONFIG.REDIS.AUTH }
  65     }
  66
  67     if (CONFIG.REDIS.DB) {
  68       config = { ...config, database: CONFIG.REDIS.DB }
  69     }
  70
  71     if (CONFIG.REDIS.HOSTNAME && CONFIG.REDIS.PORT) {
  72       config.socket = { ...config.socket, host: CONFIG.REDIS.HOSTNAME, port: CONFIG.REDIS.PORT }
  73     } else {
  74       config.socket = { ...config.socket, path: CONFIG.REDIS.SOCKET }
  75     }
  76
  77     return config
  78   }
  79
  80   getClient () {
  81     return this.client
  82   }
  83
  84   getPrefix () {
  85     return this.prefix
  86   }
  87
  88   isConnected () {
  89     return this.connected
  90   }
  91
  92   /* ************ Forgot password ************ */
  93
  94   async setResetPasswordVerificationString (userId: number) {
  95     const generatedString = await generateRandomString(32)
  96
  97     await this.setValue(this.generateResetPasswordKey(userId), generatedString, USER_PASSWORD_RESET_LIFETIME)
  98
  99     return generatedString
 100   }
 101
 102   async setCreatePasswordVerificationString (userId: number) {
 103     const generatedString = await generateRandomString(32)
 104
 105     await this.setValue(this.generateResetPasswordKey(userId), generatedString, USER_PASSWORD_CREATE_LIFETIME)
 106
 107     return generatedString
 108   }
 109
 110   async removePasswordVerificationString (userId: number) {
 111     return this.removeValue(this.generateResetPasswordKey(userId))
 112   }
 113
 114   async getResetPasswordLink (userId: number) {
 115     return this.getValue(this.generateResetPasswordKey(userId))
 116   }
 117
 118   /* ************ Email verification ************ */
 119
 120   async setVerifyEmailVerificationString (userId: number) {
 121     const generatedString = await generateRandomString(32)
 122
 123     await this.setValue(this.generateVerifyEmailKey(userId), generatedString, USER_EMAIL_VERIFY_LIFETIME)
 124
 125     return generatedString
 126   }
 127
 128   async getVerifyEmailLink (userId: number) {
 129     return this.getValue(this.generateVerifyEmailKey(userId))
 130   }
 131
 132   /* ************ Contact form per IP ************ */
 133
 134   async setContactFormIp (ip: string) {
 135     return this.setValue(this.generateContactFormKey(ip), '1', CONTACT_FORM_LIFETIME)
 136   }
 137
 138   async doesContactFormIpExist (ip: string) {
 139     return this.exists(this.generateContactFormKey(ip))
 140   }
 141
 142   /* ************ Views per IP ************ */
 143
 144   setIPVideoView (ip: string, videoUUID: string) {
 145     return this.setValue(this.generateIPViewKey(ip, videoUUID), '1', VIEW_LIFETIME.VIEW)
 146   }
 147
 148   setIPVideoViewer (ip: string, videoUUID: string) {
 149     return this.setValue(this.generateIPViewerKey(ip, videoUUID), '1', VIEW_LIFETIME.VIEWER)
 150   }
 151
 152   async doesVideoIPViewExist (ip: string, videoUUID: string) {
 153     return this.exists(this.generateIPViewKey(ip, videoUUID))
 154   }
 155
 156   async doesVideoIPViewerExist (ip: string, videoUUID: string) {
 157     return this.exists(this.generateIPViewerKey(ip, videoUUID))
 158   }
 159
 160   /* ************ Tracker IP block ************ */
 161
 162   setTrackerBlockIP (ip: string) {
 163     return this.setValue(this.generateTrackerBlockIPKey(ip), '1', TRACKER_RATE_LIMITS.BLOCK_IP_LIFETIME)
 164   }
 165
 166   async doesTrackerBlockIPExist (ip: string) {
 167     return this.exists(this.generateTrackerBlockIPKey(ip))
 168   }
 169
 170   /* ************ Video views stats ************ */
 171
 172   addVideoViewStats (videoId: number) {
 173     const { videoKey, setKey } = this.generateVideoViewStatsKeys({ videoId })
 174
 175     return Promise.all([
 176       this.addToSet(setKey, videoId.toString()),
 177       this.increment(videoKey)
 178     ])
 179   }
 180
 181   async getVideoViewsStats (videoId: number, hour: number) {
 182     const { videoKey } = this.generateVideoViewStatsKeys({ videoId, hour })
 183
 184     const valueString = await this.getValue(videoKey)
 185     const valueInt = parseInt(valueString, 10)
 186
 187     if (isNaN(valueInt)) {
 188       logger.error('Cannot get videos views stats of video %d in hour %d: views number is NaN (%s).', videoId, hour, valueString)
 189       return undefined
 190     }
 191
 192     return valueInt
 193   }
 194
 195   async listVideosViewedForStats (hour: number) {
 196     const { setKey } = this.generateVideoViewStatsKeys({ hour })
 197
 198     const stringIds = await this.getSet(setKey)
 199     return stringIds.map(s => parseInt(s, 10))
 200   }
 201
 202   deleteVideoViewsStats (videoId: number, hour: number) {
 203     const { setKey, videoKey } = this.generateVideoViewStatsKeys({ videoId, hour })
 204
 205     return Promise.all([
 206       this.deleteFromSet(setKey, videoId.toString()),
 207       this.deleteKey(videoKey)
 208     ])
 209   }
 210
 211   /* ************ Local video views buffer ************ */
 212
 213   addLocalVideoView (videoId: number) {
 214     const { videoKey, setKey } = this.generateLocalVideoViewsKeys(videoId)
 215
 216     return Promise.all([
 217       this.addToSet(setKey, videoId.toString()),
 218       this.increment(videoKey)
 219     ])
 220   }
 221
 222   async getLocalVideoViews (videoId: number) {
 223     const { videoKey } = this.generateLocalVideoViewsKeys(videoId)
 224
 225     const valueString = await this.getValue(videoKey)
 226     const valueInt = parseInt(valueString, 10)
 227
 228     if (isNaN(valueInt)) {
 229       logger.error('Cannot get videos views of video %d: views number is NaN (%s).', videoId, valueString)
 230       return undefined
 231     }
 232
 233     return valueInt
 234   }
 235
 236   async listLocalVideosViewed () {
 237     const { setKey } = this.generateLocalVideoViewsKeys()
 238
 239     const stringIds = await this.getSet(setKey)
 240     return stringIds.map(s => parseInt(s, 10))
 241   }
 242
 243   deleteLocalVideoViews (videoId: number) {
 244     const { setKey, videoKey } = this.generateLocalVideoViewsKeys(videoId)
 245
 246     return Promise.all([
 247       this.deleteFromSet(setKey, videoId.toString()),
 248       this.deleteKey(videoKey)
 249     ])
 250   }
 251
 252   /* ************ Resumable uploads final responses ************ */
 253
 254   setUploadSession (uploadId: string, response?: { video: { id: number, shortUUID: string, uuid: string } }) {
 255     return this.setValue(
 256       'resumable-upload-' + uploadId,
 257       response
 258         ? JSON.stringify(response)
 259         : '',
 260       RESUMABLE_UPLOAD_SESSION_LIFETIME
 261     )
 262   }
 263
 264   doesUploadSessionExist (uploadId: string) {
 265     return this.exists('resumable-upload-' + uploadId)
 266   }
 267
 268   async getUploadSession (uploadId: string) {
 269     const value = await this.getValue('resumable-upload-' + uploadId)
 270
 271     return value
 272       ? JSON.parse(value)
 273       : ''
 274   }
 275
 276   deleteUploadSession (uploadId: string) {
 277     return this.deleteKey('resumable-upload-' + uploadId)
 278   }
 279
 280   /* ************ AP ressource unavailability ************ */
 281
 282   async addAPUnavailability (url: string) {
 283     const key = this.generateAPUnavailabilityKey(url)
 284
 285     const value = await this.increment(key)
 286     await this.setExpiration(key, AP_CLEANER.PERIOD * 2)
 287
 288     return value
 289   }
 290
 291   /* ************ Keys generation ************ */
 292
 293   private generateLocalVideoViewsKeys (videoId?: Number) {
 294     return { setKey: `local-video-views-buffer`, videoKey: `local-video-views-buffer-${videoId}` }
 295   }
 296
 297   private generateVideoViewStatsKeys (options: { videoId?: number, hour?: number }) {
 298     const hour = exists(options.hour)
 299       ? options.hour
 300       : new Date().getHours()
 301
 302     return { setKey: `videos-view-h${hour}`, videoKey: `video-view-${options.videoId}-h${hour}` }
 303   }
 304
 305   private generateResetPasswordKey (userId: number) {
 306     return 'reset-password-' + userId
 307   }
 308
 309   private generateVerifyEmailKey (userId: number) {
 310     return 'verify-email-' + userId
 311   }
 312
 313   private generateIPViewKey (ip: string, videoUUID: string) {
 314     return `views-${videoUUID}-${ip}`
 315   }
 316
 317   private generateIPViewerKey (ip: string, videoUUID: string) {
 318     return `viewer-${videoUUID}-${ip}`
 319   }
 320
 321   private generateTrackerBlockIPKey (ip: string) {
 322     return `tracker-block-ip-${ip}`
 323   }
 324
 325   private generateContactFormKey (ip: string) {
 326     return 'contact-form-' + ip
 327   }
 328
 329   private generateAPUnavailabilityKey (url: string) {
 330     return 'ap-unavailability-' + sha256(url)
 331   }
 332
 333   /* ************ Redis helpers ************ */
 334
 335   private getValue (key: string) {
 336     return this.client.get(this.prefix + key)
 337   }
 338
 339   private getSet (key: string) {
 340     return this.client.sMembers(this.prefix + key)
 341   }
 342
 343   private addToSet (key: string, value: string) {
 344     return this.client.sAdd(this.prefix + key, value)
 345   }
 346
 347   private deleteFromSet (key: string, value: string) {
 348     return this.client.sRem(this.prefix + key, value)
 349   }
 350
 351   private deleteKey (key: string) {
 352     return this.client.del(this.prefix + key)
 353   }
 354
 355   private async setValue (key: string, value: string, expirationMilliseconds: number) {
 356     const result = await this.client.set(this.prefix + key, value, { PX: expirationMilliseconds })
 357
 358     if (result !== 'OK') throw new Error('Redis set result is not OK.')
 359   }
 360
 361   private removeValue (key: string) {
 362     return this.client.del(this.prefix + key)
 363   }
 364
 365   private increment (key: string) {
 366     return this.client.incr(this.prefix + key)
 367   }
 368
 369   private async exists (key: string) {
 370     const result = await this.client.exists(this.prefix + key)
 371
 372     return result !== 0
 373   }
 374
 375   private setExpiration (key: string, ms: number) {
 376     return this.client.expire(this.prefix + key, ms / 1000)
 377   }
 378
 379   static get Instance () {
 380     return this.instance || (this.instance = new this())
 381   }
 382 }
 383
 384 // ---------------------------------------------------------------------------
 385
 386 export {
 387   Redis
 388 }