X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Flib%2Factivitypub%2Factor.ts;h=712de7d0d9b5ff09f08a3e434a6753f01e54a530;hb=7acee6f18aac99e359360fc4f2362d5405135a79;hp=e590dc72d02069107efb1f0b41c4ec13a6c79d05;hpb=da854ddd502cd70685ef779c673b9e63757b8aa0;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/lib/activitypub/actor.ts b/server/lib/activitypub/actor.ts
index e590dc72d..712de7d0d 100644
--- a/server/lib/activitypub/actor.ts
+++ b/server/lib/activitypub/actor.ts
@@ -1,16 +1,21 @@
 import * as Bluebird from 'bluebird'
+import { join } from 'path'
 import { Transaction } from 'sequelize'
 import * as url from 'url'
+import * as uuidv4 from 'uuid/v4'
 import { ActivityPubActor, ActivityPubActorType } from '../../../shared/models/activitypub'
 import { ActivityPubAttributedTo } from '../../../shared/models/activitypub/objects'
-import { isRemoteActorValid } from '../../helpers/custom-validators/activitypub/actor'
-import { retryTransactionWrapper } from '../../helpers/database-utils'
+import { isActorObjectValid } from '../../helpers/custom-validators/activitypub/actor'
+import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
+import { retryTransactionWrapper, updateInstanceWithAnother } from '../../helpers/database-utils'
 import { logger } from '../../helpers/logger'
 import { createPrivateAndPublicKeys } from '../../helpers/peertube-crypto'
-import { doRequest } from '../../helpers/requests'
-import { CONFIG, sequelizeTypescript } from '../../initializers'
+import { doRequest, doRequestAndSaveToFile } from '../../helpers/requests'
+import { getUrlFromWebfinger } from '../../helpers/webfinger'
+import { AVATAR_MIMETYPE_EXT, CONFIG, sequelizeTypescript } from '../../initializers'
 import { AccountModel } from '../../models/account/account'
 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'
 
@@ -59,9 +64,120 @@ async function getOrCreateActorAndServerAndModel (actorUrl: string, recurseIfNee
     actor = await retryTransactionWrapper(saveActorAndServerAndModelIfNotExist, options)
   }
 
-  return actor
+  const options = {
+    arguments: [ actor ],
+    errorMessage: 'Cannot refresh actor if needed with many retries.'
+  }
+  return retryTransactionWrapper(refreshActorIfNeeded, options)
 }
 
