X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Flib%2Factivitypub%2Fvideos.ts;h=dd02141eeac07f96eb0d5526e7cfbcadb6f44ad8;hb=156c50af3085468a47b8ae73fe8cfcae46b42398;hp=de22e358442f2c07e96748fb19e0c69d89db0b50;hpb=d4defe07d26013a75577b30608841fe3f8334308;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/lib/activitypub/videos.ts b/server/lib/activitypub/videos.ts
index de22e3584..dd02141ee 100644
--- a/server/lib/activitypub/videos.ts
+++ b/server/lib/activitypub/videos.ts
@@ -107,7 +107,7 @@ function getOrCreateVideoChannelFromVideoObject (videoObject: VideoTorrentObject
   const channel = videoObject.attributedTo.find(a => a.type === 'Group')
   if (!channel) throw new Error('Cannot find associated video channel to video ' + videoObject.url)
 
-  return getOrCreateActorAndServerAndModel(channel.id)
+  return getOrCreateActorAndServerAndModel(channel.id, 'all')
 }
 
 type SyncParam = {
@@ -176,7 +176,7 @@ async function getOrCreateVideoAndAccountAndChannel (options: {
       syncParam,
       refreshViews
     }
-    const p = retryTransactionWrapper(refreshVideoIfNeeded, refreshOptions)
+    const p = refreshVideoIfNeeded(refreshOptions)
     if (syncParam.refreshVideo === true) videoFromDatabase = await p
 
     return { video: videoFromDatabase }
@@ -205,7 +205,7 @@ async function updateVideoFromAP (options: {
   let videoFieldsSave: any
 
   try {
-    const updatedVideo: VideoModel = await sequelizeTypescript.transaction(async t => {
+    await sequelizeTypescript.transaction(async t => {
       const sequelizeOptions = {
         transaction: t
       }
@@ -230,6 +230,7 @@ async function updateVideoFromAP (options: {
       options.video.set('support', videoData.support)
       options.video.set('nsfw', videoData.nsfw)
       options.video.set('commentsEnabled', videoData.commentsEnabled)
+      options.video.set('downloadingEnabled', videoData.downloadingEnabled)
       options.video.set('waitTranscoding', videoData.waitTranscoding)
       options.video.set('state', videoData.state)
       options.video.set('duration', videoData.duration)
@@ -245,34 +246,44 @@ async function updateVideoFromAP (options: {
       generateThumbnailFromUrl(options.video, options.videoObject.icon)
         .catch(err => logger.warn('Cannot generate thumbnail of %s.', options.videoObject.id, { err }))
 
-      // Remove old video files
-      const videoFileDestroyTasks: Bluebird<void>[] = []
-      for (const videoFile of options.video.VideoFiles) {
-        videoFileDestroyTasks.push(videoFile.destroy(sequelizeOptions))
-      }
-      await Promise.all(videoFileDestroyTasks)
+      {
+        const videoFileAttributes = videoFileActivityUrlToDBAttributes(options.video, options.videoObject)
+        const newVideoFiles = videoFileAttributes.map(a => new VideoFileModel(a))
+
+        // Remove video files that do not exist anymore
+        const destroyTasks = options.video.VideoFiles
+                                    .filter(f => !newVideoFiles.find(newFile => newFile.hasSameUniqueKeysThan(f)))
+                                    .map(f => f.destroy(sequelizeOptions))
+        await Promise.all(destroyTasks)
+
+        // Update or add other one
+        const upsertTasks = videoFileAttributes.map(a => {
+          return VideoFileModel.upsert<VideoFileModel>(a, { returning: true, transaction: t })
+            .then(([ file ]) => file)
+        })
 
-      const videoFileAttributes = videoFileActivityUrlToDBAttributes(options.video, options.videoObject)
-      const tasks = videoFileAttributes.map(f => VideoFileModel.create(f, sequelizeOptions))
-      await Promise.all(tasks)
+        options.video.VideoFiles = await Promise.all(upsertTasks)
+      }
 
-      // Update Tags
-      const tags = options.videoObject.tag.map(tag => tag.name)
-      const tagInstances = await TagModel.findOrCreateTags(tags, t)
-      await options.video.$set('Tags', tagInstances, sequelizeOptions)
+      {
+        // Update Tags
+        const tags = options.videoObject.tag.map(tag => tag.name)
+        const tagInstances = await TagModel.findOrCreateTags(tags, t)
+        await options.video.$set('Tags', tagInstances, sequelizeOptions)
+      }
 
-      // Update captions
-      await VideoCaptionModel.deleteAllCaptionsOfRemoteVideo(options.video.id, t)
+      {
+        // Update captions
+        await VideoCaptionModel.deleteAllCaptionsOfRemoteVideo(options.video.id, t)
 
-      const videoCaptionsPromises = options.videoObject.subtitleLanguage.map(c => {
-        return VideoCaptionModel.insertOrReplaceLanguage(options.video.id, c.identifier, t)
-      })
-      await Promise.all(videoCaptionsPromises)
+        const videoCaptionsPromises = options.videoObject.subtitleLanguage.map(c => {
+          return VideoCaptionModel.insertOrReplaceLanguage(options.video.id, c.identifier, t)
+        })
+        options.video.VideoCaptions = await Promise.all(videoCaptionsPromises)
+      }
     })
 
     logger.info('Remote video with uuid %s updated', options.videoObject.uuid)
-
-    return updatedVideo
   } catch (err) {
     if (options.video !== undefined && videoFieldsSave !== undefined) {
       resetSequelizeInstance(options.video, videoFieldsSave)
@@ -354,21 +365,23 @@ async function refreshVideoIfNeeded (options: {
   syncParam: SyncParam,
   refreshViews: boolean
 }): Promise<VideoModel> {
+  if (!options.video.isOutdated()) return options.video
+
   // We need more attributes if the argument video was fetched with not enough joints
   const video = options.fetchedType === 'all' ? options.video : await VideoModel.loadByUrlAndPopulateAccount(options.video.url)
 
-  if (!video.isOutdated()) return video
-
   try {
     const { response, videoObject } = await fetchRemoteVideo(video.url)
     if (response.statusCode === 404) {
+      logger.info('Cannot refresh remote video %s: video does not exist anymore. Deleting it.', video.url)
+
       // Video does not exist anymore
       await video.destroy()
       return undefined
     }
 
     if (videoObject === undefined) {
-      logger.warn('Cannot refresh remote video: invalid body.')
+      logger.warn('Cannot refresh remote video %s: invalid body.', video.url)
       return video
     }
 
@@ -382,10 +395,12 @@ async function refreshVideoIfNeeded (options: {
       channel: channelActor.VideoChannel,
       updateViews: options.refreshViews
     }
-    await updateVideoFromAP(updateOptions)
+    await retryTransactionWrapper(updateVideoFromAP, updateOptions)
     await syncVideoExternalAttributes(video, videoObject, options.syncParam)
+
+    return video
   } catch (err) {
-    logger.warn('Cannot refresh video.', { err })
+    logger.warn('Cannot refresh video %s.', options.video.url, { err })
     return video
   }
 }
@@ -427,6 +442,7 @@ async function videoActivityObjectToDBAttributes (
     support,
     nsfw: videoObject.sensitive,
     commentsEnabled: videoObject.commentsEnabled,
+    downloadingEnabled: videoObject.downloadingEnabled,
     waitTranscoding: videoObject.waitTranscoding,
     state: videoObject.state,
     channelId: videoChannel.id,
@@ -443,11 +459,11 @@ async function videoActivityObjectToDBAttributes (
   }
 }
 
-function videoFileActivityUrlToDBAttributes (videoCreated: VideoModel, videoObject: VideoTorrentObject) {
+function videoFileActivityUrlToDBAttributes (video: VideoModel, videoObject: VideoTorrentObject) {
   const fileUrls = videoObject.url.filter(u => isActivityVideoUrlObject(u)) as ActivityVideoUrlObject[]
 
   if (fileUrls.length === 0) {
-    throw new Error('Cannot find video files for ' + videoCreated.url)
+    throw new Error('Cannot find video files for ' + video.url)
   }
 
   const attributes: VideoFileModel[] = []
@@ -469,8 +485,8 @@ function videoFileActivityUrlToDBAttributes (videoCreated: VideoModel, videoObje
       infoHash: parsed.infoHash,
       resolution: fileUrl.height,
       size: fileUrl.size,
-      videoId: videoCreated.id,
-      fps: fileUrl.fps
+      videoId: video.id,
+      fps: fileUrl.fps || -1
     } as VideoFileModel
     attributes.push(attribute)
   }