+ return VideoFileModel.scope({ method: [ ScopeNames.WITH_VIDEO_OR_PLAYLIST, whereVideo ] })
+ .findOne(options)
+ .then(file => {
+ // We used `required: false` so check we have at least a video or a streaming playlist
+ if (!file.Video && !file.VideoStreamingPlaylist) return null
+
+ return file
+ })
+ }
+
+ static listByStreamingPlaylist (streamingPlaylistId: number, transaction: Transaction) {
+ const query = {
+ include: [
+ {
+ model: VideoModel.unscoped(),
+ required: true,
+ include: [
+ {
+ model: VideoStreamingPlaylistModel.unscoped(),
+ required: true,
+ where: {
+ id: streamingPlaylistId
+ }
+ }
+ ]
+ }
+ ],
+ transaction
+ }
+
+ return VideoFileModel.findAll(query)
+ }
+
+ static getStats () {
+ const webtorrentFilesQuery: FindOptions = {
+ include: [
+ {
+ attributes: [],
+ required: true,
+ model: VideoModel.unscoped(),
+ where: {
+ remote: false
+ }
+ }
+ ]
+ }
+
+ const hlsFilesQuery: FindOptions = {
+ include: [
+ {
+ attributes: [],
+ required: true,
+ model: VideoStreamingPlaylistModel.unscoped(),
+ include: [
+ {
+ attributes: [],
+ model: VideoModel.unscoped(),
+ required: true,
+ where: {
+ remote: false
+ }
+ }
+ ]
+ }
+ ]
+ }
+
+ return Promise.all([
+ VideoFileModel.aggregate('size', 'SUM', webtorrentFilesQuery),
+ VideoFileModel.aggregate('size', 'SUM', hlsFilesQuery)
+ ]).then(([ webtorrentResult, hlsResult ]) => ({
+ totalLocalVideoFilesSize: parseAggregateResult(webtorrentResult) + parseAggregateResult(hlsResult)
+ }))
+ }
+
+ // Redefine upsert because sequelize does not use an appropriate where clause in the update query with 2 unique indexes
+ static async customUpsert (
+ videoFile: MVideoFile,
+ mode: 'streaming-playlist' | 'video',
+ transaction: Transaction
+ ) {
+ const baseFind = {
+ fps: videoFile.fps,
+ resolution: videoFile.resolution,
+ transaction
+ }
+
+ const element = mode === 'streaming-playlist'
+ ? await VideoFileModel.loadHLSFile({ ...baseFind, playlistId: videoFile.videoStreamingPlaylistId })
+ : await VideoFileModel.loadWebTorrentFile({ ...baseFind, videoId: videoFile.videoId })
+
+ if (!element) return videoFile.save({ transaction })
+
+ for (const k of Object.keys(videoFile.toJSON())) {
+ element.set(k, videoFile[k])
+ }
+
+ return element.save({ transaction })
+ }
+
+ static async loadWebTorrentFile (options: {
+ videoId: number
+ fps: number
+ resolution: number
+ transaction?: Transaction
+ }) {
+ const where = {
+ fps: options.fps,
+ resolution: options.resolution,
+ videoId: options.videoId
+ }
+
+ return VideoFileModel.findOne({ where, transaction: options.transaction })
+ }
+
+ static async loadHLSFile (options: {
+ playlistId: number
+ fps: number
+ resolution: number
+ transaction?: Transaction
+ }) {
+ const where = {
+ fps: options.fps,
+ resolution: options.resolution,
+ videoStreamingPlaylistId: options.playlistId
+ }
+
+ return VideoFileModel.findOne({ where, transaction: options.transaction })
+ }
+
+ static removeHLSFilesOfVideoId (videoStreamingPlaylistId: number) {
+ const options = {
+ where: { videoStreamingPlaylistId }
+ }
+
+ return VideoFileModel.destroy(options)
+ }
+
+ hasTorrent () {
+ return this.infoHash && this.torrentFilename
+ }
+
+ getVideoOrStreamingPlaylist (this: MVideoFileVideo | MVideoFileStreamingPlaylistVideo): MVideo | MStreamingPlaylistVideo {
+ if (this.videoId || (this as MVideoFileVideo).Video) return (this as MVideoFileVideo).Video
+
+ return (this as MVideoFileStreamingPlaylistVideo).VideoStreamingPlaylist
+ }
+
+ getVideo (this: MVideoFileVideo | MVideoFileStreamingPlaylistVideo): MVideo {
+ return extractVideo(this.getVideoOrStreamingPlaylist())
+ }
+
+ isAudio () {
+ return this.resolution === VideoResolution.H_NOVIDEO
+ }
+
+ isLive () {
+ return this.size === -1
+ }
+
+ isHLS () {
+ return !!this.videoStreamingPlaylistId
+ }
+
+ // ---------------------------------------------------------------------------
+
+ getObjectStorageUrl (video: MVideo) {
+ if (video.hasPrivateStaticPath() && CONFIG.OBJECT_STORAGE.PROXY.PROXIFY_PRIVATE_FILES === true) {
+ return this.getPrivateObjectStorageUrl(video)
+ }
+
+ return this.getPublicObjectStorageUrl()
+ }
+
+ private getPrivateObjectStorageUrl (video: MVideo) {
+ if (this.isHLS()) {
+ return getHLSPrivateFileUrl(video, this.filename)
+ }
+
+ return getWebTorrentPrivateFileUrl(this.filename)
+ }
+
+ private getPublicObjectStorageUrl () {
+ if (this.isHLS()) {
+ return getHLSPublicFileUrl(this.fileUrl)
+ }
+
+ return getWebTorrentPublicFileUrl(this.fileUrl)
+ }
+
+ // ---------------------------------------------------------------------------
+
+ getFileUrl (video: MVideo) {
+ if (video.isOwned()) {
+ if (this.storage === VideoStorage.OBJECT_STORAGE) {
+ return this.getObjectStorageUrl(video)
+ }
+
+ return WEBSERVER.URL + this.getFileStaticPath(video)
+ }
+
+ return this.fileUrl
+ }
+
+ // ---------------------------------------------------------------------------
+
+ getFileStaticPath (video: MVideo) {
+ if (this.isHLS()) return this.getHLSFileStaticPath(video)
+
+ return this.getWebTorrentFileStaticPath(video)
+ }
+
+ private getWebTorrentFileStaticPath (video: MVideo) {
+ if (isVideoInPrivateDirectory(video.privacy)) {
+ return join(STATIC_PATHS.PRIVATE_WEBSEED, this.filename)
+ }
+
+ return join(STATIC_PATHS.WEBSEED, this.filename)
+ }
+
+ private getHLSFileStaticPath (video: MVideo) {
+ if (isVideoInPrivateDirectory(video.privacy)) {
+ return join(STATIC_PATHS.STREAMING_PLAYLISTS.PRIVATE_HLS, video.uuid, this.filename)
+ }
+
+ return join(STATIC_PATHS.STREAMING_PLAYLISTS.HLS, video.uuid, this.filename)
+ }
+
+ // ---------------------------------------------------------------------------
+
+ getFileDownloadUrl (video: MVideoWithHost) {
+ const path = this.isHLS()
+ ? join(STATIC_DOWNLOAD_PATHS.HLS_VIDEOS, `${video.uuid}-${this.resolution}-fragmented${this.extname}`)
+ : join(STATIC_DOWNLOAD_PATHS.VIDEOS, `${video.uuid}-${this.resolution}${this.extname}`)
+
+ if (video.isOwned()) return WEBSERVER.URL + path
+
+ // FIXME: don't guess remote URL
+ return buildRemoteVideoBaseUrl(video, path)
+ }
+
+ getRemoteTorrentUrl (video: MVideo) {
+ if (video.isOwned()) throw new Error(`Video ${video.url} is not a remote video`)
+
+ return this.torrentUrl
+ }
+
+ // We proxify torrent requests so use a local URL
+ getTorrentUrl () {
+ if (!this.torrentFilename) return null
+
+ return WEBSERVER.URL + this.getTorrentStaticPath()
+ }
+
+ getTorrentStaticPath () {
+ if (!this.torrentFilename) return null
+
+ return join(LAZY_STATIC_PATHS.TORRENTS, this.torrentFilename)
+ }
+
+ getTorrentDownloadUrl () {
+ if (!this.torrentFilename) return null
+
+ return WEBSERVER.URL + join(STATIC_DOWNLOAD_PATHS.TORRENTS, this.torrentFilename)
+ }
+
+ removeTorrent () {
+ if (!this.torrentFilename) return null
+
+ const torrentPath = getFSTorrentFilePath(this)
+ return remove(torrentPath)
+ .catch(err => logger.warn('Cannot delete torrent %s.', torrentPath, { err }))
+ }
+
+ hasSameUniqueKeysThan (other: MVideoFile) {
+ return this.fps === other.fps &&
+ this.resolution === other.resolution &&
+ (
+ (this.videoId !== null && this.videoId === other.videoId) ||
+ (this.videoStreamingPlaylistId !== null && this.videoStreamingPlaylistId === other.videoStreamingPlaylistId)
+ )
+ }
+
+ withVideoOrPlaylist (videoOrPlaylist: MVideo | MStreamingPlaylistVideo) {
+ if (isStreamingPlaylist(videoOrPlaylist)) return Object.assign(this, { VideoStreamingPlaylist: videoOrPlaylist })
+
+ return Object.assign(this, { Video: videoOrPlaylist })