X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fmodels%2Fvideo%2Fvideo-file.ts;h=201f0c0f1410d25201a632f05f47e58a0a048c04;hb=7b81edc854902a536083298472bf92bb6726edcf;hp=ead7f3e034d43315e2a662523bed24d72a068927;hpb=f0adb2701c1cf404ff63095f71e542bfe6d025ae;p=github%2FChocobozzz%2FPeerTube.git diff --git a/server/models/video/video-file.ts b/server/models/video/video-file.ts index ead7f3e03..201f0c0f1 100644 --- a/server/models/video/video-file.ts +++ b/server/models/video/video-file.ts @@ -1,89 +1,332 @@ -import * as Sequelize from 'sequelize' -import { values } from 'lodash' - -import { CONSTRAINTS_FIELDS } from '../../initializers' import { + AllowNull, + BelongsTo, + Column, + CreatedAt, + DataType, + Default, + ForeignKey, + HasMany, + Is, + Model, + Table, + UpdatedAt, + Scopes, + DefaultScope +} from 'sequelize-typescript' +import { + isVideoFileExtnameValid, + isVideoFileInfoHashValid, isVideoFileResolutionValid, isVideoFileSizeValid, - isVideoFileInfoHashValid -} from '../../helpers' - -import { addMethodsToModel } from '../utils' -import { - VideoFileInstance, - VideoFileAttributes -} from './video-file-interface' + isVideoFPSResolutionValid +} from '../../helpers/custom-validators/videos' +import { parseAggregateResult, throwIfNotValid } from '../utils' +import { VideoModel } from './video' +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' -let VideoFile: Sequelize.Model +export enum ScopeNames { + WITH_VIDEO = 'WITH_VIDEO', + WITH_METADATA = 'WITH_METADATA' +} -export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) { - VideoFile = sequelize.define('VideoFile', +@DefaultScope(() => ({ + attributes: { + exclude: [ 'metadata' ] + } +})) +@Scopes(() => ({ + [ScopeNames.WITH_VIDEO]: { + include: [ + { + model: VideoModel.unscoped(), + required: true + } + ] + }, + [ScopeNames.WITH_METADATA]: { + attributes: { + include: [ 'metadata' ] + } + } +})) +@Table({ + tableName: 'videoFile', + indexes: [ { - resolution: { - type: DataTypes.INTEGER, - allowNull: false, - validate: { - resolutionValid: value => { - const res = isVideoFileResolutionValid(value) - if (res === false) throw new Error('Video file resolution is not valid.') - } + fields: [ 'videoId' ], + where: { + videoId: { + [Op.ne]: null } - }, - size: { - type: DataTypes.BIGINT, - allowNull: false, - validate: { - sizeValid: value => { - const res = isVideoFileSizeValid(value) - if (res === false) throw new Error('Video file size is not valid.') - } + } + }, + { + fields: [ 'videoStreamingPlaylistId' ], + where: { + videoStreamingPlaylistId: { + [Op.ne]: null } - }, - extname: { - type: DataTypes.ENUM(values(CONSTRAINTS_FIELDS.VIDEOS.EXTNAME)), - allowNull: false - }, - infoHash: { - type: DataTypes.STRING, - allowNull: false, - validate: { - infoHashValid: value => { - const res = isVideoFileInfoHashValid(value) - if (res === false) throw new Error('Video file info hash is not valid.') - } + } + }, + + { + fields: [ 'infoHash' ] + }, + + { + fields: [ 'videoId', 'resolution', 'fps' ], + unique: true, + where: { + videoId: { + [Op.ne]: null } } }, { - indexes: [ - { - fields: [ 'videoId' ] - }, - { - fields: [ 'infoHash' ] + fields: [ 'videoStreamingPlaylistId', 'resolution', 'fps' ], + unique: true, + where: { + videoStreamingPlaylistId: { + [Op.ne]: null } - ] + } } - ) - - const classMethods = [ - associate ] - addMethodsToModel(VideoFile, classMethods) +}) +export class VideoFileModel extends Model { + @CreatedAt + createdAt: Date - return VideoFile -} + @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) + @Is('VideoFileExtname', value => throwIfNotValid(value, isVideoFileExtnameValid, 'extname')) + @Column + extname: string + + @AllowNull(false) + @Is('VideoFileInfohash', value => throwIfNotValid(value, isVideoFileInfoHashValid, 'info hash')) + @Column + infoHash: string + + @AllowNull(false) + @Default(-1) + @Is('VideoFileFPS', value => throwIfNotValid(value, isVideoFPSResolutionValid, 'fps')) + @Column + fps: number -// ------------------------------ STATICS ------------------------------ + @AllowNull(true) + @Column(DataType.JSONB) + metadata: any -function associate (models) { - VideoFile.belongsTo(models.Video, { + @AllowNull(true) + @Column + metadataUrl: string + + @ForeignKey(() => VideoModel) + @Column + videoId: number + + @BelongsTo(() => VideoModel, { foreignKey: { - name: 'videoId', - allowNull: false + allowNull: true }, onDelete: 'CASCADE' }) -} + Video: VideoModel -// ------------------------------ METHODS ------------------------------ + @ForeignKey(() => VideoStreamingPlaylistModel) + @Column + videoStreamingPlaylistId: number + + @BelongsTo(() => VideoStreamingPlaylistModel, { + foreignKey: { + allowNull: true + }, + onDelete: 'CASCADE' + }) + VideoStreamingPlaylist: VideoStreamingPlaylistModel + + @HasMany(() => VideoRedundancyModel, { + foreignKey: { + allowNull: true + }, + onDelete: 'CASCADE', + hooks: true + }) + 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: QueryTypes.SELECT as QueryTypes.SELECT, + bind: { infoHash }, + raw: true + } + + return VideoModel.sequelize.query(query, options) + .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: false, + where: whereVideo + }, + { + model: VideoStreamingPlaylistModel.unscoped(), + required: false, + include: [ + { + model: VideoModel.unscoped(), + required: true, + where: whereVideo + } + ] + } + ] + } + + 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 getStats () { + const query: FindOptions = { + include: [ + { + attributes: [], + model: VideoModel.unscoped(), + where: { + remote: false + } + } + ] + } + + return VideoFileModel.aggregate('size', 'SUM', query) + .then(result => ({ + totalLocalVideoFilesSize: parseAggregateResult(result) + })) + } + + // 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: MVideoFile) { + return this.fps === other.fps && + this.resolution === other.resolution && + ( + (this.videoId !== null && this.videoId === other.videoId) || + (this.videoStreamingPlaylistId !== null && this.videoStreamingPlaylistId === other.videoStreamingPlaylistId) + ) + } +}