+function buildActorInstance (type: ActivityPubActorType, url: string, preferredUsername: string, uuid?: string) {
+  return new ActorModel({
+    type,
+    url,
+    preferredUsername,
+    uuid,
+    publicKey: null,
+    privateKey: null,
+    followersCount: 0,
+    followingCount: 0,
+    inboxUrl: url + '/inbox',
+    outboxUrl: url + '/outbox',
+    sharedInboxUrl: CONFIG.WEBSERVER.URL + '/inbox',
+    followersUrl: url + '/followers',
+    followingUrl: url + '/following'
+  })
+}
+
+async function updateActorInstance (actorInstance: ActorModel, attributes: ActivityPubActor) {
+  const followersCount = await fetchActorTotalItems(attributes.followers)
+  const followingCount = await fetchActorTotalItems(attributes.following)
+
+  actorInstance.set('type', attributes.type)
+  actorInstance.set('uuid', attributes.uuid)
+  actorInstance.set('preferredUsername', attributes.preferredUsername)
+  actorInstance.set('url', attributes.id)
+  actorInstance.set('publicKey', attributes.publicKey.publicKeyPem)
+  actorInstance.set('followersCount', followersCount)
+  actorInstance.set('followingCount', followingCount)
+  actorInstance.set('inboxUrl', attributes.inbox)
+  actorInstance.set('outboxUrl', attributes.outbox)
+  actorInstance.set('sharedInboxUrl', attributes.endpoints.sharedInbox)
+  actorInstance.set('followersUrl', attributes.followers)
+  actorInstance.set('followingUrl', attributes.following)
+}
+
+async function updateActorAvatarInstance (actorInstance: ActorModel, avatarName: string, t: Transaction) {
+  if (avatarName !== undefined) {
+    if (actorInstance.avatarId) {
+      try {
+        await actorInstance.Avatar.destroy({ transaction: t })
+      } catch (err) {
+        logger.error('Cannot remove old avatar of actor %s.', actorInstance.url, err)
+      }
+    }
+
+    const avatar = await AvatarModel.create({
+      filename: avatarName
+    }, { transaction: t })
+
+    actorInstance.set('avatarId', avatar.id)
+    actorInstance.Avatar = avatar
+  }
+
+  return actorInstance
+}
+
+async function fetchActorTotalItems (url: string) {
+  const options = {
+    uri: url,
+    method: 'GET',
+    json: true,
+    activityPub: true
+  }
+
+  try {
+    const { body } = await doRequest(options)
+    return body.totalItems ? body.totalItems : 0
+  } catch (err) {
+    logger.warn('Cannot fetch remote actor count %s.', url, err)
+    return 0
+  }
+}
+
+async function fetchAvatarIfExists (actorJSON: ActivityPubActor) {
+  if (
+    actorJSON.icon && actorJSON.icon.type === 'Image' && AVATAR_MIMETYPE_EXT[actorJSON.icon.mediaType] !== undefined &&
+    isActivityPubUrlValid(actorJSON.icon.url)
+  ) {
+    const extension = AVATAR_MIMETYPE_EXT[actorJSON.icon.mediaType]
+
+    const avatarName = uuidv4() + extension
+    const destPath = join(CONFIG.STORAGE.AVATARS_DIR, avatarName)
+
+    await doRequestAndSaveToFile({
+      method: 'GET',
+      uri: actorJSON.icon.url
+    }, destPath)
+
+    return avatarName
+  }
+
+  return undefined
+}
+
+export {
+  getOrCreateActorAndServerAndModel,
+  buildActorInstance,
+  setAsyncActorKeys,
+  fetchActorTotalItems,
+  fetchAvatarIfExists,
+  updateActorInstance,
+  updateActorAvatarInstance
+}
+
+// ---------------------------------------------------------------------------
+
 function saveActorAndServerAndModelIfNotExist (
   result: FetchRemoteActorResult,
   ownerActor?: ActorModel,
@@ -90,9 +206,23 @@ function saveActorAndServerAndModelIfNotExist (
     // Save our new account in database
     actor.set('serverId', server.id)
 
+    // Avatar?
+    if (result.avatarName) {
+      const avatar = await AvatarModel.create({
+        filename: result.avatarName
+      }, { transaction: t })
+      actor.set('avatarId', avatar.id)
+    }
+
     // Force the actor creation, sometimes Sequelize skips the save() when it thinks the instance already exists
     // (which could be false in a retried query)
-    const actorCreated = await ActorModel.create(actor.toJSON(), { transaction: t })
+    const [ actorCreated ] = await ActorModel.findOrCreate({
+      defaults: actor.toJSON(),
+      where: {
+        url: actor.url
+      },
+      transaction: t
+    })
 
     if (actorCreated.type === 'Person' || actorCreated.type === 'Application') {
       const account = await saveAccount(actorCreated, result, t)
@@ -112,6 +242,7 @@ type FetchRemoteActorResult = {
   actor: ActorModel
   name: string
   summary: string
+  avatarName?: string
   attributedTo: ActivityPubAttributedTo[]
 }
 async function fetchRemoteActor (actorUrl: string): Promise<FetchRemoteActorResult> {
@@ -125,9 +256,9 @@ async function fetchRemoteActor (actorUrl: string): Promise<FetchRemoteActorResu
   logger.info('Fetching remote actor %s.', actorUrl)
 
   const requestResult = await doRequest(options)
-  const actorJSON: ActivityPubActor = requestResult.body
+  const actorJSON: ActivityPubActor = normalizeActor(requestResult.body)
 
-  if (isRemoteActorValid(actorJSON) === false) {
+  if (isActorObjectValid(actorJSON) === false) {
     logger.debug('Remote actor JSON is not valid.', { actorJSON: actorJSON })
     return undefined
   }
@@ -151,78 +282,95 @@ async function fetchRemoteActor (actorUrl: string): Promise<FetchRemoteActorResu
     followingUrl: actorJSON.following
   })
 
+  const avatarName = await fetchAvatarIfExists(actorJSON)
+
   const name = actorJSON.name || actorJSON.preferredUsername
   return {
     actor,
     name,
+    avatarName,
     summary: actorJSON.summary,
     attributedTo: actorJSON.attributedTo
   }
 }
 
-function buildActorInstance (type: ActivityPubActorType, url: string, preferredUsername: string, uuid?: string) {
-  return new ActorModel({
-    type,
-    url,
-    preferredUsername,
-    uuid,
-    publicKey: null,
-    privateKey: null,
-    followersCount: 0,
-    followingCount: 0,
-    inboxUrl: url + '/inbox',
-    outboxUrl: url + '/outbox',
-    sharedInboxUrl: CONFIG.WEBSERVER.URL + '/inbox',
-    followersUrl: url + '/followers',
-    followingUrl: url + '/following'
+async function saveAccount (actor: ActorModel, result: FetchRemoteActorResult, t: Transaction) {
+  const [ accountCreated ] = await AccountModel.findOrCreate({
+    defaults: {
+      name: result.name,
+      actorId: actor.id
+    },
+    where: {
+      actorId: actor.id
+    },
+    transaction: t
   })
-}
 
-export {
-  getOrCreateActorAndServerAndModel,
-  saveActorAndServerAndModelIfNotExist,
-  fetchRemoteActor,
-  buildActorInstance,
-  setAsyncActorKeys
+  return accountCreated
 }
 
-// ---------------------------------------------------------------------------
+async function saveVideoChannel (actor: ActorModel, result: FetchRemoteActorResult, ownerActor: ActorModel, t: Transaction) {
+  const [ videoChannelCreated ] = await VideoChannelModel.findOrCreate({
+    defaults: {
+      name: result.name,
+      description: result.summary,
+      actorId: actor.id,
+      accountId: ownerActor.Account.id
+    },
+    where: {
+      actorId: actor.id
+    },
+    transaction: t
+  })
 
-async function fetchActorTotalItems (url: string) {
-  const options = {
-    uri: url,
-    method: 'GET',
-    json: true,
-    activityPub: true
-  }
+  return videoChannelCreated
+}
+
+async function refreshActorIfNeeded (actor: ActorModel) {
+  if (!actor.isOutdated()) return actor
 
-  let requestResult
   try {
-    requestResult = await doRequest(options)
-  } catch (err) {
-    logger.warn('Cannot fetch remote actor count %s.', url, err)
-    return undefined
-  }
+    const actorUrl = await getUrlFromWebfinger(actor.preferredUsername, actor.getHost())
+    const result = await fetchRemoteActor(actorUrl)
+    if (result === undefined) {
+      logger.warn('Cannot fetch remote actor in refresh actor.')
+      return actor
+    }
 
-  return requestResult.totalItems ? requestResult.totalItems : 0
-}
+    return sequelizeTypescript.transaction(async t => {
+      updateInstanceWithAnother(actor, result.actor)
 
-function saveAccount (actor: ActorModel, result: FetchRemoteActorResult, t: Transaction) {
-  const account = new AccountModel({
-    name: result.name,
-    actorId: actor.id
-  })
+      if (result.avatarName !== undefined) {
+        await updateActorAvatarInstance(actor, result.avatarName, t)
+      }
+
+      // Force update
+      actor.setDataValue('updatedAt', new Date())
+      await actor.save({ transaction: t })
+
+      if (actor.Account) {
+        await actor.save({ transaction: t })
+
+        actor.Account.set('name', result.name)
+        await actor.Account.save({ transaction: t })
+      } else if (actor.VideoChannel) {
+        await actor.save({ transaction: t })
+
+        actor.VideoChannel.set('name', result.name)
+        await actor.VideoChannel.save({ transaction: t })
+      }
 
-  return account.save({ transaction: t })
+      return actor
+    })
+  } catch (err) {
+    logger.warn('Cannot refresh actor.', err)
+    return actor
+  }
 }
 
-async function saveVideoChannel (actor: ActorModel, result: FetchRemoteActorResult, ownerActor: ActorModel, t: Transaction) {
-  const videoChannel = new VideoChannelModel({
-    name: result.name,
-    description: result.summary,
-    actorId: actor.id,
-    accountId: ownerActor.Account.id
-  })
+function normalizeActor (actor: any) {
+  if (actor && actor.url && typeof actor.url === 'string') return actor
 
-  return videoChannel.save({ transaction: t })
+  actor.url = actor.url.href || actor.url.url
+  return actor
 }