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