Search video channel handle/uri

[github/Chocobozzz/PeerTube.git] / server / lib / activitypub / actor.ts

diff --git a/server/lib/activitypub/actor.ts b/server/lib/activitypub/actor.ts
index 4c336f26ebb2a4418e5c5c18119664b7313629b6..22e1c9f1950059ba768613a99a78c150740297af 100644 (file)
--- a/server/lib/activitypub/actor.ts
+++ b/server/lib/activitypub/actor.ts
@@ -19,6 +19,8 @@ import { ActorModel } from '../../models/activitypub/actor'
 import { AvatarModel } from '../../models/avatar/avatar'
 import { ServerModel } from '../../models/server/server'
 import { VideoChannelModel } from '../../models/video/video-channel'
+import { JobQueue } from '../job-queue'
+import { getServerActor } from '../../helpers/utils'
 
 // Set account keys, this could be long so process after the account creation and do not block the client
 function setAsyncActorKeys (actor: ActorModel) {
@@ -38,10 +40,15 @@ async function getOrCreateActorAndServerAndModel (activityActor: string | Activi
   const actorUrl = getActorUrl(activityActor)
 
   let actor = await ActorModel.loadByUrl(actorUrl)
+  // Orphan actor (not associated to an account of channel) so recreate it
+  if (actor && (!actor.Account && !actor.VideoChannel)) {
+    await actor.destroy()
+    actor = null
+  }
 
   // We don't have this actor in our database, fetch it on remote
   if (!actor) {
-    const result = await fetchRemoteActor(actorUrl)
+    const { result } = await fetchRemoteActor(actorUrl)
     if (result === undefined) throw new Error('Cannot fetch remote actor.')
 
     // Create the attributed to actor
@@ -60,18 +67,16 @@ async function getOrCreateActorAndServerAndModel (activityActor: string | Activi
       }
     }
 
-    const options = {
-      arguments: [ result, ownerActor ],
-      errorMessage: 'Cannot save actor and server with many retries.'
-    }
-    actor = await retryTransactionWrapper(saveActorAndServerAndModelIfNotExist, options)
+    actor = await retryTransactionWrapper(saveActorAndServerAndModelIfNotExist, result, ownerActor)
   }
 
-  const options = {
-    arguments: [ actor ],
-    errorMessage: 'Cannot refresh actor if needed with many retries.'
-  }
-  return retryTransactionWrapper(refreshActorIfNeeded, options)
+  if (actor.Account) actor.Account.Actor = actor
+  if (actor.VideoChannel) actor.VideoChannel.Actor = actor
+
+  actor = await retryTransactionWrapper(refreshActorIfNeeded, actor)
+  if (!actor) throw new Error('Actor ' + actor.url + ' does not exist anymore.')
+
+  return actor
 }
 
 function buildActorInstance (type: ActivityPubActorType, url: string, preferredUsername: string, uuid?: string) {
@@ -169,6 +174,22 @@ async function fetchAvatarIfExists (actorJSON: ActivityPubActor) {
   return undefined
 }
 
+async function addFetchOutboxJob (actor: ActorModel) {
+  // Don't fetch ourselves
+  const serverActor = await getServerActor()
+  if (serverActor.id === actor.id) {
+    logger.error('Cannot fetch our own outbox!')
+    return undefined
+  }
+
+  const payload = {
+    uri: actor.outboxUrl,
+    type: 'activity' as 'activity'
+  }
+
+  return JobQueue.Instance.createJob({ type: 'activitypub-http-fetcher', payload })
+}
+
 export {
   getOrCreateActorAndServerAndModel,
   buildActorInstance,
@@ -176,7 +197,8 @@ export {
   fetchActorTotalItems,
   fetchAvatarIfExists,
   updateActorInstance,
-  updateActorAvatarInstance
+  updateActorAvatarInstance,
+  addFetchOutboxJob
 }
 
 // ---------------------------------------------------------------------------
@@ -233,6 +255,7 @@ function saveActorAndServerAndModelIfNotExist (
     } else if (actorCreated.type === 'Group') { // Video channel
       actorCreated.VideoChannel = await saveVideoChannel(actorCreated, result, ownerActor, t)
       actorCreated.VideoChannel.Actor = actorCreated
+      actorCreated.VideoChannel.Account = ownerActor.Account
     }
 
     return actorCreated
@@ -247,7 +270,7 @@ type FetchRemoteActorResult = {
   avatarName?: string
   attributedTo: ActivityPubAttributedTo[]
 }
-async function fetchRemoteActor (actorUrl: string): Promise<FetchRemoteActorResult> {
+async function fetchRemoteActor (actorUrl: string): Promise<{ statusCode?: number, result: FetchRemoteActorResult }> {
   const options = {
     uri: actorUrl,
     method: 'GET',
@@ -264,7 +287,7 @@ async function fetchRemoteActor (actorUrl: string): Promise<FetchRemoteActorResu
 
   if (isActorObjectValid(actorJSON) === false) {
     logger.debug('Remote actor JSON is not valid.', { actorJSON: actorJSON })
-    return undefined
+    return { result: undefined, statusCode: requestResult.response.statusCode }
   }
 
   const followersCount = await fetchActorTotalItems(actorJSON.followers)
@@ -290,12 +313,15 @@ async function fetchRemoteActor (actorUrl: string): Promise<FetchRemoteActorResu
 
   const name = actorJSON.name || actorJSON.preferredUsername
   return {
-    actor,
-    name,
-    avatarName,
-    summary: actorJSON.summary,
-    support: actorJSON.support,
-    attributedTo: actorJSON.attributedTo
+    statusCode: requestResult.response.statusCode,
+    result: {
+      actor,
+      name,
+      avatarName,
+      summary: actorJSON.summary,
+      support: actorJSON.support,
+      attributedTo: actorJSON.attributedTo
+    }
   }
 }
 
@@ -337,8 +363,15 @@ async function refreshActorIfNeeded (actor: ActorModel): Promise<ActorModel> {
   if (!actor.isOutdated()) return actor
 
   try {
-    const actorUrl = await getUrlFromWebfinger(actor.preferredUsername, actor.getHost())
-    const result = await fetchRemoteActor(actorUrl)
+    const actorUrl = await getUrlFromWebfinger(actor.preferredUsername + '@' + actor.getHost())
+    const { result, statusCode } = await fetchRemoteActor(actorUrl)
+
+    if (statusCode === 404) {
+      logger.info('Deleting actor %s because there is a 404 in refresh actor.', actor.url)
+      actor.Account ? actor.Account.destroy() : actor.VideoChannel.destroy()
+      return undefined
+    }
+
     if (result === undefined) {
       logger.warn('Cannot fetch remote actor in refresh actor.')
       return actor