server/lib/server-config-manager.ts

   1 import { isSignupAllowed, isSignupAllowedForCurrentIP } from '@server/helpers/signup'
   2 import { getServerCommit } from '@server/helpers/utils'
   3 import { CONFIG, isEmailEnabled } from '@server/initializers/config'
   4 import { CONSTRAINTS_FIELDS, DEFAULT_THEME_NAME, PEERTUBE_VERSION } from '@server/initializers/constants'
   5 import { ActorCustomPageModel } from '@server/models/account/actor-custom-page'
   6 import { HTMLServerConfig, RegisteredExternalAuthConfig, RegisteredIdAndPassAuthConfig, ServerConfig } from '@shared/models'
   7 import { Hooks } from './plugins/hooks'
   8 import { PluginManager } from './plugins/plugin-manager'
   9 import { getThemeOrDefault } from './plugins/theme-utils'
  10 import { VideoTranscodingProfilesManager } from './transcoding/video-transcoding-profiles'
  11
  12 /**
  13  *
  14  * Used to send the server config to clients (using REST/API or plugins API)
  15  * We need a singleton class to manage config state depending on external events (to build menu entries etc)
  16  *
  17  */
  18
  19 class ServerConfigManager {
  20
  21   private static instance: ServerConfigManager
  22
  23   private serverCommit: string
  24
  25   private homepageEnabled = false
  26
  27   private constructor () {}
  28
  29   async init () {
  30     const instanceHomepage = await ActorCustomPageModel.loadInstanceHomepage()
  31
  32     this.updateHomepageState(instanceHomepage?.content)
  33   }
  34
  35   updateHomepageState (content: string) {
  36     this.homepageEnabled = !!content
  37   }
  38
  39   async getHTMLServerConfig (): Promise<HTMLServerConfig> {
  40     if (this.serverCommit === undefined) this.serverCommit = await getServerCommit()
  41
  42     const defaultTheme = getThemeOrDefault(CONFIG.THEME.DEFAULT, DEFAULT_THEME_NAME)
  43
  44     return {
  45       instance: {
  46         name: CONFIG.INSTANCE.NAME,
  47         shortDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
  48         isNSFW: CONFIG.INSTANCE.IS_NSFW,
  49         defaultNSFWPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
  50         defaultClientRoute: CONFIG.INSTANCE.DEFAULT_CLIENT_ROUTE,
  51         customizations: {
  52           javascript: CONFIG.INSTANCE.CUSTOMIZATIONS.JAVASCRIPT,
  53           css: CONFIG.INSTANCE.CUSTOMIZATIONS.CSS
  54         }
  55       },
  56       search: {
  57         remoteUri: {
  58           users: CONFIG.SEARCH.REMOTE_URI.USERS,
  59           anonymous: CONFIG.SEARCH.REMOTE_URI.ANONYMOUS
  60         },
  61         searchIndex: {
  62           enabled: CONFIG.SEARCH.SEARCH_INDEX.ENABLED,
  63           url: CONFIG.SEARCH.SEARCH_INDEX.URL,
  64           disableLocalSearch: CONFIG.SEARCH.SEARCH_INDEX.DISABLE_LOCAL_SEARCH,
  65           isDefaultSearch: CONFIG.SEARCH.SEARCH_INDEX.IS_DEFAULT_SEARCH
  66         }
  67       },
  68       plugin: {
  69         registered: this.getRegisteredPlugins(),
  70         registeredExternalAuths: this.getExternalAuthsPlugins(),
  71         registeredIdAndPassAuths: this.getIdAndPassAuthPlugins()
  72       },
  73       theme: {
  74         registered: this.getRegisteredThemes(),
  75         default: defaultTheme
  76       },
  77       email: {
  78         enabled: isEmailEnabled()
  79       },
  80       contactForm: {
  81         enabled: CONFIG.CONTACT_FORM.ENABLED
  82       },
  83       serverVersion: PEERTUBE_VERSION,
  84       serverCommit: this.serverCommit,
  85       transcoding: {
  86         hls: {
  87           enabled: CONFIG.TRANSCODING.HLS.ENABLED
  88         },
  89         webtorrent: {
  90           enabled: CONFIG.TRANSCODING.WEBTORRENT.ENABLED
  91         },
  92         enabledResolutions: this.getEnabledResolutions('vod'),
  93         profile: CONFIG.TRANSCODING.PROFILE,
  94         availableProfiles: VideoTranscodingProfilesManager.Instance.getAvailableProfiles('vod')
  95       },
  96       live: {
  97         enabled: CONFIG.LIVE.ENABLED,
  98
  99         allowReplay: CONFIG.LIVE.ALLOW_REPLAY,
 100         maxDuration: CONFIG.LIVE.MAX_DURATION,
 101         maxInstanceLives: CONFIG.LIVE.MAX_INSTANCE_LIVES,
 102         maxUserLives: CONFIG.LIVE.MAX_USER_LIVES,
 103
 104         transcoding: {
 105           enabled: CONFIG.LIVE.TRANSCODING.ENABLED,
 106           enabledResolutions: this.getEnabledResolutions('live'),
 107           profile: CONFIG.LIVE.TRANSCODING.PROFILE,
 108           availableProfiles: VideoTranscodingProfilesManager.Instance.getAvailableProfiles('live')
 109         },
 110
 111         rtmp: {
 112           port: CONFIG.LIVE.RTMP.PORT
 113         }
 114       },
 115       import: {
 116         videos: {
 117           http: {
 118             enabled: CONFIG.IMPORT.VIDEOS.HTTP.ENABLED
 119           },
 120           torrent: {
 121             enabled: CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED
 122           }
 123         }
 124       },
 125       autoBlacklist: {
 126         videos: {
 127           ofUsers: {
 128             enabled: CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED
 129           }
 130         }
 131       },
 132       avatar: {
 133         file: {
 134           size: {
 135             max: CONSTRAINTS_FIELDS.ACTORS.IMAGE.FILE_SIZE.max
 136           },
 137           extensions: CONSTRAINTS_FIELDS.ACTORS.IMAGE.EXTNAME
 138         }
 139       },
 140       banner: {
 141         file: {
 142           size: {
 143             max: CONSTRAINTS_FIELDS.ACTORS.IMAGE.FILE_SIZE.max
 144           },
 145           extensions: CONSTRAINTS_FIELDS.ACTORS.IMAGE.EXTNAME
 146         }
 147       },
 148       video: {
 149         image: {
 150           extensions: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME,
 151           size: {
 152             max: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.FILE_SIZE.max
 153           }
 154         },
 155         file: {
 156           extensions: CONSTRAINTS_FIELDS.VIDEOS.EXTNAME
 157         }
 158       },
 159       videoCaption: {
 160         file: {
 161           size: {
 162             max: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.FILE_SIZE.max
 163           },
 164           extensions: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.EXTNAME
 165         }
 166       },
 167       user: {
 168         videoQuota: CONFIG.USER.VIDEO_QUOTA,
 169         videoQuotaDaily: CONFIG.USER.VIDEO_QUOTA_DAILY
 170       },
 171       trending: {
 172         videos: {
 173           intervalDays: CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS,
 174           algorithms: {
 175             enabled: CONFIG.TRENDING.VIDEOS.ALGORITHMS.ENABLED,
 176             default: CONFIG.TRENDING.VIDEOS.ALGORITHMS.DEFAULT
 177           }
 178         }
 179       },
 180       tracker: {
 181         enabled: CONFIG.TRACKER.ENABLED
 182       },
 183
 184       followings: {
 185         instance: {
 186           autoFollowIndex: {
 187             indexUrl: CONFIG.FOLLOWINGS.INSTANCE.AUTO_FOLLOW_INDEX.INDEX_URL
 188           }
 189         }
 190       },
 191
 192       broadcastMessage: {
 193         enabled: CONFIG.BROADCAST_MESSAGE.ENABLED,
 194         message: CONFIG.BROADCAST_MESSAGE.MESSAGE,
 195         level: CONFIG.BROADCAST_MESSAGE.LEVEL,
 196         dismissable: CONFIG.BROADCAST_MESSAGE.DISMISSABLE
 197       },
 198
 199       homepage: {
 200         enabled: this.homepageEnabled
 201       }
 202     }
 203   }
 204
 205   async getServerConfig (ip?: string): Promise<ServerConfig> {
 206     const { allowed } = await Hooks.wrapPromiseFun(
 207       isSignupAllowed,
 208       {
 209         ip
 210       },
 211       'filter:api.user.signup.allowed.result'
 212     )
 213
 214     const allowedForCurrentIP = isSignupAllowedForCurrentIP(ip)
 215
 216     const signup = {
 217       allowed,
 218       allowedForCurrentIP,
 219       minimumAge: CONFIG.SIGNUP.MINIMUM_AGE,
 220       requiresEmailVerification: CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION
 221     }
 222
 223     const htmlConfig = await this.getHTMLServerConfig()
 224
 225     return { ...htmlConfig, signup }
 226   }
 227
 228   getRegisteredThemes () {
 229     return PluginManager.Instance.getRegisteredThemes()
 230                         .map(t => ({
 231                           name: t.name,
 232                           version: t.version,
 233                           description: t.description,
 234                           css: t.css,
 235                           clientScripts: t.clientScripts
 236                         }))
 237   }
 238
 239   getRegisteredPlugins () {
 240     return PluginManager.Instance.getRegisteredPlugins()
 241                         .map(p => ({
 242                           name: p.name,
 243                           version: p.version,
 244                           description: p.description,
 245                           clientScripts: p.clientScripts
 246                         }))
 247   }
 248
 249   getEnabledResolutions (type: 'vod' | 'live') {
 250     const transcoding = type === 'vod'
 251       ? CONFIG.TRANSCODING
 252       : CONFIG.LIVE.TRANSCODING
 253
 254     return Object.keys(transcoding.RESOLUTIONS)
 255                  .filter(key => transcoding.ENABLED && transcoding.RESOLUTIONS[key] === true)
 256                  .map(r => parseInt(r, 10))
 257   }
 258
 259   private getIdAndPassAuthPlugins () {
 260     const result: RegisteredIdAndPassAuthConfig[] = []
 261
 262     for (const p of PluginManager.Instance.getIdAndPassAuths()) {
 263       for (const auth of p.idAndPassAuths) {
 264         result.push({
 265           npmName: p.npmName,
 266           name: p.name,
 267           version: p.version,
 268           authName: auth.authName,
 269           weight: auth.getWeight()
 270         })
 271       }
 272     }
 273
 274     return result
 275   }
 276
 277   private getExternalAuthsPlugins () {
 278     const result: RegisteredExternalAuthConfig[] = []
 279
 280     for (const p of PluginManager.Instance.getExternalAuths()) {
 281       for (const auth of p.externalAuths) {
 282         result.push({
 283           npmName: p.npmName,
 284           name: p.name,
 285           version: p.version,
 286           authName: auth.authName,
 287           authDisplayName: auth.authDisplayName()
 288         })
 289       }
 290     }
 291
 292     return result
 293   }
 294
 295   static get Instance () {
 296     return this.instance || (this.instance = new this())
 297   }
 298 }
 299
 300 // ---------------------------------------------------------------------------
 301
 302 export {
 303   ServerConfigManager
 304 }