server/lib/server-config-manager.ts

   1 import { getServerCommit } from '@server/helpers/utils'
   2 import { CONFIG, isEmailEnabled } from '@server/initializers/config'
   3 import { CONSTRAINTS_FIELDS, DEFAULT_THEME_NAME, PEERTUBE_VERSION } from '@server/initializers/constants'
   4 import { isSignupAllowed, isSignupAllowedForCurrentIP } from '@server/lib/signup'
   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       client: {
  46         videos: {
  47           miniature: {
  48             preferAuthorDisplayName: CONFIG.CLIENT.VIDEOS.MINIATURE.PREFER_AUTHOR_DISPLAY_NAME
  49           }
  50         },
  51         menu: {
  52           login: {
  53             redirectOnSingleExternalAuth: CONFIG.CLIENT.MENU.LOGIN.REDIRECT_ON_SINGLE_EXTERNAL_AUTH
  54           }
  55         }
  56       },
  57
  58       webadmin: {
  59         configuration: {
  60           edition: {
  61             allowed: CONFIG.WEBADMIN.CONFIGURATION.EDITION.ALLOWED
  62           }
  63         }
  64       },
  65
  66       instance: {
  67         name: CONFIG.INSTANCE.NAME,
  68         shortDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
  69         isNSFW: CONFIG.INSTANCE.IS_NSFW,
  70         defaultNSFWPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
  71         defaultClientRoute: CONFIG.INSTANCE.DEFAULT_CLIENT_ROUTE,
  72         customizations: {
  73           javascript: CONFIG.INSTANCE.CUSTOMIZATIONS.JAVASCRIPT,
  74           css: CONFIG.INSTANCE.CUSTOMIZATIONS.CSS
  75         }
  76       },
  77       search: {
  78         remoteUri: {
  79           users: CONFIG.SEARCH.REMOTE_URI.USERS,
  80           anonymous: CONFIG.SEARCH.REMOTE_URI.ANONYMOUS
  81         },
  82         searchIndex: {
  83           enabled: CONFIG.SEARCH.SEARCH_INDEX.ENABLED,
  84           url: CONFIG.SEARCH.SEARCH_INDEX.URL,
  85           disableLocalSearch: CONFIG.SEARCH.SEARCH_INDEX.DISABLE_LOCAL_SEARCH,
  86           isDefaultSearch: CONFIG.SEARCH.SEARCH_INDEX.IS_DEFAULT_SEARCH
  87         }
  88       },
  89       plugin: {
  90         registered: this.getRegisteredPlugins(),
  91         registeredExternalAuths: this.getExternalAuthsPlugins(),
  92         registeredIdAndPassAuths: this.getIdAndPassAuthPlugins()
  93       },
  94       theme: {
  95         registered: this.getRegisteredThemes(),
  96         default: defaultTheme
  97       },
  98       email: {
  99         enabled: isEmailEnabled()
 100       },
 101       contactForm: {
 102         enabled: CONFIG.CONTACT_FORM.ENABLED
 103       },
 104       serverVersion: PEERTUBE_VERSION,
 105       serverCommit: this.serverCommit,
 106       transcoding: {
 107         hls: {
 108           enabled: CONFIG.TRANSCODING.HLS.ENABLED
 109         },
 110         webtorrent: {
 111           enabled: CONFIG.TRANSCODING.WEBTORRENT.ENABLED
 112         },
 113         enabledResolutions: this.getEnabledResolutions('vod'),
 114         profile: CONFIG.TRANSCODING.PROFILE,
 115         availableProfiles: VideoTranscodingProfilesManager.Instance.getAvailableProfiles('vod')
 116       },
 117       live: {
 118         enabled: CONFIG.LIVE.ENABLED,
 119
 120         allowReplay: CONFIG.LIVE.ALLOW_REPLAY,
 121         maxDuration: CONFIG.LIVE.MAX_DURATION,
 122         maxInstanceLives: CONFIG.LIVE.MAX_INSTANCE_LIVES,
 123         maxUserLives: CONFIG.LIVE.MAX_USER_LIVES,
 124
 125         transcoding: {
 126           enabled: CONFIG.LIVE.TRANSCODING.ENABLED,
 127           enabledResolutions: this.getEnabledResolutions('live'),
 128           profile: CONFIG.LIVE.TRANSCODING.PROFILE,
 129           availableProfiles: VideoTranscodingProfilesManager.Instance.getAvailableProfiles('live')
 130         },
 131
 132         rtmp: {
 133           port: CONFIG.LIVE.RTMP.PORT
 134         }
 135       },
 136       import: {
 137         videos: {
 138           http: {
 139             enabled: CONFIG.IMPORT.VIDEOS.HTTP.ENABLED
 140           },
 141           torrent: {
 142             enabled: CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED
 143           }
 144         }
 145       },
 146       autoBlacklist: {
 147         videos: {
 148           ofUsers: {
 149             enabled: CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED
 150           }
 151         }
 152       },
 153       avatar: {
 154         file: {
 155           size: {
 156             max: CONSTRAINTS_FIELDS.ACTORS.IMAGE.FILE_SIZE.max
 157           },
 158           extensions: CONSTRAINTS_FIELDS.ACTORS.IMAGE.EXTNAME
 159         }
 160       },
 161       banner: {
 162         file: {
 163           size: {
 164             max: CONSTRAINTS_FIELDS.ACTORS.IMAGE.FILE_SIZE.max
 165           },
 166           extensions: CONSTRAINTS_FIELDS.ACTORS.IMAGE.EXTNAME
 167         }
 168       },
 169       video: {
 170         image: {
 171           extensions: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME,
 172           size: {
 173             max: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.FILE_SIZE.max
 174           }
 175         },
 176         file: {
 177           extensions: CONSTRAINTS_FIELDS.VIDEOS.EXTNAME
 178         }
 179       },
 180       videoCaption: {
 181         file: {
 182           size: {
 183             max: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.FILE_SIZE.max
 184           },
 185           extensions: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.EXTNAME
 186         }
 187       },
 188       user: {
 189         videoQuota: CONFIG.USER.VIDEO_QUOTA,
 190         videoQuotaDaily: CONFIG.USER.VIDEO_QUOTA_DAILY
 191       },
 192       videoChannels: {
 193         maxPerUser: CONFIG.VIDEO_CHANNELS.MAX_PER_USER
 194       },
 195       trending: {
 196         videos: {
 197           intervalDays: CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS,
 198           algorithms: {
 199             enabled: CONFIG.TRENDING.VIDEOS.ALGORITHMS.ENABLED,
 200             default: CONFIG.TRENDING.VIDEOS.ALGORITHMS.DEFAULT
 201           }
 202         }
 203       },
 204       tracker: {
 205         enabled: CONFIG.TRACKER.ENABLED
 206       },
 207
 208       followings: {
 209         instance: {
 210           autoFollowIndex: {
 211             indexUrl: CONFIG.FOLLOWINGS.INSTANCE.AUTO_FOLLOW_INDEX.INDEX_URL
 212           }
 213         }
 214       },
 215
 216       broadcastMessage: {
 217         enabled: CONFIG.BROADCAST_MESSAGE.ENABLED,
 218         message: CONFIG.BROADCAST_MESSAGE.MESSAGE,
 219         level: CONFIG.BROADCAST_MESSAGE.LEVEL,
 220         dismissable: CONFIG.BROADCAST_MESSAGE.DISMISSABLE
 221       },
 222
 223       homepage: {
 224         enabled: this.homepageEnabled
 225       }
 226     }
 227   }
 228
 229   async getServerConfig (ip?: string): Promise<ServerConfig> {
 230     const { allowed } = await Hooks.wrapPromiseFun(
 231       isSignupAllowed,
 232       {
 233         ip
 234       },
 235       'filter:api.user.signup.allowed.result'
 236     )
 237
 238     const allowedForCurrentIP = isSignupAllowedForCurrentIP(ip)
 239
 240     const signup = {
 241       allowed,
 242       allowedForCurrentIP,
 243       minimumAge: CONFIG.SIGNUP.MINIMUM_AGE,
 244       requiresEmailVerification: CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION
 245     }
 246
 247     const htmlConfig = await this.getHTMLServerConfig()
 248
 249     return { ...htmlConfig, signup }
 250   }
 251
 252   getRegisteredThemes () {
 253     return PluginManager.Instance.getRegisteredThemes()
 254                         .map(t => ({
 255                           name: t.name,
 256                           version: t.version,
 257                           description: t.description,
 258                           css: t.css,
 259                           clientScripts: t.clientScripts
 260                         }))
 261   }
 262
 263   getRegisteredPlugins () {
 264     return PluginManager.Instance.getRegisteredPlugins()
 265                         .map(p => ({
 266                           name: p.name,
 267                           version: p.version,
 268                           description: p.description,
 269                           clientScripts: p.clientScripts
 270                         }))
 271   }
 272
 273   getEnabledResolutions (type: 'vod' | 'live') {
 274     const transcoding = type === 'vod'
 275       ? CONFIG.TRANSCODING
 276       : CONFIG.LIVE.TRANSCODING
 277
 278     return Object.keys(transcoding.RESOLUTIONS)
 279                  .filter(key => transcoding.ENABLED && transcoding.RESOLUTIONS[key] === true)
 280                  .map(r => parseInt(r, 10))
 281   }
 282
 283   private getIdAndPassAuthPlugins () {
 284     const result: RegisteredIdAndPassAuthConfig[] = []
 285
 286     for (const p of PluginManager.Instance.getIdAndPassAuths()) {
 287       for (const auth of p.idAndPassAuths) {
 288         result.push({
 289           npmName: p.npmName,
 290           name: p.name,
 291           version: p.version,
 292           authName: auth.authName,
 293           weight: auth.getWeight()
 294         })
 295       }
 296     }
 297
 298     return result
 299   }
 300
 301   private getExternalAuthsPlugins () {
 302     const result: RegisteredExternalAuthConfig[] = []
 303
 304     for (const p of PluginManager.Instance.getExternalAuths()) {
 305       for (const auth of p.externalAuths) {
 306         result.push({
 307           npmName: p.npmName,
 308           name: p.name,
 309           version: p.version,
 310           authName: auth.authName,
 311           authDisplayName: auth.authDisplayName()
 312         })
 313       }
 314     }
 315
 316     return result
 317   }
 318
 319   static get Instance () {
 320     return this.instance || (this.instance = new this())
 321   }
 322 }
 323
 324 // ---------------------------------------------------------------------------
 325
 326 export {
 327   ServerConfigManager
 328 }