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