X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Flib%2Factivitypub%2Fplaylists%2Fcreate-update.ts;h=9339e8ea433d904f5c1467a0ebd0e8ba3dd59d7a;hb=cea2fd90ddb3bf57c2fed77128938d12d4c2be6b;hp=fcfcc41a28fcd0ecd8546659d64899b8f38487c0;hpb=136d7efde798d3dc0ec0dd18aac674365f7d162e;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/lib/activitypub/playlists/create-update.ts b/server/lib/activitypub/playlists/create-update.ts
index fcfcc41a2..9339e8ea4 100644
--- a/server/lib/activitypub/playlists/create-update.ts
+++ b/server/lib/activitypub/playlists/create-update.ts
@@ -1,14 +1,17 @@
+import { map } from 'bluebird'
 import { isArray } from '@server/helpers/custom-validators/misc'
+import { retryTransactionWrapper } from '@server/helpers/database-utils'
 import { logger, loggerTagsFactory } from '@server/helpers/logger'
 import { CRAWL_REQUEST_CONCURRENCY } from '@server/initializers/constants'
 import { sequelizeTypescript } from '@server/initializers/database'
-import { createPlaylistMiniatureFromUrl } from '@server/lib/thumbnail'
+import { updatePlaylistMiniatureFromUrl } from '@server/lib/thumbnail'
 import { VideoPlaylistModel } from '@server/models/video/video-playlist'
 import { VideoPlaylistElementModel } from '@server/models/video/video-playlist-element'
 import { FilteredModelAttributes } from '@server/types'
-import { MAccountDefault, MAccountId, MVideoPlaylist, MVideoPlaylistFull } from '@server/types/models'
-import { AttributesOnly } from '@shared/core-utils'
+import { MThumbnail, MVideoPlaylist, MVideoPlaylistFull, MVideoPlaylistVideosLength } from '@server/types/models'
 import { PlaylistObject } from '@shared/models'
+import { AttributesOnly } from '@shared/typescript-utils'
+import { getAPId } from '../activity'
 import { getOrCreateAPActor } from '../actors'
 import { crawlCollectionPage } from '../crawl'
 import { getOrCreateAPVideo } from '../videos'
@@ -19,12 +22,10 @@ import {
   playlistObjectToDBAttributes
 } from './shared'
 
-import Bluebird = require('bluebird')
-
 const lTags = loggerTagsFactory('ap', 'video-playlist')
 
