constructor (private hooks: HooksService) { }
async ngOnInit () {
- this.pluginMetadata = await this.hooks.wrapFunResult(
- this.buildPluginMetadata.bind(this),
- { video: this.video },
+ this.pluginMetadata = await this.hooks.wrapObject(
+ this.pluginMetadata,
'video-watch',
- 'filter:video-watch.video-plugin-metadata.result'
+ 'filter:video-watch.video-plugin-metadata.result',
+ { video: this.video }
)
}
return this.video.tags
}
-
- // Used for plugin hooks
- private buildPluginMetadata (_options: {
- video: VideoDetails
- }): PluginMetadata[] {
- return []
- }
}
return this.pluginService.runHook(hookResultName, result, params)
}
- async wrapFunResult <P, R, H extends ClientFilterHookName>
- (fun: RawFunction<P, R>, params: P, scope: PluginClientScope, hookResultName: H) {
- await this.pluginService.ensurePluginsAreLoaded(scope)
-
- const result = fun(params)
-
- return this.pluginService.runHook(hookResultName, result, params)
- }
-
runAction<T, U extends ClientActionHookName> (hookName: U, scope: PluginClientScope, params?: T) {
// Use setTimeout to give priority to Angular change detector
setTimeout(() => {
})
}
- async wrapObject<T, U extends ClientFilterHookName> (result: T, scope: PluginClientScope, hookName: U) {
+ async wrapObject<T, U extends ClientFilterHookName> (result: T, scope: PluginClientScope, hookName: U, context?: any) {
await this.pluginService.ensurePluginsAreLoaded(scope)
- return this.wrapObjectWithoutScopeLoad(result, hookName)
+ return this.wrapObjectWithoutScopeLoad(result, hookName, context)
}
- private wrapObjectWithoutScopeLoad<T, U extends ClientFilterHookName> (result: T, hookName: U) {
- return this.pluginService.runHook(hookName, result)
+ private wrapObjectWithoutScopeLoad<T, U extends ClientFilterHookName> (result: T, hookName: U, context?: any) {
+ return this.pluginService.runHook(hookName, result, context)
}
}
[ '/accounts?/:name', '/accounts?/:name/video-channels', '/a/:name', '/a/:name/video-channels' ],
executeIfActivityPub,
asyncMiddleware(localAccountValidator),
- accountController
+ asyncMiddleware(accountController)
)
activityPubClientRouter.get('/accounts?/:name/followers',
executeIfActivityPub,
executeIfActivityPub,
cacheRoute(ROUTE_CACHE_LIFETIME.ACTIVITY_PUB.VIDEOS),
asyncMiddleware(getAccountVideoRateValidatorFactory('like')),
- getAccountVideoRateFactory('like')
+ asyncMiddleware(getAccountVideoRateFactory('like'))
)
activityPubClientRouter.get('/accounts?/:name/dislikes/:videoId',
executeIfActivityPub,
cacheRoute(ROUTE_CACHE_LIFETIME.ACTIVITY_PUB.VIDEOS),
asyncMiddleware(getAccountVideoRateValidatorFactory('dislike')),
- getAccountVideoRateFactory('dislike')
+ asyncMiddleware(getAccountVideoRateFactory('dislike'))
)
activityPubClientRouter.get(
executeIfActivityPub,
asyncMiddleware(videoChannelsNameWithHostValidator),
ensureIsLocalChannel,
- videoChannelController
+ asyncMiddleware(videoChannelController)
)
activityPubClientRouter.get('/video-channels/:nameWithHost/followers',
executeIfActivityPub,
activityPubClientRouter.get('/video-playlists/:playlistId/videos/:playlistElementId',
executeIfActivityPub,
asyncMiddleware(videoPlaylistElementAPGetValidator),
- videoPlaylistElementController
+ asyncMiddleware(videoPlaylistElementController)
)
activityPubClientRouter.get('/videos/local-viewer/:localViewerId',
executeIfActivityPub,
asyncMiddleware(getVideoLocalViewerValidator),
- getVideoLocalViewerController
+ asyncMiddleware(getVideoLocalViewerController)
)
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
-function accountController (req: express.Request, res: express.Response) {
+async function accountController (req: express.Request, res: express.Response) {
const account = res.locals.account
- return activityPubResponse(activityPubContextify(account.toActivityPubObject(), 'Actor'), res)
+ return activityPubResponse(activityPubContextify(await account.toActivityPubObject(), 'Actor'), res)
}
async function accountFollowersController (req: express.Request, res: express.Response) {
const videoWithCaptions = Object.assign(video, { VideoCaptions: captions })
const audience = getAudience(videoWithCaptions.VideoChannel.Account.Actor, videoWithCaptions.privacy === VideoPrivacy.PUBLIC)
- const videoObject = audiencify(videoWithCaptions.toActivityPubObject(), audience)
+ const videoObject = audiencify(await videoWithCaptions.toActivityPubObject(), audience)
if (req.path.endsWith('/activity')) {
const data = buildCreateActivity(videoWithCaptions.url, video.VideoChannel.Account.Actor, videoObject, audience)
return activityPubResponse(activityPubContextify(json, 'Collection'), res)
}
-function videoChannelController (req: express.Request, res: express.Response) {
+async function videoChannelController (req: express.Request, res: express.Response) {
const videoChannel = res.locals.videoChannel
- return activityPubResponse(activityPubContextify(videoChannel.toActivityPubObject(), 'Actor'), res)
+ return activityPubResponse(activityPubContextify(await videoChannel.toActivityPubObject(), 'Actor'), res)
}
async function videoChannelFollowersController (req: express.Request, res: express.Response) {
activities.push(announceActivity)
} else {
- const videoObject = video.toActivityPubObject()
+ const videoObject = await video.toActivityPubObject()
const createActivity = buildCreateActivity(video.url, byActor, videoObject, createActivityAudience)
activities.push(createActivity)
import express from 'express'
-function activityPubResponse (data: any, res: express.Response) {
+async function activityPubResponse (promise: Promise<any>, res: express.Response) {
+ const data = await promise
+
return res.type('application/activity+json; charset=utf-8')
.json(data)
}
import { ContextType } from '@shared/models'
+import { Hooks } from '../plugins/hooks'
-function activityPubContextify <T> (data: T, type: ContextType) {
- return { ...getContextData(type), ...data }
+async function activityPubContextify <T> (data: T, type: ContextType) {
+ return { ...await getContextData(type), ...data }
}
// ---------------------------------------------------------------------------
Rate: buildContext()
}
-function getContextData (type: ContextType) {
- return {
- '@context': contextStore[type]
- }
+async function getContextData (type: ContextType) {
+ const contextData = await Hooks.wrapObject(
+ contextStore[type],
+ 'filter:activity-pub.activity.context.build.result'
+ )
+
+ return { '@context': contextData }
}
function buildContext (contextValue?: ContextValue) {
}
}
-function signAndContextify <T> (byActor: MActor, data: T, contextType: ContextType | null) {
+async function signAndContextify <T> (byActor: MActor, data: T, contextType: ContextType | null) {
const activity = contextType
- ? activityPubContextify(data, contextType)
+ ? await activityPubContextify(data, contextType)
: data
return signJsonLDObject(byActor, activity)
logger.info('Creating job to send video creation of %s.', video.url, lTags(video.uuid))
const byActor = video.VideoChannel.Account.Actor
- const videoObject = video.toActivityPubObject()
+ const videoObject = await video.toActivityPubObject()
const audience = getAudience(byActor, video.privacy === VideoPrivacy.PUBLIC)
const createActivity = buildCreateActivity(video.url, byActor, videoObject, audience)
video.VideoCaptions = await video.$get('VideoCaptions', { transaction })
}
- const videoObject = video.toActivityPubObject()
+ const videoObject = await video.toActivityPubObject()
const audience = getAudience(byActor, video.privacy === VideoPrivacy.PUBLIC)
const updateActivity = buildUpdateActivity(url, byActor, videoObject, audience)
}
}
- toActivityPubObject (this: MAccountAP) {
- const obj = this.Actor.toActivityPubObject(this.name)
+ async toActivityPubObject (this: MAccountAP) {
+ const obj = await this.Actor.toActivityPubObject(this.name)
return Object.assign(obj, {
summary: this.description
return Object.assign(actor, videoChannel)
}
- toActivityPubObject (this: MChannelAP): ActivityPubActor {
- const obj = this.Actor.toActivityPubObject(this.name)
+ async toActivityPubObject (this: MChannelAP): Promise<ActivityPubActor> {
+ const obj = await this.Actor.toActivityPubObject(this.name)
return Object.assign(obj, {
summary: this.description,
import { VideoSourceModel } from './video-source'
import { VideoStreamingPlaylistModel } from './video-streaming-playlist'
import { VideoTagModel } from './video-tag'
+import { Hooks } from '@server/lib/plugins/hooks'
export enum ScopeNames {
FOR_API = 'FOR_API',
return files
}
- toActivityPubObject (this: MVideoAP): VideoObject {
- return videoModelToActivityPubObject(this)
+ toActivityPubObject (this: MVideoAP): Promise<VideoObject> {
+ return Hooks.wrapObject(
+ videoModelToActivityPubObject(this),
+ 'filter:activity-pub.video.jsonld.build.result',
+ { video: this }
+ )
}
getTruncatedDescription () {
import { expect } from 'chai'
import { buildDigest } from '@server/helpers/peertube-crypto'
-import { HTTP_SIGNATURE } from '@server/initializers/constants'
+import { ACTIVITY_PUB, HTTP_SIGNATURE } from '@server/initializers/constants'
import { activityPubContextify } from '@server/lib/activitypub/context'
import { buildGlobalHeaders, signAndContextify } from '@server/lib/activitypub/send'
-import { makeFollowRequest, makePOSTAPRequest } from '@server/tests/shared'
+import { makePOSTAPRequest } from '@server/tests/shared'
import { buildAbsoluteFixturePath, wait } from '@shared/core-utils'
import { HttpStatusCode } from '@shared/models'
import { cleanupTests, createMultipleServers, killallServers, PeerTubeServer } from '@shared/server-commands'
return result
}
+async function makeFollowRequest (to: { url: string }, by: { url: string, privateKey }) {
+ const follow = {
+ type: 'Follow',
+ id: by.url + '/' + new Date().getTime(),
+ actor: by.url,
+ object: to.url
+ }
+
+ const body = await activityPubContextify(follow, 'Follow')
+
+ const httpSignature = {
+ algorithm: HTTP_SIGNATURE.ALGORITHM,
+ authorizationHeaderName: HTTP_SIGNATURE.HEADER_NAME,
+ keyId: by.url,
+ key: by.privateKey,
+ headers: HTTP_SIGNATURE.HEADERS_TO_SIGN
+ }
+ const headers = {
+ 'digest': buildDigest(body),
+ 'content-type': 'application/activity+json',
+ 'accept': ACTIVITY_PUB.ACCEPT_HEADER
+ }
+
+ return makePOSTAPRequest(to.url + '/inbox', body, httpSignature, headers)
+}
+
describe('Test ActivityPub security', function () {
let servers: PeerTubeServer[]
let url: string
describe('When checking HTTP signature', function () {
it('Should fail with an invalid digest', async function () {
- const body = activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
+ const body = await activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
const headers = {
Digest: buildDigest({ hello: 'coucou' })
}
})
it('Should fail with an invalid date', async function () {
- const body = activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
+ const body = await activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
const headers = buildGlobalHeaders(body)
headers['date'] = 'Wed, 21 Oct 2015 07:28:00 GMT'
await setKeysOfServer(servers[0], servers[1], invalidKeys.publicKey, invalidKeys.privateKey)
await setKeysOfServer(servers[1], servers[1], invalidKeys.publicKey, invalidKeys.privateKey)
- const body = activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
+ const body = await activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
const headers = buildGlobalHeaders(body)
try {
await setKeysOfServer(servers[0], servers[1], keys.publicKey, keys.privateKey)
await setKeysOfServer(servers[1], servers[1], keys.publicKey, keys.privateKey)
- const body = activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
+ const body = await activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
const headers = buildGlobalHeaders(body)
const signatureOptions = baseHttpSignature()
})
it('Should succeed with a valid HTTP signature draft 11 (without date but with (created))', async function () {
- const body = activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
+ const body = await activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
const headers = buildGlobalHeaders(body)
const signatureOptions = baseHttpSignature()
})
it('Should succeed with a valid HTTP signature', async function () {
- const body = activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
+ const body = await activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
const headers = buildGlobalHeaders(body)
const { statusCode } = await makePOSTAPRequest(url, body, baseHttpSignature(), headers)
await killallServers([ servers[1] ])
await servers[1].run()
- const body = activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
+ const body = await activityPubContextify(getAnnounceWithoutContext(servers[1]), 'Announce')
const headers = buildGlobalHeaders(body)
try {
-import { buildDigest } from '@server/helpers/peertube-crypto'
import { doRequest } from '@server/helpers/requests'
-import { ACTIVITY_PUB, HTTP_SIGNATURE } from '@server/initializers/constants'
-import { activityPubContextify } from '@server/lib/activitypub/context'
export function makePOSTAPRequest (url: string, body: any, httpSignature: any, headers: any) {
const options = {
return doRequest(url, options)
}
-
-export async function makeFollowRequest (to: { url: string }, by: { url: string, privateKey }) {
- const follow = {
- type: 'Follow',
- id: by.url + '/' + new Date().getTime(),
- actor: by.url,
- object: to.url
- }
-
- const body = activityPubContextify(follow, 'Follow')
-
- const httpSignature = {
- algorithm: HTTP_SIGNATURE.ALGORITHM,
- authorizationHeaderName: HTTP_SIGNATURE.HEADER_NAME,
- keyId: by.url,
- key: by.privateKey,
- headers: HTTP_SIGNATURE.HEADERS_TO_SIGN
- }
- const headers = {
- 'digest': buildDigest(body),
- 'content-type': 'application/activity+json',
- 'accept': ACTIVITY_PUB.ACCEPT_HEADER
- }
-
- return makePOSTAPRequest(to.url + '/inbox', body, httpSignature, headers)
-}
'zh': 'zh-Hans-CN'
}
-export const POSSIBLE_LOCALES = Object.keys(I18N_LOCALES)
- .concat(Object.keys(I18N_LOCALE_ALIAS))
+export const POSSIBLE_LOCALES = (Object.keys(I18N_LOCALES) as string[]).concat(Object.keys(I18N_LOCALE_ALIAS))
export function getDefaultLocale () {
return 'en-US'
'filter:transcoding.manual.resolutions-to-transcode.result': true,
'filter:transcoding.auto.resolutions-to-transcode.result': true,
- 'filter:activity-pub.remote-video-comment.create.accept.result': true
+ 'filter:activity-pub.remote-video-comment.create.accept.result': true,
+
+ 'filter:activity-pub.activity.context.build.result': true,
+
+ // Filter the result of video JSON LD builder
+ // You may also need to use filter:activity-pub.activity.context.build.result to also update JSON LD context
+ 'filter:activity-pub.video.jsonld.build.result': true
}
export type ServerFilterHookName = keyof typeof serverFilterHookObject