init m2m client

.env.example

@@ -4,6 +4,8 @@ API_URL=https://api.test.faforever.com
 OAUTH_URL=https://hydra.test.faforever.com
 WP_URL=https://direct.faforever.com
 CALLBACK=auth
+OAUTH_M2M_CLIENT_ID=faf-website-public
+OAUTH_M2M_CLIENT_SECRET=banana
 OAUTH_CLIENT_ID=faf-website
 OAUTH_CLIENT_SECRET=banana
 SESSION_SECRET_KEY=banana

.env.faf-stack

@@ -20,7 +20,8 @@ OAUTH_PUBLIC_URL=http://localhost:4444
 
 # unsing the "xyz" wordpress because the faf-local-stack is just an empty instance without any news etc.
 WP_URL=https://direct.faforever.xyz
-
+OAUTH_M2M_CLIENT_ID=faf-website-public
+OAUTH_M2M_CLIENT_SECRET=banana
 OAUTH_CLIENT_ID=faf-website
 OAUTH_CLIENT_SECRET=banana
 SESSION_SECRET_KEY=banana

config/app.js

@@ -18,6 +18,11 @@ const appConfig = {
         publicUrl: process.env.OAUTH_PUBLIC_URL || oauthUrl,
         callback: process.env.CALLBACK || 'callback',
     },
+    m2mOauth: {
+        clientId: process.env.OAUTH_M2M_CLIENT_ID || 'faf-website-public',
+        clientSecret: process.env.OAUTH_M2M_CLIENT_SECRET || 'banana',
+        url: oauthUrl,
+    },
     apiUrl: process.env.API_URL || 'https://api.faforever.com',
     wordpressUrl: process.env.WP_URL || 'https://direct.faforever.com',
     extractorInterval: process.env.EXTRACTOR_INTERVAL || 5,

lib/JavaApiM2MClient.js

@@ -0,0 +1,6 @@
+const { JavaApiM2MClientFactory } = require("./JavaApiM2MClientFactory");
+const appConfig = require("../config/app");
+
+const client = JavaApiM2MClientFactory(appConfig.m2mOauth.clientId, appConfig.m2mOauth.clientSecret, appConfig.m2mOauth.url, appConfig.apiUrl)
+
+module.exports.JavaApiM2MClient = client

lib/JavaApiM2MClientFactory.js

@@ -0,0 +1,51 @@
+const {ClientCredentials} = require("simple-oauth2");
+const { Axios } = require("axios");
+const { AuthFailed } = require("./ApiErrors");
+
+const getToken = async function(clientId, clientSecret, host, scope) {
+    const tokenClient = new ClientCredentials({
+        client: {
+            id: clientId,
+            secret: clientSecret,
+
+        },
+        auth: {
+            tokenHost: host,
+            tokenPath: '/oauth2/token',
+            revokePath: '/oauth2/revoke'
+        },
+        options: {
+            authorizationMethod: 'body'
+        }
+    })
+
+    try {
+        return tokenClient.getToken({
+            scope: scope ?? '',
+        })
+    } catch (error) {
+        throw new AuthFailed(error.toString())
+    }
+}
+
+module.exports.JavaApiM2MClientFactory = async function(clientId, clientSecret, host, javaApiBaseURL) {
+    let passport = await getToken(clientId, clientSecret, host, '')
+
+    const client = new Axios({
+        baseURL: javaApiBaseURL
+    })
+
+    client.interceptors.request.use(config => {
+        if (passport.expired()) {
+            passport = passport.refresh()
+        }
+
+        config.headers = {
+            Authorization: `Bearer ${passport.token.access_token}`
+        }
+
+        return config;
+    });
+
+    return client
+}

lib/LeaderboardService.js

@@ -9,15 +9,15 @@ class LeaderboardService {
         this.leaderboardRepository = leaderboardRepository
     }
 
