2021-02-16 16:25:53 +01:00
|
|
|
import { remove } from 'fs-extra'
|
2021-08-27 14:32:44 +02:00
|
|
|
import memoizee from 'memoizee'
|
2021-02-16 16:25:53 +01:00
|
|
|
import { join } from 'path'
|
2022-02-09 17:48:15 +01:00
|
|
|
import { FindOptions, Op, Transaction, WhereOptions } from 'sequelize'
|
2018-09-11 16:27:07 +02:00
|
|
|
import {
|
|
|
|
AllowNull,
|
|
|
|
BelongsTo,
|
|
|
|
Column,
|
|
|
|
CreatedAt,
|
|
|
|
DataType,
|
|
|
|
Default,
|
2021-02-16 16:25:53 +01:00
|
|
|
DefaultScope,
|
2018-09-11 16:27:07 +02:00
|
|
|
ForeignKey,
|
|
|
|
HasMany,
|
|
|
|
Is,
|
|
|
|
Model,
|
2020-03-10 14:39:40 +01:00
|
|
|
Scopes,
|
2021-02-16 16:25:53 +01:00
|
|
|
Table,
|
|
|
|
UpdatedAt
|
2018-09-11 16:27:07 +02:00
|
|
|
} from 'sequelize-typescript'
|
2021-02-16 16:25:53 +01:00
|
|
|
import validator from 'validator'
|
|
|
|
import { logger } from '@server/helpers/logger'
|
|
|
|
import { extractVideo } from '@server/helpers/video'
|
2023-01-10 11:09:30 +01:00
|
|
|
import { CONFIG } from '@server/initializers/config'
|
2022-03-23 14:24:50 +01:00
|
|
|
import { buildRemoteVideoBaseUrl } from '@server/lib/activitypub/url'
|
2022-10-19 10:43:53 +02:00
|
|
|
import {
|
|
|
|
getHLSPrivateFileUrl,
|
|
|
|
getHLSPublicFileUrl,
|
2023-07-11 09:21:13 +02:00
|
|
|
getWebVideoPrivateFileUrl,
|
|
|
|
getWebVideoPublicFileUrl
|
2022-10-19 10:43:53 +02:00
|
|
|
} from '@server/lib/object-storage'
|
2021-08-17 08:26:20 +02:00
|
|
|
import { getFSTorrentFilePath } from '@server/lib/paths'
|
2022-10-12 16:09:02 +02:00
|
|
|
import { isVideoInPrivateDirectory } from '@server/lib/video-privacy'
|
2021-11-18 14:35:08 +01:00
|
|
|
import { isStreamingPlaylist, MStreamingPlaylistVideo, MVideo, MVideoWithHost } from '@server/types/models'
|
2021-12-23 10:57:55 +01:00
|
|
|
import { VideoResolution, VideoStorage } from '@shared/models'
|
2021-12-16 18:04:16 +01:00
|
|
|
import { AttributesOnly } from '@shared/typescript-utils'
|
2018-06-29 16:41:29 +02:00
|
|
|
import {
|
2018-12-11 14:52:50 +01:00
|
|
|
isVideoFileExtnameValid,
|
2018-06-29 16:41:29 +02:00
|
|
|
isVideoFileInfoHashValid,
|
|
|
|
isVideoFileResolutionValid,
|
|
|
|
isVideoFileSizeValid,
|
|
|
|
isVideoFPSResolutionValid
|
|
|
|
} from '../../helpers/custom-validators/videos'
|
2021-02-16 16:25:53 +01:00
|
|
|
import {
|
|
|
|
LAZY_STATIC_PATHS,
|
|
|
|
MEMOIZE_LENGTH,
|
|
|
|
MEMOIZE_TTL,
|
|
|
|
STATIC_DOWNLOAD_PATHS,
|
|
|
|
STATIC_PATHS,
|
|
|
|
WEBSERVER
|
|
|
|
} from '../../initializers/constants'
|
|
|
|
import { MVideoFile, MVideoFileStreamingPlaylistVideo, MVideoFileVideo } from '../../types/models/video/video-file'
|
|
|
|
import { VideoRedundancyModel } from '../redundancy/video-redundancy'
|
2023-01-10 11:09:30 +01:00
|
|
|
import { doesExist, parseAggregateResult, throwIfNotValid } from '../shared'
|
2017-12-12 17:53:50 +01:00
|
|
|
import { VideoModel } from './video'
|
2019-04-08 11:13:49 +02:00
|
|
|
import { VideoStreamingPlaylistModel } from './video-streaming-playlist'
|
2017-08-25 11:36:23 +02:00
|
|
|
|
2020-03-10 14:39:40 +01:00
|
|
|
export enum ScopeNames {
|
|
|
|
WITH_VIDEO = 'WITH_VIDEO',
|
2021-02-16 16:25:53 +01:00
|
|
|
WITH_METADATA = 'WITH_METADATA',
|
|
|
|
WITH_VIDEO_OR_PLAYLIST = 'WITH_VIDEO_OR_PLAYLIST'
|
2020-03-10 14:39:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@DefaultScope(() => ({
|
|
|
|
attributes: {
|
2020-03-10 14:49:02 +01:00
|
|
|
exclude: [ 'metadata' ]
|
2020-03-10 14:39:40 +01:00
|
|
|
}
|
|
|
|
}))
|
|
|
|
@Scopes(() => ({
|
|
|
|
[ScopeNames.WITH_VIDEO]: {
|
|
|
|
include: [
|
|
|
|
{
|
|
|
|
model: VideoModel.unscoped(),
|
|
|
|
required: true
|
|
|
|
}
|
|
|
|
]
|
|
|
|
},
|
2022-02-09 17:48:15 +01:00
|
|
|
[ScopeNames.WITH_VIDEO_OR_PLAYLIST]: (options: { whereVideo?: WhereOptions } = {}) => {
|
2021-02-16 16:25:53 +01:00
|
|
|
return {
|
|
|
|
include: [
|
|
|
|
{
|
|
|
|
model: VideoModel.unscoped(),
|
|
|
|
required: false,
|
|
|
|
where: options.whereVideo
|
|
|
|
},
|
|
|
|
{
|
|
|
|
model: VideoStreamingPlaylistModel.unscoped(),
|
|
|
|
required: false,
|
|
|
|
include: [
|
|
|
|
{
|
|
|
|
model: VideoModel.unscoped(),
|
|
|
|
required: true,
|
|
|
|
where: options.whereVideo
|
|
|
|
}
|
|
|
|
]
|
|
|
|
}
|
|
|
|
]
|
|
|
|
}
|
|
|
|
},
|
2020-03-10 14:39:40 +01:00
|
|
|
[ScopeNames.WITH_METADATA]: {
|
|
|
|
attributes: {
|
2020-03-10 14:49:02 +01:00
|
|
|
include: [ 'metadata' ]
|
2020-03-10 14:39:40 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}))
|
2017-12-12 17:53:50 +01:00
|
|
|
@Table({
|
|
|
|
tableName: 'videoFile',
|
|
|
|
indexes: [
|
2017-08-25 11:36:23 +02:00
|
|
|
{
|
2019-11-15 15:06:03 +01:00
|
|
|
fields: [ 'videoId' ],
|
|
|
|
where: {
|
|
|
|
videoId: {
|
|
|
|
[Op.ne]: null
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
fields: [ 'videoStreamingPlaylistId' ],
|
|
|
|
where: {
|
|
|
|
videoStreamingPlaylistId: {
|
|
|
|
[Op.ne]: null
|
|
|
|
}
|
|
|
|
}
|
2017-08-25 11:36:23 +02:00
|
|
|
},
|
2019-11-15 15:06:03 +01:00
|
|
|
|
2017-08-25 11:36:23 +02:00
|
|
|
{
|
2017-12-12 17:53:50 +01:00
|
|
|
fields: [ 'infoHash' ]
|
2018-07-23 20:13:30 +02:00
|
|
|
},
|
2019-11-15 15:06:03 +01:00
|
|
|
|
2021-02-16 16:25:53 +01:00
|
|
|
{
|
|
|
|
fields: [ 'torrentFilename' ],
|
|
|
|
unique: true
|
|
|
|
},
|
|
|
|
|
|
|
|
{
|
|
|
|
fields: [ 'filename' ],
|
|
|
|
unique: true
|
|
|
|
},
|
|
|
|
|
2018-07-23 20:13:30 +02:00
|
|
|
{
|
|
|
|
fields: [ 'videoId', 'resolution', 'fps' ],
|
2019-11-15 15:06:03 +01:00
|
|
|
unique: true,
|
|
|
|
where: {
|
|
|
|
videoId: {
|
|
|
|
[Op.ne]: null
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
fields: [ 'videoStreamingPlaylistId', 'resolution', 'fps' ],
|
|
|
|
unique: true,
|
|
|
|
where: {
|
|
|
|
videoStreamingPlaylistId: {
|
|
|
|
[Op.ne]: null
|
|
|
|
}
|
|
|
|
}
|
2017-08-25 11:36:23 +02:00
|
|
|
}
|
|
|
|
]
|
2017-12-12 17:53:50 +01:00
|
|
|
})
|
2021-05-12 14:09:04 +02:00
|
|
|
export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>>> {
|
2017-12-12 17:53:50 +01:00
|
|
|
@CreatedAt
|
|
|
|
createdAt: Date
|
|
|
|
|
|
|
|
@UpdatedAt
|
|
|
|
updatedAt: Date
|
|
|
|
|
|
|
|
@AllowNull(false)
|
|
|
|
@Is('VideoFileResolution', value => throwIfNotValid(value, isVideoFileResolutionValid, 'resolution'))
|
|
|
|
@Column
|
|
|
|
resolution: number
|
|
|
|
|
|
|
|
@AllowNull(false)
|
|
|
|
@Is('VideoFileSize', value => throwIfNotValid(value, isVideoFileSizeValid, 'size'))
|
|
|
|
@Column(DataType.BIGINT)
|
|
|
|
size: number
|
|
|
|
|
|
|
|
@AllowNull(false)
|
2018-12-11 14:52:50 +01:00
|
|
|
@Is('VideoFileExtname', value => throwIfNotValid(value, isVideoFileExtnameValid, 'extname'))
|
|
|
|
@Column
|
2017-12-12 17:53:50 +01:00
|
|
|
extname: string
|
|
|
|
|
2020-09-17 09:20:52 +02:00
|
|
|
@AllowNull(true)
|
|
|
|
@Is('VideoFileInfohash', value => throwIfNotValid(value, isVideoFileInfoHashValid, 'info hash', true))
|
2017-12-12 17:53:50 +01:00
|
|
|
@Column
|
|
|
|
infoHash: string
|
|
|
|
|
2018-09-26 14:08:35 +02:00
|
|
|
@AllowNull(false)
|
|
|
|
@Default(-1)
|
2018-06-29 16:41:29 +02:00
|
|
|
@Is('VideoFileFPS', value => throwIfNotValid(value, isVideoFPSResolutionValid, 'fps'))
|
|
|
|
@Column
|
|
|
|
fps: number
|
|
|
|
|
2020-03-10 14:39:40 +01:00
|
|
|
@AllowNull(true)
|
|
|
|
@Column(DataType.JSONB)
|
|
|
|
metadata: any
|
|
|
|
|
|
|
|
@AllowNull(true)
|
|
|
|
@Column
|
|
|
|
metadataUrl: string
|
|
|
|
|
2021-09-06 09:29:25 +02:00
|
|
|
// Could be null for remote files
|
2021-02-16 16:25:53 +01:00
|
|
|
@AllowNull(true)
|
|
|
|
@Column
|
|
|
|
fileUrl: string
|
|
|
|
|
|
|
|
// Could be null for live files
|
|
|
|
@AllowNull(true)
|
|
|
|
@Column
|
|
|
|
filename: string
|
|
|
|
|
2021-09-06 09:29:25 +02:00
|
|
|
// Could be null for remote files
|
2021-02-16 16:25:53 +01:00
|
|
|
@AllowNull(true)
|
|
|
|
@Column
|
|
|
|
torrentUrl: string
|
|
|
|
|
|
|
|
// Could be null for live files
|
|
|
|
@AllowNull(true)
|
|
|
|
@Column
|
|
|
|
torrentFilename: string
|
|
|
|
|
2017-12-12 17:53:50 +01:00
|
|
|
@ForeignKey(() => VideoModel)
|
|
|
|
@Column
|
|
|
|
videoId: number
|
|
|
|
|
2021-08-17 08:26:20 +02:00
|
|
|
@AllowNull(false)
|
|
|
|
@Default(VideoStorage.FILE_SYSTEM)
|
|
|
|
@Column
|
|
|
|
storage: VideoStorage
|
|
|
|
|
2017-12-12 17:53:50 +01:00
|
|
|
@BelongsTo(() => VideoModel, {
|
2017-08-25 11:36:23 +02:00
|
|
|
foreignKey: {
|
2019-11-15 15:06:03 +01:00
|
|
|
allowNull: true
|
2017-08-25 11:36:23 +02:00
|
|
|
},
|
|
|
|
onDelete: 'CASCADE'
|
|
|
|
})
|
2017-12-12 17:53:50 +01:00
|
|
|
Video: VideoModel
|
2018-08-14 11:00:03 +02:00
|
|
|
|
2019-11-15 15:06:03 +01:00
|
|
|
@ForeignKey(() => VideoStreamingPlaylistModel)
|
|
|
|
@Column
|
|
|
|
videoStreamingPlaylistId: number
|
|
|
|
|
|
|
|
@BelongsTo(() => VideoStreamingPlaylistModel, {
|
|
|
|
foreignKey: {
|
|
|
|
allowNull: true
|
|
|
|
},
|
|
|
|
onDelete: 'CASCADE'
|
|
|
|
})
|
|
|
|
VideoStreamingPlaylist: VideoStreamingPlaylistModel
|
|
|
|
|
2018-09-11 16:27:07 +02:00
|
|
|
@HasMany(() => VideoRedundancyModel, {
|
|
|
|
foreignKey: {
|
2019-01-29 08:37:25 +01:00
|
|
|
allowNull: true
|
2018-09-11 16:27:07 +02:00
|
|
|
},
|
|
|
|
onDelete: 'CASCADE',
|
|
|
|
hooks: true
|
|
|
|
})
|
|
|
|
RedundancyVideos: VideoRedundancyModel[]
|
|
|
|
|
2020-01-03 13:47:45 +01:00
|
|
|
static doesInfohashExistCached = memoizee(VideoFileModel.doesInfohashExist, {
|
|
|
|
promise: true,
|
|
|
|
max: MEMOIZE_LENGTH.INFO_HASH_EXISTS,
|
|
|
|
maxAge: MEMOIZE_TTL.INFO_HASH_EXISTS
|
|
|
|
})
|
|
|
|
|
2019-01-29 08:37:25 +01:00
|
|
|
static doesInfohashExist (infoHash: string) {
|
2018-08-14 11:00:03 +02:00
|
|
|
const query = 'SELECT 1 FROM "videoFile" WHERE "infoHash" = $infoHash LIMIT 1'
|
|
|
|
|
2023-01-10 11:09:30 +01:00
|
|
|
return doesExist(this.sequelize, query, { infoHash })
|
2018-08-14 11:00:03 +02:00
|
|
|
}
|
2018-09-24 13:07:33 +02:00
|
|
|
|
2020-03-10 14:39:40 +01:00
|
|
|
static async doesVideoExistForVideoFile (id: number, videoIdOrUUID: number | string) {
|
|
|
|
const videoFile = await VideoFileModel.loadWithVideoOrPlaylist(id, videoIdOrUUID)
|
2020-03-10 14:49:02 +01:00
|
|
|
|
|
|
|
return !!videoFile
|
2020-03-10 14:39:40 +01:00
|
|
|
}
|
|
|
|
|
2021-07-23 11:20:00 +02:00
|
|
|
static async doesOwnedTorrentFileExist (filename: string) {
|
|
|
|
const query = 'SELECT 1 FROM "videoFile" ' +
|
2023-07-11 09:21:13 +02:00
|
|
|
'LEFT JOIN "video" "webvideo" ON "webvideo"."id" = "videoFile"."videoId" AND "webvideo"."remote" IS FALSE ' +
|
2021-07-23 11:20:00 +02:00
|
|
|
'LEFT JOIN "videoStreamingPlaylist" ON "videoStreamingPlaylist"."id" = "videoFile"."videoStreamingPlaylistId" ' +
|
|
|
|
'LEFT JOIN "video" "hlsVideo" ON "hlsVideo"."id" = "videoStreamingPlaylist"."videoId" AND "hlsVideo"."remote" IS FALSE ' +
|
2023-07-11 09:21:13 +02:00
|
|
|
'WHERE "torrentFilename" = $filename AND ("hlsVideo"."id" IS NOT NULL OR "webvideo"."id" IS NOT NULL) LIMIT 1'
|
2021-07-23 11:20:00 +02:00
|
|
|
|
2023-01-10 11:09:30 +01:00
|
|
|
return doesExist(this.sequelize, query, { filename })
|
2021-07-23 11:20:00 +02:00
|
|
|
}
|
|
|
|
|
2023-07-11 09:21:13 +02:00
|
|
|
static async doesOwnedWebVideoFileExist (filename: string) {
|
2021-07-23 11:20:00 +02:00
|
|
|
const query = 'SELECT 1 FROM "videoFile" INNER JOIN "video" ON "video"."id" = "videoFile"."videoId" AND "video"."remote" IS FALSE ' +
|
2021-08-17 08:26:20 +02:00
|
|
|
`WHERE "filename" = $filename AND "storage" = ${VideoStorage.FILE_SYSTEM} LIMIT 1`
|
2021-07-23 11:20:00 +02:00
|
|
|
|
2023-01-10 11:09:30 +01:00
|
|
|
return doesExist(this.sequelize, query, { filename })
|
2021-07-23 11:20:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static loadByFilename (filename: string) {
|
|
|
|
const query = {
|
|
|
|
where: {
|
|
|
|
filename
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return VideoFileModel.findOne(query)
|
|
|
|
}
|
|
|
|
|
2022-10-12 16:09:02 +02:00
|
|
|
static loadWithVideoByFilename (filename: string): Promise<MVideoFileVideo | MVideoFileStreamingPlaylistVideo> {
|
|
|
|
const query = {
|
|
|
|
where: {
|
|
|
|
filename
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return VideoFileModel.scope(ScopeNames.WITH_VIDEO_OR_PLAYLIST).findOne(query)
|
|
|
|
}
|
|
|
|
|
2021-02-16 16:25:53 +01:00
|
|
|
static loadWithVideoOrPlaylistByTorrentFilename (filename: string) {
|
|
|
|
const query = {
|
|
|
|
where: {
|
|
|
|
torrentFilename: filename
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return VideoFileModel.scope(ScopeNames.WITH_VIDEO_OR_PLAYLIST).findOne(query)
|
|
|
|
}
|
|
|
|
|
2022-10-12 16:09:02 +02:00
|
|
|
static load (id: number): Promise<MVideoFile> {
|
|
|
|
return VideoFileModel.findByPk(id)
|
|
|
|
}
|
|
|
|
|
2020-03-10 14:39:40 +01:00
|
|
|
static loadWithMetadata (id: number) {
|
|
|
|
return VideoFileModel.scope(ScopeNames.WITH_METADATA).findByPk(id)
|
|
|
|
}
|
|
|
|
|
2018-10-03 16:43:57 +02:00
|
|
|
static loadWithVideo (id: number) {
|
2020-03-10 14:39:40 +01:00
|
|
|
return VideoFileModel.scope(ScopeNames.WITH_VIDEO).findByPk(id)
|
|
|
|
}
|
2018-10-03 16:43:57 +02:00
|
|
|
|
2020-03-10 14:39:40 +01:00
|
|
|
static loadWithVideoOrPlaylist (id: number, videoIdOrUUID: number | string) {
|
2020-03-10 14:49:02 +01:00
|
|
|
const whereVideo = validator.isUUID(videoIdOrUUID + '')
|
|
|
|
? { uuid: videoIdOrUUID }
|
|
|
|
: { id: videoIdOrUUID }
|
|
|
|
|
|
|
|
const options = {
|
|
|
|
where: {
|
|
|
|
id
|
2021-02-16 16:25:53 +01:00
|
|
|
}
|
2020-03-10 14:49:02 +01:00
|
|
|
}
|
|
|
|
|
2021-02-16 16:25:53 +01:00
|
|
|
return VideoFileModel.scope({ method: [ ScopeNames.WITH_VIDEO_OR_PLAYLIST, whereVideo ] })
|
|
|
|
.findOne(options)
|
2020-03-10 14:49:02 +01:00
|
|
|
.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
|
|
|
|
})
|
2018-10-03 16:43:57 +02:00
|
|
|
}
|
|
|
|
|
2019-04-23 09:50:57 +02:00
|
|
|
static listByStreamingPlaylist (streamingPlaylistId: number, transaction: Transaction) {
|
2019-04-08 11:13:49 +02:00
|
|
|
const query = {
|
|
|
|
include: [
|
|
|
|
{
|
|
|
|
model: VideoModel.unscoped(),
|
|
|
|
required: true,
|
|
|
|
include: [
|
|
|
|
{
|
|
|
|
model: VideoStreamingPlaylistModel.unscoped(),
|
|
|
|
required: true,
|
|
|
|
where: {
|
|
|
|
id: streamingPlaylistId
|
|
|
|
}
|
|
|
|
}
|
|
|
|
]
|
|
|
|
}
|
|
|
|
],
|
|
|
|
transaction
|
|
|
|
}
|
|
|
|
|
|
|
|
return VideoFileModel.findAll(query)
|
|
|
|
}
|
|
|
|
|
2019-04-23 09:50:57 +02:00
|
|
|
static getStats () {
|
2023-07-11 09:21:13 +02:00
|
|
|
const webVideoFilesQuery: FindOptions = {
|
2019-01-15 09:45:54 +01:00
|
|
|
include: [
|
|
|
|
{
|
|
|
|
attributes: [],
|
2020-11-10 08:07:21 +01:00
|
|
|
required: true,
|
2019-01-15 09:45:54 +01:00
|
|
|
model: VideoModel.unscoped(),
|
|
|
|
where: {
|
|
|
|
remote: false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
]
|
|
|
|
}
|
2019-04-23 09:50:57 +02:00
|
|
|
|
2020-11-10 08:07:21 +01:00
|
|
|
const hlsFilesQuery: FindOptions = {
|
|
|
|
include: [
|
|
|
|
{
|
|
|
|
attributes: [],
|
|
|
|
required: true,
|
|
|
|
model: VideoStreamingPlaylistModel.unscoped(),
|
|
|
|
include: [
|
|
|
|
{
|
|
|
|
attributes: [],
|
|
|
|
model: VideoModel.unscoped(),
|
|
|
|
required: true,
|
|
|
|
where: {
|
|
|
|
remote: false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
]
|
|
|
|
}
|
|
|
|
]
|
|
|
|
}
|
|
|
|
|
|
|
|
return Promise.all([
|
2023-07-11 09:21:13 +02:00
|
|
|
VideoFileModel.aggregate('size', 'SUM', webVideoFilesQuery),
|
2020-11-10 08:07:21 +01:00
|
|
|
VideoFileModel.aggregate('size', 'SUM', hlsFilesQuery)
|
2023-07-11 09:21:13 +02:00
|
|
|
]).then(([ webVideoResult, hlsResult ]) => ({
|
|
|
|
totalLocalVideoFilesSize: parseAggregateResult(webVideoResult) + parseAggregateResult(hlsResult)
|
2020-11-10 08:07:21 +01:00
|
|
|
}))
|
2019-01-15 09:45:54 +01:00
|
|
|
}
|
|
|
|
|
2019-11-15 15:06:03 +01:00
|
|
|
// 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
|
|
|
|
) {
|
2022-07-25 10:57:16 +02:00
|
|
|
const baseFind = {
|
2019-11-15 15:06:03 +01:00
|
|
|
fps: videoFile.fps,
|
2022-07-25 10:57:16 +02:00
|
|
|
resolution: videoFile.resolution,
|
|
|
|
transaction
|
2019-11-15 15:06:03 +01:00
|
|
|
}
|
|
|
|
|
2022-07-25 10:57:16 +02:00
|
|
|
const element = mode === 'streaming-playlist'
|
|
|
|
? await VideoFileModel.loadHLSFile({ ...baseFind, playlistId: videoFile.videoStreamingPlaylistId })
|
2023-07-11 09:21:13 +02:00
|
|
|
: await VideoFileModel.loadWebVideoFile({ ...baseFind, videoId: videoFile.videoId })
|
2019-11-15 15:06:03 +01:00
|
|
|
|
|
|
|
if (!element) return videoFile.save({ transaction })
|
|
|
|
|
|
|
|
for (const k of Object.keys(videoFile.toJSON())) {
|
2022-12-30 10:12:20 +01:00
|
|
|
element.set(k, videoFile[k])
|
2019-11-15 15:06:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return element.save({ transaction })
|
|
|
|
}
|
|
|
|
|
2023-07-11 09:21:13 +02:00
|
|
|
static async loadWebVideoFile (options: {
|
2022-07-25 10:57:16 +02:00
|
|
|
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 })
|
|
|
|
}
|
|
|
|
|
2020-11-03 15:33:30 +01:00
|
|
|
static removeHLSFilesOfVideoId (videoStreamingPlaylistId: number) {
|
|
|
|
const options = {
|
|
|
|
where: { videoStreamingPlaylistId }
|
|
|
|
}
|
|
|
|
|
|
|
|
return VideoFileModel.destroy(options)
|
|
|
|
}
|
|
|
|
|
2021-05-25 11:30:00 +02:00
|
|
|
hasTorrent () {
|
|
|
|
return this.infoHash && this.torrentFilename
|
|
|
|
}
|
|
|
|
|
2019-11-15 15:06:03 +01:00
|
|
|
getVideoOrStreamingPlaylist (this: MVideoFileVideo | MVideoFileStreamingPlaylistVideo): MVideo | MStreamingPlaylistVideo {
|
2022-10-12 16:09:02 +02:00
|
|
|
if (this.videoId || (this as MVideoFileVideo).Video) return (this as MVideoFileVideo).Video
|
2019-11-15 15:06:03 +01:00
|
|
|
|
|
|
|
return (this as MVideoFileStreamingPlaylistVideo).VideoStreamingPlaylist
|
|
|
|
}
|
|
|
|
|
2021-02-16 16:25:53 +01:00
|
|
|
getVideo (this: MVideoFileVideo | MVideoFileStreamingPlaylistVideo): MVideo {
|
|
|
|
return extractVideo(this.getVideoOrStreamingPlaylist())
|
|
|
|
}
|
|
|
|
|
2019-05-16 16:55:34 +02:00
|
|
|
isAudio () {
|
2021-12-23 10:57:55 +01:00
|
|
|
return this.resolution === VideoResolution.H_NOVIDEO
|
2019-05-16 16:55:34 +02:00
|
|
|
}
|
|
|
|
|
2020-11-04 15:31:32 +01:00
|
|
|
isLive () {
|
|
|
|
return this.size === -1
|
|
|
|
}
|
|
|
|
|
2020-11-06 10:57:40 +01:00
|
|
|
isHLS () {
|
2020-11-06 14:33:31 +01:00
|
|
|
return !!this.videoStreamingPlaylistId
|
2020-11-06 10:57:40 +01:00
|
|
|
}
|
|
|
|
|
2022-10-19 10:43:53 +02:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
getObjectStorageUrl (video: MVideo) {
|
2022-10-26 16:23:39 +02:00
|
|
|
if (video.hasPrivateStaticPath() && CONFIG.OBJECT_STORAGE.PROXY.PROXIFY_PRIVATE_FILES === true) {
|
2022-10-19 10:43:53 +02:00
|
|
|
return this.getPrivateObjectStorageUrl(video)
|
|
|
|
}
|
|
|
|
|
|
|
|
return this.getPublicObjectStorageUrl()
|
|
|
|
}
|
|
|
|
|
|
|
|
private getPrivateObjectStorageUrl (video: MVideo) {
|
|
|
|
if (this.isHLS()) {
|
|
|
|
return getHLSPrivateFileUrl(video, this.filename)
|
|
|
|
}
|
|
|
|
|
2023-07-11 09:21:13 +02:00
|
|
|
return getWebVideoPrivateFileUrl(this.filename)
|
2022-10-19 10:43:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private getPublicObjectStorageUrl () {
|
2021-08-17 08:26:20 +02:00
|
|
|
if (this.isHLS()) {
|
|
|
|
return getHLSPublicFileUrl(this.fileUrl)
|
|
|
|
}
|
|
|
|
|
2023-07-11 09:21:13 +02:00
|
|
|
return getWebVideoPublicFileUrl(this.fileUrl)
|
2021-08-17 08:26:20 +02:00
|
|
|
}
|
|
|
|
|
2022-10-19 10:43:53 +02:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
2021-02-18 11:28:00 +01:00
|
|
|
getFileUrl (video: MVideo) {
|
2022-10-19 10:43:53 +02:00
|
|
|
if (video.isOwned()) {
|
|
|
|
if (this.storage === VideoStorage.OBJECT_STORAGE) {
|
|
|
|
return this.getObjectStorageUrl(video)
|
|
|
|
}
|
2021-02-16 16:25:53 +01:00
|
|
|
|
2022-10-19 10:43:53 +02:00
|
|
|
return WEBSERVER.URL + this.getFileStaticPath(video)
|
|
|
|
}
|
2021-02-16 16:25:53 +01:00
|
|
|
|
2021-02-18 10:15:11 +01:00
|
|
|
return this.fileUrl
|
2021-02-16 16:25:53 +01:00
|
|
|
}
|
|
|
|
|
2022-10-19 10:43:53 +02:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
2021-02-16 16:25:53 +01:00
|
|
|
getFileStaticPath (video: MVideo) {
|
2022-10-19 10:43:53 +02:00
|
|
|
if (this.isHLS()) return this.getHLSFileStaticPath(video)
|
2022-10-12 16:09:02 +02:00
|
|
|
|
2023-07-11 09:21:13 +02:00
|
|
|
return this.getWebVideoFileStaticPath(video)
|
2022-10-19 10:43:53 +02:00
|
|
|
}
|
2022-10-12 16:09:02 +02:00
|
|
|
|
2023-07-11 09:21:13 +02:00
|
|
|
private getWebVideoFileStaticPath (video: MVideo) {
|
2022-10-12 16:09:02 +02:00
|
|
|
if (isVideoInPrivateDirectory(video.privacy)) {
|
2023-07-11 11:39:59 +02:00
|
|
|
return join(STATIC_PATHS.PRIVATE_WEB_VIDEOS, this.filename)
|
2022-10-12 16:09:02 +02:00
|
|
|
}
|
2021-02-16 16:25:53 +01:00
|
|
|
|
2023-07-11 11:39:59 +02:00
|
|
|
return join(STATIC_PATHS.WEB_VIDEOS, this.filename)
|
2021-02-16 16:25:53 +01:00
|
|
|
}
|
|
|
|
|
2022-10-19 10:43:53 +02:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
2021-02-16 16:25:53 +01:00
|
|
|
getFileDownloadUrl (video: MVideoWithHost) {
|
2021-07-23 11:20:00 +02:00
|
|
|
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}`)
|
2021-02-16 16:25:53 +01:00
|
|
|
|
|
|
|
if (video.isOwned()) return WEBSERVER.URL + path
|
|
|
|
|
|
|
|
// FIXME: don't guess remote URL
|
|
|
|
return buildRemoteVideoBaseUrl(video, path)
|
|
|
|
}
|
|
|
|
|
2021-02-18 11:28:00 +01:00
|
|
|
getRemoteTorrentUrl (video: MVideo) {
|
2021-02-16 16:25:53 +01:00
|
|
|
if (video.isOwned()) throw new Error(`Video ${video.url} is not a remote video`)
|
|
|
|
|
2021-02-18 10:15:11 +01:00
|
|
|
return this.torrentUrl
|
2021-02-16 16:25:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// We proxify torrent requests so use a local URL
|
|
|
|
getTorrentUrl () {
|
2021-02-25 13:56:07 +01:00
|
|
|
if (!this.torrentFilename) return null
|
|
|
|
|
2021-02-16 16:25:53 +01:00
|
|
|
return WEBSERVER.URL + this.getTorrentStaticPath()
|
|
|
|
}
|
|
|
|
|
|
|
|
getTorrentStaticPath () {
|
2021-02-25 13:56:07 +01:00
|
|
|
if (!this.torrentFilename) return null
|
|
|
|
|
2021-02-16 16:25:53 +01:00
|
|
|
return join(LAZY_STATIC_PATHS.TORRENTS, this.torrentFilename)
|
|
|
|
}
|
|
|
|
|
|
|
|
getTorrentDownloadUrl () {
|
2021-02-25 13:56:07 +01:00
|
|
|
if (!this.torrentFilename) return null
|
|
|
|
|
2021-02-16 16:25:53 +01:00
|
|
|
return WEBSERVER.URL + join(STATIC_DOWNLOAD_PATHS.TORRENTS, this.torrentFilename)
|
|
|
|
}
|
|
|
|
|
|
|
|
removeTorrent () {
|
2021-02-25 13:56:07 +01:00
|
|
|
if (!this.torrentFilename) return null
|
|
|
|
|
2021-08-17 08:26:20 +02:00
|
|
|
const torrentPath = getFSTorrentFilePath(this)
|
2021-02-16 16:25:53 +01:00
|
|
|
return remove(torrentPath)
|
|
|
|
.catch(err => logger.warn('Cannot delete torrent %s.', torrentPath, { err }))
|
|
|
|
}
|
|
|
|
|
2019-08-15 11:53:26 +02:00
|
|
|
hasSameUniqueKeysThan (other: MVideoFile) {
|
2018-09-24 13:07:33 +02:00
|
|
|
return this.fps === other.fps &&
|
|
|
|
this.resolution === other.resolution &&
|
2019-11-15 15:06:03 +01:00
|
|
|
(
|
|
|
|
(this.videoId !== null && this.videoId === other.videoId) ||
|
|
|
|
(this.videoStreamingPlaylistId !== null && this.videoStreamingPlaylistId === other.videoStreamingPlaylistId)
|
|
|
|
)
|
2018-09-24 13:07:33 +02:00
|
|
|
}
|
2021-11-18 14:35:08 +01:00
|
|
|
|
|
|
|
withVideoOrPlaylist (videoOrPlaylist: MVideo | MStreamingPlaylistVideo) {
|
|
|
|
if (isStreamingPlaylist(videoOrPlaylist)) return Object.assign(this, { VideoStreamingPlaylist: videoOrPlaylist })
|
|
|
|
|
|
|
|
return Object.assign(this, { Video: videoOrPlaylist })
|
|
|
|
}
|
2017-08-25 11:36:23 +02:00
|
|
|
}
|