import { AdminComponent } from './admin.component'
import { FriendsRoutes } from './friends'
-import { RequestsRoutes } from './requests'
+import { RequestSchedulersRoutes } from './request-schedulers'
import { UsersRoutes } from './users'
import { VideoAbusesRoutes } from './video-abuses'
pathMatch: 'full'
},
...FriendsRoutes,
- ...RequestsRoutes,
+ ...RequestSchedulersRoutes,
...UsersRoutes,
...VideoAbusesRoutes
]
import { AdminComponent } from './admin.component'
import { AdminRoutingModule } from './admin-routing.module'
import { FriendsComponent, FriendAddComponent, FriendListComponent, FriendService } from './friends'
-import { RequestsComponent, RequestStatsComponent, RequestService } from './requests'
+import { RequestSchedulersComponent, RequestSchedulersStatsComponent, RequestSchedulersService } from './request-schedulers'
import { UsersComponent, UserAddComponent, UserListComponent, UserService } from './users'
import { VideoAbusesComponent, VideoAbuseListComponent } from './video-abuses'
import { SharedModule } from '../shared'
FriendAddComponent,
FriendListComponent,
- RequestsComponent,
- RequestStatsComponent,
+ RequestSchedulersComponent,
+ RequestSchedulersStatsComponent,
UsersComponent,
UserAddComponent,
providers: [
FriendService,
- RequestService,
+ RequestSchedulersService,
UserService
]
})
-export * from './friends'
-export * from './requests'
-export * from './users'
-export * from './admin-routing.module'
export * from './admin.module'
-export * from './admin.component'
--- /dev/null
+export * from './request-schedulers-stats'
+export * from './shared'
+export * from './request-schedulers.component'
+export * from './request-schedulers.routes'
--- /dev/null
+export * from './request-schedulers-stats.component'
--- /dev/null
+<div class="row">
+ <div class="content-padding">
+
+ <h3>Requests stats</h3>
+
+ <ng-template [ngIf]="stats">
+ <div *ngFor="let requestSchedulerName of statsTitles | keys" class="col-lg-4 col-md-12">
+ <div class="panel panel-default" *ngIf="stats[requestSchedulerName] !== null">
+ <div class="panel-heading">{{ statsTitles[requestSchedulerName] }}</div>
+
+ <div class="panel-body">
+ <div class="requests-general">
+ <div>
+ <span class="label-description">Remaining requests:</span>
+ {{ stats[requestSchedulerName].totalRequests }}
+ </div>
+
+ <div>
+ <span class="label-description">Interval seconds between requests:</span>
+ {{ stats[requestSchedulerName].secondsInterval }}
+ </div>
+
+ <div>
+ <span class="label-description">Remaining time before the scheduled request:</span>
+ {{ stats[requestSchedulerName].remainingSeconds }}
+ </div>
+ </div>
+
+ <div class="requests-limit">
+ <div>
+ <span class="label-description">Maximum number of different pods for a scheduled request:</span>
+ {{ stats[requestSchedulerName].requestsLimitPods }}
+ </div>
+
+ <div>
+ <span class="label-description">Maximum number of requests per pod for a scheduled request:</span>
+ {{ stats[requestSchedulerName].requestsLimitPerPod }}
+ </div>
+ </div>
+ </div>
+ </div>
+ </div>
+ </ng-template>
+
+ </div>
+</div>
--- /dev/null
+.label-description {
+ font-weight: bold;
+ color: black;
+}
+
+.requests-limit {
+ margin-top: 20px;
+}
--- /dev/null
+import { Component, OnInit, OnDestroy } from '@angular/core'
+
+import { NotificationsService } from 'angular2-notifications'
+
+import { RequestSchedulersService, RequestSchedulerStatsAttributes } from '../shared'
+import { RequestSchedulerStats } from '../../../../../../shared'
+
+@Component({
+ selector: 'my-request-schedulers-stats',
+ templateUrl: './request-schedulers-stats.component.html',
+ styleUrls: [ './request-schedulers-stats.component.scss' ]
+})
+export class RequestSchedulersStatsComponent implements OnInit, OnDestroy {
+ statsTitles = {
+ requestScheduler: 'Basic request scheduler',
+ requestVideoEventScheduler: 'Video events request scheduler',
+ requestVideoQaduScheduler: 'Quick and dirty video updates request scheduler'
+ }
+
+ stats: RequestSchedulerStats
+
+ private intervals: { [ id: string ]: number } = {
+ requestScheduler: null,
+ requestVideoEventScheduler: null,
+ requestVideoQaduScheduler: null
+ }
+
+ private timeouts: { [ id: string ]: number } = {
+ requestScheduler: null,
+ requestVideoEventScheduler: null,
+ requestVideoQaduScheduler: null
+ }
+
+ constructor (
+ private notificationsService: NotificationsService,
+ private requestService: RequestSchedulersService
+ ) { }
+
+ ngOnInit () {
+ this.getStats()
+ this.runIntervals()
+ }
+
+ ngOnDestroy () {
+ Object.keys(this.stats).forEach(requestSchedulerName => {
+ if (this.intervals[requestSchedulerName] !== null) {
+ window.clearInterval(this.intervals[requestSchedulerName])
+ }
+
+ if (this.timeouts[requestSchedulerName] !== null) {
+ window.clearTimeout(this.timeouts[requestSchedulerName])
+ }
+ })
+ }
+
+ getStats () {
+ this.requestService.getStats().subscribe(
+ stats => this.stats = stats,
+
+ err => this.notificationsService.error('Error', err.text)
+ )
+ }
+
+ private runIntervals () {
+ Object.keys(this.intervals).forEach(requestSchedulerName => {
+ this.intervals[requestSchedulerName] = window.setInterval(() => {
+ const stats: RequestSchedulerStatsAttributes = this.stats[requestSchedulerName]
+
+ stats.remainingMilliSeconds -= 1000
+
+ if (stats.remainingMilliSeconds <= 0) {
+ this.timeouts[requestSchedulerName] = window.setTimeout(() => this.getStats(), stats.remainingMilliSeconds + 100)
+ }
+ }, 1000)
+ })
+ }
+}
--- /dev/null
+import { Component } from '@angular/core'
+
+@Component({
+ template: '<router-outlet></router-outlet>'
+})
+export class RequestSchedulersComponent {
+}
--- /dev/null
+import { Routes } from '@angular/router'
+
+import { RequestSchedulersComponent } from './request-schedulers.component'
+import { RequestSchedulersStatsComponent } from './request-schedulers-stats'
+
+export const RequestSchedulersRoutes: Routes = [
+ {
+ path: 'requests',
+ component: RequestSchedulersComponent,
+ children: [
+ {
+ path: '',
+ redirectTo: 'stats',
+ pathMatch: 'full'
+ },
+ {
+ path: 'stats',
+ component: RequestSchedulersStatsComponent,
+ data: {
+ meta: {
+ title: 'Request stats'
+ }
+ }
+ }
+ ]
+ }
+]
--- /dev/null
+export * from './request-schedulers-stats-attributes.model'
+export * from './request-schedulers.service'
--- /dev/null
+import { RequestSchedulerStatsAttributes as FormatedRequestSchedulerStatsAttributes } from '../../../../../../shared'
+
+export interface Request {
+ request: any
+ to: any
+}
+
+export class RequestSchedulerStatsAttributes implements FormatedRequestSchedulerStatsAttributes {
+ requestsLimitPods: number
+ requestsLimitPerPod: number
+ milliSecondsInterval: number
+ remainingMilliSeconds: number
+ totalRequests: number
+
+ constructor (hash: {
+ requestsLimitPods: number,
+ requestsLimitPerPod: number,
+ milliSecondsInterval: number,
+ remainingMilliSeconds: number,
+ totalRequests: number
+ }) {
+ this.requestsLimitPods = hash.requestsLimitPods
+ this.requestsLimitPerPod = hash.requestsLimitPerPod
+ this.milliSecondsInterval = hash.milliSecondsInterval
+ this.remainingMilliSeconds = hash.remainingMilliSeconds
+ this.totalRequests = hash.totalRequests
+ }
+
+ get remainingSeconds () {
+ return Math.floor(this.remainingMilliSeconds / 1000)
+ }
+
+ get secondsInterva () {
+ return Math.floor(this.milliSecondsInterval / 1000)
+ }
+
+}
--- /dev/null
+import { Injectable } from '@angular/core'
+import { Observable } from 'rxjs/Observable'
+import 'rxjs/add/operator/catch'
+import 'rxjs/add/operator/map'
+
+import { RequestSchedulerStats } from '../../../../../../shared'
+import { AuthHttp, RestExtractor } from '../../../shared'
+import { RequestSchedulerStatsAttributes } from './request-schedulers-stats-attributes.model'
+
+@Injectable()
+export class RequestSchedulersService {
+ private static BASE_REQUEST_URL = API_URL + '/api/v1/request-schedulers/'
+
+ constructor (
+ private authHttp: AuthHttp,
+ private restExtractor: RestExtractor
+ ) {}
+
+ getStats (): Observable<RequestSchedulerStats> {
+ return this.authHttp.get(RequestSchedulersService.BASE_REQUEST_URL + 'stats')
+ .map(this.restExtractor.extractDataGet)
+ .map(this.buildRequestObjects)
+ .catch((res) => this.restExtractor.handleError(res))
+ }
+
+ private buildRequestObjects (data: RequestSchedulerStats) {
+ const requestSchedulers = {}
+
+ Object.keys(data).forEach(requestSchedulerName => {
+ requestSchedulers[requestSchedulerName] = new RequestSchedulerStatsAttributes(data[requestSchedulerName])
+ })
+
+ return requestSchedulers
+ }
+}
+++ /dev/null
-export * from './request-stats'
-export * from './shared'
-export * from './requests.component'
-export * from './requests.routes'
+++ /dev/null
-export * from './request-stats.component'
+++ /dev/null
-<div class="row">
- <div class="content-padding">
-
- <h3>Requests stats</h3>
-
- <ng-template [ngIf]="stats">
- <div *ngFor="let requestSchedulerName of statsTitles | keys" class="col-lg-4 col-md-12">
- <div class="panel panel-default" *ngIf="stats[requestSchedulerName] !== null">
- <div class="panel-heading">{{ statsTitles[requestSchedulerName] }}</div>
-
- <div class="panel-body">
- <div class="requests-general">
- <div>
- <span class="label-description">Remaining requests:</span>
- {{ stats[requestSchedulerName].totalRequests }}
- </div>
-
- <div>
- <span class="label-description">Interval seconds between requests:</span>
- {{ stats[requestSchedulerName].secondsInterval }}
- </div>
-
- <div>
- <span class="label-description">Remaining time before the scheduled request:</span>
- {{ stats[requestSchedulerName].remainingSeconds }}
- </div>
- </div>
-
- <div class="requests-limit">
- <div>
- <span class="label-description">Maximum number of different pods for a scheduled request:</span>
- {{ stats[requestSchedulerName].requestsLimitPods }}
- </div>
-
- <div>
- <span class="label-description">Maximum number of requests per pod for a scheduled request:</span>
- {{ stats[requestSchedulerName].requestsLimitPerPod }}
- </div>
- </div>
- </div>
- </div>
- </div>
- </ng-template>
-
- </div>
-</div>
+++ /dev/null
-.label-description {
- font-weight: bold;
- color: black;
-}
-
-.requests-limit {
- margin-top: 20px;
-}
+++ /dev/null
-import { Component, OnInit, OnDestroy } from '@angular/core'
-
-import { NotificationsService } from 'angular2-notifications'
-
-import { RequestService, RequestSchedulerStatsAttributes } from '../shared'
-import { RequestScheduler } from '../../../../../../shared'
-
-@Component({
- selector: 'my-request-stats',
- templateUrl: './request-stats.component.html',
- styleUrls: [ './request-stats.component.scss' ]
-})
-export class RequestStatsComponent implements OnInit, OnDestroy {
- statsTitles = {
- requestScheduler: 'Basic request scheduler',
- requestVideoEventScheduler: 'Video events request scheduler',
- requestVideoQaduScheduler: 'Quick and dirty video updates request scheduler'
- }
-
- stats: RequestScheduler
-
- private intervals: { [ id: string ]: number } = {
- requestScheduler: null,
- requestVideoEventScheduler: null,
- requestVideoQaduScheduler: null
- }
-
- private timeouts: { [ id: string ]: number } = {
- requestScheduler: null,
- requestVideoEventScheduler: null,
- requestVideoQaduScheduler: null
- }
-
- constructor (
- private notificationsService: NotificationsService,
- private requestService: RequestService
- ) { }
-
- ngOnInit () {
- this.getStats()
- this.runIntervals()
- }
-
- ngOnDestroy () {
- Object.keys(this.stats).forEach(requestSchedulerName => {
- if (this.intervals[requestSchedulerName] !== null) {
- window.clearInterval(this.intervals[requestSchedulerName])
- }
-
- if (this.timeouts[requestSchedulerName] !== null) {
- window.clearTimeout(this.timeouts[requestSchedulerName])
- }
- })
- }
-
- getStats () {
- this.requestService.getStats().subscribe(
- stats => this.stats = stats,
-
- err => this.notificationsService.error('Error', err.text)
- )
- }
-
- private runIntervals () {
- Object.keys(this.intervals).forEach(requestSchedulerName => {
- this.intervals[requestSchedulerName] = window.setInterval(() => {
- const stats: RequestSchedulerStatsAttributes = this.stats[requestSchedulerName]
-
- stats.remainingMilliSeconds -= 1000
-
- if (stats.remainingMilliSeconds <= 0) {
- this.timeouts[requestSchedulerName] = window.setTimeout(() => this.getStats(), stats.remainingMilliSeconds + 100)
- }
- }, 1000)
- })
- }
-}
+++ /dev/null
-import { Component } from '@angular/core'
-
-@Component({
- template: '<router-outlet></router-outlet>'
-})
-export class RequestsComponent {
-}
+++ /dev/null
-import { Routes } from '@angular/router'
-
-import { RequestsComponent } from './requests.component'
-import { RequestStatsComponent } from './request-stats'
-
-export const RequestsRoutes: Routes = [
- {
- path: 'requests',
- component: RequestsComponent,
- children: [
- {
- path: '',
- redirectTo: 'stats',
- pathMatch: 'full'
- },
- {
- path: 'stats',
- component: RequestStatsComponent,
- data: {
- meta: {
- title: 'Request stats'
- }
- }
- }
- ]
- }
-]
+++ /dev/null
-export * from './request-stats-attributes.model'
-export * from './request.service'
+++ /dev/null
-import { RequestSchedulerAttributes as FormatedRequestSchedulerAttributes } from '../../../../../../shared'
-
-export interface Request {
- request: any
- to: any
-}
-
-export class RequestSchedulerStatsAttributes implements FormatedRequestSchedulerAttributes {
- requestsLimitPods: number
- requestsLimitPerPod: number
- milliSecondsInterval: number
- remainingMilliSeconds: number
- totalRequests: number
-
- constructor (hash: {
- requestsLimitPods: number,
- requestsLimitPerPod: number,
- milliSecondsInterval: number,
- remainingMilliSeconds: number,
- totalRequests: number
- }) {
- this.requestsLimitPods = hash.requestsLimitPods
- this.requestsLimitPerPod = hash.requestsLimitPerPod
- this.milliSecondsInterval = hash.milliSecondsInterval
- this.remainingMilliSeconds = hash.remainingMilliSeconds
- this.totalRequests = hash.totalRequests
- }
-
- get remainingSeconds () {
- return Math.floor(this.remainingMilliSeconds / 1000)
- }
-
- get secondsInterva () {
- return Math.floor(this.milliSecondsInterval / 1000)
- }
-
-}
+++ /dev/null
-import { Injectable } from '@angular/core'
-import { Observable } from 'rxjs/Observable'
-import 'rxjs/add/operator/catch'
-import 'rxjs/add/operator/map'
-
-import { RequestScheduler } from '../../../../../../shared'
-import { AuthHttp, RestExtractor } from '../../../shared'
-import { RequestSchedulerStatsAttributes } from './request-stats-attributes.model'
-
-@Injectable()
-export class RequestService {
- private static BASE_REQUEST_URL = API_URL + '/api/v1/requests/'
-
- constructor (
- private authHttp: AuthHttp,
- private restExtractor: RestExtractor
- ) {}
-
- getStats (): Observable<RequestScheduler> {
- return this.authHttp.get(RequestService.BASE_REQUEST_URL + 'stats')
- .map(this.restExtractor.extractDataGet)
- .map(this.buildRequestObjects)
- .catch((res) => this.restExtractor.handleError(res))
- }
-
- private buildRequestObjects (data: RequestScheduler) {
- const requestSchedulers = {}
-
- Object.keys(data).forEach(requestSchedulerName => {
- requestSchedulers[requestSchedulerName] = new RequestSchedulerStatsAttributes(data[requestSchedulerName])
- })
-
- return requestSchedulers
- }
-}
import { configRouter } from './config'
import { podsRouter } from './pods'
import { remoteRouter } from './remote'
-import { requestsRouter } from './requests'
+import { requestSchedulerRouter } from './request-schedulers'
import { usersRouter } from './users'
import { videosRouter } from './videos'
apiRouter.use('/config', configRouter)
apiRouter.use('/pods', podsRouter)
apiRouter.use('/remote', remoteRouter)
-apiRouter.use('/requests', requestsRouter)
+apiRouter.use('/request-schedulers', requestSchedulerRouter)
apiRouter.use('/users', usersRouter)
apiRouter.use('/videos', videosRouter)
apiRouter.use('/ping', pong)
--- /dev/null
+import * as express from 'express'
+import { parallel } from 'async'
+
+import {
+ AbstractRequestScheduler,
+ getRequestScheduler,
+ getRequestVideoQaduScheduler,
+ getRequestVideoEventScheduler
+} from '../../lib'
+import { authenticate, ensureIsAdmin } from '../../middlewares'
+import { RequestSchedulerStatsAttributes } from '../../../shared'
+
+const requestSchedulerRouter = express.Router()
+
+requestSchedulerRouter.get('/stats',
+ authenticate,
+ ensureIsAdmin,
+ getRequestSchedulersStats
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+ requestSchedulerRouter
+}
+
+// ---------------------------------------------------------------------------
+
+function getRequestSchedulersStats (req: express.Request, res: express.Response, next: express.NextFunction) {
+ parallel({
+ requestScheduler: buildRequestSchedulerStats(getRequestScheduler()),
+ requestVideoQaduScheduler: buildRequestSchedulerStats(getRequestVideoQaduScheduler()),
+ requestVideoEventScheduler: buildRequestSchedulerStats(getRequestVideoEventScheduler())
+ }, function (err, result) {
+ if (err) return next(err)
+
+ return res.json(result)
+ })
+}
+
+// ---------------------------------------------------------------------------
+
+function buildRequestSchedulerStats (requestScheduler: AbstractRequestScheduler) {
+ return function (callback) {
+ requestScheduler.remainingRequestsCount(function (err, count) {
+ if (err) return callback(err)
+
+ const result: RequestSchedulerStatsAttributes = {
+ totalRequests: count,
+ requestsLimitPods: requestScheduler.limitPods,
+ requestsLimitPerPod: requestScheduler.limitPerPod,
+ remainingMilliSeconds: requestScheduler.remainingMilliSeconds(),
+ milliSecondsInterval: requestScheduler.requestInterval
+ }
+
+ return callback(null, result)
+ })
+ }
+}
+++ /dev/null
-import * as express from 'express'
-import { parallel } from 'async'
-
-import {
- AbstractRequestScheduler,
- getRequestScheduler,
- getRequestVideoQaduScheduler,
- getRequestVideoEventScheduler
-} from '../../lib'
-import { authenticate, ensureIsAdmin } from '../../middlewares'
-import { RequestSchedulerAttributes } from '../../../shared'
-
-const requestsRouter = express.Router()
-
-requestsRouter.get('/stats',
- authenticate,
- ensureIsAdmin,
- getStatsRequests
-)
-
-// ---------------------------------------------------------------------------
-
-export {
- requestsRouter
-}
-
-// ---------------------------------------------------------------------------
-
-function getStatsRequests (req: express.Request, res: express.Response, next: express.NextFunction) {
- parallel({
- requestScheduler: buildRequestSchedulerFunction(getRequestScheduler()),
- requestVideoQaduScheduler: buildRequestSchedulerFunction(getRequestVideoQaduScheduler()),
- requestVideoEventScheduler: buildRequestSchedulerFunction(getRequestVideoEventScheduler())
- }, function (err, result) {
- if (err) return next(err)
-
- return res.json(result)
- })
-}
-
-// ---------------------------------------------------------------------------
-
-function buildRequestSchedulerFunction (requestScheduler: AbstractRequestScheduler) {
- return function (callback) {
- requestScheduler.remainingRequestsCount(function (err, count) {
- if (err) return callback(err)
-
- const result: RequestSchedulerAttributes = {
- totalRequests: count,
- requestsLimitPods: requestScheduler.limitPods,
- requestsLimitPerPod: requestScheduler.limitPerPod,
- remainingMilliSeconds: requestScheduler.remainingMilliSeconds(),
- milliSecondsInterval: requestScheduler.requestInterval
- }
-
- return callback(null, result)
- })
- }
-}
require('./pods')
require('./remotes')
require('./users')
-require('./requests')
+require('./request-schedulers')
require('./videos')
require('./video-abuses')
require('./video-blacklists')
--- /dev/null
+/* eslint-disable no-unused-expressions */
+
+'use strict'
+
+const request = require('supertest')
+const series = require('async/series')
+
+const loginUtils = require('../../utils/login')
+const usersUtils = require('../../utils/users')
+const serversUtils = require('../../utils/servers')
+
+describe('Test request schedulers stats API validators', function () {
+ const path = '/api/v1/request-schedulers/stats'
+ let server = null
+ let userAccessToken = null
+
+ // ---------------------------------------------------------------
+
+ before(function (done) {
+ this.timeout(20000)
+
+ series([
+ function (next) {
+ serversUtils.flushTests(next)
+ },
+ function (next) {
+ serversUtils.runServer(1, function (server1) {
+ server = server1
+
+ next()
+ })
+ },
+ function (next) {
+ loginUtils.loginAndGetAccessToken(server, function (err, token) {
+ if (err) throw err
+ server.accessToken = token
+
+ next()
+ })
+ },
+ function (next) {
+ const username = 'user'
+ const password = 'my super password'
+
+ usersUtils.createUser(server.url, server.accessToken, username, password, next)
+ },
+ function (next) {
+ const user = {
+ username: 'user',
+ password: 'my super password'
+ }
+
+ loginUtils.getUserAccessToken(server, user, function (err, accessToken) {
+ if (err) throw err
+
+ userAccessToken = accessToken
+
+ next()
+ })
+ }
+ ], done)
+ })
+
+ it('Should fail with an non authenticated user', function (done) {
+ request(server.url)
+ .get(path)
+ .set('Accept', 'application/json')
+ .expect(401, done)
+ })
+
+ it('Should fail with a non admin user', function (done) {
+ request(server.url)
+ .get(path)
+ .set('Authorization', 'Bearer ' + userAccessToken)
+ .set('Accept', 'application/json')
+ .expect(403, done)
+ })
+
+ after(function (done) {
+ process.kill(-server.app.pid)
+
+ // Keep the logs if the test failed
+ if (this.ok) {
+ serversUtils.flushTests(done)
+ } else {
+ done()
+ }
+ })
+})
+++ /dev/null
-/* eslint-disable no-unused-expressions */
-
-'use strict'
-
-const request = require('supertest')
-const series = require('async/series')
-
-const loginUtils = require('../../utils/login')
-const usersUtils = require('../../utils/users')
-const serversUtils = require('../../utils/servers')
-
-describe('Test requests API validators', function () {
- const path = '/api/v1/requests/stats'
- let server = null
- let userAccessToken = null
-
- // ---------------------------------------------------------------
-
- before(function (done) {
- this.timeout(20000)
-
- series([
- function (next) {
- serversUtils.flushTests(next)
- },
- function (next) {
- serversUtils.runServer(1, function (server1) {
- server = server1
-
- next()
- })
- },
- function (next) {
- loginUtils.loginAndGetAccessToken(server, function (err, token) {
- if (err) throw err
- server.accessToken = token
-
- next()
- })
- },
- function (next) {
- const username = 'user'
- const password = 'my super password'
-
- usersUtils.createUser(server.url, server.accessToken, username, password, next)
- },
- function (next) {
- const user = {
- username: 'user',
- password: 'my super password'
- }
-
- loginUtils.getUserAccessToken(server, user, function (err, accessToken) {
- if (err) throw err
-
- userAccessToken = accessToken
-
- next()
- })
- }
- ], done)
- })
-
- it('Should fail with an non authenticated user', function (done) {
- request(server.url)
- .get(path)
- .set('Accept', 'application/json')
- .expect(401, done)
- })
-
- it('Should fail with a non admin user', function (done) {
- request(server.url)
- .get(path)
- .set('Authorization', 'Bearer ' + userAccessToken)
- .set('Accept', 'application/json')
- .expect(403, done)
- })
-
- after(function (done) {
- process.kill(-server.app.pid)
-
- // Keep the logs if the test failed
- if (this.ok) {
- serversUtils.flushTests(done)
- } else {
- done()
- }
- })
-})
require('./video-abuse')
require('./video-blacklist')
require('./multiple-pods')
-require('./requests')
+require('./request-schedulers')
require('./friends-advanced')
require('./video-transcoder')
--- /dev/null
+/* eslint-disable no-unused-expressions */
+
+'use strict'
+
+const chai = require('chai')
+const each = require('async/each')
+const expect = chai.expect
+const request = require('supertest')
+
+const loginUtils = require('../utils/login')
+const podsUtils = require('../utils/pods')
+const serversUtils = require('../utils/servers')
+const videosUtils = require('../utils/videos')
+
+describe('Test requests schedulers stats', function () {
+ const requestSchedulerNames = [ 'requestScheduler', 'requestVideoQaduScheduler', 'requestVideoEventScheduler' ]
+ const path = '/api/v1/request-schedulers/stats'
+ let servers = []
+
+ function uploadVideo (server, callback) {
+ const videoAttributes = {
+ tags: [ 'tag1', 'tag2' ]
+ }
+
+ videosUtils.uploadVideo(server.url, server.accessToken, videoAttributes, callback)
+ }
+
+ function getRequestsStats (server, callback) {
+ request(server.url)
+ .get(path)
+ .set('Accept', 'application/json')
+ .set('Authorization', 'Bearer ' + server.accessToken)
+ .expect(200)
+ .end(callback)
+ }
+
+ // ---------------------------------------------------------------
+
+ before(function (done) {
+ this.timeout(20000)
+ serversUtils.flushAndRunMultipleServers(2, function (serversRun, urlsRun) {
+ servers = serversRun
+
+ each(servers, function (server, callbackEach) {
+ loginUtils.loginAndGetAccessToken(server, function (err, accessToken) {
+ if (err) return callbackEach(err)
+
+ server.accessToken = accessToken
+ callbackEach()
+ })
+ }, function (err) {
+ if (err) throw err
+
+ const server1 = servers[0]
+ podsUtils.makeFriends(server1.url, server1.accessToken, done)
+ })
+ })
+ })
+
+ it('Should have a correct timer', function (done) {
+ const server = servers[0]
+
+ getRequestsStats(server, function (err, res) {
+ if (err) throw err
+
+ const requestSchedulers = res.body
+ for (const requestSchedulerName of requestSchedulerNames) {
+ const requestScheduler = requestSchedulers[requestSchedulerName]
+
+ expect(requestScheduler.remainingMilliSeconds).to.be.at.least(0)
+ expect(requestScheduler.remainingMilliSeconds).to.be.at.most(10000)
+ }
+
+ done()
+ })
+ })
+
+ it('Should have the correct total request', function (done) {
+ this.timeout(15000)
+
+ const server = servers[0]
+ // Ensure the requests of pod 1 won't be made
+ servers[1].app.kill()
+
+ uploadVideo(server, function (err) {
+ if (err) throw err
+
+ setTimeout(function () {
+ getRequestsStats(server, function (err, res) {
+ if (err) throw err
+
+ const requestSchedulers = res.body
+ const requestScheduler = requestSchedulers.requestScheduler
+ expect(requestScheduler.totalRequests).to.equal(1)
+
+ done()
+ })
+ }, 1000)
+ })
+ })
+
+ after(function (done) {
+ process.kill(-servers[0].app.pid)
+
+ if (this.ok) {
+ serversUtils.flushTests(done)
+ } else {
+ done()
+ }
+ })
+})
+++ /dev/null
-/* eslint-disable no-unused-expressions */
-
-'use strict'
-
-const chai = require('chai')
-const each = require('async/each')
-const expect = chai.expect
-const request = require('supertest')
-
-const loginUtils = require('../utils/login')
-const podsUtils = require('../utils/pods')
-const serversUtils = require('../utils/servers')
-const videosUtils = require('../utils/videos')
-
-describe('Test requests stats', function () {
- const requestSchedulerNames = [ 'requestScheduler', 'requestVideoQaduScheduler', 'requestVideoEventScheduler' ]
- const path = '/api/v1/requests/stats'
- let servers = []
-
- function uploadVideo (server, callback) {
- const videoAttributes = {
- tags: [ 'tag1', 'tag2' ]
- }
-
- videosUtils.uploadVideo(server.url, server.accessToken, videoAttributes, callback)
- }
-
- function getRequestsStats (server, callback) {
- request(server.url)
- .get(path)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + server.accessToken)
- .expect(200)
- .end(callback)
- }
-
- // ---------------------------------------------------------------
-
- before(function (done) {
- this.timeout(20000)
- serversUtils.flushAndRunMultipleServers(2, function (serversRun, urlsRun) {
- servers = serversRun
-
- each(servers, function (server, callbackEach) {
- loginUtils.loginAndGetAccessToken(server, function (err, accessToken) {
- if (err) return callbackEach(err)
-
- server.accessToken = accessToken
- callbackEach()
- })
- }, function (err) {
- if (err) throw err
-
- const server1 = servers[0]
- podsUtils.makeFriends(server1.url, server1.accessToken, done)
- })
- })
- })
-
- it('Should have a correct timer', function (done) {
- const server = servers[0]
-
- getRequestsStats(server, function (err, res) {
- if (err) throw err
-
- const requestSchedulers = res.body
- for (const requestSchedulerName of requestSchedulerNames) {
- const requestScheduler = requestSchedulers[requestSchedulerName]
-
- expect(requestScheduler.remainingMilliSeconds).to.be.at.least(0)
- expect(requestScheduler.remainingMilliSeconds).to.be.at.most(10000)
- }
-
- done()
- })
- })
-
- it('Should have the correct total request', function (done) {
- this.timeout(15000)
-
- const server = servers[0]
- // Ensure the requests of pod 1 won't be made
- servers[1].app.kill()
-
- uploadVideo(server, function (err) {
- if (err) throw err
-
- setTimeout(function () {
- getRequestsStats(server, function (err, res) {
- if (err) throw err
-
- const requestSchedulers = res.body
- const requestScheduler = requestSchedulers.requestScheduler
- expect(requestScheduler.totalRequests).to.equal(1)
-
- done()
- })
- }, 1000)
- })
- })
-
- after(function (done) {
- process.kill(-servers[0].app.pid)
-
- if (this.ok) {
- serversUtils.flushTests(done)
- } else {
- done()
- }
- })
-})
const podsUtils = require('../utils/pods')
const serversUtils = require('../utils/servers')
const videosUtils = require('../utils/videos')
-const requestStatsUtils = require('../utils/requests-stats')
+const requestSchedulersUtils = require('../utils/request-schedulers')
program
.option('-c, --create [weight]', 'Weight for creating videos')
// Check is each server has awaiting requestq
each(servers, function (server, callbackEach) {
- requestStatsUtils.getRequestsStats(server, server.accessToken, function (err, res) {
+ requestSchedulersUtils.getRequestsStats(server, server.accessToken, function (err, res) {
if (err) throw err
const stats = res.body
--- /dev/null
+'use strict'
+
+const request = require('supertest')
+
+const requestsStatsUtils = {
+ getRequestsStats
+}
+
+// ---------------------- Export functions --------------------
+
+function getRequestsStats (server, accessToken, callback) {
+ const path = '/api/v1/requests/stats'
+
+ request(server.url)
+ .get(path)
+ .set('Accept', 'application/json')
+ .set('Authorization', 'Bearer ' + accessToken)
+ .expect(200)
+ .expect('Content-Type', /json/)
+ .end(callback)
+}
+
+// ---------------------------------------------------------------------------
+
+module.exports = requestsStatsUtils
+++ /dev/null
-'use strict'
-
-const request = require('supertest')
-
-const requestsStatsUtils = {
- getRequestsStats
-}
-
-// ---------------------- Export functions --------------------
-
-function getRequestsStats (server, accessToken, callback) {
- const path = '/api/v1/requests/stats'
-
- request(server.url)
- .get(path)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + accessToken)
- .expect(200)
- .expect('Content-Type', /json/)
- .end(callback)
-}
-
-// ---------------------------------------------------------------------------
-
-module.exports = requestsStatsUtils
export type RequestVideoEventType = 'likes' | 'dislikes' | 'views'
-export type RequestSchedulerAttributes = {
+export type RequestSchedulerStatsAttributes = {
totalRequests: number
requestsLimitPods: number
requestsLimitPerPod: number
milliSecondsInterval: number
}
-export interface RequestScheduler {
- requestScheduler: RequestSchedulerAttributes
- requestVideoQaduScheduler: RequestSchedulerAttributes
- requestVideoEventScheduler: RequestSchedulerAttributes
+export interface RequestSchedulerStats {
+ requestScheduler: RequestSchedulerStatsAttributes
+ requestVideoQaduScheduler: RequestSchedulerStatsAttributes
+ requestVideoEventScheduler: RequestSchedulerStatsAttributes
}
projects / oweals / peertube.git / commitdiff