-    async getLeaderboard(id) {
+    async getLeaderboard(id, ignoreCache = false) {
 
         if (typeof (id) !== 'number') {
             throw new Error('LeaderboardService:getLeaderboard id must be a number')
         }
 
         const cacheKey = 'leaderboard-' + id
 
-        if (this.cacheService.has(cacheKey)) {
+        if (this.cacheService.has(cacheKey) && ignoreCache === false) {
             return this.cacheService.get(cacheKey)
         }
 

package.json

@@ -22,6 +22,7 @@
     "request": "2.88.2",
     "session-file-store": "^1.5.0",
     "showdown": "^2.1.0",
+    "simple-oauth2": "^5.0.0",
     "supertest-session": "^5.0.1",
     "url-slug": "^4.0.1"
   },

routes/middleware.js

@@ -1,5 +1,6 @@
 const WordpressServiceFactory = require("../lib/WordpressServiceFactory");
 const {JavaApiClientFactory} = require('../lib/JavaApiClientFactory')
+const {JavaApiM2MClient} = require('../lib/JavaApiM2MClient')
 const LeaderboardService = require('../lib/LeaderboardService')
 const LeaderboardRepository = require('../lib/LeaderboardRepository')
 const cacheService = require('../lib/CacheService')
@@ -9,7 +10,7 @@ const fs = require('fs');
 const webpackManifestJS = JSON.parse(fs.readFileSync('dist/js/manifest.json', 'utf8'));
 const LoggedInUserService = require('../lib/LoggedInUserService')
 const UserRepository = require('../lib/UserRepository');
-    
+
 
 exports.initLocals = function(req, res, next) {
 	let locals = res.locals;
@@ -59,19 +60,24 @@ exports.isAuthenticated = (redirectUrlAfterLogin = null, isApiRequest = false) =
     }
 }
 
-exports.injectServices = (req, res, next) => {
-    req.services = {}
-    req.services.wordpressService = wordpressService
+exports.injectServices = async (req, res, next) => {
+    try {
+        req.services = {}
+        req.services.wordpressService = wordpressService
+        req.services.javaApiM2MClient = await JavaApiM2MClient
+        req.services.leaderboardService = new LeaderboardService(cacheService, new LeaderboardRepository(req.services.javaApiM2MClient))
 
-    if (req.isAuthenticated()) {
-        try {
-            req.services.javaApiClient = JavaApiClientFactory(appConfig.apiUrl, req.user.oAuthPassport)
-            req.services.userService = new LoggedInUserService(new UserRepository(req.services.javaApiClient), req)
-            req.services.leaderboardService = new LeaderboardService(cacheService, new LeaderboardRepository(req.services.javaApiClient))
-        } catch (e) {
-            req.logout(() => next(e))
+        if (req.isAuthenticated()) {
+            try {
+                req.services.javaApiClient = JavaApiClientFactory(appConfig.apiUrl, req.user.oAuthPassport)
+                req.services.userService = new LoggedInUserService(new UserRepository(req.services.javaApiClient), req)
+            } catch (e) {
+                req.logout(() => next(e))
+            }
         }
-    }
 
-    next()
+        next()
+    } catch (e) {
+        next(e)
+    }
 }

routes/views/leaderboardRouter.js

@@ -20,11 +20,11 @@ const getLeaderboardId = (leaderboardName) => {
     return null
 }
 
-router.get('/', middlewares.isAuthenticated(), (req, res) => {
+router.get('/', (req, res) => {
     return res.render('leaderboards')
 })
 
-router.get('/:leaderboard.json', middlewares.isAuthenticated(null, true), async (req, res) => {
+router.get('/:leaderboard.json', async (req, res) => {
     try {
         const leaderboardId = getLeaderboardId(req.params.leaderboard ?? null);
 
@@ -38,16 +38,6 @@ router.get('/:leaderboard.json', middlewares.isAuthenticated(null, true), async
             return res.status(503).json({error: 'timeout reached'})
         }
 
-        if (e instanceof AuthFailed) {
-            req.logout(function(err) {
-                if (err) {
-                    throw err
-                }
-            })
-
-            return res.status(400).json({error: 'authentication failed, reload site'})
-        }
-
         console.error('[error] leaderboardRouter::get:leaderboard.json failed with "' + e.toString() + '"')
 
         if (!res.headersSent) {

scripts/cron-jobs.js

@@ -1,27 +1,79 @@
 const appConfig = require("../config/app")
 const WordpressServiceFactory = require("../lib/WordpressServiceFactory");
 const Scheduler = require("../lib/Scheduler");
+const LeaderboardService = require("../lib/LeaderboardService");
+const cacheService = require("../lib/CacheService");
+const LeaderboardRepository = require("../lib/LeaderboardRepository");
+const {JavaApiM2MClient} = require('../lib/JavaApiM2MClient')
 
-const warmupWordpressCache = async () => {
-    const wordpressService = WordpressServiceFactory(appConfig.wordpressUrl)
-
-    const successHandler = (name) => {
-        console.info(name, 'cache generated')
-    }
-    const errorHandler = (e, name) => {
-        console.error(name, e.toString(), 'cache failed')
+const successHandler = (name) => {
+    console.debug('Cache updated', {name})
+}
+const errorHandler = (e, name) => {
+    console.error(e.toString() , {name, entrypoint: 'cron-jobs.js'})
+}
+
+const warmupWordpressCache = () => {
+    try {
+      const wordpressService = WordpressServiceFactory(appConfig.wordpressUrl)
+
+      wordpressService.getNews(true)
+        .then(() => successHandler('wordpressService::getNews'))
+        .catch((e) => errorHandler(e, 'wordpressService::getNews'))
+
+      wordpressService.getNewshub(true)
+        .then(() => successHandler('wordpressService::getNewshub'))
+        .catch((e) => errorHandler(e, 'wordpressService::getNewshub'))
+
+      wordpressService.getContentCreators(true)
+        .then(() => successHandler('wordpressService::getContentCreators'))
+        .catch((e) => errorHandler(e, 'wordpressService::getContentCreators'))
+
+      wordpressService.getTournamentNews(true)
+        .then(() => successHandler('wordpressService::getTournamentNews'))
+        .catch((e) => errorHandler(e, 'wordpressService::getTournamentNews'))
+
+      wordpressService.getFafTeams(true)
+        .then(() => successHandler('wordpressService::getFafTeams'))
+        .catch((e) => errorHandler(e, 'wordpressService::getFafTeams'))
+    } catch (e) {
+        console.error('Error: cron-jobs::warmupWordpressCache failed with "' + e.toString() + '"', {entrypoint: 'cron-jobs.js'})
     }
+}
+
+const warmupLeaderboard = async () => {
+  try {
+    const leaderboardService = new LeaderboardService(cacheService, new LeaderboardRepository(await JavaApiM2MClient))
 
-    wordpressService.getNews(true).then(() => successHandler('getNews')).catch((e) => errorHandler(e, 'getNews'))
-    wordpressService.getNewshub(true).then(() => successHandler('getNewshub')).catch((e) => errorHandler(e, 'getNewshub'))
-    wordpressService.getContentCreators(true).then(() => successHandler('getContentCreators')).catch((e) => errorHandler(e, 'getContentCreators'))
-    wordpressService.getTournamentNews(true).then(() => successHandler('getTournamentNews')).catch((e) => errorHandler(e, 'getTournamentNews'))
-    wordpressService.getFafTeams(true).then(() => successHandler('getFafTeams')).catch((e) => errorHandler(e, 'getFafTeams'))
+    await leaderboardService.getLeaderboard(1, true)
+      .then(() => successHandler('leaderboardService::getLeaderboard(global)'))
+      .catch((e) => errorHandler(e, 'leaderboardService::getLeaderboard(global)'))
+
+    await leaderboardService.getLeaderboard(2, true)
+      .then(() => successHandler('leaderboardService::getLeaderboard(1v1)'))
+      .catch((e) => errorHandler(e, 'leaderboardService::getLeaderboard(1v1)'))
+
+    await leaderboardService.getLeaderboard(3, true)
+      .then(() => successHandler('leaderboardService::getLeaderboard(2v2)'))
+      .catch((e) => errorHandler(e, 'leaderboardService::getLeaderboard(2v2)'))
+
+    await leaderboardService.getLeaderboard(4, true)
+      .then(() => successHandler('leaderboardService::getLeaderboard(4v4)'))
+      .catch((e) => errorHandler(e, 'leaderboardService::getLeaderboard(4v4)'))
+
+  } catch (e) {
+    console.error('Error: cron-jobs::warmupLeaderboard failed with "' + e.toString() + '"', {entrypoint: 'cron-jobs.js'})
+  }
 }
 
 module.exports = async () => {
-    await warmupWordpressCache()
+    warmupWordpressCache()
+    warmupLeaderboard().then(() => {})
 
     const wordpressScheduler = new Scheduler('createWordpressCaches', warmupWordpressCache, 60 * 59 * 1000)
-    wordpressScheduler.start()
+    wordpressScheduler.start()  
+
+
+    const leaderboardScheduler = new Scheduler('createLeaderboardCaches', warmupLeaderboard, 60 * 59 * 1000)
+    leaderboardScheduler.start()
 }

tests/integration/leaderboardRouter.test.js

@@ -13,19 +13,19 @@ beforeEach(() => {
 })
 
 describe('Leaderboard Routes', function () {
-    test('authentication required for main page', async () => {
+    test('no authentication required for main page', async () => {
         let response = await testSession.get('/leaderboards')
-        expect(response.status).toBe(302)
+        expect(response.status).toBe(200)
 
         await testSession.get('/mock-login')
 
         response = await testSession.get('/leaderboards')
         expect(response.status).toBe(200)
     })
 
-    test('authentication required for datasets', async () => {
+    test('no authentication required for datasets', async () => {
         const response = await testSession.get('/leaderboards/1v1.json')
-        expect(response.status).toBe(401)
+        expect(response.status).toBe(200)
     })
 
     test('fails with 404 on unknown leaderboard', async () => {

tests/integration/servicesMiddleware.test.js

@@ -20,12 +20,14 @@ beforeEach(() => {
 
 describe('Services Middleware', function () {
     test('public service are loaded without a user', (done) => {
-        expect.assertions(3)
+        expect.assertions(5)
         testApp.get('/', (req, res) => {
             try {
                 expect(req.services).not.toBeUndefined()
-                expect(Object.keys(req.services).length).toBe(1)
+                expect(Object.keys(req.services).length).toBe(3)
+                expect(req.services.javaApiM2MClient).toBeInstanceOf(Axios)
                 expect(req.services.wordpressService).toBeInstanceOf(WordpressService)
+                expect(req.services.leaderboardService).toBeInstanceOf(LeaderboardService)
 
                 return res.send('success')
             } catch (e) {
@@ -37,14 +39,15 @@ describe('Services Middleware', function () {
     })
 
     test('additional services are loaded with authenticated user', (done) => {
-        expect.assertions(6)
+        expect.assertions(7)
         testApp.get('/', (req, res) => {
             try {
                 expect(req.services).not.toBeUndefined()
-                expect(Object.keys(req.services).length).toBe(4)
+                expect(Object.keys(req.services).length).toBe(5)
                 expect(req.services.wordpressService).toBeInstanceOf(WordpressService)
                 expect(req.services.userService).toBeInstanceOf(UserService)
                 expect(req.services.javaApiClient).toBeInstanceOf(Axios)
+                expect(req.services.javaApiM2MClient).toBeInstanceOf(Axios)
                 expect(req.services.leaderboardService).toBeInstanceOf(LeaderboardService)
 
                 return res.send('success')