server/controllers/static.ts

   1 import * as cors from 'cors'
   2 import * as express from 'express'
   3 import {
   4   CONSTRAINTS_FIELDS,
   5   DEFAULT_THEME_NAME,
   6   HLS_STREAMING_PLAYLIST_DIRECTORY,
   7   PEERTUBE_VERSION,
   8   ROUTE_CACHE_LIFETIME,
   9   STATIC_DOWNLOAD_PATHS,
  10   STATIC_MAX_AGE,
  11   STATIC_PATHS,
  12   WEBSERVER
  13 } from '../initializers/constants'
  14 import { cacheRoute } from '../middlewares/cache'
  15 import { asyncMiddleware, videosDownloadValidator } from '../middlewares'
  16 import { VideoModel } from '../models/video/video'
  17 import { UserModel } from '../models/account/user'
  18 import { VideoCommentModel } from '../models/video/video-comment'
  19 import { HttpNodeinfoDiasporaSoftwareNsSchema20 } from '../../shared/models/nodeinfo'
  20 import { join } from 'path'
  21 import { root } from '../helpers/core-utils'
  22 import { CONFIG, isEmailEnabled } from '../initializers/config'
  23 import { getPreview, getVideoCaption } from './lazy-static'
  24 import { VideoStreamingPlaylistType } from '@shared/models/videos/video-streaming-playlist.type'
  25 import { MVideoFile, MVideoFullLight } from '@server/types/models'
  26 import { getTorrentFilePath, getVideoFilePath } from '@server/lib/video-paths'
  27 import { getThemeOrDefault } from '../lib/plugins/theme-utils'
  28 import { getEnabledResolutions, getRegisteredPlugins, getRegisteredThemes } from '@server/controllers/api/config'
  29 import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
  30
  31 const staticRouter = express.Router()
  32
  33 staticRouter.use(cors())
  34
  35 /*
  36   Cors is very important to let other servers access torrent and video files
  37 */
  38
  39 const torrentsPhysicalPath = CONFIG.STORAGE.TORRENTS_DIR
  40 staticRouter.use(
  41   STATIC_PATHS.TORRENTS,
  42   cors(),
  43   express.static(torrentsPhysicalPath, { maxAge: 0 }) // Don't cache because we could regenerate the torrent file
  44 )
  45 staticRouter.use(
  46   STATIC_DOWNLOAD_PATHS.TORRENTS + ':id-:resolution([0-9]+).torrent',
  47   asyncMiddleware(videosDownloadValidator),
  48   downloadTorrent
  49 )
  50 staticRouter.use(
  51   STATIC_DOWNLOAD_PATHS.TORRENTS + ':id-:resolution([0-9]+)-hls.torrent',
  52   asyncMiddleware(videosDownloadValidator),
  53   downloadHLSVideoFileTorrent
  54 )
  55
  56 // Videos path for webseeding
  57 staticRouter.use(
  58   STATIC_PATHS.WEBSEED,
  59   cors(),
  60   express.static(CONFIG.STORAGE.VIDEOS_DIR, { fallthrough: false }) // 404 because we don't have this video
  61 )
  62 staticRouter.use(
  63   STATIC_PATHS.REDUNDANCY,
  64   cors(),
  65   express.static(CONFIG.STORAGE.REDUNDANCY_DIR, { fallthrough: false }) // 404 because we don't have this video
  66 )
  67
  68 staticRouter.use(
  69   STATIC_DOWNLOAD_PATHS.VIDEOS + ':id-:resolution([0-9]+).:extension',
  70   asyncMiddleware(videosDownloadValidator),
  71   downloadVideoFile
  72 )
  73
  74 staticRouter.use(
  75   STATIC_DOWNLOAD_PATHS.HLS_VIDEOS + ':id-:resolution([0-9]+)-fragmented.:extension',
  76   asyncMiddleware(videosDownloadValidator),
  77   downloadHLSVideoFile
  78 )
  79
  80 // HLS
  81 staticRouter.use(
  82   STATIC_PATHS.STREAMING_PLAYLISTS.HLS,
  83   cors(),
  84   express.static(HLS_STREAMING_PLAYLIST_DIRECTORY, { fallthrough: false }) // 404 if the file does not exist
  85 )
  86
  87 // Thumbnails path for express
  88 const thumbnailsPhysicalPath = CONFIG.STORAGE.THUMBNAILS_DIR
  89 staticRouter.use(
  90   STATIC_PATHS.THUMBNAILS,
  91   express.static(thumbnailsPhysicalPath, { maxAge: STATIC_MAX_AGE.SERVER, fallthrough: false }) // 404 if the file does not exist
  92 )
  93
  94 // DEPRECATED: use lazy-static route instead
  95 const avatarsPhysicalPath = CONFIG.STORAGE.AVATARS_DIR
  96 staticRouter.use(
  97   STATIC_PATHS.AVATARS,
  98   express.static(avatarsPhysicalPath, { maxAge: STATIC_MAX_AGE.SERVER, fallthrough: false }) // 404 if the file does not exist
  99 )
 100
 101 // DEPRECATED: use lazy-static route instead
 102 staticRouter.use(
 103   STATIC_PATHS.PREVIEWS + ':uuid.jpg',
 104   asyncMiddleware(getPreview)
 105 )
 106
 107 // DEPRECATED: use lazy-static route instead
 108 staticRouter.use(
 109   STATIC_PATHS.VIDEO_CAPTIONS + ':videoId-:captionLanguage([a-z]+).vtt',
 110   asyncMiddleware(getVideoCaption)
 111 )
 112
 113 // robots.txt service
 114 staticRouter.get('/robots.txt',
 115   asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.ROBOTS)),
 116   (_, res: express.Response) => {
 117     res.type('text/plain')
 118     return res.send(CONFIG.INSTANCE.ROBOTS)
 119   }
 120 )
 121
 122 // security.txt service
 123 staticRouter.get('/security.txt',
 124   (_, res: express.Response) => {
 125     return res.redirect(HttpStatusCode.MOVED_PERMANENTLY_301, '/.well-known/security.txt')
 126   }
 127 )
 128
 129 staticRouter.get('/.well-known/security.txt',
 130   asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.SECURITYTXT)),
 131   (_, res: express.Response) => {
 132     res.type('text/plain')
 133     return res.send(CONFIG.INSTANCE.SECURITYTXT + CONFIG.INSTANCE.SECURITYTXT_CONTACT)
 134   }
 135 )
 136
 137 // nodeinfo service
 138 staticRouter.use('/.well-known/nodeinfo',
 139   asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.NODEINFO)),
 140   (_, res: express.Response) => {
 141     return res.json({
 142       links: [
 143         {
 144           rel: 'http://nodeinfo.diaspora.software/ns/schema/2.0',
 145           href: WEBSERVER.URL + '/nodeinfo/2.0.json'
 146         }
 147       ]
 148     })
 149   }
 150 )
 151 staticRouter.use('/nodeinfo/:version.json',
 152   asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.NODEINFO)),
 153   asyncMiddleware(generateNodeinfo)
 154 )
 155
 156 // dnt-policy.txt service (see https://www.eff.org/dnt-policy)
 157 staticRouter.use('/.well-known/dnt-policy.txt',
 158   asyncMiddleware(cacheRoute()(ROUTE_CACHE_LIFETIME.DNT_POLICY)),
 159   (_, res: express.Response) => {
 160     res.type('text/plain')
 161
 162     return res.sendFile(join(root(), 'dist/server/static/dnt-policy/dnt-policy-1.0.txt'))
 163   }
 164 )
 165
 166 // dnt service (see https://www.w3.org/TR/tracking-dnt/#status-resource)
 167 staticRouter.use('/.well-known/dnt/',
 168   (_, res: express.Response) => {
 169     res.json({ tracking: 'N' })
 170   }
 171 )
 172
 173 staticRouter.use('/.well-known/change-password',
 174   (_, res: express.Response) => {
 175     res.redirect('/my-account/settings')
 176   }
 177 )
 178
 179 staticRouter.use('/.well-known/host-meta',
 180   (_, res: express.Response) => {
 181     res.type('application/xml')
 182
 183     const xml = '<?xml version="1.0" encoding="UTF-8"?>\n' +
 184       '<XRD xmlns="http://docs.oasis-open.org/ns/xri/xrd-1.0">\n' +
 185       `  <Link rel="lrdd" type="application/xrd+xml" template="${WEBSERVER.URL}/.well-known/webfinger?resource={uri}"/>\n` +
 186       '</XRD>'
 187
 188     res.send(xml).end()
 189   }
 190 )
 191
 192 // ---------------------------------------------------------------------------
 193
 194 export {
 195   staticRouter
 196 }
 197
 198 // ---------------------------------------------------------------------------
 199
 200 async function generateNodeinfo (req: express.Request, res: express.Response) {
 201   const { totalVideos } = await VideoModel.getStats()
 202   const { totalLocalVideoComments } = await VideoCommentModel.getStats()
 203   const { totalUsers } = await UserModel.getStats()
 204   let json = {}
 205
 206   if (req.params.version && (req.params.version === '2.0')) {
 207     json = {
 208       version: '2.0',
 209       software: {
 210         name: 'peertube',
 211         version: PEERTUBE_VERSION
 212       },
 213       protocols: [
 214         'activitypub'
 215       ],
 216       services: {
 217         inbound: [],
 218         outbound: [
 219           'atom1.0',
 220           'rss2.0'
 221         ]
 222       },
 223       openRegistrations: CONFIG.SIGNUP.ENABLED,
 224       usage: {
 225         users: {
 226           total: totalUsers
 227         },
 228         localPosts: totalVideos,
 229         localComments: totalLocalVideoComments
 230       },
 231       metadata: {
 232         taxonomy: {
 233           postsName: 'Videos'
 234         },
 235         nodeName: CONFIG.INSTANCE.NAME,
 236         nodeDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
 237         nodeConfig: {
 238           search: {
 239             remoteUri: {
 240               users: CONFIG.SEARCH.REMOTE_URI.USERS,
 241               anonymous: CONFIG.SEARCH.REMOTE_URI.ANONYMOUS
 242             }
 243           },
 244           plugin: {
 245             registered: getRegisteredPlugins()
 246           },
 247           theme: {
 248             registered: getRegisteredThemes(),
 249             default: getThemeOrDefault(CONFIG.THEME.DEFAULT, DEFAULT_THEME_NAME)
 250           },
 251           email: {
 252             enabled: isEmailEnabled()
 253           },
 254           contactForm: {
 255             enabled: CONFIG.CONTACT_FORM.ENABLED
 256           },
 257           transcoding: {
 258             hls: {
 259               enabled: CONFIG.TRANSCODING.HLS.ENABLED
 260             },
 261             webtorrent: {
 262               enabled: CONFIG.TRANSCODING.WEBTORRENT.ENABLED
 263             },
 264             enabledResolutions: getEnabledResolutions('vod')
 265           },
 266           live: {
 267             enabled: CONFIG.LIVE.ENABLED,
 268             transcoding: {
 269               enabled: CONFIG.LIVE.TRANSCODING.ENABLED,
 270               enabledResolutions: getEnabledResolutions('live')
 271             }
 272           },
 273           import: {
 274             videos: {
 275               http: {
 276                 enabled: CONFIG.IMPORT.VIDEOS.HTTP.ENABLED
 277               },
 278               torrent: {
 279                 enabled: CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED
 280               }
 281             }
 282           },
 283           autoBlacklist: {
 284             videos: {
 285               ofUsers: {
 286                 enabled: CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED
 287               }
 288             }
 289           },
 290           avatar: {
 291             file: {
 292               size: {
 293                 max: CONSTRAINTS_FIELDS.ACTORS.AVATAR.FILE_SIZE.max
 294               },
 295               extensions: CONSTRAINTS_FIELDS.ACTORS.AVATAR.EXTNAME
 296             }
 297           },
 298           video: {
 299             image: {
 300               extensions: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME,
 301               size: {
 302                 max: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.FILE_SIZE.max
 303               }
 304             },
 305             file: {
 306               extensions: CONSTRAINTS_FIELDS.VIDEOS.EXTNAME
 307             }
 308           },
 309           videoCaption: {
 310             file: {
 311               size: {
 312                 max: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.FILE_SIZE.max
 313               },
 314               extensions: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.EXTNAME
 315             }
 316           },
 317           user: {
 318             videoQuota: CONFIG.USER.VIDEO_QUOTA,
 319             videoQuotaDaily: CONFIG.USER.VIDEO_QUOTA_DAILY
 320           },
 321           trending: {
 322             videos: {
 323               intervalDays: CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS
 324             }
 325           },
 326           tracker: {
 327             enabled: CONFIG.TRACKER.ENABLED
 328           }
 329         }
 330       }
 331     } as HttpNodeinfoDiasporaSoftwareNsSchema20
 332     res.contentType('application/json; profile="http://nodeinfo.diaspora.software/ns/schema/2.0#"')
 333   } else {
 334     json = { error: 'Nodeinfo schema version not handled' }
 335     res.status(HttpStatusCode.NOT_FOUND_404)
 336   }
 337
 338   return res.send(json).end()
 339 }
 340
 341 function downloadTorrent (req: express.Request, res: express.Response) {
 342   const video = res.locals.videoAll
 343
 344   const videoFile = getVideoFile(req, video.VideoFiles)
 345   if (!videoFile) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 346
 347   return res.download(getTorrentFilePath(video, videoFile), `${video.name}-${videoFile.resolution}p.torrent`)
 348 }
 349
 350 function downloadHLSVideoFileTorrent (req: express.Request, res: express.Response) {
 351   const video = res.locals.videoAll
 352
 353   const playlist = getHLSPlaylist(video)
 354   if (!playlist) return res.status(HttpStatusCode.NOT_FOUND_404).end
 355
 356   const videoFile = getVideoFile(req, playlist.VideoFiles)
 357   if (!videoFile) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 358
 359   return res.download(getTorrentFilePath(playlist, videoFile), `${video.name}-${videoFile.resolution}p-hls.torrent`)
 360 }
 361
 362 function downloadVideoFile (req: express.Request, res: express.Response) {
 363   const video = res.locals.videoAll
 364
 365   const videoFile = getVideoFile(req, video.VideoFiles)
 366   if (!videoFile) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 367
 368   return res.download(getVideoFilePath(video, videoFile), `${video.name}-${videoFile.resolution}p${videoFile.extname}`)
 369 }
 370
 371 function downloadHLSVideoFile (req: express.Request, res: express.Response) {
 372   const video = res.locals.videoAll
 373   const playlist = getHLSPlaylist(video)
 374   if (!playlist) return res.status(HttpStatusCode.NOT_FOUND_404).end
 375
 376   const videoFile = getVideoFile(req, playlist.VideoFiles)
 377   if (!videoFile) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 378
 379   const filename = `${video.name}-${videoFile.resolution}p-${playlist.getStringType()}${videoFile.extname}`
 380   return res.download(getVideoFilePath(playlist, videoFile), filename)
 381 }
 382
 383 function getVideoFile (req: express.Request, files: MVideoFile[]) {
 384   const resolution = parseInt(req.params.resolution, 10)
 385   return files.find(f => f.resolution === resolution)
 386 }
 387
 388 function getHLSPlaylist (video: MVideoFullLight) {
 389   const playlist = video.VideoStreamingPlaylists.find(p => p.type === VideoStreamingPlaylistType.HLS)
 390   if (!playlist) return undefined
 391
 392   return Object.assign(playlist, { Video: video })
 393 }