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