-async function createAccountPlaylists (playlistUrls: string[], account: MAccountDefault) {
-  await Bluebird.map(playlistUrls, async playlistUrl => {
+async function createAccountPlaylists (playlistUrls: string[]) {
+  await map(playlistUrls, async playlistUrl => {
     try {
       const exists = await VideoPlaylistModel.doesPlaylistExist(playlistUrl)
       if (exists === true) return
@@ -35,32 +36,31 @@ async function createAccountPlaylists (playlistUrls: string[], account: MAccount
         throw new Error(`Cannot refresh remote playlist ${playlistUrl}: invalid body.`)
       }
 
-      return createOrUpdateVideoPlaylist(playlistObject, account, playlistObject.to)
+      return createOrUpdateVideoPlaylist(playlistObject)
     } catch (err) {
       logger.warn('Cannot add playlist element %s.', playlistUrl, { err, ...lTags(playlistUrl) })
     }
   }, { concurrency: CRAWL_REQUEST_CONCURRENCY })
 }
 
-async function createOrUpdateVideoPlaylist (playlistObject: PlaylistObject, byAccount: MAccountId, to: string[]) {
-  const playlistAttributes = playlistObjectToDBAttributes(playlistObject, byAccount, to)
+async function createOrUpdateVideoPlaylist (playlistObject: PlaylistObject, to?: string[]) {
+  const playlistAttributes = playlistObjectToDBAttributes(playlistObject, to || playlistObject.to)
 
-  await setVideoChannelIfNeeded(playlistObject, playlistAttributes)
+  await setVideoChannel(playlistObject, playlistAttributes)
 
-  const [ upsertPlaylist ] = await VideoPlaylistModel.upsert<MVideoPlaylist>(playlistAttributes, { returning: true })
+  const [ upsertPlaylist ] = await VideoPlaylistModel.upsert<MVideoPlaylistVideosLength>(playlistAttributes, { returning: true })
 
   const playlistElementUrls = await fetchElementUrls(playlistObject)
 
   // Refetch playlist from DB since elements fetching could be long in time
   const playlist = await VideoPlaylistModel.loadWithAccountAndChannel(upsertPlaylist.id, null)
 
-  try {
-    await updatePlaylistThumbnail(playlistObject, playlist)
-  } catch (err) {
-    logger.warn('Cannot update thumbnail of %s.', playlistObject.id, { err, ...lTags(playlistObject.id, playlist.uuid, playlist.url) })
-  }
+  await updatePlaylistThumbnail(playlistObject, playlist)
+
+  const elementsLength = await rebuildVideoPlaylistElements(playlistElementUrls, playlist)
+  playlist.setVideosLength(elementsLength)
 
-  return rebuildVideoPlaylistElements(playlistElementUrls, playlist)
+  return playlist
 }
 
 // ---------------------------------------------------------------------------
@@ -72,10 +72,12 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function setVideoChannelIfNeeded (playlistObject: PlaylistObject, playlistAttributes: AttributesOnly<VideoPlaylistModel>) {
-  if (!isArray(playlistObject.attributedTo) || playlistObject.attributedTo.length !== 1) return
+async function setVideoChannel (playlistObject: PlaylistObject, playlistAttributes: AttributesOnly<VideoPlaylistModel>) {
+  if (!isArray(playlistObject.attributedTo) || playlistObject.attributedTo.length !== 1) {
+    throw new Error('Not attributed to for playlist object ' + getAPId(playlistObject))
+  }
 
-  const actor = await getOrCreateAPActor(playlistObject.attributedTo[0])
+  const actor = await getOrCreateAPActor(playlistObject.attributedTo[0], 'all')
 
   if (!actor.VideoChannel) {
     logger.warn('Playlist "attributedTo" %s is not a video channel.', playlistObject.id, { playlistObject, ...lTags(playlistObject.id) })
@@ -83,6 +85,7 @@ async function setVideoChannelIfNeeded (playlistObject: PlaylistObject, playlist
   }
 
   playlistAttributes.videoChannelId = actor.VideoChannel.id
+  playlistAttributes.ownerAccountId = actor.VideoChannel.Account.id
 }
 
 async function fetchElementUrls (playlistObject: PlaylistObject) {
@@ -98,8 +101,16 @@ async function fetchElementUrls (playlistObject: PlaylistObject) {
 
 async function updatePlaylistThumbnail (playlistObject: PlaylistObject, playlist: MVideoPlaylistFull) {
   if (playlistObject.icon) {
-    const thumbnailModel = await createPlaylistMiniatureFromUrl({ downloadUrl: playlistObject.icon.url, playlist })
-    await playlist.setAndSaveThumbnail(thumbnailModel, undefined)
+    let thumbnailModel: MThumbnail
+
+    try {
+      thumbnailModel = await updatePlaylistMiniatureFromUrl({ downloadUrl: playlistObject.icon.url, playlist })
+      await playlist.setAndSaveThumbnail(thumbnailModel, undefined)
+    } catch (err) {
+      logger.warn('Cannot set thumbnail of %s.', playlistObject.id, { err, ...lTags(playlistObject.id, playlist.uuid, playlist.url) })
+
+      if (thumbnailModel) await thumbnailModel.removeThumbnail()
+    }
 
     return
   }
@@ -114,23 +125,23 @@ async function updatePlaylistThumbnail (playlistObject: PlaylistObject, playlist
 async function rebuildVideoPlaylistElements (elementUrls: string[], playlist: MVideoPlaylist) {
   const elementsToCreate = await buildElementsDBAttributes(elementUrls, playlist)
 
-  await sequelizeTypescript.transaction(async t => {
+  await retryTransactionWrapper(() => sequelizeTypescript.transaction(async t => {
     await VideoPlaylistElementModel.deleteAllOf(playlist.id, t)
 
     for (const element of elementsToCreate) {
       await VideoPlaylistElementModel.create(element, { transaction: t })
     }
-  })
+  }))
 
   logger.info('Rebuilt playlist %s with %s elements.', playlist.url, elementsToCreate.length, lTags(playlist.uuid, playlist.url))
 
-  return undefined
+  return elementsToCreate.length
 }
 
 async function buildElementsDBAttributes (elementUrls: string[], playlist: MVideoPlaylist) {
   const elementsToCreate: FilteredModelAttributes<VideoPlaylistElementModel>[] = []
 
-  await Bluebird.map(elementUrls, async elementUrl => {
+  await map(elementUrls, async elementUrl => {
     try {
       const { elementObject } = await fetchRemotePlaylistElement(elementUrl)