Search video channel handle/uri
[oweals/peertube.git] / server / lib / redis.ts
1 import * as express from 'express'
2 import { createClient, RedisClient } from 'redis'
3 import { logger } from '../helpers/logger'
4 import { generateRandomString } from '../helpers/utils'
5 import { CONFIG, USER_PASSWORD_RESET_LIFETIME, VIDEO_VIEW_LIFETIME } from '../initializers'
6
7 type CachedRoute = {
8   body: string,
9   contentType?: string
10   statusCode?: string
11 }
12
13 class Redis {
14
15   private static instance: Redis
16   private initialized = false
17   private client: RedisClient
18   private prefix: string
19
20   private constructor () {}
21
22   init () {
23     // Already initialized
24     if (this.initialized === true) return
25     this.initialized = true
26
27     this.client = createClient(Redis.getRedisClient())
28
29     this.client.on('error', err => {
30       logger.error('Error in Redis client.', { err })
31       process.exit(-1)
32     })
33
34     if (CONFIG.REDIS.AUTH) {
35       this.client.auth(CONFIG.REDIS.AUTH)
36     }
37
38     this.prefix = 'redis-' + CONFIG.WEBSERVER.HOST + '-'
39   }
40
41   static getRedisClient () {
42     return Object.assign({},
43       (CONFIG.REDIS.AUTH && CONFIG.REDIS.AUTH != null) ? { password: CONFIG.REDIS.AUTH } : {},
44       (CONFIG.REDIS.DB) ? { db: CONFIG.REDIS.DB } : {},
45       (CONFIG.REDIS.HOSTNAME && CONFIG.REDIS.PORT) ?
46       { host: CONFIG.REDIS.HOSTNAME, port: CONFIG.REDIS.PORT } :
47       { path: CONFIG.REDIS.SOCKET }
48     )
49   }
50
51   async setResetPasswordVerificationString (userId: number) {
52     const generatedString = await generateRandomString(32)
53
54     await this.setValue(this.generateResetPasswordKey(userId), generatedString, USER_PASSWORD_RESET_LIFETIME)
55
56     return generatedString
57   }
58
59   async getResetPasswordLink (userId: number) {
60     return this.getValue(this.generateResetPasswordKey(userId))
61   }
62
63   setView (ip: string, videoUUID: string) {
64     return this.setValue(this.buildViewKey(ip, videoUUID), '1', VIDEO_VIEW_LIFETIME)
65   }
66
67   async isViewExists (ip: string, videoUUID: string) {
68     return this.exists(this.buildViewKey(ip, videoUUID))
69   }
70
71   async getCachedRoute (req: express.Request) {
72     const cached = await this.getObject(this.buildCachedRouteKey(req))
73
74     return cached as CachedRoute
75   }
76
77   setCachedRoute (req: express.Request, body: any, lifetime: number, contentType?: string, statusCode?: number) {
78     const cached: CachedRoute = Object.assign({}, {
79       body: body.toString()
80     },
81     (contentType) ? { contentType } : null,
82     (statusCode) ? { statusCode: statusCode.toString() } : null
83     )
84
85     return this.setObject(this.buildCachedRouteKey(req), cached, lifetime)
86   }
87
88   generateResetPasswordKey (userId: number) {
89     return 'reset-password-' + userId
90   }
91
92   buildViewKey (ip: string, videoUUID: string) {
93     return videoUUID + '-' + ip
94   }
95
96   buildCachedRouteKey (req: express.Request) {
97     return req.method + '-' + req.originalUrl
98   }
99
100   private getValue (key: string) {
101     return new Promise<string>((res, rej) => {
102       this.client.get(this.prefix + key, (err, value) => {
103         if (err) return rej(err)
104
105         return res(value)
106       })
107     })
108   }
109
110   private setValue (key: string, value: string, expirationMilliseconds: number) {
111     return new Promise<void>((res, rej) => {
112       this.client.set(this.prefix + key, value, 'PX', expirationMilliseconds, (err, ok) => {
113         if (err) return rej(err)
114
115         if (ok !== 'OK') return rej(new Error('Redis set result is not OK.'))
116
117         return res()
118       })
119     })
120   }
121
122   private setObject (key: string, obj: { [ id: string ]: string }, expirationMilliseconds: number) {
123     return new Promise<void>((res, rej) => {
124       this.client.hmset(this.prefix + key, obj, (err, ok) => {
125         if (err) return rej(err)
126         if (!ok) return rej(new Error('Redis mset result is not OK.'))
127
128         this.client.pexpire(this.prefix + key, expirationMilliseconds, (err, ok) => {
129           if (err) return rej(err)
130           if (!ok) return rej(new Error('Redis expiration result is not OK.'))
131
132           return res()
133         })
134       })
135     })
136   }
137
138   private getObject (key: string) {
139     return new Promise<{ [ id: string ]: string }>((res, rej) => {
140       this.client.hgetall(this.prefix + key, (err, value) => {
141         if (err) return rej(err)
142
143         return res(value)
144       })
145     })
146   }
147
148   private exists (key: string) {
149     return new Promise<boolean>((res, rej) => {
150       this.client.exists(this.prefix + key, (err, existsNumber) => {
151         if (err) return rej(err)
152
153         return res(existsNumber === 1)
154       })
155     })
156   }
157
158   static get Instance () {
159     return this.instance || (this.instance = new this())
160   }
161 }
162
163 // ---------------------------------------------------------------------------
164
165 export {
166   Redis
167 }