X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fmodels%2Fvideo%2Fvideo-file.ts;h=201f0c0f1410d25201a632f05f47e58a0a048c04;hb=7b81edc854902a536083298472bf92bb6726edcf;hp=7d1e371b9f5b310781100862d3182b743e69f945;hpb=88108880bbdba473cfe36ecbebc1c3c4f972e102;p=github%2FChocobozzz%2FPeerTube.git diff --git a/server/models/video/video-file.ts b/server/models/video/video-file.ts index 7d1e371b9..201f0c0f1 100644 --- a/server/models/video/video-file.ts +++ b/server/models/video/video-file.ts @@ -10,7 +10,9 @@ import { Is, Model, Table, - UpdatedAt + UpdatedAt, + Scopes, + DefaultScope } from 'sequelize-typescript' import { isVideoFileExtnameValid, @@ -19,23 +21,83 @@ import { isVideoFileSizeValid, isVideoFPSResolutionValid } from '../../helpers/custom-validators/videos' -import { throwIfNotValid } from '../utils' +import { parseAggregateResult, throwIfNotValid } from '../utils' import { VideoModel } from './video' -import * as Sequelize from 'sequelize' import { VideoRedundancyModel } from '../redundancy/video-redundancy' +import { VideoStreamingPlaylistModel } from './video-streaming-playlist' +import { FindOptions, Op, QueryTypes, Transaction } from 'sequelize' +import { MIMETYPES, MEMOIZE_LENGTH, MEMOIZE_TTL } from '../../initializers/constants' +import { MVideoFile, MVideoFileStreamingPlaylistVideo, MVideoFileVideo } from '../../typings/models/video/video-file' +import { MStreamingPlaylistVideo, MVideo } from '@server/typings/models' +import * as memoizee from 'memoizee' +import validator from 'validator' +export enum ScopeNames { + WITH_VIDEO = 'WITH_VIDEO', + WITH_METADATA = 'WITH_METADATA' +} + +@DefaultScope(() => ({ + attributes: { + exclude: [ 'metadata' ] + } +})) +@Scopes(() => ({ + [ScopeNames.WITH_VIDEO]: { + include: [ + { + model: VideoModel.unscoped(), + required: true + } + ] + }, + [ScopeNames.WITH_METADATA]: { + attributes: { + include: [ 'metadata' ] + } + } +})) @Table({ tableName: 'videoFile', indexes: [ { - fields: [ 'videoId' ] + fields: [ 'videoId' ], + where: { + videoId: { + [Op.ne]: null + } + } }, + { + fields: [ 'videoStreamingPlaylistId' ], + where: { + videoStreamingPlaylistId: { + [Op.ne]: null + } + } + }, + { fields: [ 'infoHash' ] }, + { fields: [ 'videoId', 'resolution', 'fps' ], - unique: true + unique: true, + where: { + videoId: { + [Op.ne]: null + } + } + }, + { + fields: [ 'videoStreamingPlaylistId', 'resolution', 'fps' ], + unique: true, + where: { + videoStreamingPlaylistId: { + [Op.ne]: null + } + } } ] }) @@ -72,18 +134,38 @@ export class VideoFileModel extends Model { @Column fps: number + @AllowNull(true) + @Column(DataType.JSONB) + metadata: any + + @AllowNull(true) + @Column + metadataUrl: string + @ForeignKey(() => VideoModel) @Column videoId: number @BelongsTo(() => VideoModel, { foreignKey: { - allowNull: false + allowNull: true }, onDelete: 'CASCADE' }) Video: VideoModel + @ForeignKey(() => VideoStreamingPlaylistModel) + @Column + videoStreamingPlaylistId: number + + @BelongsTo(() => VideoStreamingPlaylistModel, { + foreignKey: { + allowNull: true + }, + onDelete: 'CASCADE' + }) + VideoStreamingPlaylist: VideoStreamingPlaylistModel + @HasMany(() => VideoRedundancyModel, { foreignKey: { allowNull: true @@ -93,35 +175,101 @@ export class VideoFileModel extends Model { }) RedundancyVideos: VideoRedundancyModel[] + static doesInfohashExistCached = memoizee(VideoFileModel.doesInfohashExist, { + promise: true, + max: MEMOIZE_LENGTH.INFO_HASH_EXISTS, + maxAge: MEMOIZE_TTL.INFO_HASH_EXISTS + }) + static doesInfohashExist (infoHash: string) { const query = 'SELECT 1 FROM "videoFile" WHERE "infoHash" = $infoHash LIMIT 1' const options = { - type: Sequelize.QueryTypes.SELECT, + type: QueryTypes.SELECT as QueryTypes.SELECT, bind: { infoHash }, raw: true } return VideoModel.sequelize.query(query, options) - .then(results => { - return results.length === 1 - }) + .then(results => results.length === 1) + } + + static async doesVideoExistForVideoFile (id: number, videoIdOrUUID: number | string) { + const videoFile = await VideoFileModel.loadWithVideoOrPlaylist(id, videoIdOrUUID) + + return !!videoFile + } + + static loadWithMetadata (id: number) { + return VideoFileModel.scope(ScopeNames.WITH_METADATA).findByPk(id) } static loadWithVideo (id: number) { + return VideoFileModel.scope(ScopeNames.WITH_VIDEO).findByPk(id) + } + + static loadWithVideoOrPlaylist (id: number, videoIdOrUUID: number | string) { + const whereVideo = validator.isUUID(videoIdOrUUID + '') + ? { uuid: videoIdOrUUID } + : { id: videoIdOrUUID } + const options = { + where: { + id + }, include: [ { model: VideoModel.unscoped(), - required: true + required: false, + where: whereVideo + }, + { + model: VideoStreamingPlaylistModel.unscoped(), + required: false, + include: [ + { + model: VideoModel.unscoped(), + required: true, + where: whereVideo + } + ] } ] } - return VideoFileModel.findById(id, options) + return VideoFileModel.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 async getStats () { - let totalLocalVideoFilesSize = await VideoFileModel.sum('size', { + static getStats () { + const query: FindOptions = { include: [ { attributes: [], @@ -131,18 +279,54 @@ export class VideoFileModel extends Model { } } ] - } as any) - // Sequelize could return null... - if (!totalLocalVideoFilesSize) totalLocalVideoFilesSize = 0 + } + + return VideoFileModel.aggregate('size', 'SUM', query) + .then(result => ({ + totalLocalVideoFilesSize: parseAggregateResult(result) + })) + } - return { - totalLocalVideoFilesSize + // 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 baseWhere = { + fps: videoFile.fps, + resolution: videoFile.resolution } + + if (mode === 'streaming-playlist') Object.assign(baseWhere, { videoStreamingPlaylistId: videoFile.videoStreamingPlaylistId }) + else Object.assign(baseWhere, { videoId: videoFile.videoId }) + + const element = await VideoFileModel.findOne({ where: baseWhere, transaction }) + if (!element) return videoFile.save({ transaction }) + + for (const k of Object.keys(videoFile.toJSON())) { + element[k] = videoFile[k] + } + + return element.save({ transaction }) + } + + getVideoOrStreamingPlaylist (this: MVideoFileVideo | MVideoFileStreamingPlaylistVideo): MVideo | MStreamingPlaylistVideo { + if (this.videoId) return (this as MVideoFileVideo).Video + + return (this as MVideoFileStreamingPlaylistVideo).VideoStreamingPlaylist + } + + isAudio () { + return !!MIMETYPES.AUDIO.EXT_MIMETYPE[this.extname] } - hasSameUniqueKeysThan (other: VideoFileModel) { + hasSameUniqueKeysThan (other: MVideoFile) { return this.fps === other.fps && this.resolution === other.resolution && - this.videoId === other.videoId + ( + (this.videoId !== null && this.videoId === other.videoId) || + (this.videoStreamingPlaylistId !== null && this.videoStreamingPlaylistId === other.videoStreamingPlaylistId) + ) } }