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