time, status, error history, running sessions, sessions history, private page with key, added

src/controllers/session.js

@@ -33,6 +33,7 @@ const create_session = async (req, res, next) => {
     }
     
     var add_active_session_result = await database.add_active_session(session_server.url, session_id, websocket_url)
+    await database.add_session_to_history(session_server.url, session_id, websocket_url)
 
     if (!add_active_session_result) {
         next(new not_found_error('add_active_session error'))

src/controllers/status.js

@@ -0,0 +1,90 @@
+const request = require('request')
+const database = require('../database/database.js')
+const not_found_error = require('../../lib/src/http/errors/not_found_error')
+const {ping_session_server} = require('../modules/session_server.js')
+
+const max_response_timeout = 500
+
+const validate_url = async (domain) => {
+    var options = {
+        url: domain,
+        method: "GET",
+        path: '/',
+        timeout: max_response_timeout
+    }
+
+    return new Promise(function (resolve, reject) {
+        request(options,
+            async function(err, answer, data) {
+                if (err || !answer.socket) {
+                    resolve(false)
+                    return
+                } else if (answer.socket.authorized) {
+                    resolve(true)
+                } else {
+                    resolve(false)
+                }
+            }
+        )
+    })
+}
+
+const validate_all_urls = async (urls) => {
+    return Promise.all(urls.map(async (url) => {
+        const status = await validate_url(url)
+        return {url:url, status:status}
+    }))
+}
+
+const ping_all_session_servers = async (urls) => {
+    return Promise.all(urls.map(async (url) => {
+        const status = await ping_session_server(url)
+        return {url:url, status:status}
+    }))
+}
+
+
+
+const get_status = async (req, res, next) => {
+    let statuses = await database.get_statuses()
+    let urls = statuses[0].urls
+
+    let session_servers = await database.get_all_session_servers()
+
+    let session_servers_urls = []
+
+    session_servers.forEach(server => {
+        session_servers_urls.push(server.url)
+    })
+
+    urls = urls.concat(session_servers_urls)
+
+    // all ssl statuses
+    let ssl_statuses = await validate_all_urls(urls)
+
+    let session_server_statuses = await ping_all_session_servers(session_servers_urls)
+
+    let errors = await database.get_errors()
+
+    let active_sessions = await database.get_all_active_sessions()
+    if (active_sessions) {
+        active_sessions.forEach(function(part, index) {
+            this[index].websocket_url = ""
+            this[index].session_id = ""
+        }, active_sessions)
+    }
+
+    let sessions_history = await database.get_all_session_history()
+    if (sessions_history) {
+        sessions_history.forEach(function(part, index) {
+            this[index].websocket_url = ""
+            this[index].session_id = ""
+        }, sessions_history)
+    }
+    
+    res.json([{ssl_statuses:ssl_statuses}, {session_server_statuses:session_server_statuses}, {errors:errors}, {active_sessions:active_sessions}, {sessions_history:sessions_history}])
+}
+
+module.exports = {
+    get_status
+}

src/controllers/title.js

@@ -23,7 +23,20 @@ const get_titles_for_language = async (req, res, next) => {
     res.json(titles)
 }
 
+const get_private_title = async (req, res, next) => {
+    const {key} = req.query
+    var title = await database.get_private_title_with_key(key)
+
+    if (!title) {
+        next(new not_found_error('title not found'))
+        return
+    }
+
+    res.json(title)
+}
+
 module.exports = {
     get_titles,
-    get_titles_for_language
+    get_titles_for_language,
+    get_private_title
 }

src/database/database.js

@@ -1,6 +1,7 @@
 const { MongoClient } = require("mongodb")
 const { database_url, database_name } = require('../../config')
 const crypto = require("crypto")
+const time = require('../modules/time')
 let max_database_connection_timeout = 1000
 
 const client = new MongoClient(database_url, {
@@ -38,6 +39,15 @@ const get_titles_for_language = async (start, count, language) => {
     return (!titles.length) ? null : titles
 }
 
+const get_private_title_with_key = async (key) => {
+    var db = await get_db()
+    if (!db) {
+        return null
+    }
+    var titles = await db.collection('private_title').find({key:key}).toArray()
+    return (!titles.length) ? null : titles[0]
+}
+
 const get_free_session_servers = async (title) => {
     var db = await get_db()
     if (!db) {
@@ -122,6 +132,95 @@ const get_session_websocket_url = async (session_id) => {
     return session.websocket_url
 }
 
+const get_statuses = async () => {
+    var db = await get_db()
+    if (!db) {
+        return null
+    }
+    var statuses = await db.collection('status').find().toArray()
+    return (!statuses.length) ? null : statuses
+}
+
+const get_all_session_servers = async () => {
+    var db = await get_db()
+    if (!db) {
+        return null
+    }
+
+    var servers = await db.collection('session_server').find().toArray()
+
+    if (!servers.length) {
+        return null
+    }
+    return servers
+}
+
+const add_error = async (error_message) => {
+    var db = await get_db()
+    if (!db) {
+        return false
+    }
+
+    var error_collection = db.collection('error')
+
+    await error_collection.insertOne({error_message:error_message, time: time.get_date_time()})
+    return true
+}
+
+const get_errors = async () => {
+    var db = await get_db()
+    if (!db) {
+        return null
+    }
+    var errors = await db.collection('error').find().toArray()
+    return (!errors.length) ? null : errors
+}
+
+const get_all_active_sessions = async () => {
+    var db = await get_db()
+    if (!db) {
+        return null
+    }
+
+    var active_sessions = await db.collection('active_session').find().toArray()
+
+    if (!active_sessions.length) {
+        return null
+    }
+    return active_sessions
+}
+
+const add_session_to_history = async (server_url, session_id, websocket_url) => {
+    var db = await get_db()
+    if (!db) {
+        return false
+    }
+
+    var session_history = db.collection('session_history')
+
+    await session_history.insertOne({
+        server_url: server_url,
+        session_id: session_id,
+        websocket_url: websocket_url,
+        time: time.get_date_time()
+    })
+    return true
+}
+
+const get_all_session_history = async () => {
+    var db = await get_db()
+    if (!db) {
+        return null
+    }
+
+    var session_history = await db.collection('session_history').find().toArray()
+
+    if (!session_history.length) {
+        return null
+    }
+    return session_history
+}
+
 module.exports = {
     get_titles,
     get_free_session_servers,
@@ -129,5 +228,13 @@ module.exports = {
     generate_session_id,
     remove_active_session,
     get_session_websocket_url,
-    get_titles_for_language
+    get_titles_for_language,
+    get_private_title_with_key,
+    get_statuses,
+    get_all_session_servers,
+    add_error,
+    get_errors,
+    get_all_active_sessions,
+    add_session_to_history,
+    get_all_session_history
 }

src/middlewares/error_handler.js

@@ -1,10 +1,13 @@
 const server_error = require('../../lib/src/http/errors/server_error')
+const database = require('../database/database')
 
 const error_handler = (err, req, res, next) => {
     if (!err.status_code) {
         err = new server_error(err.message)
     }
     res.status(err.status_code).json({message:err.message})
+
+    database.add_error(err.message)
     next(err)
 }
 

src/modules/session_server.js

@@ -79,7 +79,29 @@ const run_session = async (server_url, session_id, title) => {
     })
 }
 
+const get_overal_status = async (url) => {
+
+    var options = {
+        url: url + '/get_overal_status',
+        method: "GET",
+        timeout: max_response_timeout
+    }
+
+    return new Promise(function (resolve, reject) {
+        request(options,
+            async function(err, answer, data) {
+                if (err || answer.statusCode != 200) {
+                    resolve(false)
+                } else {
+                    resolve(true)
+                }
+            }
+        )
+    })
+}
+
 module.exports = {
     get_fastest_session_server,
-    run_session
+    run_session,
+    ping_session_server
 }

src/modules/time.js

@@ -0,0 +1,14 @@
+const get_date_time = () => {
+    let currentdate = new Date(); 
+    let datetime = currentdate.getDate() + "/"
+                + (currentdate.getMonth()+1)  + "/" 
+                + currentdate.getFullYear() + " @ "  
+                + currentdate.getHours() + ":"  
+                + currentdate.getMinutes() + ":" 
+                + currentdate.getSeconds()
+    return datetime
+}
+
+module.exports = {
+    get_date_time
+}

src/routes/index.js

@@ -2,9 +2,11 @@ const router = require('express').Router()
 const router_title = require('./title')
 const router_session = require('./session')
 const router_session_server = require('./session_server')
+const router_status = require('./status')
 
 router.use('/title', router_title)
 router.use('/session', router_session)
 router.use('/session_server', router_session_server)
+router.use('/status', router_status)
 
 module.exports = router

src/routes/status.js

@@ -0,0 +1,6 @@
+const router = require('express').Router()
+const {get_status} = require('../controllers/status')
+
+router.get('/', get_status)
+
+module.exports = router

src/routes/title.js

@@ -1,6 +1,6 @@
 const router = require('express').Router()
 const { celebrate, Joi, Segments} = require('celebrate')
-const {get_titles, get_titles_for_language} = require('../controllers/title')
+const {get_titles, get_titles_for_language, get_private_title} = require('../controllers/title')
 
 router.get('/get', celebrate({
     [Segments.QUERY]: Joi.object().keys({
@@ -17,4 +17,10 @@ router.get('/get_for_language', celebrate({
     })
 }), get_titles_for_language)
 
+router.get('/get_private', celebrate({
+    [Segments.QUERY]: Joi.object().keys({
+        key: Joi.string().required()
+    })
+}), get_private_title)
+
 module.exports = router