-import * as express from 'express'
+import express from 'express'
+import { getServerActor } from '@server/models/application/application'
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
import { UserRight } from '../../../../shared/models/users'
-import { sanitizeHost } from '../../../helpers/core-utils'
-import { retryTransactionWrapper } from '../../../helpers/database-utils'
import { logger } from '../../../helpers/logger'
-import { getFormattedObjects, getServerActor } from '../../../helpers/utils'
-import { loadActorUrlOrGetFromWebfinger } from '../../../helpers/webfinger'
-import { REMOTE_SCHEME, sequelizeTypescript, SERVER_ACTOR_NAME } from '../../../initializers'
-import { getOrCreateActorAndServerAndModel } from '../../../lib/activitypub/actor'
-import { sendFollow, sendUndoFollow } from '../../../lib/activitypub/send'
+import { getFormattedObjects } from '../../../helpers/utils'
+import { SERVER_ACTOR_NAME } from '../../../initializers/constants'
+import { sequelizeTypescript } from '../../../initializers/database'
+import { autoFollowBackIfNeeded } from '../../../lib/activitypub/follow'
+import { sendAccept, sendReject, sendUndoFollow } from '../../../lib/activitypub/send'
+import { JobQueue } from '../../../lib/job-queue'
+import { removeRedundanciesOfServer } from '../../../lib/redundancy'
import {
- asyncMiddleware, authenticate, ensureUserHasRight, paginationValidator, removeFollowingValidator, setBodyHostsPort,
- setFollowersSort, setFollowingSort, setPagination
+ asyncMiddleware,
+ authenticate,
+ ensureUserHasRight,
+ paginationValidator,
+ setBodyHostsPort,
+ setDefaultPagination,
+ setDefaultSort
} from '../../../middlewares'
-import { followersSortValidator, followingSortValidator, followValidator } from '../../../middlewares/validators'
-import { ActorModel } from '../../../models/activitypub/actor'
-import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
+import {
+ acceptOrRejectFollowerValidator,
+ instanceFollowersSortValidator,
+ instanceFollowingSortValidator,
+ followValidator,
+ getFollowerValidator,
+ listFollowsValidator,
+ removeFollowingValidator
+} from '../../../middlewares/validators'
+import { ActorFollowModel } from '../../../models/actor/actor-follow'
+import { ServerFollowCreate } from '@shared/models'
const serverFollowsRouter = express.Router()
-
serverFollowsRouter.get('/following',
+ listFollowsValidator,
paginationValidator,
- followingSortValidator,
- setFollowingSort,
- setPagination,
+ instanceFollowingSortValidator,
+ setDefaultSort,
+ setDefaultPagination,
asyncMiddleware(listFollowing)
)
ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
followValidator,
setBodyHostsPort,
- asyncMiddleware(followRetry)
+ asyncMiddleware(addFollow)
)
-serverFollowsRouter.delete('/following/:host',
+serverFollowsRouter.delete('/following/:hostOrHandle',
authenticate,
ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
asyncMiddleware(removeFollowingValidator),
- asyncMiddleware(removeFollow)
+ asyncMiddleware(removeFollowing)
)
serverFollowsRouter.get('/followers',
+ listFollowsValidator,
paginationValidator,
- followersSortValidator,
- setFollowersSort,
- setPagination,
+ instanceFollowersSortValidator,
+ setDefaultSort,
+ setDefaultPagination,
asyncMiddleware(listFollowers)
)
+serverFollowsRouter.delete('/followers/:nameWithHost',
+ authenticate,
+ ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
+ asyncMiddleware(getFollowerValidator),
+ asyncMiddleware(removeOrRejectFollower)
+)
+
+serverFollowsRouter.post('/followers/:nameWithHost/reject',
+ authenticate,
+ ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
+ asyncMiddleware(getFollowerValidator),
+ acceptOrRejectFollowerValidator,
+ asyncMiddleware(removeOrRejectFollower)
+)
+
+serverFollowsRouter.post('/followers/:nameWithHost/accept',
+ authenticate,
+ ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
+ asyncMiddleware(getFollowerValidator),
+ acceptOrRejectFollowerValidator,
+ asyncMiddleware(acceptFollower)
+)
+
// ---------------------------------------------------------------------------
export {
// ---------------------------------------------------------------------------
-async function listFollowing (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listFollowing (req: express.Request, res: express.Response) {
const serverActor = await getServerActor()
- const resultList = await ActorFollowModel.listFollowingForApi(serverActor.id, req.query.start, req.query.count, req.query.sort)
+ const resultList = await ActorFollowModel.listInstanceFollowingForApi({
+ followerId: serverActor.id,
+ start: req.query.start,
+ count: req.query.count,
+ sort: req.query.sort,
+ search: req.query.search,
+ actorType: req.query.actorType,
+ state: req.query.state
+ })
return res.json(getFormattedObjects(resultList.data, resultList.total))
}
-async function listFollowers (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listFollowers (req: express.Request, res: express.Response) {
const serverActor = await getServerActor()
- const resultList = await ActorFollowModel.listFollowersForApi(serverActor.id, req.query.start, req.query.count, req.query.sort)
+ const resultList = await ActorFollowModel.listFollowersForApi({
+ actorIds: [ serverActor.id ],
+ start: req.query.start,
+ count: req.query.count,
+ sort: req.query.sort,
+ search: req.query.search,
+ actorType: req.query.actorType,
+ state: req.query.state
+ })
return res.json(getFormattedObjects(resultList.data, resultList.total))
}
-async function followRetry (req: express.Request, res: express.Response, next: express.NextFunction) {
- const hosts = req.body.hosts as string[]
- const fromActor = await getServerActor()
-
- const tasks: Promise<any>[] = []
- const actorName = SERVER_ACTOR_NAME
+async function addFollow (req: express.Request, res: express.Response) {
+ const { hosts, handles } = req.body as ServerFollowCreate
+ const follower = await getServerActor()
for (const host of hosts) {
- const sanitizedHost = sanitizeHost(host, REMOTE_SCHEME.HTTP)
-
- // We process each host in a specific transaction
- // First, we add the follow request in the database
- // Then we send the follow request to other actor
- const p = loadActorUrlOrGetFromWebfinger(actorName, sanitizedHost)
- .then(actorUrl => getOrCreateActorAndServerAndModel(actorUrl))
- .then(targetActor => {
- const options = {
- arguments: [ fromActor, targetActor ],
- errorMessage: 'Cannot follow with many retries.'
- }
-
- return retryTransactionWrapper(follow, options)
- })
- .catch(err => logger.warn('Cannot follow server %s.', sanitizedHost, err))
-
- tasks.push(p)
+ const payload = {
+ host,
+ name: SERVER_ACTOR_NAME,
+ followerActorId: follower.id
+ }
+
+ JobQueue.Instance.createJob({ type: 'activitypub-follow', payload })
}
- // Don't make the client wait the tasks
- Promise.all(tasks)
- .catch(err => logger.error('Error in follow.', err))
+ for (const handle of handles) {
+ const [ name, host ] = handle.split('@')
- return res.status(204).end()
-}
-
-function follow (fromActor: ActorModel, targetActor: ActorModel) {
- return sequelizeTypescript.transaction(async t => {
- const [ actorFollow ] = await ActorFollowModel.findOrCreate({
- where: {
- actorId: fromActor.id,
- targetActorId: targetActor.id
- },
- defaults: {
- state: 'pending',
- actorId: fromActor.id,
- targetActorId: targetActor.id
- },
- transaction: t
- })
- actorFollow.ActorFollowing = targetActor
- actorFollow.ActorFollower = fromActor
-
- // Send a notification to remote server
- if (actorFollow.state === 'pending') {
- await sendFollow(actorFollow, t)
+ const payload = {
+ host,
+ name,
+ followerActorId: follower.id
}
- })
+
+ JobQueue.Instance.createJob({ type: 'activitypub-follow', payload })
+ }
+
+ return res.status(HttpStatusCode.NO_CONTENT_204).end()
}
-async function removeFollow (req: express.Request, res: express.Response, next: express.NextFunction) {
- const follow: ActorFollowModel = res.locals.follow
+async function removeFollowing (req: express.Request, res: express.Response) {
+ const follow = res.locals.follow
await sequelizeTypescript.transaction(async t => {
- if (follow.state === 'accepted') await sendUndoFollow(follow, t)
+ if (follow.state === 'accepted') sendUndoFollow(follow, t)
+
+ // Disable redundancy on unfollowed instances
+ const server = follow.ActorFollowing.Server
+ server.redundancyAllowed = false
+ await server.save({ transaction: t })
+
+ // Async, could be long
+ removeRedundanciesOfServer(server.id)
+ .catch(err => logger.error('Cannot remove redundancy of %s.', server.host, { err }))
await follow.destroy({ transaction: t })
})
- // Destroy the actor that will destroy video channels, videos and video files too
- // This could be long so don't wait this task
- const following = follow.ActorFollowing
- following.destroy()
- .catch(err => logger.error('Cannot destroy actor that we do not follow anymore %s.', following.url, err))
+ return res.status(HttpStatusCode.NO_CONTENT_204).end()
+}
+
+async function removeOrRejectFollower (req: express.Request, res: express.Response) {
+ const follow = res.locals.follow
+
+ await sendReject(follow.url, follow.ActorFollower, follow.ActorFollowing)
+
+ await follow.destroy()
+
+ return res.status(HttpStatusCode.NO_CONTENT_204).end()
+}
+
+async function acceptFollower (req: express.Request, res: express.Response) {
+ const follow = res.locals.follow
+
+ sendAccept(follow)
+
+ follow.state = 'accepted'
+ await follow.save()
+
+ await autoFollowBackIfNeeded(follow)
- return res.status(204).end()
+ return res.status(HttpStatusCode.NO_CONTENT_204).end()
}
projects / github / Chocobozzz / PeerTube.git / blobdiff